@unoverse-platform/studio 0.1.109 → 0.1.111

package/vendor/base/src/definitions/registry/homes.ts

@@ -48,7 +48,8 @@ const INSTALLED_DESIGN = designDir(INSTALLED_HOME);
 
 /** The shared homes for the universal kinds — the marketplace.
  *
- * Resolve each shared dir from the on-disk design/marketplace (monorepo dev) if present,
+ * Resolve each shared dir from the on-disk tier (paths.ts `marketplace`: the monorepo's
+ * packages/marketplace/definitions, so a local universe reads it live) if present,
  * else from a bundle beside the home node, else from what this universe INSTALLED (rows,
  * hydrated). Mirrors theme.ts's styles fallback, and the getters resolve LAZILY so a tier
  * that appears after boot is picked up on first use.
@@ -62,7 +63,7 @@ const INSTALLED_DESIGN = designDir(INSTALLED_HOME);
  * server and Canvas — "they do not carry components, atoms, styles, skills, prompt blocks
  * or nodes, all of which are rows". A dead path that would silently adopt an npm tree if
  * one ever appeared is worse than no path. */
-const MARKETPLACE = join(DESIGN, "marketplace");
+const MARKETPLACE = getPaths().marketplace;
 const DS_BUNDLE_CANDIDATES: string[] = [];
 function marketplaceDir(kind: "components" | "atoms" | "templates" | "objects" | "pipelines"): string {
   const onDisk = join(MARKETPLACE, kind);
@@ -105,6 +106,15 @@ export const SHARED_DIR = {
   },
 } as Record<"component" | "atom" | "template" | "object" | "pipeline", string>;
 
+/** The marketplace tier's own folder, for what is not one of the kinds above (its shared
+ *  `assets/`): on disk when this checkout authors it, else what this universe installed.
+ *  The same order `projectDir` applies to an org. */
+export function marketplaceHome(): string {
+  const installed = join(INSTALLED_DESIGN, "marketplace");
+  if (databaseOnly()) return installed;
+  return existsSync(MARKETPLACE) ? MARKETPLACE : installed;
+}
+
 // rx-root entries that are NOT projects: the marketplace, the schema, and the legacy
 // orgs/ container itself. Everything else at the root is a flat project (the target model).
 const RESERVED_DESIGN = new Set(["marketplace", "_schema"]);
