npm - @onexapis/cli - Versions diffs - 1.1.64 → 1.1.66 - Mend

@onexapis/cli 1.1.64 → 1.1.66

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/README.md +1 -1
package/dist/cli.js +1350 -507
package/dist/cli.js.map +1 -1
package/dist/cli.mjs +1346 -503
package/dist/cli.mjs.map +1 -1
package/dist/index.d.mts +10 -17
package/dist/index.d.ts +10 -17
package/dist/index.js +477 -230
package/dist/index.js.map +1 -1
package/dist/index.mjs +473 -226
package/dist/index.mjs.map +1 -1
package/dist/preview/preview-app.tsx +89 -7
package/package.json +2 -2
package/templates/default/.env.example +1 -1

package/dist/cli.mjs CHANGED Viewed

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import chalk4 from 'chalk';
 import ora from 'ora';
-import * as esbuild from 'esbuild';
-import path9 from 'path';
-import fs8 from 'fs/promises';
-import crypto from 'crypto';
+import path11 from 'path';
 import { glob } from 'glob';
+import fs from 'fs-extra';
+import crypto from 'crypto';
+import * as esbuild from 'esbuild';
+import fs9 from 'fs/promises';
 import { createRequire } from 'module';
 import http from 'http';
 import fs3 from 'fs';
 import { WebSocketServer, WebSocket } from 'ws';
 import os from 'os';
 import dotenv from 'dotenv';
-import fs from 'fs-extra';
 import ejs from 'ejs';
 import { execSync, spawn } from 'child_process';
 import { Command } from 'commander';
@@ -89,6 +89,206 @@ var init_logger = __esm({
     logger = new Logger();
   }
 });
