unoverse 0.1.188 → 0.1.190

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoverse",
-  "version": "0.1.188",
+  "version": "0.1.190",
   "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/file.mjs

@@ -399,8 +399,16 @@ function lintFile(file) {
     // ONE REQUIREMENT SHAPE (2026-08-29): a kind declares its tree (`states:`) OR
     // its drawing (`root` — flat components/atoms). A tree component's root is
     // SYNTHESIZED by the compiler, never required.
+    // A BLOCK is a template that declares a DRAWING instead of a tree (2026-08-31): a flat
+    // file, no manifest, one `root:` — `pair`, `feature`, `single`, `rail`, `stack`. It has
+    // no states because it is not a screen: it is a shape a page imports by `Ref`, inlined
+    // before the page's sections compile. Requiring `states:` of it would be demanding a
+    // state machine from a fragment, which is the same mistake as demanding a manifest:
+    // both are what a PAGE has, and a block is not a page.
+    const isBlock = declared === "template" && json.states === undefined && json.root !== undefined;
     const envelopeRequired =
-      declared === "app" || declared === "template" ? ["name", "states"]
+      isBlock ? ["name", "root"]
+      : declared === "app" || declared === "template" ? ["name", "states"]
       : declared === "component" ? ["name", ...(json.states !== undefined || json.state?.view !== undefined ? [] : ["root"])]
       : ["name", "root"];
     if (declared === "template" && json.states === undefined && (json.parts !== undefined || json.shapes !== undefined)) envelopeRequired.pop();

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

@@ -45,7 +45,7 @@ export const UNIVERSAL_PROPS = new Set([
  */
 export const PROP_KEYS = [
   "type", "input", "description", "maxLength", "minItems", "maxItems",
-  "hydrate", "optional", "enum", "preview", "default", "items",
+  "hydrate", "override", "optional", "enum", "preview", "default", "items",
 ];
 
 /**
@@ -86,7 +86,7 @@ export const PRIMITIVE_PROPS = {
   Input: ["placeholder", "inputType", "disabledWhen", "maxLength", "multiline", "rows",
           "inputMode", "autoComplete", "advanceOnFill"],
   Select: ["placeholder", "options", "disabledWhen"],
-  Each: ["template", "app", "items"],
+  Each: ["item", "app", "items"],
   Switch: ["on", "cases", "fallback"],
   Ref: ["ref", "props", "with", "children", "name"],
   ComponentSlot: ["select", "frame", "fallback", "pinned", "appWidth"],
@@ -121,7 +121,7 @@ export const STYLE_KEYS = new Set([
 // exact regex from server/src/runtime/definition-tokens.test.ts
 export const RAW_VALUE = /#[0-9a-fA-F]{3,8}\b|\b\d*\.?\d+(px|rem|em)\b/;
 // nodes reachable through these keys (data keys like `items`/`cases` handled explicitly)
-export const CHILD_NODE_KEYS = ["children", "template", "fallback", "user", "assistant"];
+export const CHILD_NODE_KEYS = ["children", "item", "fallback", "user", "assistant"];
 // folders that hold BARE PARTIALS one level under the definition root
 export const PARTIAL_DIRS = new Set(["layouts", "states", "components", "blocks"]);
 

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

@@ -17,9 +17,15 @@ import { join, dirname, basename, relative, sep } from "node:path";
 import { PRIMITIVES, CONDITION_KEYS, STYLE_KEYS, RAW_VALUE, CHILD_NODE_KEYS, PARTIAL_DIRS, DIMENSION_KEYS, UNIVERSAL_PROPS, PRIMITIVE_PROPS, PRIMITIVE_BINDS } from "./vocabulary.mjs";
 import { isDefFile, defName, defPath, readDef } from "./defs.mjs";
 
-// THE THREE WORDS and the director's closed block (UNOVERSE_TEMPLATE_MODEL.md §9b).
-const SECTION_WORDS = ["static", "copywriter", "director"];
+// 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"];
+// §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"];
+// 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.
+const QUERY_TYPES = ["services", "images", "needs", "actions"];
 
 export function makeWalkNode(ctx) {
   const { report, checkCondition, checkDimension, checkToken, appSizesForFile, componentNamesForFile, refResolves, canonicalRef, declaredProps, atomsDirExists, stepList, spaceSteps, isAppPath, isTemplatePath, defRoot } = ctx;
@@ -68,18 +74,86 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
               report("error", file, `director.preview names unknown component "${c}". No match in the design system or this org's components (lookup is case-insensitive)`);
         }
       }
-      // ONE MIND, MANY BANDS (§9b rule 3, amended 2026-08-30): a layout may hold several
-      // directed bands — one verdict, arranged — but each must claim a DISTINCT face, or
-      // the surface is ambiguous (the reaction contract's one-view-one-surface rule). So
-      // on a multi-band layout every director declares its `state:`; two bands claiming
-      // the same face is the error this rule now exists for.
+      // 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 (seen.length && !face)
-        report("error", file, `a second "director:" in this layout declares no "state:". Several bands are allowed — one mind, arranged — but each must claim a DISTINCT face, so every one of them names it (§9b rule 3)`);
-      else if (face && seen.includes(face))
+      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)`);
+      }
     } 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)`);
     } else {
@@ -94,7 +168,7 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
     // exists to abolish.
     if (node.select !== undefined)
       report("error", file, `a template part never authors "select" — the three words compile to the wire primitives at serve time (§9b rule 9)`);
-    const { static: _s, copywriter: _c, director: _d, select: _sel, ...rest } = node;
+    const { static: _s, copywriter: _c, director: _d, query: _q, select: _sel, ...rest } = node;
     // An unpinned director claims the OWNING STATE's name (arrivals keep their own state
     // and the template's states react by name — the free grid↔page dance), so the face
     // comes from whichever state in the envelope declares this layout.
@@ -108,7 +182,12 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
         return typeof l === "string" && basename(l).toLowerCase() === here.toLowerCase();
       });
     };
-    const face = word === "director" ? (node.director?.state ?? owningState()) : String(node[word]).split("/").pop();
+    // A QUERIED place links its component under `component:`, and claims that part's own
+    // face at limit 1 exactly as a linked part does — its `limit:` counts ROWS inside the
+    // part, not instances of it, so it never reaches the slot (§9e).
+    const linkedPath = word === "query" ? node.query?.component : node[word];
+    const face =
+      word === "director" ? (node.director?.state ?? owningState()) : typeof linkedPath === "string" ? linkedPath.split("/").pop() : undefined;
     const limit = word === "director" ? node.director?.limit : 1;
     const select = { from: "all", ...(face ? { where: { field: "state", eq: face } } : {}), ...(typeof limit === "number" ? { limit } : {}) };
     return walkNode({ type: "ComponentSlot", select, ...rest }, file, root, widthCap);
@@ -151,12 +230,12 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
           report("error", file, `Switch on "${node.on}" → case "${caseKey}" re-guards its own discriminant. A layer never guards itself; delete the visibleWhen (docs.unoverse.ai/design/components)`);
       }
   }
-  // Each: a `template` + a list — EITHER a literal `items:[]` (hardcoded content,
+  // Each: an `item` + a list — EITHER a literal `items:[]` (hardcoded content,
   // the microapp default) OR `bind.items` (a workflow-fed array).
   if (t === "Each") {
     const hasList = Array.isArray(node.items) || (node.bind && typeof node.bind === "object" && node.bind.items);
-    if (!node.template || !hasList)
-      report("error", file, `Each needs "template" + a list. Literal "items": [...] or "bind": { "items": "<field>" } (docs.unoverse.ai/design/components)`);
+    if (!node.item || !hasList)
+      report("error", file, `Each needs "item" + a list. Literal "items": [...] or "bind": { "items": "<field>" } (docs.unoverse.ai/design/components)`);
   }
   if (t === "Ref") {
     if (typeof node.ref !== "string")