@onexapis/cli 1.1.65 → 1.1.66

package/dist/index.js

@@ -2,16 +2,16 @@
 
 var chalk4 = require('chalk');
 var ora = require('ora');
-var esbuild = require('esbuild');
-var path8 = require('path');
-var fs7 = require('fs/promises');
-var crypto = require('crypto');
+var path10 = require('path');
 var glob = require('glob');
+var fs = require('fs-extra');
+var crypto = require('crypto');
+var esbuild = require('esbuild');
+var fs8 = require('fs/promises');
 var module$1 = require('module');
 var fs3 = require('fs');
 var child_process = require('child_process');
 var inquirer = require('inquirer');
-var fs = require('fs-extra');
 var ejs = require('ejs');
 var os = require('os');
 var AdmZip = require('adm-zip');
@@ -39,13 +39,13 @@ function _interopNamespace(e) {
 
 var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
-var esbuild__namespace = /*#__PURE__*/_interopNamespace(esbuild);
-var path8__default = /*#__PURE__*/_interopDefault(path8);
-var fs7__default = /*#__PURE__*/_interopDefault(fs7);
+var path10__default = /*#__PURE__*/_interopDefault(path10);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var esbuild__namespace = /*#__PURE__*/_interopNamespace(esbuild);
+var fs8__default = /*#__PURE__*/_interopDefault(fs8);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
-var fs__default = /*#__PURE__*/_interopDefault(fs);
 var ejs__default = /*#__PURE__*/_interopDefault(ejs);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var AdmZip__default = /*#__PURE__*/_interopDefault(AdmZip);
@@ -121,6 +121,187 @@ var init_logger = __esm({
     exports.logger = new exports.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('index.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(path10__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 mimeFor(filename) {
+  const ext = path10__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 = path10__default.default.posix.dirname(relPath);
+  const base = path10__default.default.posix.basename(relPath);
+  const ext = path10__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 = path10__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 = path10__default.default.join(assetsDir, rel);
+    const stat = await fs__default.default.stat(absPath);
+    if (!stat.isFile()) continue;
+    const originalPath = rel.split(path10__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;
+}
+var MIME_MAP, HASH_LEN;
+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;
+  }
+});
 
 // src/utils/compile-theme.ts
 var compile_theme_exports = {};
@@ -136,8 +317,8 @@ async function generateThemeCSS(themePath, outDir) {
     const tailwindcss = (await import('tailwindcss')).default;
     const tailwindConfig = {
       content: [
-        path8__default.default.join(themePath, "sections/**/*.{ts,tsx}"),
-        path8__default.default.join(themePath, "components/**/*.{ts,tsx}")
+        path10__default.default.join(themePath, "sections/**/*.{ts,tsx}"),
+        path10__default.default.join(themePath, "components/**/*.{ts,tsx}")
       ],
       theme: { extend: {} },
       plugins: []
@@ -147,7 +328,7 @@ async function generateThemeCSS(themePath, outDir) {
       inputCSS,
       { from: void 0 }
     );
-    await fs7__default.default.writeFile(path8__default.default.join(outDir, "bundle.css"), result.css);
+    await fs8__default.default.writeFile(path10__default.default.join(outDir, "bundle.css"), result.css);
     exports.logger.info("Generated bundle.css");
   } catch (err) {
     exports.logger.warning(
@@ -158,12 +339,12 @@ async function generateThemeCSS(themePath, outDir) {
 async function resolveNodeModulesFile(startDir, relativePath) {
   let dir = startDir;
   while (true) {
-    const candidate = path8__default.default.join(dir, "node_modules", relativePath);
+    const candidate = path10__default.default.join(dir, "node_modules", relativePath);
     try {
-      await fs7__default.default.access(candidate);
+      await fs8__default.default.access(candidate);
       return candidate;
     } catch {
-      const parent = path8__default.default.dirname(dir);
+      const parent = path10__default.default.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -187,7 +368,7 @@ async function scanImportsFromPackage(sourceDir, packageName) {
   });
   for (const file of sourceFiles) {
     try {
-      const content = await fs7__default.default.readFile(path8__default.default.join(sourceDir, file), "utf-8");
+      const content = await fs8__default.default.readFile(path10__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();
@@ -241,17 +422,17 @@ function createCoreGlobalPlugin(themePath) {
           const distFileName = subpath ? `${subpath}.mjs` : "index.mjs";
           let distPath = await resolveNodeModulesFile(
             themePath,
-            path8__default.default.join("@onexapis", "core", "dist", distFileName)
+            path10__default.default.join("@onexapis", "core", "dist", distFileName)
           );
           if (!distPath) {
             distPath = await resolveNodeModulesFile(
               __dirname,
-              path8__default.default.join("@onexapis", "core", "dist", distFileName)
+              path10__default.default.join("@onexapis", "core", "dist", distFileName)
             );
           }
           try {
             if (!distPath) throw new Error("not found");
-            const distContent = await fs7__default.default.readFile(distPath, "utf-8");
+            const distContent = await fs8__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) => {
@@ -480,7 +661,7 @@ async function generateThemeData(themePath, outputDir, themeId) {
   const pages = {};
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path8__default.default.join(themePath, `theme.config${ext}`));
+      const mod = await jiti.import(path10__default.default.join(themePath, `theme.config${ext}`));
       themeConfig = mod.default || mod;
       break;
     } catch {
@@ -488,20 +669,20 @@ async function generateThemeData(themePath, outputDir, themeId) {
   }
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path8__default.default.join(themePath, `theme.layout${ext}`));
+      const mod = await jiti.import(path10__default.default.join(themePath, `theme.layout${ext}`));
       layoutConfig = mod.default || mod;
       break;
     } catch {
     }
   }
   const schemas = {};
-  const sectionsDir = path8__default.default.join(themePath, "sections");
+  const sectionsDir = path10__default.default.join(themePath, "sections");
   try {
-    const sectionDirs = await fs7__default.default.readdir(sectionsDir);
+    const sectionDirs = await fs8__default.default.readdir(sectionsDir);
     for (const dir of sectionDirs) {
-      const schemaFile = path8__default.default.join(sectionsDir, dir, `${dir}.schema.ts`);
+      const schemaFile = path10__default.default.join(sectionsDir, dir, `${dir}.schema.ts`);
       try {
-        await fs7__default.default.access(schemaFile);
+        await fs8__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) {
@@ -513,14 +694,14 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  const pagesDir = path8__default.default.join(themePath, "pages");
+  const pagesDir = path10__default.default.join(themePath, "pages");
   try {
-    const files = await fs7__default.default.readdir(pagesDir);
+    const files = await fs8__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(path8__default.default.join(pagesDir, file));
+        const mod = await jiti.import(path10__default.default.join(pagesDir, file));
         const config = mod.default || mod;
         const sections = (config.sections || []).map((section) => {
           const schema = schemas[section.type];
@@ -548,8 +729,8 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  await fs7__default.default.writeFile(
-    path8__default.default.join(outputDir, "theme-data.json"),
+  await fs8__default.default.writeFile(
+    path10__default.default.join(outputDir, "theme-data.json"),
     JSON.stringify(
       {
         themeId,
@@ -572,22 +753,22 @@ async function generateThemeData(themePath, outputDir, themeId) {
   exports.logger.info(`Generated theme-data.json (${Object.keys(pages).length} pages)`);
 }
 async function contentHashEntry(outputDir) {
-  const entryPath = path8__default.default.join(outputDir, "bundle-entry.js");
-  const mapPath = path8__default.default.join(outputDir, "bundle-entry.js.map");
+  const entryPath = path10__default.default.join(outputDir, "bundle-entry.js");
+  const mapPath = path10__default.default.join(outputDir, "bundle-entry.js.map");
   let entryContent;
   try {
-    entryContent = await fs7__default.default.readFile(entryPath, "utf-8");
+    entryContent = await fs8__default.default.readFile(entryPath, "utf-8");
   } catch {
-    const indexPath = path8__default.default.join(outputDir, "index.js");
+    const indexPath = path10__default.default.join(outputDir, "index.js");
     try {
-      entryContent = await fs7__default.default.readFile(indexPath, "utf-8");
+      entryContent = await fs8__default.default.readFile(indexPath, "utf-8");
     } catch {
       exports.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 = path8__default.default.join(outputDir, "index.js.map");
+    const indexMapPath = path10__default.default.join(outputDir, "index.js.map");
     const hashedMapName2 = `bundle-entry-${hash2}.js.map`;
     entryContent = entryContent.replace(
       /\/\/# sourceMappingURL=index\.js\.map/,
@@ -595,18 +776,18 @@ async function contentHashEntry(outputDir) {
     );
     const oldFiles2 = await glob.glob("bundle-entry-*.js*", { cwd: outputDir });
     for (const f of oldFiles2) {
-      await fs7__default.default.unlink(path8__default.default.join(outputDir, f));
+      await fs8__default.default.unlink(path10__default.default.join(outputDir, f));
     }
-    await fs7__default.default.writeFile(path8__default.default.join(outputDir, hashedName2), entryContent);
-    await fs7__default.default.unlink(indexPath);
+    await fs8__default.default.writeFile(path10__default.default.join(outputDir, hashedName2), entryContent);
+    await fs8__default.default.unlink(indexPath);
     try {
-      await fs7__default.default.unlink(entryPath);
+      await fs8__default.default.unlink(entryPath);
     } catch {
     }
-    await fs7__default.default.writeFile(entryPath, entryContent);
+    await fs8__default.default.writeFile(entryPath, entryContent);
     try {
-      await fs7__default.default.access(indexMapPath);
-      await fs7__default.default.rename(indexMapPath, path8__default.default.join(outputDir, hashedMapName2));
+      await fs8__default.default.access(indexMapPath);
+      await fs8__default.default.rename(indexMapPath, path10__default.default.join(outputDir, hashedMapName2));
     } catch {
     }
     exports.logger.info(`Entry hashed: ${hashedName2}`);
@@ -621,17 +802,17 @@ async function contentHashEntry(outputDir) {
   );
   const oldFiles = await glob.glob("bundle-entry-*.js*", { cwd: outputDir });
   for (const f of oldFiles) {
-    await fs7__default.default.unlink(path8__default.default.join(outputDir, f));
+    await fs8__default.default.unlink(path10__default.default.join(outputDir, f));
   }
-  await fs7__default.default.writeFile(path8__default.default.join(outputDir, hashedName), entryContent);
+  await fs8__default.default.writeFile(path10__default.default.join(outputDir, hashedName), entryContent);
   try {
-    await fs7__default.default.unlink(entryPath);
+    await fs8__default.default.unlink(entryPath);
   } catch {
   }
-  await fs7__default.default.writeFile(entryPath, entryContent);
+  await fs8__default.default.writeFile(entryPath, entryContent);
   try {
-    await fs7__default.default.access(mapPath);
-    await fs7__default.default.rename(mapPath, path8__default.default.join(outputDir, hashedMapName));
+    await fs8__default.default.access(mapPath);
+    await fs8__default.default.rename(mapPath, path10__default.default.join(outputDir, hashedMapName));
   } catch {
   }
   exports.logger.info(`Entry hashed: ${hashedName}`);
@@ -643,7 +824,7 @@ async function extractDataRequirements(themePath) {
   const requirements = {};
   for (const file of schemaFiles) {
     try {
-      const mod = await jiti.import(path8__default.default.join(themePath, file));
+      const mod = await jiti.import(path10__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") {
@@ -658,12 +839,46 @@ async function extractDataRequirements(themePath) {
   }
   return requirements;
 }
+async function writeGateManifests(themePath, outputDir) {
+  try {
+    const schemas = await extractSchemas(themePath);
+    await fs8__default.default.writeFile(
+      path10__default.default.join(outputDir, "schemas.json"),
+      serializeManifest(schemas)
+    );
+    exports.logger.info(
+      `Generated schemas.json (${Object.keys(schemas.sections).length} sections)`
+    );
+  } catch (err) {
+    exports.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 fs8__default.default.writeFile(
+      path10__default.default.join(outputDir, "asset-manifest.json"),
+      JSON.stringify({ manifestVersion: 1, assets }, null, 2)
+    );
+    exports.logger.info(`Generated asset-manifest.json (${assets.length} assets)`);
+  } catch (err) {
+    exports.logger.warning(
+      `asset-manifest.json not written: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 async function generateManifest(themeName, themePath, outputDir) {
   let version = "1.0.0";
   let themeId = themeName;
   try {
-    const pkgContent = await fs7__default.default.readFile(
-      path8__default.default.join(themePath, "package.json"),
+    const pkgContent = await fs8__default.default.readFile(
+      path10__default.default.join(themePath, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(pkgContent);
@@ -681,7 +896,7 @@ async function generateManifest(themeName, themePath, outputDir) {
   const dataRequirements = await extractDataRequirements(themePath);
   let hasThemeConfig = false;
   try {
-    await fs7__default.default.access(path8__default.default.join(themePath, "theme.config.ts"));
+    await fs8__default.default.access(path10__default.default.join(themePath, "theme.config.ts"));
     hasThemeConfig = true;
   } catch {
   }
@@ -722,24 +937,24 @@ async function generateManifest(themeName, themePath, outputDir) {
     // Section data requirements for server-side prefetching (keyed by section type)
     dataRequirements
   };
-  await fs7__default.default.writeFile(
-    path8__default.default.join(outputDir, "manifest.json"),
+  await fs8__default.default.writeFile(
+    path10__default.default.join(outputDir, "manifest.json"),
     JSON.stringify(manifest, null, 2)
   );
 }
 async function compileStandaloneTheme(themePath, themeName) {
-  const outputDir = path8__default.default.join(themePath, "dist");
-  const bundleEntry = path8__default.default.join(themePath, "bundle-entry.ts");
-  const indexEntry = path8__default.default.join(themePath, "index.ts");
+  const outputDir = path10__default.default.join(themePath, "dist");
+  const bundleEntry = path10__default.default.join(themePath, "bundle-entry.ts");
+  const indexEntry = path10__default.default.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs7__default.default.access(bundleEntry);
+    await fs8__default.default.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path8__default.default.join(outputDir, ".process-shim.js");
-  await fs7__default.default.mkdir(outputDir, { recursive: true });
-  await fs7__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path10__default.default.join(outputDir, ".process-shim.js");
+  await fs8__default.default.mkdir(outputDir, { recursive: true });
+  await fs8__default.default.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -790,19 +1005,20 @@ async function compileStandaloneTheme(themePath, themeName) {
   try {
     const result = await esbuild__namespace.build(buildOptions);
     try {
-      await fs7__default.default.unlink(shimPath);
+      await fs8__default.default.unlink(shimPath);
     } catch {
     }
     await contentHashEntry(outputDir);
-    const themeAssetsDir = path8__default.default.join(themePath, "assets");
-    const distThemeAssets = path8__default.default.join(outputDir, "theme-assets");
+    const themeAssetsDir = path10__default.default.join(themePath, "assets");
+    const distThemeAssets = path10__default.default.join(outputDir, "theme-assets");
     try {
-      await fs7__default.default.access(themeAssetsDir);
-      await fs7__default.default.cp(themeAssetsDir, distThemeAssets, { recursive: true });
+      await fs8__default.default.access(themeAssetsDir);
+      await fs8__default.default.cp(themeAssetsDir, distThemeAssets, { recursive: true });
       exports.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) {
@@ -817,7 +1033,7 @@ async function compileStandaloneTheme(themePath, themeName) {
     return true;
   } catch (error) {
     try {
-      await fs7__default.default.unlink(shimPath);
+      await fs8__default.default.unlink(shimPath);
     } catch {
     }
     exports.logger.error(`esbuild compilation failed: ${error}`);
@@ -825,18 +1041,18 @@ async function compileStandaloneTheme(themePath, themeName) {
   }
 }
 async function compileStandaloneThemeDev(themePath, themeName) {
-  const outputDir = path8__default.default.join(themePath, "dist");
-  const bundleEntry = path8__default.default.join(themePath, "bundle-entry.ts");
-  const indexEntry = path8__default.default.join(themePath, "index.ts");
+  const outputDir = path10__default.default.join(themePath, "dist");
+  const bundleEntry = path10__default.default.join(themePath, "bundle-entry.ts");
+  const indexEntry = path10__default.default.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs7__default.default.access(bundleEntry);
+    await fs8__default.default.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path8__default.default.join(outputDir, ".process-shim.js");
-  await fs7__default.default.mkdir(outputDir, { recursive: true });
-  await fs7__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path10__default.default.join(outputDir, ".process-shim.js");
+  await fs8__default.default.mkdir(outputDir, { recursive: true });
+  await fs8__default.default.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -890,18 +1106,18 @@ async function compileStandaloneThemeDev(themePath, themeName) {
   return { context: context2, outputDir };
 }
 async function compilePreviewRuntime(themePath) {
-  const outputDir = path8__default.default.join(themePath, "dist");
-  await fs7__default.default.mkdir(outputDir, { recursive: true });
-  const outputPath = path8__default.default.join(outputDir, "preview-runtime.js");
+  const outputDir = path10__default.default.join(themePath, "dist");
+  await fs8__default.default.mkdir(outputDir, { recursive: true });
+  const outputPath = path10__default.default.join(outputDir, "preview-runtime.js");
   const locations = [
-    path8__default.default.join(__dirname, "..", "preview", "preview-app.tsx"),
-    path8__default.default.join(__dirname, "preview", "preview-app.tsx"),
-    path8__default.default.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
+    path10__default.default.join(__dirname, "..", "preview", "preview-app.tsx"),
+    path10__default.default.join(__dirname, "preview", "preview-app.tsx"),
+    path10__default.default.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
   ];
   let previewEntryPath = null;
   for (const loc of locations) {
     try {
-      await fs7__default.default.access(loc);
+      await fs8__default.default.access(loc);
       previewEntryPath = loc;
       break;
     } catch {
@@ -984,10 +1200,10 @@ ${locations.join("\n")}`
         if (!lucideScanned) {
           lucideScanned = true;
           const coreSrcCandidates = [
-            path8__default.default.join(themePath, "node_modules", "@onexapis", "core", "src"),
-            path8__default.default.join(themePath, "..", "..", "packages", "core", "src"),
+            path10__default.default.join(themePath, "node_modules", "@onexapis", "core", "src"),
+            path10__default.default.join(themePath, "..", "..", "packages", "core", "src"),
             // monorepo sibling
-            path8__default.default.join(
+            path10__default.default.join(
               __dirname,
               "..",
               "..",
@@ -1002,7 +1218,7 @@ ${locations.join("\n")}`
           let coreSourceDir = null;
           for (const candidate of coreSrcCandidates) {
             try {
-              await fs7__default.default.access(candidate);
+              await fs8__default.default.access(candidate);
               coreSourceDir = candidate;
               break;
             } catch {
@@ -1021,21 +1237,21 @@ ${locations.join("\n")}`
             }
           } else {
             const coreDistCandidates = [
-              path8__default.default.join(themePath, "node_modules", "@onexapis", "core", "dist")
+              path10__default.default.join(themePath, "node_modules", "@onexapis", "core", "dist")
             ];
             const resolvedDist = await resolveNodeModulesFile(
               __dirname,
-              path8__default.default.join("@onexapis", "core", "dist")
+              path10__default.default.join("@onexapis", "core", "dist")
             );
             if (resolvedDist) coreDistCandidates.push(resolvedDist);
             for (const candidate of coreDistCandidates) {
               try {
-                await fs7__default.default.access(candidate);
+                await fs8__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 fs7__default.default.readFile(
-                    path8__default.default.join(candidate, file),
+                  const content = await fs8__default.default.readFile(
+                    path10__default.default.join(candidate, file),
                     "utf-8"
                   );
                   for (const match of content.matchAll(importRegex)) {
@@ -1090,7 +1306,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('index.js', document.baseURI).href)) || __filename);
           const cjsPath = req.resolve("framer-motion");
           const pkgDir = cjsPath.replace(/[/\\]dist[/\\].*$/, "");
-          const esmEntry = path8__default.default.join(pkgDir, "dist", "es", "index.mjs");
+          const esmEntry = path10__default.default.join(pkgDir, "dist", "es", "index.mjs");
           const { existsSync } = await import('fs');
           if (existsSync(esmEntry)) {
             return { path: esmEntry, namespace: "file" };
@@ -1189,8 +1405,8 @@ export function headers() { return new Headers(); }
       });
     }
   };
-  const shimPath = path8__default.default.join(outputDir, ".process-shim-preview.js");
-  await fs7__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path10__default.default.join(outputDir, ".process-shim-preview.js");
+  await fs8__default.default.writeFile(shimPath, PROCESS_SHIM);
   await esbuild__namespace.build({
     entryPoints: [previewEntryPath],
     bundle: true,
@@ -1225,7 +1441,7 @@ export function headers() { return new Headers(); }
     }
   });
   try {
-    await fs7__default.default.unlink(shimPath);
+    await fs8__default.default.unlink(shimPath);
   } catch {
   }
   return outputPath;
@@ -1234,6 +1450,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 = {
@@ -1403,8 +1621,8 @@ function validateThemeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name);
 }
 function pathExists(filePath) {
-  const fs11 = __require("fs-extra");
-  return fs11.existsSync(filePath);
+  const fs12 = __require("fs-extra");
+  return fs12.existsSync(filePath);
 }
 function validateCategory(category) {
   const validCategories = [
@@ -1445,18 +1663,18 @@ async function renderTemplate(templatePath, data) {
   return ejs__default.default.render(template, data);
 }
 async function writeFile(filePath, content) {
-  await fs__default.default.ensureDir(path8__default.default.dirname(filePath));
+  await fs__default.default.ensureDir(path10__default.default.dirname(filePath));
   await fs__default.default.writeFile(filePath, content, "utf-8");
 }
 function getTemplatesDir() {
   const locations = [
-    path8__default.default.join(__dirname, "../../templates"),
+    path10__default.default.join(__dirname, "../../templates"),
     // Development
-    path8__default.default.join(__dirname, "../templates"),
+    path10__default.default.join(__dirname, "../templates"),
     // Production (dist/)
-    path8__default.default.join(process.cwd(), "templates"),
+    path10__default.default.join(process.cwd(), "templates"),
     // Fallback
-    path8__default.default.join(process.cwd(), "packages/cli/templates")
+    path10__default.default.join(process.cwd(), "packages/cli/templates")
     // Monorepo
   ];
   for (const location of locations) {
@@ -1468,7 +1686,7 @@ function getTemplatesDir() {
 }
 async function copyTemplate(templateName, targetDir, data) {
   const templatesDir = getTemplatesDir();
-  const templateDir = path8__default.default.join(templatesDir, templateName);
+  const templateDir = path10__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(", ")}`
@@ -1477,8 +1695,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 = path8__default.default.join(templateDir, file);
-    const targetPath = path8__default.default.join(targetDir, file);
+    const templatePath = path10__default.default.join(templateDir, file);
+    const targetPath = path10__default.default.join(targetDir, file);
     const stat = await fs__default.default.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -1495,8 +1713,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 = path8__default.default.join(templateDir, file);
-    const targetPath = path8__default.default.join(targetDir, file);
+    const templatePath = path10__default.default.join(templateDir, file);
+    const targetPath = path10__default.default.join(targetDir, file);
     const stat = await fs__default.default.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -1511,32 +1729,32 @@ async function copyTemplateDir(templateDir, targetDir, data) {
 }
 function getProjectRoot() {
   let currentDir = process.cwd();
-  while (currentDir !== path8__default.default.parse(currentDir).root) {
-    const packageJsonPath = path8__default.default.join(currentDir, "package.json");
+  while (currentDir !== path10__default.default.parse(currentDir).root) {
+    const packageJsonPath = path10__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(path8__default.default.join(currentDir, "src/themes")) || fs__default.default.existsSync(path8__default.default.join(currentDir, "themes"))) {
+      if (packageJson.workspaces || fs__default.default.existsSync(path10__default.default.join(currentDir, "src/themes")) || fs__default.default.existsSync(path10__default.default.join(currentDir, "themes"))) {
         return currentDir;
       }
     }
-    currentDir = path8__default.default.dirname(currentDir);
+    currentDir = path10__default.default.dirname(currentDir);
   }
   return process.cwd();
 }
 function getThemesDir() {
   const root = getProjectRoot();
-  if (fs__default.default.existsSync(path8__default.default.join(root, "themes")))
-    return path8__default.default.join(root, "themes");
-  if (fs__default.default.existsSync(path8__default.default.join(root, "src/themes")))
-    return path8__default.default.join(root, "src/themes");
-  return path8__default.default.dirname(root);
+  if (fs__default.default.existsSync(path10__default.default.join(root, "themes")))
+    return path10__default.default.join(root, "themes");
+  if (fs__default.default.existsSync(path10__default.default.join(root, "src/themes")))
+    return path10__default.default.join(root, "src/themes");
+  return path10__default.default.dirname(root);
 }
 function getFeaturesDir() {
-  return path8__default.default.join(getProjectRoot(), "src/features");
+  return path10__default.default.join(getProjectRoot(), "src/features");
 }
 function isOneXProject() {
   const root = getProjectRoot();
-  return fs__default.default.existsSync(path8__default.default.join(root, "themes")) || fs__default.default.existsSync(path8__default.default.join(root, "src/themes")) || fs__default.default.existsSync(path8__default.default.join(root, "theme.config.ts")) || fs__default.default.existsSync(path8__default.default.join(root, "bundle-entry.ts"));
+  return fs__default.default.existsSync(path10__default.default.join(root, "themes")) || fs__default.default.existsSync(path10__default.default.join(root, "src/themes")) || fs__default.default.existsSync(path10__default.default.join(root, "theme.config.ts")) || fs__default.default.existsSync(path10__default.default.join(root, "bundle-entry.ts"));
 }
 function ensureOneXProject() {
   if (!isOneXProject()) {
@@ -1552,13 +1770,13 @@ function listThemes() {
     return [];
   }
   return fs__default.default.readdirSync(themesDir).filter((name) => {
-    const themePath = path8__default.default.join(themesDir, name);
-    return fs__default.default.statSync(themePath).isDirectory() && (fs__default.default.existsSync(path8__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path8__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path8__default.default.join(themePath, "manifest.ts")));
+    const themePath = path10__default.default.join(themesDir, name);
+    return fs__default.default.statSync(themePath).isDirectory() && (fs__default.default.existsSync(path10__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path10__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path10__default.default.join(themePath, "manifest.ts")));
   });
 }
 function themeExists(themeName) {
-  const themePath = path8__default.default.join(getThemesDir(), themeName);
-  return fs__default.default.existsSync(themePath) && (fs__default.default.existsSync(path8__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path8__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path8__default.default.join(themePath, "manifest.ts")));
+  const themePath = path10__default.default.join(getThemesDir(), themeName);
+  return fs__default.default.existsSync(themePath) && (fs__default.default.existsSync(path10__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path10__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path10__default.default.join(themePath, "manifest.ts")));
 }
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
@@ -1566,9 +1784,9 @@ function detectPackageManager() {
   if (userAgent.includes("yarn")) return "yarn";
   if (userAgent.includes("bun")) return "bun";
   const cwd = process.cwd();
-  if (fs__default.default.existsSync(path8__default.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs__default.default.existsSync(path8__default.default.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs__default.default.existsSync(path8__default.default.join(cwd, "bun.lockb"))) return "bun";
+  if (fs__default.default.existsSync(path10__default.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs__default.default.existsSync(path10__default.default.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs__default.default.existsSync(path10__default.default.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 async function installDependencies(projectPath, packageManager = "npm") {
@@ -1585,15 +1803,16 @@ async function installDependencies(projectPath, packageManager = "npm") {
     }
   });
 }
-var AUTH_DIR = path8__default.default.join(os__default.default.homedir(), ".onexthm");
+var AUTH_DIR = path10__default.default.join(os__default.default.homedir(), ".onexthm");
 var ENV_URLS = {
   dev: "https://platform-dev.onexeos.com",
-  prod: "https://platform-staging.onexeos.com"
+  staging: "https://platform-staging.onexeos.com",
+  prod: "https://platform-apis.onexeos.com"
 };
 function getAuthFile(env = "dev") {
-  const newFile = path8__default.default.join(AUTH_DIR, `auth-${env}.json`);
+  const newFile = path10__default.default.join(AUTH_DIR, `auth-${env}.json`);
   if (env === "dev") {
-    const legacyFile = path8__default.default.join(AUTH_DIR, "auth.json");
+    const legacyFile = path10__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);
@@ -1735,7 +1954,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(path8__default.default.join(process.cwd(), kebabName))) {
+          if (fs3__default.default.existsSync(path10__default.default.join(process.cwd(), kebabName))) {
             return `Directory "${kebabName}" already exists`;
           }
           return true;
@@ -1746,7 +1965,7 @@ async function initCommand(projectName, options = {}) {
   } else {
     name = toKebabCase(projectName);
   }
-  const projectPath = path8__default.default.join(process.cwd(), name);
+  const projectPath = path10__default.default.join(process.cwd(), name);
   if (fs3__default.default.existsSync(projectPath)) {
     exports.logger.error(`Directory "${name}" already exists.`);
     process.exit(1);
@@ -1862,7 +2081,7 @@ async function initCommand(projectName, options = {}) {
       description,
       author
     );
-    const mcpJsonPath = path8__default.default.join(projectPath, ".mcp.json");
+    const mcpJsonPath = path10__default.default.join(projectPath, ".mcp.json");
     if (fs3__default.default.existsSync(mcpJsonPath)) {
       let mcpContent = fs3__default.default.readFileSync(mcpJsonPath, "utf-8");
       if (figmaApiKey) {
@@ -1942,7 +2161,7 @@ async function initCommand(projectName, options = {}) {
   }
 }
 async function renameThemeInFiles(projectPath, themeName, displayName, description, author) {
-  const configPath = path8__default.default.join(projectPath, "theme.config.ts");
+  const configPath = path10__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(
@@ -1955,7 +2174,7 @@ async function renameThemeInFiles(projectPath, themeName, displayName, descripti
     );
     fs3__default.default.writeFileSync(configPath, content, "utf-8");
   }
-  const pkgPath = path8__default.default.join(projectPath, "package.json");
+  const pkgPath = path10__default.default.join(projectPath, "package.json");
   if (fs3__default.default.existsSync(pkgPath)) {
     let content = fs3__default.default.readFileSync(pkgPath, "utf-8");
     content = content.replace(
@@ -1977,10 +2196,10 @@ async function createSectionCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs__default.default.existsSync(path8__default.default.join(process.cwd(), f))
+      (f) => fs__default.default.existsSync(path10__default.default.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path8__default.default.basename(process.cwd());
+      options.theme = path10__default.default.basename(process.cwd());
     }
   }
   const sectionName = toKebabCase(name);
@@ -2043,35 +2262,35 @@ async function createSectionCommand(name, options) {
   };
   exports.logger.startSpinner("Creating section files...");
   try {
-    const themePath = path8__default.default.join(getThemesDir(), themeName);
-    const sectionPath = path8__default.default.join(themePath, "sections", sectionName);
+    const themePath = path10__default.default.join(getThemesDir(), themeName);
+    const sectionPath = path10__default.default.join(themePath, "sections", sectionName);
     const schemaContent = generateSectionSchema(data);
     await writeFile(
-      path8__default.default.join(sectionPath, `${sectionName}.schema.ts`),
+      path10__default.default.join(sectionPath, `${sectionName}.schema.ts`),
       schemaContent
     );
     if (createTemplate) {
       const templateContent = generateSectionTemplate(data);
       await writeFile(
-        path8__default.default.join(sectionPath, `${sectionName}-default.tsx`),
+        path10__default.default.join(sectionPath, `${sectionName}-default.tsx`),
         templateContent
       );
     }
     const indexContent = generateSectionIndex(data, createTemplate);
-    await writeFile(path8__default.default.join(sectionPath, "index.ts"), indexContent);
+    await writeFile(path10__default.default.join(sectionPath, "index.ts"), indexContent);
     exports.logger.stopSpinner(true, "Section files created successfully!");
     exports.logger.newLine();
     exports.logger.section("Next steps:");
     exports.logger.log(
-      `  1. Edit schema: ${path8__default.default.relative(process.cwd(), path8__default.default.join(sectionPath, `${sectionName}.schema.ts`))}`
+      `  1. Edit schema: ${path10__default.default.relative(process.cwd(), path10__default.default.join(sectionPath, `${sectionName}.schema.ts`))}`
     );
     if (createTemplate) {
       exports.logger.log(
-        `  2. Edit template: ${path8__default.default.relative(process.cwd(), path8__default.default.join(sectionPath, `${sectionName}-default.tsx`))}`
+        `  2. Edit template: ${path10__default.default.relative(process.cwd(), path10__default.default.join(sectionPath, `${sectionName}-default.tsx`))}`
       );
     }
     exports.logger.log(
-      `  3. Add to theme manifest: ${path8__default.default.relative(process.cwd(), path8__default.default.join(themePath, "manifest.ts"))}`
+      `  3. Add to theme manifest: ${path10__default.default.relative(process.cwd(), path10__default.default.join(themePath, "manifest.ts"))}`
     );
     exports.logger.newLine();
     exports.logger.success("Section created successfully!");
@@ -2219,10 +2438,10 @@ async function createBlockCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs__default.default.existsSync(path8__default.default.join(process.cwd(), f))
+      (f) => fs__default.default.existsSync(path10__default.default.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path8__default.default.basename(process.cwd());
+      options.theme = path10__default.default.basename(process.cwd());
     }
   }
   const blockName = toKebabCase(name);
@@ -2297,24 +2516,24 @@ async function createBlockCommand(name, options) {
   };
   exports.logger.startSpinner("Creating block files...");
   try {
-    const blockPath = scope === "shared" ? path8__default.default.join(getFeaturesDir(), "blocks", blockName) : path8__default.default.join(getThemesDir(), themeName, "blocks", blockName);
+    const blockPath = scope === "shared" ? path10__default.default.join(getFeaturesDir(), "blocks", blockName) : path10__default.default.join(getThemesDir(), themeName, "blocks", blockName);
     const schemaContent = generateBlockSchema(data);
     await writeFile(
-      path8__default.default.join(blockPath, `${blockName}.schema.ts`),
+      path10__default.default.join(blockPath, `${blockName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateBlockComponent(data);
-    await writeFile(path8__default.default.join(blockPath, `${blockName}.tsx`), componentContent);
+    await writeFile(path10__default.default.join(blockPath, `${blockName}.tsx`), componentContent);
     const indexContent = generateBlockIndex(data);
-    await writeFile(path8__default.default.join(blockPath, "index.ts"), indexContent);
+    await writeFile(path10__default.default.join(blockPath, "index.ts"), indexContent);
     exports.logger.stopSpinner(true, "Block files created successfully!");
     exports.logger.newLine();
     exports.logger.section("Next steps:");
     exports.logger.log(
-      `  1. Edit schema: ${path8__default.default.relative(process.cwd(), path8__default.default.join(blockPath, `${blockName}.schema.ts`))}`
+      `  1. Edit schema: ${path10__default.default.relative(process.cwd(), path10__default.default.join(blockPath, `${blockName}.schema.ts`))}`
     );
     exports.logger.log(
-      `  2. Edit component: ${path8__default.default.relative(process.cwd(), path8__default.default.join(blockPath, `${blockName}.tsx`))}`
+      `  2. Edit component: ${path10__default.default.relative(process.cwd(), path10__default.default.join(blockPath, `${blockName}.tsx`))}`
     );
     exports.logger.log(
       `  3. Register in block registry: src/lib/registry/block-registry.ts`
@@ -2492,31 +2711,31 @@ async function createComponentCommand(name, options) {
   };
   exports.logger.startSpinner("Creating component files...");
   try {
-    const componentPath = path8__default.default.join(
+    const componentPath = path10__default.default.join(
       getFeaturesDir(),
       "components",
       componentName
     );
     const schemaContent = generateComponentSchema(data);
     await writeFile(
-      path8__default.default.join(componentPath, `${componentName}.schema.ts`),
+      path10__default.default.join(componentPath, `${componentName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateComponent(data);
     await writeFile(
-      path8__default.default.join(componentPath, `${componentName}.tsx`),
+      path10__default.default.join(componentPath, `${componentName}.tsx`),
       componentContent
     );
     const indexContent = generateComponentIndex(data);
-    await writeFile(path8__default.default.join(componentPath, "index.ts"), indexContent);
+    await writeFile(path10__default.default.join(componentPath, "index.ts"), indexContent);
     exports.logger.stopSpinner(true, "Component files created successfully!");
     exports.logger.newLine();
     exports.logger.section("Next steps:");
     exports.logger.log(
-      `  1. Edit schema: ${path8__default.default.relative(process.cwd(), path8__default.default.join(componentPath, `${componentName}.schema.ts`))}`
+      `  1. Edit schema: ${path10__default.default.relative(process.cwd(), path10__default.default.join(componentPath, `${componentName}.schema.ts`))}`
     );
     exports.logger.log(
-      `  2. Edit component: ${path8__default.default.relative(process.cwd(), path8__default.default.join(componentPath, `${componentName}.tsx`))}`
+      `  2. Edit component: ${path10__default.default.relative(process.cwd(), path10__default.default.join(componentPath, `${componentName}.tsx`))}`
     );
     exports.logger.log(
       `  3. Register in component registry: src/lib/registry/component-registry.ts`
@@ -2673,13 +2892,13 @@ async function listSections(themeFilter) {
     return;
   }
   for (const theme of themes) {
-    const sectionsDir = path8__default.default.join(getThemesDir(), theme, "sections");
+    const sectionsDir = path10__default.default.join(getThemesDir(), theme, "sections");
     if (!fs__default.default.existsSync(sectionsDir)) {
       continue;
     }
     const sections = fs__default.default.readdirSync(sectionsDir).filter((name) => {
-      const sectionPath = path8__default.default.join(sectionsDir, name);
-      return fs__default.default.statSync(sectionPath).isDirectory() && fs__default.default.existsSync(path8__default.default.join(sectionPath, "index.ts"));
+      const sectionPath = path10__default.default.join(sectionsDir, name);
+      return fs__default.default.statSync(sectionPath).isDirectory() && fs__default.default.existsSync(path10__default.default.join(sectionPath, "index.ts"));
     });
     if (sections.length > 0) {
       exports.logger.log(chalk4__default.default.cyan(`
@@ -2693,11 +2912,11 @@ async function listSections(themeFilter) {
 }
 async function listBlocks(themeFilter) {
   exports.logger.section("\u{1F9F1} Blocks");
-  const sharedBlocksDir = path8__default.default.join(getFeaturesDir(), "blocks");
+  const sharedBlocksDir = path10__default.default.join(getFeaturesDir(), "blocks");
   if (fs__default.default.existsSync(sharedBlocksDir)) {
     const sharedBlocks = fs__default.default.readdirSync(sharedBlocksDir).filter((name) => {
-      const blockPath = path8__default.default.join(sharedBlocksDir, name);
-      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path8__default.default.join(blockPath, "index.ts"));
+      const blockPath = path10__default.default.join(sharedBlocksDir, name);
+      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path10__default.default.join(blockPath, "index.ts"));
     });
     if (sharedBlocks.length > 0) {
       exports.logger.log(chalk4__default.default.cyan("\n  Shared:"));
@@ -2708,13 +2927,13 @@ async function listBlocks(themeFilter) {
   }
   const themes = themeFilter ? [themeFilter] : listThemes();
   for (const theme of themes) {
-    const blocksDir = path8__default.default.join(getThemesDir(), theme, "blocks");
+    const blocksDir = path10__default.default.join(getThemesDir(), theme, "blocks");
     if (!fs__default.default.existsSync(blocksDir)) {
       continue;
     }
     const blocks = fs__default.default.readdirSync(blocksDir).filter((name) => {
-      const blockPath = path8__default.default.join(blocksDir, name);
-      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path8__default.default.join(blockPath, "index.ts"));
+      const blockPath = path10__default.default.join(blocksDir, name);
+      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path10__default.default.join(blockPath, "index.ts"));
     });
     if (blocks.length > 0) {
       exports.logger.log(chalk4__default.default.cyan(`
@@ -2728,14 +2947,14 @@ async function listBlocks(themeFilter) {
 }
 async function listComponents() {
   exports.logger.section("\u2699\uFE0F  Components");
-  const componentsDir = path8__default.default.join(getFeaturesDir(), "components");
+  const componentsDir = path10__default.default.join(getFeaturesDir(), "components");
   if (!fs__default.default.existsSync(componentsDir)) {
     exports.logger.warning("No components directory found");
     return;
   }
   const components = fs__default.default.readdirSync(componentsDir).filter((name) => {
-    const componentPath = path8__default.default.join(componentsDir, name);
-    return fs__default.default.statSync(componentPath).isDirectory() && fs__default.default.existsSync(path8__default.default.join(componentPath, "index.ts"));
+    const componentPath = path10__default.default.join(componentsDir, name);
+    return fs__default.default.statSync(componentPath).isDirectory() && fs__default.default.existsSync(path10__default.default.join(componentPath, "index.ts"));
   });
   if (components.length === 0) {
     exports.logger.warning("No components found");
@@ -2756,11 +2975,11 @@ async function listThemesInfo() {
   }
   exports.logger.log("");
   for (const theme of themes) {
-    const themeDir = path8__default.default.join(getThemesDir(), theme);
+    const themeDir = path10__default.default.join(getThemesDir(), theme);
     const candidates = ["theme.config.ts", "bundle-entry.ts", "manifest.ts"];
     let manifestContent = "";
     for (const candidate of candidates) {
-      const candidatePath = path8__default.default.join(themeDir, candidate);
+      const candidatePath = path10__default.default.join(themeDir, candidate);
       if (fs__default.default.existsSync(candidatePath)) {
         manifestContent = fs__default.default.readFileSync(candidatePath, "utf-8");
         break;
@@ -2789,14 +3008,14 @@ async function buildCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path8__default.default.join(getThemesDir(), themeName);
+      const workspaceThemePath = path10__default.default.join(getThemesDir(), themeName);
       if (fs__default.default.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path8__default.default.join(process.cwd(), themeName);
+        themePath = path10__default.default.join(process.cwd(), themeName);
       }
     } catch {
-      themePath = path8__default.default.join(process.cwd(), themeName);
+      themePath = path10__default.default.join(process.cwd(), themeName);
     }
     if (!fs__default.default.existsSync(themePath)) {
       exports.logger.error(`Theme "${themeName}" not found.`);
@@ -2807,10 +3026,10 @@ async function buildCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path8__default.default.join(process.cwd(), f)));
+    ].some((f) => fs__default.default.existsSync(path10__default.default.join(process.cwd(), f)));
     if (isThemeDir) {
       themePath = process.cwd();
-      themeName = path8__default.default.basename(themePath);
+      themeName = path10__default.default.basename(themePath);
       exports.logger.info(`Building current theme: ${themeName}`);
     } else {
       exports.logger.error(
@@ -2819,7 +3038,7 @@ async function buildCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path8__default.default.join(themePath, "package.json");
+  const packageJsonPath = path10__default.default.join(themePath, "package.json");
   const hasPkgJson = fs__default.default.existsSync(packageJsonPath);
   if (!hasPkgJson) {
     exports.logger.warning(
@@ -2875,9 +3094,9 @@ async function buildCommand(options) {
     exports.logger.success("\u2713 Theme built successfully!");
     exports.logger.newLine();
     exports.logger.info(`Theme: ${themeName}`);
-    const distPath = path8__default.default.join(themePath, "dist");
+    const distPath = path10__default.default.join(themePath, "dist");
     if (fs__default.default.existsSync(distPath)) {
-      exports.logger.log(`Output: ${path8__default.default.relative(process.cwd(), distPath)}`);
+      exports.logger.log(`Output: ${path10__default.default.relative(process.cwd(), distPath)}`);
       const files = fs__default.default.readdirSync(distPath);
       exports.logger.log(`Files: ${files.length}`);
     }
@@ -3018,8 +3237,8 @@ async function downloadBundleZip(apiUrl, themeId, version) {
 async function createCompatibilityFiles(outputDir, manifest) {
   const entryFile = manifest.output?.entry || "bundle-entry.js";
   if (entryFile !== "bundle-entry.js" && entryFile.startsWith("bundle-entry-")) {
-    const hashedPath = path8__default.default.join(outputDir, entryFile);
-    const stablePath = path8__default.default.join(outputDir, "bundle-entry.js");
+    const hashedPath = path10__default.default.join(outputDir, entryFile);
+    const stablePath = path10__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";
@@ -3028,13 +3247,13 @@ async function createCompatibilityFiles(outputDir, manifest) {
       }
     }
   }
-  const sectionsRegistryPath = path8__default.default.join(outputDir, "sections-registry.js");
+  const sectionsRegistryPath = path10__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 = path8__default.default.join(outputDir, "package.json");
+  const pkgJsonPath = path10__default.default.join(outputDir, "package.json");
   await fs__default.default.writeFile(pkgJsonPath, '{\n  "type": "module"\n}\n', "utf-8");
 }
 function showDownloadFailureHelp(themeId, apiUrl) {
@@ -3133,7 +3352,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 = path8__default.default.join(outputDir, "manifest.json");
+    const manifestPath = path10__default.default.join(outputDir, "manifest.json");
     const manifest = await fs__default.default.readJson(manifestPath);
     await createCompatibilityFiles(outputDir, manifest);
     console.log();
@@ -3254,7 +3473,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 = path8__default.default.join(themeDir, "package.json");
+  const pkgPath = path10__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}`;
@@ -3270,7 +3489,7 @@ async function renameTheme(themeDir, oldName, newName) {
     }
     await fs__default.default.writeJson(pkgPath, pkg, { spaces: 2 });
   }
-  const configPath = path8__default.default.join(themeDir, "theme.config.ts");
+  const configPath = path10__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}"`);
@@ -3280,7 +3499,7 @@ async function renameTheme(themeDir, oldName, newName) {
     );
     await fs__default.default.writeFile(configPath, content);
   }
-  const layoutPath = path8__default.default.join(themeDir, "theme.layout.ts");
+  const layoutPath = path10__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}"`);
@@ -3293,7 +3512,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 = path8__default.default.join(themeDir, file);
+    const filePath = path10__default.default.join(themeDir, file);
     let content = await fs__default.default.readFile(filePath, "utf-8");
     const original = content;
     content = content.replace(
@@ -3336,7 +3555,7 @@ async function cloneCommand(themeName, options) {
   }
   const spinner = ora__default.default("Initializing clone...").start();
   try {
-    const outputDir = options.output || path8__default.default.resolve(process.cwd(), newName);
+    const outputDir = options.output || path10__default.default.resolve(process.cwd(), newName);
     if (await fs__default.default.pathExists(outputDir)) {
       spinner.fail(chalk4__default.default.red(`Directory already exists: ${outputDir}`));
       exports.logger.info(
@@ -3382,7 +3601,7 @@ async function cloneCommand(themeName, options) {
     spinner.succeed(
       `Renamed theme: ${chalk4__default.default.gray(themeName)} \u2192 ${chalk4__default.default.cyan(newName)}`
     );
-    const envExamplePath = path8__default.default.join(outputDir, ".env.example");
+    const envExamplePath = path10__default.default.join(outputDir, ".env.example");
     if (!await fs__default.default.pathExists(envExamplePath)) {
       await fs__default.default.writeFile(
         envExamplePath,
@@ -3395,7 +3614,7 @@ async function cloneCommand(themeName, options) {
         ].join("\n")
       );
     }
-    const mcpJsonPath = path8__default.default.join(outputDir, ".mcp.json");
+    const mcpJsonPath = path10__default.default.join(outputDir, ".mcp.json");
     if (await fs__default.default.pathExists(mcpJsonPath)) {
       const { default: inquirerMod } = await import('inquirer');
       const { figmaApiKey } = await inquirerMod.prompt([
@@ -3420,7 +3639,7 @@ async function cloneCommand(themeName, options) {
     }
     if (options.install !== false) {
       const hasPkgJson = await fs__default.default.pathExists(
-        path8__default.default.join(outputDir, "package.json")
+        path10__default.default.join(outputDir, "package.json")
       );
       if (hasPkgJson) {
         spinner.start("Installing dependencies...");
@@ -3448,7 +3667,7 @@ async function cloneCommand(themeName, options) {
     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 ${path8__default.default.relative(process.cwd(), outputDir)}`));
+    console.log(chalk4__default.default.gray(`   cd ${path10__default.default.relative(process.cwd(), outputDir)}`));
     console.log(
       chalk4__default.default.gray("   cp .env.example .env  # then add your Company ID")
     );