+function sortedCopy(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => sortedCopy(v));
+  }
+  if (value && typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = sortedCopy(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function normalizeField(raw) {
+  const out = {
+    id: String(raw.id),
+    type: String(raw.type)
+  };
+  if (raw.required === true) out.required = true;
+  if (raw.default !== void 0) out.default = raw.default;
+  if (Array.isArray(raw.aliases) && raw.aliases.length > 0) {
+    out.aliases = [...raw.aliases].map(String).sort();
+  }
+  if (typeof raw.maxLength === "number") out.maxLength = raw.maxLength;
+  if (typeof raw.min === "number") out.min = raw.min;
+  if (typeof raw.max === "number") out.max = raw.max;
+  if (typeof raw.step === "number") out.step = raw.step;
+  if (Array.isArray(raw.accept)) {
+    out.accept = [...raw.accept].map(String).sort();
+  }
+  if (Array.isArray(raw.options)) {
+    out.options = raw.options.map((o) => String(o?.value ?? o)).sort();
+  }
+  return out;
+}
+function normalizeBlock(raw) {
+  return {
+    type: String(raw.type),
+    settings: Array.isArray(raw.settings) ? raw.settings.map(normalizeField).sort(sortFieldsById) : [],
+    defaults: raw.defaults && typeof raw.defaults === "object" ? sortedCopy(raw.defaults) : {},
+    ...typeof raw.limit === "number" ? { limit: raw.limit } : {},
+    ...typeof raw.min === "number" ? { min: raw.min } : {},
+    ...raw.sortable === true ? { sortable: true } : {},
+    ...raw.baseType ? { baseType: String(raw.baseType) } : {}
+  };
+}
+function normalizeTemplate(raw) {
+  const out = { id: String(raw.id) };
+  if (raw.isDefault === true) out.isDefault = true;
+  if (Array.isArray(raw.settings)) {
+    out.settings = raw.settings.map(normalizeField).sort(sortFieldsById);
+  }
+  if (raw.defaults && typeof raw.defaults === "object") {
+    out.defaults = sortedCopy(raw.defaults);
+  }
+  return out;
+}
+function sortFieldsById(a, b) {
+  return a.id.localeCompare(b.id);
+}
+function sortByType(a, b) {
+  return a.type.localeCompare(b.type);
+}
+function normalizeSection(raw) {
+  return {
+    type: String(raw.type),
+    settings: Array.isArray(raw.settings) ? raw.settings.map(normalizeField).sort(sortFieldsById) : [],
+    defaults: raw.defaults && typeof raw.defaults === "object" ? sortedCopy(raw.defaults) : {},
+    blocks: Array.isArray(raw.blocks) ? raw.blocks.map(normalizeBlock).sort(sortByType) : [],
+    templates: Array.isArray(raw.templates) ? raw.templates.map(normalizeTemplate).sort(sortFieldsById) : [],
+    dataRequirements: raw.dataRequirements && typeof raw.dataRequirements === "object" ? sortedCopy(raw.dataRequirements) : null,
+    ...raw.global === true ? { global: true } : {},
+    ...typeof raw.maxBlocks === "number" ? { maxBlocks: raw.maxBlocks } : {}
+  };
+}
+async function extractSchemas(themePath) {
+  const { createJiti } = await import('jiti');
+  const jiti = createJiti(import.meta.url);
+  const schemaFiles = await glob("sections/**/*.schema.ts", { cwd: themePath });
+  const sections = {};
+  for (const file of schemaFiles) {
+    try {
+      const mod = await jiti.import(path11.join(themePath, file));
+      const exports$1 = mod;
+      for (const value of Object.values(exports$1)) {
+        if (value && typeof value === "object" && typeof value.type === "string" && Array.isArray(value.settings)) {
+          const section = normalizeSection(value);
+          sections[section.type] = section;
+        }
+      }
+    } catch {
+    }
+  }
+  const manifest = {
+    manifestVersion: 1,
+    sections: {}
+  };
+  for (const type of Object.keys(sections).sort()) {
+    manifest.sections[type] = sections[type];
+  }
+  return manifest;
+}
+function serializeManifest(manifest) {
+  return JSON.stringify(sortedCopy(manifest), null, 2);
+}
+var init_extract_schemas = __esm({
+  "src/utils/extract-schemas.ts"() {
+  }
+});
+function isVideoAsset(filePath) {
+  const lower = filePath.toLowerCase();
+  return VIDEO_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+function mimeFor(filename) {
+  const ext = path11.extname(filename).toLowerCase();
+  return MIME_MAP[ext] || "application/octet-stream";
+}
+async function sha256Prefix(absPath, len) {
+  const buf = await fs.readFile(absPath);
+  return crypto.createHash("sha256").update(buf).digest("hex").slice(0, len);
+}
+function insertHashIntoName(relPath, hash) {
+  const dir = path11.posix.dirname(relPath);
+  const base = path11.posix.basename(relPath);
+  const ext = path11.posix.extname(base);
+  const stem = ext ? base.slice(0, -ext.length) : base;
+  const hashed = `${stem}-${hash}${ext}`;
+  return dir === "." ? hashed : `${dir}/${hashed}`;
+}
+async function scanThemeAssets(distDir) {
+  const assetsDir = path11.join(distDir, "theme-assets");
+  if (!await fs.pathExists(assetsDir)) return [];
+  const files = await glob("**/*", {
+    cwd: assetsDir,
+    nodir: true,
+    dot: false
+  });
+  const results = [];
+  for (const rel of files) {
+    const absPath = path11.join(assetsDir, rel);
+    const stat = await fs.stat(absPath);
+    if (!stat.isFile()) continue;
+    const originalPath = rel.split(path11.sep).join("/");
+    const hash = await sha256Prefix(absPath, HASH_LEN);
+    const hashedPath = insertHashIntoName(originalPath, hash);
+    const contentType = mimeFor(rel);
+    results.push({
+      originalPath,
+      hashedPath,
+      hash,
+      size: stat.size,
+      contentType,
+      absPath
+    });
+  }
+  results.sort((a, b) => a.originalPath.localeCompare(b.originalPath));
+  return results;
+}
+function buildAssetMap(entries) {
+  const map = {};
+  for (const e of entries) {
+    map[e.originalPath] = e.hashedPath;
+  }
+  return map;
+}
+var MIME_MAP, HASH_LEN, VIDEO_EXTENSIONS;
+var init_scan_theme_assets = __esm({
+  "src/utils/scan-theme-assets.ts"() {
+    MIME_MAP = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".avif": "image/avif",
+      ".svg": "image/svg+xml",
+      ".ico": "image/x-icon",
+      ".bmp": "image/bmp",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".otf": "font/otf",
+      ".eot": "application/vnd.ms-fontobject",
+      ".mp4": "video/mp4",
+      ".webm": "video/webm",
+      ".mov": "video/quicktime",
+      ".ogg": "video/ogg",
+      ".json": "application/json"
+    };
+    HASH_LEN = 8;
+    VIDEO_EXTENSIONS = [
+      ".mp4",
+      ".webm",
+      ".ogg",
+      ".mov",
+      ".avi",
+      ".mkv"
+    ];
+  }
+});
 // src/utils/compile-theme.ts
 var compile_theme_exports = {};
@@ -104,8 +304,8 @@ async function generateThemeCSS(themePath, outDir) {
     const tailwindcss = (await import('tailwindcss')).default;
     const tailwindConfig = {
       content: [
-        path9.join(themePath, "sections/**/*.{ts,tsx}"),
-        path9.join(themePath, "components/**/*.{ts,tsx}")
+        path11.join(themePath, "sections/**/*.{ts,tsx}"),
+        path11.join(themePath, "components/**/*.{ts,tsx}")
       ],
       theme: { extend: {} },
       plugins: []
@@ -115,7 +315,7 @@ async function generateThemeCSS(themePath, outDir) {
       inputCSS,
       { from: void 0 }
     );
-    await fs8.writeFile(path9.join(outDir, "bundle.css"), result.css);
+    await fs9.writeFile(path11.join(outDir, "bundle.css"), result.css);
     logger.info("Generated bundle.css");
   } catch (err) {
     logger.warning(
@@ -126,12 +326,12 @@ async function generateThemeCSS(themePath, outDir) {
 async function resolveNodeModulesFile(startDir, relativePath) {
   let dir = startDir;
   while (true) {
-    const candidate = path9.join(dir, "node_modules", relativePath);
+    const candidate = path11.join(dir, "node_modules", relativePath);
     try {
-      await fs8.access(candidate);
+      await fs9.access(candidate);
       return candidate;
     } catch {
-      const parent = path9.dirname(dir);
+      const parent = path11.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -155,7 +355,7 @@ async function scanImportsFromPackage(sourceDir, packageName) {
   });
   for (const file of sourceFiles) {
     try {
-      const content = await fs8.readFile(path9.join(sourceDir, file), "utf-8");
+      const content = await fs9.readFile(path11.join(sourceDir, file), "utf-8");
       for (const match of content.matchAll(namespaceImportRegex)) {
         const subpath = match[1] ? match[1].slice(1) : "";
         if (!result[subpath]) result[subpath] = /* @__PURE__ */ new Set();
@@ -209,17 +409,17 @@ function createCoreGlobalPlugin(themePath) {
           const distFileName = subpath ? `${subpath}.mjs` : "index.mjs";
           let distPath = await resolveNodeModulesFile(
             themePath,
-            path9.join("@onexapis", "core", "dist", distFileName)
+            path11.join("@onexapis", "core", "dist", distFileName)
           );
           if (!distPath) {
             distPath = await resolveNodeModulesFile(
               __dirname,
-              path9.join("@onexapis", "core", "dist", distFileName)
+              path11.join("@onexapis", "core", "dist", distFileName)
             );
           }
           try {
             if (!distPath) throw new Error("not found");
-            const distContent = await fs8.readFile(distPath, "utf-8");
+            const distContent = await fs9.readFile(distPath, "utf-8");
             const exportMatches = distContent.matchAll(/export\s*\{([^}]+)\}/g);
             for (const m of exportMatches) {
               const names = m[1].split(",").map((n) => {
@@ -448,7 +648,7 @@ async function generateThemeData(themePath, outputDir, themeId) {
   const pages = {};
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path9.join(themePath, `theme.config${ext}`));
+      const mod = await jiti.import(path11.join(themePath, `theme.config${ext}`));
       themeConfig = mod.default || mod;
       break;
     } catch {
@@ -456,20 +656,20 @@ async function generateThemeData(themePath, outputDir, themeId) {
   }
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path9.join(themePath, `theme.layout${ext}`));
+      const mod = await jiti.import(path11.join(themePath, `theme.layout${ext}`));
       layoutConfig = mod.default || mod;
       break;
     } catch {
     }
   }
   const schemas = {};
-  const sectionsDir = path9.join(themePath, "sections");
+  const sectionsDir = path11.join(themePath, "sections");
   try {
-    const sectionDirs = await fs8.readdir(sectionsDir);
+    const sectionDirs = await fs9.readdir(sectionsDir);
     for (const dir of sectionDirs) {
-      const schemaFile = path9.join(sectionsDir, dir, `${dir}.schema.ts`);
+      const schemaFile = path11.join(sectionsDir, dir, `${dir}.schema.ts`);
       try {
-        await fs8.access(schemaFile);
+        await fs9.access(schemaFile);
         const mod = await jiti.import(schemaFile);
         for (const [key, value] of Object.entries(mod)) {
           if (key.endsWith("Schema") && value && typeof value === "object" && value.type) {
@@ -481,14 +681,14 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  const pagesDir = path9.join(themePath, "pages");
+  const pagesDir = path11.join(themePath, "pages");
   try {
-    const files = await fs8.readdir(pagesDir);
+    const files = await fs9.readdir(pagesDir);
     for (const file of files) {
       if (!file.match(/\.(ts|js)$/)) continue;
       const name = file.replace(/\.(ts|js)$/, "");
       try {
-        const mod = await jiti.import(path9.join(pagesDir, file));
+        const mod = await jiti.import(path11.join(pagesDir, file));
         const config = mod.default || mod;
         const sections = (config.sections || []).map((section) => {
           const schema = schemas[section.type];
@@ -516,8 +716,8 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  await fs8.writeFile(
-    path9.join(outputDir, "theme-data.json"),
+  await fs9.writeFile(
+    path11.join(outputDir, "theme-data.json"),
     JSON.stringify(
       {
         themeId,
@@ -540,22 +740,22 @@ async function generateThemeData(themePath, outputDir, themeId) {
   logger.info(`Generated theme-data.json (${Object.keys(pages).length} pages)`);
 }
 async function contentHashEntry(outputDir) {
-  const entryPath = path9.join(outputDir, "bundle-entry.js");
-  const mapPath = path9.join(outputDir, "bundle-entry.js.map");
+  const entryPath = path11.join(outputDir, "bundle-entry.js");
+  const mapPath = path11.join(outputDir, "bundle-entry.js.map");
   let entryContent;
   try {
-    entryContent = await fs8.readFile(entryPath, "utf-8");
+    entryContent = await fs9.readFile(entryPath, "utf-8");
   } catch {
-    const indexPath = path9.join(outputDir, "index.js");
+    const indexPath = path11.join(outputDir, "index.js");
     try {
-      entryContent = await fs8.readFile(indexPath, "utf-8");
+      entryContent = await fs9.readFile(indexPath, "utf-8");
     } catch {
       logger.warning("No entry file found in output, skipping content hash");
       return;
     }
     const hash2 = crypto.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
     const hashedName2 = `bundle-entry-${hash2}.js`;
-    const indexMapPath = path9.join(outputDir, "index.js.map");
+    const indexMapPath = path11.join(outputDir, "index.js.map");
     const hashedMapName2 = `bundle-entry-${hash2}.js.map`;
     entryContent = entryContent.replace(
       /\/\/# sourceMappingURL=index\.js\.map/,
@@ -563,18 +763,18 @@ async function contentHashEntry(outputDir) {
     );
     const oldFiles2 = await glob("bundle-entry-*.js*", { cwd: outputDir });
     for (const f of oldFiles2) {
-      await fs8.unlink(path9.join(outputDir, f));
+      await fs9.unlink(path11.join(outputDir, f));
     }
-    await fs8.writeFile(path9.join(outputDir, hashedName2), entryContent);
-    await fs8.unlink(indexPath);
+    await fs9.writeFile(path11.join(outputDir, hashedName2), entryContent);
+    await fs9.unlink(indexPath);
     try {
-      await fs8.unlink(entryPath);
+      await fs9.unlink(entryPath);
     } catch {
     }
-    await fs8.writeFile(entryPath, entryContent);
+    await fs9.writeFile(entryPath, entryContent);
     try {
-      await fs8.access(indexMapPath);
-      await fs8.rename(indexMapPath, path9.join(outputDir, hashedMapName2));
+      await fs9.access(indexMapPath);
+      await fs9.rename(indexMapPath, path11.join(outputDir, hashedMapName2));
     } catch {
     }
     logger.info(`Entry hashed: ${hashedName2}`);
@@ -589,17 +789,17 @@ async function contentHashEntry(outputDir) {
   );
   const oldFiles = await glob("bundle-entry-*.js*", { cwd: outputDir });
   for (const f of oldFiles) {
-    await fs8.unlink(path9.join(outputDir, f));
+    await fs9.unlink(path11.join(outputDir, f));
   }
-  await fs8.writeFile(path9.join(outputDir, hashedName), entryContent);
+  await fs9.writeFile(path11.join(outputDir, hashedName), entryContent);
   try {
-    await fs8.unlink(entryPath);
+    await fs9.unlink(entryPath);
   } catch {
   }
-  await fs8.writeFile(entryPath, entryContent);
+  await fs9.writeFile(entryPath, entryContent);
   try {
-    await fs8.access(mapPath);
-    await fs8.rename(mapPath, path9.join(outputDir, hashedMapName));
+    await fs9.access(mapPath);
+    await fs9.rename(mapPath, path11.join(outputDir, hashedMapName));
   } catch {
   }
   logger.info(`Entry hashed: ${hashedName}`);
@@ -611,7 +811,7 @@ async function extractDataRequirements(themePath) {
   const requirements = {};
   for (const file of schemaFiles) {
     try {
-      const mod = await jiti.import(path9.join(themePath, file));
+      const mod = await jiti.import(path11.join(themePath, file));
       const exports$1 = mod;
       for (const value of Object.values(exports$1)) {
         if (value && typeof value === "object" && typeof value.type === "string" && value.dataRequirements && typeof value.dataRequirements === "object") {
@@ -626,12 +826,46 @@ async function extractDataRequirements(themePath) {
   }
   return requirements;
 }
+async function writeGateManifests(themePath, outputDir) {
+  try {
+    const schemas = await extractSchemas(themePath);
+    await fs9.writeFile(
+      path11.join(outputDir, "schemas.json"),
+      serializeManifest(schemas)
+    );
+    logger.info(
+      `Generated schemas.json (${Object.keys(schemas.sections).length} sections)`
+    );
+  } catch (err) {
+    logger.warning(
+      `schemas.json not written: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    const entries = await scanThemeAssets(outputDir);
+    const assets = entries.map((e) => ({
+      path: e.originalPath,
+      hash: e.hash,
+      size: e.size,
+      contentType: e.contentType
+    }));
+    await fs9.writeFile(
+      path11.join(outputDir, "asset-manifest.json"),
+      JSON.stringify({ manifestVersion: 1, assets }, null, 2)
+    );
+    logger.info(`Generated asset-manifest.json (${assets.length} assets)`);
+  } catch (err) {
+    logger.warning(
+      `asset-manifest.json not written: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 async function generateManifest(themeName, themePath, outputDir) {
   let version2 = "1.0.0";
   let themeId = themeName;
   try {
-    const pkgContent = await fs8.readFile(
-      path9.join(themePath, "package.json"),
+    const pkgContent = await fs9.readFile(
+      path11.join(themePath, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(pkgContent);
@@ -649,7 +883,7 @@ async function generateManifest(themeName, themePath, outputDir) {
   const dataRequirements = await extractDataRequirements(themePath);
   let hasThemeConfig = false;
   try {
-    await fs8.access(path9.join(themePath, "theme.config.ts"));
+    await fs9.access(path11.join(themePath, "theme.config.ts"));
     hasThemeConfig = true;
   } catch {
   }
@@ -690,24 +924,24 @@ async function generateManifest(themeName, themePath, outputDir) {
     // Section data requirements for server-side prefetching (keyed by section type)
     dataRequirements
   };
-  await fs8.writeFile(
-    path9.join(outputDir, "manifest.json"),
+  await fs9.writeFile(
+    path11.join(outputDir, "manifest.json"),
     JSON.stringify(manifest, null, 2)
   );
 }
 async function compileStandaloneTheme(themePath, themeName) {
-  const outputDir = path9.join(themePath, "dist");
-  const bundleEntry = path9.join(themePath, "bundle-entry.ts");
-  const indexEntry = path9.join(themePath, "index.ts");
+  const outputDir = path11.join(themePath, "dist");
+  const bundleEntry = path11.join(themePath, "bundle-entry.ts");
+  const indexEntry = path11.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs8.access(bundleEntry);
+    await fs9.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path9.join(outputDir, ".process-shim.js");
-  await fs8.mkdir(outputDir, { recursive: true });
-  await fs8.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path11.join(outputDir, ".process-shim.js");
+  await fs9.mkdir(outputDir, { recursive: true });
+  await fs9.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -758,19 +992,20 @@ async function compileStandaloneTheme(themePath, themeName) {
   try {
     const result = await esbuild.build(buildOptions);
     try {
-      await fs8.unlink(shimPath);
+      await fs9.unlink(shimPath);
     } catch {
     }
     await contentHashEntry(outputDir);
-    const themeAssetsDir = path9.join(themePath, "assets");
-    const distThemeAssets = path9.join(outputDir, "theme-assets");
+    const themeAssetsDir = path11.join(themePath, "assets");
+    const distThemeAssets = path11.join(outputDir, "theme-assets");
     try {
-      await fs8.access(themeAssetsDir);
-      await fs8.cp(themeAssetsDir, distThemeAssets, { recursive: true });
+      await fs9.access(themeAssetsDir);
+      await fs9.cp(themeAssetsDir, distThemeAssets, { recursive: true });
       logger.info("Copied static assets to dist/theme-assets/");
     } catch {
     }
     await generateManifest(themeName, themePath, outputDir);
+    await writeGateManifests(themePath, outputDir);
     await generateThemeData(themePath, outputDir, themeName);
     await generateThemeCSS(themePath, outputDir);
     if (result.metafile) {
@@ -785,7 +1020,7 @@ async function compileStandaloneTheme(themePath, themeName) {
     return true;
   } catch (error) {
     try {
-      await fs8.unlink(shimPath);
+      await fs9.unlink(shimPath);
     } catch {
     }
     logger.error(`esbuild compilation failed: ${error}`);
@@ -793,18 +1028,18 @@ async function compileStandaloneTheme(themePath, themeName) {
   }
 }
 async function compileStandaloneThemeDev(themePath, themeName) {
-  const outputDir = path9.join(themePath, "dist");
-  const bundleEntry = path9.join(themePath, "bundle-entry.ts");
-  const indexEntry = path9.join(themePath, "index.ts");
+  const outputDir = path11.join(themePath, "dist");
+  const bundleEntry = path11.join(themePath, "bundle-entry.ts");
+  const indexEntry = path11.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs8.access(bundleEntry);
+    await fs9.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path9.join(outputDir, ".process-shim.js");
-  await fs8.mkdir(outputDir, { recursive: true });
-  await fs8.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path11.join(outputDir, ".process-shim.js");
+  await fs9.mkdir(outputDir, { recursive: true });
+  await fs9.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -858,18 +1093,18 @@ async function compileStandaloneThemeDev(themePath, themeName) {
   return { context: context2, outputDir };
 }
 async function compilePreviewRuntime(themePath) {
-  const outputDir = path9.join(themePath, "dist");
-  await fs8.mkdir(outputDir, { recursive: true });
-  const outputPath = path9.join(outputDir, "preview-runtime.js");
+  const outputDir = path11.join(themePath, "dist");
+  await fs9.mkdir(outputDir, { recursive: true });
+  const outputPath = path11.join(outputDir, "preview-runtime.js");
   const locations = [
-    path9.join(__dirname, "..", "preview", "preview-app.tsx"),
-    path9.join(__dirname, "preview", "preview-app.tsx"),
-    path9.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
+    path11.join(__dirname, "..", "preview", "preview-app.tsx"),
+    path11.join(__dirname, "preview", "preview-app.tsx"),
+    path11.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
   ];
   let previewEntryPath = null;
   for (const loc of locations) {
     try {
-      await fs8.access(loc);
+      await fs9.access(loc);
       previewEntryPath = loc;
       break;
     } catch {
@@ -952,10 +1187,10 @@ ${locations.join("\n")}`
         if (!lucideScanned) {
           lucideScanned = true;
           const coreSrcCandidates = [
-            path9.join(themePath, "node_modules", "@onexapis", "core", "src"),
-            path9.join(themePath, "..", "..", "packages", "core", "src"),
+            path11.join(themePath, "node_modules", "@onexapis", "core", "src"),
+            path11.join(themePath, "..", "..", "packages", "core", "src"),
             // monorepo sibling
-            path9.join(
+            path11.join(
               __dirname,
               "..",
               "..",
@@ -970,7 +1205,7 @@ ${locations.join("\n")}`
           let coreSourceDir = null;
           for (const candidate of coreSrcCandidates) {
             try {
-              await fs8.access(candidate);
+              await fs9.access(candidate);
               coreSourceDir = candidate;
               break;
             } catch {
@@ -989,21 +1224,21 @@ ${locations.join("\n")}`
             }
           } else {
             const coreDistCandidates = [
-              path9.join(themePath, "node_modules", "@onexapis", "core", "dist")
+              path11.join(themePath, "node_modules", "@onexapis", "core", "dist")
             ];
             const resolvedDist = await resolveNodeModulesFile(
               __dirname,
-              path9.join("@onexapis", "core", "dist")
+              path11.join("@onexapis", "core", "dist")
             );
             if (resolvedDist) coreDistCandidates.push(resolvedDist);
             for (const candidate of coreDistCandidates) {
               try {
-                await fs8.access(candidate);
+                await fs9.access(candidate);
                 const mjsFiles = await glob("*.mjs", { cwd: candidate });
                 const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']lucide-react["']/g;
                 for (const file of mjsFiles) {
-                  const content = await fs8.readFile(
-                    path9.join(candidate, file),
+                  const content = await fs9.readFile(
+                    path11.join(candidate, file),
                     "utf-8"
                   );
                   for (const match of content.matchAll(importRegex)) {
@@ -1058,7 +1293,7 @@ export default new Proxy({}, { get: (_, name) => name === '__esModule' ? true :
           const req = createRequire(import.meta.url || __filename);
           const cjsPath = req.resolve("framer-motion");
           const pkgDir = cjsPath.replace(/[/\\]dist[/\\].*$/, "");
-          const esmEntry = path9.join(pkgDir, "dist", "es", "index.mjs");
+          const esmEntry = path11.join(pkgDir, "dist", "es", "index.mjs");
           const { existsSync } = await import('fs');
           if (existsSync(esmEntry)) {
             return { path: esmEntry, namespace: "file" };
@@ -1157,8 +1392,8 @@ export function headers() { return new Headers(); }
       });
     }
   };
-  const shimPath = path9.join(outputDir, ".process-shim-preview.js");
-  await fs8.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path11.join(outputDir, ".process-shim-preview.js");
+  await fs9.writeFile(shimPath, PROCESS_SHIM);
   await esbuild.build({
     entryPoints: [previewEntryPath],
     bundle: true,
@@ -1193,7 +1428,7 @@ export function headers() { return new Headers(); }
     }
   });
   try {
-    await fs8.unlink(shimPath);
+    await fs9.unlink(shimPath);
   } catch {
   }
   return outputPath;
@@ -1202,6 +1437,8 @@ var PROCESS_SHIM, reactGlobalPlugin, reactQueryGlobalPlugin;
 var init_compile_theme = __esm({
   "src/utils/compile-theme.ts"() {
     init_logger();
+    init_extract_schemas();
+    init_scan_theme_assets();
     PROCESS_SHIM = `
 if (typeof process === "undefined") {
   globalThis.process = {
@@ -1357,7 +1594,7 @@ __export(dev_server_exports, {
 });
 function createDevServer(options) {
   const clients = /* @__PURE__ */ new Set();
-  const themeDataPath = path9.join(options.distDir, "theme-data.json");
+  const themeDataPath = path11.join(options.distDir, "theme-data.json");
   const server = http.createServer((req, res) => {
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
@@ -1383,8 +1620,8 @@ function createDevServer(options) {
     if (pathname.startsWith("/_assets/")) {
       const parts = pathname.replace(/^\/_assets\//, "").split("/");
       const assetSubpath = parts.slice(1).join("/");
-      const assetPath = path9.join(options.themePath, "assets", assetSubpath);
-      if (!assetPath.startsWith(path9.join(options.themePath, "assets"))) {
+      const assetPath = path11.join(options.themePath, "assets", assetSubpath);
+      if (!assetPath.startsWith(path11.join(options.themePath, "assets"))) {
         res.writeHead(403);
         res.end("Forbidden");
         return;
@@ -1395,8 +1632,8 @@ function createDevServer(options) {
     if (pathname.startsWith("/themes/")) {
       const match = pathname.match(/^\/themes\/[^/]+\/assets\/(.+)/);
       if (match) {
-        const assetPath = path9.join(options.themePath, "assets", match[1]);
-        if (!assetPath.startsWith(path9.join(options.themePath, "assets"))) {
+        const assetPath = path11.join(options.themePath, "assets", match[1]);
+        if (!assetPath.startsWith(path11.join(options.themePath, "assets"))) {
           res.writeHead(403);
           res.end("Forbidden");
           return;
@@ -1408,26 +1645,26 @@ function createDevServer(options) {
     if (pathname.startsWith("/assets/")) {
       const subpath = pathname.replace(/^\/assets\//, "");
       const segments = subpath.split("/");
-      const assetsBase = path9.join(options.themePath, "assets");
+      const assetsBase = path11.join(options.themePath, "assets");
       let assetPath;
       if (segments[0] === options.themeName || segments[0] === options.themeName.replace(/^my-/, "")) {
-        assetPath = path9.join(assetsBase, segments.slice(1).join("/"));
+        assetPath = path11.join(assetsBase, segments.slice(1).join("/"));
       } else {
-        assetPath = path9.join(assetsBase, subpath);
+        assetPath = path11.join(assetsBase, subpath);
       }
       if (assetPath.startsWith(assetsBase) && fs3.existsSync(assetPath)) {
         serveFile(res, assetPath);
         return;
       }
       if (segments.length > 1) {
-        const fallbackPath = path9.join(assetsBase, segments.slice(1).join("/"));
+        const fallbackPath = path11.join(assetsBase, segments.slice(1).join("/"));
         if (fallbackPath.startsWith(assetsBase) && fs3.existsSync(fallbackPath)) {
           serveFile(res, fallbackPath);
           return;
         }
       }
     }
-    const filePath = path9.join(options.distDir, pathname);
+    const filePath = path11.join(options.distDir, pathname);
     if (!filePath.startsWith(options.distDir)) {
       res.writeHead(403);
       res.end("Forbidden");
@@ -1470,7 +1707,7 @@ function serveFile(res, filePath) {
       res.end("Not Found");
       return;
     }
-    const ext = path9.extname(filePath);
+    const ext = path11.extname(filePath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     const content = fs3.readFileSync(filePath);
     res.writeHead(200, { "Content-Type": contentType });
@@ -1591,18 +1828,18 @@ async function renderTemplate(templatePath, data) {
   return ejs.render(template, data);
 }
 async function writeFile(filePath, content) {
-  await fs.ensureDir(path9.dirname(filePath));
+  await fs.ensureDir(path11.dirname(filePath));
   await fs.writeFile(filePath, content, "utf-8");
 }
 function getTemplatesDir() {
   const locations = [
-    path9.join(__dirname, "../../templates"),
+    path11.join(__dirname, "../../templates"),
     // Development
-    path9.join(__dirname, "../templates"),
+    path11.join(__dirname, "../templates"),
     // Production (dist/)
-    path9.join(process.cwd(), "templates"),
+    path11.join(process.cwd(), "templates"),
     // Fallback
-    path9.join(process.cwd(), "packages/cli/templates")
+    path11.join(process.cwd(), "packages/cli/templates")
     // Monorepo
   ];
   for (const location of locations) {
@@ -1614,7 +1851,7 @@ function getTemplatesDir() {
 }
 async function copyTemplate(templateName, targetDir, data) {
   const templatesDir = getTemplatesDir();
-  const templateDir = path9.join(templatesDir, templateName);
+  const templateDir = path11.join(templatesDir, templateName);
   if (!fs.existsSync(templateDir)) {
     throw new Error(
       `Template "${templateName}" not found at ${templateDir}. Available templates: ${fs.readdirSync(templatesDir).join(", ")}`
@@ -1623,8 +1860,8 @@ async function copyTemplate(templateName, targetDir, data) {
   await fs.ensureDir(targetDir);
   const files = await fs.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path9.join(templateDir, file);
-    const targetPath = path9.join(targetDir, file);
+    const templatePath = path11.join(templateDir, file);
+    const targetPath = path11.join(targetDir, file);
     const stat = await fs.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -1641,8 +1878,8 @@ async function copyTemplateDir(templateDir, targetDir, data) {
   await fs.ensureDir(targetDir);
   const files = await fs.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path9.join(templateDir, file);
-    const targetPath = path9.join(targetDir, file);
+    const templatePath = path11.join(templateDir, file);
+    const targetPath = path11.join(targetDir, file);
     const stat = await fs.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -1657,32 +1894,32 @@ async function copyTemplateDir(templateDir, targetDir, data) {
 }
 function getProjectRoot() {
   let currentDir = process.cwd();
-  while (currentDir !== path9.parse(currentDir).root) {
-    const packageJsonPath = path9.join(currentDir, "package.json");
+  while (currentDir !== path11.parse(currentDir).root) {
+    const packageJsonPath = path11.join(currentDir, "package.json");
     if (fs.existsSync(packageJsonPath)) {
       const packageJson = fs.readJsonSync(packageJsonPath);
-      if (packageJson.workspaces || fs.existsSync(path9.join(currentDir, "src/themes")) || fs.existsSync(path9.join(currentDir, "themes"))) {
+      if (packageJson.workspaces || fs.existsSync(path11.join(currentDir, "src/themes")) || fs.existsSync(path11.join(currentDir, "themes"))) {
         return currentDir;
       }
     }
-    currentDir = path9.dirname(currentDir);
+    currentDir = path11.dirname(currentDir);
   }
   return process.cwd();
 }
 function getThemesDir() {
   const root = getProjectRoot();
-  if (fs.existsSync(path9.join(root, "themes")))
-    return path9.join(root, "themes");
-  if (fs.existsSync(path9.join(root, "src/themes")))
-    return path9.join(root, "src/themes");
-  return path9.dirname(root);
+  if (fs.existsSync(path11.join(root, "themes")))
+    return path11.join(root, "themes");
+  if (fs.existsSync(path11.join(root, "src/themes")))
+    return path11.join(root, "src/themes");
+  return path11.dirname(root);
 }
 function getFeaturesDir() {
-  return path9.join(getProjectRoot(), "src/features");
+  return path11.join(getProjectRoot(), "src/features");
 }
 function isOneXProject() {
   const root = getProjectRoot();
-  return fs.existsSync(path9.join(root, "themes")) || fs.existsSync(path9.join(root, "src/themes")) || fs.existsSync(path9.join(root, "theme.config.ts")) || fs.existsSync(path9.join(root, "bundle-entry.ts"));
+  return fs.existsSync(path11.join(root, "themes")) || fs.existsSync(path11.join(root, "src/themes")) || fs.existsSync(path11.join(root, "theme.config.ts")) || fs.existsSync(path11.join(root, "bundle-entry.ts"));
 }
 function ensureOneXProject() {
   if (!isOneXProject()) {
@@ -1698,13 +1935,13 @@ function listThemes() {
     return [];
   }
   return fs.readdirSync(themesDir).filter((name) => {
-    const themePath = path9.join(themesDir, name);
-    return fs.statSync(themePath).isDirectory() && (fs.existsSync(path9.join(themePath, "theme.config.ts")) || fs.existsSync(path9.join(themePath, "bundle-entry.ts")) || fs.existsSync(path9.join(themePath, "manifest.ts")));
+    const themePath = path11.join(themesDir, name);
+    return fs.statSync(themePath).isDirectory() && (fs.existsSync(path11.join(themePath, "theme.config.ts")) || fs.existsSync(path11.join(themePath, "bundle-entry.ts")) || fs.existsSync(path11.join(themePath, "manifest.ts")));
   });
 }
 function themeExists(themeName) {
-  const themePath = path9.join(getThemesDir(), themeName);
-  return fs.existsSync(themePath) && (fs.existsSync(path9.join(themePath, "theme.config.ts")) || fs.existsSync(path9.join(themePath, "bundle-entry.ts")) || fs.existsSync(path9.join(themePath, "manifest.ts")));
+  const themePath = path11.join(getThemesDir(), themeName);
+  return fs.existsSync(themePath) && (fs.existsSync(path11.join(themePath, "theme.config.ts")) || fs.existsSync(path11.join(themePath, "bundle-entry.ts")) || fs.existsSync(path11.join(themePath, "manifest.ts")));
 }
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
@@ -1712,9 +1949,9 @@ function detectPackageManager() {
   if (userAgent.includes("yarn")) return "yarn";
   if (userAgent.includes("bun")) return "bun";
   const cwd = process.cwd();
-  if (fs.existsSync(path9.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs.existsSync(path9.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs.existsSync(path9.join(cwd, "bun.lockb"))) return "bun";
+  if (fs.existsSync(path11.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path11.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path11.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 async function installDependencies(projectPath, packageManager = "npm") {
@@ -1763,22 +2000,45 @@ function getValidCategories() {
     "contact"
   ];
 }
-var AUTH_DIR = path9.join(os.homedir(), ".onexthm");
-var AUTH_FILE = path9.join(AUTH_DIR, "auth.json");
-function getApiUrl() {
-  return process.env.ONEXTHM_API_URL || "https://platform-dev.onexeos.com";
+var AUTH_DIR = path11.join(os.homedir(), ".onexthm");
+var ENV_URLS = {
+  dev: "https://platform-dev.onexeos.com",
+  staging: "https://platform-staging.onexeos.com",
+  prod: "https://platform-apis.onexeos.com"
+};
+function getAuthFile(env = "dev") {
+  const newFile = path11.join(AUTH_DIR, `auth-${env}.json`);
+  if (env === "dev") {
+    const legacyFile = path11.join(AUTH_DIR, "auth.json");
+    if (fs.existsSync(legacyFile) && !fs.existsSync(newFile)) {
+      try {
+        fs.moveSync(legacyFile, newFile);
+      } catch {
+        try {
+          fs.copySync(legacyFile, newFile);
+          fs.removeSync(legacyFile);
+        } catch {
+        }
+      }
+    }
+  }
+  return newFile;
+}
+function getApiUrl(env = "dev") {
+  return process.env.ONEXTHM_API_URL || ENV_URLS[env];
 }
-async function saveAuthTokens(tokens) {
+async function saveAuthTokens(tokens, env = "dev") {
   await fs.ensureDir(AUTH_DIR);
   const key = getMachineKey();
   const data = JSON.stringify(tokens);
   const encrypted = encrypt(data, key);
-  await fs.writeFile(AUTH_FILE, encrypted, "utf-8");
+  await fs.writeFile(getAuthFile(env), encrypted, "utf-8");
 }
-function loadAuthTokens() {
+function loadAuthTokens(env = "dev") {
   try {
-    if (!fs.existsSync(AUTH_FILE)) return null;
-    const encrypted = fs.readFileSync(AUTH_FILE, "utf-8");
+    const file = getAuthFile(env);
+    if (!fs.existsSync(file)) return null;
+    const encrypted = fs.readFileSync(file, "utf-8");
     const key = getMachineKey();
     const data = decrypt(encrypted, key);
     return JSON.parse(data);
@@ -1786,34 +2046,34 @@ function loadAuthTokens() {
     return null;
   }
 }
-async function clearAuthTokens() {
+async function clearAuthTokens(env = "dev") {
   try {
-    await fs.remove(AUTH_FILE);
+    await fs.remove(getAuthFile(env));
   } catch {
   }
 }
 function isTokenExpired(tokens) {
   return Date.now() / 1e3 > tokens.expiresAt - 300;
 }
-async function getValidTokens() {
-  const tokens = loadAuthTokens();
+async function getValidTokens(env = "dev") {
+  const tokens = loadAuthTokens(env);
   if (!tokens) return null;
   if (!isTokenExpired(tokens)) return tokens;
   try {
-    const apiUrl = getApiUrl();
+    const apiUrl = getApiUrl(env);
     const response = await fetch(`${apiUrl}/auth/refresh`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ refresh_token: tokens.refreshToken })
     });
     if (!response.ok) {
-      await clearAuthTokens();
+      await clearAuthTokens(env);
       return null;
     }
     const data = await response.json();
     const body = data.statusCode ? data.body : data;
     if (!body.IdToken) {
-      await clearAuthTokens();
+      await clearAuthTokens(env);
       return null;
     }
     const refreshed = {
@@ -1822,17 +2082,19 @@ async function getValidTokens() {
       idToken: body.IdToken,
       expiresAt: Math.floor(Date.now() / 1e3) + (body.ExpiresIn || 3600)
     };
-    await saveAuthTokens(refreshed);
+    await saveAuthTokens(refreshed, env);
     return refreshed;
   } catch {
-    await clearAuthTokens();
+    await clearAuthTokens(env);
     return null;
   }
 }
-async function authenticatedFetch(url, init) {
-  const tokens = await getValidTokens();
+async function authenticatedFetch(url, init, env = "dev") {
+  const tokens = await getValidTokens(env);
   if (!tokens) {
-    throw new Error("Not logged in. Run: onexthm login");
+    throw new Error(
+      `Not logged in to ${env} environment. Run: onexthm login --env ${env}`
+    );
   }
   const headers = new Headers(init?.headers);
   headers.set("Authorization", `Bearer ${tokens.idToken}`);
@@ -1898,7 +2160,7 @@ async function initCommand(projectName, options = {}) {
           if (!validateThemeName(kebabName)) {
             return "Invalid project name. Use lowercase letters, numbers, and hyphens only.";
           }
-          if (fs3.existsSync(path9.join(process.cwd(), kebabName))) {
+          if (fs3.existsSync(path11.join(process.cwd(), kebabName))) {
             return `Directory "${kebabName}" already exists`;
           }
           return true;
@@ -1909,14 +2171,14 @@ async function initCommand(projectName, options = {}) {
   } else {
     name = toKebabCase(projectName);
   }
-  const projectPath = path9.join(process.cwd(), name);
+  const projectPath = path11.join(process.cwd(), name);
   if (fs3.existsSync(projectPath)) {
     logger.error(`Directory "${name}" already exists.`);
     process.exit(1);
   }
   if (!options.yes) {
     try {
-      const apiUrl = getApiUrl();
+      const apiUrl = getApiUrl(options.env ?? "dev");
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), 3e3);
       const response = await fetch(
@@ -2025,7 +2287,7 @@ async function initCommand(projectName, options = {}) {
       description,
       author
     );
-    const mcpJsonPath = path9.join(projectPath, ".mcp.json");
+    const mcpJsonPath = path11.join(projectPath, ".mcp.json");
     if (fs3.existsSync(mcpJsonPath)) {
       let mcpContent = fs3.readFileSync(mcpJsonPath, "utf-8");
       if (figmaApiKey) {
@@ -2105,7 +2367,7 @@ async function initCommand(projectName, options = {}) {
   }
 }
 async function renameThemeInFiles(projectPath, themeName, displayName, description, author) {
-  const configPath = path9.join(projectPath, "theme.config.ts");
+  const configPath = path11.join(projectPath, "theme.config.ts");
   if (fs3.existsSync(configPath)) {
     let content = fs3.readFileSync(configPath, "utf-8");
     content = content.replace(
@@ -2118,7 +2380,7 @@ async function renameThemeInFiles(projectPath, themeName, displayName, descripti
     );
     fs3.writeFileSync(configPath, content, "utf-8");
   }
-  const pkgPath = path9.join(projectPath, "package.json");
+  const pkgPath = path11.join(projectPath, "package.json");
   if (fs3.existsSync(pkgPath)) {
     let content = fs3.readFileSync(pkgPath, "utf-8");
     content = content.replace(
@@ -2140,10 +2402,10 @@ async function createSectionCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs.existsSync(path9.join(process.cwd(), f))
+      (f) => fs.existsSync(path11.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path9.basename(process.cwd());
+      options.theme = path11.basename(process.cwd());
     }
   }
   const sectionName = toKebabCase(name);
@@ -2206,35 +2468,35 @@ async function createSectionCommand(name, options) {
   };
   logger.startSpinner("Creating section files...");
   try {
-    const themePath = path9.join(getThemesDir(), themeName);
-    const sectionPath = path9.join(themePath, "sections", sectionName);
+    const themePath = path11.join(getThemesDir(), themeName);
+    const sectionPath = path11.join(themePath, "sections", sectionName);
     const schemaContent = generateSectionSchema(data);
     await writeFile(
-      path9.join(sectionPath, `${sectionName}.schema.ts`),
+      path11.join(sectionPath, `${sectionName}.schema.ts`),
       schemaContent
     );
     if (createTemplate) {
       const templateContent = generateSectionTemplate(data);
       await writeFile(
-        path9.join(sectionPath, `${sectionName}-default.tsx`),
+        path11.join(sectionPath, `${sectionName}-default.tsx`),
         templateContent
       );
     }
     const indexContent = generateSectionIndex(data, createTemplate);
-    await writeFile(path9.join(sectionPath, "index.ts"), indexContent);
+    await writeFile(path11.join(sectionPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Section files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path9.relative(process.cwd(), path9.join(sectionPath, `${sectionName}.schema.ts`))}`
+      `  1. Edit schema: ${path11.relative(process.cwd(), path11.join(sectionPath, `${sectionName}.schema.ts`))}`
     );
     if (createTemplate) {
       logger.log(
-        `  2. Edit template: ${path9.relative(process.cwd(), path9.join(sectionPath, `${sectionName}-default.tsx`))}`
+        `  2. Edit template: ${path11.relative(process.cwd(), path11.join(sectionPath, `${sectionName}-default.tsx`))}`
       );
     }
     logger.log(
-      `  3. Add to theme manifest: ${path9.relative(process.cwd(), path9.join(themePath, "manifest.ts"))}`
+      `  3. Add to theme manifest: ${path11.relative(process.cwd(), path11.join(themePath, "manifest.ts"))}`
     );
     logger.newLine();
     logger.success("Section created successfully!");
@@ -2382,10 +2644,10 @@ async function createBlockCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs.existsSync(path9.join(process.cwd(), f))
+      (f) => fs.existsSync(path11.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path9.basename(process.cwd());
+      options.theme = path11.basename(process.cwd());
     }
   }
   const blockName = toKebabCase(name);
@@ -2460,24 +2722,24 @@ async function createBlockCommand(name, options) {
   };
   logger.startSpinner("Creating block files...");
   try {
-    const blockPath = scope === "shared" ? path9.join(getFeaturesDir(), "blocks", blockName) : path9.join(getThemesDir(), themeName, "blocks", blockName);
+    const blockPath = scope === "shared" ? path11.join(getFeaturesDir(), "blocks", blockName) : path11.join(getThemesDir(), themeName, "blocks", blockName);
     const schemaContent = generateBlockSchema(data);
     await writeFile(
-      path9.join(blockPath, `${blockName}.schema.ts`),
+      path11.join(blockPath, `${blockName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateBlockComponent(data);
-    await writeFile(path9.join(blockPath, `${blockName}.tsx`), componentContent);
+    await writeFile(path11.join(blockPath, `${blockName}.tsx`), componentContent);
     const indexContent = generateBlockIndex(data);
-    await writeFile(path9.join(blockPath, "index.ts"), indexContent);
+    await writeFile(path11.join(blockPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Block files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path9.relative(process.cwd(), path9.join(blockPath, `${blockName}.schema.ts`))}`
+      `  1. Edit schema: ${path11.relative(process.cwd(), path11.join(blockPath, `${blockName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path9.relative(process.cwd(), path9.join(blockPath, `${blockName}.tsx`))}`
+      `  2. Edit component: ${path11.relative(process.cwd(), path11.join(blockPath, `${blockName}.tsx`))}`
     );
     logger.log(
       `  3. Register in block registry: src/lib/registry/block-registry.ts`
@@ -2655,31 +2917,31 @@ async function createComponentCommand(name, options) {
   };
   logger.startSpinner("Creating component files...");
   try {
-    const componentPath = path9.join(
+    const componentPath = path11.join(
       getFeaturesDir(),
       "components",
       componentName
     );
     const schemaContent = generateComponentSchema(data);
     await writeFile(
-      path9.join(componentPath, `${componentName}.schema.ts`),
+      path11.join(componentPath, `${componentName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateComponent(data);
     await writeFile(
-      path9.join(componentPath, `${componentName}.tsx`),
+      path11.join(componentPath, `${componentName}.tsx`),
       componentContent
     );
     const indexContent = generateComponentIndex(data);
-    await writeFile(path9.join(componentPath, "index.ts"), indexContent);
+    await writeFile(path11.join(componentPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Component files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path9.relative(process.cwd(), path9.join(componentPath, `${componentName}.schema.ts`))}`
+      `  1. Edit schema: ${path11.relative(process.cwd(), path11.join(componentPath, `${componentName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path9.relative(process.cwd(), path9.join(componentPath, `${componentName}.tsx`))}`
+      `  2. Edit component: ${path11.relative(process.cwd(), path11.join(componentPath, `${componentName}.tsx`))}`
     );
     logger.log(
       `  3. Register in component registry: src/lib/registry/component-registry.ts`
@@ -2836,13 +3098,13 @@ async function listSections(themeFilter) {
     return;
   }
   for (const theme of themes) {
-    const sectionsDir = path9.join(getThemesDir(), theme, "sections");
+    const sectionsDir = path11.join(getThemesDir(), theme, "sections");
     if (!fs.existsSync(sectionsDir)) {
       continue;
     }
     const sections = fs.readdirSync(sectionsDir).filter((name) => {
-      const sectionPath = path9.join(sectionsDir, name);
-      return fs.statSync(sectionPath).isDirectory() && fs.existsSync(path9.join(sectionPath, "index.ts"));
+      const sectionPath = path11.join(sectionsDir, name);
+      return fs.statSync(sectionPath).isDirectory() && fs.existsSync(path11.join(sectionPath, "index.ts"));
     });
     if (sections.length > 0) {
       logger.log(chalk4.cyan(`
@@ -2856,11 +3118,11 @@ async function listSections(themeFilter) {
 }
 async function listBlocks(themeFilter) {
   logger.section("\u{1F9F1} Blocks");
-  const sharedBlocksDir = path9.join(getFeaturesDir(), "blocks");
+  const sharedBlocksDir = path11.join(getFeaturesDir(), "blocks");
   if (fs.existsSync(sharedBlocksDir)) {
     const sharedBlocks = fs.readdirSync(sharedBlocksDir).filter((name) => {
-      const blockPath = path9.join(sharedBlocksDir, name);
-      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path9.join(blockPath, "index.ts"));
+      const blockPath = path11.join(sharedBlocksDir, name);
+      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path11.join(blockPath, "index.ts"));
     });
     if (sharedBlocks.length > 0) {
       logger.log(chalk4.cyan("\n  Shared:"));
@@ -2871,13 +3133,13 @@ async function listBlocks(themeFilter) {
   }
   const themes = themeFilter ? [themeFilter] : listThemes();
   for (const theme of themes) {
-    const blocksDir = path9.join(getThemesDir(), theme, "blocks");
+    const blocksDir = path11.join(getThemesDir(), theme, "blocks");
     if (!fs.existsSync(blocksDir)) {
       continue;
     }
     const blocks = fs.readdirSync(blocksDir).filter((name) => {
-      const blockPath = path9.join(blocksDir, name);
-      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path9.join(blockPath, "index.ts"));
+      const blockPath = path11.join(blocksDir, name);
+      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path11.join(blockPath, "index.ts"));
     });
     if (blocks.length > 0) {
       logger.log(chalk4.cyan(`
@@ -2891,14 +3153,14 @@ async function listBlocks(themeFilter) {
 }
 async function listComponents() {
   logger.section("\u2699\uFE0F  Components");
-  const componentsDir = path9.join(getFeaturesDir(), "components");
+  const componentsDir = path11.join(getFeaturesDir(), "components");
   if (!fs.existsSync(componentsDir)) {
     logger.warning("No components directory found");
     return;
   }
   const components = fs.readdirSync(componentsDir).filter((name) => {
-    const componentPath = path9.join(componentsDir, name);
-    return fs.statSync(componentPath).isDirectory() && fs.existsSync(path9.join(componentPath, "index.ts"));
+    const componentPath = path11.join(componentsDir, name);
+    return fs.statSync(componentPath).isDirectory() && fs.existsSync(path11.join(componentPath, "index.ts"));
   });
   if (components.length === 0) {
     logger.warning("No components found");
@@ -2919,11 +3181,11 @@ async function listThemesInfo() {
   }
   logger.log("");
   for (const theme of themes) {
-    const themeDir = path9.join(getThemesDir(), theme);
+    const themeDir = path11.join(getThemesDir(), theme);
     const candidates = ["theme.config.ts", "bundle-entry.ts", "manifest.ts"];
     let manifestContent = "";
     for (const candidate of candidates) {
-      const candidatePath = path9.join(themeDir, candidate);
+      const candidatePath = path11.join(themeDir, candidate);
       if (fs.existsSync(candidatePath)) {
         manifestContent = fs.readFileSync(candidatePath, "utf-8");
         break;
@@ -2961,9 +3223,9 @@ async function validateCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path9.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path11.join(process.cwd(), f)));
     if (isThemeDir2) {
-      themeToValidate = path9.basename(process.cwd());
+      themeToValidate = path11.basename(process.cwd());
       logger.info(`Validating current theme: ${themeToValidate}`);
     } else {
       logger.error(
@@ -2972,11 +3234,11 @@ async function validateCommand(options) {
       process.exit(1);
     }
   }
-  const themePath = path9.join(getThemesDir(), themeToValidate);
+  const themePath = path11.join(getThemesDir(), themeToValidate);
   logger.startSpinner("Running validation checks...");
   const entryFiles = ["manifest.ts", "theme.config.ts", "bundle-entry.ts"];
   const foundEntry = entryFiles.find(
-    (f) => fs.existsSync(path9.join(themePath, f))
+    (f) => fs.existsSync(path11.join(themePath, f))
   );
   if (!foundEntry) {
     issues.push({
@@ -2986,7 +3248,7 @@ async function validateCommand(options) {
     });
   } else if (foundEntry === "manifest.ts") {
     const manifestContent = fs.readFileSync(
-      path9.join(themePath, foundEntry),
+      path11.join(themePath, foundEntry),
       "utf-8"
     );
     if (!manifestContent.includes("export const") && !manifestContent.includes("export default") && !manifestContent.includes("export interface")) {
@@ -2997,7 +3259,7 @@ async function validateCommand(options) {
       });
     }
   }
-  const configPath = path9.join(themePath, "theme.config.ts");
+  const configPath = path11.join(themePath, "theme.config.ts");
   if (!fs.existsSync(configPath)) {
     issues.push({
       type: "warning",
@@ -3005,7 +3267,7 @@ async function validateCommand(options) {
       message: "Theme config file not found (recommended)"
     });
   }
-  const indexPath = path9.join(themePath, "index.ts");
+  const indexPath = path11.join(themePath, "index.ts");
   if (!fs.existsSync(indexPath)) {
     issues.push({
       type: "warning",
@@ -3013,7 +3275,7 @@ async function validateCommand(options) {
       message: "Index file not found (recommended)"
     });
   }
-  const sectionsDir = path9.join(themePath, "sections");
+  const sectionsDir = path11.join(themePath, "sections");
   if (!fs.existsSync(sectionsDir)) {
     issues.push({
       type: "warning",
@@ -3022,16 +3284,16 @@ async function validateCommand(options) {
     });
   } else {
     const sections = fs.readdirSync(sectionsDir).filter(
-      (name) => fs.statSync(path9.join(sectionsDir, name)).isDirectory()
+      (name) => fs.statSync(path11.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
-      const sectionPath = path9.join(sectionsDir, sectionName);
-      const schemaFile = path9.join(sectionPath, `${sectionName}.schema.ts`);
-      const defaultTemplate = path9.join(
+      const sectionPath = path11.join(sectionsDir, sectionName);
+      const schemaFile = path11.join(sectionPath, `${sectionName}.schema.ts`);
+      const defaultTemplate = path11.join(
         sectionPath,
         `${sectionName}-default.tsx`
       );
-      const indexFile = path9.join(sectionPath, "index.ts");
+      const indexFile = path11.join(sectionPath, "index.ts");
       if (!fs.existsSync(schemaFile)) {
         issues.push({
           type: "error",
@@ -3055,14 +3317,14 @@ async function validateCommand(options) {
       }
     }
   }
-  const blocksDir = path9.join(themePath, "blocks");
+  const blocksDir = path11.join(themePath, "blocks");
   if (fs.existsSync(blocksDir)) {
-    const blocks = fs.readdirSync(blocksDir).filter((name) => fs.statSync(path9.join(blocksDir, name)).isDirectory());
+    const blocks = fs.readdirSync(blocksDir).filter((name) => fs.statSync(path11.join(blocksDir, name)).isDirectory());
     for (const blockName of blocks) {
-      const blockPath = path9.join(blocksDir, blockName);
-      const schemaFile = path9.join(blockPath, `${blockName}.schema.ts`);
-      const componentFile = path9.join(blockPath, `${blockName}.tsx`);
-      const indexFile = path9.join(blockPath, "index.ts");
+      const blockPath = path11.join(blocksDir, blockName);
+      const schemaFile = path11.join(blockPath, `${blockName}.schema.ts`);
+      const componentFile = path11.join(blockPath, `${blockName}.tsx`);
+      const indexFile = path11.join(blockPath, "index.ts");
       if (!fs.existsSync(schemaFile)) {
         issues.push({
           type: "error",
@@ -3088,13 +3350,13 @@ async function validateCommand(options) {
   }
   if (fs.existsSync(sectionsDir)) {
     const sections = fs.readdirSync(sectionsDir).filter(
-      (name) => fs.statSync(path9.join(sectionsDir, name)).isDirectory()
+      (name) => fs.statSync(path11.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
-      const sectionPath = path9.join(sectionsDir, sectionName);
+      const sectionPath = path11.join(sectionsDir, sectionName);
       const tsxFiles = fs.readdirSync(sectionPath).filter((f) => f.endsWith(".tsx") && !f.endsWith(".schema.ts"));
       for (const tsxFile of tsxFiles) {
-        const filePath = path9.join(sectionPath, tsxFile);
+        const filePath = path11.join(sectionPath, tsxFile);
         const content = fs.readFileSync(filePath, "utf-8");
         const relPath = `sections/${sectionName}/${tsxFile}`;
         if (!content.includes('"use client"') && !content.includes("'use client'")) {
@@ -3142,12 +3404,12 @@ async function validateCommand(options) {
       }
     }
   }
-  const registryPath = path9.join(themePath, "sections-registry.ts");
-  const bundleEntryPath = path9.join(themePath, "bundle-entry.ts");
+  const registryPath = path11.join(themePath, "sections-registry.ts");
+  const bundleEntryPath = path11.join(themePath, "bundle-entry.ts");
   const registryContent = fs.existsSync(registryPath) ? fs.readFileSync(registryPath, "utf-8") : fs.existsSync(bundleEntryPath) ? fs.readFileSync(bundleEntryPath, "utf-8") : "";
   if (fs.existsSync(sectionsDir) && registryContent) {
     const sections = fs.readdirSync(sectionsDir).filter(
-      (name) => fs.statSync(path9.join(sectionsDir, name)).isDirectory()
+      (name) => fs.statSync(path11.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
       if (!registryContent.includes(`sections/${sectionName}`) && !registryContent.includes(`"${sectionName}"`)) {
@@ -3170,7 +3432,7 @@ async function validateCommand(options) {
         });
       }
     }
-    const pagesDir = path9.join(themePath, "pages");
+    const pagesDir = path11.join(themePath, "pages");
     if (fs.existsSync(pagesDir)) {
       const allSchemaTypeSet = new Set(
         schemaTypes.map((s) => s.schemaType || s.folderName)
@@ -3222,9 +3484,9 @@ async function validateCommand(options) {
 }
 async function loadSchemaTypes(themePath, sectionsDir) {
   const results = [];
-  const sections = fs.readdirSync(sectionsDir).filter((name) => fs.statSync(path9.join(sectionsDir, name)).isDirectory());
+  const sections = fs.readdirSync(sectionsDir).filter((name) => fs.statSync(path11.join(sectionsDir, name)).isDirectory());
   for (const sectionName of sections) {
-    const schemaFile = path9.join(
+    const schemaFile = path11.join(
       sectionsDir,
       sectionName,
       `${sectionName}.schema.ts`
@@ -3262,7 +3524,7 @@ async function validatePageSectionTypes(pagesDir, validTypes) {
   const issues = [];
   const files = fs.readdirSync(pagesDir).filter((f) => f.match(/\.(ts|js)$/));
   for (const file of files) {
-    const content = fs.readFileSync(path9.join(pagesDir, file), "utf-8");
+    const content = fs.readFileSync(path11.join(pagesDir, file), "utf-8");
     const pageName = file.replace(/\.(ts|js)$/, "");
     const sectionsMatch = content.match(/\bsections:\s*\[/);
     if (!sectionsMatch || sectionsMatch.index === void 0) continue;
@@ -3275,9 +3537,13 @@ async function validatePageSectionTypes(pagesDir, validTypes) {
       endIdx = i;
     }
     const sectionsBlock = content.slice(startIdx, endIdx);
-    const typeMatches = sectionsBlock.matchAll(/\btype:\s*["']([^"']+)["']/g);
-    for (const match of typeMatches) {
+    const sectionTypeMatches = sectionsBlock.matchAll(
+      /\bid:\s*["'][^"']*["'],\s*\n?\s*type:\s*["']([^"']+)["']/g
+    );
+    for (const match of sectionTypeMatches) {
       const sectionType = match[1];
+      if (COMPONENT_TYPES.has(sectionType)) continue;
+      if (BLOCK_TYPES.has(sectionType)) continue;
       if (!validTypes.has(sectionType)) {
         issues.push({
           type: "error",
@@ -3330,6 +3596,64 @@ var FIELD_TYPES = /* @__PURE__ */ new Set([
   "inline_richtext",
   "repeater"
 ]);
+var COMPONENT_TYPES = /* @__PURE__ */ new Set([
+  "heading",
+  "paragraph",
+  "button",
+  "image",
+  "link",
+  "icon",
+  "badge",
+  "divider",
+  "spacer",
+  "container",
+  "grid",
+  "columns",
+  "card",
+  "quote",
+  "input",
+  "textarea",
+  "checkbox",
+  "select",
+  "video",
+  "gallery",
+  "alert",
+  "progress",
+  "rating",
+  "timer",
+  "list",
+  "table",
+  "accordion",
+  "tabs",
+  "code",
+  "map",
+  "product-card",
+  "blog-card",
+  "social-links",
+  "hotline-contacts",
+  "company-info",
+  "torn-separator"
+]);
+var BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "brand-feature",
+  "collection-item",
+  "crafting-step",
+  "testimonial-item",
+  "stat-item",
+  "footer-link",
+  "navigation-links-block",
+  "policy-section",
+  "core-value-card",
+  "faq-item",
+  "feature-item",
+  "gallery-item",
+  "logo-item",
+  "pricing-tier",
+  "service-item",
+  "stat-card",
+  "team-member",
+  "hero-content"
+]);
 // src/commands/build.ts
 init_logger();
@@ -3340,14 +3664,14 @@ async function buildCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path9.join(getThemesDir(), themeName);
+      const workspaceThemePath = path11.join(getThemesDir(), themeName);
       if (fs.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path9.join(process.cwd(), themeName);
+        themePath = path11.join(process.cwd(), themeName);
       }
     } catch {
-      themePath = path9.join(process.cwd(), themeName);
+      themePath = path11.join(process.cwd(), themeName);
     }
     if (!fs.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
@@ -3358,10 +3682,10 @@ async function buildCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path9.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path11.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
-      themeName = path9.basename(themePath);
+      themeName = path11.basename(themePath);
       logger.info(`Building current theme: ${themeName}`);
     } else {
       logger.error(
@@ -3370,7 +3694,7 @@ async function buildCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path9.join(themePath, "package.json");
+  const packageJsonPath = path11.join(themePath, "package.json");
   const hasPkgJson = fs.existsSync(packageJsonPath);
   if (!hasPkgJson) {
     logger.warning(
@@ -3426,9 +3750,9 @@ async function buildCommand(options) {
     logger.success("\u2713 Theme built successfully!");
     logger.newLine();
     logger.info(`Theme: ${themeName}`);
-    const distPath = path9.join(themePath, "dist");
+    const distPath = path11.join(themePath, "dist");
     if (fs.existsSync(distPath)) {
-      logger.log(`Output: ${path9.relative(process.cwd(), distPath)}`);
+      logger.log(`Output: ${path11.relative(process.cwd(), distPath)}`);
       const files = fs.readdirSync(distPath);
       logger.log(`Files: ${files.length}`);
     }
@@ -3484,7 +3808,7 @@ async function packageCommand(options) {
   let themeName;
   if (options.theme) {
     themeName = options.theme;
-    themePath = path9.join(getThemesDir(), themeName);
+    themePath = path11.join(getThemesDir(), themeName);
     if (!fs.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
       process.exit(1);
@@ -3494,10 +3818,10 @@ async function packageCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path9.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path11.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
-      themeName = path9.basename(themePath);
+      themeName = path11.basename(themePath);
       logger.info(`Packaging current theme: ${themeName}`);
     } else {
       logger.error(
@@ -3506,7 +3830,7 @@ async function packageCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path9.join(themePath, "package.json");
+  const packageJsonPath = path11.join(themePath, "package.json");
   let version2 = "1.0.0";
   if (fs.existsSync(packageJsonPath)) {
     const packageJson = await fs.readJson(packageJsonPath);
@@ -3516,7 +3840,7 @@ async function packageCommand(options) {
   logger.info(`Theme: ${themeName}`);
   logger.info(`Version: ${version2}`);
   logger.newLine();
-  const compiledThemePath = path9.join(
+  const compiledThemePath = path11.join(
     process.cwd(),
     "themes",
     themeName,
@@ -3550,8 +3874,8 @@ async function packageCommand(options) {
   logger.newLine();
   logger.section("Step 2: Create Package");
   const packageName = options.name || `${themeName}-${version2}`;
-  const outputDir = options.output || path9.join(process.cwd(), "dist");
-  const outputPath = path9.join(outputDir, `${packageName}.zip`);
+  const outputDir = options.output || path11.join(process.cwd(), "dist");
+  const outputPath = path11.join(outputDir, `${packageName}.zip`);
   await fs.ensureDir(outputDir);
   logger.startSpinner("Creating zip archive...");
   try {
@@ -3564,11 +3888,11 @@ async function packageCommand(options) {
     logger.newLine();
     logger.info(`Package: ${packageName}.zip`);
     logger.log(`Size: ${sizeMB} MB`);
-    logger.log(`Location: ${path9.relative(process.cwd(), outputPath)}`);
+    logger.log(`Location: ${path11.relative(process.cwd(), outputPath)}`);
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  onexthm deploy --package ${path9.relative(process.cwd(), outputPath)}`
+      `  onexthm deploy --package ${path11.relative(process.cwd(), outputPath)}`
     );
   } catch (error) {
     logger.stopSpinner(false, "Failed to create package");
@@ -3626,9 +3950,9 @@ async function deployCommand(options) {
   ensureOneXProject();
   let packagePath;
   if (options.package) {
-    packagePath = path9.resolve(options.package);
+    packagePath = path11.resolve(options.package);
   } else if (options.theme) {
-    const distDir = path9.join(process.cwd(), "dist");
+    const distDir = path11.join(process.cwd(), "dist");
     if (!fs.existsSync(distDir)) {
       logger.error("No dist/ directory found. Run 'onexthm package' first.");
       process.exit(1);
@@ -3643,7 +3967,7 @@ async function deployCommand(options) {
       process.exit(1);
     }
     packageFiles.sort().reverse();
-    packagePath = path9.join(distDir, packageFiles[0]);
+    packagePath = path11.join(distDir, packageFiles[0]);
   } else {
     logger.error("Either --package or --theme must be specified.");
     logger.info("Examples:");
@@ -3657,11 +3981,11 @@ async function deployCommand(options) {
   }
   const stats = await fs.stat(packagePath);
   const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-  const fileName = path9.basename(packagePath);
+  const fileName = path11.basename(packagePath);
   logger.newLine();
   logger.info(`Package: ${fileName}`);
   logger.log(`Size: ${sizeMB} MB`);
-  logger.log(`Path: ${path9.relative(process.cwd(), packagePath)}`);
+  logger.log(`Path: ${path11.relative(process.cwd(), packagePath)}`);
   logger.newLine();
   const apiUrl = options.apiUrl || process.env.ONEX_API_URL || "http://localhost:3001";
   const uploadEndpoint = `${apiUrl}/website-api/themes/upload`;
@@ -3818,8 +4142,8 @@ async function downloadBundleZip(apiUrl, themeId, version2) {
 async function createCompatibilityFiles(outputDir, manifest) {
   const entryFile = manifest.output?.entry || "bundle-entry.js";
   if (entryFile !== "bundle-entry.js" && entryFile.startsWith("bundle-entry-")) {
-    const hashedPath = path9.join(outputDir, entryFile);
-    const stablePath = path9.join(outputDir, "bundle-entry.js");
+    const hashedPath = path11.join(outputDir, entryFile);
+    const stablePath = path11.join(outputDir, "bundle-entry.js");
     if (await fs.pathExists(hashedPath)) {
       await fs.copy(hashedPath, stablePath);
       const mapPath = hashedPath + ".map";
@@ -3828,13 +4152,13 @@ async function createCompatibilityFiles(outputDir, manifest) {
       }
     }
   }
-  const sectionsRegistryPath = path9.join(outputDir, "sections-registry.js");
+  const sectionsRegistryPath = path11.join(outputDir, "sections-registry.js");
   const content = `// Re-export all sections from bundle-entry
 // This file exists to maintain compatibility with the import path
 export * from './bundle-entry.js';
 `;
   await fs.writeFile(sectionsRegistryPath, content, "utf-8");
-  const pkgJsonPath = path9.join(outputDir, "package.json");
+  const pkgJsonPath = path11.join(outputDir, "package.json");
   await fs.writeFile(pkgJsonPath, '{\n  "type": "module"\n}\n', "utf-8");
 }
 function showDownloadFailureHelp(themeId, apiUrl) {
@@ -3865,9 +4189,7 @@ function showDownloadFailureHelp(themeId, apiUrl) {
   console.log();
   console.log(chalk4.white("2. Check API URL configuration:"));
   console.log(chalk4.gray(`   Current API URL: ${apiUrl}`));
-  console.log(
-    chalk4.gray("   Override with NEXT_PUBLIC_API_URL or ONEXTHM_API_URL")
-  );
+  console.log(chalk4.gray("   Override with ONEXTHM_API_URL env var if needed"));
   console.log();
   console.log(chalk4.white("3. Pin a specific version (CI/production):"));
   console.log(
@@ -3877,15 +4199,17 @@ function showDownloadFailureHelp(themeId, apiUrl) {
 }
 async function downloadCommand(options) {
   logger.header("Download Theme");
+  const env = options.env ?? "dev";
+  const apiUrl = getApiUrl(env);
+  logger.info(`Environment: ${env}  (${apiUrl})`);
   const spinner = ora("Initializing download...").start();
-  if (options.bucket || options.environment) {
+  if (options.bucket) {
     spinner.stop();
     logger.warning(
-      "--bucket and --environment are deprecated and ignored. Themes are now served via HTTP from the website-api Lambda."
+      "--bucket is deprecated and ignored. Themes are now served via HTTP from the website-api Lambda."
     );
     spinner.start();
   }
-  const apiUrl = getApiUrl();
   try {
     const themeId = options.themeId || process.env.NEXT_PUBLIC_THEME_ID || process.env.THEME_ID;
     const requestedVersion = options.version || process.env.THEME_VERSION || "latest";
@@ -3933,7 +4257,7 @@ async function downloadCommand(options) {
     zip.extractAllTo(outputDir, true);
     const entries = zip.getEntries().filter((e) => !e.isDirectory);
     spinner.succeed(`Extracted ${entries.length} files to ${outputDir}`);
-    const manifestPath = path9.join(outputDir, "manifest.json");
+    const manifestPath = path11.join(outputDir, "manifest.json");
     const manifest = await fs.readJson(manifestPath);
     await createCompatibilityFiles(outputDir, manifest);
     console.log();
@@ -3942,6 +4266,7 @@ async function downloadCommand(options) {
     console.log(
       chalk4.cyan("   Theme:   ") + chalk4.white(`${themeId}@${resolvedVersion}`)
     );
+    console.log(chalk4.cyan("   Env:     ") + chalk4.white(env));
     console.log(chalk4.cyan("   Source:  ") + chalk4.white(apiUrl));
     console.log(chalk4.cyan("   Output:  ") + chalk4.white(outputDir));
     console.log(chalk4.cyan("   Files:   ") + chalk4.white(entries.length));
@@ -3984,11 +4309,9 @@ async function resolveLatestVersion2(apiUrl, themeId) {
   }
   return latest;
 }
-async function fetchSourceZip(apiUrl, themeId, version2) {
+async function fetchSourceZip(apiUrl, themeId, version2, env) {
   const url = `${apiUrl}/website-api/themes/${encodeURIComponent(themeId)}/source?version=${encodeURIComponent(version2)}`;
-  const response = await authenticatedFetch(url, {
-    method: "GET"
-  });
+  const response = await authenticatedFetch(url, { method: "GET" }, env);
   if (!response.ok) {
     if (response.status === 404) {
       throw new Error(
@@ -3997,7 +4320,7 @@ async function fetchSourceZip(apiUrl, themeId, version2) {
     }
     if (response.status === 401 || response.status === 403) {
       throw new Error(
-        `Not authorized to download source for "${themeId}". Run \`onexthm login\` first.`
+        `Not authorized to download source for "${themeId}". Run \`onexthm login --env ${env}\` first.`
       );
     }
     throw new Error(
@@ -4055,7 +4378,7 @@ async function renameTheme(themeDir, oldName, newName) {
   const oldPrefix = `${oldName}-`;
   const newPrefix = `${newName}-`;
   const newDisplayName = newName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-  const pkgPath = path9.join(themeDir, "package.json");
+  const pkgPath = path11.join(themeDir, "package.json");
   if (await fs.pathExists(pkgPath)) {
     const pkg = await fs.readJson(pkgPath);
     pkg.name = `@onex-themes/${newName}`;
@@ -4071,7 +4394,7 @@ async function renameTheme(themeDir, oldName, newName) {
     }
     await fs.writeJson(pkgPath, pkg, { spaces: 2 });
   }
-  const configPath = path9.join(themeDir, "theme.config.ts");
+  const configPath = path11.join(themeDir, "theme.config.ts");
   if (await fs.pathExists(configPath)) {
     let content = await fs.readFile(configPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
@@ -4081,7 +4404,7 @@ async function renameTheme(themeDir, oldName, newName) {
     );
     await fs.writeFile(configPath, content);
   }
-  const layoutPath = path9.join(themeDir, "theme.layout.ts");
+  const layoutPath = path11.join(themeDir, "theme.layout.ts");
   if (await fs.pathExists(layoutPath)) {
     let content = await fs.readFile(layoutPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
@@ -4094,7 +4417,7 @@ async function renameTheme(themeDir, oldName, newName) {
   const oldDisplayName = oldName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
   const tsFiles = await glob("**/*.ts", { cwd: themeDir, nodir: true });
   for (const file of tsFiles) {
-    const filePath = path9.join(themeDir, file);
+    const filePath = path11.join(themeDir, file);
     let content = await fs.readFile(filePath, "utf-8");
     const original = content;
     content = content.replace(
@@ -4116,14 +4439,19 @@ async function renameTheme(themeDir, oldName, newName) {
 }
 async function cloneCommand(themeName, options) {
   logger.header("Clone Theme Source");
-  if (options.bucket || options.environment) {
+  const env = options.env ?? "dev";
+  const apiUrl = getApiUrl(env);
+  logger.info(`Environment: ${env}  (${apiUrl})`);
+  if (options.bucket) {
     logger.warning(
-      "--bucket and --environment are deprecated and ignored. Source is now fetched via HTTP from the website-api Lambda."
+      "--bucket is deprecated and ignored. Source is now fetched via HTTP from the website-api Lambda."
     );
   }
-  const tokens = await getValidTokens();
+  const tokens = await getValidTokens(env);
   if (!tokens) {
-    logger.error("Not logged in. Run: onexthm login");
+    logger.error(
+      `Not logged in to ${env} environment. Run: onexthm login --env ${env}`
+    );
     process.exit(1);
   }
   let newName = options.name;
@@ -4132,8 +4460,7 @@ async function cloneCommand(themeName, options) {
   }
   const spinner = ora("Initializing clone...").start();
   try {
-    const apiUrl = getApiUrl();
-    const outputDir = options.output || path9.resolve(process.cwd(), newName);
+    const outputDir = options.output || path11.resolve(process.cwd(), newName);
     if (await fs.pathExists(outputDir)) {
       spinner.fail(chalk4.red(`Directory already exists: ${outputDir}`));
       logger.info(
@@ -4152,7 +4479,7 @@ async function cloneCommand(themeName, options) {
     spinner.start(`Downloading source.zip for ${themeName}@${version2}...`);
     let zipBuffer;
     try {
-      zipBuffer = await fetchSourceZip(apiUrl, themeName, version2);
+      zipBuffer = await fetchSourceZip(apiUrl, themeName, version2, env);
     } catch (error) {
       spinner.fail(chalk4.red(error.message));
       console.log();
@@ -4179,20 +4506,20 @@ async function cloneCommand(themeName, options) {
     spinner.succeed(
       `Renamed theme: ${chalk4.gray(themeName)} \u2192 ${chalk4.cyan(newName)}`
     );
-    const envExamplePath = path9.join(outputDir, ".env.example");
+    const envExamplePath = path11.join(outputDir, ".env.example");
     if (!await fs.pathExists(envExamplePath)) {
       await fs.writeFile(
         envExamplePath,
         [
           "# API Configuration (enables real data in preview)",
           "# Get your Company ID from the OneX dashboard",
-          "NEXT_PUBLIC_API_URL=https://platform-dev.onexeos.com",
+          `NEXT_PUBLIC_API_URL=${apiUrl}`,
           "NEXT_PUBLIC_COMPANY_ID=",
           ""
         ].join("\n")
       );
     }
-    const mcpJsonPath = path9.join(outputDir, ".mcp.json");
+    const mcpJsonPath = path11.join(outputDir, ".mcp.json");
     if (await fs.pathExists(mcpJsonPath)) {
       const { default: inquirerMod } = await import('inquirer');
       const { figmaApiKey } = await inquirerMod.prompt([
@@ -4217,7 +4544,7 @@ async function cloneCommand(themeName, options) {
     }
     if (options.install !== false) {
       const hasPkgJson = await fs.pathExists(
-        path9.join(outputDir, "package.json")
+        path11.join(outputDir, "package.json")
       );
       if (hasPkgJson) {
         spinner.start("Installing dependencies...");
@@ -4239,12 +4566,13 @@ async function cloneCommand(themeName, options) {
     console.log(
       chalk4.cyan("   Source:   ") + chalk4.gray(`${themeName}@${version2}`)
     );
+    console.log(chalk4.cyan("   Env:      ") + chalk4.white(env));
     console.log(chalk4.cyan("   Theme:    ") + chalk4.white(newName));
     console.log(chalk4.cyan("   Location: ") + chalk4.white(outputDir));
     console.log(chalk4.cyan("   Files:    ") + chalk4.white(entries.length));
     console.log();
     console.log(chalk4.cyan("Next steps:"));
-    console.log(chalk4.gray(`   cd ${path9.relative(process.cwd(), outputDir)}`));
+    console.log(chalk4.gray(`   cd ${path11.relative(process.cwd(), outputDir)}`));
     console.log(
       chalk4.gray("   cp .env.example .env  # then add your Company ID")
     );
@@ -4271,14 +4599,14 @@ async function devCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path9.join(getThemesDir(), themeName);
+      const workspaceThemePath = path11.join(getThemesDir(), themeName);
       if (fs.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path9.join(process.cwd(), themeName);
+        themePath = path11.join(process.cwd(), themeName);
       }
     } catch {
-      themePath = path9.join(process.cwd(), themeName);
+      themePath = path11.join(process.cwd(), themeName);
     }
     if (!fs.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
@@ -4289,10 +4617,10 @@ async function devCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path9.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path11.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
-      themeName = path9.basename(themePath);
+      themeName = path11.basename(themePath);
     } else {
       logger.error(
         "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
@@ -4361,9 +4689,9 @@ async function devCommand(options) {
     watcher.close();
     await context2.dispose();
     server.close();
-    const shimPath = path9.join(outputDir, ".process-shim.js");
+    const shimPath = path11.join(outputDir, ".process-shim.js");
     try {
-      await fs8.unlink(shimPath);
+      await fs9.unlink(shimPath);
     } catch {
     }
     process.exit(0);
@@ -4372,8 +4700,8 @@ async function devCommand(options) {
 // src/commands/config.ts
 init_logger();
-var CONFIG_DIR = path9.join(os.homedir(), ".onexthm");
-var CONFIG_FILE = path9.join(CONFIG_DIR, ".env");
+var CONFIG_DIR = path11.join(os.homedir(), ".onexthm");
+var CONFIG_FILE = path11.join(CONFIG_DIR, ".env");
 var CONFIG_ENTRIES = [
   {
     key: "AWS_ACCESS_KEY_ID",
@@ -4515,9 +4843,13 @@ async function configCommand() {
 // src/commands/login.ts
 init_logger();
-async function loginCommand() {
+async function loginCommand(options = {}) {
+  const env = options.env ?? "dev";
+  const apiUrl = getApiUrl(env);
   logger.header("OneX Theme Developer Login");
-  const existing = loadAuthTokens();
+  logger.info(`Environment: ${env}  (${apiUrl})`);
+  logger.newLine();
+  const existing = loadAuthTokens(env);
   if (existing) {
     logger.info(`Already logged in as: ${existing.user.email}`);
     const { relogin } = await inquirer.prompt([
@@ -4546,7 +4878,6 @@ async function loginCommand() {
   ]);
   logger.startSpinner("Logging in...");
   try {
-    const apiUrl = getApiUrl();
     const response = await fetch(`${apiUrl}/auth/login`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -4581,15 +4912,18 @@ async function loginCommand() {
         userId: claims.sub
       }
     };
-    await saveAuthTokens(tokens);
+    await saveAuthTokens(tokens, env);
     logger.stopSpinner(true, "Logged in!");
     logger.newLine();
-    logger.info(`  Email:   ${tokens.user.email}`);
-    if (tokens.user.name) logger.info(`  Name:    ${tokens.user.name}`);
+    logger.info(`  Environment: ${env}`);
+    logger.info(`  Email:       ${tokens.user.email}`);
+    if (tokens.user.name) logger.info(`  Name:        ${tokens.user.name}`);
     if (tokens.user.companyId)
-      logger.info(`  Company: ${tokens.user.companyId}`);
+      logger.info(`  Company:     ${tokens.user.companyId}`);
     logger.newLine();
-    logger.success("Token stored securely in ~/.onexthm/auth.json (encrypted)");
+    logger.success(
+      `Token stored securely in ~/.onexthm/auth-${env}.json (encrypted)`
+    );
   } catch (error) {
     logger.stopSpinner(false, "Login failed");
     logger.error(error instanceof Error ? error.message : "Connection failed");
@@ -4599,142 +4933,418 @@ async function loginCommand() {
 // src/commands/logout.ts
 init_logger();
-async function logoutCommand() {
-  const tokens = loadAuthTokens();
+async function logoutCommand(options = {}) {
+  const env = options.env ?? "dev";
+  const tokens = loadAuthTokens(env);
   if (!tokens) {
-    logger.info("Not logged in.");
+    logger.info(`Not logged in to ${env} environment.`);
     return;
   }
-  await clearAuthTokens();
-  logger.success(`Logged out (was: ${tokens.user.email})`);
+  await clearAuthTokens(env);
+  logger.success(`Logged out of ${env} (was: ${tokens.user.email})`);
 }
 // src/commands/whoami.ts
 init_logger();
-async function whoamiCommand() {
-  const tokens = loadAuthTokens();
+async function whoamiCommand(options = {}) {
+  const env = options.env ?? "dev";
+  const tokens = loadAuthTokens(env);
   if (!tokens) {
-    logger.error("Not logged in. Run: onexthm login");
+    logger.error(
+      `Not logged in to ${env} environment. Run: onexthm login --env ${env}`
+    );
     process.exit(1);
   }
   const expired = isTokenExpired(tokens);
   logger.header("OneX Theme Developer");
-  logger.info(`  Email:    ${tokens.user.email}`);
-  if (tokens.user.name) logger.info(`  Name:     ${tokens.user.name}`);
+  logger.info(`  Environment: ${env}  (${getApiUrl(env)})`);
+  logger.info(`  Email:       ${tokens.user.email}`);
+  if (tokens.user.name) logger.info(`  Name:        ${tokens.user.name}`);
   if (tokens.user.companyId)
-    logger.info(`  Company:  ${tokens.user.companyId}`);
+    logger.info(`  Company:     ${tokens.user.companyId}`);
   logger.info(
-    `  Status:   ${expired ? "\u26A0 Token expired (will auto-refresh)" : "\u2713 Active"}`
+    `  Status:      ${expired ? "\u26A0 Token expired (will auto-refresh)" : "\u2713 Active"}`
   );
 }
 // src/commands/publish.ts
 init_logger();
-var MIME_MAP = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".bmp": "image/bmp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".eot": "application/vnd.ms-fontobject",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mov": "video/quicktime",
-  ".ogg": "video/ogg",
-  ".json": "application/json"
+init_scan_theme_assets();
+// src/utils/fetch-prior-schemas.ts
+async function fetchPriorGateManifests(themeId, env) {
+  const apiUrl = getApiUrl(env);
+  const url = `${apiUrl}/website-api/themes/${encodeURIComponent(themeId)}/gate-manifests/latest`;
+  let res;
+  try {
+    res = await authenticatedFetch(url, { method: "GET" }, env);
+  } catch (err) {
+    return {
+      result: null,
+      reason: `network error: ${err instanceof Error ? err.message : "unknown"}`
+    };
+  }
+  if (res.status === 404) {
+    return { result: null, reason: "no-prior" };
+  }
+  if (!res.ok) {
+    return {
+      result: null,
+      reason: `server returned ${res.status} ${res.statusText}`
+    };
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    return { result: null, reason: "non-JSON response from server" };
+  }
+  const body = data.statusCode ? data.body : data;
+  if (!body || typeof body.version !== "string" || !body.schemas || !body.assets) {
+    return { result: null, reason: "malformed response (missing fields)" };
+  }
+  return {
+    result: {
+      version: body.version,
+      schemas: body.schemas,
+      assets: body.assets
+    },
+    reason: null
+  };
+}
+// src/utils/schema-diff.ts
+var SEVERITY = {
+  safe: 0,
+  "safe-rename": 1,
+  "defaults-only": 2,
+  additive: 3,
+  breaking: 4,
+  "breaking-asset": 5,
+  "breaking-severe": 6
 };
-var HASH_LEN = 8;
-var VIDEO_EXTENSIONS = [
-  ".mp4",
-  ".webm",
-  ".ogg",
-  ".mov",
-  ".avi",
-  ".mkv"
-];
-function isVideoAsset(filePath) {
-  const lower = filePath.toLowerCase();
-  return VIDEO_EXTENSIONS.some((ext) => lower.endsWith(ext));
+var BUMP_FOR = {
+  safe: "patch",
+  "safe-rename": "patch",
+  "defaults-only": "patch",
+  additive: "minor",
+  breaking: "major",
+  "breaking-asset": "major",
+  "breaking-severe": "major"
+};
+function bumpFor(kind) {
+  return BUMP_FOR[kind];
 }
-function mimeFor(filename) {
-  const ext = path9.extname(filename).toLowerCase();
-  return MIME_MAP[ext] || "application/octet-stream";
+function maxSeverity(a, b) {
+  return SEVERITY[a] >= SEVERITY[b] ? a : b;
 }
-async function sha256Prefix(absPath, len) {
-  const buf = await fs.readFile(absPath);
-  return crypto.createHash("sha256").update(buf).digest("hex").slice(0, len);
+function classify(changes) {
+  let highest = "safe";
+  for (const c of changes) {
+    highest = maxSeverity(highest, c.kind);
+  }
+  return { bump: bumpFor(highest), highest, changes };
 }
-function insertHashIntoName(relPath, hash) {
-  const dir = path9.posix.dirname(relPath);
-  const base = path9.posix.basename(relPath);
-  const ext = path9.posix.extname(base);
-  const stem = ext ? base.slice(0, -ext.length) : base;
-  const hashed = `${stem}-${hash}${ext}`;
-  return dir === "." ? hashed : `${dir}/${hashed}`;
+function diffManifests(prior, current) {
+  const changes = [];
+  const priorSections = prior.schemas.sections;
+  const currentSections = current.schemas.sections;
+  const sectionTypes = /* @__PURE__ */ new Set([
+    ...Object.keys(priorSections),
+    ...Object.keys(currentSections)
+  ]);
+  for (const type of [...sectionTypes].sort()) {
+    const p = priorSections[type];
+    const c = currentSections[type];
+    if (p && !c) {
+      changes.push({
+        kind: "breaking-severe",
+        path: `sections.${type}`,
+        detail: `Section type "${type}" removed. Pages using this section will render empty.`
+      });
+      continue;
+    }
+    if (!p && c) {
+      changes.push({
+        kind: "additive",
+        path: `sections.${type}`,
+        detail: `Section type "${type}" added.`
+      });
+      continue;
+    }
+    if (p && c) diffSection(p, c, changes);
+  }
+  diffAssets(prior.assets, current.assets, changes);
+  return changes;
 }
-async function scanThemeAssets(distDir) {
-  const assetsDir = path9.join(distDir, "theme-assets");
-  if (!await fs.pathExists(assetsDir)) return [];
-  const files = await glob("**/*", {
-    cwd: assetsDir,
-    nodir: true,
-    dot: false
-  });
-  const results = [];
-  for (const rel of files) {
-    const absPath = path9.join(assetsDir, rel);
-    const stat = await fs.stat(absPath);
-    if (!stat.isFile()) continue;
-    const originalPath = rel.split(path9.sep).join("/");
-    const hash = await sha256Prefix(absPath, HASH_LEN);
-    const hashedPath = insertHashIntoName(originalPath, hash);
-    const contentType = mimeFor(rel);
-    results.push({
-      originalPath,
-      hashedPath,
-      hash,
-      size: stat.size,
-      contentType,
-      absPath
+function diffSection(prior, current, out) {
+  const type = current.type;
+  if (JSON.stringify(prior.dataRequirements) !== JSON.stringify(current.dataRequirements)) {
+    out.push({
+      kind: "breaking",
+      path: `sections.${type}.dataRequirements`,
+      detail: "dataRequirements changed."
     });
   }
-  results.sort((a, b) => a.originalPath.localeCompare(b.originalPath));
-  return results;
+  diffFieldList(
+    prior.settings,
+    current.settings,
+    `sections.${type}.settings`,
+    out
+  );
+  diffDefaults(
+    prior.defaults,
+    current.defaults,
+    `sections.${type}.defaults`,
+    out
+  );
+  diffBlocks(prior.blocks, current.blocks, `sections.${type}.blocks`, out);
 }
-function buildAssetMap(entries) {
-  const map = {};
-  for (const e of entries) {
-    map[e.originalPath] = e.hashedPath;
+function diffBlocks(prior, current, pathPrefix, out) {
+  const priorByType = new Map(prior.map((b) => [b.type, b]));
+  const currentByType = new Map(current.map((b) => [b.type, b]));
+  for (const type of /* @__PURE__ */ new Set([
+    ...priorByType.keys(),
+    ...currentByType.keys()
+  ])) {
+    const p = priorByType.get(type);
+    const c = currentByType.get(type);
+    if (p && !c) {
+      out.push({
+        kind: "breaking",
+        path: `${pathPrefix}.${type}`,
+        detail: `Block type "${type}" removed.`
+      });
+      continue;
+    }
+    if (!p && c) {
+      out.push({
+        kind: "additive",
+        path: `${pathPrefix}.${type}`,
+        detail: `Block type "${type}" added.`
+      });
+      continue;
+    }
+    if (p && c) {
+      diffFieldList(
+        p.settings,
+        c.settings,
+        `${pathPrefix}.${type}.settings`,
+        out
+      );
+      diffDefaults(
+        p.defaults,
+        c.defaults,
+        `${pathPrefix}.${type}.defaults`,
+        out
+      );
+    }
+  }
+}
+function diffFieldList(prior, current, pathPrefix, out) {
+  const priorById = new Map(prior.map((f) => [f.id, f]));
+  const currentById = new Map(current.map((f) => [f.id, f]));
+  const aliasToCurrent = /* @__PURE__ */ new Map();
+  for (const f of current) {
+    if (f.aliases) {
+      for (const alias of f.aliases) {
+        aliasToCurrent.set(alias, f);
+      }
+    }
+  }
+  for (const [id, p] of priorById) {
+    const c = currentById.get(id);
+    if (c) {
+      diffFieldPair(p, c, `${pathPrefix}.${id}`, out);
+      continue;
+    }
+    const renamed = aliasToCurrent.get(id);
+    if (renamed) {
+      if (renamed.type === p.type) {
+        out.push({
+          kind: "safe-rename",
+          path: `${pathPrefix}.${id}`,
+          detail: `Field "${id}" renamed to "${renamed.id}" (alias preserved).`
+        });
+      } else {
+        out.push({
+          kind: "breaking",
+          path: `${pathPrefix}.${id}`,
+          detail: `Field "${id}" renamed to "${renamed.id}" but type changed (${p.type} \u2192 ${renamed.type}).`
+        });
+      }
+    } else {
+      out.push({
+        kind: "breaking",
+        path: `${pathPrefix}.${id}`,
+        detail: `Field "${id}" removed. Consider adding aliases: ["${id}"] to the replacement field if this was a rename.`
+      });
+    }
+  }
+  for (const [id, c] of currentById) {
+    if (priorById.has(id)) continue;
+    const coveredByAlias = c.aliases?.some((a) => priorById.has(a)) ?? false;
+    if (coveredByAlias) continue;
+    if (c.required && c.default === void 0) {
+      out.push({
+        kind: "breaking",
+        path: `${pathPrefix}.${id}`,
+        detail: `Required field "${id}" added with no default. Existing instances cannot satisfy it.`
+      });
+    } else {
+      out.push({
+        kind: "additive",
+        path: `${pathPrefix}.${id}`,
+        detail: `Field "${id}" added.`
+      });
+    }
+  }
+}
+function diffFieldPair(p, c, path23, out) {
+  if (p.type !== c.type) {
+    out.push({
+      kind: "breaking",
+      path: path23,
+      detail: `Type changed (${p.type} \u2192 ${c.type}). Saved values may misrender.`
+    });
+    return;
+  }
+  if (p.required !== true && c.required === true) {
+    out.push({
+      kind: "breaking",
+      path: path23,
+      detail: "Field became required. Existing empty instances now invalid."
+    });
+  }
+  if (typeof p.maxLength === "number" || typeof c.maxLength === "number") {
+    if ((c.maxLength ?? Infinity) < (p.maxLength ?? Infinity)) {
+      out.push({
+        kind: "breaking",
+        path: path23,
+        detail: `maxLength tightened (${p.maxLength ?? "\u221E"} \u2192 ${c.maxLength}).`
+      });
+    }
+  }
+  if (typeof p.min === "number" || typeof c.min === "number") {
+    if ((c.min ?? -Infinity) > (p.min ?? -Infinity)) {
+      out.push({
+        kind: "breaking",
+        path: path23,
+        detail: `min raised (${p.min ?? "-\u221E"} \u2192 ${c.min}).`
+      });
+    }
+  }
+  if (typeof p.max === "number" || typeof c.max === "number") {
+    if ((c.max ?? Infinity) < (p.max ?? Infinity)) {
+      out.push({
+        kind: "breaking",
+        path: path23,
+        detail: `max lowered (${p.max ?? "\u221E"} \u2192 ${c.max}).`
+      });
+    }
+  }
+  if (p.options || c.options) {
+    const priorOpts = new Set(p.options ?? []);
+    const currentOpts = new Set(c.options ?? []);
+    const removed = [...priorOpts].filter((o) => !currentOpts.has(o));
+    const added = [...currentOpts].filter((o) => !priorOpts.has(o));
+    if (removed.length > 0) {
+      out.push({
+        kind: "breaking",
+        path: path23,
+        detail: `Option(s) removed: ${removed.join(", ")}. Existing saved values may be orphaned.`
+      });
+    }
+    if (added.length > 0) {
+      out.push({
+        kind: "additive",
+        path: path23,
+        detail: `Option(s) added: ${added.join(", ")}.`
+      });
+    }
+  }
+  if (!deepEqual(p.default, c.default)) {
+    out.push({
+      kind: "defaults-only",
+      path: path23,
+      detail: `Default changed: ${JSON.stringify(p.default)} \u2192 ${JSON.stringify(c.default)}.`
+    });
+  }
+}
+function diffDefaults(prior, current, pathPrefix, out) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(prior), ...Object.keys(current)]);
+  for (const key of [...keys].sort()) {
+    if (!(key in prior) || !(key in current)) continue;
+    if (!deepEqual(prior[key], current[key])) {
+      out.push({
+        kind: "defaults-only",
+        path: `${pathPrefix}.${key}`,
+        detail: `Default value changed.`
+      });
+    }
+  }
+}
+function diffAssets(prior, current, out) {
+  const currentPaths = new Set(current.assets.map((a) => a.path));
+  for (const a of prior.assets) {
+    if (!currentPaths.has(a.path)) {
+      out.push({
+        kind: "breaking-asset",
+        path: `theme-assets/${a.path}`,
+        detail: `Asset "${a.path}" was present in the prior version and is now missing. Code that references it hardcoded will break.`
+      });
+    }
   }
-  return map;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) {
+    if (!deepEqual(
+      a[k],
+      b[k]
+    ))
+      return false;
+  }
+  return true;
 }
 // src/commands/publish.ts
 async function publishCommand(options) {
+  const env = options.env ?? "dev";
   logger.header("OneX Theme Publish");
-  const tokens = await getValidTokens();
+  logger.info(`Environment: ${env}  (${getApiUrl(env)})`);
+  logger.newLine();
+  const tokens = await getValidTokens(env);
   if (!tokens) {
-    logger.error("Not logged in. Run: onexthm login");
+    logger.error(
+      `Not logged in to ${env} environment. Run: onexthm login --env ${env}`
+    );
     process.exit(1);
   }
   logger.info(`Logged in as: ${tokens.user.email}`);
   let themePath;
   if (options.theme) {
-    themePath = path9.resolve(options.theme);
+    themePath = path11.resolve(options.theme);
   } else {
     const isThemeDir2 = [
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path9.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path11.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
     } else {
@@ -4744,13 +5354,13 @@ async function publishCommand(options) {
       process.exit(1);
     }
   }
-  const pkgPath = path9.join(themePath, "package.json");
+  const pkgPath = path11.join(themePath, "package.json");
   if (!fs.existsSync(pkgPath)) {
     logger.error("No package.json found in theme directory");
     process.exit(1);
   }
   const pkg = fs.readJsonSync(pkgPath);
-  const themeId = pkg.name?.replace("@onex-themes/", "") || path9.basename(themePath);
+  const themeId = pkg.name?.replace("@onex-themes/", "") || path11.basename(themePath);
   if (options.bump) {
     const currentVersion = pkg.version || "1.0.0";
     const newVersion = semver.inc(currentVersion, options.bump);
@@ -4773,56 +5383,63 @@ async function publishCommand(options) {
   logger.info(`Theme: ${themeId}`);
   logger.info(`Version: ${version2}`);
   logger.newLine();
-  const apiUrl = getApiUrl();
-  logger.startSpinner("Registering theme...");
-  try {
-    const regResponse = await authenticatedFetch(
-      `${apiUrl}/website-api/themes/register`,
-      {
-        method: "POST",
-        body: JSON.stringify({
-          themeId,
-          name: pkg.displayName || themeId,
-          description: pkg.description || "",
-          email: tokens.user.email,
-          author: typeof pkg.author === "string" ? pkg.author : pkg.author?.name || tokens.user.name || "",
-          category: pkg.onex?.category || "MINIMAL",
-          tags: pkg.keywords || [],
-          thumbnail_url: pkg.onex?.thumbnail || ""
-        })
-      }
-    );
-    const regData = await regResponse.json();
-    const regBody = regData.statusCode ? regData.body : regData;
-    if (!regResponse.ok) {
-      const errMsg = regBody.error || regBody.message || "Registration failed";
-      if (!errMsg.includes("already registered")) {
-        logger.stopSpinner(false, "Registration failed");
-        logger.error(errMsg);
-        process.exit(1);
+  const apiUrl = getApiUrl(env);
+  if (!options.dryRun) {
+    logger.startSpinner("Registering theme...");
+    try {
+      const regResponse = await authenticatedFetch(
+        `${apiUrl}/website-api/themes/register`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            themeId,
+            name: pkg.displayName || themeId,
+            description: pkg.description || "",
+            email: tokens.user.email,
+            author: typeof pkg.author === "string" ? pkg.author : pkg.author?.name || tokens.user.name || "",
+            category: pkg.onex?.category || "MINIMAL",
+            tags: pkg.keywords || [],
+            thumbnail_url: pkg.onex?.thumbnail || ""
+          })
+        },
+        env
+      );
+      const regData = await regResponse.json();
+      const regBody = regData.statusCode ? regData.body : regData;
+      if (!regResponse.ok) {
+        const errMsg = regBody.error || regBody.message || "Registration failed";
+        if (!errMsg.includes("already registered")) {
+          logger.stopSpinner(false, "Registration failed");
+          logger.error(errMsg);
+          process.exit(1);
+        }
       }
+      logger.stopSpinner(true, regBody.message || "Theme registered");
+    } catch (error) {
+      logger.stopSpinner(false, "Registration failed");
+      logger.error(
+        error instanceof Error ? error.message : "Connection failed"
+      );
+      process.exit(1);
     }
-    logger.stopSpinner(true, regBody.message || "Theme registered");
-  } catch (error) {
-    logger.stopSpinner(false, "Registration failed");
-    logger.error(error instanceof Error ? error.message : "Connection failed");
-    process.exit(1);
   }
-  logger.startSpinner("Checking version availability...");
-  try {
-    const checkResponse = await authenticatedFetch(
-      `${apiUrl}/website-api/themes/${encodeURIComponent(themeId)}/versions/${encodeURIComponent(version2)}/exists`,
-      { method: "GET" }
-    );
-    const checkData = await checkResponse.json();
-    const checkBody = checkData.statusCode ? checkData.body : checkData;
-    if (checkBody.exists) {
-      logger.stopSpinner(false, "Version already published");
-      const patchVer = semver.inc(version2, "patch") || "?";
-      const minorVer = semver.inc(version2, "minor") || "?";
-      const majorVer = semver.inc(version2, "major") || "?";
-      logger.error(
-        `
+  if (!options.dryRun) {
+    logger.startSpinner("Checking version availability...");
+    try {
+      const checkResponse = await authenticatedFetch(
+        `${apiUrl}/website-api/themes/${encodeURIComponent(themeId)}/versions/${encodeURIComponent(version2)}/exists`,
+        { method: "GET" },
+        env
+      );
+      const checkData = await checkResponse.json();
+      const checkBody = checkData.statusCode ? checkData.body : checkData;
+      if (checkBody.exists) {
+        logger.stopSpinner(false, "Version already published");
+        const patchVer = semver.inc(version2, "patch") || "?";
+        const minorVer = semver.inc(version2, "minor") || "?";
+        const majorVer = semver.inc(version2, "major") || "?";
+        logger.error(
+          `
 Version ${version2} of "${themeId}" is already published and cannot be overwritten.
 To publish a new version:
@@ -4833,12 +5450,16 @@ Or use the --bump flag:
   onexthm publish --bump patch    (${version2} -> ${patchVer})
   onexthm publish --bump minor    (${version2} -> ${minorVer})
   onexthm publish --bump major    (${version2} -> ${majorVer})`
+        );
+        process.exit(1);
+      }
+      logger.stopSpinner(true, `Version ${version2} is available`);
+    } catch (error) {
+      logger.stopSpinner(
+        true,
+        "Version check skipped (endpoint not available)"
       );
-      process.exit(1);
     }
-    logger.stopSpinner(true, `Version ${version2} is available`);
-  } catch (error) {
-    logger.stopSpinner(true, "Version check skipped (endpoint not available)");
   }
   logger.startSpinner("Building theme...");
   try {
@@ -4855,7 +5476,19 @@ Or use the --bump flag:
     logger.error(error instanceof Error ? error.message : "Build error");
     process.exit(1);
   }
-  const distDir = path9.join(themePath, "dist");
+  const distDir = path11.join(themePath, "dist");
+  const classification = await runSchemaDiffGate(
+    themeId,
+    distDir,
+    env,
+    options
+  );
+  if (options.dryRun) {
+    const exitCode = classification?.highest === "breaking" || classification?.highest === "breaking-severe" || classification?.highest === "breaking-asset" ? 2 : 0;
+    logger.newLine();
+    logger.info(`Dry run complete (exit ${exitCode}). No files uploaded.`);
+    process.exit(exitCode);
+  }
   let assetEntries = [];
   try {
     assetEntries = await scanThemeAssets(distDir);
@@ -4877,7 +5510,7 @@ Or use the --bump flag:
     logger.startSpinner(`Uploading ${videoAssets.length} video(s)...`);
     try {
       for (const video of videoAssets) {
-        const url = await uploadVideoMultipart(apiUrl, themeId, video);
+        const url = await uploadVideoMultipart(apiUrl, themeId, video, env);
         videoUrls[video.originalPath] = url;
       }
       logger.stopSpinner(true, `Uploaded ${videoAssets.length} video(s)`);
@@ -4892,7 +5525,7 @@ Or use the --bump flag:
     for (const [originalPath, url] of Object.entries(videoUrls)) {
       assetMap[originalPath] = url;
     }
-    const assetMapPath = path9.join(distDir, "asset-map.json");
+    const assetMapPath = path11.join(distDir, "asset-map.json");
     await fs.writeFile(assetMapPath, JSON.stringify(assetMap, null, 2));
   } catch (error) {
     logger.error(
@@ -4919,7 +5552,8 @@ Or use the --bump flag:
             content_type: a.contentType
           }))
         })
-      }
+      },
+      env
     );
     const pubData = await pubResponse.json();
     const pubBody = pubData.statusCode ? pubData.body : pubData;
@@ -4945,6 +5579,12 @@ Or use the --bump flag:
   }
   if (assetUploads.length > 0) {
     logger.startSpinner(`Uploading ${assetUploads.length} asset(s) to S3...`);
+    if (assetUploads[0]) {
+      logger.log(
+        `  [debug] sample presigned PUT URL: ${assetUploads[0].upload_url}`
+      );
+      logger.log(`  [debug] sample s3_key: ${assetUploads[0].s3_key}`);
+    }
     const CONCURRENCY = 8;
     const byHashedPath = new Map(regularAssets.map((a) => [a.hashedPath, a]));
     const queue = [...assetUploads];
@@ -4971,6 +5611,13 @@ Or use the --bump flag:
             body: buf
           });
           if (!res.ok) {
+            if (failed === 0) {
+              const errBody = await res.text().catch(() => "(unreadable)");
+              logger.log(`  [debug] PUT ${item.upload_url}`);
+              logger.log(
+                `  [debug] response ${res.status} ${res.statusText}: ${errBody.slice(0, 500)}`
+              );
+            }
             throw new Error(`HTTP ${res.status}`);
           }
           uploaded++;
@@ -5001,7 +5648,7 @@ Or use the --bump flag:
       logger.error("Build the theme first: onexthm build");
       process.exit(1);
     }
-    const bundleZipPath = path9.join(themePath, "dist", "bundle.zip");
+    const bundleZipPath = path11.join(themePath, "dist", "bundle.zip");
     await createZip(distDir, bundleZipPath, [
       "bundle.zip",
       "source.zip",
@@ -5028,7 +5675,7 @@ Or use the --bump flag:
   }
   logger.startSpinner("Uploading source...");
   try {
-    const sourceZipPath = path9.join(themePath, "dist", "source.zip");
+    const sourceZipPath = path11.join(themePath, "dist", "source.zip");
     await createZip(themePath, sourceZipPath, [
       "node_modules",
       "dist",
@@ -5055,7 +5702,8 @@ Or use the --bump flag:
   try {
     const confirmResponse = await authenticatedFetch(
       `${apiUrl}/website-api/themes/${encodeURIComponent(themeId)}/versions/${encodeURIComponent(version2)}/confirm`,
-      { method: "POST" }
+      { method: "POST" },
+      env
     );
     const confirmData = await confirmResponse.json();
     const confirmBody = confirmData.statusCode ? confirmData.body : confirmData;
@@ -5101,9 +5749,9 @@ Or use the --bump flag:
   }
   logger.newLine();
   logger.success(`\u2713 Theme "${themeId}" v${version2} published!`);
-  await uploadThumbnail(apiUrl, themeId, themePath, distDir);
+  await uploadThumbnail(apiUrl, themeId, themePath, distDir, env);
 }
-async function uploadThumbnail(apiUrl, themeId, themePath, distDir) {
+async function uploadThumbnail(apiUrl, themeId, themePath, distDir, env = "dev") {
   const THUMBNAIL_CANDIDATES = [
     { file: "thumbnail.png", mime: "image/png" },
     { file: "thumbnail.jpg", mime: "image/jpeg" },
@@ -5113,7 +5761,7 @@ async function uploadThumbnail(apiUrl, themeId, themePath, distDir) {
   let imageBase64 = null;
   let mimeType = "image/png";
   for (const { file, mime } of THUMBNAIL_CANDIDATES) {
-    const candidate = path9.join(themePath, file);
+    const candidate = path11.join(themePath, file);
     if (fs.existsSync(candidate)) {
       const buf = fs.readFileSync(candidate);
       imageBase64 = `data:${mime};base64,${buf.toString("base64")}`;
@@ -5138,9 +5786,19 @@ async function uploadThumbnail(apiUrl, themeId, themePath, distDir) {
     }
   }
   logger.startSpinner("Uploading thumbnail...");
+  const imageUploadUrl = `${apiUrl}/media/images/upload`;
+  const imageRequestBody = {
+    prefix: `themes/${themeId}`,
+    image: imageBase64 ? `${imageBase64.slice(0, 60)}... [${Math.round(imageBase64.length * 3 / 4 / 1024)} KB]` : null,
+    name: "thumbnail.png"
+  };
+  logger.log(`  \u2192 POST ${imageUploadUrl}`);
+  logger.log(
+    `  \u2192 body: ${JSON.stringify({ ...imageRequestBody, image: imageBase64 ? `<base64 ${mimeType} truncated>` : null })}`
+  );
   try {
     const uploadRes = await authenticatedFetch(
-      `${apiUrl}/media/images/upload`,
+      imageUploadUrl,
       {
         method: "POST",
         body: JSON.stringify({
@@ -5148,30 +5806,56 @@ async function uploadThumbnail(apiUrl, themeId, themePath, distDir) {
           image: imageBase64,
           name: "thumbnail.png"
         })
-      }
+      },
+      env
     );
-    const uploadData = await uploadRes.json();
+    logger.log(`  \u2190 HTTP ${uploadRes.status} ${uploadRes.statusText}`);
+    const uploadRawText = await uploadRes.text();
+    logger.log(`  \u2190 raw response: ${uploadRawText.slice(0, 500)}`);
+    let uploadData;
+    try {
+      uploadData = JSON.parse(uploadRawText);
+    } catch {
+      throw new Error(
+        `Image upload returned non-JSON (HTTP ${uploadRes.status}): ${uploadRawText.slice(0, 200)}`
+      );
+    }
     const uploadBody = uploadData.statusCode ? uploadData.body : uploadData;
     if (!uploadRes.ok || !uploadBody.url) {
-      throw new Error(uploadBody.error || "Upload failed");
+      throw new Error(
+        `Image upload failed \u2014 HTTP ${uploadRes.status}: ${uploadBody.error || uploadBody.message || JSON.stringify(uploadBody).slice(0, 300)}`
+      );
     }
+    const patchUrl = `${apiUrl}/website-api/themes/${encodeURIComponent(themeId)}`;
+    logger.log(`  \u2192 PATCH ${patchUrl}`);
     const patchRes = await authenticatedFetch(
-      `${apiUrl}/website-api/themes/${encodeURIComponent(themeId)}`,
+      patchUrl,
       {
         method: "PATCH",
         body: JSON.stringify({ thumbnail_url: uploadBody.url })
-      }
+      },
+      env
     );
+    logger.log(`  \u2190 HTTP ${patchRes.status} ${patchRes.statusText}`);
     if (!patchRes.ok) {
-      const patchData = await patchRes.json();
-      const patchBody = patchData.statusCode ? patchData.body : patchData;
-      throw new Error(patchBody.error || "Failed to set thumbnail");
+      const patchRawText = await patchRes.text();
+      logger.log(`  \u2190 raw response: ${patchRawText.slice(0, 500)}`);
+      let patchBody = {};
+      try {
+        patchBody = JSON.parse(patchRawText);
+      } catch {
+      }
+      patchBody = patchBody.statusCode ? patchBody.body : patchBody;
+      throw new Error(
+        `Thumbnail patch failed \u2014 HTTP ${patchRes.status}: ${patchBody.error || patchBody.message || patchRawText.slice(0, 200)}`
+      );
     }
     logger.stopSpinner(true, "Thumbnail set");
   } catch (err) {
-    logger.stopSpinner(false, "Thumbnail upload skipped");
+    logger.stopSpinner(false, "Thumbnail upload failed");
+    logger.error(err instanceof Error ? err.message : String(err));
     logger.info(
-      `Theme published successfully. Thumbnail can be updated later.`
+      "Theme published successfully. Thumbnail can be updated later."
     );
   }
 }
@@ -5179,7 +5863,7 @@ async function screenshotHomePage(themePath, distDir) {
   const { compilePreviewRuntime: compilePreviewRuntime2 } = await Promise.resolve().then(() => (init_compile_theme(), compile_theme_exports));
   const { createDevServer: createDevServer2 } = await Promise.resolve().then(() => (init_dev_server(), dev_server_exports));
   const previewRuntimePath = await compilePreviewRuntime2(themePath);
-  const themeName = path9.basename(themePath);
+  const themeName = path11.basename(themePath);
   const port = await findFreePort(4500);
   const server = createDevServer2({
     port,
@@ -5235,25 +5919,40 @@ async function findFreePort(start) {
     srv.on("error", () => resolve(findFreePort(start + 1)));
   });
 }
-async function uploadVideoMultipart(apiUrl, themeId, video) {
-  const fileName = path9.basename(video.originalPath);
+async function uploadVideoMultipart(apiUrl, themeId, video, env = "dev") {
+  const fileName = path11.basename(video.originalPath);
+  const videoInitUrl = `${apiUrl}/media/videos/multipart/init`;
+  const videoInitBody = {
+    file_name: fileName,
+    content_type: video.contentType,
+    file_size: video.size,
+    prefix: `themes/${themeId}/assets`
+  };
+  logger.log(`  \u2192 POST ${videoInitUrl}`);
+  logger.log(`  \u2192 body: ${JSON.stringify(videoInitBody)}`);
   const initRes = await authenticatedFetch(
-    `${apiUrl}/media/videos/multipart/init`,
+    videoInitUrl,
     {
       method: "POST",
-      body: JSON.stringify({
-        file_name: fileName,
-        content_type: video.contentType,
-        file_size: video.size,
-        prefix: `themes/${themeId}/assets`
-      })
-    }
+      body: JSON.stringify(videoInitBody)
+    },
+    env
   );
-  const initData = await initRes.json();
+  logger.log(`  \u2190 HTTP ${initRes.status} ${initRes.statusText}`);
+  const initRawText = await initRes.text();
+  logger.log(`  \u2190 raw response: ${initRawText.slice(0, 500)}`);
+  let initData;
+  try {
+    initData = JSON.parse(initRawText);
+  } catch {
+    throw new Error(
+      `Video init returned non-JSON (HTTP ${initRes.status}): ${initRawText.slice(0, 200)}`
+    );
+  }
   const initBody = initData.statusCode ? initData.body : initData;
   if (!initRes.ok || !initBody.upload_id) {
     throw new Error(
-      `Init multipart failed for ${fileName}: ${initBody.error || initRes.status}`
+      `Init multipart failed for ${fileName} \u2014 HTTP ${initRes.status}: ${initBody.error || initBody.message || JSON.stringify(initBody).slice(0, 300)}`
     );
   }
   const { upload_id, file_key, chunk_size, chunk_urls } = initBody;
@@ -5288,25 +5987,47 @@ async function uploadVideoMultipart(apiUrl, themeId, video) {
     )
   );
   parts.sort((a, b) => a.part_number - b.part_number);
+  const videoCompleteUrl = `${apiUrl}/media/videos/multipart/complete`;
+  logger.log(`  \u2192 POST ${videoCompleteUrl}`);
+  logger.log(
+    `  \u2192 body: ${JSON.stringify({ upload_id, file_key, parts: `[${parts.length} parts]` })}`
+  );
   const completeRes = await authenticatedFetch(
-    `${apiUrl}/media/videos/multipart/complete`,
+    videoCompleteUrl,
     {
       method: "POST",
       body: JSON.stringify({ upload_id, file_key, parts })
-    }
+    },
+    env
   );
-  const completeData = await completeRes.json();
+  logger.log(`  \u2190 HTTP ${completeRes.status} ${completeRes.statusText}`);
+  const completeRawText = await completeRes.text();
+  logger.log(`  \u2190 raw response: ${completeRawText.slice(0, 500)}`);
+  let completeData;
+  try {
+    completeData = JSON.parse(completeRawText);
+  } catch {
+    throw new Error(
+      `Video complete returned non-JSON (HTTP ${completeRes.status}): ${completeRawText.slice(0, 200)}`
+    );
+  }
   const completeBody = completeData.statusCode ? completeData.body : completeData;
   if (!completeRes.ok || !completeBody.url) {
     try {
-      await authenticatedFetch(`${apiUrl}/media/videos/multipart/abort`, {
-        method: "POST",
-        body: JSON.stringify({ upload_id, file_key })
-      });
+      const abortUrl = `${apiUrl}/media/videos/multipart/abort`;
+      logger.log(`  \u2192 POST ${abortUrl} (cleanup)`);
+      await authenticatedFetch(
+        abortUrl,
+        {
+          method: "POST",
+          body: JSON.stringify({ upload_id, file_key })
+        },
+        env
+      );
     } catch {
     }
     throw new Error(
-      `Complete multipart failed for ${fileName}: ${completeBody.error || completeRes.status}`
+      `Complete multipart failed for ${fileName} \u2014 HTTP ${completeRes.status}: ${completeBody.error || completeBody.message || JSON.stringify(completeBody).slice(0, 300)}`
     );
   }
   return completeBody.url;
@@ -5328,6 +6049,91 @@ async function createZip(sourceDir, outputPath, exclude) {
     archive.finalize();
   });
 }
+async function runSchemaDiffGate(themeId, distDir, env, options) {
+  logger.startSpinner("Fetching prior version for diff...");
+  const { result: prior, reason } = await fetchPriorGateManifests(themeId, env);
+  if (!prior) {
+    if (reason === "no-prior") {
+      logger.stopSpinner(true, "First publish \u2014 no prior version to diff");
+    } else {
+      logger.stopSpinner(true, `Gate skipped (${reason})`);
+    }
+    return null;
+  }
+  logger.stopSpinner(true, `Fetched prior version ${prior.version}`);
+  let currentSchemas;
+  let currentAssets;
+  try {
+    currentSchemas = JSON.parse(
+      await fs.readFile(path11.join(distDir, "schemas.json"), "utf-8")
+    );
+  } catch (err) {
+    logger.warning(
+      `Gate skipped: dist/schemas.json missing or unreadable (${err instanceof Error ? err.message : "unknown"})`
+    );
+    return null;
+  }
+  try {
+    currentAssets = JSON.parse(
+      await fs.readFile(path11.join(distDir, "asset-manifest.json"), "utf-8")
+    );
+  } catch {
+    currentAssets = { manifestVersion: 1, assets: [] };
+  }
+  const changes = diffManifests(
+    { schemas: prior.schemas, assets: prior.assets },
+    { schemas: currentSchemas, assets: currentAssets }
+  );
+  const classification = classify(changes);
+  printGateReport(prior.version, classification);
+  if (options.dryRun) return classification;
+  const isBreaking = classification.highest === "breaking" || classification.highest === "breaking-severe" || classification.highest === "breaking-asset";
+  if (isBreaking && !options.force) {
+    logger.error(
+      "\nPublish blocked: breaking changes detected.\n  \u2022 Bump major version and ship migration notes, OR\n  \u2022 Re-run with --force to override (logged in the audit trail)."
+    );
+    process.exit(1);
+  }
+  if (classification.highest === "defaults-only" && !options.confirmDefaults) {
+    logger.error(
+      "\nPublish blocked: default values changed.\nThese defaults will propagate to every customer site that hasn't overridden\nthe field. Re-run with --confirm-defaults to acknowledge the change, or\nrevert the default if it wasn't intentional."
+    );
+    process.exit(1);
+  }
+  return classification;
+}
+function printGateReport(priorVersion, classification) {
+  logger.newLine();
+  logger.info(`Schema diff vs. v${priorVersion}:`);
+  if (classification.changes.length === 0) {
+    logger.log("  \u2713 Safe \u2014 no schema changes detected");
+    return;
+  }
+  for (const change of classification.changes) {
+    const icon = iconFor(change.kind);
+    logger.log(`  ${icon} [${change.kind}] ${change.path} \u2014 ${change.detail}`);
+  }
+  logger.log(
+    `
+  \u2192 Classification: ${classification.highest}. Suggested bump: ${classification.bump}.`
+  );
+}
+function iconFor(kind) {
+  switch (kind) {
+    case "safe":
+    case "safe-rename":
+      return "\u2713";
+    case "additive":
+      return "+";
+    case "defaults-only":
+      return "\u26A0";
+    case "breaking":
+    case "breaking-asset":
+      return "\u2717";
+    case "breaking-severe":
+      return "\u2717\u2717";
+  }
+}
 // src/commands/mcp.ts
 init_logger();
@@ -5339,18 +6145,18 @@ var AI_CONTEXT_FILES = [
   ".mcp.json"
 ];
 function resolveTargetDir(opts) {
-  return path9.resolve(opts.cwd ?? process.cwd());
+  return path11.resolve(opts.cwd ?? process.cwd());
 }
 function resolveDefaultTemplateDir() {
-  return path9.join(getTemplatesDir(), "default");
+  return path11.join(getTemplatesDir(), "default");
 }
 function isThemeDir(dir) {
-  return fs.existsSync(path9.join(dir, "theme.config.ts")) || fs.existsSync(path9.join(dir, "theme.config.js"));
+  return fs.existsSync(path11.join(dir, "theme.config.ts")) || fs.existsSync(path11.join(dir, "theme.config.js"));
 }
 function inspectFiles(templateDir, targetDir) {
   return AI_CONTEXT_FILES.map((name) => {
-    const templatePath = path9.join(templateDir, name);
-    const targetPath = path9.join(targetDir, name);
+    const templatePath = path11.join(templateDir, name);
+    const targetPath = path11.join(targetDir, name);
     const exists = fs.existsSync(targetPath);
     let identical = false;
     if (exists && fs.existsSync(templatePath)) {
@@ -5493,7 +6299,7 @@ async function mcpDoctorCommand(options = {}) {
     return;
   }
   logger.success("theme.config.ts present");
-  const mcpJsonPath = path9.join(targetDir, ".mcp.json");
+  const mcpJsonPath = path11.join(targetDir, ".mcp.json");
   if (!fs.existsSync(mcpJsonPath)) {
     logger.error(".mcp.json missing \u2014 run `onexthm mcp setup`");
   } else {
@@ -5531,7 +6337,7 @@ async function mcpDoctorCommand(options = {}) {
       logger.success(`${s.name} up to date`);
     }
   }
-  const registryPath = path9.join(targetDir, "sections-registry.ts");
+  const registryPath = path11.join(targetDir, "sections-registry.ts");
   if (fs.existsSync(registryPath)) {
     logger.success("sections-registry.ts present");
   } else {
@@ -5543,22 +6349,22 @@ async function mcpDoctorCommand(options = {}) {
 // src/cli.ts
 dotenv.config({
-  path: path9.join(process.cwd(), ".env.local"),
+  path: path11.join(process.cwd(), ".env.local"),
   override: true
 });
-dotenv.config({ path: path9.join(process.cwd(), ".env") });
+dotenv.config({ path: path11.join(process.cwd(), ".env") });
 try {
   const projectRoot = getProjectRoot();
-  if (path9.resolve(projectRoot) !== path9.resolve(process.cwd())) {
+  if (path11.resolve(projectRoot) !== path11.resolve(process.cwd())) {
     dotenv.config({
-      path: path9.join(projectRoot, ".env.local")
+      path: path11.join(projectRoot, ".env.local")
     });
-    dotenv.config({ path: path9.join(projectRoot, ".env") });
+    dotenv.config({ path: path11.join(projectRoot, ".env") });
   }
 } catch {
 }
 dotenv.config({
-  path: path9.join(os.homedir(), ".onexthm", ".env"),
+  path: path11.join(os.homedir(), ".onexthm", ".env"),
   quiet: true
 });
 var require2 = createRequire(import.meta.url);
@@ -5569,7 +6375,11 @@ program.command("init").description("Create a new OneX theme project").argument(
   "-t, --template <template>",
   "Template to use (default, minimal)",
   "default"
-).option("--no-install", "Skip installing dependencies").option("--git", "Initialize git repository").option("-y, --yes", "Skip prompts and use defaults").action(initCommand);
+).option("--no-install", "Skip installing dependencies").option("--git", "Initialize git repository").option("-y, --yes", "Skip prompts and use defaults").option(
+  "--env <env>",
+  "Target environment: dev, staging, or prod (default: dev)",
+  "dev"
+).action(initCommand);
 program.command("create:section").alias("cs").description("Create a new section").argument("<name>", "Name of the section (e.g., hero, features)").option("-t, --theme <theme>", "Theme to create section in").option(
   "-c, --category <category>",
   "Section category (headers, content, footers)"
@@ -5596,16 +6406,36 @@ program.command("download").description("Download a published theme via the webs
   "-v, --version <version>",
   "Theme version (default: latest)",
   "latest"
-).option("-b, --bucket <name>", "[deprecated] ignored").option("-e, --environment <env>", "[deprecated] ignored").option("-o, --output <dir>", "Output directory", "./active-theme").action(downloadCommand);
+).option(
+  "--env <env>",
+  "Target environment: dev, staging, or prod (default: dev)",
+  "dev"
+).option("-b, --bucket <name>", "[deprecated] ignored").option("-o, --output <dir>", "Output directory", "./active-theme").action(downloadCommand);
 program.command("clone").description("Clone theme source code via the website-api").argument("<theme-name>", "Theme to clone").option(
   "-v, --version <version>",
   "Theme version (default: latest)",
   "latest"
-).option("-n, --name <name>", "New theme name (skips interactive prompt)").option("-o, --output <dir>", "Output directory").option("-b, --bucket <name>", "[deprecated] ignored").option("-e, --environment <env>", "[deprecated] ignored").option("--no-install", "Skip running pnpm install after clone").action(cloneCommand);
+).option("-n, --name <name>", "New theme name (skips interactive prompt)").option("-o, --output <dir>", "Output directory").option(
+  "--env <env>",
+  "Target environment: dev, staging, or prod (default: dev)",
+  "dev"
+).option("-b, --bucket <name>", "[deprecated] ignored").option("--no-install", "Skip running pnpm install after clone").action(cloneCommand);
 program.command("config").description("Configure OneX CLI credentials (AWS, API keys)").action(configCommand);
-program.command("login").description("Login to OneX platform").action(loginCommand);
-program.command("logout").description("Logout from OneX platform").action(logoutCommand);
-program.command("whoami").description("Show current logged-in developer").action(whoamiCommand);
+program.command("login").description("Login to OneX platform").option(
+  "--env <env>",
+  "Target environment: dev, staging, or prod (default: dev)",
+  "dev"
+).action(loginCommand);
+program.command("logout").description("Logout from OneX platform").option(
+  "--env <env>",
+  "Target environment: dev, staging, or prod (default: dev)",
+  "dev"
+).action(logoutCommand);
+program.command("whoami").description("Show current logged-in developer").option(
+  "--env <env>",
+  "Target environment: dev, staging, or prod (default: dev)",
+  "dev"
+).action(whoamiCommand);
 var mcpCmd = program.command("mcp").description("Manage MCP server registration and AI-context files");
 mcpCmd.command("setup").description(
   "Install .mcp.json + CLAUDE.md + AGENTS.md + .cursorrules into the current theme"
@@ -5617,6 +6447,19 @@ mcpCmd.command("doctor").description("Diagnose MCP setup in the current theme di
 program.command("publish").description("Build, scan, and publish theme to marketplace (requires login)").option("-t, --theme <path>", "Theme directory path").option(
   "--bump <type>",
   "Auto-bump version before publish (patch|minor|major)"
+).option(
+  "--env <env>",
+  "Target environment: dev, staging, or prod (default: dev)",
+  "dev"
+).option(
+  "--dry-run",
+  "Build locally and print the schema-diff classification without publishing"
+).option(
+  "--confirm-defaults",
+  "Confirm that changed section/block defaults should propagate to live sites"
+).option(
+  "--force",
+  "Publish even when the diff gate detects a breaking change"
 ).action(publishCommand);
 program.configureOutput({
   writeErr: (str) => process.stderr.write(chalk4.red(str))