@unoverse-platform/studio 0.1.45 → 0.1.47

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/mcp.ts

@@ -63,7 +63,11 @@ export interface McpDeps {
   vocabulary: () => Promise<unknown>;
 }
 
-const SKILL_DIRS = ["vendor/skills/unoverse-create", "../../prompts/skills/unoverse-create"];
+const SKILL_DIRS = [
+  "vendor/skills/unoverse-create",
+  "../../.claude/skills/unoverse-create", // running from source: the authoring home
+  "../../prompts/skills/unoverse-create",
+];
 
 /** The vendored authoring skill, which is how an agent learns the rules before writing. */
 function authoringSkill(appRoot: string): string {

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`.
@@ -85,7 +86,10 @@ export function createFirstProject(home, name) {
 
   // The Claude Code authoring skills, so "open the folder and describe what you want"
   // works in every Studio project from its first minute. Vendored into the published
-  // app (vendor/skills, written by prepack); read from the repo when running as source.
+  // app (vendor/skills, written by prepack from the monorepo's .claude/skills, the one
+  // authoring home, mirrored publicly to github.com/unoverse-platform/skills); read
+  // from that home when running as source. `unoverse update` refreshes installed
+  // copies from the public mirror.
   //
   // ALL of them. One Studio project is where a person designs a brand AND writes the node
   // behind it, so they need the whole set: naming one skill here shipped the authoring

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.45",
+  "version": "0.1.47",
   "type": "module",
   "description": "Unoverse Studio: the local authoring app. Reads your own rx/ folder, no backend.",
   "scripts": {

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; }