@@ -181,7 +191,7 @@ export function appDirs(refOrg: string | null): { org: string; dir: string }[] {
 
 /** The TEMPLATE homes a ref resolves against — the Template Model's kind
  *  (docs/unoverse/UNOVERSE_TEMPLATE_MODEL.md). Two tiers like components: the
- *  marketplace shelf (`design/marketplace/templates`, the BASE shapes) and the
+ *  marketplace shelf (`packages/marketplace/definitions/templates`, the BASE shapes) and the
  *  org packs (`design/<org>/templates`). The word is free in code because the app
  *  kind's in-code name is `app` (rename finished in code 2026-08-28; stored words
  *  unchanged until their own migration). */
@@ -194,7 +204,7 @@ export function templateDirs(refOrg: string | null): { org: string | undefined;
 }
 
 /** The OBJECT homes a ref resolves against (docs/unoverse/data/objects/README.md): the same two
- *  tiers as components, the marketplace (`design/marketplace/objects`, the platform's kinds,
+ *  tiers as components, the marketplace (`packages/marketplace/definitions/objects`, the platform's kinds,
  *  and `need`, the atom every object extends) and the org packs (`design/<org>/objects`, an
  *  org's own kinds). An org-qualified ref searches its org first, then the marketplace, so
  *  `extends: need` resolves from an org's object; a bare ref searches the marketplace first. */
@@ -207,7 +217,7 @@ export function objectDirs(refOrg: string | null): { org: string | undefined; di
 }
 
 /** The PIPELINE homes a ref resolves against (docs/unoverse/data/pipelines/README.md layer 1): the marketplace
- *  (`design/marketplace/pipelines`, the sources everyone gets: website, spreadsheet, images) and
+ *  (`packages/marketplace/definitions/pipelines`, the sources everyone gets: website, spreadsheet, images) and
  *  the org packs (`design/<org>/pipelines`, a source nobody else has). Same order as objects. */
 export function pipelineDirs(refOrg: string | null): { org: string | undefined; dir: string }[] {
   const shared = { org: undefined as string | undefined, dir: SHARED_DIR.pipeline };

package/vendor/base/src/definitions/registry/objects.ts

@@ -13,7 +13,7 @@
  *   objects/<name>/api/service.yaml the object's public functions by name (getDetail, searchDetail), as a
  *                                  service node's tools; found by name, declared nowhere else
  *
- * in two tiers, the marketplace's (`design/marketplace/objects/`, shared by every org) and an
+ * in two tiers, the marketplace's (`packages/marketplace/definitions/objects/`, shared by every org) and an
  * org's own (`design/<org>/objects/`). `extends` names another object and is resolved here,
  * across the tiers, never as a path: the base's props compose under the object's own, later
  * keys over earlier. `need` is the atom every other positioned object extends (owner ruling

package/vendor/base/src/definitions/registry/orgDocuments.ts

@@ -4,7 +4,7 @@
  *
  * Four objects in the marketplace pack say the SHAPE, brief by brief:
  *
- *   design/marketplace/objects/<doc>/   organisation, brand, purpose, story
+ *   packages/marketplace/definitions/objects/<doc>/   organisation, brand, purpose, story
  *
  * and the org's pack holds its ANSWERS, one instance a file, in the one grammar:
  *
@@ -71,7 +71,7 @@ export function instanceText(doc: OrgDocument, values: Record<string, unknown> =
   if (!object) throw new Error(`identity/${doc}: no object named ${doc} in any tier`);
   const props: Record<string, { default: unknown }> = {};
   for (const [name, p] of writable(object)) props[name] = { default: name in values ? values[name] : emptyValue(p.type) };
-  const head = `# The org's ${doc}: its own words, and only those. The briefs, the limits and the shape are the\n# ${doc} object's (design/marketplace/objects/${doc}/); this file carries the answers as defaults.\n`;
+  const head = `# The org's ${doc}: its own words, and only those. The briefs, the limits and the shape are the\n# ${doc} object's (packages/marketplace/definitions/objects/${doc}/); this file carries the answers as defaults.\n`;
   return head + stringify({ unoverse: "1.0", type: "identity", extends: doc, props }, { lineWidth: 100 });
 }
 

package/vendor/base/src/definitions/registry/orgPack.ts

@@ -16,12 +16,13 @@
  *                         semantic tokens are INHERITED at resolve time (an org is a theme)
  *
  * Shapes (ruled 2026-09-08): each identity file is an INSTANCE of its marketplace object
- * (design/marketplace/objects/<doc>/), the one grammar with `extends: <doc>` and props
+ * (the marketplace tier's objects/<doc>/), the one grammar with `extends: <doc>` and props
  * carrying `default` only. The briefs are the object's. Nothing is invented: the defaults
  * are empty until a writer fills them from the org's own sources.
  */
 import { cpSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { getPaths } from "../../paths.js";
 import { ORG_DOCUMENTS, instanceText } from "./orgDocuments.js";
 
 export const ORG_SLUG = /^[a-z][a-z0-9-]{0,63}$/;
@@ -34,7 +35,7 @@ export function createOrgPack(designHome: string, slug: string, name: string): s
   if (!ORG_SLUG.test(slug)) throw new Error("slug: lowercase letters, digits and hyphens, starting with a letter");
   const dest = join(designHome, slug);
   if (existsSync(dest)) throw new Error(`design/${slug} already exists`);
-  const themes = join(designHome, "marketplace", "styles", "themes");
+  const themes = join(getPaths().marketplace, "styles", "themes");
   if (!existsSync(themes)) throw new Error("the marketplace theme foundation is missing; cannot seed the org's themes");
 
   mkdirSync(join(dest, "apps"), { recursive: true });

package/vendor/base/src/definitions/registry/pipelines.ts

@@ -15,7 +15,7 @@
  *   pipelines/<name>/interface.yaml  the pipeline as a node on a canvas: signal in, rows out
  *   pipelines/<name>/test.yaml       the collect steps faked, the rows asserted
  *
- * in two tiers, the marketplace's (`design/marketplace/pipelines/`) and an org's own
+ * in two tiers, the marketplace's (`packages/marketplace/definitions/pipelines/`) and an org's own
  * (`design/<org>/pipelines/`). Nodes are the only way a pipeline touches the world: no HTTP,
  * no credentials, no hosts in the file; the nodes it names carry them.
  *

package/vendor/base/src/definitions/theme.ts

@@ -36,9 +36,8 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 // VALUES are each org's own — that's how two clients get different fonts/colors/spacing
 // from the same components, without re-copying the foundation.
 import { listOrgs, projectDir } from "./definitions.js";
-import { PLUGINS_DIR, DESIGN_HOME, INSTALLED_HOME, databaseOnly, designDir } from "../paths.js";
+import { PLUGINS_DIR, MARKETPLACE_HOME, INSTALLED_HOME, databaseOnly, designDir } from "../paths.js";
 
-const DESIGN = DESIGN_HOME;
 export const DEFAULT_ORG = "default";
 
 /** The styles dir for a project, or null if it has none. `projectDir` resolves the
@@ -51,11 +50,11 @@ function orgStyles(org: string): string | null {
 /**
  * The marketplace FOUNDATION — base + semantic + default themes, the shared token
  * contract every org inherits (buildTheme's fallback layer) AND the `default` theme set
- * itself. Its home is now `rx/marketplace/styles` (the honest marketplace folder, no
- * longer an org costume under `orgs/default`). Resolution mirrors `findDesignComponentsDir`:
+ * itself. Its home is the marketplace tier's `styles/` (paths.ts `marketplace`; no longer
+ * an org costume under `orgs/default`). Resolution mirrors `findDesignComponentsDir`:
  * the on-disk marketplace dir wins (dev/local), else the bundled package — the monorepo
  * home node, then the installed marketplace package. This lets the foundation ship WITH
- * the package (no `rx/marketplace` on disk) once purged from the image (Phase 4).
+ * the package (no marketplace tier on disk) once purged from the image (Phase 4).
  */
 const DS_STYLES_CANDIDATES = [
   join(PLUGINS_DIR, "node_modules", "@unoverse-platform", "marketplace", "definitions", "styles"),
@@ -80,7 +79,7 @@ function foundationStyles(): string | null {
   // Under the switch the authored tiers are skipped, so what a deployed universe would
   // resolve is what a developer resolves. Same shape as `marketplaceDir`.
   if (databaseOnly()) return existsSync(INSTALLED_STYLES) ? INSTALLED_STYLES : null;
-  const designDs = join(DESIGN, "marketplace", "styles");
+  const designDs = join(MARKETPLACE_HOME, "styles");
   if (existsSync(designDs)) return designDs; // on-disk marketplace wins (dev/local)
   for (const c of DS_STYLES_CANDIDATES) if (existsSync(c)) return c;
   // SEARCHED LAST, so anything on disk still wins — the same precedence the node loader

package/vendor/base/src/items/baseVersion.ts

@@ -67,7 +67,7 @@ function packageVersion(designSystemDir: string): string | null {
 
 /**
  * Compute the version of the design system at `designSystemDir` (the resolved marketplace
- * directory: on-disk design/marketplace, or the installed bundle).
+ * directory: the tier on disk, or the installed bundle).
  *
  * Hashes components, atoms and styles together, because they only mean anything as a set:
  * a universe holding half of them renders against a contract with holes.

package/vendor/base/src/items/collect.ts

@@ -300,7 +300,7 @@ function collectFrom(root: string, project: string, designSystem: string): Colle
   // 2026-09-08 it looked at a `nodes/` folder beside design/ while every org already
   // kept its nodes INSIDE its project, so the same nodes were left behind again. Org
   // nodes are org-scoped like skills; the marketplace tier's own nodes sit under
-  // design/marketplace/, which is never collected.
+  // the marketplace tier, which is never collected.
   const nodesHome = join(root, "nodes");
   if (existsSync(nodesHome)) {
     for (const pkg of collectNodePackages(nodesHome)) {

package/vendor/base/src/lint/design/file.mjs

@@ -175,7 +175,7 @@ function checkAppTree(json, root, file) {
             if (ref.includes("/"))
               report("error", file, `state "${where}" preview names "${ref}" with an org prefix. Studio seeds a preview by the component's bare name ("${ref.split("/").pop()}"); a prefixed name resolves to nothing and the state's tab shows nothing (docs.unoverse.ai/design/apps)`);
             else if (comps && !comps.has(ref.toLowerCase()))
-              report("error", file, `state "${where}" preview names "${ref}", which is no component or template this org can see (design/marketplace/, this org's components/ and templates/). Studio would seed nothing and the state's tab would show nothing (docs.unoverse.ai/design/apps)`);
+              report("error", file, `state "${where}" preview names "${ref}", which is no component or template this org can see (the marketplace's, this org's components/ and templates/). Studio would seed nothing and the state's tab would show nothing (docs.unoverse.ai/design/apps)`);
           }
         } else if (entry.preview !== undefined && (typeof entry.preview !== "object" || entry.preview === null))
           report("error", file, `state "${where}" preview must be a list of component names, or an object of app-state mock data (docs.unoverse.ai/design/apps)`);
@@ -578,7 +578,7 @@ function lintFile(file) {
             // 2026-09-11); the lookup is the name before the hash.
             for (const c of list)
               if (comps && !comps.has(String(c).split("#")[0].toLowerCase()))
-                report("error", file, `preview."${state}" names unknown component "${c}". No match in design/marketplace/components/ or this org's components/ (org-privacy: another org's components are out of reach; lookup is case-insensitive)`);
+                report("error", file, `preview."${state}" names unknown component "${c}". No match in the marketplace's components/ or this org's components/ (org-privacy: another org's components are out of reach; lookup is case-insensitive)`);
           }
         }
       }

package/vendor/base/src/lint/design/index.d.mts

@@ -29,6 +29,12 @@ export interface LintDefinitionsOptions {
   overlay?: Record<string, string>;
   /** An org's own repo (UNO-88): its folder and its DECLARED name. The org list is then this one. */
   org?: { name: string; dir: string };
+  /**
+   * The marketplace tier's folder, when it is not `<root>/marketplace`: the platform repo
+   * authors it at packages/marketplace/definitions (base paths.ts `marketplace`), outside
+   * any design root. Only a caller that knows the folder exists passes it.
+   */
+  marketplace?: string;
 }
 
 export function lintDefinitions(rxHome?: string, options?: LintDefinitionsOptions): DefinitionsResult;

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

@@ -42,10 +42,13 @@ export function lintDefinitions(designRoot, options = {}) {
     const hit = overlay[resolve(f)];
     return hit === undefined ? readFileSync(f, "utf8") : hit;
   };
-  const candidates = designRoot ? [resolve(designRoot)] : [resolve("apps/unoverse/design"), resolve("design")];
+  // With no root given: the platform repo's marketplace tier (linted as the root itself, as
+  // CI and the release do), else a developer's design/.
+  const candidates = designRoot ? [resolve(designRoot)] : [resolve("packages/marketplace/definitions"), resolve("design")];
 
-  /** The monorepo's shapes: the design system at `design/marketplace/`, or the legacy one
-   *  with `components/` and `atoms/` loose at the root. */
+  /** A design root holding the design system at `<root>/marketplace/`, or the design system
+   *  itself as the root, with `components/` and `atoms/` loose in it (how the platform repo
+   *  lints its tier, `packages/marketplace/definitions`). */
   const holdsDesignSystem = (p) =>
     existsSync(join(p, "marketplace")) || existsSync(join(p, "components")) || existsSync(join(p, "atoms"));
 
@@ -53,7 +56,7 @@ export function lintDefinitions(designRoot, options = {}) {
    * A DEVELOPER'S design/ HOLDS ONLY ORG FOLDERS, and looking for the monorepo's shapes there
    * finds nothing. `design/<org>/{components,styles,apps}` is what Studio scaffolds and
    * the only layout a developer ever has, because the design system is INSTALLED rather
-   * than authored (sync-starter.sh keeps `design/marketplace` out of a project on purpose).
+   * than authored (sync-starter.sh keeps the marketplace tier out of a project on purpose).
    *
    * So a project could not be linted, and since publishing lints first, it could not be
    * published either: "no design/ folder here", naming the folder it was standing in.
@@ -85,7 +88,24 @@ export function lintDefinitions(designRoot, options = {}) {
    */
   const ORG_REPO = options.org?.dir ? resolve(options.org.dir) : null;
   const ORG_NAME = options.org?.name ?? null;
-  const DESIGN_ROOT = ORG_REPO ? dirname(ORG_REPO) : candidates.find((p) => holdsDesignSystem(p) || holdsOrgs(p));
+  /**
+   * THE MARKETPLACE TIER BY NAME, when it is not `<root>/marketplace`. The platform repo
+   * authors it at packages/marketplace/definitions (base paths.ts `marketplace`), outside any
+   * design root, and a caller that knows that says so. The tier then reads exactly as
+   * `<root>/marketplace` would: the design system, and a home named `marketplace`.
+   */
+  const MARKETPLACE = !ORG_REPO && options.marketplace ? resolve(options.marketplace) : null;
+  const DESIGN_ROOT = ORG_REPO
+    ? dirname(ORG_REPO)
+    : candidates.find((p) => holdsDesignSystem(p) || holdsOrgs(p)) ??
+      (MARKETPLACE && (existsSync(candidates[0]) || existsSync(MARKETPLACE)) ? candidates[0] : undefined);
+  /**
+   * NO ORG TIER HERE. The platform repo authors no orgs (its design/ was retired 2026-10-04),
+   * so a caller naming the marketplace tier may hand a design root that does not exist. That
+   * means "lint the tier alone", never "nothing to lint": an error here would fail every save
+   * in the platform repo's Studio on a folder nobody is meant to have.
+   */
+  const NO_ORG_TIER = !ORG_REPO && !existsSync(DESIGN_ROOT ?? "");
   if (!DESIGN_ROOT)
     return {
       problems: [{ level: "error", file: candidates[0], msg: `no design/ folder here (looked in: ${candidates.join(", ")})` }],
@@ -93,14 +113,15 @@ export function lintDefinitions(designRoot, options = {}) {
     };
 
 // ── tree layout ──
-// New layout: design/marketplace/{atoms,components,styles} + one top-level folder per
+// New layout: <root>/marketplace/{atoms,components,styles} (or the tier named by
+// options.marketplace) + one top-level folder per
 // org (design/<org>/). Legacy layout: components/ + atoms/ at the root, orgs under design/orgs/.
 // The DESIGN SYSTEM is the primary lint target; org folders get the SAME generic
 // checks — nothing here may key on a specific org's name.
-// WHERE THE DESIGN SYSTEM ACTUALLY IS. `design/marketplace/` exists in this monorepo and is
-  // deliberately absent from a developer's project (sync-starter.sh): the platform installs
-  // @unoverse-platform/marketplace, whose `definitions/` bundle carries components, atoms
-  // AND styles (bundle-defs.mjs). All three matter — the space-scale check reads
+// WHERE THE DESIGN SYSTEM ACTUALLY IS. `<root>/marketplace/` when a root carries one; it
+  // is deliberately absent from a developer's project (sync-starter.sh): the platform installs
+  // @unoverse-platform/marketplace, whose `definitions/` folder carries components, atoms
+  // AND styles (authored there, packages/marketplace/definitions in the platform repo). All three matter — the space-scale check reads
   // styles/base/spacing, so a fallback finding only components would build a PARTIAL scale
   // and reject valid steps, reporting false errors on correct work. Mirrors definitions.ts.
   const DS = (() => {
@@ -110,6 +131,7 @@ export function lintDefinitions(designRoot, options = {}) {
       const bundled = join(ORG_REPO, "plugins", "node_modules", "@unoverse-platform", "marketplace", "definitions");
       return existsSync(bundled) ? bundled : join(ORG_REPO, ".unoverse", "no-design-system");
     }
+    if (MARKETPLACE) return MARKETPLACE;
     const onDisk = join(DESIGN_ROOT, "marketplace");
     if (existsSync(onDisk)) return onDisk;
     for (const c of [
@@ -123,10 +145,15 @@ const HAS_DS = DS !== DESIGN_ROOT && existsSync(DS);
 /** The org a home folder belongs to: the declared name in an org repo, else the folder's name. */
 const orgName = (dir) => (ORG_REPO && dir === ORG_REPO ? ORG_NAME : basename(dir));
 /** Every home that can hold node packages, credentials or places: the design system and the orgs. */
-const tierHomes = () => (ORG_REPO ? [DS, ...orgDirs] : readdirSync(DESIGN_ROOT).map((t) => join(DESIGN_ROOT, t)));
+const tierHomes = () =>
+  ORG_REPO ? [DS, ...orgDirs] : [...(MARKETPLACE ? [DS] : []), ...(NO_ORG_TIER ? [] : readdirSync(DESIGN_ROOT).map((t) => join(DESIGN_ROOT, t)))];
+/** A file's path below the design root, the named marketplace tier reading as `marketplace/…`. */
+const underRoot = (f) =>
+  MARKETPLACE && (f === DS || f.startsWith(DS + sep)) ? ["marketplace", ...relative(DS, f).split(sep)] : relative(DESIGN_ROOT, f).split(sep);
 const legacyOrgsDir = join(DESIGN_ROOT, "orgs");
 const orgDirs = (() => {
   if (ORG_REPO) return [ORG_REPO];
+  if (NO_ORG_TIER) return [];
   if (existsSync(legacyOrgsDir))
     return readdirSync(legacyOrgsDir)
       .filter((e) => !e.startsWith("."))
@@ -199,11 +226,11 @@ const isPropsExtract = (f) => {
 const isManifest = (f) => /^manifest\.(json|yaml)$/.test(basename(f));
 // WHICH HOME A FILE IS IN — asked of the path BELOW the design root, never the absolute
 // one. Testing the absolute path for an `apps` segment was true of every file in this
-// monorepo, because the design tree itself lives at `apps/unoverse/design`: every
+// monorepo, because the design tree itself lived at `apps/unoverse/design`: every
 // component manifest in the repo was linted as an APP manifest (two bogus warnings each,
 // while the real component-manifest rules never ran once). A rule that cannot tell the
 // homes apart is worse than no rule — it trains people to ignore its output.
-const homeSegments = (f) => relative(DESIGN_ROOT, f).split(sep);
+const homeSegments = (f) => underRoot(f);
 const isAppPath = (f) => homeSegments(f).includes("apps");
 // THE TEMPLATE KIND (UNOVERSE_TEMPLATE_MODEL.md §9b). Its folders answer to different
 // rules than an app's or a component's, so the rules that would misfire have to be able
@@ -931,7 +958,7 @@ function appSizesForFile(file) {
   return appSizesCache.get(home);
 }
 
-// The universal component names (design/marketplace/components/*, case-insensitive) — for
+// The universal component names (the tier's components/*, case-insensitive) — for
 // validating an app manifest's `preview` map. null = the file is not under a design tree.
 const componentNamesCache = new Map();
 // Components an ORG's template may reference: the marketplace tier + that org's OWN
@@ -941,9 +968,10 @@ function componentNamesForFile(file) {
   // `${sep}orgs${sep}` and returned null for anything else, so on the flat layout — which
   // is every project now (`design/<org>/…`, "flat wins") — it answered "no list" and
   // every rule that asks it, preview names included, silently stopped checking.
-  const segs = relative(DESIGN_ROOT, file).split(sep);
+  const segs = underRoot(file);
   if (segs.length < 2 || segs[0] === "..") return null;
   const projectSegs = segs[0] === "orgs" ? segs.slice(0, 2) : segs.slice(0, 1);
+  const projectHome = MARKETPLACE && projectSegs[0] === "marketplace" ? DS : join(DESIGN_ROOT, ...projectSegs);
   const org = projectSegs.join("/");
   const cached = componentNamesCache.get(org);
   if (cached !== undefined) return cached;
@@ -958,11 +986,11 @@ function componentNamesForFile(file) {
   }
   const dirs = [
     join(DS, "components"),
-    join(DESIGN_ROOT, ...projectSegs, "components"),
+    join(projectHome, "components"),
     // TEMPLATES ARE PEERS (§9c): a state that holds one seeds it by name like any
     // component, so the name set a preview is checked against includes them.
     join(DS, "templates"),
-    join(DESIGN_ROOT, ...projectSegs, "templates"),
+    join(projectHome, "templates"),
   ];
   let names = null;
   for (const dir of dirs) {

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

@@ -1,7 +1,7 @@
 /**
  * The CLOSED SETS. This file is the linter's ground truth.
  *
- * Mirrors apps/unoverse/design/_schema/unoverse.schema.json and the server guards, and UNOVERSE_CONFORMANCE
+ * Mirrors packages/docs/schemas/design/unoverse.schema.json and the server guards, and UNOVERSE_CONFORMANCE
  * §5 makes keeping them equal a maintenance rule: "One source for each closed set... Keep
  * them equal or they disagree silently."
  *
@@ -10,7 +10,7 @@
  * without extending the schema and the SDK in the same change.
  */
 
-// ── ground truth (mirrors design/_schema/unoverse.schema.json + server guards) ──
+// ── ground truth (mirrors packages/docs/schemas/design/unoverse.schema.json + server guards) ──
 export const PRIMITIVES = new Set([
   "Box", "Stack", "Row", "Column", "Each", "Switch", "ComponentSlot", "Timeline",
   "Text", "Image", "Button", "Input", "Select", "Markdown", "Skeleton", "Icon", "Ref", "Orb", "Template", "Place",

package/vendor/base/src/lint/nodes/blocks.mjs

@@ -23,7 +23,7 @@ export const HANDLEBARS_HELPERS = new Set([
 ]);
 
 /**
- * The prompt-block library: design/marketplace/blocks/**\/*.md, keyed the way the resolver keys them
+ * The prompt-block library: the marketplace tier's blocks/**\/*.md, keyed the way the resolver keys them
  * (engine/src/template/promptBlocks.ts) — the filename camelCased, so markdown-guidelines.md is
  * referenced as {{prompt.markdownGuidelines}}.
  *
@@ -42,8 +42,8 @@ const CACHE = new Map();
 
 export function promptBlocks() {
   // The block library is the marketplace tier's. Beside the nodes when they ARE that
-  // tier (design/marketplace/{nodes,blocks}); one tier over for an org's own nodes
-  // (design/<org>/nodes → design/marketplace/blocks).
+  // tier (packages/marketplace/definitions/{nodes,blocks}); one tier over for an org's own
+  // nodes (design/<org>/nodes → design/marketplace/blocks, a design root carrying the tier).
   const home = [resolve(state.nodesHome, "../blocks"), resolve(state.nodesHome, "../../marketplace/blocks")]
     .find((d) => existsSync(d)) ?? resolve(state.nodesHome, "../../marketplace/blocks");
   const cached = CACHE.get(home);

package/vendor/base/src/lint/nodes/node.mjs

@@ -672,7 +672,7 @@ export function lintNode(dir, pkg) {
       for (const [, b] of body.matchAll(/\b(?:prompt|blocks)\.([A-Za-z0-9_]+)/g))
         if (!promptBlocks().has(b) && !seen.has(b)) {
           seen.add(b);
-          report("error", F.api, `references prompt block "{{prompt.${b}}}", which does not exist in design/marketplace/blocks/. It resolves to empty and the instruction silently disappears`);
+          report("error", F.api, `references prompt block "{{prompt.${b}}}", which does not exist in the marketplace's blocks/. It resolves to empty and the instruction silently disappears`);
         }
     }
   }

package/vendor/base/src/lint/objects/index.d.mts

@@ -25,6 +25,12 @@ export interface LintObjectsOptions {
   overlay?: Record<string, string>;
   /** An org's own repo (UNO-88): its folder and its DECLARED name. The org list is then this one. */
   org?: { name: string; dir: string };
+  /**
+   * The marketplace tier's folder, when it is not `<root>/marketplace`: the platform repo
+   * authors it at packages/marketplace/definitions (base paths.ts `marketplace`), outside
+   * any design root. Only a caller that knows the folder exists passes it.
+   */
+  marketplace?: string;
 }
 
 /** Lint every object and pipeline folder under `designRoot`, every tier. Prints nothing, throws nothing for a lint failure. */

package/vendor/base/src/lint/objects/index.mjs

@@ -106,7 +106,13 @@ export function lintObjects(designRoot, options = {}) {
     }
   };
 
-  if (!isDir(ROOT)) {
+  // The marketplace tier: `<root>/marketplace`, unless the caller names it (options.marketplace:
+  // the platform repo authors it outside any design root, base paths.ts `marketplace`).
+  const marketplace = options.marketplace ? resolve(options.marketplace) : join(ROOT, "marketplace");
+  // NO ORG TIER HERE: a named marketplace tier with no design root beside it (the platform
+  // repo, whose design/ was retired 2026-10-04) lints the tier alone. Only a root with neither
+  // is "nothing to lint".
+  if (!isDir(ROOT) && !(options.marketplace && isDir(marketplace))) {
     report("error", ROOT, "no design/ folder here");
     return { problems: [...problems], objectCount: 0, pipelineCount: 0, designRoot: ROOT };
   }
@@ -119,13 +125,12 @@ export function lintObjects(designRoot, options = {}) {
   // ── the tiers: the marketplace, then every org folder ──
   // An org's own repo is ONE tier with a DECLARED name (`options.org`, UNO-88): its folder may
   // be called anything, and the org name is also the dataset table's (`dataset_<org>_<name>`).
-  const marketplace = join(ROOT, "marketplace");
   const tiers = [];
   if (options.org?.dir) {
     tiers.push({ org: options.org.name, dir: resolve(options.org.dir) });
   } else {
     if (isDir(marketplace)) tiers.push({ org: undefined, dir: marketplace });
-    for (const e of readdirSync(ROOT)) {
+    for (const e of isDir(ROOT) ? readdirSync(ROOT) : []) {
       if (e.startsWith(".") || e === "marketplace" || e === "_schema") continue;
       const d = join(ROOT, e);
       if (isDir(d)) tiers.push({ org: e, dir: d });
@@ -265,22 +270,38 @@ export function lintObjects(designRoot, options = {}) {
 
     // extends: resolves, no cycle, across the tiers the org can see.
     let parentProps = null;
+    // A BASE THAT CANNOT BE SEEN is not a missing base. An org repo carries no marketplace on
+    // disk (UNO-88), so `extends: need` names an object installed in every universe and present
+    // in none of the repo's folders. The same rule as the nodes above: step back to a hint, read
+    // a description-only prop as the re-brief of an inherited field (the only thing it can be),
+    // and leave the row keys, which need the base's fields, to the universe that has them.
+    let baseUnseen = false;
     const base = isRecord(f.envelope) ? f.envelope.extends : undefined;
     if (typeof base === "string") {
       const parent = findObject(base, f.org);
-      if (!parent) report("error", rel(f.envFile), `object ${f.name}: extends "${base}", which no tier holds`);
+      if (!parent && options.org?.dir && !marketplaceSeen) {
+        baseUnseen = true;
+        report("hint", rel(f.envFile), `object ${f.name}: extends "${base}", which is not on disk here (the marketplace is installed, not in the repo), so what it inherits was not checked`);
+        parentProps = Object.fromEntries(
+          Object.entries(isRecord(f.props) ? f.props : {}).filter(([, p]) => isRecord(p) && Object.keys(p).every((k) => k === "description")),
+        );
+      } else if (!parent) report("error", rel(f.envFile), `object ${f.name}: extends "${base}", which no tier holds`);
       else {
         parentProps = composedProps(parent, [f.name]);
         if (parentProps === null) report("error", rel(f.envFile), `object ${f.name}: extends cycle through ${base}`);
       }
     }
     say(propsFindings(f.name, f.props, parentProps, base, basename(f.propsFile)));
-    if (isRecord(f.props)) for (const [k, p] of Object.entries(f.props)) if (isRecord(p) && p.from != null) say(fromFindings(f.name, k, p.from, composedService(f), basename(f.propsFile)));
+    // With the base unseen, a function the object does not declare itself may be the base's
+    // (README: a prop may be written from an inherited function), so only its own are checked.
+    const fns = composedService(f);
+    const ownFn = (from) => typeof from === "string" && from.split(".")[0] in fns;
+    if (isRecord(f.props)) for (const [k, p] of Object.entries(f.props)) if (isRecord(p) && p.from != null && (!baseUnseen || ownFn(p.from))) say(fromFindings(f.name, k, p.from, fns, basename(f.propsFile)));
     say(serviceFindings(f.name, f.service, visibleNodes(tier)));
     say(makeFindings(f.name, f.make, f.service, visibleNodes(tier)));
     if (!marketplaceSeen && isRecord(f.service)) report("hint", rel(f.servicePath), `object ${f.name}: the marketplace is not on disk here, so the nodes its calls name were not checked`);
     const all = composedProps(f) ?? (isRecord(f.props) ? f.props : {});
-    say(rowKeyFindings(f.name, f.envelope, all, basename(f.envFile)));
+    if (!baseUnseen) say(rowKeyFindings(f.name, f.envelope, all, basename(f.envFile)));
     say(objectTestFindings(f.name, f.test, ownFunctions(f)));
     // An org may never take a marketplace name: a bare object_type must stay unambiguous.
     if (f.org && marketplaceObjects.has(f.name)) report("error", rel(f.envFile), `object ${f.name}: an org's object may not take a marketplace object's name; the row's object_type would be ambiguous. Rename it, or extend ${f.name} under a name of its own`);

package/vendor/base/src/lint/prompts/index.d.mts

@@ -24,6 +24,12 @@ export interface LintPromptsOptions {
   overlay?: Record<string, string>;
   /** An org's own repo (UNO-88): its folder and its DECLARED name. The org list is then this one. */
   org?: { name: string; dir: string };
+  /**
+   * The marketplace tier's folder, when it is not `<root>/marketplace`: the platform repo
+   * authors it at packages/marketplace/definitions (base paths.ts `marketplace`), outside
+   * any design root. Only a caller that knows the folder exists passes it.
+   */
+  marketplace?: string;
 }
 
 /** Lint every skill and prompt block under `designRoot`, every tier. Prints nothing, throws nothing for a lint failure. */

package/vendor/base/src/lint/prompts/index.mjs

@@ -135,21 +135,26 @@ export function lintPrompts(designRoot, options = {}) {
   const present = (f) => existsSync(f) || overlay[resolve(f)] !== undefined;
   const rel = (f) => (relative(process.cwd(), f).startsWith("..") ? f : relative(process.cwd(), f));
 
-  if (!isDir(ROOT)) {
+  // The marketplace tier: `<root>/marketplace`, unless the caller names it (options.marketplace:
+  // the platform repo authors it outside any design root, base paths.ts `marketplace`).
+  const marketplace = options.marketplace ? resolve(options.marketplace) : join(ROOT, "marketplace");
+  // NO ORG TIER HERE: a named marketplace tier with no design root beside it (the platform
+  // repo, whose design/ was retired 2026-10-04) lints the tier alone. Only a root with neither
+  // is "nothing to lint".
+  if (!isDir(ROOT) && !(options.marketplace && isDir(marketplace))) {
     report("error", ROOT, "no design/ folder here");
     return { problems: [...problems], skillCount: 0, blockCount: 0, designRoot: ROOT };
   }
 
   // ── the tiers: the marketplace, every flat org folder, and the legacy orgs/ container ──
   const tiers = [];
-  const marketplace = join(ROOT, "marketplace");
   const orgDirs = (base) => readdirSync(base).filter((e) => !e.startsWith(".") && !e.startsWith("_") && e !== "marketplace" && e !== "orgs" && isDir(join(base, e)));
   if (options.org?.dir) {
     // An org's own repo: one tier, its name declared, never read off the folder (UNO-88).
     tiers.push({ org: options.org.name, dir: resolve(options.org.dir) });
   } else {
     if (isDir(marketplace)) tiers.push({ org: undefined, dir: marketplace });
-    for (const e of orgDirs(ROOT)) tiers.push({ org: e, dir: join(ROOT, e) });
+    if (isDir(ROOT)) for (const e of orgDirs(ROOT)) tiers.push({ org: e, dir: join(ROOT, e) });
     if (isDir(join(ROOT, "orgs"))) for (const e of orgDirs(join(ROOT, "orgs"))) tiers.push({ org: e, dir: join(ROOT, "orgs", e) });
   }