@unoverse-platform/studio 0.1.97 → 0.1.99

package/vendor/sdk/lib/connection.tsx

@@ -40,6 +40,9 @@ export interface UnoverseSessionParams {
   conversationId: string;
   /** Groups one request→response turn. Defaults to conversationId if omitted. */
   chatId?: string;
+  /** The app this session shows (`<org>/<name>`). The server draws an app that declares places
+   *  from its screen document (docs/unoverse/design/screen/UNOVERSE_SCREEN.md). */
+  appId?: string;
 }
 
 export interface UnoverseConnection {
@@ -63,7 +66,7 @@ export interface UnoverseConnection {
   /** Answer a pending ELICITATION with the submitted component state (the native
    *  collection path — §3.3). Returns false when no elicitation is pending (the
    *  channel then falls back to `sendAction`). */
-  resolveElicitation: (state: Record<string, unknown>) => boolean;
+  resolveElicitation: (state: Record<string, unknown>, action?: "accept" | "cancel") => boolean;
   /** The workflow-selected template (MCP app) name, or null. The channel renders
    *  `unoverse://apps/{activeApp}/definition` when set — the official resources/read load. */
   activeApp: string | null;
@@ -83,7 +86,7 @@ const UNOVERSE_EVENT = "notifications/unoverse/event";
  * one visitor); a host with a token is untouched.
  */
 const GUEST_KEY = "unoverse:guestId";
-function resolveGuestId(): string {
+export function resolveGuestId(): string {
   let id: string | null = null;
   try {
     id = localStorage.getItem(GUEST_KEY);
@@ -101,19 +104,38 @@ function resolveGuestId(): string {
   return id;
 }
 
+/**
+ * THE ONE IDENTITY RULE for every lane the SDK opens: with a token the host's userId passes
+ * through; without one the platform sees a guest and requires a guest-prefixed id, so a
+ * host-supplied guest id wins and anything else is replaced by the stored guest id. The data
+ * plane and the audio lane both call this, so a page never speaks with two names.
+ */
+export function sessionUserId(userId: string | undefined, getAccessToken: unknown): string {
+  return getAccessToken || /^guest[-:]/.test(userId ?? "") ? (userId as string) : resolveGuestId();
+}
+
 export function useUnoverseConnection(
   config: UnoverseConnectionConfig,
   session: UnoverseSessionParams,
   store: ComponentStore,
-  options: { enabled?: boolean } = {},
+  options: { enabled?: boolean; onAppSwitch?: (app: string) => void } = {},
 ): UnoverseConnection {
   const enabled = options.enabled ?? true;
+  // Read through a ref so a host's inline arrow does not tear down the stream on
+  // every render — the connection effect must not depend on the callback's identity.
+  const onAppSwitchRef = useRef(options.onAppSwitch);
+  onAppSwitchRef.current = options.onAppSwitch;
+  const onAppSwitch = (app: string) => onAppSwitchRef.current?.(app);
+  // Read through a ref too: the server follows app switches itself, so a new app must not
+  // tear the stream down; the next registration simply names it.
+  const appIdRef = useRef(session.appId);
+  appIdRef.current = session.appId;
   const { streamUrl, getAccessToken } = config;
   const { workflowId, targetTriggerNode, conversationId } = session;
   // No token ⇒ the platform sees a GUEST session and requires a guest-prefixed id —
   // supply one automatically (host-supplied guest ids win; with a token the host's
   // real userId passes through untouched). This is the whole guest story for a host.
-  const userId = getAccessToken || /^guest[-:]/.test(session.userId ?? "") ? session.userId : resolveGuestId();
+  const userId = sessionUserId(session.userId, getAccessToken);
   const chatId = session.chatId ?? conversationId;
 
   const [isConnected, setIsConnected] = useState(false);
@@ -125,7 +147,7 @@ export function useUnoverseConnection(
   // The pending elicitation's resolver (one at a time per session) — set while the
   // server is asking this session for structured input; the channel's submit branch
   // answers it via `resolveElicitation`.
-  const pendingElicitRef = useRef<((state: Record<string, unknown>) => void) | null>(null);
+  const pendingElicitRef = useRef<((state: Record<string, unknown>, action: "accept" | "cancel") => void) | null>(null);
 
   // ---- connection lifecycle (MCP stream) ----
   useEffect(() => {
@@ -187,8 +209,9 @@ export function useUnoverseConnection(
         const requested =
           (req.params as unknown as { requestedSchema?: { properties?: Record<string, unknown> } }).requestedSchema?.properties ?? {};
         return await new Promise((resolve) => {
-          pendingElicitRef.current = (state: Record<string, unknown>) => {
+          pendingElicitRef.current = (state: Record<string, unknown>, action: "accept" | "cancel") => {
             pendingElicitRef.current = null;
+            if (action === "cancel") return resolve({ action: "cancel" } as never);
             const content: Record<string, unknown> = {};
             for (const k of Object.keys(requested)) if (state[k] !== undefined) content[k] = state[k];
             resolve({ action: "accept", content } as never);
@@ -234,6 +257,16 @@ export function useUnoverseConnection(
           if (typeof evt.event === "string" && evt.event) emitAnalytics(evt.event, evt.params ?? {});
           return;
         }
+        // AN APP SWAP IS THE HOST'S CALL, not the renderer's. Handed straight out, like
+        // ANALYTICS_EVENT above and for the same reason: it does not touch the store —
+        // the conversation and everything already on screen survive a swap, which is the
+        // whole point of swapping rather than starting again. The host re-points its one
+        // engine (appEngine.tsx); a host that ignores this simply stays where it is.
+        if (evt.type === "APP_SWITCH") {
+          const next = (msg as unknown as { app?: unknown }).app;
+          if (typeof next === "string" && next) onAppSwitch?.(next);
+          return;
+        }
         applyServerMessage(store, msg, seenRef.current);
       };
 
@@ -264,7 +297,7 @@ export function useUnoverseConnection(
         // stream and an immediate SESSION_READY.
         const bind = await client.callTool({
           name: "register_session",
-          arguments: { userId, conversationId, workflowId, targetTriggerNode, chatId },
+          arguments: { userId, conversationId, workflowId, targetTriggerNode, chatId, ...(appIdRef.current ? { appId: appIdRef.current } : {}) },
         });
         // A refusal (public-entry gate, requires.role, …) is an isError tool RESULT,
         // not a thrown error — surface it and STOP, never retry: the server has
@@ -344,60 +377,17 @@ export function useUnoverseConnection(
     (text: string) => {
       const message = text.trim();
       if (!message) return;
-      /**
-       * THE LATCH RIDES THE ORDINARY SEND (docs/MCP_COMPLETE_GUIDE.md §The Component Latch).
-       *
-       * 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.
-       *
-       * 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;
-      /**
-       * THE RUN REUSES THE LATCHED TURN; the guest's message does not.
-       *
-       * 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 turn = mintTurn();
       store.addUserMessage(turn, message); // optimistic user turn
-      const run = held ? held.chatId : turn;
+      // The answer opens under the message that asked for it. What is on screen is the
+      // SERVER's fact (the standing set, the open pages); the send carries nothing about it.
+      const run = 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.
+      // (and the first COMPONENT_INIT) reuse this same turn (responseFor by chatId).
       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: viewOf(store.get(held.chatId, held.nodeId) as Record<string, unknown>) ?? "",
-                state: store.get(held.chatId, held.nodeId) ?? {},
-              },
-            }
-          : { message },
-        run,
-      );
+      trigger({ message }, run);
     },
     [mintTurn, store, trigger],
   );
@@ -421,10 +411,10 @@ export function useUnoverseConnection(
   );
 
   // Answer a pending elicitation with the submitted component state (native path).
-  const resolveElicitation = useCallback((state: Record<string, unknown>): boolean => {
+  const resolveElicitation = useCallback((state: Record<string, unknown>, action: "accept" | "cancel" = "accept"): boolean => {
     const pending = pendingElicitRef.current;
     if (!pending) return false;
-    pending(state);
+    pending(state, action);
     return true;
   }, []);
 

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

@@ -72,6 +72,12 @@ export function dispatchAction(
     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 (ctx.nodeId && "step" in patch) {
+      // A CONFIRMED STEP IS NEWS TOO (SIGNAL.md § 6b): a form's Continue writes the
+      // compiler's hidden step key (`STEP` in packages/base compile/component.ts; the
+      // author wrote `state`), so the face never changes and no view is entered. Reported
+      // as its own message: the server saves the slice and runs no face lifecycle.
+      ctx.sendToServer?.("stepEntered", { step: patch.step });
     }
   } else if (spec.type === "setAppValue") {
     // Write the dev's chosen keys into TEMPLATE state — the template-state twin of setValue.

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

@@ -48,6 +48,24 @@ export function orderedClaims(def: UnoverseDefinition | null | undefined): strin
  *  it can never emit invalid CSS (or an invalid native constraint). */
 export const cssWidth = (w: unknown): string | undefined => (typeof w === "string" && /\d/.test(w) ? w : undefined);
 
+/**
+ * THE ONE WIDTH LAW FOR A PLACE (docs/design/apps, Width). A panel, a slot frame or a
+ * mounted template declares `appWidth` once. A NAMED size resolves via theme.appSize and
+ * raw CSS passes through: the place is that width, always (`flex: 0 0 auto`). `flex` is
+ * the SDK's own word, never a token: "fill the space remaining beside whatever core is
+ * open" (`flex: 1 1 0%`). Anything else declares nothing and the place's own style decides.
+ *
+ * ONE function for every caller, because the slot frame once had its own copy without the
+ * `flex` word: beside a full-width app it rendered the task surface in a zero-width frame
+ * the moment the org's `flex` token went (SAB's comparison, blank, 2026-09-07).
+ */
+export function placeWidthStyle(declared: unknown, appSize?: Record<string, string>): Record<string, unknown> | null {
+  const width = cssWidth(typeof declared === "string" ? (appSize?.[declared] ?? declared) : undefined);
+  if (width) return { width, flex: "0 0 auto" };
+  if (declared === "flex") return { flex: "1 1 0%", minWidth: 0 };
+  return null;
+}
+
 /** The author's declared prop defaults (def.props[k].default) → a flat data object. Content, not policy. */
 export function propDefaults(props?: Record<string, unknown>): Record<string, unknown> {
   const out: Record<string, unknown> = {};
@@ -142,6 +160,16 @@ export function computeAppWidth(root: unknown, store: ComponentStore, appSize?:
       if (piece) walk(piece);
       return;
     }
+    // A PLACE HOLDING SOMETHING sizes the app like an open panel (UNOVERSE_SCREEN.md §2.2).
+    if (n.type === "Place") {
+      const name = (n as { name?: unknown }).name;
+      if (typeof name === "string" && store.placeItems(name).length) {
+        const w = rw(n.appWidth);
+        if (w) widths.push(w);
+        else if (n.appWidth === "flex") flexOpen = true;
+      }
+      return;
+    }
     if (n !== r) {
       if (n.type === "ComponentSlot") {
         const claim = n.select?.where;
@@ -195,6 +223,22 @@ export function resolveActiveLayout(def: UnoverseDefinition | null | undefined,
   return layouts[view] ?? layouts[def.defaultLayout ?? "main"] ?? def.root;
 }
 
+/**
+ * MOUNT CLAIMS AS ALIASES: a state that mounts a template claims the template's own states
+ * (loader-stamped `claims`, UNOVERSE_TEMPLATE_MODEL §12). A face in a claimed state IS a
+ * face in the mount state — `grid` under `page` is `page` — for the ladder walk and for
+ * rule 4's cancellation alike (the two read faces the same way, or a card wearing `grid`
+ * survives a higher state that should have cleared it; observed live 2026-09-06).
+ */
+export function mountAliases(def: UnoverseDefinition | null | undefined, valid: Set<string>): Map<string, string> {
+  const aliasOf = new Map<string, string>();
+  for (const [sname, entry] of Object.entries((def?.templates ?? {}) as Record<string, { template?: string; claims?: string[] }>)) {
+    if (!entry?.template || !valid.has(sname)) continue;
+    for (const c of entry.claims ?? []) aliasOf.set(c, sname);
+  }
+  return aliasOf;
+}
+
 /**
  * THE TEMPLATE'S ACTIVE STATE — the ONE derivation every consumer shares.
  *
@@ -222,11 +266,7 @@ export function resolveActiveView(
   // `claims`, UNOVERSE_TEMPLATE_MODEL §12): an instance arriving in any of them is a
   // match FOR THE MOUNT STATE — "the grid holds cards" is what enters `courses`, and
   // the empty grid is what releases it. Same walk, one more spelling of a match.
-  const aliasOf = new Map<string, string>();
-  for (const [sname, entry] of Object.entries((def?.templates ?? {}) as Record<string, { template?: string; claims?: string[] }>)) {
-    if (!entry?.template || !valid.has(sname)) continue;
-    for (const c of entry.claims ?? []) aliasOf.set(c, sname);
-  }
+  const aliasOf = mountAliases(def, valid);
   // A mount-claim match counts only within THE CURRENT DELIVERY (hold: latest):
   // released instances must release the state too, or the app would sit in an
   // arrangement whose template just emptied.
@@ -266,81 +306,6 @@ export function resolveActiveView(
   return { view, byGuest };
 }
 
-/**
- * THE LATCH (docs/MCP_COMPLETE_GUIDE.md §The Component Latch) — which component the
- * 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. 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.
- *
- * THE HOLDER MUST BE THE STATE ON SCREEN, which is why `active` is a required argument
- * rather than something derived again here. Being ON the ladder is not enough: an app whose
- * ladder is [page, perfect-day] shows `page` the moment a card arrives wearing that face,
- * and the composed page — still live, still ranked, just not showing — went on holding the
- * latch. The guest then reads a pill naming a page that is nowhere on screen and types into
- * it (observed live 2026-08-31: three search cards took the surface and "Your Perfect Day"
- * stayed up over them). A pill is a promise about what the words will reach.
- *
- * SAME WALK AS `resolveActiveView` otherwise: the highest-ranked wins, ties going to the
- * most recent write. So a page retracted to `inline` (superseded by an arrival, released by
- * `cancelBelow`, closed by the guest) silently stops holding it too.
- *
- * Returns the FULL key. `chatId` alone reaches the turn, not the component inside it: a
- * turn carrying two components would hydrate the wrong one.
- */
-export function resolveLatch(
-  def: UnoverseDefinition | null | undefined,
-  store: ComponentStore,
-  /** The state the app is ACTUALLY showing (`resolveActiveView().view`). Empty = nothing is
-   *  surfaced, so nothing can be addressed. */
-  active: string,
-  dismissed?: string,
-): { 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
-  // WHAT IS ON SCREEN, first: an addressable state that is not the active one is not being
-  // shown, and a pill over someone else's surface points at nothing the guest can see.
-  if (!active || !latches[active]) return null;
-  // `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: { title: string; icon?: string }; view: string; rank: number; at: number }
-    | null = null;
-  for (const turn of store.getResponses())
-    for (const p of turn.components) {
-      // THE ✕ IS THE ONLY EXIT, and this is it: the guest dismissed THIS holder by key, so
-      // it is passed over and the walk continues to the next candidate. Keyed rather than a
-      // bare flag so the dismissal cannot outlive the thing dismissed — a different
-      // component taking the latch is a different key and is not affected.
-      if (dismissed && dismissed === p) continue;
-      const { chatId, nodeId } = store.split(p);
-      const slice = store.get(chatId, nodeId) as Record<string, unknown>;
-      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, and it must be the state SHOWING. 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 that is not the active one is
-      // not on screen to be addressed.
-      if (view !== active) continue;
-      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, view, rank, at };
-    }
-  return best ? { key: best.key, chatId: best.chatId, nodeId: best.nodeId, latch: best.latch, view: best.view } : null;
-}
 
 /** Resolve a ComponentSlot's `select` against the store → ordered pointers. */
 export function selectPointers(store: ComponentStore, node: UnoverseNode, scope?: Set<string>): string[] {
@@ -390,8 +355,28 @@ export function selectPointers(store: ComponentStore, node: UnoverseNode, scope?
       if (Array.isArray(within)) return within.includes(v);
       return ne !== undefined ? v !== ne : v === eq;
     });
-    pointers = [...pointers].sort((a, b) => store.touchOf(b) - store.touchOf(a));
   }
+  // THE MOST RECENT WINS (the `limit: 1` law) for EVERY capped select, not only a state
+  // select. A slot pinned to a component by `type` with `limit: 1` kept the OLDEST card:
+  // the sort lived inside the `where` branch, so a name-pinned cap sliced arrival order
+  // (SAB voice, two Account Agent cards, 2026-09-10). A cap means "the newest N"; an
+  // uncapped flow keeps arrival order.
+  if (sel.where || sel.limit != null) pointers = [...pointers].sort((a, b) => store.touchOf(b) - store.touchOf(a));
   if (sel.limit != null) pointers = pointers.slice(0, sel.limit);
   return pointers;
 }
+
+/**
+ * THE HASH NAMES THE STATE (owner ruling 2026-09-09: "make this the standard way to change
+ * states in an app, component or layout"). `unoverse://components/acme/deal#page` is the
+ * deal, opened on its page, the way a URL's hash means "this, opened here". Every reader
+ * splits the address here: the part before the hash is what the server resolves, the part
+ * after is the public `state` the thing opens in. No hash, and the definition's declared
+ * initial state stands.
+ */
+export function stateOfUri(address: string): { uri: string; state?: string } {
+  const i = address.indexOf("#");
+  if (i < 0) return { uri: address };
+  const state = address.slice(i + 1);
+  return { uri: address.slice(0, i), ...(state ? { state } : {}) };
+}

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

@@ -11,6 +11,7 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 // ChatGPT's widget CSP. See connection.tsx for the full rationale.
 import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker";
 import type { UnoverseDefinition, ResolvedTheme } from "./types";
+import { stateOfUri } from "./apps";
 
 export interface UnoverseClientOptions {
   /**
@@ -128,21 +129,11 @@ export class UnoverseClient {
     return this.withSession(() => this.client.callTool({ name, arguments: args }));
   }
 
-  /**
-   * The cached definition for a URI, or null — SYNCHRONOUS, and it never fetches.
-   *
-   * For derivations that must answer INSIDE an event, where awaiting is not an option: the
-   * latch resolves on send (`sendMessage`), and a send cannot wait on a resources/read.
-   * Safe because the only caller asks about the template it is already rendering, which
-   * means `readDefinition` resolved before the first frame. Null is a legitimate answer
-   * (nothing rendered yet) and every caller must treat it as "no opinion", never as "no".
-   */
-  peekDefinition(uri: string): UnoverseDefinition | null {
-    return this.cache.get(uri) ?? null;
-  }
 
-  /** resources/read a definition by URI (e.g. unoverse://components/card). Cached. */
-  async readDefinition(uri: string): Promise<UnoverseDefinition> {
+  /** resources/read a definition by URI (e.g. unoverse://components/card). Cached. A hash on
+   *  the address names the state it opens in (`stateOfUri`) and is never sent to the server. */
+  async readDefinition(address: string): Promise<UnoverseDefinition> {
+    const { uri } = stateOfUri(address);
     const cached = this.cache.get(uri);
     if (cached) return cached;
     const pending = this.inflight.get(uri);

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

@@ -137,6 +137,19 @@ export function applyServerMessage(store: ComponentStore, msg: ServerMessage, se
       else if (m.state === "ERROR" || m.state === "WORKFLOW_ERROR") store.setLifecycle("error");
       return;
     }
+    case "COMPONENT_CLOSE": {
+      // A CLOSE, not a placement (RENDER_PIPELINE §3.3): the LLM chose content over an
+      // open task (screen_show), and the task closes exactly as the guest's own ✕ closes
+      // it — a guest-hand write to `inline`. A plain face write would be refused by the
+      // guest-hold shield when the guest had opened the task themselves (observed live
+      // 2026-09-07: closed on the server, still on screen).
+      // The state to wear rides the message when the sender names one (a step-aside on an app with
+      // places, docs/unoverse/design/screen/UNOVERSE_SCREEN.md §2.6); else the universal `inline`.
+      const m = msg as { chatId?: string; nodeId?: string; state?: unknown };
+      if (typeof m.chatId === "string" && typeof m.nodeId === "string")
+        store.mergeComponentState(m.chatId, m.nodeId, { state: typeof m.state === "string" && m.state ? m.state : "inline" });
+      return;
+    }
     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
@@ -162,6 +175,23 @@ export function applyServerMessage(store: ComponentStore, msg: ServerMessage, se
     }
     // 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 "SCREEN_PLACE": {
+      // THE SCREEN DOCUMENT (docs/unoverse/design/screen/UNOVERSE_SCREEN.md): one place's full contents,
+      // in order. The server decided where everything is; this only records it.
+      const m = msg as { place?: unknown; items?: unknown };
+      if (typeof m.place !== "string" || !Array.isArray(m.items)) return;
+      const pointers: string[] = [];
+      const states: Record<string, string> = {};
+      for (const x of m.items) {
+        const i = x as { chatId?: unknown; nodeId?: unknown; state?: unknown };
+        if (typeof i?.chatId !== "string" || typeof i?.nodeId !== "string") continue;
+        const p = `${i.chatId}:${i.nodeId}`;
+        pointers.push(p);
+        if (typeof i.state === "string" && i.state) states[p] = i.state;
+      }
+      store.setPlace(m.place, pointers, states);
+      return;
+    }
     case "APP_DATA": {
       // Generic write into TEMPLATE STATE (the template-state twin of COMPONENT_DATA). The
       // PRODUCER names the keys (the Suggestions node sends `{ faqs }`); the template picks

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

@@ -35,14 +35,14 @@ export { dispatchAction, resolveValue, type ActionContext } from "./actions";
 export {
   collectSurfacedViews,
   computeAppWidth,
-  cssWidth,
+  cssWidth, placeWidthStyle,
   formatRelative,
   isViewField,
+  mountAliases,
   orderedClaims,
   propDefaults,
   resolveActiveLayout,
   resolveActiveView,
-  resolveLatch,
   selectPointers,
   viewOf,
 } from "./apps";