@unoverse-platform/studio 0.1.87 → 0.1.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unoverse-platform/studio",
-  "version": "0.1.87",
+  "version": "0.1.89",
   "type": "module",
   "description": "Unoverse Studio: the local authoring app. Reads your own rx/ folder, no backend.",
   "scripts": {

package/screens/TemplatesLibraryView.tsx

@@ -201,28 +201,53 @@ export function TemplatesLibraryView({ theme, org }: { theme: ResolvedTheme; org
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [storeVersion, store, current]);
 
+  // GROUPED BY CATEGORY, exactly as Components groups its rail — the shelf is no longer a
+  // flat list the moment small templates land on it (the `Blocks` shelf: pair, feature,
+  // single, rail, stack, statement) and a page has to be found among them. The category is
+  // the DOMAIN of the job, so the grouping reads as what a template is FOR. Within a
+  // category the developer's own list first, ownership marked per item rather than by
+  // section — the org chip says "yours"; no chip means the base shelf.
+  const byCategory = Object.entries(
+    templates.reduce<Record<string, TemplateDef[]>>((acc, t) => {
+      (acc[t.category ?? "Uncategorized"] ??= []).push(t);
+      return acc;
+    }, {}),
+  ).sort(([a], [b]) => a.localeCompare(b));
+  for (const [, items] of byCategory) items.sort((a, b) => (a.org ? 0 : 1) - (b.org ? 0 : 1));
+
   return (
     <div className={SCREEN}>
-      {/* NAVIGATOR — per-item org chip, like Components: no chip = BASE shelf. */}
+      {/* NAVIGATOR — grouped by category, per-item org chip: no chip = BASE shelf. */}
       <nav className={NAV}>
         {templates.length === 0 && (
           <div className="p-2 text-xs text-gray-400">
             No templates — restart the Unoverse server so /dev/templates is available.
           </div>
         )}
-        {templates.map((t) => (
-          <div key={refOf(t)}>
-            <button
-              onClick={() => setSelected(refOf(t))}
-              className={`flex w-full items-center gap-2 rounded px-2 py-1 text-left text-sm transition ${navItem(selected === refOf(t))}`}
-            >
-              <span className="truncate">{t.title ?? t.name}</span>
-              {t.org && (
-                <span className="ml-auto shrink-0 rounded bg-emerald-900/50 px-1.5 py-0.5 text-[10px] text-emerald-300">
-                  {t.org}
-                </span>
-              )}
-            </button>
+        {byCategory.map(([cat, items]) => (
+          <div key={cat} className="mb-3">
+            {/* The same group header Components draws: a hairline that fades right lifts the
+                label without adding weight, and wider tracking reads as a label rather than
+                another item. One anatomy across the workbench's rails. */}
+            <div className="mb-1 mt-1 flex items-center gap-2 px-2">
+              <span className="text-[10px] font-medium uppercase tracking-[0.14em] text-gray-400">{cat}</span>
+              <span className="h-px flex-1 bg-gradient-to-r from-gray-500/40 to-transparent" />
+            </div>
+            {items.map((t) => (
+              <div key={refOf(t)}>
+                <button
+                  onClick={() => setSelected(refOf(t))}
+                  className={`flex w-full items-center gap-2 rounded px-2 py-1 text-left text-sm transition ${navItem(selected === refOf(t))}`}
+                >
+                  <span className="truncate">{t.title ?? t.name}</span>
+                  {t.org && (
+                    <span className="ml-auto shrink-0 rounded bg-emerald-900/50 px-1.5 py-0.5 text-[10px] text-emerald-300">
+                      {t.org}
+                    </span>
+                  )}
+                </button>
+              </div>
+            ))}
           </div>
         ))}
       </nav>

package/vendor/sdk/lib/app.tsx

@@ -144,10 +144,10 @@ function collectSlotPointers(node: unknown, store: ComponentStore, scope?: Set<s
   const out: string[] = [];
   const walk = (n: unknown): void => {
     if (!n || typeof n !== "object") return;
-    const un = n as UnoverseNode & { children?: unknown[]; template?: unknown; frame?: unknown; cases?: Record<string, unknown> };
+    const un = n as UnoverseNode & { children?: unknown[]; item?: unknown; frame?: unknown; cases?: Record<string, unknown> };
     if (un.type === "ComponentSlot") out.push(...selectPointers(store, un, scope));
     (un.children ?? []).forEach(walk);
-    if (un.template) walk(un.template);
+    if (un.item) walk(un.item);
     if (un.frame) walk(un.frame);
     if (un.cases) Object.values(un.cases).forEach(walk);
   };
@@ -331,11 +331,11 @@ export function StreamedUnoverseApp({ client, store, uri, onAction, theme: theme
    */
   const tstate = store.getAppState() as Record<string, unknown>;
   const dismissedRaw = tstate.latchDismissed;
-  const held = def ? resolveLatch(def, store, typeof dismissedRaw === "string" ? dismissedRaw : undefined) : null;
+  const held = def ? resolveLatch(def, store, ladder.view, 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;
+      const current = def ? resolveLatch(def, store, ladder.view) : null;
       store.mergeAppState({ latchDismissed: current ? current.key : "" });
       return;
     }
@@ -353,6 +353,7 @@ export function StreamedUnoverseApp({ client, store, uri, onAction, theme: theme
     held?.key,
     held?.latch,
     dismissedRaw,
+    ladder.view,
     def,
     store,
     tstate.latched,

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

@@ -279,11 +279,17 @@ export function resolveActiveView(
  * 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
- * the highest-ranked one 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 rather than leaving a pill pointing at something off-surface.
+ * 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.
@@ -291,12 +297,18 @@ export function resolveActiveView(
 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.
@@ -316,9 +328,11 @@ export function resolveLatch(
       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.
+      // 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);

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

@@ -65,7 +65,7 @@ function remapFields(node: AnyNode, propMap: Record<string, string>): void {
     for (const v of when as { field?: string }[]) if (v && typeof v.field === "string" && propMap[v.field]) v.field = propMap[v.field];
   }
   if (Array.isArray(node.children)) node.children.forEach((c: AnyNode) => remapFields(c, propMap));
-  if (node.template) remapFields(node.template as AnyNode, propMap);
+  if (node.item) remapFields(node.item as AnyNode, propMap);
   if (node.cases && typeof node.cases === "object") for (const k of Object.keys(node.cases)) remapFields(node.cases[k] as AnyNode, propMap);
 }
 
@@ -102,7 +102,7 @@ function applyLiterals(node: AnyNode, lits: Record<string, unknown>): void {
   }
   if (node.style && typeof node.style === "object") applyStyleLiterals(node.style as AnyNode, lits);
   if (Array.isArray(node.children)) node.children.forEach((c: AnyNode) => applyLiterals(c, lits));
-  if (node.template) applyLiterals(node.template as AnyNode, lits);
+  if (node.item) applyLiterals(node.item as AnyNode, lits);
   if (node.cases && typeof node.cases === "object") for (const k of Object.keys(node.cases)) applyLiterals(node.cases[k] as AnyNode, lits);
 }
 

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

@@ -78,15 +78,18 @@ export interface UnoverseNode {
   user?: UnoverseNode;
   /** Timeline: data sub-tree rendered for an assistant turn (its ComponentSlot is scoped to that turn). */
   assistant?: UnoverseNode;
-  /** TWO node types read this, and the shape says which.
-   *
-   *  Each: the per-item subtree, rendered once per element of the bound array (`bind.items`),
+  /** Each: the per-item subtree, drawn once per element of the bound array (`bind.items`),
    *  with that element as its data scope. The node's own `style` is the list container.
    *
-   *  Template: a STRING naming what the place holds (UNOVERSE_TEMPLATE_MODEL.md — holder
+   *  RENAMED FROM `template` (2026-09-01). One word named two unrelated things — an Each's
+   *  repeated drawing and a mounted TEMPLATE — and the only way to tell them apart was the
+   *  shape of the value, which this type spelled out as `UnoverseNode | string`. A reader
+   *  hitting it in a layout had to work out which; an author writing one had to know both. */
+  item?: UnoverseNode;
+  /** Template: a STRING naming what the place holds (UNOVERSE_TEMPLATE_MODEL.md — holder
    *  grammar, deliberately the same shape as `interface:`), e.g. `template: grid-page`.
-   *  A renderer branches on the node's `type`, never on this key alone. */
-  template?: UnoverseNode | string;
+   *  Unmoved by the rename above: here the word names a template. */
+  template?: string;
   /** Template: the judgment granted to THIS placement — which items the director may select,
    *  whether it may order them, and the rules it works to. Opaque to the renderer, which
    *  carries it to the loader rather than reading into it; the placed node owns the mount,

package/vendor/sdk/lib/render.tsx

@@ -173,21 +173,21 @@ export function renderNode(
     return branch ? renderNode(branch, data, onAction, theme, key, slot, defs) : null;
   }
 
-  // `Each` — control flow: map a bound array (bind.items) → the `template` subtree once
+  // `Each` — control flow: map a bound array (bind.items) → the `item` subtree once
   // per item (that item as the data scope), inside the node's own container (a Box).
   // A PRIMITIVE item (string/number — e.g. a `string[]` of follow-up questions) is exposed
-  // as `{ value: item }`, so the template binds `value` like any field; object items pass
+  // as `{ value: item }`, so the item binds `value` like any field; object items pass
   // through unchanged. This is what lets an `Each` iterate a plain list of strings.
   if (node.type === "Each") {
     // Literal `items` fallback: a microapp component hardcodes its static option lists
     // in the def (props exist only for state — UNOVERSE_AUTHORING.md). bind wins.
     const src = node.bind?.items ? data[node.bind.items] : node.items;
     const items = Array.isArray(src) ? src : [];
-    // `template` is read by two node types and the shape says which: a SUBTREE here on Each,
+    // `item` is the Each's repeated drawing (renamed from `template` 2026-09-01: one word for
     // a holder NAME (string) on Template, which this branch never sees. Narrow rather than
     // assert, so a definition that puts the wrong one here renders nothing instead of
     // throwing inside the map.
-    const tpl = typeof node.template === "object" ? node.template : undefined;
+    const tpl = typeof node.item === "object" ? node.item : undefined;
     // WHERE AN ITEM SITS is something only the renderer knows, and a numbered list cannot
     // be authored without it: the data carries no ordinal, and a template cannot count.
     // `index` is 0-based for logic, `position` 1-based because that is what a reader sees.