@unoverse-platform/studio 0.1.46 → 0.1.48

package/bin/studio.mjs

@@ -21,6 +21,7 @@ import { dirname, resolve, join, basename } from "path";
 import { fileURLToPath } from "url";
 import { existsSync, readdirSync } from "fs";
 import { createInterface } from "readline/promises";
+import { designHome, hasDesignHome } from "../local/design-home.mjs";
 import { createFirstProject, checkProjectName } from "../local/scaffold.mjs";
 
 const here = dirname(fileURLToPath(import.meta.url));
@@ -37,11 +38,12 @@ const appRoot = resolve(here, "..");
  * instruction; the folder says where and its name says what. The only question left is the
  * one it cannot answer for you: a folder whose name no project can carry.
  */
-/** The same walk `catalog.ts` does: the nearest folder above us holding rx/. */
+/** The same walk `catalog.ts` does: the nearest folder above us holding a design tree
+ *  (design/, or the legacy rx/). */
 function findProjectRootFromCwd() {
   for (let dir = process.cwd(); ; ) {
-    if (existsSync(join(dir, "rx"))) return dir;
-    if (existsSync(join(dir, "apps/unoverse/rx"))) return join(dir, "apps/unoverse");
+    if (hasDesignHome(dir)) return dir;
+    if (hasDesignHome(join(dir, "apps/unoverse"))) return join(dir, "apps/unoverse");
     const parent = resolve(dir, "..");
     if (parent === dir) return process.cwd();
     dir = parent;
@@ -64,7 +66,7 @@ function findProjectBelowCwd() {
   const cwd = process.cwd();
   const found = readdirSync(cwd, { withFileTypes: true })
     .filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules")
-    .filter((e) => existsSync(join(cwd, e.name, "rx")))
+    .filter((e) => hasDesignHome(join(cwd, e.name)))
     .map((e) => e.name);
 
   if (found.length === 1) return join(cwd, found[0]);
@@ -80,7 +82,7 @@ async function scaffoldIfEmpty() {
   // The same walk findProjectRoot does. A project ABOVE us is a project; do not offer to
   // make a second one inside it.
   for (let dir = cwd; ; ) {
-    if (existsSync(join(dir, "rx")) || existsSync(join(dir, "apps/unoverse/rx"))) return;
+    if (hasDesignHome(dir) || hasDesignHome(join(dir, "apps/unoverse"))) return;
     const parent = resolve(dir, "..");
     if (parent === dir) break;
     dir = parent;
@@ -122,7 +124,7 @@ async function scaffoldIfEmpty() {
     // being named or why one was needed. The name is the folder under rx/ AND the org
     // column on everything that project publishes, which is why the tool cannot pick it.
     console.log(`\n  Setting up Studio here.\n\n  ${cwd}\n`);
-    console.log(`  Your components live in rx/<project>/, and that name is the org they`);
+    console.log(`  Your components live in design/<project>/, and that name is the org they`);
     console.log(`  publish under. This folder is "${derived}", which cannot be one.\n`);
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     for (;;) {
@@ -140,7 +142,7 @@ async function scaffoldIfEmpty() {
   // publishes, so a flat rx/ could hold exactly one project and would read `components`
   // and `templates` as orgs.
   createFirstProject(home, name);
-  console.log(`\n  Created rx/${name}/, prompts/ and nodes/ in ${cwd}\n`);
+  console.log(`\n  Created design/${name}/, prompts/ and nodes/ in ${cwd}\n`);
 }
 
 await scaffoldIfEmpty();
@@ -148,7 +150,7 @@ await scaffoldIfEmpty();
 /**
  * POINT `base` AT THIS DEVELOPER'S PROJECT, before anything imports it.
  *
- * `paths.ts` snapshots its exports at import time (`export const RX_HOME = paths.rx`), so
+ * `paths.ts` snapshots its exports at import time (`export const DESIGN_HOME = paths.rx`), so
  * `setPaths()` called later updates an object nobody reads any more. The only hook that
  * lands is the environment, read by `findHome()` on first import.
  *
@@ -159,7 +161,7 @@ await scaffoldIfEmpty();
  */
 const projectRoot = findProjectRootFromCwd();
 process.env.UNOVERSE_HOME = projectRoot;
-console.log(`\n  Studio reading: ${join(projectRoot, "rx")}\n`);
+console.log(`\n  Studio reading: ${designHome(projectRoot)}\n`);
 
 const server = await createServer({
   // The APP is the vite root; the developer's project is found by walking up from the

package/local/authoring.ts

@@ -2,8 +2,8 @@
  * COMPLETION VOCABULARY for the source pane.
  *
  * THERE IS ONE LINTER, and it is not here. The rules live in
- * `@unoverse-platform/base/src/lint/rx/`, and the editor lints unsaved text by handing that
- * library an overlay (`lintDefinitions(rxHome, { overlay })`), so the squiggles a developer
+ * `@unoverse-platform/base/src/lint/design/`, and the editor lints unsaved text by handing that
+ * library an overlay (`lintDefinitions(designRoot, { overlay })`), so the squiggles a developer
  * sees are the same rules publish and CI apply. An approximation of those rules in the
  * editor would be a second linter, which is exactly what the shared library exists to
  * prevent. This file adds no rule and judges nothing.
@@ -18,6 +18,7 @@
  *
  * See docs/architecture/LOCAL_STUDIO.md §Authoring in Studio.
  */
+import { designHome } from "./design-home.mjs";
 import { resolve } from "path";
 import { existsSync, readdirSync } from "fs";
 
@@ -88,7 +89,7 @@ export function vocabulary(
 
 /** Atom names off disk, for completion of `Ref.ref`. */
 export function atomNames(projectRoot: string): { name: string }[] {
-  const dirs = [resolve(projectRoot, "rx/marketplace/atoms"), resolve(projectRoot, "rx/atoms")];
+  const dirs = [resolve(designHome(projectRoot), "marketplace/atoms"), resolve(designHome(projectRoot), "atoms")];
   const names = new Set<string>();
   for (const d of dirs) {
     if (!existsSync(d)) continue;

package/local/catalog.ts

@@ -10,6 +10,7 @@
  *
  * See docs/architecture/LOCAL_STUDIO.md.
  */
+import { hasDesignHome } from "./design-home.mjs";
 import { resolve } from "path";
 import { existsSync } from "fs";
 
@@ -41,10 +42,10 @@ export function findProjectRoot(from: string = process.cwd()): string {
   let dir = resolve(from);
   for (;;) {
     // A developer's project (starter kit): rx/ sits at the root.
-    if (existsSync(resolve(dir, "rx"))) return dir;
+    if (hasDesignHome(dir)) return dir;
     // This monorepo, where Studio's author works: rx/ lives under apps/unoverse. Same
     // shape underneath (rx/ + prompts/), just nested, so return that as the root.
-    if (existsSync(resolve(dir, "apps/unoverse/rx"))) return resolve(dir, "apps/unoverse");
+    if (hasDesignHome(resolve(dir, "apps/unoverse"))) return resolve(dir, "apps/unoverse");
     const parent = resolve(dir, "..");
     if (parent === dir) break;
     dir = parent;

package/local/design-home.d.mts

@@ -0,0 +1,2 @@
+export function designHome(root: string): string;
+export function hasDesignHome(root: string): boolean;

package/local/design-home.mjs

@@ -0,0 +1,31 @@
+// The design folder for a root, renamed `rx` → `design` (2026-08-20).
+//
+// MIGRATE-ONCE, not dual-read: a root still holding the legacy `rx/` is renamed to
+// `design/` on first resolution, and the platform knows ONE name from then on. The
+// canonical rule lives in @unoverse-platform/base `paths.ts` (`designDir`); this copy
+// exists because the plain-node entrypoints (bin/studio.mjs, scaffold.mjs) cannot
+// import base's TypeScript source. Keep the two in step.
+import { existsSync, renameSync } from "node:fs";
+import { join } from "node:path";
+
+export function designHome(root) {
+  const design = join(root, "design");
+  const legacy = join(root, "rx");
+  if (!existsSync(design) && existsSync(legacy)) {
+    try {
+      renameSync(legacy, design);
+      console.warn(`[studio] migrated ${legacy} → ${design} (rx/ is now design/)`);
+    } catch (e) {
+      console.warn(`[studio] could not rename ${legacy} → ${design} (${e.message}). Rename it by hand; Studio reads design/ only.`);
+    }
+  }
+  return design;
+}
+
+/** Does this folder hold a design tree under either name? DETECTION ONLY — the walk in
+ *  bin/studio.mjs probes arbitrary ancestor folders, and probing must never rename a
+ *  stranger's `rx/`. Migration happens in `designHome`, called only on the root a
+ *  caller actually adopts. */
+export function hasDesignHome(root) {
+  return existsSync(join(root, "design")) || existsSync(join(root, "rx"));
+}

package/local/plugin.ts

@@ -15,6 +15,7 @@
  *
  * See docs/architecture/LOCAL_STUDIO.md.
  */
+import { designHome } from "./design-home.mjs";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { resolve } from "path";
@@ -51,13 +52,13 @@ function definitionHome(
     return null;
   }
   if (/\/atoms\//.test(uri)) {
-    const flat = resolve(projectRoot, "rx/atoms", `${ref.toLowerCase()}.json`);
+    const flat = resolve(designHome(projectRoot), "atoms", `${ref.toLowerCase()}.json`);
     return existsSync(flat) ? flat : null;
   }
   const folder = c.componentFolder(ref);
   if (folder) return folder;
   // A flat, folderless component: `rx/components/<name>.json` in either tier.
-  for (const dir of [resolve(projectRoot, "rx/marketplace/components"), resolve(projectRoot, "rx/components")]) {
+  for (const dir of [resolve(designHome(projectRoot), "marketplace/components"), resolve(designHome(projectRoot), "components")]) {
     const flat = resolve(dir, `${ref.toLowerCase()}.json`);
     if (existsSync(flat)) return flat;
   }
@@ -195,7 +196,7 @@ export function localStudioHost(): Plugin {
       let nodesOnce: Promise<LocalNodes | null> | null = null;
       const nodes = () => (nodesOnce ??= loadLocalNodes(baseSrc, ssr, projectRoot));
 
-      server.config.logger.info(`\n  Studio reading: ${resolve(projectRoot, "rx")}\n`);
+      server.config.logger.info(`\n  Studio reading: ${designHome(projectRoot)}\n`);
 
       /**
        * WATCH THE PROJECT EXPLICITLY. Vite watches its own root, which is this package,
@@ -208,7 +209,7 @@ export function localStudioHost(): Plugin {
        *
        * Adding the paths puts them in the same watcher, so the existing hook fires.
        */
-      for (const dir of ["rx", "prompts"]) {
+      for (const dir of [designHome(projectRoot), resolve(projectRoot, "prompts")]) {
         const full = resolve(projectRoot, dir);
         if (existsSync(full)) server.watcher.add(full);
       }
@@ -242,7 +243,7 @@ export function localStudioHost(): Plugin {
             case path === "/local/info":
               return json(res, {
                 projectRoot,
-                rx: resolve(projectRoot, "rx"),
+                rx: designHome(projectRoot),
                 nodes: resolve(projectRoot, "nodes"),
                 envFiles: [resolve(projectRoot, "..", ".env"), resolve(projectRoot, ".env")],
               });
@@ -276,20 +277,20 @@ export function localStudioHost(): Plugin {
               // mirrors the module's real exports — tsc can't follow an ssrLoadModule path.
               type PublishItem = { kind: string; name: string; why?: string; mode?: string };
               type PublishModule = {
-                lintForPublish(rxHome: string, project: string): Promise<{ problems: unknown[]; errors: unknown[] }>;
-                collectProject(rxHome: string, project: string): unknown;
+                lintForPublish(designRoot: string, project: string): Promise<{ problems: unknown[]; errors: unknown[] }>;
+                collectProject(designRoot: string, project: string): unknown;
                 planPublish(collected: unknown, universe: string, token: string): Promise<Record<string, PublishItem[]>>;
                 sendPublish(plan: unknown, universe: string, token: string): Promise<{ sent: PublishItem[]; failed?: PublishItem[] }>;
               };
               const items = (await ssr(`${baseSrc}/items/publish.ts`)) as PublishModule;
-              const rxHome = resolve(projectRoot, "rx");
+              const designRoot = designHome(projectRoot);
 
               // LINT FIRST, ALWAYS. Nothing leaves the machine until the rules pass: a
               // developer should learn about a raw hex value here, not from an HTTP error.
-              const { problems, errors } = await items.lintForPublish(rxHome, project);
+              const { problems, errors } = await items.lintForPublish(designRoot, project);
               if (errors.length) return json(res, { blocked: true, problems, errors });
 
-              const collected = items.collectProject(rxHome, project);
+              const collected = items.collectProject(designRoot, project);
               const plan = await items.planPublish(collected, universe, token);
 
               // The screen renders kinds and names. The plan carries every file's full
@@ -424,8 +425,8 @@ export function localStudioHost(): Plugin {
               const p = String(b.path ?? "");
               if (!p || typeof b.text !== "string") return json(res, { error: "path and text are required" }, 400);
 
-              type LintModule = { lintDefinitions(rxHome: string): { problems: { level?: string; file?: string }[] } };
-              const lintMod = (await ssr(`${baseSrc}/lint/rx/index.mjs`)) as unknown as LintModule;
+              type LintModule = { lintDefinitions(designRoot: string): { problems: { level?: string; file?: string }[] } };
+              const lintMod = (await ssr(`${baseSrc}/lint/design/index.mjs`)) as unknown as LintModule;
 
               // Marked BEFORE the write, so the filesystem event can never beat the mark.
               recentSelfWrites.set(resolve(p), Date.now());
@@ -434,7 +435,7 @@ export function localStudioHost(): Plugin {
                 b.text as string,
                 writableRoots(projectRoot, c),
                 projectRoot,
-                (rxHome) => lintMod.lintDefinitions(rxHome),
+                (designRoot) => lintMod.lintDefinitions(designRoot),
               );
               return json(res, result, result.saved ? 200 : result.error === "lint errors" ? 422 : 403);
             }
@@ -454,13 +455,13 @@ export function localStudioHost(): Plugin {
 
               type LintModule = {
                 lintDefinitions(
-                  rxHome: string,
+                  designRoot: string,
                   options?: { overlay?: Record<string, string> },
                 ): { problems: { level?: string; file?: string; line?: number; msg?: string }[] };
               };
-              const lintMod = (await ssr(`${baseSrc}/lint/rx/index.mjs`)) as unknown as LintModule;
+              const lintMod = (await ssr(`${baseSrc}/lint/design/index.mjs`)) as unknown as LintModule;
               const abs = resolve(p);
-              const { problems } = lintMod.lintDefinitions(resolve(projectRoot, "rx"), { overlay: { [abs]: b.text as string } });
+              const { problems } = lintMod.lintDefinitions(designHome(projectRoot), { overlay: { [abs]: b.text as string } });
               return json(res, {
                 findings: problems.filter((f) => f.file && resolve(f.file) === abs),
                 elsewhere: problems.filter((f) => !f.file || resolve(f.file) !== abs).length,
@@ -472,7 +473,7 @@ export function localStudioHost(): Plugin {
              * linter enforces, plus this project's own token, atom and component names.
              */
             case path === "/local/vocabulary": {
-              const vocabMod = (await ssr(`${baseSrc}/lint/rx/vocabulary.mjs`)) as unknown as Parameters<typeof vocabulary>[0];
+              const vocabMod = (await ssr(`${baseSrc}/lint/design/vocabulary.mjs`)) as unknown as Parameters<typeof vocabulary>[0];
               const theme = c.resolveTheme(url.searchParams.get("theme") ?? "light");
               return json(
                 res,
@@ -517,21 +518,21 @@ export function localStudioHost(): Plugin {
                   },
                   readSource: (p) => readSource(p, writableRoots(projectRoot, c), projectRoot),
                   saveSource: async (p, text) => {
-                    type LintModule = { lintDefinitions(rxHome: string): { problems: { level?: string; file?: string }[] } };
-                    const lintMod = (await ssr(`${baseSrc}/lint/rx/index.mjs`)) as unknown as LintModule;
+                    type LintModule = { lintDefinitions(designRoot: string): { problems: { level?: string; file?: string }[] } };
+                    const lintMod = (await ssr(`${baseSrc}/lint/design/index.mjs`)) as unknown as LintModule;
                     recentSelfWrites.set(resolve(p), Date.now());
-                    return saveSource(p, text, writableRoots(projectRoot, c), projectRoot, (rxHome) =>
-                      lintMod.lintDefinitions(rxHome),
+                    return saveSource(p, text, writableRoots(projectRoot, c), projectRoot, (designRoot) =>
+                      lintMod.lintDefinitions(designRoot),
                     );
                   },
                   lintProject: async () => {
-                    type LintModule = { lintDefinitions(rxHome: string): { problems: unknown[] } };
-                    const lintMod = (await ssr(`${baseSrc}/lint/rx/index.mjs`)) as unknown as LintModule;
-                    return lintMod.lintDefinitions(resolve(projectRoot, "rx"));
+                    type LintModule = { lintDefinitions(designRoot: string): { problems: unknown[] } };
+                    const lintMod = (await ssr(`${baseSrc}/lint/design/index.mjs`)) as unknown as LintModule;
+                    return lintMod.lintDefinitions(designHome(projectRoot));
                   },
                   selection: () => selection,
                   vocabulary: async () => {
-                    const vocabMod = (await ssr(`${baseSrc}/lint/rx/vocabulary.mjs`)) as unknown as Parameters<typeof vocabulary>[0];
+                    const vocabMod = (await ssr(`${baseSrc}/lint/design/vocabulary.mjs`)) as unknown as Parameters<typeof vocabulary>[0];
                     return vocabulary(vocabMod, c.resolveTheme("light"), atomNames(projectRoot), c.listDefinitions("component") as { name?: string }[]);
                   },
                 },
@@ -632,7 +633,7 @@ export function localStudioHost(): Plugin {
      * else, which means the developer's other editor, still reloads.
      */
     handleHotUpdate({ server, file }) {
-      const watched = [resolve(projectRoot, "rx"), resolve(projectRoot, "prompts")];
+      const watched = [designHome(projectRoot), resolve(projectRoot, "prompts")];
       if (!watched.some((w) => file.startsWith(w))) return;
       const self = recentSelfWrites.get(resolve(file));
       if (self !== undefined && Date.now() - self < SELF_WRITE_WINDOW_MS) return [];
@@ -642,10 +643,10 @@ export function localStudioHost(): Plugin {
 
     configResolved() {
       // Surface a clear failure at startup rather than an empty catalog later.
-      if (projectRoot && !existsSync(resolve(projectRoot, "rx"))) {
+      if (projectRoot && !existsSync(designHome(projectRoot))) {
         throw new Error(`No rx/ folder at ${projectRoot}`);
       }
-      if (projectRoot) statSync(resolve(projectRoot, "rx"));
+      if (projectRoot) statSync(designHome(projectRoot));
     },
   };
 }

package/local/scaffold.mjs

@@ -1,7 +1,7 @@
 /**
  * Creating a project, from either end.
  *
- * A project (an "org" in rx terms) is `rx/<name>/` holding components, styles and
+ * A project (an "org") is `design/<name>/` holding components, styles and
  * templates. It is the unit a developer authors in and the unit that publishes: every row
  * that lands in a universe carries its name in the `org` column.
  *
@@ -14,6 +14,7 @@
  * See docs/architecture/LOCAL_STUDIO.md.
  */
 import { existsSync, mkdirSync, writeFileSync, cpSync, readdirSync } from "node:fs";
+import { designHome } from "./design-home.mjs";
 import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -27,7 +28,7 @@ import { fileURLToPath } from "node:url";
 export function checkProjectName(name) {
   const n = String(name ?? "").trim();
   if (!n) return "A name is required";
-  // RESERVED FIRST, so the message is the true reason. These folders under rx/ are never a
+  // RESERVED FIRST, so the message is the true reason. These folders under design/ are never a
   // developer's own project (collect.ts NOT_A_PROJECT), and a project named `marketplace`
   // would shadow the design system in every loader that resolves one. Checked before the
   // format rule because `_schema` fails that too, and "use lowercase letters" would send a
@@ -56,7 +57,7 @@ const WELCOME = [
 ].join("\n");
 
 /**
- * Create `rx/<name>/` under `home`, with its three authoring folders and one component.
+ * Create `design/<name>/` under `home`, with its three authoring folders and one component.
  *
  * Refuses an existing name rather than merging into it: "create" that silently adopts a
  * folder is how a developer ends up publishing someone else's work under their own project.
@@ -65,8 +66,8 @@ export function createProject(home, name) {
   const bad = checkProjectName(name);
   if (bad) throw new Error(bad);
 
-  const root = join(home, "rx", name);
-  if (existsSync(root)) throw new Error(`rx/${name} already exists`);
+  const root = join(designHome(home), name);
+  if (existsSync(root)) throw new Error(`${name} already exists in this workspace`);
 
   for (const d of ["components/welcome", "templates", "styles"]) mkdirSync(join(root, d), { recursive: true });
   writeFileSync(join(root, "components/welcome/welcome.yaml"), WELCOME);
@@ -74,7 +75,7 @@ export function createProject(home, name) {
 }
 
 /**
- * The FIRST project, plus the folders that live beside rx/ rather than inside it.
+ * The FIRST project, plus the folders that live beside the design tree rather than inside it.
  *
  * Skills, prompt blocks and nodes are per-developer and not per-project, so they are made
  * once here and never by `createProject`.

package/local/source.ts

@@ -22,6 +22,7 @@
  *
  * See docs/architecture/LOCAL_STUDIO.md §Authoring in Studio.
  */
+import { designHome } from "./design-home.mjs";
 import { resolve, sep, relative } from "path";
 import { existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 
@@ -163,7 +164,7 @@ export async function saveSource(
   text: string,
   roots: string[],
   projectRoot: string,
-  lint: (rxHome: string) => Promise<{ problems: LintFinding[] }> | { problems: LintFinding[] },
+  lint: (designRoot: string) => Promise<{ problems: LintFinding[] }> | { problems: LintFinding[] },
 ): Promise<SaveResult> {
   const abs = resolve(path);
   const w = writability(abs, roots, projectRoot);
@@ -183,10 +184,10 @@ export async function saveSource(
 
   writeFileSync(abs, text, "utf8");
 
-  const rxHome = resolve(projectRoot, "rx");
+  const designRoot = designHome(projectRoot);
   let problems: LintFinding[] = [];
   try {
-    problems = (await lint(rxHome)).problems ?? [];
+    problems = (await lint(designRoot)).problems ?? [];
   } catch (e) {
     // A linter that throws must not silently accept the write.
     if (previous === null) rmSync(abs, { force: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unoverse-platform/studio",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "type": "module",
   "description": "Unoverse Studio: the local authoring app. Reads your own rx/ folder, no backend.",
   "scripts": {
@@ -26,7 +26,7 @@
     "@codemirror/view": "^6.37.1",
     "@modelcontextprotocol/sdk": "^1.25.1",
     "@tailwindcss/vite": "^4.0.0",
-    "@unoverse-platform/base": "^0.3.0",
+    "@unoverse-platform/base": "^0.3.36",
     "@unoverse-platform/marketplace": "*",
     "@vitejs/plugin-react": "^4.3.4",
     "markdown-to-jsx": "^7.7.17",

package/screens/DesignSystemView.tsx

@@ -321,7 +321,7 @@ export function DesignSystemView({
           {foundation ? (
             <>Tokens with an <OverrideMark /> are <b style={{ color: ink }}>{org}</b>&rsquo;s own; the rest are inherited from the design-system foundation.</>
           ) : (
-            <>Live tokens from the design-system foundation (<code>rx/design-system/styles</code>). Toggle the theme to restyle everything.</>
+            <>Live tokens from the design-system foundation (<code>design/marketplace/styles</code>). Toggle the theme to restyle everything.</>
           )}
         </p>
         {current.body}

package/screens/TemplatesView.tsx

@@ -7,7 +7,7 @@
  * Gavin first. No exceptions: not bug fixes, not one-liners, not reverts.
  * State the intended diff and wait for an explicit yes.
  *
- * Components and templates are DATA (rx/). If a template seems to need code
+ * Components and templates are DATA (design/). If a template seems to need code
  * here, the answer is almost always to express it as data — or to ask.
  * ============================================================================
  *
@@ -532,7 +532,7 @@ export function TemplatesView({
   const seedSet = (tmpls: Def[], comps: Def[], sel: string | null): Def[] => {
     const t = tmpls.find((t) => t.name === sel);
     // The declaration lives in the app manifest (app.previewComponents); the def-level
-    // field is the legacy envelope home. Names are case-insensitive like every rx name,
+    // field is the legacy envelope home. Names are case-insensitive like every design name,
     // and each ENTRY seeds one instance — a repeated name previews several (a card rail).
     const pc = t?.app?.previewComponents ?? t?.previewComponents ?? [];
     return pc
@@ -657,7 +657,7 @@ export function TemplatesView({
       <nav className="flex min-h-0 min-w-0 flex-col overflow-auto border-r border-gray-700 bg-[#2c2c2e] p-2">
         <div className="px-2 py-1 text-[10px] font-semibold uppercase tracking-wider text-gray-400">Apps</div>
         {templates.length === 0 && (
-          <div className="p-2 text-xs text-gray-400">No apps yet — add one under rx/orgs/&lt;client&gt;/templates/.</div>
+          <div className="p-2 text-xs text-gray-400">No apps yet — add one under design/&lt;project&gt;/templates/.</div>
         )}
         {templates.map((t) => (
           <div key={`${t.org ?? ""}/${t.name}`}>

package/src/App.tsx

@@ -81,7 +81,7 @@ function Shell({
   const [foundation, setFoundation] = useState<ResolvedTheme | null>(null);
   const [error, setError] = useState<string | null>(null);
 
-  // The projects in this developer's rx/ folder. Flat, per RX_ORG_MODEL. Re-read after
+  // The projects in this developer's design/ folder. Flat, per RX_ORG_MODEL. Re-read after
   // creating one, so a new project appears without a reload.
   const loadProjects = () =>
     fetch("/dev/orgs")

package/src/NewProject.tsx

@@ -1,7 +1,7 @@
 /**
  * Creating a project from inside Studio.
  *
- * A project is `rx/<name>/`: the folder a developer authors in, and the unit that
+ * A project is `design/<name>/`: the folder a developer authors in, and the unit that
  * publishes. Until this existed, Studio could create your FIRST one (bin/studio.mjs, at
  * launch, only when the folder was empty) and never your second. The dropdown listed what
  * was on disk and offered no way to add to it, so the answer to "start another project"
@@ -51,7 +51,7 @@ export function NewProject({
       >
         <h2 className="text-base font-semibold text-gray-100">New project</h2>
         <p className="mt-1 text-xs text-gray-500">
-          Creates rx/&lt;name&gt;/ with components, styles and templates, and one component to
+          Creates design/&lt;name&gt;/ with components, styles and templates, and one component to
           open on.
         </p>
 

package/src/PublishDialog.tsx

@@ -267,7 +267,7 @@ export function PublishDialog({
                     .map((p, i) => (
                       <li key={i} className="leading-relaxed">
                         <span className="text-gray-500">
-                          {p.file?.replace(/^.*\/rx\//, "")}
+                          {p.file?.replace(/^.*\/design\//, "")}
                           {p.line ? `:${p.line}` : ""}
                         </span>
                         <br />

package/vendor/sdk/appEngine.tsx

@@ -68,7 +68,7 @@ export function AppEngine(cfg: AppConfig) {
     setBoundFor(templateId);
     setBinding({});
   }
-  // STATE-OWNED WIDTH (rx data): the layout root's `appWidth` = the core surface's
+  // STATE-OWNED WIDTH (design data): the layout root's `appWidth` = the core surface's
   // constant width; an occupied panel slot's `appWidth` adds to it (computeAppWidth).
   // No declared width → the host keeps its own default. There is no other path.
   // THE WHOLE DEFINITION, not a chosen four fields. This used to keep `{root, org, layouts,

package/vendor/sdk/lib/core/client.ts

@@ -163,7 +163,7 @@ export class UnoverseClient {
 
   /**
    * resources/read the RESOLVED theme by name (e.g. "light"). The server owns the
-   * values (rx/styles); the SDK only fetches — it bundles no tokens. Cached.
+   * values (design/styles); the SDK only fetches — it bundles no tokens. Cached.
    */
   async readTheme(name = "light"): Promise<ResolvedTheme> {
     const cached = this.themeCache.get(name);

package/vendor/sdk/lib/core/types.ts

@@ -42,7 +42,7 @@ export interface UnoverseNode {
    *  content grows (new turn or streaming text), unless the user has scrolled up. Generic
    *  scroll-container behavior, opt-in via data (e.g. the conversation state's scroll box). */
   autoScroll?: boolean;
-  /** Box: a sticky bar (its own `position: sticky` + `top` in rx) that stays HIDDEN while
+  /** Box: a sticky bar (its own `position: sticky` + `top` in the design definition) that stays HIDDEN while
    *  the element before it (its previous sibling — e.g. a hero image) is on screen, then
    *  fades in once that sibling scrolls away. Overlays the content (no flow gap). Generic
    *  scroll-reveal behavior, opt-in via data. */
@@ -203,16 +203,16 @@ export type StyleVariant = Condition & { apply: Record<string, unknown> };
 // ---- The resolved theme (SHAPE only — values live on the server) ----
 //
 // The MCP server OWNS THE VISUAL: it resolves the design tokens (apps/unoverse/
-// rx/styles) live and serves this shape at `unoverse://theme/{name}`. This is the
+// design/styles) live and serves this shape at `unoverse://theme/{name}`. This is the
 // token SHAPE, never the token VALUES — the SDK fetches the values (readTheme),
-// it does NOT bundle them. A brand change in rx/styles is therefore refresh-only,
+// it does NOT bundle them. A brand change in design/styles is therefore refresh-only,
 // exactly like a definition change (UNOVERSE_SPEC §2d-1).
 export interface ResolvedTheme {
   color: Record<string, string>;
   /** Webfont stylesheet URLs (served `fonts.stylesheets` data) — injected into
    *  document.head by the SDK (shadow roots can't register @font-face). */
   fonts?: string[];
-  /** Dimension scale (theme.space ← rx/styles/base/spacing.json) — used for BOTH spacing
+  /** Dimension scale (theme.space ← design/styles/base/spacing.json) — used for BOTH spacing
    *  (gap/padding/margin) AND element sizes (width/height), Tailwind-style. */
   space: Record<string, string>;
   radius: Record<string, string>;
@@ -227,17 +227,17 @@ export interface ResolvedTheme {
   text: Record<string, Record<string, string | number>>;
   skeleton: Record<string, unknown>;
   prose: Record<string, unknown>;
-  /** STANDARD APP SIZES (theme.appSize ← rx/styles/semantic/app-sizes.json) — the named
+  /** STANDARD APP SIZES (theme.appSize ← design/styles/semantic/app-sizes.json) — the named
    *  width blocks `appWidth` references ("chat"/"rail"/"panel" → raw host-facing CSS).
    *  Resolved by the SDK like every other token — one pipeline. */
   appSize?: Record<string, string>;
-  /** Grid behaviour (theme.grid ← rx/styles/semantic/grid) — `stackBelow`, the width
+  /** Grid behaviour (theme.grid ← design/styles/semantic/grid) — `stackBelow`, the width
    *  at which a columns grid stacks. Served: the SDK holds no threshold of its own. */
   grid?: Record<string, string>;
-  /** PAGE WIDTHS by name (theme.layout ← rx/styles/semantic/layout) — resolved by `dim()`
+  /** PAGE WIDTHS by name (theme.layout ← design/styles/semantic/layout) — resolved by `dim()`
    *  alongside the space scale, so `maxWidth: "reading"` works like any dimension. */
   layout?: Record<string, string>;
-  /** Named keyframes (theme.keyframes ← rx/styles/semantic/keyframes.json), injected
+  /** Named keyframes (theme.keyframes ← design/styles/semantic/keyframes.json), injected
    *  once per render root. Lets any definition animate via `style.animation` — no SDK edit. */
   keyframes: Record<string, Record<string, Record<string, string>>>;
   /** Named icon glyphs as SERVED DATA. The SERVER sources these from an icon pack
@@ -245,7 +245,7 @@ export interface ResolvedTheme {
    *  elements `[tag, attrs]`. The generic `Icon` leaf renders them, sized/coloured by
    *  node.style. The SDK never bundles the pack — icons are served like any token. */
   icons: Record<string, { viewBox?: string; attrs?: Record<string, unknown>; children?: [string, Record<string, unknown>][] }>;
-  /** Base render-root settings (theme.root ← rx/styles/semantic/root.json) — a CSS
+  /** Base render-root settings (theme.root ← design/styles/semantic/root.json) — a CSS
    *  object the SDK spreads onto its outermost wrapper (e.g. font-smoothing). Served,
    *  not authored: a whole-tree rendering normalization, like legacy styles/base.css. */
   root: Record<string, unknown>;

package/vendor/sdk/lib/isolate.tsx

@@ -31,7 +31,7 @@ const RESET_CSS = `
     font: inherit; letter-spacing: inherit; color: inherit; margin: 0;
   }
   /* Scrollbars hidden by default across every scroll container — scrolling still works,
-     the bar is just not painted. Generic chrome that rx can't author per-node (pseudo-
+     the bar is just not painted. Generic chrome that design definitions can't author per-node (pseudo-
      elements), so it lives with the structural reset. */
   .uno-isolate-root * { scrollbar-width: none; }
   .uno-isolate-root *::-webkit-scrollbar { width: 0; height: 0; display: none; }

package/vendor/sdk/lib/primitives.tsx

@@ -247,7 +247,7 @@ function useTextSelection(enabled: boolean) {
  * (childList change) OR streaming text (a child resizing) — but only while the user is
  * already near the bottom, so scrolling up to read history is never yanked back down.
  * NOT chat-specific: any `overflow:auto` Box can opt in. The SDK owns behaviour, never
- * styles — the scroll container itself is defined in `rx/` (the conversation state box).
+ * styles — the scroll container itself is defined in `design/` (the conversation state box).
  */
 function useAutoScrollToEnd(enabled: boolean) {
   const ref = useRef<HTMLDivElement | null>(null);
@@ -281,11 +281,11 @@ function useAutoScrollToEnd(enabled: boolean) {
 /**
  * Generic "sticky bar that reveals only once you've scrolled past the element before it"
  * (opt-in via `node.revealOnStick`). Pins the bar at the top (its own `position: sticky`
- * + `top` in `rx/`) and, using an IntersectionObserver on the bar's PREVIOUS sibling as
+ * + `top` in `design/`) and, using an IntersectionObserver on the bar's PREVIOUS sibling as
  * the sentinel (e.g. a hero image), keeps it hidden while that sibling is on screen and
  * fades it in once the sibling scrolls away. A negative margin removes the bar's flow
  * footprint so it OVERLAYS the content (no gap at the top). NOT card-specific: any sticky
- * bar can opt in. The SDK owns behaviour, never styles — the bar's look lives in `rx/`.
+ * bar can opt in. The SDK owns behaviour, never styles — the bar's look lives in `design/`.
  */
 function useRevealWhenStuck(enabled: boolean) {
   const ref = useRef<HTMLDivElement | null>(null);
@@ -415,7 +415,7 @@ export function IconView({ name, style, theme }: { name?: string; style?: Record
 
 /**
  * `Skeleton` — built-in loading placeholder. ALL dimensions are DATA, fetched
- * from the theme (theme.skeleton ← rx/styles/semantic/skeleton.json). The SDK
+ * from the theme (theme.skeleton ← design/styles/semantic/skeleton.json). The SDK
  * authors nothing here but structure (flex/full). `bars` are 'width height' pairs.
  */
 export function SkeletonView({ variant = "text", theme }: { variant?: string; theme: ResolvedTheme }): ReactNode {
@@ -680,9 +680,9 @@ export function InputView({ node, data, theme, onAction }: { node: UnoverseNode;
  * markdown-to-jsx overrides for the `Markdown` primitive.
  *
  * ⛔ AUTHORS ZERO STYLE VALUES. Every element style is read verbatim from the
- *    SERVED prose recipe (`theme.prose` ← rx/styles/semantic/prose.json). The SDK
+ *    SERVED prose recipe (`theme.prose` ← design/styles/semantic/prose.json). The SDK
  *    only maps element → recipe key and supplies BEHAVIOUR (target=_blank, image
- *    error-fallback). No hex, no px/rem, no weights here — they live in rx/.
+ *    error-fallback). No hex, no px/rem, no weights here — they live in design/.
  *
  * Built once per theme (stable component identities so streaming re-renders don't
  * remount images and drop their broken-state).
@@ -734,7 +734,7 @@ function buildMarkdownOverrides(theme: ResolvedTheme, inheritLinkColor = false)
     // INLINE MARKS and BLOCKS. Authored copy uses all of these (a bolded access code, a
     // rule between sections, a quoted term), and an element absent from this map renders
     // at the browser's default — the one place a definition's look escapes the token
-    // layer. Each maps to a served recipe key; the VALUES live in rx/styles/semantic/prose.
+    // layer. Each maps to a served recipe key; the VALUES live in design/styles/semantic/prose.
     strong: { props: { style: s("strong") } },
     em: { props: { style: s("emphasis") } },
     del: { props: { style: s("strikethrough") } },

package/vendor/sdk/lib/render.tsx

@@ -12,7 +12,7 @@
  *  `Button` (and its styling logic) kept leaking back into the dispatcher.
  *
  *  THE FRAMEWORK IN ONE SENTENCE: this SDK is a FIXED, GENERIC interpreter. ALL
- *  UX is built in DATA (rx/ definitions + the served theme) — an author creates
+ *  UX is built in DATA (design/ definitions + the served theme) — an author creates
  *  ANY interface WITHOUT editing this SDK. (See FRAMEWORK.md.)
  *
  *  WHERE THINGS LIVE:
@@ -30,7 +30,7 @@
  *
  *  Need something the vocab can't express? Prefer extending the generic interpreter
  *  ONCE (a new style-vocab key in ./style, a new model projection) over a primitive.
- *  You almost never need to touch this file — build it in rx/ first.
+ *  You almost never need to touch this file — build it in design/ first.
  * ════════════════════════════════════════════════════════════════════════════
  */
 import type { ReactNode } from "react";

package/vendor/sdk/lib/style.ts

@@ -1,7 +1,7 @@
 /**
  * The style + animation INTERPRETER — neutral vocab → CSS, resolving token NAMES
  * against a theme FETCHED from the server. ⛔ OWNS ZERO STYLE VALUES (no hex, no
- * px/rem/em, no recipes); every value lives in rx/styles and is served. See
+ * px/rem/em, no recipes); every value lives in design/styles and is served. See
  * FRAMEWORK.md and render.tsx's header. Enforced by test/golden-rule.test.mjs.
  */
 import type { CSSProperties } from "react";
@@ -227,10 +227,10 @@ export function cssDecls(css: CSSProperties, important = false): string {
 }
 
 /**
- * Serialize the SERVED keyframes (theme.keyframes ← rx/styles/semantic/keyframes.json)
+ * Serialize the SERVED keyframes (theme.keyframes ← design/styles/semantic/keyframes.json)
  * into a CSS string, injected ONCE per render root (<style>). This authors zero values —
  * it only structures DATA into `@keyframes uno-<name>{ <stop>{ <prop>:<val> } }`. Adding a
- * new animation = adding a keyframe to rx/ + a `style.animation` ref in a definition. No
+ * new animation = adding a keyframe to design/ + a `style.animation` ref in a definition. No
  * SDK edit, no new primitive. Keyframe decls use real CSS prop names, KEBAB-CASE
  * (`box-shadow`, never `boxShadow`) — that is the canonical authored form, lint-enforced.
  * Property keys are still kebab-normalized here, exactly as Studio's gallery serializer

package/vendor/sdk/lib/template.tsx

@@ -179,7 +179,7 @@ export function StreamedUnoverseTemplate({ client, store, uri, onAction, theme:
    * THE LATCH, PUBLISHED FOR CHROME (docs/MCP_COMPLETE_GUIDE.md §The Component Latch).
    *
    * `resolveLatch` derives WHICH instance the conversation addresses; the composer's pill
-   * is ordinary rx chrome, so it needs those facts as template state to bind against. Same
+   * is ordinary design chrome, so it needs those facts as template state to bind against. Same
    * shape as the voice service (§4 "services feed the state"): a producer writes derived
    * values into the normal bucket, and `core` learns no UI concept — nothing here knows a
    * pill exists.
@@ -328,7 +328,7 @@ export function StreamedUnoverseTemplate({ client, store, uri, onAction, theme:
 
   // Timeline — GENERIC iterator. Walks the timeline and renders the `user` / `assistant`
   // DATA sub-tree per turn. Zero chat UX in the SDK: bubbles, alignment, structure all live
-  // in those sub-trees (rx/templates/chatlayout/*.json). The assistant sub-tree's ComponentSlot
+  // in those sub-trees (design/templates/chatlayout/*.json). The assistant sub-tree's ComponentSlot
   // is scoped to THAT turn's components.
   const resolveTimeline = (node: UnoverseNode, key?: React.Key): ReactNode => {
     return (

package/vendor/sdk/lib/theme.ts

@@ -2,8 +2,8 @@
  * useUnoverseTheme — fetch the RESOLVED theme from the MCP server by name.
  *
  * The SDK owns ZERO token values. The server owns the visual (apps/unoverse/
- * rx/styles, resolved live) and serves it at `unoverse://theme/{name}`; this hook
- * fetches it (cached in the client). A brand change in rx/styles is refresh-only
+ * design/styles, resolved live) and serves it at `unoverse://theme/{name}`; this hook
+ * fetches it (cached in the client). A brand change in design/styles is refresh-only
  * — there is no baked theme in this bundle to rebuild (UNOVERSE_SPEC §2d-1).
  */
 import { useEffect, useState } from "react";

package/vendor/skills/unoverse-create/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: unoverse-create
-description: Create or edit Unoverse platform artifacts: UI components (including briefed/AI-filled components), templates, atoms and styles (rx/), brand and org packs (themes, tokens, rebranding, cloning a universe for a new client), agent skills and prompt blocks (prompts/), custom workflow nodes (nodes/), and workflows built live on the Canvas via the builder MCP. Use whenever the user wants to create, add, build, or modify a component, template, card, page, theme, brand, org pack, agent skill, prompt block, custom node, or workflow in an Unoverse project, even if they don't say "Unoverse" (they'll describe UI like "a card with a button and an image" or "a page the AI fills in").
+description: "Create or edit Unoverse platform artifacts: UI components (including briefed/AI-filled components), templates, atoms and styles (design/), brand and org packs (themes, tokens, rebranding, cloning a universe for a new client), agent skills and prompt blocks (prompts/), custom workflow nodes (nodes/), and workflows built live on the Canvas via the builder MCP. Use whenever the user wants to create, add, build, or modify a component, template, card, page, theme, brand, org pack, agent skill, prompt block, custom node, or workflow in an Unoverse project, even if they don't say 'Unoverse' (they'll describe UI like 'a card with a button and an image' or 'a page the AI fills in')."
 ---
 
 # Creating Unoverse Artifacts
@@ -10,7 +10,7 @@ the platform reads.
 
 | Folder | What lives there |
 |---|---|
-| `rx/` | **Design** (data, not code): per-project components, templates + styles; each project is `rx/<project>/` |
+| `design/` | **Design** (data, not code): per-project components, templates + styles; each project is `design/<project>/` |
 | `prompts/` | **Behavior**: agent skills (`skills/`) + prompt blocks (`blocks/`) |
 | `nodes/` | **Logic**: custom workflow nodes, authored as YAML |
 
@@ -19,7 +19,7 @@ that is the workspace folder itself; in the platform monorepo it is `apps/unover
 
 ## Step 0: Anchor in the project before writing
 
-1. **Pick the right `rx/<project>/`.** Every design artifact belongs to a project (an
+1. **Pick the right `design/<project>/`.** Every design artifact belongs to a project (an
    "org"). If the workspace has more than one, or the only one looks like a placeholder,
    ask which project the artifact belongs to. Never invent a new project folder to hold
    one artifact.
@@ -29,7 +29,7 @@ that is the workspace folder itself; in the platform monorepo it is `apps/unover
    authoring MCP: `listDefinitions` (kind `atom` / `component`, org `marketplace`),
    `readDefinition` for a full definition, `getVocabulary` for the closed node/style
    vocabulary. Compose those atoms; never hand-roll a shape the design system already
-   ships. (In the platform monorepo the same material is on disk at `rx/marketplace/`.)
+   ships. (In the platform monorepo the same material is on disk at `design/marketplace/`.)
 
 ## Step 1: Identify the artifact, read its playbook
 
@@ -108,7 +108,7 @@ messages; justify any warning), and the conformance checklist is
 | Artifact | To see it live |
 |---|---|
 | Component / atom / template / style | Preview in Studio (`unoverse studio`), then publish from Studio: the publish lint gates it |
-| Existing component restyle/edit only | takes effect live (the SDK reads `rx/` directly) |
+| Existing component restyle/edit only | takes effect live (the SDK reads `design/` directly) |
 | Agent skill / prompt block | publish from Studio, same gate |
 | Node | Studio's Nodes screen: Load sample → Run. A node is YAML; running it is the only proof (no build) |
 
@@ -120,4 +120,4 @@ Verify the platform with `unoverse check` (services, schema, environment).
 
 > In the platform monorepo (not a developer workspace), the project root is
 > `apps/unoverse/`, the docs source is `packages/docs/`, and the dev loop is
-> `npm run dev`. Component nodes synthesize from rx/ definitions at boot.
+> `npm run dev`. Component nodes synthesize from design/ definitions at boot.

package/vendor/skills/unoverse-create/references/brand.md

@@ -13,7 +13,7 @@ client. They share one discipline and one failure mode.
 
 ## 1. How overriding actually works: name a token to override, omit it to inherit
 
-`rx/marketplace/styles` is the **foundation**: the shared token contract every org
+`design/marketplace/styles` is the **foundation**: the shared token contract every org
 inherits. Your org pack is read **on top** of it.
 
 The server builds a theme in three passes (`buildTheme`, in the platform's theme
@@ -45,8 +45,8 @@ re-copying anything.
 
 | Pack | `styles/base/` holds |
 |---|---|
-| Foundation (`rx/marketplace/`) | `border` `color` `motion` `radius` `shadow` `spacing` `typography` |
-| A brand (`rx/bpp/`) | `color` `typography` **only** |
+| Foundation (`design/marketplace/`) | `border` `color` `motion` `radius` `shadow` `spacing` `typography` |
+| A brand (`design/bpp/`) | `color` `typography` **only** |
 
 BPP names two files and inherits the other five. That ratio is the health check: a pack
 redefining `spacing` or `radius` is not branding, it is forking. The neutral core is
@@ -57,7 +57,7 @@ redefining `spacing` or `radius` is not branding, it is forking. The neutral cor
 An org is a folder. There is no registry to edit and nothing to declare.
 
 ```
-rx/<neworg>/
+design/<neworg>/
   styles/
     base/color.yaml          brand INGREDIENTS (color.brand.*)
     base/typography.yaml     font families only
@@ -85,10 +85,10 @@ you genuinely differ.
 
 Its theme is then served at `unoverse://theme/<neworg>/light`, and a template points at it.
 
-## 4. Anatomy of an org pack (`rx/<org>/styles/`)
+## 4. Anatomy of an org pack (`design/<org>/styles/`)
 
 Read an installed org pack as the worked example (Studio MCP `listOrgs` →
-`listDefinitions`; in the platform monorepo, `rx/bpp/styles/`). Every file in a healthy
+`listDefinitions`; in the platform monorepo, `design/bpp/styles/`). Every file in a healthy
 pack carries a `$description` explaining its own job, and those descriptions are the spec.
 
 | File | Holds | Rule |
@@ -128,7 +128,7 @@ naming your situation is the intended answer.
 Copying an org pack is mechanical, and every gotcha is a name that exists in more than one
 place. Work through them in order.
 
-1. **Copy the folder.** `rx/<source>/` → `rx/<neworg>/`, keeping `styles/`, `components/`,
+1. **Copy the folder.** `design/<source>/` → `design/<neworg>/`, keeping `styles/`, `components/`,
    `templates/`.
 2. **Rename the templates.** Folder AND the id inside the manifest. `bpp-chat-layout`
    becomes `lyceum-chat-layout` in both places. Template ids are org-qualified and they
@@ -145,7 +145,7 @@ place. Work through them in order.
 
 ## 7. Done means all four
 
-- `grep -ri "<oldorg>" rx/<neworg>/` returns **nothing**. This is the check that catches
+- `grep -ri "<oldorg>" design/<neworg>/` returns **nothing**. This is the check that catches
   the id someone missed at midnight, and it is the one people skip.
 - The new org appears in **Studio's universe dropdown** and its theme renders.
 - **Studio's publish lint: 0 errors.** Justify any warning out loud.

package/vendor/skills/unoverse-create/references/component.md

@@ -1,4 +1,4 @@
-# Playbook: Components & Atoms (rx data)
+# Playbook: Components & Atoms (design data)
 
 **Read first:** [design/components](https://docs.unoverse.ai/design/components.md) (the
 microapp anatomy) + [design/state](https://docs.unoverse.ai/design/state.md) (the state
@@ -9,12 +9,12 @@ model). Deep law: [UNOVERSE_AUTHORING](https://docs.unoverse.ai/unoverse/UNOVERS
 below; for a full worked component, read an installed one through Studio's MCP
 (`listDefinitions` kind `component`, then `readDefinition`), and prefer a rich
 multi-state one over a starter stub. (In the platform monorepo the canonical exemplar
-is on disk: `rx/sab/components/product-card`.)
+is on disk: `design/sab/components/product-card`.)
 
 ## The anatomy
 
 ```
-rx/<project>/components/<name>/
+design/<project>/components/<name>/
   <name>.yaml      # ROOT: envelope (name/category/nodeSize/outputs/props) + the STATE TREE + root
   manifest.yaml    # RENDER CONTRACT + discovery meta (title / description ≤120 /
                    #   whenToUse utterance-shaped). Presence = spatially discoverable;
@@ -142,7 +142,7 @@ The rules, in the order they bite:
    questions sharing one shape are one `question` state whose data changes, never seven
    files (LAYERS §4, §7).
 5. **Atoms** (the installed design system's shared shapes, used via `Ref`; list them with
-   Studio's MCP `listDefinitions` kind `atom`, or on disk at `rx/marketplace/atoms/` in the
+   Studio's MCP `listDefinitions` kind `atom`, or on disk at `design/marketplace/atoms/` in the
    platform monorepo) are for shapes shared across components, authoring-time
    only (the server expands them before serving; no Studio view). `Ref props` remaps FIELDS;
    **`Ref with` passes LITERALS**: `{ "type": "Ref", "ref": "button", "with": { "label":
@@ -176,7 +176,7 @@ The rules, in the order they bite:
    [UNOVERSE_AUTHORING](https://docs.unoverse.ai/unoverse/UNOVERSE_AUTHORING.md) §3c). When a component needs data the
    workflow did not send (not from an AI = brief, not from the workflow = `input` props),
    it declares CALLS that the platform runs at a platform-owned fire point. **No code**:
-   a hook is data like everything else in `rx/`. It's for DATA, not styling or logic.
+   a hook is data like everything else in `design/`. It's for DATA, not styling or logic.
    - **Two phases**: `onStart` (the instance is created: data every copy needs) and
      `onEnterView` (the instance entered a named STATE: data only that state needs). A
      detail view's content is `onEnterView`, NEVER `onStart` — hydrating at creation
@@ -210,7 +210,7 @@ The rules, in the order they bite:
    - **`allowedHosts` in the manifest is NOT optional**: a hook that makes requests
      without it is a lint ERROR (deny by default). Credentials are named by type in the
      manifest and resolved server-side from encrypted storage; **a key never sits in
-     `rx/`** (a shared design folder) and never reaches the client.
+     `design/`** (a shared design folder) and never reaches the client.
    - A phase fires once per instance; enrichment streams in (no blocked render); errors
      fail quietly, leaving whatever the card already had.
 
@@ -271,7 +271,7 @@ component. Its key nouns/verbs must appear in `whenToUse`'s first sentence.
 ## Workflow
 
 1. Study the closest installed exemplar (Studio MCP `listDefinitions` → `readDefinition`;
-   monorepo: `rx/sab/components/product-card`); copy its folder shape.
+   monorepo: `design/sab/components/product-card`); copy its folder shape.
 2. Declare the state tree first: public states on top, steps nested, each state owning
    its layout (same-name default, `layout:` only when the filename differs).
 3. Write the envelope + manifest + layouts; root = `Switch on view`; every shown thing

package/vendor/skills/unoverse-create/references/template.md

@@ -8,7 +8,7 @@
 Everything in the component playbook (closed vocabulary, tokens, scale steps) applies
 here too. **Study an exemplar before writing**: read the closest installed template
 through Studio's MCP (`listDefinitions` kind `template` → `readDefinition`); the
-canonical manifest tree is inlined below. (Monorepo: `rx/sab/templates/sab-chat-layout`.)
+canonical manifest tree is inlined below. (Monorepo: `design/sab/templates/sab-chat-layout`.)
 
 ## THE model: the component drives; the template reacts by name
 
@@ -68,7 +68,7 @@ states:
 ## The anatomy: manifest-only (NO `<name>.yaml` envelope)
 
 ```
-rx/<project>/templates/<name>/
+design/<project>/templates/<name>/
   manifest.yaml    # THE ENVELOPE: the whole app contract, incl. the states tree
   layouts/         # the ARRANGEMENTS: one per state that owns one (same-name default)
     main.yaml      #   the base: the core alone
@@ -159,7 +159,7 @@ template states by name exactly as in chat. Audio is never wired in a definition
 
 ## New project?
 
-`rx/<project>/` = `templates/` + optional `components/` (project-private microapps;
+`design/<project>/` = `templates/` + optional `components/` (project-private microapps;
 names unique within the project and never shadowing a marketplace name; two projects
 may share a name, each addressed `<org>/<name>`) + `styles/` holding ONLY the org's
 overrides (the foundation cascades per token; the theme file is the one you copy

package/vendor/skills/unoverse-prompt-component/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: unoverse-prompt-component
-description: Build or audit a PROMPT component (a briefed, AI-filled Unoverse component) in rx/. Use when adding brief tags, deciding which props an agent may fill, debugging a part the agent never fills or fills wrongly, or checking what a component's MCP tool schema actually contains. Covers the traps that silently discard an authored brief.
+description: Build or audit a PROMPT component (a briefed, AI-filled Unoverse component) in design/. Use when adding brief tags, deciding which props an agent may fill, debugging a part the agent never fills or fills wrongly, or checking what a component's MCP tool schema actually contains. Covers the traps that silently discard an authored brief.
 ---
 
 # Prompt components: the parts an agent fills
 
-A prompt component is an ordinary `rx/` component whose bound nodes carry `brief` tags.
+A prompt component is an ordinary `design/` component whose bound nodes carry `brief` tags.
 The platform compiles those tags into the component's **MCP tool schema**, and that schema
 is the only instruction channel: no side-channel prompt, no per-component agent skill.
 `unoverse-create` covers authoring components in general; this skill is about the briefs.
@@ -29,8 +29,8 @@ rm -f verify.tmp.ts
 ```
 
 It prints every part the agent can fill, its description, and its limits. Read that
-output, not the YAML. Then run the rx lint
-(`node -e "import('./packages/base/src/lint/rx/index.mjs').then(m=>{const r=m.lintDefinitions();console.log(r.problems.length);r.problems.forEach(p=>console.log(p.level,p.file,p.msg))})"`).
+output, not the YAML. Then run the design lint
+(`node -e "import('./packages/base/src/lint/design/index.mjs').then(m=>{const r=m.lintDefinitions();console.log(r.problems.length);r.problems.forEach(p=>console.log(p.level,p.file,p.msg))})"`).
 
 In a **Studio developer workspace**, the same linter runs as Studio's publish lint (or
 the authoring MCP's `lintProject` tool); it catches two of the five traps below by