@unoverse-platform/studio 0.1.68 → 0.1.70

package/vendor/sdk/appEngine.tsx

@@ -13,7 +13,7 @@ import { postToEmbedHost } from "./mcpAppBridge";
 import {
   UnoverseClient,
   ComponentStore,
-  StreamedUnoverseTemplate,
+  StreamedUnoverseApp,
   useUnoverseConnection,
   useUnoverseTheme,
   computeAppWidth,
@@ -28,7 +28,7 @@ import {
 export interface AppConfig {
   serverUrl: string;
   apiUrl?: string;
-  templateId: string;
+  appId: string;
   getAccessToken?: () => Promise<string | null> | string | null;
   userId?: string;
   conversationId: string;
@@ -42,7 +42,7 @@ export interface AppConfig {
 }
 
 export function AppEngine(cfg: AppConfig) {
-  const { serverUrl, apiUrl, templateId, getAccessToken, userId, conversationId, surface, analyticsDebug } = cfg;
+  const { serverUrl, apiUrl, appId, getAccessToken, userId, conversationId, surface, analyticsDebug } = cfg;
 
   // ONE STORE PER CONVERSATION. The host may reuse this engine (the native-host
   // iframe posts new config on app switch), and a template swap keeps the store by
@@ -63,9 +63,9 @@ export function AppEngine(cfg: AppConfig) {
   // Setting state during render makes React re-render BEFORE the commit, so the
   // connection effect only ever sees either the old app intact or an empty binding —
   // never the cross-app hybrid.
-  const [boundFor, setBoundFor] = useState(templateId);
-  if (boundFor !== templateId) {
-    setBoundFor(templateId);
+  const [boundFor, setBoundFor] = useState(appId);
+  if (boundFor !== appId) {
+    setBoundFor(appId);
     setBinding({});
   }
   // STATE-OWNED WIDTH (design data): the layout root's `appWidth` = the core surface's
@@ -81,11 +81,11 @@ export function AppEngine(cfg: AppConfig) {
   const [def, setDef] = useState<UnoverseDefinition | null>(null);
   const lastWidthRef = useRef<string | undefined>(undefined);
   // Named app sizes resolve via the served theme (theme.appSize), like every token.
-  // The theme's name is the template's org. When templateId already carries it
+  // The theme's name is the template's org. When appId already carries it
   // ("org/name" — every production boot), start the theme read IMMEDIATELY, in
   // parallel with the template read; waiting for the definition just to learn an org
   // we were handed serialized two round trips for nothing. Bare ids (dev) still wait.
-  const orgFromId = templateId.includes("/") ? templateId.split("/")[0] : null;
+  const orgFromId = appId.includes("/") ? appId.split("/")[0] : null;
   const theme = useUnoverseTheme(
     client,
     orgFromId ? `${orgFromId}/light` : def ? (def.org ? `${def.org}/light` : "light") : null,
@@ -99,7 +99,7 @@ export function AppEngine(cfg: AppConfig) {
     // the previous app's trigger within the same commit.
     client
       .connect()
-      .then(() => (client as any).client.readResource({ uri: `unoverse://apps/${templateId.toLowerCase()}` }))
+      .then(() => (client as any).client.readResource({ uri: `unoverse://apps/${appId.toLowerCase()}` }))
       .then((res: any) => {
         const parsed = res?.contents?.[0]?.text ? JSON.parse(res.contents[0].text) : null;
         const m = parsed?.manifest ?? parsed ?? {};
@@ -113,7 +113,7 @@ export function AppEngine(cfg: AppConfig) {
     // definition too — same resource the renderer loads.
     client
       .connect()
-      .then(() => client.readDefinition(`unoverse://templates/${templateId}`))
+      .then(() => client.readDefinition(`unoverse://apps/${appId}/definition`))
       .then((d) => {
         if (alive) setDef(d ?? null);
       })
@@ -121,7 +121,7 @@ export function AppEngine(cfg: AppConfig) {
     return () => {
       alive = false;
     };
-  }, [client, templateId]);
+  }, [client, appId]);
 
   // Report the app's width UP to the embedding host (iframe boundary → the twin of the
   // inbound `unoverse:config` channel), re-reporting whenever a panel surface opens or
@@ -145,13 +145,13 @@ export function AppEngine(cfg: AppConfig) {
   useEffect(() => {
     // A NEW APP RE-ANNOUNCES ITS WIDTH, ALWAYS. The native host keeps ONE iframe for every
     // app (its srcdoc is keyed on the server, not the app — it just re-posts
-    // `unoverse:config` with a new templateId) and this engine is re-rendered in place, so
+    // `unoverse:config` with a new appId) and this engine is re-rendered in place, so
     // the change-guard below outlives the switch — while the host RESETS its frame to the
     // default on it (NativeAppHost/TemplatesView). Two apps of the same declared width is
     // the ordinary case (one org, one `chat` size), and the incoming app then reported
     // nothing: its frame sat at the host default (100%) while its core panel held its
     // declared width, leaving a dead band beside it (observed live 2026-08-13,
-    // bpp-voice-layout). Clearing the guard here makes the first report after an app
+    // bpp-voice). Clearing the guard here makes the first report after an app
     // switch unconditional; the guard still suppresses repeats within one app.
     lastWidthRef.current = undefined;
     const report = () => {
@@ -208,7 +208,7 @@ export function AppEngine(cfg: AppConfig) {
   }, [conn.isReady, conn.isConnected, conn.refusal, failure]);
 
   // VOICE (§2e-1): a `service: "voice"` app runs the native voice service — which now lives
-  // in the shared renderer (StreamedUnoverseTemplate), identical to Studio. The host only
+  // in the shared renderer (StreamedUnoverseApp), identical to Studio. The host only
   // supplies the connection identity it already holds; startCall/endCall/toggleMute are
   // answered inside the renderer, so this host wires NO voice buttons. Absent → inert.
   const voiceConfig = useMemo<UseVoiceServiceConfig | undefined>(
@@ -235,10 +235,10 @@ export function AppEngine(cfg: AppConfig) {
   );
 
   return (
-    <StreamedUnoverseTemplate
+    <StreamedUnoverseApp
       client={client}
       store={store}
-      uri={`unoverse://templates/${templateId}`}
+      uri={`unoverse://apps/${appId}/definition`}
       voice={voiceConfig}
       onAction={(action, data, meta) => {
         const t = typeof action === "string" ? action : (action as any)?.type;
@@ -270,10 +270,10 @@ export function AppEngine(cfg: AppConfig) {
                 // pre-rename alias) into template state NOW — e.g. a "focus" app pre-opens
                 // the focus surface, whose slot shows its fallback (skeleton) until the
                 // workflow streams the component in. Same template-state key the node's
-                // TEMPLATE_DATA emit writes; no new vocabulary. "template" apps ARE the
-                // surface — nothing to write.
+                // APP_DATA emit writes; no new vocabulary. An "app" app IS the surface
+                // — nothing to write.
                 const declared = parsed?.manifest?.defaultState ?? parsed?.manifest?.mode ?? parsed?.defaultState ?? parsed?.mode;
-                if (declared && declared !== "template") store.mergeTemplateState({ defaultState: declared });
+                if (declared && declared !== "app") store.mergeAppState({ defaultState: declared });
                 conn.trigger({ app, metadata: { targetTriggerNode: b.trigger } });
               })
               .catch((e: any) => console.error("[app] launch failed:", e));

package/vendor/sdk/lib/{template.tsx → app.tsx}

@@ -1,5 +1,5 @@
 /**
- * <StreamedUnoverseTemplate> — renders a TEMPLATE definition (the layout) and
+ * <StreamedUnoverseApp> — renders a TEMPLATE definition (the layout) and
  * fills its ComponentSlots from the store's timeline.
  *
  * A template owns nothing (UNOVERSE_SPEC.md §2e-0): it reads the shared state
@@ -34,7 +34,7 @@ import {
 } from "./core";
 import { renderNode, styleToCss, keyframesCss, type ActionHandler, type SlotResolver } from "./render";
 
-// The pure template derivations moved to core/templates.ts (the portable brain —
+// The pure template derivations moved to core/apps.ts (the portable brain —
 // framework-agnostic, guarded by sdk-core-portable.test.ts). Re-exported here so
 // existing consumers keep their import path.
 export { collectSurfacedViews, computeAppWidth, orderedClaims, resolveActiveLayout, resolveActiveView, selectPointers, viewOf } from "./core";
@@ -43,10 +43,10 @@ import { useUnoverseTheme, ensureFontStylesheets } from "./theme";
 import { IsolatedRoot } from "./isolate";
 import { useVoiceService, type UseVoiceServiceConfig } from "./voice";
 
-export interface StreamedUnoverseTemplateProps {
+export interface StreamedUnoverseAppProps {
   client: UnoverseClient;
   store: ComponentStore;
-  /** e.g. "unoverse://templates/KeyService" */
+  /** e.g. "unoverse://apps/acme/KeyService/definition" */
   uri: string;
   onAction?: ActionHandler;
   theme?: ResolvedTheme;
@@ -72,7 +72,7 @@ const INERT_VOICE: UseVoiceServiceConfig = {
   session: { userId: "", conversationId: "", workflowId: "", targetTriggerNode: "" },
 };
 
-export function StreamedUnoverseTemplate({ client, store, uri, onAction, theme: themeProp, props, isolate = true, voice: voiceConfig }: StreamedUnoverseTemplateProps) {
+export function StreamedUnoverseApp({ client, store, uri, onAction, theme: themeProp, props, isolate = true, voice: voiceConfig }: StreamedUnoverseAppProps) {
   const [def, setDef] = useState<UnoverseDefinition | null>(null);
   const [error, setError] = useState<string | null>(null);
   // The voice native service lives HERE (shared), not in each host. Called every render
@@ -189,14 +189,14 @@ export function StreamedUnoverseTemplate({ client, store, uri, onAction, theme:
    * dies with the thing dismissed: a different component taking the latch is a different
    * key, and its pill comes up as it should rather than being suppressed by a stale flag.
    */
-  const tstate = store.getTemplateState() as Record<string, unknown>;
+  const tstate = store.getAppState() as Record<string, unknown>;
   const dismissedRaw = tstate.latchDismissed;
   const held = def ? resolveLatch(def, store, typeof dismissedRaw === "string" ? dismissedRaw : undefined) : null;
   useEffect(() => {
     if (dismissedRaw === true) {
       // Resolve the bare flag against whoever holds it RIGHT NOW, then re-derive.
       const current = def ? resolveLatch(def, store) : null;
-      store.mergeTemplateState({ latchDismissed: current ? current.key : "" });
+      store.mergeAppState({ latchDismissed: current ? current.key : "" });
       return;
     }
     const l = held?.latch as { title?: unknown } | undefined;
@@ -208,7 +208,7 @@ export function StreamedUnoverseTemplate({ client, store, uri, onAction, theme:
     // its condition — which is why they are separate keys and not the condition itself.
     const latched = held != null;
     if (tstate.latched !== latched || tstate.latchTitle !== title || tstate.latchKey !== (held?.key ?? ""))
-      store.mergeTemplateState({ latched, latchTitle: title, latchKey: held?.key ?? "" });
+      store.mergeAppState({ latched, latchTitle: title, latchKey: held?.key ?? "" });
   }, [
     held?.key,
     held?.latch,
@@ -226,7 +226,7 @@ export function StreamedUnoverseTemplate({ client, store, uri, onAction, theme:
   if (!def || !theme) return <div>Loading {uri}…</div>;
 
   // ONE action interpreter for the whole tree: template chrome runs the same
-  // `dispatchAction` (core/actions.ts) every leaf runs — `setTemplateValue` writes
+  // `dispatchAction` (core/actions.ts) every leaf runs — `setAppValue` writes
   // template state, `then` chains, anything else routes to the channel. Template
   // chrome has NO component slice, so `setValue` here is an authoring error (it
   // belongs on the component); the empty ids make that write inert.
@@ -321,7 +321,7 @@ export function StreamedUnoverseTemplate({ client, store, uri, onAction, theme:
       const frame = appWidth
         ? ({ ...node.frame, style: { ...(node.frame.style ?? {}), width: appWidth, flex: "0 0 auto" } } as UnoverseNode)
         : node.frame;
-      return renderNode(frame, store.getTemplateState() as Record<string, unknown>, dispatch, theme, key ?? "frame", innerSlot, def?.defs);
+      return renderNode(frame, store.getAppState() as Record<string, unknown>, dispatch, theme, key ?? "frame", innerSlot, def?.defs);
     }
     return pointers.map((p) => leaf(p));
   };
@@ -404,7 +404,7 @@ export function StreamedUnoverseTemplate({ client, store, uri, onAction, theme:
     // The active template's OWN state — one generic bag of the DEV's chosen keys (draft,
     // openPanel, suggestions data, focusMode, voice call state, …). No per-feature
     // projections; the engine knows no key names (UNOVERSE_STATE_MODEL §2).
-    ...store.getTemplateState(),
+    ...store.getAppState(),
     // Conversation-derived facts — READ OFF the timeline / lifecycle, never stored.
     isEmpty,
     hasMessages: !isEmpty,

package/vendor/sdk/lib/connection.tsx

@@ -6,7 +6,7 @@
  * sending messages. Inbound `notifications/unoverse/event` messages feed the single
  * `ComponentStore` via the pure `applyServerMessage` mapper.
  *
- * Per UNOVERSE_MCP_TEMPLATE_PROTOCOL.md §5/§5a/§5b: the component stream rides MCP
+ * Per UNOVERSE_MCP_APP_PROTOCOL.md §5/§5a/§5b: the component stream rides MCP
  * (NOT the legacy `/ws/gravity` WS — that's reserved for live audio). The node
  * executes in the same Unoverse process that serves this stream, so there's no
  * gateway relay and no Redis in the component path.
@@ -65,8 +65,8 @@ export interface UnoverseConnection {
    *  channel then falls back to `sendAction`). */
   resolveElicitation: (state: Record<string, unknown>) => boolean;
   /** The workflow-selected template (MCP app) name, or null. The channel renders
-   *  `unoverse://templates/{activeTemplate}` when set — the official resources/read load. */
-  activeTemplate: string | null;
+   *  `unoverse://apps/{activeApp}/definition` when set — the official resources/read load. */
+  activeApp: string | null;
 }
 
 /** The data-plane endpoint on the Unoverse server (§5b). */
@@ -171,7 +171,7 @@ export function useUnoverseConnection(
     const connect = async () => {
       if (cancelled) return;
       // Declare the ELICITATION capability (form mode) — the native collection path
-      // (UNOVERSE_MCP_TEMPLATE_PROTOCOL §3.3): the server pauses inside an app tool
+      // (UNOVERSE_MCP_APP_PROTOCOL §3.3): the server pauses inside an app tool
       // call and asks THIS session for the user's structured input. The interactive
       // component already on screen IS the form; its `submit` answers the elicitation.
       const client = new Client(
@@ -317,7 +317,7 @@ export function useUnoverseConnection(
       const turn = turnId ?? mintTurn();
       (async () => {
         // NATIVE MCP: fire the run via a `tools/call` on the live /stream session — NOT
-        // the retired REST `/api/workflows/:id/execute` (UNOVERSE_MCP_TEMPLATE_PROTOCOL
+        // the retired REST `/api/workflows/:id/execute` (UNOVERSE_MCP_APP_PROTOCOL
         // §0.3). Fire-and-forget: the run's UI streams back over this same session; the
         // caller's token rides the connection (server reads it from extra.authInfo).
         const client = clientRef.current;
@@ -378,8 +378,8 @@ export function useUnoverseConnection(
       const cache = clientRef.current as unknown as
         | { peekDefinition?: (uri: string) => Parameters<typeof resolveLatch>[0] }
         | null;
-      const tmpl = store.getActiveTemplate().name;
-      const def = tmpl ? (cache?.peekDefinition?.(`unoverse://templates/${tmpl}`) ?? null) : null;
+      const tmpl = store.getActiveApp().name;
+      const def = tmpl ? (cache?.peekDefinition?.(`unoverse://apps/${tmpl}/definition`) ?? null) : null;
       const held = def ? resolveLatch(def, store) : null;
       trigger(
         held
@@ -412,9 +412,9 @@ export function useUnoverseConnection(
   // The workflow-selected template, reactively (a primitive snapshot so the store
   // subscription doesn't loop). The channel renders it via resources/read.
   // Stable subscribe fn — an inline arrow re-subscribes every render.
-  const activeTemplate = useSyncExternalStore(
+  const activeApp = useSyncExternalStore(
     useCallback((cb) => store.subscribe(cb), [store]),
-    useCallback(() => store.getActiveTemplate().name, [store]),
+    useCallback(() => store.getActiveApp().name, [store]),
   );
 
   // Answer a pending elicitation with the submitted component state (native path).
@@ -425,5 +425,5 @@ export function useUnoverseConnection(
     return true;
   }, []);
 
-  return { isConnected, isReady, refusal, sendMessage, trigger, sendAction, resolveElicitation, activeTemplate };
+  return { isConnected, isReady, refusal, sendMessage, trigger, sendAction, resolveElicitation, activeApp };
 }

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

@@ -73,14 +73,14 @@ export function dispatchAction(
       const entered = patch.view ?? patch.defaultState;
       ctx.sendToServer?.("viewEntered", { layout: entered, view: entered });
     }
-  } else if (spec.type === "setTemplateValue") {
+  } else if (spec.type === "setAppValue") {
     // Write the dev's chosen keys into TEMPLATE state — the template-state twin of setValue.
     // No component scope. The dev builds disclosure / focus / etc. from a key THEY name
     // (openPanel, focusMode, …) and reads it via `visibleWhen`. The SDK hardcodes NO UI
     // concept — only "write a key to component state" and "write a key to template state".
     const patch: Record<string, unknown> = {};
     for (const { key, value } of spec.values ?? []) patch[key] = resolveValue(value, scope);
-    ctx.store.mergeTemplateState(patch);
+    ctx.store.mergeAppState(patch);
   } else if (spec.type === "input") {
     // A controlled Input changed — write its bound field back into the state bag that
     // OWNS this tree (local two-way binding; every keystroke is local, never a server
@@ -92,7 +92,7 @@ export function dispatchAction(
     const field = typeof scope.field === "string" ? scope.field : undefined;
     if (field) {
       if (ctx.nodeId) ctx.store.apply({ type: "COMPONENT_DATA", chatId: ctx.chatId, nodeId: ctx.nodeId, data: { [field]: scope.text } });
-      else ctx.store.mergeTemplateState({ [field]: scope.text });
+      else ctx.store.mergeAppState({ [field]: scope.text });
     }
   } else {
     // SERVER — narrow the payload by `send` if given, else forward the whole scope.

package/vendor/sdk/lib/core/{templates.ts → apps.ts}

@@ -4,7 +4,7 @@
  * Everything a template "decides" is DERIVED here from the store, never stored:
  * the active layout (name-sync), the active view (with the pinned/guest-control
  * law), which pointers a reaction surface selects, which views are claimed, and
- * the app's declared width. `StreamedUnoverseTemplate` (the React binding) calls
+ * the app's declared width. `StreamedUnoverseApp` (the React binding) calls
  * these; a platform port (Flutter/Swift/Kotlin) re-implements its own binding and
  * calls the SAME derivations — this file IS the port list for the template tier.
  *

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

@@ -7,7 +7,7 @@
  * React hook (react/src/connection.tsx) own only socket lifecycle.
  *
  * The Unoverse MCP server is NOT involved here — it's the control plane
- * (definitions + theme). See UNOVERSE_MCP_TEMPLATE_PROTOCOL.md §5a.
+ * (definitions + theme). See UNOVERSE_MCP_APP_PROTOCOL.md §5a.
  */
 import type { ComponentStore } from "./store";
 
@@ -23,7 +23,7 @@ export interface ServerComponentInit {
   /** Marks a TEMPLATE directive (legacy emits a fake COMPONENT_INIT with nodeId
    *  `<name>_template`). Templates are SERVED apps, loaded via resources/read — never
    *  rendered as components — so we route these to the template plane, not the timeline. */
-  metadata?: { isTemplate?: boolean; [k: string]: unknown };
+  metadata?: { isApp?: boolean; [k: string]: unknown };
 }
 export interface ServerComponentData {
   type: "COMPONENT_DATA" | "OBJECT_DATA";
@@ -37,17 +37,19 @@ export interface ServerWorkflowState {
   chatId: string;
   workflowId?: string;
   workflowRunId?: string | null;
-  /** Template SELECTION rides here (SPEC §5b: `{ template, templateMode }`) — the
-   *  OFFICIAL signal for which MCP-app shell to load via resources/read. */
-  metadata?: { template?: string; templateMode?: string; [k: string]: unknown };
+  /** APP SELECTION rides here (SPEC §5b: `{ app, appMode }`) — the OFFICIAL signal for
+   *  which MCP-app shell to load via resources/read. Note this `app` is a bare app NAME.
+   *  A content ROW's `metadata.app` is a different bag entirely and holds a component URI;
+   *  the two never meet on one object. */
+  metadata?: { app?: string; appMode?: string; [k: string]: unknown };
 }
 export interface ServerSessionReady {
   type: "SESSION_READY";
 }
 /** Generic write into TEMPLATE STATE — the template-state twin of COMPONENT_DATA. The
  *  producer names the keys (e.g. the Suggestions node sends `{ faqs }`); core stays generic. */
-export interface ServerTemplateData {
-  type: "TEMPLATE_DATA";
+export interface ServerAppData {
+  type: "APP_DATA";
   data: Record<string, unknown>;
 }
 export type ServerMessage =
@@ -55,7 +57,7 @@ export type ServerMessage =
   | ServerComponentData
   | ServerWorkflowState
   | ServerSessionReady
-  | ServerTemplateData
+  | ServerAppData
   | { type: string; [k: string]: unknown }; // forward-compat: unknown types ignored
 
 // Track first-seen components per `chatId:nodeId` so a repeated COMPONENT_INIT
@@ -74,12 +76,12 @@ export function applyServerMessage(store: ComponentStore, msg: ServerMessage, se
       const m = msg as ServerComponentInit;
       if (!m.chatId || !m.nodeId) return;
       // TEMPLATE DIRECTIVE — a template is a SERVED MCP app (protocol §0.1), loaded via
-      // resources/read unoverse://templates/{name}; it is NEVER a streamed component. Record
+      // resources/read unoverse://apps/{org}/{name}/definition; it is NEVER a streamed component. Record
       // WHICH app to load (the channel reads it); do not place it in the component timeline
       // (that produced "Unknown Unoverse component: <Template>"). The legacy componentUrl
       // .js bundle is ignored — Unoverse loads the neutral definition, not a React bundle.
-      if (m.metadata?.isTemplate === true || m.nodeId.endsWith("_template")) {
-        if (m.component?.type) store.setActiveTemplate(m.component.type, m.component.props ?? {});
+      if (m.metadata?.isApp === true || m.nodeId.endsWith("_template")) {
+        if (m.component?.type) store.setActiveApp(m.component.type, m.component.props ?? {});
         return;
       }
       const key = `${m.chatId}:${m.nodeId}`;
@@ -105,9 +107,9 @@ export function applyServerMessage(store: ComponentStore, msg: ServerMessage, se
     case "WORKFLOW_STATE": {
       const m = msg as ServerWorkflowState;
       // OFFICIAL template selection (SPEC §5b): the workflow names the app shell in
-      // metadata.template; the channel loads it via resources/read. (templateMode
+      // metadata.app; the channel loads it via resources/read. (appMode
       // switch/stack/replace is future — default "switch".)
-      if (m.metadata?.template) store.setActiveTemplate(m.metadata.template);
+      if (m.metadata?.app) store.setActiveApp(m.metadata.app);
       // Open an EMPTY streaming turn so the timeline shows a thinking state BEFORE the
       // first component (legacy processWorkflowState.ts; aiContext treats these as
       // streaming). COMPONENT_INIT then reuses it. Without this, the assistant turn is
@@ -137,12 +139,12 @@ 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 "TEMPLATE_DATA": {
+    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
       // them up. Core knows NO key names — fully generic (UNOVERSE_STATE_MODEL §2/§8).
       const data = ((msg as { data?: Record<string, unknown> }).data ?? {}) as Record<string, unknown>;
-      store.mergeTemplateState(data);
+      store.mergeAppState(data);
       return;
     }
     default:

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

@@ -22,7 +22,7 @@ export {
   type ServerComponentData,
   type ServerWorkflowState,
   type ServerSessionReady,
-  type ServerTemplateData,
+  type ServerAppData,
 } from "./connection";
 
 // The action interpreter (§2e-3) — local `setValue` store write + server route.
@@ -45,7 +45,7 @@ export {
   resolveLatch,
   selectPointers,
   viewOf,
-} from "./templates";
+} from "./apps";
 
 // Experience analytics (UNOVERSE_ANALYTICS.md) — the SDK emits; the host decides where to.
 export {

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

@@ -11,10 +11,10 @@
  *                 turn holds POINTERS (the `chatId:nodeId` keys) into the data
  *                 plane — never copies. This is what templates read.
  *
- * Plus a generic TEMPLATE-STATE bag (`templateState`) + `lifecycle` (derived from the
+ * Plus a generic TEMPLATE-STATE bag (`appState`) + `lifecycle` (derived from the
  * conversation) + `draft` (the shared composer buffer). The SDK hardcodes NO UI concept —
  * disclosure/focus/etc. are keys the dev writes via the `setValue` (component) or
- * `setTemplateValue` (template) actions and reads via `visibleWhen`. (Voice is a native
+ * `setAppValue` (template) actions and reads via `visibleWhen`. (Voice is a native
  * SERVICE — WS audio lane, react package — whose call state a producer merges into
  * template state, per UNOVERSE_SPEC §2e-1. The store holds structured state only.)
  *
@@ -92,12 +92,12 @@ export class ComponentStore {
   private notifyScheduled = false;
   private seq = 0;
   // --- active template (the workflow-selected MCP app shell; §0.1) ---
-  private activeTemplateName: string | null = null;
-  private activeTemplateProps: Record<string, unknown> = {};
+  private activeAppName: string | null = null;
+  private activeAppProps: Record<string, unknown> = {};
   // --- template state: the active template's OWN generic bag (UNOVERSE_STATE_MODEL §2).
   //     draft / suggestions / openPanel / focusedId / voice call state all live here as
   //     plain keys — core knows NO key names. Replace/merge only (O(1), never append). ---
-  private templateState: Record<string, unknown> = {};
+  private appState: Record<string, unknown> = {};
   // --- history cap (UNOVERSE_STATE_MODEL §6a): hold at most N turns, oldest-out-first. ---
   private maxTurns: number;
 
@@ -130,35 +130,35 @@ export class ComponentStore {
 
   /** The current composer draft (a key in template state). */
   getDraft(): string {
-    return (this.templateState.draft as string) ?? "";
+    return (this.appState.draft as string) ?? "";
   }
   /** Set the composer draft (input onChange writes here; a send button reads it). */
   setDraft(text: string): void {
     if (this.getDraft() === text) return;
-    this.mergeTemplateState({ draft: text });
+    this.mergeAppState({ draft: text });
   }
 
   /** The workflow-selected template (MCP app shell) + its props, or null if the channel picks. */
-  getActiveTemplate(): { name: string | null; props: Record<string, unknown> } {
-    return { name: this.activeTemplateName, props: this.activeTemplateProps };
+  getActiveApp(): { name: string | null; props: Record<string, unknown> } {
+    return { name: this.activeAppName, props: this.activeAppProps };
   }
   /**
    * Switch the active template (a workflow "render this app" directive — a COMPONENT_INIT
-   * marked isTemplate). Templates are SERVED apps, never streamed components (protocol
+   * marked isApp). Templates are SERVED apps, never streamed components (protocol
    * §0.1); this records WHICH app the channel should load, never a timeline component.
    */
-  setActiveTemplate(name: string, props: Record<string, unknown> = {}): void {
-    if (this.activeTemplateName === name && JSON.stringify(this.activeTemplateProps) === JSON.stringify(props)) return;
+  setActiveApp(name: string, props: Record<string, unknown> = {}): void {
+    if (this.activeAppName === name && JSON.stringify(this.activeAppProps) === JSON.stringify(props)) return;
     // TEMPLATE SWAP = the hard refresh boundary: a NEW shell starts with every surface
     // retired — every instance (durable ones included) returns to inline; the new
     // template derives its base state. Conversation data stays untouched (turns +
     // slices persist; only the active VIEW resets) — swapping back re-presents nothing
     // until something surfaces again.
-    if (this.activeTemplateName !== null && this.activeTemplateName !== name) {
+    if (this.activeAppName !== null && this.activeAppName !== name) {
       for (const [key, slice] of this.data) this.retractSlice(key, slice);
     }
-    this.activeTemplateName = name;
-    this.activeTemplateProps = props;
+    this.activeAppName = name;
+    this.activeAppProps = props;
     this.bump();
   }
 
@@ -235,12 +235,12 @@ export class ComponentStore {
   }
 
   /** The active template's state bag (templates read this into their root scope). */
-  getTemplateState(): Readonly<Record<string, unknown>> {
-    return this.templateState;
+  getAppState(): Readonly<Record<string, unknown>> {
+    return this.appState;
   }
   /** Merge a patch into template state (replace/merge — never append, stays O(1)). */
-  mergeTemplateState(patch: Record<string, unknown>): void {
-    this.templateState = { ...this.templateState, ...patch };
+  mergeAppState(patch: Record<string, unknown>): void {
+    this.appState = { ...this.appState, ...patch };
     this.bump();
   }
 
@@ -249,15 +249,15 @@ export class ComponentStore {
   //  NO UI concept (no panel / focus / faq / voice). The dev picks the key and the home:
   //   • COMPONENT state — a component's own data + view state (tab / edit / wizard-step /
   //     displayState / …), keyed by its id, written via the `setValue` action (data plane).
-  //   • TEMPLATE state — the active template's own bag (`templateState`), written via the
-  //     `setTemplateValue` action (or `mergeTemplateState` from a producer). Just keys.
+  //   • TEMPLATE state — the active template's own bag (`appState`), written via the
+  //     `setAppValue` action (or `mergeAppState` from a producer). Just keys.
   //  `lifecycle` is the one thing that is NEITHER: it's READ OFF the conversation (the turn's
   //  streaming/complete status), so it stays a tiny derived machine here. `draft` is the one
   //  named convenience (the shared composer buffer the channel reads to send).
   //  (Voice is a NATIVE SERVICE — WS audio lane, react package — whose call state a producer
   //   merges into template state. Not a store machine.)
   //  ⛔ Do NOT add a UI-pattern method here (togglePanel/openFocus/…). It's a key the dev
-  //     writes via setValue / setTemplateValue and reads via `visibleWhen`. Removed twice.
+  //     writes via setValue / setAppValue and reads via `visibleWhen`. Removed twice.
   // ════════════════════════════════════════════════════════════════════════════
 
   // --- lifecycle: the workflow turn's status (derived from WORKFLOW_STATE) ---

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

@@ -171,8 +171,8 @@ export interface ActionValue {
  *  (optionally narrowed by `send`). `then` chains a follow-up (Stac Multi Action). */
 export interface ActionSpec {
   // The SDK hardcodes no UI concept — only generic writes + a server route:
-  type: string; // "setValue" (component slice) | "setTemplateValue" (template state) | "input" | "submit"/custom (→ server)
-  values?: ActionValue[]; // setValue / setTemplateValue patches (the dev's chosen keys)
+  type: string; // "setValue" (component slice) | "setAppValue" (template state) | "input" | "submit"/custom (→ server)
+  values?: ActionValue[]; // setValue / setAppValue patches (the dev's chosen keys)
   send?: string[]; // server route: which scope fields to include (default: all)
   then?: ActionSpec | string; // optional chained follow-up
   /** Carried here by the renderer, NOT authored on the action: a node declares

package/vendor/sdk/lib/index.ts

@@ -2,8 +2,8 @@ export { UnoverseComponent } from "./UnoverseComponent";
 export type { UnoverseComponentProps } from "./UnoverseComponent";
 export { StreamedUnoverseComponent, useUnoverseInstance } from "./streamed";
 export type { StreamedUnoverseComponentProps } from "./streamed";
-export { StreamedUnoverseTemplate, selectPointers, computeAppWidth, resolveActiveLayout } from "./template";
-export type { StreamedUnoverseTemplateProps } from "./template";
+export { StreamedUnoverseApp, selectPointers, computeAppWidth, resolveActiveLayout } from "./app";
+export type { StreamedUnoverseAppProps } from "./app";
 export { renderNode, styleToCss, keyframesCss } from "./render";
 export type { ActionHandler, SlotResolver } from "./render";
 export { useUnoverseTheme } from "./theme";
@@ -59,7 +59,7 @@ export type {
   ServerComponentInit,
   ServerComponentData,
   ServerWorkflowState,
-  ServerTemplateData,
+  ServerAppData,
   ServerSessionReady,
   AnalyticsSpec,
   AnalyticsEvent,

package/vendor/sdk/lib/render.tsx

@@ -81,7 +81,7 @@ export function nodeAction(node: UnoverseNode, fallback: string): string | Actio
  */
 export type SlotResolver = (node: UnoverseNode, key?: React.Key) => ReactNode;
 
-// cssWidth moved to core/templates.ts (computeAppWidth needs it and core imports
+// cssWidth moved to core/apps.ts (computeAppWidth needs it and core imports
 // nothing from the React layer); re-exported to keep this import path working.
 export { cssWidth };
 

package/vendor/sdk/lib/voice.tsx

@@ -12,7 +12,7 @@
  * voice action names to the actions — see the workbench wiring. The SDK owns NO styles
  * and exposes only NEUTRAL model facts here (never UX flags).
  *
- * Transport split (docs/UNOVERSE_MCP_TEMPLATE_PROTOCOL §5): the live PCM frames AND the
+ * Transport split (docs/UNOVERSE_MCP_APP_PROTOCOL §5): the live PCM frames AND the
  * synchronized audio-state control events both ride the /ws/gravity WS lane (they stay
  * frame-synchronized); only structured component data is on MCP, untouched by voice.
  */
@@ -318,7 +318,7 @@ export function useVoiceService(config: UseVoiceServiceConfig): VoiceService {
   // host-side props spread. Low-frequency (call phases + a 1Hz duration tick).
   const store = config.store;
   useEffect(() => {
-    store?.mergeTemplateState(state as unknown as Record<string, unknown>);
+    store?.mergeAppState(state as unknown as Record<string, unknown>);
   }, [store, state]);
 
   return { state, startCall, endCall, toggleMute };