@object-ui/cli 17.5.0 → 17.7.0

package/dist/cli.js

@@ -3,115 +3,36 @@ import {
   createTempApp,
   createTempAppWithRouting,
   init,
-  parseSchemaFile,
-  scanPagesDirectory,
+  isWorkspaceRoot,
+  prepareWorkspaceTempApp,
+  reportProjectSource,
+  resolveProjectSource,
   serve
-} from "./chunk-2MZA766D.js";
+} from "./chunk-VMMIGYU3.js";
 
 // src/cli.ts
 import { Command } from "commander";
-import chalk14 from "chalk";
+import chalk9 from "chalk";
 
 // src/commands/dev.ts
 import { createServer } from "vite";
 import react from "@vitejs/plugin-react";
-import { existsSync, mkdirSync, unlinkSync, statSync } from "fs";
-import { join, resolve, dirname } from "path";
+import { mkdirSync } from "fs";
+import { join } from "path";
 import chalk from "chalk";
 import { execSync } from "child_process";
-import { createRequire } from "module";
-async function loadTempAppPostcssPlugins() {
-  try {
-    const [tailwindPostcss, autoprefixer] = await Promise.all([
-      import("@tailwindcss/postcss"),
-      import("autoprefixer")
-    ]);
-    return [tailwindPostcss.default(), autoprefixer.default()];
-  } catch (error) {
-    throw new Error(
-      `Failed to load the Tailwind CSS PostCSS pipeline: ${error instanceof Error ? error.message : error}
-  Both '@tailwindcss/postcss' and 'autoprefixer' are dependencies of @object-ui/cli \u2014 a
-  broken install of the CLI is the likeliest cause; reinstall it and try again.
-  (Refusing to start unstyled: that failure is silent in the browser.)`
-    );
-  }
-}
 async function dev(schemaPath, options) {
   const cwd = process.cwd();
-  let _projectRoot = cwd;
-  const targetSchemaPath = schemaPath;
-  let hasPagesDir = false;
-  let pagesDir = "";
-  let appConfig = null;
-  const absoluteSchemaPath = resolve(cwd, schemaPath);
-  if (existsSync(absoluteSchemaPath) && statSync(absoluteSchemaPath).isFile()) {
-    const fileDir = dirname(absoluteSchemaPath);
-    const potentialPagesDir = join(fileDir, "pages");
-    if (existsSync(potentialPagesDir)) {
-      console.log(chalk.blue(`\u{1F4C2} Detected project structure at ${fileDir}`));
-      _projectRoot = fileDir;
-      hasPagesDir = true;
-      pagesDir = potentialPagesDir;
-      try {
-        appConfig = parseSchemaFile(absoluteSchemaPath);
-        console.log(chalk.blue("\u2699\uFE0F  Loaded App Config from app.json"));
-      } catch (_e) {
-        console.warn("Failed to parse app config");
-      }
-    }
-  }
-  if (!hasPagesDir) {
-    const localPagesDir = join(cwd, "pages");
-    if (existsSync(localPagesDir)) {
-      hasPagesDir = true;
-      pagesDir = localPagesDir;
-      const appJsonPath = join(cwd, "app.json");
-      if (existsSync(appJsonPath)) {
-        try {
-          appConfig = parseSchemaFile(appJsonPath);
-          console.log(chalk.blue("\u2699\uFE0F  Loaded App Config from app.json"));
-        } catch (_e) {
-          console.warn("Failed to parse app.json config");
-        }
-      }
-    }
-  }
-  const require2 = createRequire(join(cwd, "package.json"));
-  let routes = [];
-  let schema = null;
-  let useFileSystemRouting = false;
-  if (hasPagesDir) {
-    console.log(chalk.blue(`\u{1F4C1} Using file-system routing from ${pagesDir}`));
-    routes = scanPagesDirectory(pagesDir);
-    useFileSystemRouting = true;
-    if (routes.length === 0) {
-      throw new Error(`No schema files found in ${pagesDir}`);
-    }
-    console.log(chalk.green(`\u2713 Found ${routes.length} route(s)`));
-    routes.forEach((route) => {
-      console.log(chalk.dim(`  ${route.path} \u2192 ${route.filePath.replace(cwd, ".")}`));
-    });
-  } else {
-    const fullSchemaPath = resolve(cwd, schemaPath);
-    if (!existsSync(fullSchemaPath)) {
-      throw new Error(`Schema file not found: ${schemaPath}
-Run 'objectui init' to create a sample schema.`);
-    }
-    console.log(chalk.blue("\u{1F4CB} Loading schema:"), chalk.cyan(schemaPath));
-    try {
-      schema = parseSchemaFile(fullSchemaPath);
-    } catch (error) {
-      throw new Error(`Invalid schema file: ${error instanceof Error ? error.message : error}`);
-    }
-  }
+  const source = resolveProjectSource(cwd, schemaPath);
+  reportProjectSource(source, cwd);
   const tmpDir = join(cwd, ".objectui-tmp");
   mkdirSync(tmpDir, { recursive: true });
-  if (useFileSystemRouting) {
-    createTempAppWithRouting(tmpDir, routes, appConfig);
+  if (source.mode === "routes") {
+    createTempAppWithRouting(tmpDir, source.routes, source.appConfig);
   } else {
-    createTempApp(tmpDir, schema);
+    createTempApp(tmpDir, source.schema);
   }
-  const isMonorepo = existsSync(join(cwd, "pnpm-workspace.yaml"));
+  const isMonorepo = isWorkspaceRoot(cwd);
   if (isMonorepo) {
     console.log(chalk.blue("\u{1F4E6} Detected monorepo - using root node_modules"));
   } else {
@@ -129,6 +50,10 @@ Run 'objectui init' to create a sample schema.`);
   }
   console.log(chalk.green("\u2713 Schema loaded successfully"));
   console.log(chalk.blue("\u{1F680} Starting development server...\n"));
+  if (isMonorepo) {
+    console.log(chalk.blue("\u{1F4E6} Detected monorepo - configuring workspace aliases"));
+  }
+  const workspaceConfig = isMonorepo ? await prepareWorkspaceTempApp(cwd, tmpDir) : {};
   const viteConfig = {
     root: tmpDir,
     server: {
@@ -140,38 +65,9 @@ Run 'objectui init' to create a sample schema.`);
         allow: [cwd]
       }
     },
-    resolve: {
-      alias: {}
-    },
-    plugins: [react()]
+    plugins: [react()],
+    ...workspaceConfig
   };
-  if (isMonorepo) {
-    console.log(chalk.blue("\u{1F4E6} Detected monorepo - configuring workspace aliases"));
-    const postcssPath = join(tmpDir, "postcss.config.js");
-    if (existsSync(postcssPath)) {
-      unlinkSync(postcssPath);
-    }
-    viteConfig.resolve.alias = {
-      "@object-ui/react": join(cwd, "packages/react/src/index.ts"),
-      "@object-ui/components": join(cwd, "packages/components/src/index.ts"),
-      "@object-ui/core": join(cwd, "packages/core/src/index.ts"),
-      "@object-ui/types": join(cwd, "packages/types/src/index.ts"),
-      "@object-ui/plugin-charts": join(cwd, "packages/plugin-charts/src/index.tsx"),
-      "@object-ui/plugin-editor": join(cwd, "packages/plugin-editor/src/index.tsx"),
-      "@object-ui/plugin-kanban": join(cwd, "packages/plugin-kanban/src/index.tsx"),
-      "@object-ui/plugin-markdown": join(cwd, "packages/plugin-markdown/src/index.tsx"),
-      "@object-ui/plugin-form": join(cwd, "packages/plugin-form/src/index.tsx"),
-      "@object-ui/plugin-grid": join(cwd, "packages/plugin-grid/src/index.tsx"),
-      "@object-ui/plugin-view": join(cwd, "packages/plugin-view/src/index.tsx")
-    };
-    try {
-      const lucidePath = require2.resolve("lucide-react", { paths: [join(cwd, "packages/components")] });
-      viteConfig.resolve.alias["lucide-react"] = lucidePath;
-    } catch (e) {
-      console.warn("\u26A0\uFE0F Could not resolve lucide-react automatically:", e);
-    }
-    viteConfig.css = { postcss: { plugins: await loadTempAppPostcssPlugins() } };
-  }
   const server = await createServer(viteConfig);
   await server.listen();
   const { port, host } = server.config.server;
