unoverse 0.1.191 → 0.1.192

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoverse",
-  "version": "0.1.191",
+  "version": "0.1.192",
   "description": "The Unoverse front door — create a Studio project, a universe, or a client app, and launch Studio.",
   "license": "SEE LICENSE IN README.md",
   "type": "module",

package/vendor/base/lint/design/index.mjs

@@ -454,16 +454,31 @@ for (const orgDir of orgDirs) {
 // resolver has always done this (componentDirs' fallback); the lint did not, so a part
 // composing a sibling part read as an unresolvable Ref while it rendered perfectly.
 const templatePartNames = new Map(); // template folder name -> Set(lower part names)
+// BLOCKS (§6b-0, 2026-09-02): a flat def file directly under a templates home is a small
+// reusable template — Ref'able bare from its own org (the loader's third fallback).
+const orgTemplateNames = new Map(); // org (or DS basename) -> Set(lower block names)
 for (const root of [DS, ...orgDirs]) {
   const home = join(root, "templates");
   if (!existsSync(home)) continue;
+  const blocks = orgTemplateNames.get(basename(root)) ?? new Set();
   for (const t of readdirSync(home)) {
+    if (isDefFile(t)) {
+      blocks.add(defName(t).toLowerCase());
+      continue;
+    }
     const parts = join(home, t, "components");
     if (!existsSync(parts)) continue;
     const set = templatePartNames.get(t.toLowerCase()) ?? new Set();
-    for (const e of readdirSync(parts)) if (isDefFile(e)) set.add(defName(e).toLowerCase());
+    for (const e of readdirSync(parts)) {
+      if (isDefFile(e)) set.add(defName(e).toLowerCase());
+      // FOLDER-FORM PARTS (moment/, chapter/): the part is <name>/<name>.yaml. The flat
+      // scan above missed them, so a part in earned structure read as unresolvable while
+      // it rendered perfectly.
+      else if (existsSync(join(parts, e, e + ".yaml"))) set.add(e.toLowerCase());
+    }
     templatePartNames.set(t.toLowerCase(), set);
   }
+  orgTemplateNames.set(basename(root), blocks);
 }
 const orgOfFile = (file) => {
   const home = orgDirs.find((d) => file.startsWith(d + sep));
@@ -485,7 +500,10 @@ const refResolves = (ref, file) => {
     return orgComponentNames.get(qualifier)?.has(name) ?? false;
   }
   if (atomNames.has(lower) || dsComponentNames.has(lower)) return true;
-  return fileOrg ? (orgComponentNames.get(fileOrg)?.has(lower) ?? false) : false;
+  if (fileOrg && orgComponentNames.get(fileOrg)?.has(lower)) return true;
+  // A BLOCK — a flat template, own org first, then the design system's (loader order).
+  if (fileOrg && orgTemplateNames.get(fileOrg)?.has(lower)) return true;
+  return orgTemplateNames.get(basename(DS))?.has(lower) ?? false;
 };
 
 /**

package/vendor/base/lint/design/walk.mjs

@@ -18,10 +18,10 @@ import { PRIMITIVES, CONDITION_KEYS, STYLE_KEYS, RAW_VALUE, CHILD_NODE_KEYS, PAR
 import { isDefFile, defName, defPath, readDef } from "./defs.mjs";
 
 // THE FOUR WORDS and the two closed blocks (UNOVERSE_TEMPLATE_MODEL.md §9b + §9e).
-const SECTION_WORDS = ["static", "copywriter", "director", "query"];
-const DIRECTOR_KEYS = ["state", "limit", "rules", "preview"];
+const SECTION_WORDS = ["static", "copywriter", "director"];
+const DELIVERY_KEYS = ["state", "pick", "rules", "preview"];
 // §9e: a queried place says WHAT draws it, WHAT it asks, WHAT KIND may answer, HOW MANY.
-const QUERY_KEYS = ["component", "ask", "type", "include", "pick"];
+const SEARCH_KEYS = ["component", "type", "include", "pick", "items"];
 // The `object_type`s a place may admit. Apps and skills are absent by construction: the
 // page's own searches are SILENT (no app unlocked, no tool minted, no card lane, no
 // director woken), or every place would rain cards onto a page still assembling itself.
@@ -53,16 +53,82 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
   if (word && node.type === undefined) {
     if (!isTemplatePath(file))
       report("error", file, `"${word}:" is template grammar — only a template layout's parts say how they are filled. Apps and components author ComponentSlot directly (UNOVERSE_TEMPLATE_MODEL §9b)`);
+    if (node.query !== undefined) {
+      report("error", file, `"query:" is retired vocabulary (§9e rule 10b REVERSED 2026-09-02) — spell the place director: with the same component/items/type/include/pick. One word, one judge`);
+    }
     if (word === "director") {
+      /**
+       * ONE WORD, TWO MODES (§9e, 2026-09-02): a director place WITH `component` is a
+       * SEARCH place (the page fetches its own content); WITHOUT one it is a DELIVERY
+       * band (the conversation fills it). The key sets are mutually exclusive, so a
+       * place is always unambiguously one or the other — behaviour never forks on a
+       * stray key. The QUESTION is never authored (rule 10d): it is derived from the
+       * writing, the page's pool, the component's contract, or the guest's ask.
+       */
       const d = node.director;
-      if (!d || typeof d !== "object" || Array.isArray(d))
-        report("error", file, `"director:" is a block, not a path — no component is ever named there: it is the one part whose content nobody knows at design time (§9b rule 1)`);
-      else {
+      if (!d || typeof d !== "object" || Array.isArray(d)) {
+        report("error", file, `"director:" is a block, not a path (§9b rule 1)`);
+      } else if (d.limit !== undefined) {
+        report("error", file, `director.limit is retired — the one cap word is "pick": how many the director keeps (§9e rule 9, renamed 2026-09-02)`);
+      } else if (d.ask !== undefined || d.query !== undefined) {
+        report("error", file, `a director place never states its question — it is DERIVED (§9e rule 10d): the writer's headings (items), the page's pool (a gallery), the component's own contract, or the guest's ask`);
+      } else if (typeof d.component === "string" && d.component) {
+        // A SEARCH PLACE. The checks here are the ones that fail SILENTLY at runtime: a
+        // place missing include or pick is skipped, and a kind nobody stores draws
+        // nothing — both read as "the design is broken" with no log saying why.
+        //
+        // THE SEARCH WORDS SIT ON THE THING THAT SEARCHES (owner ruling 2026-09-02): on
+        // an items place each ITEM searches, so type/include/pick nest INSIDE items:
+        // beside min/max, and pick reads unambiguously as per-item. Spelled flat, the
+        // same word meant two scopes depending on whether items: was present.
+        const itemed = d.items && typeof d.items === "object" && !Array.isArray(d.items);
+        if (d.items !== undefined && !itemed)
+          report("error", file, `director.items is a block — items: { min, max, type, include, pick } (§9e rule 10c)`);
+        if (itemed && (d.type !== undefined || d.include !== undefined || d.pick !== undefined))
+          report("error", file, `an items place nests its search words INSIDE items: { min, max, type, include, pick } — each ITEM searches, so pick reads per item (§9e rule 10c, 2026-09-02)`);
+        const TOP_KEYS = itemed ? ["component", "items"] : SEARCH_KEYS;
         for (const k of Object.keys(d))
-          if (!DIRECTOR_KEYS.includes(k))
-            report("error", file, `director has no "${k}". It reads ${DIRECTOR_KEYS.map((x) => `"${x}"`).join(", ")} (§9b)`);
-        if (d.limit !== undefined && typeof d.limit !== "number")
-          report("error", file, `director.limit is a NUMBER — a hard cap the machine enforces, never trusted to the model (§9b)`);
+          if (!TOP_KEYS.includes(k))
+            report("error", file, `a search place has no "${k}". It reads ${TOP_KEYS.map((x) => `"${x}"`).join(", ")} (§9e; "state"/"rules" belong to a delivery band — a place with a component is governed by the page's brief)`);
+        if (!defPath(root, d.component) && !existsSync(join(root, d.component)))
+          report("error", file, `director.component "${d.component}" does not resolve under ${relative(process.cwd(), root)}/ (§9e)`);
+        const ITEM_KEYS = ["min", "max", "type", "include", "pick"];
+        if (itemed) {
+          for (const k of Object.keys(d.items))
+            if (!ITEM_KEYS.includes(k))
+              report("error", file, `director.items has no "${k}". It reads ${ITEM_KEYS.map((x) => `"${x}"`).join(", ")} (§9e rule 10c)`);
+          const { min, max } = d.items;
+          if (typeof min !== "number" || typeof max !== "number" || min < 1 || max < min)
+            report("error", file, `director.items carries { min, max } — how many items the writer may shape, 1 <= min <= max (§9e rule 10c)`);
+        }
+        // The search words, read where they live: the place itself, or each item.
+        const s = itemed ? d.items : d;
+        const at = itemed ? "director.items" : "director";
+        // REQUIRED, both (2026-09-01, carried over). The engine supplies NO defaults: a
+        // default include or pick would be one template's answer written into the platform.
+        if (s.include === undefined)
+          report("error", file, `${at}.include is REQUIRED on a search place — what KIND may answer; the engine has no default kind (§9e rule 6)`);
+        else if (!Array.isArray(s.include) || s.include.some((t) => typeof t !== "string"))
+          report("error", file, `${at}.include is an array of result types — ${QUERY_TYPES.map((t) => `"${t}"`).join(", ")} (§9e rule 6)`);
+        else
+          for (const t of s.include)
+            if (!QUERY_TYPES.includes(String(t)))
+              report("error", file, `${at}.include has no "${t}". A place may admit ${QUERY_TYPES.map((x) => `"${x}"`).join(", ")}; apps and skills are never included, because the page's own searches are SILENT (§9e rule 6)`);
+        if (s.pick === undefined)
+          report("error", file, `${at}.pick is REQUIRED — how many the director keeps${itemed ? " PER ITEM" : ""}; the engine has no default count (§9e rule 9)`);
+        else if (typeof s.pick !== "number" || s.pick < 1)
+          report("error", file, `${at}.pick is a NUMBER — how many the director keeps${itemed ? " per item" : ""}, a cap the machine enforces (§9e rule 9)`);
+        // `type` is OPTIONAL since the question derives (rule 10d): authored it stands;
+        // absent, a contract subject searches as intent and the guest's ask as discovery.
+        if (s.type !== undefined && s.type !== "discovery" && s.type !== "intent")
+          report("error", file, `${at}.type is "discovery" (what lives around a topic) or "intent" (a named need) — or omitted, and the derivation decides (§9e rule 10d)`);
+      } else {
+        // A DELIVERY BAND.
+        for (const k of Object.keys(d))
+          if (!DELIVERY_KEYS.includes(k))
+            report("error", file, `a delivery band has no "${k}". It reads ${DELIVERY_KEYS.map((x) => `"${x}"`).join(", ")} (§9b; a place that names a component is a search place)`);
+        if (d.pick !== undefined && (typeof d.pick !== "number" || d.pick < 1))
+          report("error", file, `director.pick is a NUMBER — how many the director keeps, a cap the machine enforces (§9e rule 9)`);
         if (d.rules !== undefined && typeof d.rules !== "string")
           report("error", file, `director.rules is written like a brief: one string of English (§9b)`);
         if (d.preview !== undefined && (!Array.isArray(d.preview) || d.preview.some((c) => typeof c !== "string")))
@@ -73,86 +139,14 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
             if (comps && !comps.has(String(c).toLowerCase()))
               report("error", file, `director.preview names unknown component "${c}". No match in the design system or this org's components (lookup is case-insensitive)`);
         }
-      }
-      // A PLACE NEEDS NO NAME (§9d, ruled 2026-08-31). A layout may hold several director
-      // places — one mind, arranged — and each needs a DISTINCT address or the surface is
-      // ambiguous (the reaction contract's one-view-one-surface rule). But the ADDRESS is
-      // the compiler's to hand out, by position, and an author writes places and a brief,
-      // never a face name. This rule used to demand `state:` on every place after the
-      // first; that was config in the layout, saying nothing the one mind did not already
-      // know from the page's brief.
-      //
-      // An AUTHORED `state:` still stands (the flat-email pin, §9b rule 4), so two places
-      // pinned to the SAME face remains an error — that one is genuinely ambiguous.
-      const seen = directorsSeen.get(file) ?? [];
-      const face = typeof d?.state === "string" ? d.state : null;
-      if (face && seen.includes(face))
-        report("error", file, `two directed bands claim the face "${face}". A face has exactly one surface, or the active one is ambiguous (§9b rule 3, the reaction contract)`);
-      directorsSeen.set(file, [...seen, face]);
-    } else if (word === "query") {
-      /**
-       * A QUERIED PLACE (§9e, RULED 2026-09-01) — lane 2 of §5b, spelled at last. It links a
-       * component like `static:`/`copywriter:` do, but as a BLOCK, because it also carries
-       * the question it puts to the search.
-       *
-       * The checks here are the ones that fail SILENTLY at runtime: a place with no ask
-       * simply never fills, and a place asking for a type nobody stores draws nothing. Both
-       * read as "the design is broken" on screen, with nothing in any log saying why.
-       */
-      const q = node.query;
-      if (!q || typeof q !== "object" || Array.isArray(q)) {
-        report("error", file, `"query:" is a block, not a path — it carries the component AND the question it asks (§9e)`);
-      } else {
-        for (const k of Object.keys(q))
-          if (!QUERY_KEYS.includes(k))
-            report("error", file, `query has no "${k}". It reads ${QUERY_KEYS.map((x) => `"${x}"`).join(", ")} (§9e, the four words: the ask, which search answers it, what kind may answer, how many the director picks)`);
-        if (typeof q.component !== "string" || !q.component)
-          report("error", file, `query.component links the part by PATH (component: components/<part>) — that is what draws the rows it finds (§9e)`);
-        else if (!defPath(root, q.component) && !existsSync(join(root, q.component)))
-          report("error", file, `query.component "${q.component}" does not resolve under ${relative(process.cwd(), root)}/ (§9e)`);
-        if (typeof q.ask !== "string" || !q.ask.trim())
-          report("error", file, `query.ask is the QUESTION put to the search — without one the place never fills, and nothing says so (§9e)`);
-        // REQUIRED, both of them (2026-09-01). The engine supplies NO defaults: it has to
-        // fill a course page and a deal page as readily as a day, and a default `include`
-        // or `limit` would be one template's answer written into the platform. A place that
-        // does not say what it wants and how many is skipped at runtime, so the slip has to
-        // be caught here or it is silent.
-        if (q.include === undefined)
-          report("error", file, `query.include is REQUIRED — the engine has no default kind, because a default would be one template's answer written into the platform (§9e rule 6)`);
-        if (q.pick === undefined)
-          report("error", file, `query.pick is REQUIRED — how many the director puts on the page; the engine has no default count (§9e rule 9)`);
-        // A searching place says WHICH search answers it; a gallery place ([images] alone)
-        // never searches and omits it. Skipped silently at runtime otherwise (§9e).
-        const gallery = Array.isArray(q.include) && q.include.length > 0 && q.include.every((w) => String(w).toLowerCase() === "images");
-        if (!gallery && q.type !== "discovery" && q.type !== "intent")
-          report("error", file, `query.type is REQUIRED on a searching place — "discovery" (what lives around a topic) or "intent" (a named need). The author knows which their question is (§9e)`);
-        {
-          // NOT CHECKED HERE: "one place, one kind of moment, one plain question" (§9e).
-          // It is a real rule and it is not machine-readable. An "and" check was written and
-          // removed the same hour: it fired on "theme parks and attractions"
-          // and "bars and evening entertainment", which name ONE kind of thing twice for
-          // recall — indistinguishable by regex from "dinner and after-dark", which is two
-          // moments. A warning that fires on correct authoring teaches authors to ignore
-          // warnings, so the rule stays in the doc and in review rather than half-enforced.
-
-          // The template writes the half true of EVERY guest; who the guest is reaches the
-          // ranking through task affinity, not through the words. Measured 2026-09-01:
-          // a plain "restaurants" ask returned three matches, and the same question with
-          // ", for a family with teenagers" appended returned NONE — the clause pulls the
-          // embedding off the thing being asked for, under the precision floor.
-          if (/\b(for a|for my|with kids|with children|teenager|family of)\b/i.test(q.ask))
-            report("error", file, `query.ask "${q.ask}" names WHO it is for. An ask says what KIND of thing; who the guest is rides task affinity in the ranking, and appending it to the question drops every match under the precision floor (§9e rule 4)`);
-        }
-        if (q.include !== undefined) {
-          if (!Array.isArray(q.include) || q.include.some((t) => typeof t !== "string"))
-            report("error", file, `query.include is an array of result types — ${QUERY_TYPES.map((t) => `"${t}"`).join(", ")} (§9e rule 6)`);
-          else
-            for (const t of q.include)
-              if (!QUERY_TYPES.includes(String(t)))
-                report("error", file, `query.include has no "${t}". A place may admit ${QUERY_TYPES.map((x) => `"${x}"`).join(", ")}; apps and skills are never included, because the page's own searches are SILENT (§9e rule 6)`);
-        }
-        if (q.pick !== undefined && (typeof q.pick !== "number" || q.pick < 1))
-          report("error", file, `query.pick is a NUMBER — how many the director puts on the page, a cap the machine enforces (§9e rule 9)`);
+        // A PLACE NEEDS NO NAME (§9d): the compiler addresses delivery bands by
+        // position; an AUTHORED state: still stands (the flat-email pin), so two bands
+        // pinned to the SAME face remains the one genuine ambiguity.
+        const seen = directorsSeen.get(file) ?? [];
+        const face = typeof d?.state === "string" ? d.state : null;
+        if (face && seen.includes(face))
+          report("error", file, `two directed bands claim the face "${face}". A face has exactly one surface, or the active one is ambiguous (§9b rule 3, the reaction contract)`);
+        directorsSeen.set(file, [...seen, face]);
       }
     } else if (typeof node[word] !== "string") {
       report("error", file, `"${word}:" links a component by PATH (${word}: components/<part>) — that is what makes it a known part (§9b rule 1)`);