@unoverse-platform/studio 0.1.88 → 0.1.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unoverse-platform/studio",
-  "version": "0.1.88",
+  "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);
   };

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.