@@ -189,62 +85,47 @@ Run 'objectui init' to create a sample schema.`);
 // src/commands/build.ts
 import { build as viteBuild } from "vite";
 import react2 from "@vitejs/plugin-react";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, cpSync, rmSync } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
+import { existsSync, mkdirSync as mkdirSync2, cpSync, rmSync } from "fs";
+import { join as join2, resolve } from "path";
 import chalk2 from "chalk";
 import { execSync as execSync2 } from "child_process";
 async function buildApp(schemaPath, options) {
   const cwd = process.cwd();
   const outDir = options.outDir || "dist";
-  const outputPath = resolve2(cwd, outDir);
+  const outputPath = resolve(cwd, outDir);
   console.log(chalk2.blue("\u{1F528} Building application for production..."));
   console.log();
-  const pagesDir = join2(cwd, "pages");
-  const hasPagesDir = existsSync2(pagesDir);
-  let routes = [];
-  let schema = null;
-  let useFileSystemRouting = false;
-  if (hasPagesDir) {
-    console.log(chalk2.blue("\u{1F4C1} Using file-system routing"));
-    routes = scanPagesDirectory(pagesDir);
-    useFileSystemRouting = true;
-    if (routes.length === 0) {
-      throw new Error("No schema files found in pages/ directory");
-    }
-    console.log(chalk2.green(`\u2713 Found ${routes.length} route(s)`));
-  } else {
-    const fullSchemaPath = resolve2(cwd, schemaPath);
-    if (!existsSync2(fullSchemaPath)) {
-      throw new Error(`Schema file not found: ${schemaPath}
-Run 'objectui init' to create a sample schema.`);
-    }
-    console.log(chalk2.blue("\u{1F4CB} Loading schema:"), chalk2.cyan(schemaPath));
-    try {
-      schema = parseSchemaFile(fullSchemaPath);
-    } catch (error) {
-      throw new Error(`Invalid schema file: ${error instanceof Error ? error.message : error}`);
-    }
-  }
+  const source = resolveProjectSource(cwd, schemaPath);
+  reportProjectSource(source, cwd);
   const tmpDir = join2(cwd, ".objectui-tmp");
   mkdirSync2(tmpDir, { recursive: true });
-  if (useFileSystemRouting) {
-    createTempAppWithRouting(tmpDir, routes);
+  if (source.mode === "routes") {
+    createTempAppWithRouting(tmpDir, source.routes, source.appConfig);
   } else {
-    createTempApp(tmpDir, schema);
+    createTempApp(tmpDir, source.schema);
   }
-  console.log(chalk2.blue("\u{1F4E6} Installing dependencies..."));
-  try {
-    execSync2("npm install --silent --prefer-offline", {
-      cwd: tmpDir,
-      stdio: "pipe"
-    });
-    console.log(chalk2.green("\u2713 Dependencies installed"));
-  } catch {
-    throw new Error("Failed to install dependencies. Please check your internet connection and try again.");
+  const isMonorepo = isWorkspaceRoot(cwd);
+  if (isMonorepo) {
+    console.log(chalk2.blue("\u{1F4E6} Detected monorepo - using root node_modules"));
+  } else {
+    console.log(chalk2.blue("\u{1F4E6} Installing dependencies..."));
+    try {
+      execSync2("npm install --silent --prefer-offline", {
+        cwd: tmpDir,
+        stdio: "pipe"
+      });
+      console.log(chalk2.green("\u2713 Dependencies installed"));
+    } catch {
+      throw new Error("Failed to install dependencies. Please check your internet connection and try again.");
+    }
+  }
+  if (isMonorepo) {
+    console.log(chalk2.blue("\u{1F4E6} Detected monorepo - configuring workspace aliases"));
   }
+  const workspaceConfig = isMonorepo ? await prepareWorkspaceTempApp(cwd, tmpDir) : {};
   console.log(chalk2.blue("\u2699\uFE0F  Building with Vite..."));
   console.log();
-  if (options.clean && existsSync2(outputPath)) {
+  if (options.clean && existsSync(outputPath)) {
     console.log(chalk2.dim(`  Cleaning ${outDir}/ directory...`));
     rmSync(outputPath, { recursive: true, force: true });
   }
@@ -257,7 +138,8 @@ Run 'objectui init' to create a sample schema.`);
         reportCompressedSize: true
       },
       plugins: [react2()],
-      logLevel: "info"
+      logLevel: "info",
+      ...workspaceConfig
     });
     mkdirSync2(outputPath, { recursive: true });
     cpSync(join2(tmpDir, "dist"), outputPath, { recursive: true });
@@ -277,21 +159,21 @@ Run 'objectui init' to create a sample schema.`);
 // src/commands/start.ts
 import express from "express";
 import rateLimit from "express-rate-limit";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3, resolve as resolve3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
 import chalk3 from "chalk";
 async function start(options) {
   const cwd = process.cwd();
   const distDir = options.dir || "dist";
-  const distPath = resolve3(cwd, distDir);
-  if (!existsSync3(distPath)) {
+  const distPath = resolve2(cwd, distDir);
+  if (!existsSync2(distPath)) {
     throw new Error(
       `Build directory not found: ${distDir}
 Run 'objectui build' first to create a production build.`
     );
   }
   const indexPath = join3(distPath, "index.html");
-  if (!existsSync3(indexPath)) {
+  if (!existsSync2(indexPath)) {
     throw new Error(
       `index.html not found in ${distDir}/
 Make sure you have a valid production build.`
@@ -330,108 +212,10 @@ Make sure you have a valid production build.`
   });
 }
 
-// src/commands/lint.ts
-import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
-import chalk4 from "chalk";
-async function lint(options) {
-  const cwd = process.cwd();
-  console.log(chalk4.blue("\u{1F50D} Running linter...\n"));
-  const tmpDir = join4(cwd, ".objectui-tmp");
-  const hasTempApp = existsSync4(tmpDir);
-  if (!hasTempApp) {
-    throw new Error(
-      "No Object UI application found. Run 'objectui dev' first to generate the application."
-    );
-  }
-  const packageJsonPath = join4(tmpDir, "package.json");
-  const nodeModulesPath = join4(tmpDir, "node_modules");
-  if (!existsSync4(packageJsonPath) || !existsSync4(nodeModulesPath)) {
-    throw new Error(
-      "Dependencies not installed. Run 'objectui dev' first to set up the application."
-    );
-  }
-  try {
-    const fixFlag = options.fix ? "--fix" : "";
-    const command = `npx eslint "src/**/*.{js,jsx,ts,tsx}" ${fixFlag}`.trim();
-    console.log(chalk4.dim(`  Running: ${command}
-`));
-    execSync3(command, {
-      cwd: tmpDir,
-      stdio: "inherit"
-    });
-    console.log();
-    console.log(chalk4.green("\u2713 Linting completed successfully!"));
-    console.log();
-  } catch {
-    console.log();
-    console.log(chalk4.yellow("\u26A0 Linting found issues."));
-    if (!options.fix) {
-      console.log(chalk4.dim("  Run 'objectui lint --fix' to automatically fix some issues."));
-    }
-    console.log();
-    process.exit(1);
-  }
-}
-
-// src/commands/test.ts
-import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
-import chalk5 from "chalk";
-async function test(options) {
-  const cwd = process.cwd();
-  console.log(chalk5.blue("\u{1F9EA} Running tests...\n"));
-  const tmpDir = join5(cwd, ".objectui-tmp");
-  const hasTempApp = existsSync5(tmpDir);
-  if (!hasTempApp) {
-    throw new Error(
-      "No Object UI application found. Run 'objectui dev' first to generate the application."
-    );
-  }
-  const packageJsonPath = join5(tmpDir, "package.json");
-  const nodeModulesPath = join5(tmpDir, "node_modules");
-  if (!existsSync5(packageJsonPath) || !existsSync5(nodeModulesPath)) {
-    throw new Error(
-      "Dependencies not installed. Run 'objectui dev' first to set up the application."
-    );
-  }
-  try {
-    let command = "npx vitest";
-    if (options.watch) {
-      command += " --watch";
-    } else if (options.ui) {
-      command += " --ui";
-    } else {
-      command += " run";
-    }
-    if (options.coverage) {
-      command += " --coverage";
-    }
-    console.log(chalk5.dim(`  Running: ${command}
-`));
-    execSync4(command, {
-      cwd: tmpDir,
-      stdio: "inherit"
-    });
-    if (!options.watch && !options.ui) {
-      console.log();
-      console.log(chalk5.green("\u2713 Tests completed successfully!"));
-      console.log();
-    }
-  } catch {
-    console.log();
-    console.log(chalk5.red("\u2717 Some tests failed."));
-    console.log();
-    process.exit(1);
-  }
-}
-
 // src/commands/generate.ts
-import chalk6 from "chalk";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync } from "fs";
-import { join as join6 } from "path";
+import chalk4 from "chalk";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync } from "fs";
+import { join as join4 } from "path";
 async function generate(type, name) {
   const cwd = process.cwd();
   switch (type) {
@@ -446,18 +230,18 @@ async function generate(type, name) {
       generatePlugin(cwd, name);
       break;
     default:
-      console.log(chalk6.red(`Unknown type: ${type}`));
+      console.log(chalk4.red(`Unknown type: ${type}`));
       console.log(`Available types: resource, page, plugin`);
       process.exit(1);
   }
 }
 function generateResource(cwd, name) {
-  const dir = join6(cwd, "objects");
-  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
+  const dir = join4(cwd, "objects");
+  if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true });
   const fileName = `${name.toLowerCase()}.json`;
-  const filePath = join6(dir, fileName);
-  if (existsSync6(filePath)) {
-    console.log(chalk6.yellow(`Object ${name} already exists at ${filePath}`));
+  const filePath = join4(dir, fileName);
+  if (existsSync3(filePath)) {
+    console.log(chalk4.yellow(`Object ${name} already exists at ${filePath}`));
     return;
   }
   const content = {
@@ -467,34 +251,35 @@ function generateResource(cwd, name) {
     }
   };
   writeFileSync(filePath, JSON.stringify(content, null, 2));
-  console.log(chalk6.green(`\u2713 Generated resource schema: ${filePath}`));
+  console.log(chalk4.green(`\u2713 Generated resource schema: ${filePath}`));
 }
 function generatePage(cwd, name) {
-  const dir = join6(cwd, "pages");
-  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
+  const dir = join4(cwd, "pages");
+  if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true });
   const fileName = `${name.toLowerCase()}.json`;
