@unoverse-platform/studio 0.1.85 → 0.1.87

package/vendor/sdk/lib/UnoverseComponent.tsx

@@ -14,8 +14,8 @@
  * definition, and `setValue` writes the same instance either way.
  */
 import { useCallback, useEffect, useMemo, useState, useSyncExternalStore, type CSSProperties } from "react";
-import { dispatchAction, type ComponentStore, type ResolvedTheme, type UnoverseClient, type UnoverseDefinition } from "./core";
-import { renderNode, keyframesCss, type ActionHandler } from "./render";
+import { dispatchAction, matches, type ComponentStore, type ResolvedTheme, type UnoverseClient, type UnoverseDefinition } from "./core";
+import { renderNode, keyframesCss, type ActionHandler, type SlotResolver } from "./render";
 import { useUnoverseTheme, ensureFontStylesheets } from "./theme";
 import { IsolatedRoot } from "./isolate";
 
@@ -192,7 +192,53 @@ export function UnoverseComponent({ client, uri, data, store, chatId, nodeId, ex
   const keyframes = <style>{keyframesCss(activeTheme)}</style>;
   // The shared pieces this definition NAMES travel beside it and are threaded through
   // every recursion, so a reference nested in a Switch branch or an Each item resolves too.
-  const tree = renderNode(def.root, merged, handleAction, activeTheme, undefined, undefined, def.defs);
+  // A DEFINITION THAT CARRIES SLOTS RESOLVES THEM — the rule the SDK already applies to
+  // an app tree, applied here too. Without it a rendered TEMPLATE drew its frame and every
+  // section resolved to null (render.tsx: `slot ? slot(node) : null`), so a page that
+  // STREAMED IN rather than being mounted by an app came out blank. Mounted templates were
+  // fine because `app.tsx` hands that path a resolver; instances never got one, and a
+  // definition rendering its own parts nowhere is a renderer bug, not a design decision.
+  //
+  // Generic and dumb, like the rest of it: the slot's claim picks instances out of the
+  // SAME store by the face they wear, in the order the store holds them. It knows nothing
+  // about templates, days or cards — only "which instances match this claim".
+  //
+  // TEMPLATES ONLY, and the boundary matters: an ordinary component may carry the
+  // conversation's FLOW slot (`select: {}` inside a chat's assistant turn), and that one
+  // belongs to the app's timeline, which scopes it to a single turn's unclaimed
+  // components. Resolving it here too rendered every instance in the store a second time
+  // — the composed page appeared in its surface AND in the chat beside it.
+  const resolveSlot: SlotResolver | undefined = store && (def as { sections?: unknown }).sections
+    ? (node, key) => {
+        const claim = node.select?.where;
+        const pointers = store
+          .getResponses()
+          .flatMap((r) => r.components)
+          .filter((p) => {
+            const { chatId: c, nodeId: n } = store.split(p);
+            if (n === nodeId) return false; // never claim the instance drawing the slot
+            return claim ? matches(claim, (store.get(c, n) ?? {}) as Record<string, unknown>) : true;
+          })
+          .slice(0, node.select?.limit ?? undefined);
+        if (!pointers.length)
+          return node.fallback ? renderNode(node.fallback, {}, handleAction, activeTheme, key ?? "fb", undefined, def.defs) : null;
+        return pointers.map((p) => {
+          const { chatId: c, nodeId: n } = store.split(p);
+          return (
+            <UnoverseComponent
+              key={n}
+              client={client}
+              store={store}
+              chatId={c}
+              nodeId={n}
+              onAction={onAction}
+              theme={activeTheme}
+            />
+          );
+        });
+      }
+    : undefined;
+  const tree = renderNode(def.root, merged, handleAction, activeTheme, undefined, resolveSlot, def.defs);
   // The isolation container MIRRORS the component root's declared sizing intent (§4a:
   // the component owns its size; the host responds). A root that declares
   // `height: "full"` needs a definite chain — the container passes the host's height

package/vendor/sdk/lib/app.tsx

@@ -39,6 +39,8 @@ import { renderNode, styleToCss, keyframesCss, type ActionHandler, type SlotReso
 // existing consumers keep their import path.
 export { collectSurfacedViews, computeAppWidth, orderedClaims, resolveActiveLayout, resolveActiveView, selectPointers, viewOf } from "./core";
 import { UnoverseComponent } from "./UnoverseComponent";
+import { MountArrangement } from "./transition/index";
+import { guestHeldPointers } from "./transition/guestHold";
 
 /**
  * FLIP wrapper for a multi-occupant slot: when arrivals reorder the list (a refreshed
@@ -217,6 +219,29 @@ export function StreamedUnoverseApp({ client, store, uri, onAction, theme: theme
     };
   }, [client, uri]);
 
+  // A PAGE THAT STREAMED IN is on screen exactly like a mounted one, and claims exactly
+  // as much — but the app never named it, so nothing has fetched its definition. Its
+  // ADDRESS says what it is (`unoverse://templates/…`, §9c), which is all the SDK needs
+  // to learn what it claims. Fetched once per instance, into the same map the mounts use.
+  useEffect(() => {
+    let alive = true;
+    for (const p of store.getResponses().flatMap((r) => r.components)) {
+      const { chatId: c, nodeId: n } = store.split(p);
+      const url = store.getComponentUrl(c, n);
+      if (!url || !url.includes("://templates/")) continue;
+      const key = url.replace(/^unoverse:\/\/templates\//, "");
+      if (mounted[key]) continue;
+      client
+        .readDefinition(url)
+        .then((t) => alive && t && setMounted((m) => (m[key] ? m : { ...m, [key]: t })))
+        .catch((e) => console.warn(`[unoverse] streamed template "${key}" failed to load:`, e));
+    }
+    return () => {
+      alive = false;
+    };
+  }, [client, store, structureVersion, mounted]);
+
+
   // ARRIVAL PLACEMENT (STATE_MODEL v2 §5 rule 3): nobody sends a state — the HOST
   // places the actor at spawn. For each arrived component whose slice has no view yet:
   //   1. the component's DECLARED INITIAL, if this template has a state for it (the
@@ -240,7 +265,7 @@ export function StreamedUnoverseApp({ client, store, uri, onAction, theme: theme
         if (!menu) continue;
         const initial = typeof slice.initialView === "string" ? slice.initialView : undefined;
         const face = initial && order.includes(initial) ? initial : order.find((s) => menu.includes(s));
-        if (face) store.apply({ type: "COMPONENT_DATA", chatId, nodeId, data: { view: face } });
+        if (face) store.apply({ type: "COMPONENT_DATA", chatId, nodeId, data: { state: face } });
       }
   }, [def, store, structureVersion]);
 
@@ -260,6 +285,14 @@ export function StreamedUnoverseApp({ client, store, uri, onAction, theme: theme
     // it holds must not also render in the flow — one instance, one placeholder.
     for (const tpl of Object.values(mounted)) {
       for (const name of Object.keys(tpl.layouts ?? {})) views.add(name);
+      // A TEMPLATE CLAIMS WHAT ITS SECTIONS CLAIM, not just its state names. A grid-page
+      // holds its content in its own states, so the names were enough; a rich page holds
+      // its content in PARTS — a written hero, a section head, the band's cards — and
+      // each wears the section's face. Without these the parts are unclaimed at app
+      // level, so the SDK draws the page in its surface AND every piece of it again in
+      // the conversation flow (observed live 2026-08-30: the whole page, twice).
+      for (const secs of Object.values((tpl as { sections?: Record<string, { face?: string }[]> }).sections ?? {}))
+        for (const sec of secs) if (sec?.face) views.add(sec.face);
     }
     return views;
   }, [activeRoot, def, mounted]);
@@ -419,38 +452,95 @@ export function StreamedUnoverseApp({ client, store, uri, onAction, theme: theme
       // nothing collapses.
       if (spec?.template) {
         const tpl = mounted[spec.template];
-        const active = tpl ? resolveActiveLayout(tpl, store) : undefined;
+        if (!tpl) return null;
         // HOLD: LATEST (basic form, UNOVERSE_TEMPLATE_MODEL §9b): the mount holds
-        // only the CURRENT delivery — the guest's send clears the set.
+        // only the CURRENT delivery — spent by the settle or the clear, never the
+        // guest's send. A judged DIRECTOR_VERDICT narrows it further (§7); no
+        // verdict, or a verdict holding nothing that survives, falls back to the
+        // whole delivery.
+        const active = resolveActiveLayout(tpl, store);
         const delivery = store.currentDeliveryPointers();
-        const held = active ? collectSlotPointers(active, store, delivery) : [];
-        if (!tpl) return null;
-        if (!active) return null;
-        if (!held.length) return null;
-        const tree = renderNode(active, store.getAppState() as Record<string, unknown>, dispatch, theme, `${String(key ?? cname)}-tpl`, makeResolveSlot(delivery), tpl.defs);
-        // A PLACE DECLARES ITS WIDTH ONCE (docs/design/05), same law as a slot
-        // panel: `appWidth` resolves via theme.appSize and sizes the frame box —
-        // `flex` is the served "all remaining space" name. Without it the frame's
-        // own styles decide (and a width-less frame beside a fixed-width chat
-        // collapsed to its padding — observed live 2026-08-28).
-        const declaredW = (node as { appWidth?: string }).appWidth;
-        const placeW = cssWidth(typeof declaredW === "string" ? (theme.appSize?.[declaredW] ?? declaredW) : undefined);
-        // THEME-FREE FALLBACK (same law as computeAppWidth's marker): a theme without
-        // an `appSize.flex` token must still mean "fill the remaining host space" —
-        // an unresolved name collapsed the place to its padding (observed live
-        // 2026-08-28, the light theme's missing `flex`).
-        const flexFallback = !placeW && declaredW === "flex";
-        const rawFrame = (node as { frame?: UnoverseNode }).frame;
-        if (rawFrame) {
-          const frame = placeW
-            ? ({ ...rawFrame, style: { ...(rawFrame.style ?? {}), width: placeW, flex: "0 0 auto" } } as UnoverseNode)
-            : flexFallback
-              ? ({ ...rawFrame, style: { ...(rawFrame.style ?? {}), flex: "1 1 0%", minWidth: 0 } } as UnoverseNode)
-              : rawFrame;
-          const innerSlot: SlotResolver = () => tree;
-          return renderNode(frame, store.getAppState() as Record<string, unknown>, dispatch, theme, `${String(key ?? cname)}-frame`, innerSlot, def?.defs);
-        }
-        return <div key={key} style={{ display: "flex", flexDirection: "column", minHeight: 0, ...(placeW ? { width: placeW, flex: "0 0 auto" } : flexFallback ? { flex: "1 1 0%", minWidth: 0 } : {}) }}>{tree}</div>;
+        const dirScope = store.directorScope(delivery);
+        const tplLayouts = (tpl as { layouts?: Record<string, UnoverseNode> }).layouts ?? {};
+        // THE GUEST'S HAND OUTRANKS THE SETTLE (§6b rule 3, state priority): an
+        // instance the guest holds open in a non-base face (Detail View) stays in
+        // the mount's scope through deliveries and settles — a new batch landing
+        // below must not unseat it. The hold releases when the guest writes the
+        // face back to the base (✕), and the CURRENT arrangement takes over.
+        const layoutNames = Object.keys(tplLayouts);
+        const baseLayout = (tpl as { defaultLayout?: string }).defaultLayout ?? layoutNames[0] ?? null;
+        const guestHeld = guestHeldPointers(
+          store.getResponses().flatMap((r) => r.components),
+          {
+            touchOf: (p) => store.touchOf(p),
+            interactionTouchOf: (p) => store.interactionTouchOf(p),
+            viewOf: (p) => {
+              const { chatId, nodeId } = store.split(p);
+              return viewOf(store.get(chatId, nodeId) as Record<string, unknown> | undefined);
+            },
+          },
+          layoutNames,
+          baseLayout,
+        );
+        const scope = guestHeld.length ? new Set([...(dirScope ?? delivery), ...guestHeld]) : (dirScope ?? delivery);
+        const held = active ? collectSlotPointers(active, store, scope) : [];
+        // THE TRANSITION MODEL (§13): the mount double-buffers — this render
+        // derives the NEXT arrangement; MountArrangement commits it only at a
+        // boundary (verdict change, guest layout change, un-directed mount), so
+        // a data ripple can never move the shelf, and EMPTY COLLAPSES only when
+        // an arrangement holding nothing is COMMITTED. Content inside held
+        // instances stays live: the closure reads slices at render time.
+        const nextArrangement = {
+          layoutName: active ? (Object.entries(tplLayouts).find(([, t]) => t === active)?.[0] ?? null) : null,
+          held,
+          verdictSig: dirScope ? [...dirScope].sort().join("|") : null,
+        };
+        const motion = ((theme as { motion?: { mount?: string } }).motion?.mount ?? "") === "transition";
+        return (
+          <MountArrangement
+            key={key ?? cname}
+            next={nextArrangement}
+            directed={
+              // THE ONE HOME (§9b clause 5): the grant is the template's own
+              // director SECTION, compiled into the served def's `sections`;
+              // the placement's `director:` block is the legacy fallback.
+              Object.values(((tpl as { sections?: Record<string, { kind?: string }[]> }).sections ?? {}))
+                .flat()
+                .some((s) => s?.kind === "director") || Boolean((spec as { director?: unknown }).director)
+            }
+            motion={motion}
+            render={(arr) => {
+              if (!arr.held.length) return null;
+              const arrActive = (arr.layoutName ? tplLayouts[arr.layoutName] : undefined) ?? active;
+              if (!arrActive) return null;
+              const arrScope = new Set(arr.held);
+              const tree = renderNode(arrActive, store.getAppState() as Record<string, unknown>, dispatch, theme, `${String(key ?? cname)}-tpl`, makeResolveSlot(arrScope), tpl.defs);
+              // A PLACE DECLARES ITS WIDTH ONCE (docs/design/05), same law as a slot
+              // panel: `appWidth` resolves via theme.appSize and sizes the frame box —
+              // `flex` is the served "all remaining space" name. Without it the frame's
+              // own styles decide (and a width-less frame beside a fixed-width chat
+              // collapsed to its padding — observed live 2026-08-28).
+              const declaredW = (node as { appWidth?: string }).appWidth;
+              const placeW = cssWidth(typeof declaredW === "string" ? (theme.appSize?.[declaredW] ?? declaredW) : undefined);
+              // THEME-FREE FALLBACK (same law as computeAppWidth's marker): a theme without
+              // an `appSize.flex` token must still mean "fill the remaining host space" —
+              // an unresolved name collapsed the place to its padding (observed live
+              // 2026-08-28, the light theme's missing `flex`).
+              const flexFallback = !placeW && declaredW === "flex";
+              const rawFrame = (node as { frame?: UnoverseNode }).frame;
+              if (rawFrame) {
+                const frame = placeW
+                  ? ({ ...rawFrame, style: { ...(rawFrame.style ?? {}), width: placeW, flex: "0 0 auto" } } as UnoverseNode)
+                  : flexFallback
+                    ? ({ ...rawFrame, style: { ...(rawFrame.style ?? {}), flex: "1 1 0%", minWidth: 0 } } as UnoverseNode)
+                    : rawFrame;
+                const innerSlot: SlotResolver = () => tree;
+                return renderNode(frame, store.getAppState() as Record<string, unknown>, dispatch, theme, `${String(key ?? cname)}-frame`, innerSlot, def?.defs);
+              }
+              return <div style={{ display: "flex", flexDirection: "column", minHeight: 0, ...(placeW ? { width: placeW, flex: "0 0 auto" } : flexFallback ? { flex: "1 1 0%", minWidth: 0 } : {}) }}>{tree}</div>;
+            }}
+          />
+        );
       }
       const stateNames = spec?.states ? Object.keys(spec.states) : [];
       const appState = store.getAppState() as Record<string, unknown>;

package/vendor/sdk/lib/connection.tsx

@@ -13,7 +13,7 @@
  */
 import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
 import { emitAnalytics } from "./core/analytics";
-import { applyServerMessage, resolveLatch, type ComponentStore, type ServerMessage } from "./core";
+import { applyServerMessage, viewOf, type ComponentStore, type ServerMessage } from "./core";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 // Interpreter-based JSON-schema validator (no `new Function`). The SDK's default Ajv
@@ -344,58 +344,59 @@ export function useUnoverseConnection(
     (text: string) => {
       const message = text.trim();
       if (!message) return;
-      const turn = mintTurn(); // ONE turn id shared by the user message, the assistant response, and the run
-      store.addUserMessage(turn, message); // optimistic user turn
-      // Optimistically open the assistant turn too, so the avatar + thinking dots
-      // appear IMMEDIATELY on send instead of waiting for the backend's
-      // WORKFLOW_STARTED. startResponse is idempotent — the later WORKFLOW_STARTED
-      // (and the first COMPONENT_INIT) reuse this same turn (responseFor by chatId).
-      store.startResponse(turn);
       /**
        * THE LATCH RIDES THE ORDINARY SEND (docs/MCP_COMPLETE_GUIDE.md §The Component Latch).
        *
-       * Resolved HERE rather than in a host, because both hosts call this one function and
+       * Handled HERE rather than in a host, because both hosts call this one function and
        * two hosts each deciding "what happens on send" is how the composer regression
-       * happened. The user turn is still minted normally — the guest said something and it
-       * belongs in the timeline; the latch only tells the workflow WHERE the answer lands.
+       * happened.
        *
-       * `state` is the component's live slice, so the workflow is told what the page
-       * currently holds without a round trip, and it stays right after local `setValue`
-       * writes the server never saw. Sent as one `latch` object so an unlatched send is
-       * byte-for-byte what it was before.
+       * READ, NOT RE-DERIVED. `app.tsx` runs `resolveLatch` every render and publishes
+       * `latched`/`latchKey` into app state for the composer's pill; this reads that same
+       * published fact. Deriving it again here is what left the send inert for two weeks:
+       * `resolveLatch` needs the app DEFINITION and this file holds a raw MCP `Client` with
+       * no definition cache, so the second derivation could never see `def.latches` and
+       * silently answered "not latched" on every send.
        */
+      const app = store.getAppState() as Record<string, unknown>;
+      const held =
+        app.latched === true && typeof app.latchKey === "string" && app.latchKey ? store.split(app.latchKey) : null;
       /**
-       * UNFINISHED, and deliberately shipped inert rather than guessed at.
-       *
-       * `peekDefinition` is the SYNCHRONOUS cached read the send path needs (a send cannot
-       * await a resources/read), and it lives on `UnoverseClient` — the wrapper holding the
-       * definition cache, constructed in appEngine.tsx. THIS file holds a raw MCP `Client`
-       * (line 137), which has no cache and no such method, so the lookup finds nothing here.
+       * THE RUN REUSES THE LATCHED TURN; the guest's message does not.
        *
-       * Optional-called through a narrow type so the shape is honest: null is already a
-       * legitimate answer meaning "no opinion", `resolveLatch` is not called for it, and an
-       * unlatched send is byte-for-byte what it was before. The day this ref carries the
-       * wrapper, latching starts working with no change here.
+       * The user turn is minted normally either way — the guest said something and it
+       * belongs in the timeline where they said it. What the latch changes is where the
+       * ANSWER opens: `startResponse` and the trigger both take the held component's own
+       * chatId, so every render in that run keys `chatId:nodeId` to what is already on
+       * screen, and a repeated COMPONENT_INIT on a seen key is already a props merge
+       * (applyServerMessage). Hydrate in place, by construction, with no new return path.
        */
-      const cache = clientRef.current as unknown as
-        | { peekDefinition?: (uri: string) => Parameters<typeof resolveLatch>[0] }
-        | null;
-      const tmpl = store.getActiveApp().name;
-      const def = tmpl ? (cache?.peekDefinition?.(`unoverse://apps/${tmpl}/definition`) ?? null) : null;
-      const held = def ? resolveLatch(def, store) : null;
+      const turn = mintTurn();
+      store.addUserMessage(turn, message); // optimistic user turn
+      const run = held ? held.chatId : turn;
+      // Optimistically open the assistant turn too, so the avatar + thinking dots
+      // appear IMMEDIATELY on send instead of waiting for the backend's
+      // WORKFLOW_STARTED. startResponse is idempotent — the later WORKFLOW_STARTED
+      // (and the first COMPONENT_INIT) reuse this same turn (responseFor by chatId), and
+      // while latched that turn is the page's own, which is exactly the point.
+      store.startResponse(run);
       trigger(
         held
           ? {
               message,
+              // `state` is the component's live slice, so the workflow is told what the page
+              // currently holds without a round trip, and it stays right after local
+              // `setValue` writes the server never saw. Sent as one `latch` object so an
+              // unlatched send is byte-for-byte what it was before.
               latch: {
                 chatId: held.chatId,
                 nodeId: held.nodeId,
-                view: held.view,
+                view: viewOf(store.get(held.chatId, held.nodeId) as Record<string, unknown>) ?? "",
                 state: store.get(held.chatId, held.nodeId) ?? {},
               },
             }
           : { message },
-        turn,
+        run,
       );
     },
     [mintTurn, store, trigger],

package/vendor/sdk/lib/core/actions.ts

@@ -69,8 +69,8 @@ export function dispatchAction(
     // on the channel path every other server action uses; the server decides whether
     // any hook cares. The payload carries both spellings during the migration (the
     // server's lifecycle scope historically read `layout`).
-    if (ctx.nodeId && ("view" in patch || "defaultState" in patch)) {
-      const entered = patch.view ?? patch.defaultState;
+    if (ctx.nodeId && ("state" in patch || "view" in patch || "defaultState" in patch)) {
+      const entered = patch.state ?? patch.view ?? patch.defaultState;
       ctx.sendToServer?.("viewEntered", { layout: entered, view: entered });
     }
   } else if (spec.type === "setAppValue") {

package/vendor/sdk/lib/core/apps.ts

@@ -15,17 +15,18 @@ import type { ComponentStore } from "./store";
 import type { UnoverseDefinition, UnoverseNode } from "./types";
 
 /**
- * THE PUBLIC AXIS (STATE_MODEL v2 §2): a component's public state lives in its slice
- * under `view`; `defaultState` is the read-compatible legacy alias during migration.
- * Every derivation reads through these two helpers so the alias lives in ONE place.
+ * THE PUBLIC AXIS: a component's public state lives in its slice under `state`
+ * (the word ruled 2026-08-29, finishing the v2 rename journey); `view` and
+ * `defaultState` are the read-compatible legacy aliases during migration.
+ * Every derivation reads through these two helpers so the aliases live in ONE place.
  */
 export const viewOf = (slice: Record<string, unknown> | null | undefined): string | undefined => {
-  const v = slice?.view ?? slice?.defaultState;
+  const v = slice?.state ?? slice?.view ?? slice?.defaultState;
   return typeof v === "string" ? v : undefined;
 };
 
-/** Is a `select.where` field the public axis? Accepts both spellings during migration. */
-export const isViewField = (f: unknown): boolean => f === "view" || f === "defaultState";
+/** Is a `select.where` field the public axis? Accepts every spelling during migration. */
+export const isViewField = (f: unknown): boolean => f === "state" || f === "view" || f === "defaultState";
 
 /**
  * THE TEMPLATE'S DECLARED ORDER (STATE_MODEL v2 §5 rule 5) — its priority ladder and
@@ -270,11 +271,13 @@ export function resolveActiveView(
  * conversation is currently ADDRESSED AT, or none.
  *
  * DERIVED, never stored, for the same reason `lifecycle` is (STATE_MODEL §3): nothing
- * registers a latch and nothing unregisters one. A component becomes latchable by carrying
- * `latch` on its slice (seeded from its manifest with the render); it stops holding the
- * latch when its slice evicts or leaves the surface. There is no set, no stack, and no
- * "latch this one too" — this function returns ONE holder or null, so two latches are not
- * a bug to prevent but a state that cannot be represented.
+ * registers a latch and nothing unregisters one. THE STATE IS WHAT IS LATCHABLE, not the
+ * component (moved off the manifest 2026-08-31): an instance holds the latch while it is
+ * wearing a state the app declared a `latch` on, and stops the moment it wears one that
+ * says nothing — retracted inline, superseded, evicted, all the same answer with no code.
+ * There is no set, no stack, and no "latch this one too" — this function returns ONE
+ * holder or null, so two latches are not a bug to prevent but a state that cannot be
+ * represented.
  *
  * SAME WALK AS `resolveActiveView`, deliberately: the ladder is the ladder. A latchable
  * slice must be sitting in one of the template's declared states to hold the latch, and
@@ -289,14 +292,16 @@ export function resolveLatch(
   def: UnoverseDefinition | null | undefined,
   store: ComponentStore,
   dismissed?: string,
-): { key: string; chatId: string; nodeId: string; latch: Record<string, unknown>; view: string } | null {
+): { key: string; chatId: string; nodeId: string; latch: { title: string; icon?: string }; view: string } | null {
   const order = def?.stateOrder?.length ? def.stateOrder : undefined;
   if (!order) return null; // no ladder, no ranking — abstain rather than guess a holder
+  const latches = def?.latches;
+  if (!latches || !Object.keys(latches).length) return null; // no state is addressable here
   // `key` is the component key this candidate came from, carried so the return can name the
   // FULL key (line 269) rather than re-deriving it from chatId, which reaches the turn and
   // not the component inside it.
   let best:
-    | { key: string; chatId: string; nodeId: string; latch: Record<string, unknown>; view: string; rank: number; at: number }
+    | { key: string; chatId: string; nodeId: string; latch: { title: string; icon?: string }; view: string; rank: number; at: number }
     | null = null;
   for (const turn of store.getResponses())
     for (const p of turn.components) {
@@ -307,15 +312,18 @@ export function resolveLatch(
       if (dismissed && dismissed === p) continue;
       const { chatId, nodeId } = store.split(p);
       const slice = store.get(chatId, nodeId) as Record<string, unknown>;
-      const latch = slice?.latch;
-      if (!latch || typeof latch !== "object") continue;
       const view = viewOf(slice);
       if (!view) continue;
       const rank = order.indexOf(view);
       if (rank < 0) continue; // not on the surface (inline/retracted): holds nothing
+      // THE STATE DECIDES. Same lookup for every instance, so nothing has to be told it is
+      // addressable and nothing has to be untold — the face it currently wears is the whole
+      // question, and a face with no `latch:` is simply not in this map.
+      const latch = latches[view];
+      if (!latch) continue;
       const at = store.touchOf(p);
       if (!best || rank < best.rank || (rank === best.rank && at > best.at))
-        best = { key: p, chatId, nodeId, latch: latch as Record<string, unknown>, view, rank, at };
+        best = { key: p, chatId, nodeId, latch, view, rank, at };
     }
   return best ? { key: best.key, chatId: best.chatId, nodeId: best.nodeId, latch: best.latch, view: best.view } : null;
 }
@@ -323,11 +331,16 @@ export function resolveLatch(
 /** Resolve a ComponentSlot's `select` against the store → ordered pointers. */
 export function selectPointers(store: ComponentStore, node: UnoverseNode, scope?: Set<string>): string[] {
   const sel = (node.select ?? {}) as { from?: string; type?: string; where?: { field?: string; eq?: unknown; ne?: unknown }; limit?: number };
+  // A SCOPED selection (the mount's hold: latest) spans ALL turns and the SCOPE is
+  // the boundary — never the latest assistant turn. The guest's send opens a new
+  // (empty) turn immediately, so latest-turn scoping emptied the mount at every
+  // send and refilled it as renders landed: the shelf flicker ruled out in
+  // UNOVERSE_TEMPLATE_MODEL §12e. The delivery scope is touch-based for exactly
+  // this reason (turn position says nothing about freshness).
   let pointers =
-    sel.from === "all"
+    sel.from === "all" || scope
       ? store.getResponses().flatMap((r) => r.components)
       : (store.latestResponse()?.components ?? []);
-  // A SCOPED selection (the mount's hold: latest) sees only the given pointers.
   if (scope) pointers = pointers.filter((p) => scope.has(p));
 
   // `where` — select by COMPONENT STATE (the reaction contract, STATE_MODEL §5b): any

package/vendor/sdk/lib/core/conditions.ts

@@ -10,9 +10,21 @@
  */
 import type { Condition, VisibleWhen, UnoverseNode } from "./types";
 
+/** THE PUBLIC AXIS ALIASES (`state` is the ruled word, 2026-08-29; `view` and
+ *  `defaultState` are the legacy spellings): a lookup on any axis word falls
+ *  through the aliases, so a layout authored in either era reads a slice keyed in
+ *  either era. Lives HERE so every "react to state" mechanism shares it. */
+const AXIS_WORDS = ["state", "view", "defaultState"] as const;
+function scopeValue(data: Record<string, unknown>, field: string): unknown {
+  const v = data[field];
+  if (v !== undefined || !(AXIS_WORDS as readonly string[]).includes(field)) return v;
+  for (const w of AXIS_WORDS) if (data[w] !== undefined) return data[w];
+  return undefined;
+}
+
 /** Does a `Condition` hold against the data scope? `eq`/`ne`/`in`, else a truthy test. */
 export function matches(cond: Condition, data: Record<string, unknown>): boolean {
-  const v = data[cond.field];
+  const v = scopeValue(data, cond.field);
   if ("eq" in cond) return v === cond.eq;
   if ("ne" in cond) return v !== cond.ne;
   if ("in" in cond) return Array.isArray(cond.in) && cond.in.includes(v);
@@ -24,7 +36,7 @@ export function matches(cond: Condition, data: Record<string, unknown>): boolean
  *  `Condition`. Returns whether the node should render. */
 export function visible(vw: VisibleWhen, data: Record<string, unknown>): boolean {
   if (typeof vw === "string") {
-    const v = data[vw];
+    const v = scopeValue(data, vw);
     return !(v == null || v === "" || v === false || (Array.isArray(v) && v.length === 0));
   }
   return matches(vw, data);
@@ -38,6 +50,6 @@ export function selectCase(
 ): UnoverseNode | undefined {
   const cases = node.cases;
   if (!cases) return undefined;
-  const key = node.on != null ? String(data[node.on] ?? "") : "";
+  const key = node.on != null ? String(scopeValue(data, node.on) ?? "") : "";
   return cases[key] ?? cases.default;
 }

package/vendor/sdk/lib/core/connection.ts

@@ -140,10 +140,26 @@ export function applyServerMessage(store: ComponentStore, msg: ServerMessage, se
     case "COMPONENTS_CLEAR": {
       // Rule 5's empty delivery (STATE_MODEL §5, amended 2026-08-26): a turn that ran
       // with cards enabled and surfaced none owns the screen — earlier-turn components
-      // in public states retract to inline. The sender decided WHEN; this only obeys.
+      // in public states retract to inline, and the delivery is SPENT (§12e: the
+      // confirmed-empty boundary — the mount collapses now, not at the guest's send).
+      // The sender decided WHEN; this only obeys.
+      store.spendDelivery();
       store.supersedeAll(typeof msg.chatId === "string" ? msg.chatId : undefined);
       return;
     }
+    case "DIRECTOR_VERDICT": {
+      // The director's judged hold for the delivery (UNOVERSE_TEMPLATE_MODEL §7):
+      // ids and order only, judged server-side at run completion. Each item names
+      // the chatId it was DELIVERED under (turn or conversation — the durable
+      // lane), so the pointer is exact. This only obeys — exactly the
+      // COMPONENTS_CLEAR contract, for the held-something verdict.
+      const raw = (msg as { items?: unknown }).items;
+      const items = Array.isArray(raw)
+        ? raw.filter((x): x is { chatId: string; nodeId: string } => !!x && typeof (x as { chatId?: unknown }).chatId === "string" && typeof (x as { nodeId?: unknown }).nodeId === "string")
+        : [];
+      if (items.length) store.applyDirectorVerdict(items);
+      return;
+    }
     // No AUDIO_STATE case: voice is a NATIVE SERVICE on the WS audio lane (useVoiceService),
     // NOT the structured MCP stream. Audio-state events never arrive here (UNOVERSE_SPEC §2e-1).
     case "APP_DATA": {