unoverse 0.1.166 → 0.1.168

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoverse",
-  "version": "0.1.166",
+  "version": "0.1.168",
   "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

@@ -112,6 +112,12 @@ function lintFile(file) {
       //   (layouts/<name>); every base substate needs its state file
       //   (states/<name>); a name cannot be both; an authored stateOrder is
       //   superseded and should be deleted.
+      // ONE DRAWINGS FOLDER (owner ruling 2026-08-22): templates work like
+      // components — every drawing lives in layouts/, the tree decides which state
+      // owns which. A states/ folder is the pre-unification anatomy: move its files
+      // into layouts/ and update $include paths.
+      if (existsSync(join(root, "states")))
+        report("error", file, `template carries a states/ folder — templates have ONE drawings folder. Move states/* into layouts/ and update every "$include: states/<name>" to "layouts/<name>" (anatomy unified with components, LAYERS §3)`);
       if (json.states !== undefined) {
         if (!json.states || typeof json.states !== "object" || Array.isArray(json.states)) {
           report("error", file, `manifest "states" must be an object — the template tree: { <base>: { states: {…} }, <reaction>: {}, … } (STATE_MODEL §5)`);
@@ -124,19 +130,43 @@ function lintFile(file) {
           for (const [n, s] of Object.entries(json.states)) {
             if (s !== null && (typeof s !== "object" || Array.isArray(s)))
               report("error", file, `tree state "${n}" must be an object ({} is a complete state) (STATE_MODEL §5)`);
-            if (n !== base && !defPath(join(root, "layouts"), n) && !defPath(join(root, "states"), n))
-              report("error", file, `tree state "${n}" has no layouts/${n} and no states/${n}. A reaction state needs its drawing — a full arrangement (layouts/) or a STACKED overlay (states/, LAYERS §6) (STATE_MODEL §5)`);
+            if (n !== base && !defPath(join(root, "layouts"), n))
+              report("error", file, `tree state "${n}" has no layouts/${n}. Every state's drawing — a full arrangement or a stacked overlay — lives in layouts/, the template's ONE drawings folder (anatomy unified with components, LAYERS §3) (STATE_MODEL §5)`);
             const nested = s && typeof s === "object" ? s.states : undefined;
             if (nested && typeof nested === "object" && !Array.isArray(nested))
               for (const sub of Object.keys(nested)) {
                 subs.push(sub);
-                if (!defPath(join(root, "states"), sub))
-                  report("error", file, `substate "${sub}" (under "${n}") has no states/${sub} file — a contained substate is a state file the base includes (STATE_MODEL §5)`);
+                if (!defPath(join(root, "layouts"), `${n}-${sub}`))
+                  report("error", file, `substate "${sub}" (under "${n}") has no layouts/${n}-${sub} file — a substate's drawing is OWNER-PREFIXED in layouts/ (the step-* convention: bare names are the app's screens, <owner>-<sub> their sub-drawings) (LAYERS §3)`);
               }
           }
           for (const sub of subs)
             if (names.includes(sub))
               report("error", file, `"${sub}" is declared both as a top-level state and a substate — nesting IS containment; a name lives at exactly one level (STATE_MODEL §5)`);
+          // THE FOLDER CANNOT LIE (owner ruling 2026-08-22): every layouts/ file is
+          // either a SCREEN (a bare name declaring a top-level state) or a substate
+          // drawing (<owner>-<sub>, both declared). Anything else is an error — a
+          // shared part belongs in components/.
+          {
+            const ldir = join(root, "layouts");
+            if (existsSync(ldir)) {
+              const declaredSubs = new Map();
+              for (const [n2, s2] of Object.entries(json.states)) {
+                const nested2 = s2 && typeof s2 === "object" ? s2.states : undefined;
+                if (nested2 && typeof nested2 === "object" && !Array.isArray(nested2))
+                  for (const sub2 of Object.keys(nested2)) declaredSubs.set(`${n2}-${sub2}`, n2);
+              }
+              for (const f of readdirSync(ldir).filter(isDefFile)) {
+                const nm = defName(f);
+                if (names.includes(nm) || declaredSubs.has(nm)) continue;
+                const owner = names.find((n2) => nm.startsWith(`${n2}-`));
+                if (owner)
+                  report("error", file, `layouts/${nm} is prefixed for state "${owner}" but "${nm.slice(owner.length + 1)}" is not declared as its substate — declare it in the tree, or move the file to components/ if it is a shared part (LAYERS §3)`);
+                else
+                  report("error", file, `layouts/${nm} is neither a declared state nor an <owner>-<sub> substate drawing — bare names are the app's screens; declare it, prefix it with its owner, or move it to components/ (LAYERS §3)`);
+              }
+            }
+          }
           if (json.stateOrder !== undefined)
             report("warn", file, `"stateOrder" is superseded by the "states" tree (the ladder derives from the top level minus the base) — delete it (STATE_MODEL §5)`);
         }
@@ -187,6 +217,14 @@ function lintFile(file) {
               : [];
           };
           const states = new Set([...viewsIn("states"), ...viewsIn("layouts")]);
+          // ANATOMY UNIFIED (2026-08-22): a substate's drawing lives in layouts/ under
+          // `<arrangement>-<substate>`, so the STATE's own name is no longer a filename.
+          // The resolver already looks both ways (definitions.ts, template tree); without
+          // the same lookup here a correctly-migrated template lints as though every one
+          // of its substates had vanished.
+          const declared = json.states && typeof json.states === "object" && !Array.isArray(json.states) ? json.states : {};
+          for (const [parent, node] of Object.entries(declared))
+            for (const sub of Object.keys(node?.states ?? {})) if (states.has(`${parent}-${sub}`)) states.add(sub);
           const comps = componentNamesForFile(file);
           for (const [state, list] of Object.entries(json.preview)) {
             if (!states.has(state))
@@ -270,11 +308,16 @@ function lintFile(file) {
 
       // only components that ADOPTED the structure are held to the full discipline
       if (hasLayouts || stateFiles.length || hasStateBlock) {
-        const nonInput = Object.entries(json.props ?? {})
-          .filter(([, v]) => !(v && typeof v === "object" && v.input === true))
+        // Every prop declares what fills it. Was "must be input:true", from when props
+        // only held workflow data; shared components added props nothing streams in (the
+        // preview axis, literals passed via `Ref with`) — input:true there is false AND
+        // load-bearing, since configSchema derives from it. Silence is the error:
+        // unflagged props default to INPUTS.
+        const undeclared = Object.entries(json.props ?? {})
+          .filter(([, v]) => !(v && typeof v === "object" && typeof v.input === "boolean"))
           .map(([k]) => k);
-        if (nonInput.length)
-          report("error", file, `microapp props [${nonInput.join(", ")}] are not input:true. Hardcode content in the layout, or move mutable keys into the \`state\` block (docs/design/03)`);
+        if (undeclared.length)
+          report("error", file, `microapp props [${undeclared.join(", ")}] do not declare "input". Every prop says what fills it: input:true = a workflow streams it (it joins the node's configSchema); input:false = nothing does (a preview axis, or a literal the host passes via Ref with). Unflagged props default to INPUTS (docs/design/03)`);
 
         // STATE MODEL v2 (UNOVERSE_STATE_MODEL §5): an authored `state.view` TREE is
         // the component's state machine — the ONE object the scalar rule admits.

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

@@ -407,8 +407,42 @@ const dsComponentNames = new Set(
     .filter((e) => !e.name.startsWith("."))
     .map((e) => (e.isDirectory() ? e.name : defName(e.name)).toLowerCase()),
 );
-// A valid Ref target if there's ANY resolvable home (atoms OR DS components).
-const refResolves = (ref) => atomNames.has(ref.toLowerCase()) || dsComponentNames.has(ref.toLowerCase());
+// The ORG tier's component names, per org (docs/unoverse/UNOVERSE_COMPONENT_ORGS.md):
+// a Ref may also resolve an org component — bare from inside that org's own tree (the
+// resolver's context rule), or org-qualified as `<org>/<name>` when two orgs share the
+// name. Org-privacy holds: a file only ever reaches its OWN org's components, and a
+// design-system file reaches none.
+const orgComponentNames = new Map(); // org dir basename -> Set(lower names)
+for (const orgDir of orgDirs) {
+  const home = join(orgDir, "components");
+  const set = new Set();
+  if (existsSync(home))
+    for (const e of readdirSync(home)) {
+      if (e.startsWith(".")) continue;
+      const name = statSync(join(home, e)).isDirectory() ? e : isDefFile(e) ? defName(e) : null;
+      if (name) set.add(name.toLowerCase());
+    }
+  orgComponentNames.set(basename(orgDir), set);
+}
+const orgOfFile = (file) => {
+  const home = orgDirs.find((d) => file.startsWith(d + sep));
+  return home ? basename(home) : null;
+};
+// A valid Ref target if there's ANY resolvable home the FILE may reach: atoms, DS
+// components, or (from inside an org tree) that org's own components — bare or
+// `<org>/<name>`-qualified.
+const refResolves = (ref, file) => {
+  const lower = ref.toLowerCase();
+  const fileOrg = file ? orgOfFile(file) : null;
+  const slash = lower.indexOf("/");
+  if (slash > 0) {
+    const org = lower.slice(0, slash);
+    if (org !== fileOrg) return false; // another org's, or a DS file naming any org
+    return orgComponentNames.get(org)?.has(lower.slice(slash + 1)) ?? false;
+  }
+  if (atomNames.has(lower) || dsComponentNames.has(lower)) return true;
+  return fileOrg ? (orgComponentNames.get(fileOrg)?.has(lower) ?? false) : false;
+};
 
 /**
  * THE KEY IS ONE STRING, CASE AND ALL.

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

@@ -60,8 +60,8 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
   if (t === "Ref") {
     if (typeof node.ref !== "string")
       report("error", file, `Ref needs "ref": "<atom name>" (docs/design/03)`);
-    else if (atomsDirExists && !refResolves(node.ref))
-      report("error", file, `Ref "${node.ref}". No matching atom (rx/marketplace/atoms) or shared component (rx/marketplace/components); lookup is case-insensitive by name`);
+    else if (atomsDirExists && !refResolves(node.ref, file))
+      report("error", file, `Ref "${node.ref}". No matching atom, shared component, or own-org component (bare, or "<org>/<name>" for the file's OWN org only — org-privacy); lookup is case-insensitive by name`);
     // RESOLVES IS NOT ENOUGH. Ref lookup ignores case; the marketplace fetches
     // items/<kind>/<key>.json off a case-sensitive host. A Ref that differs only in case
     // renders forever in rx/ and 404s on install (index.mjs, canonicalRef).
@@ -199,32 +199,17 @@ function walkNode(node, file, root, widthCap = null, isLayoutRoot = false) {
   // key anymore — a component writes only its own slice; templates react via select.where.
   // (Legit panel/draft setTemplateValue writes a DIFFERENT key and is untouched.)
   //
-  // The PLATFORM-DEFINED chrome keys a shared partial may write (see the exception below).
-  // Add to this only for state the SDK itself publishes and the design system must be able
-  // to answer — never for an app's own vocabulary, which is what template-local partials
-  // are for.
-  const SHARED_CHROME_KEYS = new Set(["latchDismissed"]);
   const scanAction = (a) => {
     if (!a || typeof a !== "object") return;
     if (a.type === "setTemplateValue") {
-      // A COMPONENT writes only its own slice — ANY template-state write from the
-      // shared component home is the deprecated bridge (STATE_MODEL §5b). Template-
-      // local partials (composer, suggestions) legitimately write template chrome.
-      //
-      // NARROW EXCEPTION (2026-08-13): a SHARED chrome partial may write the chrome keys
-      // named below, and nothing else. The rule's target is the deprecated FOCUS bridge —
-      // a component reaching up to move the template's state — which is why its own note
-      // above says a write to a DIFFERENT key is untouched. Some chrome is genuinely
-      // universal and belongs in the design system rather than copied into every app's
-      // folder: the composer's latch pill is one bar, shared, and its ✕ is the guest's only
-      // exit from the latch (docs/MCP_COMPLETE_GUIDE.md §The Component Latch). The list is
-      // an ALLOWLIST on purpose — it grants exactly the keys the platform defines and stays
-      // an error for everything else, so this cannot widen into "shared components may
-      // write template state".
-      if (!isTemplatePath(file) && !(Array.isArray(a.values) && a.values.length && a.values.every((v) => v && SHARED_CHROME_KEYS.has(v.key))))
-        report("error", file, `a component never writes template state: setTemplateValue is the deprecated bridge; change the view with setValue and let the template react via select.where (STATE_MODEL §5b)`);
-      else if (Array.isArray(a.values) && a.values.some((v) => v && v.key === "defaultState"))
-        report("warn", file, `setTemplateValue writing "defaultState" is the deprecated focus bridge. A component writes only its own slice; templates react via ComponentSlot.select.where (STATE_MODEL §5b)`);
+      // WHAT IS DEPRECATED IS THE FOCUS BRIDGE, not the action (2026-08-23, owner
+      // ruling). Writing `defaultState` to move the template is the bridge: a component
+      // reaching up to change which surface is shown, which the tree reacts to by name
+      // instead. Writing the template's own CHROME (openPanel, draft) is legitimate from
+      // anywhere — a `Ref`-embedded component has no slice of its own, so template state
+      // is the only state in scope, and the shared chat chrome depends on it.
+      if (Array.isArray(a.values) && a.values.some((v) => v && v.key === "defaultState"))
+        report(isTemplatePath(file) ? "warn" : "error", file, `setTemplateValue writing "defaultState" is the deprecated focus bridge. Change the view with setValue and let the template react via ComponentSlot.select.where (STATE_MODEL §5b)`);
     }
     if (a.then) scanAction(a.then);
   };