@onexapis/cli 1.1.64 → 1.1.66

package/dist/cli.js

@@ -3,18 +3,18 @@
 
 var chalk4 = require('chalk');
 var ora = require('ora');
-var esbuild = require('esbuild');
-var path9 = require('path');
-var fs8 = require('fs/promises');
-var crypto = require('crypto');
+var path11 = require('path');
 var glob = require('glob');
+var fs = require('fs-extra');
+var crypto = require('crypto');
+var esbuild = require('esbuild');
+var fs9 = require('fs/promises');
 var module$1 = require('module');
 var http = require('http');
 var fs3 = require('fs');
 var ws = require('ws');
 var os = require('os');
 var dotenv = require('dotenv');
-var fs = require('fs-extra');
 var ejs = require('ejs');
 var child_process = require('child_process');
 var commander = require('commander');
@@ -49,15 +49,15 @@ function _interopNamespace(e) {
 
 var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
-var esbuild__namespace = /*#__PURE__*/_interopNamespace(esbuild);
-var path9__default = /*#__PURE__*/_interopDefault(path9);
-var fs8__default = /*#__PURE__*/_interopDefault(fs8);
+var path11__default = /*#__PURE__*/_interopDefault(path11);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var esbuild__namespace = /*#__PURE__*/_interopNamespace(esbuild);
+var fs9__default = /*#__PURE__*/_interopDefault(fs9);
 var http__default = /*#__PURE__*/_interopDefault(http);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
-var fs__default = /*#__PURE__*/_interopDefault(fs);
 var ejs__default = /*#__PURE__*/_interopDefault(ejs);
 var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
 var archiver__default = /*#__PURE__*/_interopDefault(archiver);
@@ -132,6 +132,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((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)));
+  const schemaFiles = await glob.glob("sections/**/*.schema.ts", { cwd: themePath });
+  const sections = {};
+  for (const file of schemaFiles) {
+    try {
+      const mod = await jiti.import(path11__default.default.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__default.default.extname(filename).toLowerCase();
+  return MIME_MAP[ext] || "application/octet-stream";
+}
+async function sha256Prefix(absPath, len) {
+  const buf = await fs__default.default.readFile(absPath);
+  return crypto__default.default.createHash("sha256").update(buf).digest("hex").slice(0, len);
+}
+function insertHashIntoName(relPath, hash) {
+  const dir = path11__default.default.posix.dirname(relPath);
+  const base = path11__default.default.posix.basename(relPath);
+  const ext = path11__default.default.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__default.default.join(distDir, "theme-assets");
+  if (!await fs__default.default.pathExists(assetsDir)) return [];
+  const files = await glob.glob("**/*", {
+    cwd: assetsDir,
+    nodir: true,
+    dot: false
+  });
+  const results = [];
+  for (const rel of files) {
+    const absPath = path11__default.default.join(assetsDir, rel);
+    const stat = await fs__default.default.stat(absPath);
+    if (!stat.isFile()) continue;
+    const originalPath = rel.split(path11__default.default.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 = {};
@@ -147,8 +347,8 @@ async function generateThemeCSS(themePath, outDir) {
     const tailwindcss = (await import('tailwindcss')).default;
     const tailwindConfig = {
       content: [
-        path9__default.default.join(themePath, "sections/**/*.{ts,tsx}"),
-        path9__default.default.join(themePath, "components/**/*.{ts,tsx}")
+        path11__default.default.join(themePath, "sections/**/*.{ts,tsx}"),
+        path11__default.default.join(themePath, "components/**/*.{ts,tsx}")
       ],
       theme: { extend: {} },
       plugins: []
@@ -158,7 +358,7 @@ async function generateThemeCSS(themePath, outDir) {
       inputCSS,
       { from: void 0 }
     );
-    await fs8__default.default.writeFile(path9__default.default.join(outDir, "bundle.css"), result.css);
+    await fs9__default.default.writeFile(path11__default.default.join(outDir, "bundle.css"), result.css);
     logger.info("Generated bundle.css");
   } catch (err) {
     logger.warning(
@@ -169,12 +369,12 @@ async function generateThemeCSS(themePath, outDir) {
 async function resolveNodeModulesFile(startDir, relativePath) {
   let dir = startDir;
   while (true) {
-    const candidate = path9__default.default.join(dir, "node_modules", relativePath);
+    const candidate = path11__default.default.join(dir, "node_modules", relativePath);
     try {
-      await fs8__default.default.access(candidate);
+      await fs9__default.default.access(candidate);
       return candidate;
     } catch {
-      const parent = path9__default.default.dirname(dir);
+      const parent = path11__default.default.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -198,7 +398,7 @@ async function scanImportsFromPackage(sourceDir, packageName) {
   });
   for (const file of sourceFiles) {
     try {
-      const content = await fs8__default.default.readFile(path9__default.default.join(sourceDir, file), "utf-8");
+      const content = await fs9__default.default.readFile(path11__default.default.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();
@@ -252,17 +452,17 @@ function createCoreGlobalPlugin(themePath) {
           const distFileName = subpath ? `${subpath}.mjs` : "index.mjs";
           let distPath = await resolveNodeModulesFile(
             themePath,
-            path9__default.default.join("@onexapis", "core", "dist", distFileName)
+            path11__default.default.join("@onexapis", "core", "dist", distFileName)
           );
           if (!distPath) {
             distPath = await resolveNodeModulesFile(
               __dirname,
-              path9__default.default.join("@onexapis", "core", "dist", distFileName)
+              path11__default.default.join("@onexapis", "core", "dist", distFileName)
             );
           }
           try {
             if (!distPath) throw new Error("not found");
-            const distContent = await fs8__default.default.readFile(distPath, "utf-8");
+            const distContent = await fs9__default.default.readFile(distPath, "utf-8");
             const exportMatches = distContent.matchAll(/export\s*\{([^}]+)\}/g);
             for (const m of exportMatches) {
               const names = m[1].split(",").map((n) => {
@@ -491,7 +691,7 @@ async function generateThemeData(themePath, outputDir, themeId) {
   const pages = {};
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path9__default.default.join(themePath, `theme.config${ext}`));
+      const mod = await jiti.import(path11__default.default.join(themePath, `theme.config${ext}`));
       themeConfig = mod.default || mod;
       break;
     } catch {
@@ -499,20 +699,20 @@ async function generateThemeData(themePath, outputDir, themeId) {
   }
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path9__default.default.join(themePath, `theme.layout${ext}`));
+      const mod = await jiti.import(path11__default.default.join(themePath, `theme.layout${ext}`));
       layoutConfig = mod.default || mod;
       break;
     } catch {
     }
   }
   const schemas = {};
-  const sectionsDir = path9__default.default.join(themePath, "sections");
+  const sectionsDir = path11__default.default.join(themePath, "sections");
   try {
-    const sectionDirs = await fs8__default.default.readdir(sectionsDir);
+    const sectionDirs = await fs9__default.default.readdir(sectionsDir);
     for (const dir of sectionDirs) {
-      const schemaFile = path9__default.default.join(sectionsDir, dir, `${dir}.schema.ts`);
+      const schemaFile = path11__default.default.join(sectionsDir, dir, `${dir}.schema.ts`);
       try {
-        await fs8__default.default.access(schemaFile);
+        await fs9__default.default.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) {
@@ -524,14 +724,14 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  const pagesDir = path9__default.default.join(themePath, "pages");
+  const pagesDir = path11__default.default.join(themePath, "pages");
   try {
-    const files = await fs8__default.default.readdir(pagesDir);
+    const files = await fs9__default.default.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__default.default.join(pagesDir, file));
+        const mod = await jiti.import(path11__default.default.join(pagesDir, file));
         const config = mod.default || mod;
         const sections = (config.sections || []).map((section) => {
           const schema = schemas[section.type];
@@ -559,8 +759,8 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  await fs8__default.default.writeFile(
-    path9__default.default.join(outputDir, "theme-data.json"),
+  await fs9__default.default.writeFile(
+    path11__default.default.join(outputDir, "theme-data.json"),
     JSON.stringify(
       {
         themeId,
@@ -583,22 +783,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__default.default.join(outputDir, "bundle-entry.js");
-  const mapPath = path9__default.default.join(outputDir, "bundle-entry.js.map");
+  const entryPath = path11__default.default.join(outputDir, "bundle-entry.js");
+  const mapPath = path11__default.default.join(outputDir, "bundle-entry.js.map");
   let entryContent;
   try {
-    entryContent = await fs8__default.default.readFile(entryPath, "utf-8");
+    entryContent = await fs9__default.default.readFile(entryPath, "utf-8");
   } catch {
-    const indexPath = path9__default.default.join(outputDir, "index.js");
+    const indexPath = path11__default.default.join(outputDir, "index.js");
     try {
-      entryContent = await fs8__default.default.readFile(indexPath, "utf-8");
+      entryContent = await fs9__default.default.readFile(indexPath, "utf-8");
     } catch {
       logger.warning("No entry file found in output, skipping content hash");
       return;
     }
     const hash2 = crypto__default.default.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
     const hashedName2 = `bundle-entry-${hash2}.js`;
-    const indexMapPath = path9__default.default.join(outputDir, "index.js.map");
+    const indexMapPath = path11__default.default.join(outputDir, "index.js.map");
     const hashedMapName2 = `bundle-entry-${hash2}.js.map`;
     entryContent = entryContent.replace(
       /\/\/# sourceMappingURL=index\.js\.map/,
@@ -606,18 +806,18 @@ async function contentHashEntry(outputDir) {
     );
     const oldFiles2 = await glob.glob("bundle-entry-*.js*", { cwd: outputDir });
     for (const f of oldFiles2) {
-      await fs8__default.default.unlink(path9__default.default.join(outputDir, f));
+      await fs9__default.default.unlink(path11__default.default.join(outputDir, f));
     }
-    await fs8__default.default.writeFile(path9__default.default.join(outputDir, hashedName2), entryContent);
-    await fs8__default.default.unlink(indexPath);
+    await fs9__default.default.writeFile(path11__default.default.join(outputDir, hashedName2), entryContent);
+    await fs9__default.default.unlink(indexPath);
     try {
-      await fs8__default.default.unlink(entryPath);
+      await fs9__default.default.unlink(entryPath);
     } catch {
     }
-    await fs8__default.default.writeFile(entryPath, entryContent);
+    await fs9__default.default.writeFile(entryPath, entryContent);
     try {
-      await fs8__default.default.access(indexMapPath);
-      await fs8__default.default.rename(indexMapPath, path9__default.default.join(outputDir, hashedMapName2));
+      await fs9__default.default.access(indexMapPath);
+      await fs9__default.default.rename(indexMapPath, path11__default.default.join(outputDir, hashedMapName2));
     } catch {
     }
     logger.info(`Entry hashed: ${hashedName2}`);
@@ -632,17 +832,17 @@ async function contentHashEntry(outputDir) {
   );
   const oldFiles = await glob.glob("bundle-entry-*.js*", { cwd: outputDir });
   for (const f of oldFiles) {
-    await fs8__default.default.unlink(path9__default.default.join(outputDir, f));
+    await fs9__default.default.unlink(path11__default.default.join(outputDir, f));
   }
-  await fs8__default.default.writeFile(path9__default.default.join(outputDir, hashedName), entryContent);
+  await fs9__default.default.writeFile(path11__default.default.join(outputDir, hashedName), entryContent);
   try {
-    await fs8__default.default.unlink(entryPath);
+    await fs9__default.default.unlink(entryPath);
   } catch {
   }
-  await fs8__default.default.writeFile(entryPath, entryContent);
+  await fs9__default.default.writeFile(entryPath, entryContent);
   try {
-    await fs8__default.default.access(mapPath);
-    await fs8__default.default.rename(mapPath, path9__default.default.join(outputDir, hashedMapName));
+    await fs9__default.default.access(mapPath);
+    await fs9__default.default.rename(mapPath, path11__default.default.join(outputDir, hashedMapName));
   } catch {
   }
   logger.info(`Entry hashed: ${hashedName}`);
@@ -654,7 +854,7 @@ async function extractDataRequirements(themePath) {
   const requirements = {};
   for (const file of schemaFiles) {
     try {
-      const mod = await jiti.import(path9__default.default.join(themePath, file));
+      const mod = await jiti.import(path11__default.default.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") {
@@ -669,12 +869,46 @@ async function extractDataRequirements(themePath) {
   }
   return requirements;
 }
+async function writeGateManifests(themePath, outputDir) {
+  try {
+    const schemas = await extractSchemas(themePath);
+    await fs9__default.default.writeFile(
+      path11__default.default.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__default.default.writeFile(
+      path11__default.default.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__default.default.readFile(
-      path9__default.default.join(themePath, "package.json"),
+    const pkgContent = await fs9__default.default.readFile(
+      path11__default.default.join(themePath, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(pkgContent);
@@ -692,7 +926,7 @@ async function generateManifest(themeName, themePath, outputDir) {
   const dataRequirements = await extractDataRequirements(themePath);
   let hasThemeConfig = false;
   try {
-    await fs8__default.default.access(path9__default.default.join(themePath, "theme.config.ts"));
+    await fs9__default.default.access(path11__default.default.join(themePath, "theme.config.ts"));
     hasThemeConfig = true;
   } catch {
   }
@@ -733,24 +967,24 @@ async function generateManifest(themeName, themePath, outputDir) {
     // Section data requirements for server-side prefetching (keyed by section type)
     dataRequirements
   };
-  await fs8__default.default.writeFile(
-    path9__default.default.join(outputDir, "manifest.json"),
+  await fs9__default.default.writeFile(
+    path11__default.default.join(outputDir, "manifest.json"),
     JSON.stringify(manifest, null, 2)
   );
 }
 async function compileStandaloneTheme(themePath, themeName) {
-  const outputDir = path9__default.default.join(themePath, "dist");
-  const bundleEntry = path9__default.default.join(themePath, "bundle-entry.ts");
-  const indexEntry = path9__default.default.join(themePath, "index.ts");
+  const outputDir = path11__default.default.join(themePath, "dist");
+  const bundleEntry = path11__default.default.join(themePath, "bundle-entry.ts");
+  const indexEntry = path11__default.default.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs8__default.default.access(bundleEntry);
+    await fs9__default.default.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path9__default.default.join(outputDir, ".process-shim.js");
-  await fs8__default.default.mkdir(outputDir, { recursive: true });
-  await fs8__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path11__default.default.join(outputDir, ".process-shim.js");
+  await fs9__default.default.mkdir(outputDir, { recursive: true });
+  await fs9__default.default.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -801,19 +1035,20 @@ async function compileStandaloneTheme(themePath, themeName) {
   try {
     const result = await esbuild__namespace.build(buildOptions);
     try {
-      await fs8__default.default.unlink(shimPath);
+      await fs9__default.default.unlink(shimPath);
     } catch {
     }
     await contentHashEntry(outputDir);
-    const themeAssetsDir = path9__default.default.join(themePath, "assets");
-    const distThemeAssets = path9__default.default.join(outputDir, "theme-assets");
+    const themeAssetsDir = path11__default.default.join(themePath, "assets");
+    const distThemeAssets = path11__default.default.join(outputDir, "theme-assets");
     try {
-      await fs8__default.default.access(themeAssetsDir);
-      await fs8__default.default.cp(themeAssetsDir, distThemeAssets, { recursive: true });
+      await fs9__default.default.access(themeAssetsDir);
+      await fs9__default.default.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) {
@@ -828,7 +1063,7 @@ async function compileStandaloneTheme(themePath, themeName) {
     return true;
   } catch (error) {
     try {
-      await fs8__default.default.unlink(shimPath);
+      await fs9__default.default.unlink(shimPath);
     } catch {
     }
     logger.error(`esbuild compilation failed: ${error}`);
@@ -836,18 +1071,18 @@ async function compileStandaloneTheme(themePath, themeName) {
   }
 }
 async function compileStandaloneThemeDev(themePath, themeName) {
-  const outputDir = path9__default.default.join(themePath, "dist");
-  const bundleEntry = path9__default.default.join(themePath, "bundle-entry.ts");
-  const indexEntry = path9__default.default.join(themePath, "index.ts");
+  const outputDir = path11__default.default.join(themePath, "dist");
+  const bundleEntry = path11__default.default.join(themePath, "bundle-entry.ts");
+  const indexEntry = path11__default.default.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs8__default.default.access(bundleEntry);
+    await fs9__default.default.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path9__default.default.join(outputDir, ".process-shim.js");
-  await fs8__default.default.mkdir(outputDir, { recursive: true });
-  await fs8__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path11__default.default.join(outputDir, ".process-shim.js");
+  await fs9__default.default.mkdir(outputDir, { recursive: true });
+  await fs9__default.default.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -901,18 +1136,18 @@ async function compileStandaloneThemeDev(themePath, themeName) {
   return { context: context2, outputDir };
 }
 async function compilePreviewRuntime(themePath) {
-  const outputDir = path9__default.default.join(themePath, "dist");
-  await fs8__default.default.mkdir(outputDir, { recursive: true });
-  const outputPath = path9__default.default.join(outputDir, "preview-runtime.js");
+  const outputDir = path11__default.default.join(themePath, "dist");
+  await fs9__default.default.mkdir(outputDir, { recursive: true });
+  const outputPath = path11__default.default.join(outputDir, "preview-runtime.js");
   const locations = [
-    path9__default.default.join(__dirname, "..", "preview", "preview-app.tsx"),
-    path9__default.default.join(__dirname, "preview", "preview-app.tsx"),
-    path9__default.default.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
+    path11__default.default.join(__dirname, "..", "preview", "preview-app.tsx"),
+    path11__default.default.join(__dirname, "preview", "preview-app.tsx"),
+    path11__default.default.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
   ];
   let previewEntryPath = null;
   for (const loc of locations) {
     try {
-      await fs8__default.default.access(loc);
+      await fs9__default.default.access(loc);
       previewEntryPath = loc;
       break;
     } catch {
@@ -995,10 +1230,10 @@ ${locations.join("\n")}`
         if (!lucideScanned) {
           lucideScanned = true;
           const coreSrcCandidates = [
-            path9__default.default.join(themePath, "node_modules", "@onexapis", "core", "src"),
-            path9__default.default.join(themePath, "..", "..", "packages", "core", "src"),
+            path11__default.default.join(themePath, "node_modules", "@onexapis", "core", "src"),
+            path11__default.default.join(themePath, "..", "..", "packages", "core", "src"),
             // monorepo sibling
-            path9__default.default.join(
+            path11__default.default.join(
               __dirname,
               "..",
               "..",
@@ -1013,7 +1248,7 @@ ${locations.join("\n")}`
           let coreSourceDir = null;
           for (const candidate of coreSrcCandidates) {
             try {
-              await fs8__default.default.access(candidate);
+              await fs9__default.default.access(candidate);
               coreSourceDir = candidate;
               break;
             } catch {
@@ -1032,21 +1267,21 @@ ${locations.join("\n")}`
             }
           } else {
             const coreDistCandidates = [
-              path9__default.default.join(themePath, "node_modules", "@onexapis", "core", "dist")
+              path11__default.default.join(themePath, "node_modules", "@onexapis", "core", "dist")
             ];
             const resolvedDist = await resolveNodeModulesFile(
               __dirname,
-              path9__default.default.join("@onexapis", "core", "dist")
+              path11__default.default.join("@onexapis", "core", "dist")
             );
             if (resolvedDist) coreDistCandidates.push(resolvedDist);
             for (const candidate of coreDistCandidates) {
               try {
-                await fs8__default.default.access(candidate);
+                await fs9__default.default.access(candidate);
                 const mjsFiles = await glob.glob("*.mjs", { cwd: candidate });
                 const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']lucide-react["']/g;
                 for (const file of mjsFiles) {
-                  const content = await fs8__default.default.readFile(
-                    path9__default.default.join(candidate, file),
+                  const content = await fs9__default.default.readFile(
+                    path11__default.default.join(candidate, file),
                     "utf-8"
                   );
                   for (const match of content.matchAll(importRegex)) {
@@ -1101,7 +1336,7 @@ export default new Proxy({}, { get: (_, name) => name === '__esModule' ? true :
           const req = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)) || __filename);
           const cjsPath = req.resolve("framer-motion");
           const pkgDir = cjsPath.replace(/[/\\]dist[/\\].*$/, "");
-          const esmEntry = path9__default.default.join(pkgDir, "dist", "es", "index.mjs");
+          const esmEntry = path11__default.default.join(pkgDir, "dist", "es", "index.mjs");
           const { existsSync } = await import('fs');
           if (existsSync(esmEntry)) {
             return { path: esmEntry, namespace: "file" };
@@ -1200,8 +1435,8 @@ export function headers() { return new Headers(); }
       });
     }
   };
-  const shimPath = path9__default.default.join(outputDir, ".process-shim-preview.js");
-  await fs8__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path11__default.default.join(outputDir, ".process-shim-preview.js");
+  await fs9__default.default.writeFile(shimPath, PROCESS_SHIM);
   await esbuild__namespace.build({
     entryPoints: [previewEntryPath],
     bundle: true,
@@ -1236,7 +1471,7 @@ export function headers() { return new Headers(); }
     }
   });
   try {
-    await fs8__default.default.unlink(shimPath);
+    await fs9__default.default.unlink(shimPath);
   } catch {
   }
   return outputPath;
@@ -1245,6 +1480,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 = {
@@ -1400,7 +1637,7 @@ __export(dev_server_exports, {
 });
 function createDevServer(options) {
   const clients = /* @__PURE__ */ new Set();
-  const themeDataPath = path9__default.default.join(options.distDir, "theme-data.json");
+  const themeDataPath = path11__default.default.join(options.distDir, "theme-data.json");
   const server = http__default.default.createServer((req, res) => {
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
@@ -1426,8 +1663,8 @@ function createDevServer(options) {
     if (pathname.startsWith("/_assets/")) {
       const parts = pathname.replace(/^\/_assets\//, "").split("/");
       const assetSubpath = parts.slice(1).join("/");
-      const assetPath = path9__default.default.join(options.themePath, "assets", assetSubpath);
-      if (!assetPath.startsWith(path9__default.default.join(options.themePath, "assets"))) {
+      const assetPath = path11__default.default.join(options.themePath, "assets", assetSubpath);
+      if (!assetPath.startsWith(path11__default.default.join(options.themePath, "assets"))) {
         res.writeHead(403);
         res.end("Forbidden");
         return;
@@ -1438,8 +1675,8 @@ function createDevServer(options) {
     if (pathname.startsWith("/themes/")) {
       const match = pathname.match(/^\/themes\/[^/]+\/assets\/(.+)/);
       if (match) {
-        const assetPath = path9__default.default.join(options.themePath, "assets", match[1]);
-        if (!assetPath.startsWith(path9__default.default.join(options.themePath, "assets"))) {
+        const assetPath = path11__default.default.join(options.themePath, "assets", match[1]);
+        if (!assetPath.startsWith(path11__default.default.join(options.themePath, "assets"))) {
           res.writeHead(403);
           res.end("Forbidden");
           return;
@@ -1451,26 +1688,26 @@ function createDevServer(options) {
     if (pathname.startsWith("/assets/")) {
       const subpath = pathname.replace(/^\/assets\//, "");
       const segments = subpath.split("/");
-      const assetsBase = path9__default.default.join(options.themePath, "assets");
+      const assetsBase = path11__default.default.join(options.themePath, "assets");
       let assetPath;
       if (segments[0] === options.themeName || segments[0] === options.themeName.replace(/^my-/, "")) {
-        assetPath = path9__default.default.join(assetsBase, segments.slice(1).join("/"));
+        assetPath = path11__default.default.join(assetsBase, segments.slice(1).join("/"));
       } else {
-        assetPath = path9__default.default.join(assetsBase, subpath);
+        assetPath = path11__default.default.join(assetsBase, subpath);
       }
       if (assetPath.startsWith(assetsBase) && fs3__default.default.existsSync(assetPath)) {
         serveFile(res, assetPath);
         return;
       }
       if (segments.length > 1) {
-        const fallbackPath = path9__default.default.join(assetsBase, segments.slice(1).join("/"));
+        const fallbackPath = path11__default.default.join(assetsBase, segments.slice(1).join("/"));
         if (fallbackPath.startsWith(assetsBase) && fs3__default.default.existsSync(fallbackPath)) {
           serveFile(res, fallbackPath);
           return;
         }
       }
     }
-    const filePath = path9__default.default.join(options.distDir, pathname);
+    const filePath = path11__default.default.join(options.distDir, pathname);
     if (!filePath.startsWith(options.distDir)) {
       res.writeHead(403);
       res.end("Forbidden");
@@ -1513,7 +1750,7 @@ function serveFile(res, filePath) {
       res.end("Not Found");
       return;
     }
-    const ext = path9__default.default.extname(filePath);
+    const ext = path11__default.default.extname(filePath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     const content = fs3__default.default.readFileSync(filePath);
     res.writeHead(200, { "Content-Type": contentType });
@@ -1634,18 +1871,18 @@ async function renderTemplate(templatePath, data) {
   return ejs__default.default.render(template, data);
 }
 async function writeFile(filePath, content) {
-  await fs__default.default.ensureDir(path9__default.default.dirname(filePath));
+  await fs__default.default.ensureDir(path11__default.default.dirname(filePath));
   await fs__default.default.writeFile(filePath, content, "utf-8");
 }
 function getTemplatesDir() {
   const locations = [
-    path9__default.default.join(__dirname, "../../templates"),
+    path11__default.default.join(__dirname, "../../templates"),
     // Development
-    path9__default.default.join(__dirname, "../templates"),
+    path11__default.default.join(__dirname, "../templates"),
     // Production (dist/)
-    path9__default.default.join(process.cwd(), "templates"),
+    path11__default.default.join(process.cwd(), "templates"),
     // Fallback
-    path9__default.default.join(process.cwd(), "packages/cli/templates")
+    path11__default.default.join(process.cwd(), "packages/cli/templates")
     // Monorepo
   ];
   for (const location of locations) {
@@ -1657,7 +1894,7 @@ function getTemplatesDir() {
 }
 async function copyTemplate(templateName, targetDir, data) {
   const templatesDir = getTemplatesDir();
-  const templateDir = path9__default.default.join(templatesDir, templateName);
+  const templateDir = path11__default.default.join(templatesDir, templateName);
   if (!fs__default.default.existsSync(templateDir)) {
     throw new Error(
       `Template "${templateName}" not found at ${templateDir}. Available templates: ${fs__default.default.readdirSync(templatesDir).join(", ")}`
@@ -1666,8 +1903,8 @@ async function copyTemplate(templateName, targetDir, data) {
   await fs__default.default.ensureDir(targetDir);
   const files = await fs__default.default.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path9__default.default.join(templateDir, file);
-    const targetPath = path9__default.default.join(targetDir, file);
+    const templatePath = path11__default.default.join(templateDir, file);
+    const targetPath = path11__default.default.join(targetDir, file);
     const stat = await fs__default.default.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -1684,8 +1921,8 @@ async function copyTemplateDir(templateDir, targetDir, data) {
   await fs__default.default.ensureDir(targetDir);
   const files = await fs__default.default.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path9__default.default.join(templateDir, file);
-    const targetPath = path9__default.default.join(targetDir, file);
+    const templatePath = path11__default.default.join(templateDir, file);
+    const targetPath = path11__default.default.join(targetDir, file);
     const stat = await fs__default.default.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -1700,32 +1937,32 @@ async function copyTemplateDir(templateDir, targetDir, data) {
 }
 function getProjectRoot() {
   let currentDir = process.cwd();
-  while (currentDir !== path9__default.default.parse(currentDir).root) {
-    const packageJsonPath = path9__default.default.join(currentDir, "package.json");
+  while (currentDir !== path11__default.default.parse(currentDir).root) {
+    const packageJsonPath = path11__default.default.join(currentDir, "package.json");
     if (fs__default.default.existsSync(packageJsonPath)) {
       const packageJson = fs__default.default.readJsonSync(packageJsonPath);
-      if (packageJson.workspaces || fs__default.default.existsSync(path9__default.default.join(currentDir, "src/themes")) || fs__default.default.existsSync(path9__default.default.join(currentDir, "themes"))) {
+      if (packageJson.workspaces || fs__default.default.existsSync(path11__default.default.join(currentDir, "src/themes")) || fs__default.default.existsSync(path11__default.default.join(currentDir, "themes"))) {
         return currentDir;
       }
     }
-    currentDir = path9__default.default.dirname(currentDir);
+    currentDir = path11__default.default.dirname(currentDir);
   }
   return process.cwd();
 }
 function getThemesDir() {
   const root = getProjectRoot();
-  if (fs__default.default.existsSync(path9__default.default.join(root, "themes")))
-    return path9__default.default.join(root, "themes");
-  if (fs__default.default.existsSync(path9__default.default.join(root, "src/themes")))
-    return path9__default.default.join(root, "src/themes");
-  return path9__default.default.dirname(root);
+  if (fs__default.default.existsSync(path11__default.default.join(root, "themes")))
+    return path11__default.default.join(root, "themes");
+  if (fs__default.default.existsSync(path11__default.default.join(root, "src/themes")))
+    return path11__default.default.join(root, "src/themes");
+  return path11__default.default.dirname(root);
 }
 function getFeaturesDir() {
-  return path9__default.default.join(getProjectRoot(), "src/features");
+  return path11__default.default.join(getProjectRoot(), "src/features");
 }
 function isOneXProject() {
   const root = getProjectRoot();
-  return fs__default.default.existsSync(path9__default.default.join(root, "themes")) || fs__default.default.existsSync(path9__default.default.join(root, "src/themes")) || fs__default.default.existsSync(path9__default.default.join(root, "theme.config.ts")) || fs__default.default.existsSync(path9__default.default.join(root, "bundle-entry.ts"));
+  return fs__default.default.existsSync(path11__default.default.join(root, "themes")) || fs__default.default.existsSync(path11__default.default.join(root, "src/themes")) || fs__default.default.existsSync(path11__default.default.join(root, "theme.config.ts")) || fs__default.default.existsSync(path11__default.default.join(root, "bundle-entry.ts"));
 }
 function ensureOneXProject() {
   if (!isOneXProject()) {
@@ -1741,13 +1978,13 @@ function listThemes() {
     return [];
   }
   return fs__default.default.readdirSync(themesDir).filter((name) => {
-    const themePath = path9__default.default.join(themesDir, name);
-    return fs__default.default.statSync(themePath).isDirectory() && (fs__default.default.existsSync(path9__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path9__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path9__default.default.join(themePath, "manifest.ts")));
+    const themePath = path11__default.default.join(themesDir, name);
+    return fs__default.default.statSync(themePath).isDirectory() && (fs__default.default.existsSync(path11__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path11__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path11__default.default.join(themePath, "manifest.ts")));
   });
 }
 function themeExists(themeName) {
-  const themePath = path9__default.default.join(getThemesDir(), themeName);
-  return fs__default.default.existsSync(themePath) && (fs__default.default.existsSync(path9__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path9__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path9__default.default.join(themePath, "manifest.ts")));
+  const themePath = path11__default.default.join(getThemesDir(), themeName);
+  return fs__default.default.existsSync(themePath) && (fs__default.default.existsSync(path11__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path11__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path11__default.default.join(themePath, "manifest.ts")));
 }
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
@@ -1755,9 +1992,9 @@ function detectPackageManager() {
   if (userAgent.includes("yarn")) return "yarn";
   if (userAgent.includes("bun")) return "bun";
   const cwd = process.cwd();
-  if (fs__default.default.existsSync(path9__default.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs__default.default.existsSync(path9__default.default.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs__default.default.existsSync(path9__default.default.join(cwd, "bun.lockb"))) return "bun";
+  if (fs__default.default.existsSync(path11__default.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs__default.default.existsSync(path11__default.default.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs__default.default.existsSync(path11__default.default.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 async function installDependencies(projectPath, packageManager = "npm") {
@@ -1806,22 +2043,45 @@ function getValidCategories() {
     "contact"
   ];
 }
-var AUTH_DIR = path9__default.default.join(os__default.default.homedir(), ".onexthm");
-var AUTH_FILE = path9__default.default.join(AUTH_DIR, "auth.json");
-function getApiUrl() {
-  return process.env.ONEXTHM_API_URL || "https://platform-dev.onexeos.com";
+var AUTH_DIR = path11__default.default.join(os__default.default.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__default.default.join(AUTH_DIR, `auth-${env}.json`);
+  if (env === "dev") {
+    const legacyFile = path11__default.default.join(AUTH_DIR, "auth.json");
+    if (fs__default.default.existsSync(legacyFile) && !fs__default.default.existsSync(newFile)) {
+      try {
+        fs__default.default.moveSync(legacyFile, newFile);
+      } catch {
+        try {
+          fs__default.default.copySync(legacyFile, newFile);
+          fs__default.default.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__default.default.ensureDir(AUTH_DIR);
   const key = getMachineKey();
   const data = JSON.stringify(tokens);
   const encrypted = encrypt(data, key);
-  await fs__default.default.writeFile(AUTH_FILE, encrypted, "utf-8");
+  await fs__default.default.writeFile(getAuthFile(env), encrypted, "utf-8");
 }
-function loadAuthTokens() {
+function loadAuthTokens(env = "dev") {
   try {
-    if (!fs__default.default.existsSync(AUTH_FILE)) return null;
-    const encrypted = fs__default.default.readFileSync(AUTH_FILE, "utf-8");
+    const file = getAuthFile(env);
+    if (!fs__default.default.existsSync(file)) return null;
+    const encrypted = fs__default.default.readFileSync(file, "utf-8");
     const key = getMachineKey();
     const data = decrypt(encrypted, key);
     return JSON.parse(data);
@@ -1829,34 +2089,34 @@ function loadAuthTokens() {
     return null;
   }
 }
-async function clearAuthTokens() {
+async function clearAuthTokens(env = "dev") {
   try {
-    await fs__default.default.remove(AUTH_FILE);
+    await fs__default.default.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 = {
@@ -1865,17 +2125,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}`);
@@ -1941,7 +2203,7 @@ async function initCommand(projectName, options = {}) {
           if (!validateThemeName(kebabName)) {
             return "Invalid project name. Use lowercase letters, numbers, and hyphens only.";
           }
-          if (fs3__default.default.existsSync(path9__default.default.join(process.cwd(), kebabName))) {
+          if (fs3__default.default.existsSync(path11__default.default.join(process.cwd(), kebabName))) {
             return `Directory "${kebabName}" already exists`;
           }
           return true;
@@ -1952,14 +2214,14 @@ async function initCommand(projectName, options = {}) {
   } else {
     name = toKebabCase(projectName);
   }
-  const projectPath = path9__default.default.join(process.cwd(), name);
+  const projectPath = path11__default.default.join(process.cwd(), name);
   if (fs3__default.default.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(
@@ -2068,7 +2330,7 @@ async function initCommand(projectName, options = {}) {
       description,
       author
     );
-    const mcpJsonPath = path9__default.default.join(projectPath, ".mcp.json");
+    const mcpJsonPath = path11__default.default.join(projectPath, ".mcp.json");
     if (fs3__default.default.existsSync(mcpJsonPath)) {
       let mcpContent = fs3__default.default.readFileSync(mcpJsonPath, "utf-8");
       if (figmaApiKey) {
@@ -2148,7 +2410,7 @@ async function initCommand(projectName, options = {}) {
   }
 }
 async function renameThemeInFiles(projectPath, themeName, displayName, description, author) {
-  const configPath = path9__default.default.join(projectPath, "theme.config.ts");
+  const configPath = path11__default.default.join(projectPath, "theme.config.ts");
   if (fs3__default.default.existsSync(configPath)) {
     let content = fs3__default.default.readFileSync(configPath, "utf-8");
     content = content.replace(
@@ -2161,7 +2423,7 @@ async function renameThemeInFiles(projectPath, themeName, displayName, descripti
     );
     fs3__default.default.writeFileSync(configPath, content, "utf-8");
   }
-  const pkgPath = path9__default.default.join(projectPath, "package.json");
+  const pkgPath = path11__default.default.join(projectPath, "package.json");
   if (fs3__default.default.existsSync(pkgPath)) {
     let content = fs3__default.default.readFileSync(pkgPath, "utf-8");
     content = content.replace(
@@ -2183,10 +2445,10 @@ async function createSectionCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs__default.default.existsSync(path9__default.default.join(process.cwd(), f))
+      (f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path9__default.default.basename(process.cwd());
+      options.theme = path11__default.default.basename(process.cwd());
     }
   }
   const sectionName = toKebabCase(name);
@@ -2249,35 +2511,35 @@ async function createSectionCommand(name, options) {
   };
   logger.startSpinner("Creating section files...");
   try {
-    const themePath = path9__default.default.join(getThemesDir(), themeName);
-    const sectionPath = path9__default.default.join(themePath, "sections", sectionName);
+    const themePath = path11__default.default.join(getThemesDir(), themeName);
+    const sectionPath = path11__default.default.join(themePath, "sections", sectionName);
     const schemaContent = generateSectionSchema(data);
     await writeFile(
-      path9__default.default.join(sectionPath, `${sectionName}.schema.ts`),
+      path11__default.default.join(sectionPath, `${sectionName}.schema.ts`),
       schemaContent
     );
     if (createTemplate) {
       const templateContent = generateSectionTemplate(data);
       await writeFile(
-        path9__default.default.join(sectionPath, `${sectionName}-default.tsx`),
+        path11__default.default.join(sectionPath, `${sectionName}-default.tsx`),
         templateContent
       );
     }
     const indexContent = generateSectionIndex(data, createTemplate);
-    await writeFile(path9__default.default.join(sectionPath, "index.ts"), indexContent);
+    await writeFile(path11__default.default.join(sectionPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Section files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path9__default.default.relative(process.cwd(), path9__default.default.join(sectionPath, `${sectionName}.schema.ts`))}`
+      `  1. Edit schema: ${path11__default.default.relative(process.cwd(), path11__default.default.join(sectionPath, `${sectionName}.schema.ts`))}`
     );
     if (createTemplate) {
       logger.log(
-        `  2. Edit template: ${path9__default.default.relative(process.cwd(), path9__default.default.join(sectionPath, `${sectionName}-default.tsx`))}`
+        `  2. Edit template: ${path11__default.default.relative(process.cwd(), path11__default.default.join(sectionPath, `${sectionName}-default.tsx`))}`
       );
     }
     logger.log(
-      `  3. Add to theme manifest: ${path9__default.default.relative(process.cwd(), path9__default.default.join(themePath, "manifest.ts"))}`
+      `  3. Add to theme manifest: ${path11__default.default.relative(process.cwd(), path11__default.default.join(themePath, "manifest.ts"))}`
     );
     logger.newLine();
     logger.success("Section created successfully!");
@@ -2425,10 +2687,10 @@ async function createBlockCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs__default.default.existsSync(path9__default.default.join(process.cwd(), f))
+      (f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path9__default.default.basename(process.cwd());
+      options.theme = path11__default.default.basename(process.cwd());
     }
   }
   const blockName = toKebabCase(name);
@@ -2503,24 +2765,24 @@ async function createBlockCommand(name, options) {
   };
   logger.startSpinner("Creating block files...");
   try {
-    const blockPath = scope === "shared" ? path9__default.default.join(getFeaturesDir(), "blocks", blockName) : path9__default.default.join(getThemesDir(), themeName, "blocks", blockName);
+    const blockPath = scope === "shared" ? path11__default.default.join(getFeaturesDir(), "blocks", blockName) : path11__default.default.join(getThemesDir(), themeName, "blocks", blockName);
     const schemaContent = generateBlockSchema(data);
     await writeFile(
-      path9__default.default.join(blockPath, `${blockName}.schema.ts`),
+      path11__default.default.join(blockPath, `${blockName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateBlockComponent(data);
-    await writeFile(path9__default.default.join(blockPath, `${blockName}.tsx`), componentContent);
+    await writeFile(path11__default.default.join(blockPath, `${blockName}.tsx`), componentContent);
     const indexContent = generateBlockIndex(data);
-    await writeFile(path9__default.default.join(blockPath, "index.ts"), indexContent);
+    await writeFile(path11__default.default.join(blockPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Block files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path9__default.default.relative(process.cwd(), path9__default.default.join(blockPath, `${blockName}.schema.ts`))}`
+      `  1. Edit schema: ${path11__default.default.relative(process.cwd(), path11__default.default.join(blockPath, `${blockName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path9__default.default.relative(process.cwd(), path9__default.default.join(blockPath, `${blockName}.tsx`))}`
+      `  2. Edit component: ${path11__default.default.relative(process.cwd(), path11__default.default.join(blockPath, `${blockName}.tsx`))}`
     );
     logger.log(
       `  3. Register in block registry: src/lib/registry/block-registry.ts`
@@ -2698,31 +2960,31 @@ async function createComponentCommand(name, options) {
   };
   logger.startSpinner("Creating component files...");
   try {
-    const componentPath = path9__default.default.join(
+    const componentPath = path11__default.default.join(
       getFeaturesDir(),
       "components",
       componentName
     );
     const schemaContent = generateComponentSchema(data);
     await writeFile(
-      path9__default.default.join(componentPath, `${componentName}.schema.ts`),
+      path11__default.default.join(componentPath, `${componentName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateComponent(data);
     await writeFile(
-      path9__default.default.join(componentPath, `${componentName}.tsx`),
+      path11__default.default.join(componentPath, `${componentName}.tsx`),
       componentContent
     );
     const indexContent = generateComponentIndex(data);
-    await writeFile(path9__default.default.join(componentPath, "index.ts"), indexContent);
+    await writeFile(path11__default.default.join(componentPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Component files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path9__default.default.relative(process.cwd(), path9__default.default.join(componentPath, `${componentName}.schema.ts`))}`
+      `  1. Edit schema: ${path11__default.default.relative(process.cwd(), path11__default.default.join(componentPath, `${componentName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path9__default.default.relative(process.cwd(), path9__default.default.join(componentPath, `${componentName}.tsx`))}`
+      `  2. Edit component: ${path11__default.default.relative(process.cwd(), path11__default.default.join(componentPath, `${componentName}.tsx`))}`
     );
     logger.log(
       `  3. Register in component registry: src/lib/registry/component-registry.ts`
@@ -2879,13 +3141,13 @@ async function listSections(themeFilter) {
     return;
   }
   for (const theme of themes) {
-    const sectionsDir = path9__default.default.join(getThemesDir(), theme, "sections");
+    const sectionsDir = path11__default.default.join(getThemesDir(), theme, "sections");
     if (!fs__default.default.existsSync(sectionsDir)) {
       continue;
     }
     const sections = fs__default.default.readdirSync(sectionsDir).filter((name) => {
-      const sectionPath = path9__default.default.join(sectionsDir, name);
-      return fs__default.default.statSync(sectionPath).isDirectory() && fs__default.default.existsSync(path9__default.default.join(sectionPath, "index.ts"));
+      const sectionPath = path11__default.default.join(sectionsDir, name);
+      return fs__default.default.statSync(sectionPath).isDirectory() && fs__default.default.existsSync(path11__default.default.join(sectionPath, "index.ts"));
     });
     if (sections.length > 0) {
       logger.log(chalk4__default.default.cyan(`
@@ -2899,11 +3161,11 @@ async function listSections(themeFilter) {
 }
 async function listBlocks(themeFilter) {
   logger.section("\u{1F9F1} Blocks");
-  const sharedBlocksDir = path9__default.default.join(getFeaturesDir(), "blocks");
+  const sharedBlocksDir = path11__default.default.join(getFeaturesDir(), "blocks");
   if (fs__default.default.existsSync(sharedBlocksDir)) {
     const sharedBlocks = fs__default.default.readdirSync(sharedBlocksDir).filter((name) => {
-      const blockPath = path9__default.default.join(sharedBlocksDir, name);
-      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path9__default.default.join(blockPath, "index.ts"));
+      const blockPath = path11__default.default.join(sharedBlocksDir, name);
+      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path11__default.default.join(blockPath, "index.ts"));
     });
     if (sharedBlocks.length > 0) {
       logger.log(chalk4__default.default.cyan("\n  Shared:"));
@@ -2914,13 +3176,13 @@ async function listBlocks(themeFilter) {
   }
   const themes = themeFilter ? [themeFilter] : listThemes();
   for (const theme of themes) {
-    const blocksDir = path9__default.default.join(getThemesDir(), theme, "blocks");
+    const blocksDir = path11__default.default.join(getThemesDir(), theme, "blocks");
     if (!fs__default.default.existsSync(blocksDir)) {
       continue;
     }
     const blocks = fs__default.default.readdirSync(blocksDir).filter((name) => {
-      const blockPath = path9__default.default.join(blocksDir, name);
-      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path9__default.default.join(blockPath, "index.ts"));
+      const blockPath = path11__default.default.join(blocksDir, name);
+      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path11__default.default.join(blockPath, "index.ts"));
     });
     if (blocks.length > 0) {
       logger.log(chalk4__default.default.cyan(`
@@ -2934,14 +3196,14 @@ async function listBlocks(themeFilter) {
 }
 async function listComponents() {
   logger.section("\u2699\uFE0F  Components");
-  const componentsDir = path9__default.default.join(getFeaturesDir(), "components");
+  const componentsDir = path11__default.default.join(getFeaturesDir(), "components");
   if (!fs__default.default.existsSync(componentsDir)) {
     logger.warning("No components directory found");
     return;
   }
   const components = fs__default.default.readdirSync(componentsDir).filter((name) => {
-    const componentPath = path9__default.default.join(componentsDir, name);
-    return fs__default.default.statSync(componentPath).isDirectory() && fs__default.default.existsSync(path9__default.default.join(componentPath, "index.ts"));
+    const componentPath = path11__default.default.join(componentsDir, name);
+    return fs__default.default.statSync(componentPath).isDirectory() && fs__default.default.existsSync(path11__default.default.join(componentPath, "index.ts"));
   });
   if (components.length === 0) {
     logger.warning("No components found");
@@ -2962,11 +3224,11 @@ async function listThemesInfo() {
   }
   logger.log("");
   for (const theme of themes) {
-    const themeDir = path9__default.default.join(getThemesDir(), theme);
+    const themeDir = path11__default.default.join(getThemesDir(), theme);
     const candidates = ["theme.config.ts", "bundle-entry.ts", "manifest.ts"];
     let manifestContent = "";
     for (const candidate of candidates) {
-      const candidatePath = path9__default.default.join(themeDir, candidate);
+      const candidatePath = path11__default.default.join(themeDir, candidate);
       if (fs__default.default.existsSync(candidatePath)) {
         manifestContent = fs__default.default.readFileSync(candidatePath, "utf-8");
         break;
@@ -3004,9 +3266,9 @@ async function validateCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path9__default.default.join(process.cwd(), f)));
+    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
-      themeToValidate = path9__default.default.basename(process.cwd());
+      themeToValidate = path11__default.default.basename(process.cwd());
       logger.info(`Validating current theme: ${themeToValidate}`);
     } else {
       logger.error(
@@ -3015,11 +3277,11 @@ async function validateCommand(options) {
       process.exit(1);
     }
   }
-  const themePath = path9__default.default.join(getThemesDir(), themeToValidate);
+  const themePath = path11__default.default.join(getThemesDir(), themeToValidate);
   logger.startSpinner("Running validation checks...");
   const entryFiles = ["manifest.ts", "theme.config.ts", "bundle-entry.ts"];
   const foundEntry = entryFiles.find(
-    (f) => fs__default.default.existsSync(path9__default.default.join(themePath, f))
+    (f) => fs__default.default.existsSync(path11__default.default.join(themePath, f))
   );
   if (!foundEntry) {
     issues.push({
@@ -3029,7 +3291,7 @@ async function validateCommand(options) {
     });
   } else if (foundEntry === "manifest.ts") {
     const manifestContent = fs__default.default.readFileSync(
-      path9__default.default.join(themePath, foundEntry),
+      path11__default.default.join(themePath, foundEntry),
       "utf-8"
     );
     if (!manifestContent.includes("export const") && !manifestContent.includes("export default") && !manifestContent.includes("export interface")) {
@@ -3040,7 +3302,7 @@ async function validateCommand(options) {
       });
     }
   }
-  const configPath = path9__default.default.join(themePath, "theme.config.ts");
+  const configPath = path11__default.default.join(themePath, "theme.config.ts");
   if (!fs__default.default.existsSync(configPath)) {
     issues.push({
       type: "warning",
@@ -3048,7 +3310,7 @@ async function validateCommand(options) {
       message: "Theme config file not found (recommended)"
     });
   }
-  const indexPath = path9__default.default.join(themePath, "index.ts");
+  const indexPath = path11__default.default.join(themePath, "index.ts");
   if (!fs__default.default.existsSync(indexPath)) {
     issues.push({
       type: "warning",
@@ -3056,7 +3318,7 @@ async function validateCommand(options) {
       message: "Index file not found (recommended)"
     });
   }
-  const sectionsDir = path9__default.default.join(themePath, "sections");
+  const sectionsDir = path11__default.default.join(themePath, "sections");
   if (!fs__default.default.existsSync(sectionsDir)) {
     issues.push({
       type: "warning",
@@ -3065,16 +3327,16 @@ async function validateCommand(options) {
     });
   } else {
     const sections = fs__default.default.readdirSync(sectionsDir).filter(
-      (name) => fs__default.default.statSync(path9__default.default.join(sectionsDir, name)).isDirectory()
+      (name) => fs__default.default.statSync(path11__default.default.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
-      const sectionPath = path9__default.default.join(sectionsDir, sectionName);
-      const schemaFile = path9__default.default.join(sectionPath, `${sectionName}.schema.ts`);
-      const defaultTemplate = path9__default.default.join(
+      const sectionPath = path11__default.default.join(sectionsDir, sectionName);
+      const schemaFile = path11__default.default.join(sectionPath, `${sectionName}.schema.ts`);
+      const defaultTemplate = path11__default.default.join(
         sectionPath,
         `${sectionName}-default.tsx`
       );
-      const indexFile = path9__default.default.join(sectionPath, "index.ts");
+      const indexFile = path11__default.default.join(sectionPath, "index.ts");
       if (!fs__default.default.existsSync(schemaFile)) {
         issues.push({
           type: "error",
@@ -3098,14 +3360,14 @@ async function validateCommand(options) {
       }
     }
   }
-  const blocksDir = path9__default.default.join(themePath, "blocks");
+  const blocksDir = path11__default.default.join(themePath, "blocks");
   if (fs__default.default.existsSync(blocksDir)) {
-    const blocks = fs__default.default.readdirSync(blocksDir).filter((name) => fs__default.default.statSync(path9__default.default.join(blocksDir, name)).isDirectory());
+    const blocks = fs__default.default.readdirSync(blocksDir).filter((name) => fs__default.default.statSync(path11__default.default.join(blocksDir, name)).isDirectory());
     for (const blockName of blocks) {
-      const blockPath = path9__default.default.join(blocksDir, blockName);
-      const schemaFile = path9__default.default.join(blockPath, `${blockName}.schema.ts`);
-      const componentFile = path9__default.default.join(blockPath, `${blockName}.tsx`);
-      const indexFile = path9__default.default.join(blockPath, "index.ts");
+      const blockPath = path11__default.default.join(blocksDir, blockName);
+      const schemaFile = path11__default.default.join(blockPath, `${blockName}.schema.ts`);
+      const componentFile = path11__default.default.join(blockPath, `${blockName}.tsx`);
+      const indexFile = path11__default.default.join(blockPath, "index.ts");
       if (!fs__default.default.existsSync(schemaFile)) {
         issues.push({
           type: "error",
@@ -3131,13 +3393,13 @@ async function validateCommand(options) {
   }
   if (fs__default.default.existsSync(sectionsDir)) {
     const sections = fs__default.default.readdirSync(sectionsDir).filter(
-      (name) => fs__default.default.statSync(path9__default.default.join(sectionsDir, name)).isDirectory()
+      (name) => fs__default.default.statSync(path11__default.default.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
-      const sectionPath = path9__default.default.join(sectionsDir, sectionName);
+      const sectionPath = path11__default.default.join(sectionsDir, sectionName);
       const tsxFiles = fs__default.default.readdirSync(sectionPath).filter((f) => f.endsWith(".tsx") && !f.endsWith(".schema.ts"));
       for (const tsxFile of tsxFiles) {
-        const filePath = path9__default.default.join(sectionPath, tsxFile);
+        const filePath = path11__default.default.join(sectionPath, tsxFile);
         const content = fs__default.default.readFileSync(filePath, "utf-8");
         const relPath = `sections/${sectionName}/${tsxFile}`;
         if (!content.includes('"use client"') && !content.includes("'use client'")) {
@@ -3185,12 +3447,12 @@ async function validateCommand(options) {
       }
     }
   }
-  const registryPath = path9__default.default.join(themePath, "sections-registry.ts");
-  const bundleEntryPath = path9__default.default.join(themePath, "bundle-entry.ts");
+  const registryPath = path11__default.default.join(themePath, "sections-registry.ts");
+  const bundleEntryPath = path11__default.default.join(themePath, "bundle-entry.ts");
   const registryContent = fs__default.default.existsSync(registryPath) ? fs__default.default.readFileSync(registryPath, "utf-8") : fs__default.default.existsSync(bundleEntryPath) ? fs__default.default.readFileSync(bundleEntryPath, "utf-8") : "";
   if (fs__default.default.existsSync(sectionsDir) && registryContent) {
     const sections = fs__default.default.readdirSync(sectionsDir).filter(
-      (name) => fs__default.default.statSync(path9__default.default.join(sectionsDir, name)).isDirectory()
+      (name) => fs__default.default.statSync(path11__default.default.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
       if (!registryContent.includes(`sections/${sectionName}`) && !registryContent.includes(`"${sectionName}"`)) {
@@ -3213,7 +3475,7 @@ async function validateCommand(options) {
         });
       }
     }
-    const pagesDir = path9__default.default.join(themePath, "pages");
+    const pagesDir = path11__default.default.join(themePath, "pages");
     if (fs__default.default.existsSync(pagesDir)) {
       const allSchemaTypeSet = new Set(
         schemaTypes.map((s) => s.schemaType || s.folderName)
@@ -3265,9 +3527,9 @@ async function validateCommand(options) {
 }
 async function loadSchemaTypes(themePath, sectionsDir) {
   const results = [];
-  const sections = fs__default.default.readdirSync(sectionsDir).filter((name) => fs__default.default.statSync(path9__default.default.join(sectionsDir, name)).isDirectory());
+  const sections = fs__default.default.readdirSync(sectionsDir).filter((name) => fs__default.default.statSync(path11__default.default.join(sectionsDir, name)).isDirectory());
   for (const sectionName of sections) {
-    const schemaFile = path9__default.default.join(
+    const schemaFile = path11__default.default.join(
       sectionsDir,
       sectionName,
       `${sectionName}.schema.ts`
@@ -3305,7 +3567,7 @@ async function validatePageSectionTypes(pagesDir, validTypes) {
   const issues = [];
   const files = fs__default.default.readdirSync(pagesDir).filter((f) => f.match(/\.(ts|js)$/));
   for (const file of files) {
-    const content = fs__default.default.readFileSync(path9__default.default.join(pagesDir, file), "utf-8");
+    const content = fs__default.default.readFileSync(path11__default.default.join(pagesDir, file), "utf-8");
     const pageName = file.replace(/\.(ts|js)$/, "");
     const sectionsMatch = content.match(/\bsections:\s*\[/);
     if (!sectionsMatch || sectionsMatch.index === void 0) continue;
@@ -3318,9 +3580,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",
@@ -3373,6 +3639,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();
@@ -3383,14 +3707,14 @@ async function buildCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path9__default.default.join(getThemesDir(), themeName);
+      const workspaceThemePath = path11__default.default.join(getThemesDir(), themeName);
       if (fs__default.default.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path9__default.default.join(process.cwd(), themeName);
+        themePath = path11__default.default.join(process.cwd(), themeName);
       }
     } catch {
-      themePath = path9__default.default.join(process.cwd(), themeName);
+      themePath = path11__default.default.join(process.cwd(), themeName);
     }
     if (!fs__default.default.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
@@ -3401,10 +3725,10 @@ async function buildCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path9__default.default.join(process.cwd(), f)));
+    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
-      themeName = path9__default.default.basename(themePath);
+      themeName = path11__default.default.basename(themePath);
       logger.info(`Building current theme: ${themeName}`);
     } else {
       logger.error(
@@ -3413,7 +3737,7 @@ async function buildCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path9__default.default.join(themePath, "package.json");
+  const packageJsonPath = path11__default.default.join(themePath, "package.json");
   const hasPkgJson = fs__default.default.existsSync(packageJsonPath);
   if (!hasPkgJson) {
     logger.warning(
@@ -3469,9 +3793,9 @@ async function buildCommand(options) {
     logger.success("\u2713 Theme built successfully!");
     logger.newLine();
     logger.info(`Theme: ${themeName}`);
-    const distPath = path9__default.default.join(themePath, "dist");
+    const distPath = path11__default.default.join(themePath, "dist");
     if (fs__default.default.existsSync(distPath)) {
-      logger.log(`Output: ${path9__default.default.relative(process.cwd(), distPath)}`);
+      logger.log(`Output: ${path11__default.default.relative(process.cwd(), distPath)}`);
       const files = fs__default.default.readdirSync(distPath);
       logger.log(`Files: ${files.length}`);
     }
@@ -3527,7 +3851,7 @@ async function packageCommand(options) {
   let themeName;
   if (options.theme) {
     themeName = options.theme;
-    themePath = path9__default.default.join(getThemesDir(), themeName);
+    themePath = path11__default.default.join(getThemesDir(), themeName);
     if (!fs__default.default.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
       process.exit(1);
@@ -3537,10 +3861,10 @@ async function packageCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path9__default.default.join(process.cwd(), f)));
+    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
-      themeName = path9__default.default.basename(themePath);
+      themeName = path11__default.default.basename(themePath);
       logger.info(`Packaging current theme: ${themeName}`);
     } else {
       logger.error(
@@ -3549,7 +3873,7 @@ async function packageCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path9__default.default.join(themePath, "package.json");
+  const packageJsonPath = path11__default.default.join(themePath, "package.json");
   let version2 = "1.0.0";
   if (fs__default.default.existsSync(packageJsonPath)) {
     const packageJson = await fs__default.default.readJson(packageJsonPath);
@@ -3559,7 +3883,7 @@ async function packageCommand(options) {
   logger.info(`Theme: ${themeName}`);
   logger.info(`Version: ${version2}`);
   logger.newLine();
-  const compiledThemePath = path9__default.default.join(
+  const compiledThemePath = path11__default.default.join(
     process.cwd(),
     "themes",
     themeName,
@@ -3593,8 +3917,8 @@ async function packageCommand(options) {
   logger.newLine();
   logger.section("Step 2: Create Package");
   const packageName = options.name || `${themeName}-${version2}`;
-  const outputDir = options.output || path9__default.default.join(process.cwd(), "dist");
-  const outputPath = path9__default.default.join(outputDir, `${packageName}.zip`);
+  const outputDir = options.output || path11__default.default.join(process.cwd(), "dist");
+  const outputPath = path11__default.default.join(outputDir, `${packageName}.zip`);
   await fs__default.default.ensureDir(outputDir);
   logger.startSpinner("Creating zip archive...");
   try {
@@ -3607,11 +3931,11 @@ async function packageCommand(options) {
     logger.newLine();
     logger.info(`Package: ${packageName}.zip`);
     logger.log(`Size: ${sizeMB} MB`);
-    logger.log(`Location: ${path9__default.default.relative(process.cwd(), outputPath)}`);
+    logger.log(`Location: ${path11__default.default.relative(process.cwd(), outputPath)}`);
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  onexthm deploy --package ${path9__default.default.relative(process.cwd(), outputPath)}`
+      `  onexthm deploy --package ${path11__default.default.relative(process.cwd(), outputPath)}`
     );
   } catch (error) {
     logger.stopSpinner(false, "Failed to create package");
@@ -3669,9 +3993,9 @@ async function deployCommand(options) {
   ensureOneXProject();
   let packagePath;
   if (options.package) {
-    packagePath = path9__default.default.resolve(options.package);
+    packagePath = path11__default.default.resolve(options.package);
   } else if (options.theme) {
-    const distDir = path9__default.default.join(process.cwd(), "dist");
+    const distDir = path11__default.default.join(process.cwd(), "dist");
     if (!fs__default.default.existsSync(distDir)) {
       logger.error("No dist/ directory found. Run 'onexthm package' first.");
       process.exit(1);
@@ -3686,7 +4010,7 @@ async function deployCommand(options) {
       process.exit(1);
     }
     packageFiles.sort().reverse();
-    packagePath = path9__default.default.join(distDir, packageFiles[0]);
+    packagePath = path11__default.default.join(distDir, packageFiles[0]);
   } else {
     logger.error("Either --package or --theme must be specified.");
     logger.info("Examples:");
@@ -3700,11 +4024,11 @@ async function deployCommand(options) {
   }
   const stats = await fs__default.default.stat(packagePath);
   const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-  const fileName = path9__default.default.basename(packagePath);
+  const fileName = path11__default.default.basename(packagePath);
   logger.newLine();
   logger.info(`Package: ${fileName}`);
   logger.log(`Size: ${sizeMB} MB`);
-  logger.log(`Path: ${path9__default.default.relative(process.cwd(), packagePath)}`);
+  logger.log(`Path: ${path11__default.default.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`;
@@ -3861,8 +4185,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__default.default.join(outputDir, entryFile);
-    const stablePath = path9__default.default.join(outputDir, "bundle-entry.js");
+    const hashedPath = path11__default.default.join(outputDir, entryFile);
+    const stablePath = path11__default.default.join(outputDir, "bundle-entry.js");
     if (await fs__default.default.pathExists(hashedPath)) {
       await fs__default.default.copy(hashedPath, stablePath);
       const mapPath = hashedPath + ".map";
@@ -3871,13 +4195,13 @@ async function createCompatibilityFiles(outputDir, manifest) {
       }
     }
   }
-  const sectionsRegistryPath = path9__default.default.join(outputDir, "sections-registry.js");
+  const sectionsRegistryPath = path11__default.default.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__default.default.writeFile(sectionsRegistryPath, content, "utf-8");
-  const pkgJsonPath = path9__default.default.join(outputDir, "package.json");
+  const pkgJsonPath = path11__default.default.join(outputDir, "package.json");
   await fs__default.default.writeFile(pkgJsonPath, '{\n  "type": "module"\n}\n', "utf-8");
 }
 function showDownloadFailureHelp(themeId, apiUrl) {
@@ -3908,9 +4232,7 @@ function showDownloadFailureHelp(themeId, apiUrl) {
   console.log();
   console.log(chalk4__default.default.white("2. Check API URL configuration:"));
   console.log(chalk4__default.default.gray(`   Current API URL: ${apiUrl}`));
-  console.log(
-    chalk4__default.default.gray("   Override with NEXT_PUBLIC_API_URL or ONEXTHM_API_URL")
-  );
+  console.log(chalk4__default.default.gray("   Override with ONEXTHM_API_URL env var if needed"));
   console.log();
   console.log(chalk4__default.default.white("3. Pin a specific version (CI/production):"));
   console.log(
@@ -3920,15 +4242,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__default.default("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";
@@ -3976,7 +4300,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__default.default.join(outputDir, "manifest.json");
+    const manifestPath = path11__default.default.join(outputDir, "manifest.json");
     const manifest = await fs__default.default.readJson(manifestPath);
     await createCompatibilityFiles(outputDir, manifest);
     console.log();
@@ -3985,6 +4309,7 @@ async function downloadCommand(options) {
     console.log(
       chalk4__default.default.cyan("   Theme:   ") + chalk4__default.default.white(`${themeId}@${resolvedVersion}`)
     );
+    console.log(chalk4__default.default.cyan("   Env:     ") + chalk4__default.default.white(env));
     console.log(chalk4__default.default.cyan("   Source:  ") + chalk4__default.default.white(apiUrl));
     console.log(chalk4__default.default.cyan("   Output:  ") + chalk4__default.default.white(outputDir));
     console.log(chalk4__default.default.cyan("   Files:   ") + chalk4__default.default.white(entries.length));
@@ -4027,11 +4352,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(
@@ -4040,7 +4363,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(
@@ -4098,7 +4421,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__default.default.join(themeDir, "package.json");
+  const pkgPath = path11__default.default.join(themeDir, "package.json");
   if (await fs__default.default.pathExists(pkgPath)) {
     const pkg = await fs__default.default.readJson(pkgPath);
     pkg.name = `@onex-themes/${newName}`;
@@ -4114,7 +4437,7 @@ async function renameTheme(themeDir, oldName, newName) {
     }
     await fs__default.default.writeJson(pkgPath, pkg, { spaces: 2 });
   }
-  const configPath = path9__default.default.join(themeDir, "theme.config.ts");
+  const configPath = path11__default.default.join(themeDir, "theme.config.ts");
   if (await fs__default.default.pathExists(configPath)) {
     let content = await fs__default.default.readFile(configPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
@@ -4124,7 +4447,7 @@ async function renameTheme(themeDir, oldName, newName) {
     );
     await fs__default.default.writeFile(configPath, content);
   }
-  const layoutPath = path9__default.default.join(themeDir, "theme.layout.ts");
+  const layoutPath = path11__default.default.join(themeDir, "theme.layout.ts");
   if (await fs__default.default.pathExists(layoutPath)) {
     let content = await fs__default.default.readFile(layoutPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
@@ -4137,7 +4460,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.glob("**/*.ts", { cwd: themeDir, nodir: true });
   for (const file of tsFiles) {
-    const filePath = path9__default.default.join(themeDir, file);
+    const filePath = path11__default.default.join(themeDir, file);
     let content = await fs__default.default.readFile(filePath, "utf-8");
     const original = content;
     content = content.replace(
@@ -4159,14 +4482,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;
@@ -4175,8 +4503,7 @@ async function cloneCommand(themeName, options) {
   }
   const spinner = ora__default.default("Initializing clone...").start();
   try {
-    const apiUrl = getApiUrl();
-    const outputDir = options.output || path9__default.default.resolve(process.cwd(), newName);
+    const outputDir = options.output || path11__default.default.resolve(process.cwd(), newName);
     if (await fs__default.default.pathExists(outputDir)) {
       spinner.fail(chalk4__default.default.red(`Directory already exists: ${outputDir}`));
       logger.info(
@@ -4195,7 +4522,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__default.default.red(error.message));
       console.log();
@@ -4222,20 +4549,20 @@ async function cloneCommand(themeName, options) {
     spinner.succeed(
       `Renamed theme: ${chalk4__default.default.gray(themeName)} \u2192 ${chalk4__default.default.cyan(newName)}`
     );
-    const envExamplePath = path9__default.default.join(outputDir, ".env.example");
+    const envExamplePath = path11__default.default.join(outputDir, ".env.example");
     if (!await fs__default.default.pathExists(envExamplePath)) {
       await fs__default.default.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__default.default.join(outputDir, ".mcp.json");
+    const mcpJsonPath = path11__default.default.join(outputDir, ".mcp.json");
     if (await fs__default.default.pathExists(mcpJsonPath)) {
       const { default: inquirerMod } = await import('inquirer');
       const { figmaApiKey } = await inquirerMod.prompt([
@@ -4260,7 +4587,7 @@ async function cloneCommand(themeName, options) {
     }
     if (options.install !== false) {
       const hasPkgJson = await fs__default.default.pathExists(
-        path9__default.default.join(outputDir, "package.json")
+        path11__default.default.join(outputDir, "package.json")
       );
       if (hasPkgJson) {
         spinner.start("Installing dependencies...");
@@ -4282,12 +4609,13 @@ async function cloneCommand(themeName, options) {
     console.log(
       chalk4__default.default.cyan("   Source:   ") + chalk4__default.default.gray(`${themeName}@${version2}`)
     );
+    console.log(chalk4__default.default.cyan("   Env:      ") + chalk4__default.default.white(env));
     console.log(chalk4__default.default.cyan("   Theme:    ") + chalk4__default.default.white(newName));
     console.log(chalk4__default.default.cyan("   Location: ") + chalk4__default.default.white(outputDir));
     console.log(chalk4__default.default.cyan("   Files:    ") + chalk4__default.default.white(entries.length));
     console.log();
     console.log(chalk4__default.default.cyan("Next steps:"));
-    console.log(chalk4__default.default.gray(`   cd ${path9__default.default.relative(process.cwd(), outputDir)}`));
+    console.log(chalk4__default.default.gray(`   cd ${path11__default.default.relative(process.cwd(), outputDir)}`));
     console.log(
       chalk4__default.default.gray("   cp .env.example .env  # then add your Company ID")
     );
@@ -4314,14 +4642,14 @@ async function devCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path9__default.default.join(getThemesDir(), themeName);
+      const workspaceThemePath = path11__default.default.join(getThemesDir(), themeName);
       if (fs__default.default.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path9__default.default.join(process.cwd(), themeName);
+        themePath = path11__default.default.join(process.cwd(), themeName);
       }
     } catch {
-      themePath = path9__default.default.join(process.cwd(), themeName);
+      themePath = path11__default.default.join(process.cwd(), themeName);
     }
     if (!fs__default.default.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
@@ -4332,10 +4660,10 @@ async function devCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path9__default.default.join(process.cwd(), f)));
+    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
-      themeName = path9__default.default.basename(themePath);
+      themeName = path11__default.default.basename(themePath);
     } else {
       logger.error(
         "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
@@ -4404,9 +4732,9 @@ async function devCommand(options) {
     watcher.close();
     await context2.dispose();
     server.close();
-    const shimPath = path9__default.default.join(outputDir, ".process-shim.js");
+    const shimPath = path11__default.default.join(outputDir, ".process-shim.js");
     try {
-      await fs8__default.default.unlink(shimPath);
+      await fs9__default.default.unlink(shimPath);
     } catch {
     }
     process.exit(0);
@@ -4415,8 +4743,8 @@ async function devCommand(options) {
 
 // src/commands/config.ts
 init_logger();
-var CONFIG_DIR = path9__default.default.join(os__default.default.homedir(), ".onexthm");
-var CONFIG_FILE = path9__default.default.join(CONFIG_DIR, ".env");
+var CONFIG_DIR = path11__default.default.join(os__default.default.homedir(), ".onexthm");
+var CONFIG_FILE = path11__default.default.join(CONFIG_DIR, ".env");
 var CONFIG_ENTRIES = [
   {
     key: "AWS_ACCESS_KEY_ID",
@@ -4558,9 +4886,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__default.default.prompt([
@@ -4589,7 +4921,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" },
@@ -4624,15 +4955,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");
@@ -4642,142 +4976,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__default.default.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__default.default.readFile(absPath);
-  return crypto__default.default.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__default.default.posix.dirname(relPath);
-  const base = path9__default.default.posix.basename(relPath);
-  const ext = path9__default.default.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__default.default.join(distDir, "theme-assets");
-  if (!await fs__default.default.pathExists(assetsDir)) return [];
-  const files = await glob.glob("**/*", {
-    cwd: assetsDir,
-    nodir: true,
-    dot: false
-  });
-  const results = [];
-  for (const rel of files) {
-    const absPath = path9__default.default.join(assetsDir, rel);
-    const stat = await fs__default.default.stat(absPath);
-    if (!stat.isFile()) continue;
-    const originalPath = rel.split(path9__default.default.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.`
+      });
+    }
   }
-  return map;
+}
+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.`
+      });
+    }
+  }
+}
+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__default.default.resolve(options.theme);
+    themePath = path11__default.default.resolve(options.theme);
   } else {
     const isThemeDir2 = [
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path9__default.default.join(process.cwd(), f)));
+    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
     } else {
@@ -4787,13 +5397,13 @@ async function publishCommand(options) {
       process.exit(1);
     }
   }
-  const pkgPath = path9__default.default.join(themePath, "package.json");
+  const pkgPath = path11__default.default.join(themePath, "package.json");
   if (!fs__default.default.existsSync(pkgPath)) {
     logger.error("No package.json found in theme directory");
     process.exit(1);
   }
   const pkg = fs__default.default.readJsonSync(pkgPath);
-  const themeId = pkg.name?.replace("@onex-themes/", "") || path9__default.default.basename(themePath);
+  const themeId = pkg.name?.replace("@onex-themes/", "") || path11__default.default.basename(themePath);
   if (options.bump) {
     const currentVersion = pkg.version || "1.0.0";
     const newVersion = semver__default.default.inc(currentVersion, options.bump);
@@ -4816,56 +5426,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__default.default.inc(version2, "patch") || "?";
-      const minorVer = semver__default.default.inc(version2, "minor") || "?";
-      const majorVer = semver__default.default.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__default.default.inc(version2, "patch") || "?";
+        const minorVer = semver__default.default.inc(version2, "minor") || "?";
+        const majorVer = semver__default.default.inc(version2, "major") || "?";
+        logger.error(
+          `
 Version ${version2} of "${themeId}" is already published and cannot be overwritten.
 
 To publish a new version:
@@ -4876,12 +5493,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 {
@@ -4898,7 +5519,19 @@ Or use the --bump flag:
     logger.error(error instanceof Error ? error.message : "Build error");
     process.exit(1);
   }
-  const distDir = path9__default.default.join(themePath, "dist");
+  const distDir = path11__default.default.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);
@@ -4920,7 +5553,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)`);
@@ -4935,7 +5568,7 @@ Or use the --bump flag:
     for (const [originalPath, url] of Object.entries(videoUrls)) {
       assetMap[originalPath] = url;
     }
-    const assetMapPath = path9__default.default.join(distDir, "asset-map.json");
+    const assetMapPath = path11__default.default.join(distDir, "asset-map.json");
     await fs__default.default.writeFile(assetMapPath, JSON.stringify(assetMap, null, 2));
   } catch (error) {
     logger.error(
@@ -4962,7 +5595,8 @@ Or use the --bump flag:
             content_type: a.contentType
           }))
         })
-      }
+      },
+      env
     );
     const pubData = await pubResponse.json();
     const pubBody = pubData.statusCode ? pubData.body : pubData;
@@ -4988,6 +5622,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];
@@ -5014,6 +5654,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++;
@@ -5044,7 +5691,7 @@ Or use the --bump flag:
       logger.error("Build the theme first: onexthm build");
       process.exit(1);
     }
-    const bundleZipPath = path9__default.default.join(themePath, "dist", "bundle.zip");
+    const bundleZipPath = path11__default.default.join(themePath, "dist", "bundle.zip");
     await createZip(distDir, bundleZipPath, [
       "bundle.zip",
       "source.zip",
@@ -5071,7 +5718,7 @@ Or use the --bump flag:
   }
   logger.startSpinner("Uploading source...");
   try {
-    const sourceZipPath = path9__default.default.join(themePath, "dist", "source.zip");
+    const sourceZipPath = path11__default.default.join(themePath, "dist", "source.zip");
     await createZip(themePath, sourceZipPath, [
       "node_modules",
       "dist",
@@ -5098,7 +5745,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;
@@ -5144,9 +5792,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" },
@@ -5156,7 +5804,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__default.default.join(themePath, file);
+    const candidate = path11__default.default.join(themePath, file);
     if (fs__default.default.existsSync(candidate)) {
       const buf = fs__default.default.readFileSync(candidate);
       imageBase64 = `data:${mime};base64,${buf.toString("base64")}`;
@@ -5181,9 +5829,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({
@@ -5191,30 +5849,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."
     );
   }
 }
@@ -5222,7 +5906,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__default.default.basename(themePath);
+  const themeName = path11__default.default.basename(themePath);
   const port = await findFreePort(4500);
   const server = createDevServer2({
     port,
@@ -5278,25 +5962,40 @@ async function findFreePort(start) {
     srv.on("error", () => resolve(findFreePort(start + 1)));
   });
 }
-async function uploadVideoMultipart(apiUrl, themeId, video) {
-  const fileName = path9__default.default.basename(video.originalPath);
+async function uploadVideoMultipart(apiUrl, themeId, video, env = "dev") {
+  const fileName = path11__default.default.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;
@@ -5331,25 +6030,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;
@@ -5371,6 +6092,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__default.default.readFile(path11__default.default.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__default.default.readFile(path11__default.default.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();
@@ -5382,18 +6188,18 @@ var AI_CONTEXT_FILES = [
   ".mcp.json"
 ];
 function resolveTargetDir(opts) {
-  return path9__default.default.resolve(opts.cwd ?? process.cwd());
+  return path11__default.default.resolve(opts.cwd ?? process.cwd());
 }
 function resolveDefaultTemplateDir() {
-  return path9__default.default.join(getTemplatesDir(), "default");
+  return path11__default.default.join(getTemplatesDir(), "default");
 }
 function isThemeDir(dir) {
-  return fs__default.default.existsSync(path9__default.default.join(dir, "theme.config.ts")) || fs__default.default.existsSync(path9__default.default.join(dir, "theme.config.js"));
+  return fs__default.default.existsSync(path11__default.default.join(dir, "theme.config.ts")) || fs__default.default.existsSync(path11__default.default.join(dir, "theme.config.js"));
 }
 function inspectFiles(templateDir, targetDir) {
   return AI_CONTEXT_FILES.map((name) => {
-    const templatePath = path9__default.default.join(templateDir, name);
-    const targetPath = path9__default.default.join(targetDir, name);
+    const templatePath = path11__default.default.join(templateDir, name);
+    const targetPath = path11__default.default.join(targetDir, name);
     const exists = fs__default.default.existsSync(targetPath);
     let identical = false;
     if (exists && fs__default.default.existsSync(templatePath)) {
@@ -5536,7 +6342,7 @@ async function mcpDoctorCommand(options = {}) {
     return;
   }
   logger.success("theme.config.ts present");
-  const mcpJsonPath = path9__default.default.join(targetDir, ".mcp.json");
+  const mcpJsonPath = path11__default.default.join(targetDir, ".mcp.json");
   if (!fs__default.default.existsSync(mcpJsonPath)) {
     logger.error(".mcp.json missing \u2014 run `onexthm mcp setup`");
   } else {
@@ -5574,7 +6380,7 @@ async function mcpDoctorCommand(options = {}) {
       logger.success(`${s.name} up to date`);
     }
   }
-  const registryPath = path9__default.default.join(targetDir, "sections-registry.ts");
+  const registryPath = path11__default.default.join(targetDir, "sections-registry.ts");
   if (fs__default.default.existsSync(registryPath)) {
     logger.success("sections-registry.ts present");
   } else {
@@ -5586,22 +6392,22 @@ async function mcpDoctorCommand(options = {}) {
 
 // src/cli.ts
 dotenv__default.default.config({
-  path: path9__default.default.join(process.cwd(), ".env.local"),
+  path: path11__default.default.join(process.cwd(), ".env.local"),
   override: true
 });
-dotenv__default.default.config({ path: path9__default.default.join(process.cwd(), ".env") });
+dotenv__default.default.config({ path: path11__default.default.join(process.cwd(), ".env") });
 try {
   const projectRoot = getProjectRoot();
-  if (path9__default.default.resolve(projectRoot) !== path9__default.default.resolve(process.cwd())) {
+  if (path11__default.default.resolve(projectRoot) !== path11__default.default.resolve(process.cwd())) {
     dotenv__default.default.config({
-      path: path9__default.default.join(projectRoot, ".env.local")
+      path: path11__default.default.join(projectRoot, ".env.local")
     });
-    dotenv__default.default.config({ path: path9__default.default.join(projectRoot, ".env") });
+    dotenv__default.default.config({ path: path11__default.default.join(projectRoot, ".env") });
   }
 } catch {
 }
 dotenv__default.default.config({
-  path: path9__default.default.join(os__default.default.homedir(), ".onexthm", ".env"),
+  path: path11__default.default.join(os__default.default.homedir(), ".onexthm", ".env"),
   quiet: true
 });
 var require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)));
@@ -5612,7 +6418,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)"
@@ -5639,16 +6449,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"
@@ -5660,6 +6490,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__default.default.red(str))