-  const filePath = join6(dir, fileName);
-  if (existsSync6(filePath)) {
-    console.log(chalk6.yellow(`Page ${name} already exists at ${filePath}`));
+  const filePath = join4(dir, fileName);
+  if (existsSync3(filePath)) {
+    console.log(chalk4.yellow(`Page ${name} already exists at ${filePath}`));
     return;
   }
   const content = {
     type: "page",
+    pageType: "app",
     title: name,
-    body: [
+    children: [
       {
         type: "markdown",
-        content: `# Welcome to ${name}`
+        content: `Welcome to ${name}`
       }
     ]
   };
   writeFileSync(filePath, JSON.stringify(content, null, 2));
-  console.log(chalk6.green(`\u2713 Generated page schema: ${filePath}`));
+  console.log(chalk4.green(`\u2713 Generated page schema: ${filePath}`));
 }
 function generatePlugin(cwd, name) {
-  const dir = join6(cwd, "plugins", name);
-  if (existsSync6(dir)) {
-    console.log(chalk6.yellow(`Plugin ${name} already exists`));
+  const dir = join4(cwd, "plugins", name);
+  if (existsSync3(dir)) {
+    console.log(chalk4.yellow(`Plugin ${name} already exists`));
     return;
   }
   mkdirSync3(dir, { recursive: true });
@@ -506,14 +291,14 @@ export const ${name}Plugin = {
   }
 };
 `;
-  writeFileSync(join6(dir, "index.ts"), content.trim());
-  console.log(chalk6.green(`\u2713 Generated plugin: ${dir}`));
+  writeFileSync(join4(dir, "index.ts"), content.trim());
+  console.log(chalk4.green(`\u2713 Generated plugin: ${dir}`));
 }
 
 // src/commands/doctor.ts
-import chalk7 from "chalk";
-import { existsSync as existsSync7, readFileSync } from "fs";
-import { dirname as dirname2, join as join7, resolve as resolvePath } from "path";
+import chalk5 from "chalk";
+import { existsSync as existsSync4, readFileSync } from "fs";
+import { dirname, join as join5, resolve as resolvePath } from "path";
 var CSS_ENTRY_CANDIDATES = [
   "src/index.css",
   "src/main.css",
@@ -548,15 +333,15 @@ var V4_POSTCSS_PLUGIN = /@tailwindcss\/postcss/;
 var V3_POSTCSS_PLUGIN = /["']tailwindcss["']|(?:^|[{,\s])tailwindcss\s*:/m;
 function readIfExists(path) {
   try {
-    return existsSync7(path) ? readFileSync(path, "utf-8") : null;
+    return existsSync4(path) ? readFileSync(path, "utf-8") : null;
   } catch {
     return null;
   }
 }
 function findFile(cwd, candidates) {
   for (const rel of candidates) {
-    const abs = join7(cwd, rel);
-    if (existsSync7(abs)) return abs;
+    const abs = join5(cwd, rel);
+    if (existsSync4(abs)) return abs;
   }
   return null;
 }
@@ -569,8 +354,8 @@ function majorOf(range) {
 function isInstalledFrom(cwd, specifier) {
   let dir = resolvePath(cwd);
   for (; ; ) {
-    if (existsSync7(join7(dir, "node_modules", ...specifier.split("/")))) return true;
-    const parent = dirname2(dir);
+    if (existsSync4(join5(dir, "node_modules", ...specifier.split("/")))) return true;
+    const parent = dirname(dir);
     if (parent === dir) return false;
     dir = parent;
   }
@@ -586,7 +371,7 @@ function runDiagnostics(cwd) {
   const error = (id, message) => {
     results.push({ id, level: "error", message });
   };
-  const pkgPath = join7(cwd, "package.json");
+  const pkgPath = join5(cwd, "package.json");
   const pkgRaw = readIfExists(pkgPath);
   let pkg = null;
   if (pkgRaw === null) {
@@ -654,7 +439,7 @@ function runDiagnostics(cwd) {
     }
     const cssEntries = CSS_ENTRY_CANDIDATES.map((rel) => ({
       rel,
-      content: readIfExists(join7(cwd, rel))
+      content: readIfExists(join5(cwd, rel))
     })).filter((entry) => entry.content !== null);
     const importsTailwind = cssEntries.some((entry) => V4_CSS_IMPORT.test(entry.content));
     const usesV3Directives = cssEntries.some((entry) => V3_CSS_DIRECTIVE.test(entry.content));
@@ -688,7 +473,7 @@ function runDiagnostics(cwd) {
       ok("tailwind-config-active", "JS Tailwind config is loaded via `@config`");
     }
   }
-  if (existsSync7(join7(cwd, "tsconfig.json"))) {
+  if (existsSync4(join5(cwd, "tsconfig.json"))) {
     ok("tsconfig-found", "tsconfig.json found");
     const tsRange = deps.typescript;
     if (tsRange) {
@@ -716,142 +501,879 @@ function countIssues(results) {
   return results.filter((result) => result.level !== "ok").length;
 }
 async function doctor() {
-  console.log(chalk7.bold("Object UI Doctor"));
+  console.log(chalk5.bold("Object UI Doctor"));
   console.log("Diagnosis in progress...\n");
   const results = runDiagnostics(process.cwd());
   for (const result of results) {
     if (result.level === "ok") {
-      console.log(chalk7.green(`\u2713 ${result.message}`));
+      console.log(chalk5.green(`\u2713 ${result.message}`));
     } else if (result.level === "warn") {
-      console.log(chalk7.yellow(`\u26A0\uFE0F ${result.message}`));
+      console.log(chalk5.yellow(`\u26A0\uFE0F ${result.message}`));
     } else {
-      console.log(chalk7.red(`x ${result.message}`));
+      console.log(chalk5.red(`x ${result.message}`));
     }
   }
   const issues = countIssues(results);
   console.log("\nResult:");
   if (issues === 0) {
-    console.log(chalk7.green("Everything looks good! \u2728"));
+    console.log(chalk5.green("Everything looks good! \u2728"));
   } else {
-    console.log(chalk7.yellow(`Found ${issues} issue(s).`));
+    console.log(chalk5.yellow(`Found ${issues} issue(s).`));
   }
 }
 
-// src/commands/add.ts
-import chalk8 from "chalk";
-async function add(component) {
-  console.log(chalk8.bold(`Object UI Add: ${component}`));
-  console.log(chalk8.yellow("Feature not implemented yet."));
-  console.log(`This command will download the source code for ${component}Renderer to your project.`);
+// src/commands/check.ts
+import chalk6 from "chalk";
+import { globSync } from "glob";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join6 } from "path";
+import { parse as parseJsonc, printParseErrorCode } from "jsonc-parser";
+import { safeValidateSchema } from "@object-ui/types/zod";
+
+// src/utils/issue-path.ts
+function formatIssuePath(path) {
+  const segments = path ?? [];
+  return segments.length > 0 ? segments.join(" \u2192 ") : "(root)";
 }
 
-// src/commands/studio.ts
-import chalk9 from "chalk";
-import { spawn } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { join as join8, resolve as resolve4, dirname as dirname3 } from "path";
-import { fileURLToPath } from "url";
-async function studio() {
-  console.log(chalk9.bold("\n\u{1F3A8} Starting ObjectUI Studio...\n"));
-  const cwd = process.cwd();
-  const __filename3 = fileURLToPath(import.meta.url);
-  const __dirname3 = dirname3(__filename3);
-  const candidates = [
-    join8(cwd, "apps/console"),
-    resolve4(__dirname3, "../../apps/console"),
-    resolve4(__dirname3, "../../../apps/console")
-  ];
-  let consolePath = null;
-  for (const candidate of candidates) {
-    if (existsSync8(join8(candidate, "package.json"))) {
-      consolePath = candidate;
-      break;
-    }
+// src/utils/known-schema-types.ts
+var KNOWN_SCHEMA_TYPES = [
+  "a",
+  "abbr",
+  "accordion",
+  "action:bar",
+  "action:button",
+  "action:group",
+  "action:icon",
+  "action:menu",
+  "address",
+  "ai-form-assist",
+  "ai-recommendations",
+  "ai:feedback",
+  "ai:input",
+  "ai:suggestion",
+  "alert",
+  "alert-dialog",
+  "app",
+  "app-schema-renderer",
+  "app-shell:cloud-connection:panel",
+  "app-shell:cloud:ai-model-status",
+  "app-shell:cloud:onboarding-next",
+  "app-shell:marketplace:installed-list",
+  "app-shell:mcp:connect-agent",
+  "app:launcher",
+  "article",
+  "aside",
+  "aspect-ratio",
+  "avatar",
+  "b",
+  "badge",
+  "bar-chart",
+  "blockquote",
+  "box",
+  "br",
+  "breadcrumb",
+  "button",
+  "button-group",
+  "calendar",
+  "calendar-view",
+  "card",
+  "carousel",
+  "chart",
+  "chart:bar",
+  "chatbot",
+  "chatbot-enhanced",
+  "chatbot-floating",
+  "checkbox",
+  "cite",
+  "cloud-connection:panel",
+  "cloud:ai-model-status",
+  "cloud:onboarding-next",
+  "cloud:plan-status",
+  "code",
+  "code-editor",
+  "collapsible",
+  "combobox",
+  "command",
+  "container",
+  "context-menu",
+  "dashboard",
+  "data-model-designer",
+  "data-table",
+  "date-picker",
+  "dd",
+  "del",
+  "detail",
+  "detail-section",
+  "detail-view",
+  "dialog",
+  "div",
+  "dl",
+  "drawer",
+  "dropdown-menu",
+  "dt",
+  "element:button",
+  "element:definition-list",
+  "element:divider",
+  "element:image",
+  "element:metadata_viewer",
+  "element:number",
+  "element:record_picker",
+  "element:repeater",
+  "element:text",
+  "element:text_input",
+  "em",
+  "email",
+  "embeddable-form",
+  "empty",
+  "field-designer",
+  "field:address",
+  "field:audio",
+  "field:auto_number",
+  "field:avatar",
+  "field:boolean",
+  "field:checkboxes",
+  "field:code",
+  "field:color",
+  "field:currency",
+  "field:date",
+  "field:datetime",
+  "field:duration",
+  "field:email",
+  "field:file",
+  "field:filter-condition",
+  "field:formula",
+  "field:geolocation",
+  "field:grid",
+  "field:html",
+  "field:image",
+  "field:json",
+  "field:location",
+  "field:lookup",
+  "field:markdown",
+  "field:master_detail",
+  "field:multiselect",
+  "field:number",
+  "field:object",
+  "field:object-ref",
+  "field:password",
+  "field:percent",
+  "field:permission-facet-link",
+  "field:phone",
+  "field:progress",
+  "field:qrcode",
+  "field:radio",
+  "field:rating",
+  "field:recipient-picker",
+  "field:richtext",
+  "field:select",
+  "field:signature",
+  "field:slider",
+  "field:summary",
+  "field:tags",
+  "field:text",
+  "field:textarea",
+  "field:time",
+  "field:tree",
+  "field:url",
+  "field:user",
+  "field:vector",
+  "field:video",
+  "figcaption",
+  "figure",
+  "file-upload",
+  "filter-builder",
+  "filter-ui",
+  "flex",
+  "footer",
+  "form",
+  "global:notifications",
+  "global:search",
+  "grid",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "header-bar",
+  "home",
+  "hover-card",
+  "hr",
+  "html",
+  "i",
+  "icon",
+  "image",
+  "img",
+  "input",
+  "input-otp",
+  "ins",
+  "kbd",
+  "label",
+  "layout:app-schema-renderer",
+  "layout:page:card",
+  "li",
+  "list",
+  "list-view",
+  "loading",
+  "main",
+  "mark",
+  "markdown",
+  "marketplace:installed-list",
+  "mcp:connect-agent",
+  "menubar",
+  "nav",
+  "nav:breadcrumb",
+  "nav:menu",
+  "navigation-menu",
+  "nl-query",
+  "object-calendar",
+  "object-chart",
+  "object-data-table",
+  "object-form",
+  "object-gallery",
+  "object-gantt",
+  "object-grid",
+  "object-kanban",
+  "object-manager",
+  "object-map",
+  "object-master-detail-form",
+  "object-metric",
+  "object-pivot",
+  "object-timeline",
+  "object-tree",
+  "object-view",
+  "ol",
+  "p",
+  "page",
+  "page-designer",
+  "page:accordion",
+  "page:card",
+  "page:footer",
+  "page:header",
+  "page:section",
+  "page:sidebar",
+  "page:tabs",
+  "pagination",
+  "password",
+  "pivot",
+  "plugin-calendar:calendar-view",
+  "plugin-calendar:object-calendar",
+  "plugin-charts:bar-chart",
+  "plugin-charts:chart",
+  "plugin-charts:chart:bar",
+  "plugin-charts:object-chart",
+  "plugin-chatbot:chatbot",
+  "plugin-chatbot:chatbot-enhanced",
+  "plugin-chatbot:chatbot-floating",
+  "plugin-dashboard:dashboard",
+  "plugin-dashboard:metric",
+  "plugin-dashboard:metric-card",
+  "plugin-dashboard:object-data-table",
+  "plugin-dashboard:object-metric",
+  "plugin-dashboard:object-pivot",
+  "plugin-dashboard:pivot",
+  "plugin-designer:data-model-designer",
+  "plugin-designer:field-designer",
+  "plugin-designer:object-manager",
+  "plugin-designer:page-designer",
+  "plugin-designer:process-designer",
+  "plugin-designer:report-designer",
+  "plugin-detail:detail-section",
+  "plugin-detail:detail-view",
+  "plugin-editor:code-editor",
+  "plugin-form:embeddable-form",
+  "plugin-form:object-form",
+  "plugin-form:object-master-detail-form",
+  "plugin-gantt:object-gantt",
+  "plugin-grid:object-grid",
+  "plugin-kanban:object-kanban",
+  "plugin-list:list-view",
+  "plugin-list:object-gallery",
+  "plugin-map:object-map",
+  "plugin-markdown:markdown",
+  "plugin-report:report",
+  "plugin-report:report-viewer",
+  "plugin-timeline:object-timeline",
+  "plugin-timeline:timeline",
+  "plugin-tree:object-tree",
+  "plugin-view:object-view",
+  "plugin-view:view:simple",
+  "popover",
+  "pre",
+  "process-designer",
+  "progress",
+  "protocol-placeholder:ai:feedback",
+  "protocol-placeholder:ai:input",
+  "protocol-placeholder:ai:suggestion",
+  "protocol-placeholder:app:launcher",
+  "protocol-placeholder:field:address",
+  "protocol-placeholder:field:audio",
+  "protocol-placeholder:field:avatar",
+  "protocol-placeholder:field:boolean",
+  "protocol-placeholder:field:checkboxes",
+  "protocol-placeholder:field:code",
+  "protocol-placeholder:field:color",
+  "protocol-placeholder:field:currency",
+  "protocol-placeholder:field:date",
+  "protocol-placeholder:field:datetime",
+  "protocol-placeholder:field:duration",
+  "protocol-placeholder:field:email",
+  "protocol-placeholder:field:file",
+  "protocol-placeholder:field:html",
+  "protocol-placeholder:field:image",
+  "protocol-placeholder:field:json",
+  "protocol-placeholder:field:location",
+  "protocol-placeholder:field:lookup",
+  "protocol-placeholder:field:markdown",
+  "protocol-placeholder:field:master_detail",
+  "protocol-placeholder:field:multiselect",
+  "protocol-placeholder:field:number",
+  "protocol-placeholder:field:password",
+  "protocol-placeholder:field:percent",
+  "protocol-placeholder:field:phone",
+  "protocol-placeholder:field:progress",
+  "protocol-placeholder:field:qrcode",
+  "protocol-placeholder:field:radio",
+  "protocol-placeholder:field:rating",
+  "protocol-placeholder:field:select",
+  "protocol-placeholder:field:signature",
+  "protocol-placeholder:field:slider",
+  "protocol-placeholder:field:text",
+  "protocol-placeholder:field:textarea",
+  "protocol-placeholder:field:time",
+  "protocol-placeholder:field:tree",
+  "protocol-placeholder:field:url",
+  "protocol-placeholder:field:video",
+  "protocol-placeholder:global:notifications",
+  "protocol-placeholder:global:search",
+  "protocol-placeholder:nav:breadcrumb",
+  "protocol-placeholder:nav:menu",
+  "protocol-placeholder:page:accordion",
+  "protocol-placeholder:page:card",
+  "protocol-placeholder:page:footer",
+  "protocol-placeholder:page:header",
+  "protocol-placeholder:page:sidebar",
+  "protocol-placeholder:page:tabs",
+  "protocol-placeholder:record:activity",
+  "protocol-placeholder:record:chatter",
+  "protocol-placeholder:record:details",
+  "protocol-placeholder:record:highlights",
+  "protocol-placeholder:record:path",
+  "protocol-placeholder:record:related_list",
+  "protocol-placeholder:view:calendar",
+  "protocol-placeholder:view:drawer",
+  "protocol-placeholder:view:gallery",
+  "protocol-placeholder:view:gantt",
+  "protocol-placeholder:view:grid",
+  "protocol-placeholder:view:kanban",
+  "protocol-placeholder:view:map",
+  "protocol-placeholder:view:modal",
+  "protocol-placeholder:view:simple",
+  "protocol-placeholder:view:split",
+  "protocol-placeholder:view:tabbed",
+  "protocol-placeholder:view:timeline",
+  "protocol-placeholder:view:wizard",
+  "protocol-placeholder:widget:bar",
+  "protocol-placeholder:widget:funnel",
+  "protocol-placeholder:widget:heatmap",
+  "protocol-placeholder:widget:image",
+  "protocol-placeholder:widget:line",
+  "protocol-placeholder:widget:metric",
+  "protocol-placeholder:widget:pie",
+  "protocol-placeholder:widget:pivot",
+  "protocol-placeholder:widget:radar",
+  "protocol-placeholder:widget:scatter",
+  "protocol-placeholder:widget:table",
+  "protocol-placeholder:widget:text",
+  "q",
+  "radio-group",
+  "record",
+  "record:activity",
+  "record:alert",
+  "record:approvals",
+  "record:attachments",
+  "record:chatter",
+  "record:details",
+  "record:discussion",
+  "record:highlights",
+  "record:history",
+  "record:line_items",
+  "record:path",
+  "record:quick_actions",
+  "record:reference_rail",
+  "record:related_list",
+  "report",
+  "report-designer",
+  "report-viewer",
+  "resizable",
+  "scroll-area",
+  "section",
+  "select",
+  "separator",
+  "sheet",
+  "sidebar",
+  "skeleton",
+  "slider",
+  "small",
+  "sonner",
+  "sort-ui",
+  "span",
+  "spinner",
+  "stack",
+  "statistic",
+  "strong",
+  "sub",
+  "sup",
+  "switch",
+  "table",
+  "tabs",
+  "text",
+  "textarea",
+  "time",
+  "timeline",
+  "toast",
+  "toaster",
+  "toggle",
+  "toggle-group",
+  "tooltip",
+  "tree-view",
+  "u",
+  "ui:a",
+  "ui:abbr",
+  "ui:accordion",
+  "ui:address",
+  "ui:alert",
+  "ui:alert-dialog",
+  "ui:app",
+  "ui:article",
+  "ui:aside",
+  "ui:aspect-ratio",
+  "ui:avatar",
+  "ui:b",
+  "ui:badge",
+  "ui:blockquote",
+  "ui:box",
+  "ui:br",
+  "ui:breadcrumb",
+  "ui:button",
+  "ui:button-group",
+  "ui:calendar",
+  "ui:card",
+  "ui:carousel",
+  "ui:checkbox",
+  "ui:cite",
+  "ui:code",
+  "ui:collapsible",
+  "ui:combobox",
+  "ui:command",
+  "ui:container",
+  "ui:context-menu",
+  "ui:data-table",
+  "ui:date-picker",
+  "ui:dd",
+  "ui:del",
+  "ui:dialog",
+  "ui:div",
+  "ui:dl",
+  "ui:drawer",
+  "ui:dropdown-menu",
+  "ui:dt",
+  "ui:em",
+  "ui:email",
+  "ui:empty",
+  "ui:figcaption",
+  "ui:figure",
+  "ui:file-upload",
+  "ui:filter-builder",
+  "ui:flex",
+  "ui:footer",
+  "ui:grid",
+  "ui:h1",
+  "ui:h2",
+  "ui:h3",
+  "ui:h4",
+  "ui:h5",
+  "ui:h6",
+  "ui:header",
+  "ui:header-bar",
+  "ui:home",
+  "ui:hover-card",
+  "ui:hr",
+  "ui:html",
+  "ui:i",
+  "ui:icon",
+  "ui:image",
+  "ui:img",
+  "ui:input",
+  "ui:input-otp",
+  "ui:ins",
+  "ui:kbd",
+  "ui:label",
+  "ui:li",
+  "ui:list",
+  "ui:loading",
+  "ui:main",
+  "ui:mark",
+  "ui:menubar",
+  "ui:nav",
+  "ui:navigation-menu",
+  "ui:ol",
+  "ui:p",
+  "ui:page",
+  "ui:pagination",
+  "ui:password",
+  "ui:popover",
+  "ui:pre",
+  "ui:progress",
+  "ui:q",
+  "ui:radio-group",
+  "ui:record",
+  "ui:resizable",
+  "ui:scroll-area",
+  "ui:section",
+  "ui:select",
+  "ui:separator",
+  "ui:sheet",
+  "ui:sidebar",
+  "ui:skeleton",
+  "ui:slider",
+  "ui:small",
+  "ui:sonner",
+  "ui:span",
+  "ui:spinner",
+  "ui:stack",
+  "ui:statistic",
+  "ui:strong",
+  "ui:sub",
+  "ui:sup",
+  "ui:switch",
+  "ui:table",
+  "ui:tabs",
+  "ui:text",
+  "ui:textarea",
+  "ui:time",
+  "ui:toast",
+  "ui:toaster",
+  "ui:toggle",
+  "ui:toggle-group",
+  "ui:tooltip",
+  "ui:tree-view",
+  "ui:u",
+  "ui:ul",
+  "ui:utility",
+  "ul",
+  "utility",
+  "view-switcher",
+  "view:calendar",
+  "view:chart",
+  "view:detail",
+  "view:drawer",
+  "view:filter-ui",
+  "view:form",
+  "view:gallery",
+  "view:gantt",
+  "view:grid",
+  "view:kanban",
+  "view:list",
+  "view:map",
+  "view:modal",
+  "view:simple",
+  "view:sort-ui",
+  "view:split",
+  "view:tabbed",
+  "view:timeline",
+  "view:view-switcher",
+  "view:wizard",
+  "widget:bar",
+  "widget:funnel",
+  "widget:heatmap",
+  "widget:image",
+  "widget:line",
+  "widget:metric",
+  "widget:pie",
+  "widget:pivot",
+  "widget:radar",
+  "widget:scatter",
+  "widget:table",
+  "widget:text"
+];
+var KNOWN_SCHEMA_TYPE_SET = new Set(KNOWN_SCHEMA_TYPES);
+function isKnownSchemaType(type) {
+  return KNOWN_SCHEMA_TYPE_SET.has(type);
+}
+
+// src/utils/known-type-case-suggestion.ts
+function suggestKnownTypeByCase(type) {
+  if (typeof type !== "string" || type === "") return void 0;
+  const wanted = type.toLowerCase();
+  for (const candidate of KNOWN_SCHEMA_TYPES) {
+    if (candidate !== type && candidate.toLowerCase() === wanted) return candidate;
+  }
+  return void 0;
+}
+function didYouMeanClause(type) {
+  const match = suggestKnownTypeByCase(type);
+  return match === void 0 ? "" : ` \u2014 did you mean "${match}"?`;
+}
+
+// src/utils/unbindable-text-expressions.ts
+import {
+  EXPRESSION_BINDABLE_TEXT_KEYS,
+  expressionBindableTextKeysFor
+} from "@objectstack/spec/ui";
+var EXPRESSION_PATTERN = /\$\{[^}]+\}/;
+var COMPOSITION_KEY = "children";
+var PAGE_DOCUMENT_ROOT_TYPE = "page";
+function isComponentNode(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.type === "string";
+}
+function judge(node, path, into) {
+  const evaluatedKeys = expressionBindableTextKeysFor(node.type);
+  for (const key of EXPRESSION_BINDABLE_TEXT_KEYS) {
+    const value = node[key];
+    if (typeof value !== "string" || !EXPRESSION_PATTERN.test(value)) continue;
+    if (evaluatedKeys.includes(key)) continue;
+    into.push({
+      severity: isKnownSchemaType(node.type) ? "refusal" : "warning",
+      path: [...path, key],
+      type: node.type,
+      key,
+      evaluatedKeys
+    });
   }
-  if (!consolePath) {
-    console.log(chalk9.yellow("\u26A0  Console app not found in workspace."));
-    console.log(chalk9.dim("  Hint: Run this command from the monorepo root."));
-    console.log(chalk9.dim("  Expected: apps/console/package.json\n"));
-    process.exit(1);
+}
+function visit(node, path, isDocumentRoot, into) {
+  if (!(isDocumentRoot && node.type === PAGE_DOCUMENT_ROOT_TYPE)) {
+    judge(node, path, into);
+  }
+  const children = node[COMPOSITION_KEY];
+  if (Array.isArray(children)) {
+    children.forEach((child, index) => {
+      if (isComponentNode(child)) visit(child, [...path, COMPOSITION_KEY, index], false, into);
+    });
+  } else if (isComponentNode(children)) {
+    visit(children, [...path, COMPOSITION_KEY], false, into);
   }
-  console.log(chalk9.dim(`  Console: ${consolePath}`));
-  console.log(chalk9.dim("  Mode:    MSW (in-browser mock server)\n"));
-  const child = spawn("pnpm", ["run", "dev"], {
-    cwd: consolePath,
-    stdio: "inherit",
-    env: { ...process.env, NODE_ENV: "development" },
-    shell: true
-  });
-  child.on("error", (err) => {
-    console.error(chalk9.red(`
-  \u2717 Failed to start studio: ${err.message}`));
-    process.exit(1);
-  });
-  child.on("exit", (code) => process.exit(code ?? 0));
+}
+function findUnbindableTextExpressions(document) {
+  const found = [];
+  if (isComponentNode(document)) visit(document, [], true, found);
+  return found;
+}
+var inCode = (key) => "`" + key + "`";
+function describeUnbindableTextExpression(finding) {
+  const at = formatIssuePath(finding.path);
+  if (finding.severity === "warning") {
+    return `at ${at}: "${finding.type}" is not a registered component, so the expression on ${inCode(finding.key)} is not refused; a custom renderer may evaluate it itself.`;
+  }
+  const evaluates = finding.evaluatedKeys.length > 0 ? `it evaluates only ${finding.evaluatedKeys.map(inCode).join(", ")}` : `it evaluates none of ${EXPRESSION_BINDABLE_TEXT_KEYS.map(inCode).join(", ")}`;
+  return `at ${at}: "${finding.type}" never evaluates ${inCode(finding.key)} (${evaluates}), so the expression is never resolved: the user sees its literal text, or nothing.`;
+}
+function workingChannels(finding) {
+  const channels = [
+    ...finding.evaluatedKeys.map(inCode),
+    inCode("content"),
+    `${inCode(`properties.${finding.key}`)} (evaluated, then hoisted onto the node)`
+  ];
+  return `Channels SchemaRenderer evaluates: ${channels.join(", ")}; or resolve the value in the host before the schema reaches SchemaRenderer.`;
 }
 
 // src/commands/check.ts
-import chalk10 from "chalk";
-import { globSync } from "glob";
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join9 } from "path";
-async function check() {
-  console.log(chalk10.bold("Object UI Schema Check"));
-  const cwd = process.cwd();
+var OBJECTUI_STRUCTURAL_KEYS = [
+  // Composition — the `children`/`body`-class keys the ruling names.
+  // `body` is the RETIRED spelling, kept so old files are still identified and
+  // then refused — see the docblock above (objectui#6771).
+  "body",
+  "children",
+  // Presentation.
+  "className",
+  "style",
+  "placeholder",
+  // Conditional rendering and interaction state.
+  "visible",
+  "visibleWhen",
+  "visibleOn",
+  "hidden",
+  "hiddenOn",
+  "disabled",
+  "disabledOn",
+  // Test and accessibility handles.
+  "testId",
+  "ariaLabel"
+];
+function recogniseObjectUiSchemaFile(content) {
+  if (OBJECTUI_STRUCTURAL_KEYS.some((key) => key in content)) {
+    return { recognised: true, validated: false };
+  }
+  const result = safeValidateSchema(content);
+  return result.success ? { recognised: true, validated: true } : { recognised: false, issues: result.error.issues };
+}
+function describeFirstIssue(issues) {
+  const [first] = issues;
+  if (first === void 0) return void 0;
+  const lead = issues.length === 1 ? "Issue" : `First of ${issues.length} issues`;
+  return `${lead} at ${formatIssuePath(first.path)}: ${first.message}`;
+}
+function closingLine(tally) {
+  return `ObjectUI schema files: ${tally.validated} validated, ${tally.notValidated} recognised but not validated, ${tally.didNotValidate} did not validate. This sweep is advisory; run \`objectui validate <file>\` for a verdict.`;
+}
+function isUnvalidatedCandidate(type) {
+  return isKnownSchemaType(type);
+}
+function describeParseError(text, error) {
+  const upTo = text.slice(0, error.offset);
+  const line = upTo.split("\n").length;
+  const column = error.offset - (upTo.lastIndexOf("\n") + 1) + 1;
+  return `${printParseErrorCode(error.error)} at line ${line} column ${column}`;
+}
+async function check(cwd = process.cwd()) {
+  console.log(chalk6.bold("Object UI Schema Check"));
   const files = globSync("**/*.{json,yaml,yml}", {
     cwd,
-    ignore: ["node_modules/**", "dist/**", ".git/**"]
+    // `glob` matches `ignore` patterns against the path relative to `cwd`, so
+    // an unanchored `dist/**`/`node_modules/**` excludes only a directory of
+    // that name at the scan root — every nested `packages/*/dist/`,
+    // `examples/*/dist/`, `apps/*/dist/` (and their `node_modules/`) is still
+    // scanned. `**/` anchors the match at any depth (objectui#6320): measured
+    // on this repository, a built tree without it reports roughly double the
+    // files of a clean checkout, almost all of it re-reading the author's own
+    // schemas from build output.
+    ignore: ["**/node_modules/**", "**/dist/**", ".git/**"]
   });
   console.log(`Analyzing ${files.length} files...`);
   let errors = 0;
+  let skipped = 0;
+  const unvalidatedCandidates = [];
+  let validated = 0;
+  let notValidated = 0;
   for (const file of files) {
     try {
       if (file.endsWith(".json")) {
-        const content = JSON.parse(readFileSync2(join9(cwd, file), "utf-8"));
+        const text = readFileSync2(join6(cwd, file), "utf-8");
+        const parseErrors = [];
+        const content = parseJsonc(text, parseErrors, { allowTrailingComma: true });
+        if (parseErrors.length > 0) {
+          const [first] = parseErrors;
+          console.log(
+            chalk6.red(`x Invalid JSON in ${file}: ${describeParseError(text, first)}`)
+          );
+          errors++;
+          continue;
+        }
         if (content && typeof content === "object" && content.type) {
-          const knownTypes = [
-            "page",
-            "form",
-            "grid",
-            "crud",
-            "kanban",
-            "calendar",
-            "dashboard",
-            "chart",
-            "detail",
-            "list",
-            "timeline",
-            "gantt",
-            "map",
-            "gallery",
-            "object-view",
-            "detail-view",
-            "object-chart"
-          ];
-          if (typeof content.type === "string" && !knownTypes.includes(content.type)) {
-            console.log(chalk10.yellow(`\u26A0\uFE0F Unknown schema type "${content.type}" in ${file}`));
+          if (typeof content.type === "string") {
+            const recognition = recogniseObjectUiSchemaFile(
+              content
+            );
+            if (!recognition.recognised) {
+              if (isUnvalidatedCandidate(content.type)) {
+                unvalidatedCandidates.push({
+                  file,
+                  type: content.type,
+                  issues: recognition.issues
+                });
+              } else {
+                skipped++;
+              }
+              continue;
+            }
+            if (recognition.validated) {
+              validated++;
+            } else {
+              notValidated++;
+            }
+            if (!isKnownSchemaType(content.type)) {
+              console.log(
+                chalk6.yellow(
+                  `\u26A0\uFE0F Unknown schema type "${content.type}" in ${file}` + didYouMeanClause(content.type)
+                )
+              );
+            }
+            for (const finding of findUnbindableTextExpressions(content)) {
+              const line = `${file} ${describeUnbindableTextExpression(finding)}`;
+              if (finding.severity === "refusal") {
+                console.log(chalk6.red(`x Unevaluated expression in ${line}`));
+                console.log(chalk6.dim(`   ${workingChannels(finding)}`));
+                errors++;
+              } else {
+                console.log(chalk6.yellow(`\u26A0\uFE0F Expression not judged in ${line}`));
+              }
+            }
           }
         }
       }
     } catch (e) {
-      console.log(chalk10.red(`x Invalid JSON in ${file}: ${e.message}`));
+      console.log(chalk6.red(`x Invalid JSON in ${file}: ${e.message}`));
       errors++;
     }
   }
+  if (unvalidatedCandidates.length > 0) {
+    const n = unvalidatedCandidates.length;
+    console.log(
+      chalk6.yellow(
+        `\u26A0\uFE0F ${n} file${n === 1 ? "" : "s"} carr${n === 1 ? "ies" : "y"} a registered ObjectUI component type but did not validate as an ObjectUI schema:`
+      )
+    );
+    for (const { file, type, issues } of unvalidatedCandidates) {
+      console.log(chalk6.yellow(`   ${file} (type "${type}")`));
+      const firstIssue = describeFirstIssue(issues);
+      if (firstIssue !== void 0) {
+        console.log(chalk6.yellow(`     ${firstIssue}`));
+      }
+    }
+    console.log(
+      chalk6.dim("   Run `objectui validate <file>` on any of them for the full diagnosis.")
+    );
+    console.log(
+      chalk6.dim(
+        "   Either the document is off-spec, or its component type is not modelled by @object-ui/types."
+      )
+    );
+    console.log(
+      chalk6.dim(
+        "   These are NOT counted as skipped: a schema that fails validation is a broken schema, not a foreign file."
+      )
+    );
+  }
+  if (skipped > 0) {
+    console.log(
+      chalk6.dim(
+        `Skipped ${skipped} file${skipped === 1 ? "" : "s"} with a root "type" that no ObjectUI recogniser admitted.`
+      )
+    );
+    console.log(
+      chalk6.dim(
+        `  A file is checked when its root carries an ObjectUI structural key: ${OBJECTUI_STRUCTURAL_KEYS.join(", ")}.`
+      )
+    );
+    console.log(
+      chalk6.dim(
+        "  It is also checked when the whole document validates as an ObjectUI component schema."
+      )
+    );
+  }
   if (errors === 0) {
-    console.log(chalk10.green("\u2713 All checks passed"));
+    console.log(
+      closingLine({
+        validated,
+        notValidated,
+        didNotValidate: unvalidatedCandidates.length
+      })
+    );
   } else {
-    console.log(chalk10.red(`Found ${errors} errors`));
+    console.log(chalk6.red(`Found ${errors} errors`));
     process.exit(1);
   }
 }
 
 // src/commands/validate.ts
-import chalk11 from "chalk";
-import { readFileSync as readFileSync3, existsSync as existsSync9 } from "fs";
-import { resolve as resolve5 } from "path";
+import chalk7 from "chalk";
+import { readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
+import { resolve as resolve3 } from "path";
 import { load as loadYaml } from "js-yaml";
-import { safeValidateSchema } from "@object-ui/types/zod";
+import { safeValidateSchema as safeValidateSchema2 } from "@object-ui/types/zod";
 
 // src/utils/spec-vocabulary-hint.ts
 function findSpecVocabularyFormFields(node, path = "") {
@@ -882,53 +1404,185 @@ function findSpecVocabularyFormFields(node, path = "") {
   return findings;
 }
 
+// src/utils/union-arm-diagnostics.ts
+var MAX_UNION_ARMS_REPORTED = 5;
+function editDistance(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i += 1) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j += 1) {
+      current[j] = Math.min(
+        previous[j] + 1,
+        current[j - 1] + 1,
+        previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+    previous = current;
+  }
+  return previous[b.length];
+}
+function nearestArmNames(authoredType, armNames) {
+  const unique = [...new Set(armNames)].sort();
+  if (typeof authoredType !== "string" || authoredType === "") {
+    return { candidates: [], total: unique.length };
+  }
+  const ordered = [...unique].sort((x, y) => {
+    const d = editDistance(authoredType, x) - editDistance(authoredType, y);
+    return d !== 0 ? d : x.localeCompare(y);
+  });
+  return { candidates: ordered.slice(0, MAX_UNION_ARMS_REPORTED), total: unique.length };
+}
+function authoredTypeAt(document, path) {
+  let node = document;
+  for (const key of path) {
+    if (node === null || typeof node !== "object") return void 0;
+    node = node[key];
+  }
+  if (node === null || typeof node !== "object") return void 0;
+  const type = node.type;
+  return typeof type === "string" ? type : void 0;
+}
+function isUnion(issue) {
+  return issue.code === "invalid_union" && Array.isArray(issue.errors);
+}
+var NO_MATCHING_DISCRIMINATOR = "No matching discriminator";
+function noArmAccepts(node, literals, document) {
+  const authoredType = authoredTypeAt(document, node);
+  const { candidates, total } = nearestArmNames(authoredType, literals);
+  return {
+    kind: "note",
+    path: [...node],
+    ...authoredType === void 0 ? {} : { authoredType },
+    candidates,
+    totalArmNames: total
+  };
+}
+function noMatchingDiscriminator(issue, document) {
+  if (issue.code !== "invalid_union") return void 0;
+  if (issue.note !== NO_MATCHING_DISCRIMINATOR) return void 0;
+  if (!Array.isArray(issue.options)) return void 0;
+  if ((issue.errors ?? []).length > 0) return void 0;
+  const path = issue.path ?? [];
+  if (path[path.length - 1] !== "type") return void 0;
+  if (issue.discriminator !== void 0 && issue.discriminator !== "type") return void 0;
+  const literals = issue.options.filter((v) => typeof v === "string");
+  if (literals.length === 0) return void 0;
+  return noArmAccepts(path.slice(0, -1), literals, document);
+}
+function isAtTypeKey(issue) {
+  const path = issue.path ?? [];
+  return path.length === 1 && path[0] === "type";
+}
+function declaredTypeLiterals(armIssues) {
+  const literals = [];
+  let declares = false;
+  for (const issue of armIssues) {
+    if (isAtTypeKey(issue) && issue.code === "invalid_value" && Array.isArray(issue.values)) {
+      declares = true;
+      literals.push(...issue.values.filter((v) => typeof v === "string"));
+      continue;
+    }
+    if (isAtTypeKey(issue) && isUnion(issue) && Array.isArray(issue.options)) {
+      declares = true;
+      literals.push(...issue.options.filter((v) => typeof v === "string"));
+      continue;
+    }
+    if ((issue.path ?? []).length === 0 && isUnion(issue)) {
+      const nested = (issue.errors ?? []).map((sub) => declaredTypeLiterals(sub));
+      if (nested.length > 0 && nested.every((n) => n !== void 0)) {
+        declares = true;
+        for (const n of nested) literals.push(...n);
+      }
+    }
+  }
+  return declares ? literals : void 0;
+}
+function explain(unionIssue, prefix, document) {
+  const arms = unionIssue.errors ?? [];
+  const declared = arms.map((arm) => declaredTypeLiterals(arm));
+  const declaringArms = declared.filter((d) => d !== void 0);
+  const acceptingIndexes = declared.map((d, i) => d === void 0 ? i : -1).filter((i) => i >= 0);
+  const expand = (armIssues, arm) => armIssues.flatMap((issue) => {
+    const absolute = [...prefix, ...issue.path ?? []];
+    const discriminated = noMatchingDiscriminator({ ...issue, path: absolute }, document);
+    if (discriminated) return [discriminated];
+    if (isUnion(issue)) return explain(issue, absolute, document);
+    return [
+      {
+        kind: "issue",
+        path: absolute,
+        message: issue.message ?? "",
+        code: issue.code,
+        ...arm === void 0 ? {} : { arm }
+      }
+    ];
+  });
+  if (declaringArms.length > 0 && acceptingIndexes.length === 1) {
+    return expand(arms[acceptingIndexes[0]]);
+  }
+  if (declaringArms.length > 0 && acceptingIndexes.length === 0) {
+    return [noArmAccepts(prefix, declaringArms.flat(), document)];
+  }
+  return arms.slice(0, MAX_UNION_ARMS_REPORTED).flatMap((arm, i) => expand(arm, `${i + 1}/${arms.length}`));
+}
+function explainUnionIssue(issue, document) {
+  const discriminated = noMatchingDiscriminator(issue, document);
+  if (discriminated) return [discriminated];
+  if (!isUnion(issue)) return [];
+  return explain(issue, issue.path ?? [], document);
+}
+
 // src/commands/validate.ts
 async function validate(schemaPath) {
-  console.log(chalk11.blue("\u{1F50D} ObjectUI Schema Validator\n"));
-  const resolvedPath = resolve5(process.cwd(), schemaPath);
-  if (!existsSync9(resolvedPath)) {
-    console.error(chalk11.red(`\u2717 Error: Schema file not found: ${schemaPath}`));
+  console.log(chalk7.blue("\u{1F50D} ObjectUI Schema Validator\n"));
+  const resolvedPath = resolve3(process.cwd(), schemaPath);
+  if (!existsSync5(resolvedPath)) {
+    console.error(chalk7.red(`\u2717 Error: Schema file not found: ${schemaPath}`));
     process.exit(1);
   }
   try {
     const fileContent = readFileSync3(resolvedPath, "utf-8");
     let schema;
     if (schemaPath.endsWith(".yaml") || schemaPath.endsWith(".yml")) {
-      console.log(chalk11.gray(`Reading YAML schema from: ${schemaPath}`));
+      console.log(chalk7.gray(`Reading YAML schema from: ${schemaPath}`));
       schema = loadYaml(fileContent);
     } else if (schemaPath.endsWith(".json")) {
-      console.log(chalk11.gray(`Reading JSON schema from: ${schemaPath}`));
+      console.log(chalk7.gray(`Reading JSON schema from: ${schemaPath}`));
       schema = JSON.parse(fileContent);
     } else {
       try {
         schema = JSON.parse(fileContent);
-        console.log(chalk11.gray(`Reading schema from: ${schemaPath} (detected as JSON)`));
+        console.log(chalk7.gray(`Reading schema from: ${schemaPath} (detected as JSON)`));
       } catch {
         schema = loadYaml(fileContent);
-        console.log(chalk11.gray(`Reading schema from: ${schemaPath} (detected as YAML)`));
+        console.log(chalk7.gray(`Reading schema from: ${schemaPath} (detected as YAML)`));
       }
     }
-    console.log(chalk11.gray("Validating schema...\n"));
-    const result = safeValidateSchema(schema);
+    console.log(chalk7.gray("Validating schema...\n"));
+    const result = safeValidateSchema2(schema);
     if (result.success) {
-      console.log(chalk11.green("\u2713 Schema is valid!\n"));
+      console.log(chalk7.green("\u2713 Schema is valid!\n"));
       const data = result.data;
-      console.log(chalk11.bold("Schema Information:"));
-      console.log(chalk11.gray("  Type:"), data.type || "unknown");
+      console.log(chalk7.bold("Schema Information:"));
+      console.log(chalk7.gray("  Type:"), data.type || "unknown");
       if (data.id) {
-        console.log(chalk11.gray("  ID:"), data.id);
+        console.log(chalk7.gray("  ID:"), data.id);
       }
-      if (data.label || data.title) {
-        console.log(chalk11.gray("  Label:"), data.label || data.title);
+      const title = "title" in data ? data.title : void 0;
+      if (data.label || title) {
+        console.log(chalk7.gray("  Label:"), data.label || title);
       }
       if (data.children && Array.isArray(data.children)) {
-        console.log(chalk11.gray("  Children:"), data.children.length);
+        console.log(chalk7.gray("  Children:"), data.children.length);
       }
       const mixed = findSpecVocabularyFormFields(schema).filter((f) => f.mixedName);
       if (mixed.length > 0) {
-        console.log(chalk11.yellow("\nWarnings:"));
+        console.log(chalk7.yellow("\nWarnings:"));
         for (const m of mixed) {
-          console.log(chalk11.yellow(
+          console.log(chalk7.yellow(
             `  ${m.path}: '${m.mixedName}' also carries { field: '${m.field}' } \u2014 mixed form-field vocabularies. The renderer ignores \`field\` here; drop one of the two.`
           ));
         }
@@ -936,27 +1590,56 @@ async function validate(schemaPath) {
       console.log("");
       process.exit(0);
     } else {
-      console.error(chalk11.red("\u2717 Schema validation failed!\n"));
-      console.error(chalk11.bold("Validation Errors:"));
+      console.error(chalk7.red("\u2717 Schema validation failed!\n"));
+      console.error(chalk7.bold("Validation Errors:"));
       result.error.issues.forEach((issue, index) => {
-        console.error(chalk11.red(`
+        console.error(chalk7.red(`
 ${index + 1}. ${issue.message}`));
-        if (issue.path && issue.path.length > 0) {
-          console.error(chalk11.gray(`   Path: ${issue.path.join(" \u2192 ")}`));
-        }
+        console.error(chalk7.gray(`   Path: ${formatIssuePath(issue.path)}`));
         if (issue.code) {
-          console.error(chalk11.gray(`   Code: ${issue.code}`));
+          console.error(chalk7.gray(`   Code: ${issue.code}`));
         }
+        explainUnionIssue(issue, schema).forEach((line, sub) => {
+          const where = formatIssuePath(line.path);
+          if (line.kind === "note") {
+            const at = line.path.length > 0 ? ` at ${where}` : "";
+            if (line.authoredType === void 0) {
+              console.error(
+                chalk7.yellow(
+                  `   No \`type\` is declared${at}, so none of the ${line.totalArmNames} accepted component types can be selected.`
+                )
+              );
+              return;
+            }
+            console.error(
+              chalk7.yellow(`   No arm accepts type "${line.authoredType}"${at}.`)
+            );
+            if (line.candidates.length > 0) {
+              console.error(
+                chalk7.gray(
+                  `   Nearest of the ${line.totalArmNames} accepted types: ` + line.candidates.join(", ")
+                )
+              );
+            }
+            return;
+          }
+          const arm = line.arm === void 0 ? "" : `[arm ${line.arm}] `;
+          console.error(chalk7.red(`   ${index + 1}.${sub + 1} ${arm}${line.message}`));
+          console.error(chalk7.gray(`       Path: ${where}`));
+          if (line.code) {
+            console.error(chalk7.gray(`       Code: ${line.code}`));
+          }
+        });
       });
       const specShaped = findSpecVocabularyFormFields(schema).filter((f) => !f.mixedName);
       if (specShaped.length > 0) {
-        console.error(chalk11.bold("\nLikely cause \u2014 spec form-view vocabulary in a standalone form:"));
+        console.error(chalk7.bold("\nLikely cause \u2014 spec form-view vocabulary in a standalone form:"));
         for (const s of specShaped) {
-          console.error(chalk11.yellow(
+          console.error(chalk7.yellow(
             `   ${s.path}: { field: '${s.field}' } is the spec form-VIEW shape (an object-field reference).`
           ));
         }
-        console.error(chalk11.yellow(
+        console.error(chalk7.yellow(
           `   A standalone \`type: 'form'\` component uses { name: \u2026 } (the form data path).
    Fix: author the field with \`name\` and its own type/label \u2014 or, to reference object fields
    with the spec shape, use an object-bound form (\`type: 'object-form'\` with objectName +
@@ -967,62 +1650,29 @@ ${index + 1}. ${issue.message}`));
       process.exit(1);
     }
   } catch (error) {
-    console.error(chalk11.red("\n\u2717 Error reading or parsing schema file:"));
-    console.error(chalk11.red(error.message));
+    console.error(chalk7.red("\n\u2717 Error reading or parsing schema file:"));
+    console.error(chalk7.red(error.message));
     console.error("");
     process.exit(1);
   }
 }
 
-// src/commands/create-plugin.ts
-import chalk12 from "chalk";
-import { spawn as spawn2 } from "child_process";
-import { resolve as resolve6, dirname as dirname4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname = dirname4(__filename);
-async function createPlugin(pluginName) {
-  console.log(chalk12.blue("\u{1F680} Creating ObjectUI plugin...\n"));
-  const createPluginScript = resolve6(
-    __dirname,
-    "../../../create-plugin/dist/index.js"
-  );
-  return new Promise((resolve8, reject) => {
-    const child = spawn2("node", [createPluginScript, pluginName], {
-      stdio: "inherit",
-      shell: true
-    });
-    child.on("error", (error) => {
-      console.error(chalk12.red("Failed to create plugin:"), error);
-      reject(error);
-    });
-    child.on("exit", (code) => {
-      if (code === 0) {
-        resolve8();
-      } else {
-        reject(new Error(`create-plugin exited with code ${code}`));
-      }
-    });
-  });
-}
-
 // src/commands/analyze.ts
-import chalk13 from "chalk";
-import { existsSync as existsSync10, statSync as statSync2, readdirSync } from "fs";
-import { resolve as resolve7, join as join10, extname } from "path";
+import chalk8 from "chalk";
+import { existsSync as existsSync6, statSync, readdirSync } from "fs";
+import { resolve as resolve4, join as join7, extname } from "path";
 async function analyzeBundleSize() {
-  console.log(chalk13.bold("\n\u{1F4E6} Bundle Size Analysis\n"));
-  const distDir = resolve7(process.cwd(), "dist");
-  if (!existsSync10(distDir)) {
-    console.log(chalk13.yellow("\u26A0 No dist directory found. Run build first."));
-    return;
+  console.log(chalk8.bold("\n\u{1F4E6} Bundle Size Analysis\n"));
+  const distDir = resolve4(process.cwd(), "dist");
+  if (!existsSync6(distDir)) {
+    throw new Error("No dist/ directory to analyze. Run `objectui build` first.");
   }
   const files = [];
   function scanDirectory(dir) {
     const items = readdirSync(dir);
     for (const item of items) {
-      const fullPath = join10(dir, item);
-      const stat = statSync2(fullPath);
+      const fullPath = join7(dir, item);
+      const stat = statSync(fullPath);
       if (stat.isDirectory()) {
         scanDirectory(fullPath);
       } else {
@@ -1040,48 +1690,34 @@ async function analyzeBundleSize() {
   const cssFiles = files.filter((f) => extname(f.path) === ".css");
   const jsSize = jsFiles.reduce((sum, file) => sum + file.size, 0);
   const cssSize = cssFiles.reduce((sum, file) => sum + file.size, 0);
-  console.log(chalk13.bold("Summary:"));
-  console.log(chalk13.gray("  Total Size:"), formatBytes(totalSize));
-  console.log(chalk13.gray("  JavaScript:"), formatBytes(jsSize), chalk13.dim(`(${jsFiles.length} files)`));
-  console.log(chalk13.gray("  CSS:       "), formatBytes(cssSize), chalk13.dim(`(${cssFiles.length} files)`));
-  console.log(chalk13.gray("  Other:     "), formatBytes(totalSize - jsSize - cssSize));
-  console.log(chalk13.bold("\nLargest Files:"));
+  console.log(chalk8.bold("Summary:"));
+  console.log(chalk8.gray("  Total Size:"), formatBytes(totalSize));
+  console.log(chalk8.gray("  JavaScript:"), formatBytes(jsSize), chalk8.dim(`(${jsFiles.length} files)`));
+  console.log(chalk8.gray("  CSS:       "), formatBytes(cssSize), chalk8.dim(`(${cssFiles.length} files)`));
+  console.log(chalk8.gray("  Other:     "), formatBytes(totalSize - jsSize - cssSize));
+  console.log(chalk8.bold("\nLargest Files:"));
   files.slice(0, 10).forEach((file) => {
     const sizeStr = formatBytes(file.size).padStart(10);
-    console.log(chalk13.gray(`  ${sizeStr}`), file.path);
+    console.log(chalk8.gray(`  ${sizeStr}`), file.path);
   });
-  console.log(chalk13.bold("\n\u{1F4A1} Recommendations:"));
+  console.log(chalk8.bold("\n\u{1F4A1} Recommendations:"));
   if (totalSize > 1024 * 1024) {
-    console.log(chalk13.yellow("  \u26A0 Total bundle size is large (> 1MB)"));
-    console.log(chalk13.gray("    Consider code splitting or lazy loading"));
+    console.log(chalk8.yellow("  \u26A0 Total bundle size is large (> 1MB)"));
+    console.log(chalk8.gray("    Consider code splitting or lazy loading"));
   }
   if (jsSize > 500 * 1024) {
-    console.log(chalk13.yellow("  \u26A0 JavaScript bundle is large (> 500KB)"));
-    console.log(chalk13.gray("    Consider:"));
-    console.log(chalk13.gray("    - Tree shaking unused code"));
-    console.log(chalk13.gray("    - Lazy loading components"));
-    console.log(chalk13.gray("    - Using dynamic imports"));
+    console.log(chalk8.yellow("  \u26A0 JavaScript bundle is large (> 500KB)"));
+    console.log(chalk8.gray("    Consider:"));
+    console.log(chalk8.gray("    - Tree shaking unused code"));
+    console.log(chalk8.gray("    - Lazy loading components"));
+    console.log(chalk8.gray("    - Using dynamic imports"));
   }
   if (files.length > 100) {
-    console.log(chalk13.yellow(`  \u26A0 Large number of files (${files.length})`));
-    console.log(chalk13.gray("    Consider bundling or combining files"));
+    console.log(chalk8.yellow(`  \u26A0 Large number of files (${files.length})`));
+    console.log(chalk8.gray("    Consider bundling or combining files"));
   }
   console.log("");
 }
-async function analyzeRenderPerformance() {
-  console.log(chalk13.bold("\n\u26A1 Render Performance Analysis\n"));
-  console.log(chalk13.gray("Performance analysis features:"));
-  console.log(chalk13.gray("  \u2713 Expression caching enabled"));
-  console.log(chalk13.gray("  \u2713 Component memoization available"));
-  console.log(chalk13.gray("  \u2713 Virtual scrolling support for large lists"));
-  console.log(chalk13.bold("\n\u{1F4A1} Performance Tips:"));
-  console.log(chalk13.gray("  \u2022 Use virtual scrolling for lists > 100 items"));
-  console.log(chalk13.gray("  \u2022 Cache frequently evaluated expressions"));
-  console.log(chalk13.gray("  \u2022 Use React.memo for expensive components"));
-  console.log(chalk13.gray("  \u2022 Implement pagination for large datasets"));
-  console.log(chalk13.gray("  \u2022 Use code splitting for large apps"));
-  console.log("");
-}
 function formatBytes(bytes) {
   if (bytes === 0) return "0 B";
   const k = 1024;
@@ -1089,50 +1725,44 @@ function formatBytes(bytes) {
   const i = Math.floor(Math.log(bytes) / Math.log(k));
   return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
 }
-async function analyze(options = {}) {
-  console.log(chalk13.blue("\u{1F50D} ObjectUI Performance Analyzer\n"));
-  const runAll = !options.bundleSize && !options.renderPerformance;
-  if (options.bundleSize || runAll) {
-    await analyzeBundleSize();
-  }
-  if (options.renderPerformance || runAll) {
-    await analyzeRenderPerformance();
-  }
-  console.log(chalk13.green("\u2713 Analysis complete!\n"));
+async function analyze() {
+  console.log(chalk8.blue("\u{1F50D} ObjectUI Performance Analyzer\n"));
+  await analyzeBundleSize();
+  console.log(chalk8.green("\u2713 Analysis complete!\n"));
 }
 
 // src/cli.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname5, join as join11 } from "path";
-var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname2 = dirname5(__filename2);
+import { fileURLToPath } from "url";
+import { dirname as dirname2, join as join8 } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
 var packageJson = JSON.parse(
-  readFileSync4(join11(__dirname2, "../package.json"), "utf-8")
+  readFileSync4(join8(__dirname, "../package.json"), "utf-8")
 );
 var program = new Command();
 program.name("objectui").description("CLI tool for Object UI - Build applications from JSON schemas").version(packageJson.version);
-program.command("serve").description("Start a development server with your JSON/YAML schema").argument("[schema]", "Path to JSON/YAML schema file", "app.json").option("-p, --port <port>", "Port to run the server on", "3000").option("-h, --host <host>", "Host to bind the server to", "localhost").action(async (schema, options) => {
+program.command("serve").description("Start a development server with your JSON/YAML schema").argument("[schema]", "Path to JSON/YAML schema file, or a project / pages directory", "app.json").option("-p, --port <port>", "Port to run the server on", "3000").option("-h, --host <host>", "Host to bind the server to", "localhost").option("--no-open", "Do not open browser automatically").action(async (schema, options) => {
   try {
     await serve(schema, options);
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
-program.command("dev").description("Start development server (alias for serve)").argument("[schema]", "Path to JSON/YAML schema file", "app.json").option("-p, --port <port>", "Port to run the server on", "3000").option("-h, --host <host>", "Host to bind the server to", "localhost").option("--no-open", "Do not open browser automatically").action(async (schema, options) => {
+program.command("dev").description("Start development server (alias for serve)").argument("[schema]", "Path to JSON/YAML schema file, or a project / pages directory", "app.json").option("-p, --port <port>", "Port to run the server on", "3000").option("-h, --host <host>", "Host to bind the server to", "localhost").option("--no-open", "Do not open browser automatically").action(async (schema, options) => {
   try {
     await dev(schema, options);
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
-program.command("build").description("Build application for production").argument("[schema]", "Path to JSON/YAML schema file", "app.json").option("-o, --out-dir <dir>", "Output directory", "dist").option("--clean", "Clean output directory before build", false).action(async (schema, options) => {
+program.command("build").description("Build application for production").argument("[schema]", "Path to JSON/YAML schema file, or a project / pages directory", "app.json").option("-o, --out-dir <dir>", "Output directory", "dist").option("--clean", "Clean output directory before build", false).action(async (schema, options) => {
   try {
     await buildApp(schema, options);
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
@@ -1140,7 +1770,7 @@ program.command("start").description("Start production server").option("-p, --po
   try {
     await start(options);
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
@@ -1148,68 +1778,31 @@ program.command("init").description("Initialize a new Object UI application with
   try {
     await init(name, options);
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-});
-program.command("lint").description("Lint the generated application code").option("--fix", "Automatically fix linting issues").action(async (options) => {
-  try {
-    await lint(options);
-  } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
-program.command("test").description("Run tests for the application").option("-w, --watch", "Run tests in watch mode").option("-c, --coverage", "Generate test coverage report").option("--ui", "Run tests with Vitest UI").action(async (options) => {
+program.command("generate").alias("g").description("Generate new resources (objects, pages, plugins)").argument("<type>", "Type of resource to generate (resource/object, page, plugin)").argument("<name>", "Name of the resource").action(async (type, name) => {
   try {
-    await test(options);
-  } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-});
-program.command("generate").alias("g").description("Generate new resources (objects, pages, plugins)").argument("<type>", "Type of resource to generate (resource/object, page, plugin)").argument("<name>", "Name of the resource").option("--from <source>", "Generate schema from external source (openapi.yaml, prisma.schema)").option("--output <dir>", "Output directory for generated schemas", "schemas/").action(async (type, name, options) => {
-  try {
-    if (options.from) {
-      console.log(chalk14.yellow("\n\u26A0 Schema generation from external sources (OpenAPI/Prisma) is not yet implemented."));
-      console.log(chalk14.gray("This feature will be available in a future release.\n"));
-      process.exit(0);
-    }
     await generate(type, name);
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
-program.command("doctor").description("Diagnose and fix common issues").action(async () => {
+program.command("doctor").description("Diagnose common project setup issues (reports only, changes nothing)").action(async () => {
   try {
     await doctor();
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
-program.command("add").description("Add a new component renderer to your project").argument("<component>", "Component name (e.g. Input, Grid)").action(async (component) => {
-  try {
-    await add(component);
-  } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-});
-program.command("studio").description("Start the visual designer").action(async () => {
-  try {
-    await studio();
-  } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-});
-program.command("check").description("Validate schema files").action(async () => {
+program.command("check").description("Advisory JSON file sweep; run objectui validate for a verdict").action(async () => {
   try {
     await check();
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
@@ -1217,29 +1810,15 @@ program.command("validate").description("Validate a schema file against ObjectUI
   try {
     await validate(schema);
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-});
-program.command("create").description("Create new resources").argument("<type>", "Type of resource to create (plugin)").argument("<name>", "Name of the resource").action(async (type, name) => {
-  try {
-    if (type === "plugin") {
-      await createPlugin(name);
-    } else {
-      console.error(chalk14.red(`Unknown resource type: ${type}`));
-      console.log(chalk14.gray("Available types: plugin"));
-      process.exit(1);
-    }
-  } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
-program.command("analyze").description("Analyze application performance").option("--bundle-size", "Analyze bundle size").option("--render-performance", "Analyze render performance").action(async (options) => {
+program.command("analyze").description("Analyze application performance").action(async () => {
   try {
-    await analyze(options);
+    await analyze();
   } catch (error) {
-    console.error(chalk14.red("Error:"), error instanceof Error ? error.message : error);
+    console.error(chalk9.red("Error:"), error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });