@unoverse-platform/studio 0.1.88 → 0.1.90

package/package.json

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

package/screens/TemplatesLibraryView.tsx

@@ -23,7 +23,8 @@ import { NAV, SCREEN, navItem } from "./chrome";
 
 interface TemplateSection {
   /** static = placed as designed; copywriter = written into through its briefs;
-   *  director = decided from what streams in (§9b, the three words). */
+   *  director = the judge: a search place (with `component`) or a delivery band
+   *  (without) — one word since 2026-09-02 (§9b + §9e). */
   kind: "static" | "copywriter" | "director";
   /** The state instances render in at this section — what the claim matches. */
   face: string;
@@ -36,9 +37,15 @@ interface TemplateSection {
    *  previews as written and filled rather than as a page of ghosts. */
   seeds?: Record<string, Record<string, unknown>>;
   state?: string;
-  limit?: number;
   rules?: string;
   preview?: string[];
+  /** Director places (§9e): the grammar, echoed for the dock table. `ask` appears
+   *  only after derivation (rule 10d) — never authored. */
+  ask?: string;
+  type?: "discovery" | "intent";
+  include?: string[];
+  pick?: number;
+  items?: { min: number; max: number };
 }
 interface TemplateDef {
   name: string;
@@ -73,13 +80,26 @@ const refOf = (t: TemplateDef) => (t.org ? `${t.org}/${t.name}` : t.name);
 
 /** One section's description for the dock table — the three words (§9b). */
 function sectionLabel(sec: TemplateSection): { name: string; filler: string; rules: string } {
+  // ONE WORD, TWO MODES (§9e, 2026-09-02): with `component` = a search place; without =
+  // a delivery band. Both show as the director's — the judge is the same.
+  if (sec.kind === "director" && sec.component)
+    return {
+      name: sec.component,
+      filler: "director",
+      rules: [
+        sec.items ? `items ${sec.items.min}–${sec.items.max}` : null,
+        sec.type ?? null,
+        sec.include?.length ? sec.include.join("+") : null,
+        sec.pick != null ? `pick ${sec.pick}` : null,
+      ].filter(Boolean).join(" · "),
+    };
   if (sec.kind === "director")
     return {
       name: "director",
       filler: "director",
       rules: [
         sec.state ? `state ${sec.state}` : null,
-        sec.limit != null ? `limit ${sec.limit}` : null,
+        sec.pick != null ? `pick ${sec.pick}` : null,
         sec.rules ?? null,
       ].filter(Boolean).join(" · "),
     };
@@ -151,11 +171,16 @@ export function TemplatesLibraryView({ theme, org }: { theme: ResolvedTheme; org
     const secs = (base && current?.sections?.[base]) || [];
     const out: { nodeId: string; ref: string; face?: string; framed: boolean; seed?: Record<string, unknown> }[] = [];
     for (const sec of secs) {
-      if (sec.kind === "director") {
+      // ONE word, two modes (§9e rule 10b, 2026-09-02): a director WITH a component is a
+      // SEARCH place — its mock is its own component's preview, seeded exactly like a
+      // linked part. Only the BAND form (no ref) seeds stand-ins. This branch predates
+      // the merge and read every director as a band, so search places seeded nothing and
+      // the template previewed with those sections simply missing.
+      if (sec.ref) {
+        out.push({ nodeId: `${sec.face}~${sec.ref}`, ref: sec.ref, face: sec.face, framed: true, seed: sec.seeds?.[sec.ref] });
+      } else if (sec.kind === "director") {
         for (const [i, ref] of (sec.preview ?? []).entries())
           out.push({ nodeId: `${sec.face}~${ref}~${i}`, ref, face: sec.face, framed: false, seed: sec.seeds?.[ref] });
-      } else if (sec.ref) {
-        out.push({ nodeId: `${sec.face}~${sec.ref}`, ref: sec.ref, face: sec.face, framed: true, seed: sec.seeds?.[sec.ref] });
       }
     }
     return out;
@@ -201,28 +226,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/screens/TemplatesView.tsx

@@ -590,7 +590,7 @@ export function TemplatesView({
     const base = d.defaultLayout ?? Object.keys(d.layouts ?? {})[0];
     const out: { ref: string; face: string; props: Record<string, unknown> }[] = [];
     for (const sec of (base && d.sections?.[base]) || []) {
-      const refs = sec.kind === "director" ? (sec.preview ?? []) : sec.ref ? [sec.ref] : [];
+      const refs = sec.ref ? [sec.ref] : sec.kind === "director" ? (sec.preview ?? []) : [];
       for (const ref of refs) out.push({ ref, face: sec.face, props: sec.seeds?.[ref] ?? {} });
     }
     return out;

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.