@onexapis/cli 1.1.2 → 1.1.4

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import chalk4 from 'chalk';
 import ora from 'ora';
 import * as esbuild from 'esbuild';
-import path from 'path';
+import path8 from 'path';
 import fs7 from 'fs/promises';
 import crypto from 'crypto';
 import { glob } from 'glob';
@@ -25,22 +25,6 @@ import { WebSocketServer, WebSocket } from 'ws';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -48,7 +32,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 var Logger, logger;
 var init_logger = __esm({
   "src/utils/logger.ts"() {
@@ -117,12 +100,12 @@ __export(compile_theme_exports, {
 async function resolveNodeModulesFile(startDir, relativePath) {
   let dir = startDir;
   while (true) {
-    const candidate = path.join(dir, "node_modules", relativePath);
+    const candidate = path8.join(dir, "node_modules", relativePath);
     try {
       await fs7.access(candidate);
       return candidate;
-    } catch (e) {
-      const parent = path.dirname(dir);
+    } catch {
+      const parent = path8.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -140,7 +123,7 @@ function createCoreGlobalPlugin(themePath) {
       }));
       build2.onLoad({ filter: /.*/, namespace: "core-global" }, async (args) => {
         const match = args.path.match(/^@onexapis\/core(\/(.+))?$/);
-        const subpath = (match == null ? void 0 : match[2]) || "";
+        const subpath = match?.[2] || "";
         const moduleAccess = subpath ? `['${subpath}']` : "";
         let namedExports = [];
         const cacheKey = subpath || "__root__";
@@ -148,10 +131,16 @@ function createCoreGlobalPlugin(themePath) {
           namedExports = exportsBySubpath[cacheKey];
         } else {
           const distFileName = subpath ? `${subpath}.mjs` : "index.mjs";
-          const distPath = await resolveNodeModulesFile(
+          let distPath = await resolveNodeModulesFile(
             themePath,
-            path.join("@onexapis", "core", "dist", distFileName)
+            path8.join("@onexapis", "core", "dist", distFileName)
           );
+          if (!distPath) {
+            distPath = await resolveNodeModulesFile(
+              __dirname,
+              path8.join("@onexapis", "core", "dist", distFileName)
+            );
+          }
           try {
             if (!distPath) throw new Error("not found");
             const distContent = await fs7.readFile(distPath, "utf-8");
@@ -164,7 +153,7 @@ function createCoreGlobalPlugin(themePath) {
               namedExports.push(...names);
             }
             namedExports = [...new Set(namedExports)];
-          } catch (e) {
+          } catch {
           }
           exportsBySubpath[cacheKey] = namedExports;
         }
@@ -198,60 +187,60 @@ ${namedExportLines}
 }
 async function generateThemeData(themePath, outputDir, themeId) {
   const { createJiti } = await import('jiti');
-  const jiti = createJiti(import_meta.url);
+  const jiti = createJiti(import.meta.url);
   let themeConfig = null;
   let layoutConfig = null;
   const pages = {};
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path.join(themePath, `theme.config${ext}`));
+      const mod = await jiti.import(path8.join(themePath, `theme.config${ext}`));
       themeConfig = mod.default || mod;
       break;
-    } catch (e) {
+    } catch {
     }
   }
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path.join(themePath, `theme.layout${ext}`));
+      const mod = await jiti.import(path8.join(themePath, `theme.layout${ext}`));
       layoutConfig = mod.default || mod;
       break;
-    } catch (e) {
+    } catch {
     }
   }
-  const pagesDir = path.join(themePath, "pages");
+  const pagesDir = path8.join(themePath, "pages");
   try {
     const files = await fs7.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(path.join(pagesDir, file));
+        const mod = await jiti.import(path8.join(pagesDir, file));
         const config = mod.default || mod;
         pages[name] = {
           id: name,
           name: config.title || name,
           path: config.path || `/${name}`,
-          config: __spreadValues({ id: name }, config),
+          config: { id: name, ...config },
           sections: config.sections || [],
           seo: config.seo
         };
-      } catch (e) {
+      } catch {
       }
     }
-  } catch (e) {
+  } catch {
   }
   await fs7.writeFile(
-    path.join(outputDir, "theme-data.json"),
+    path8.join(outputDir, "theme-data.json"),
     JSON.stringify(
       {
         themeId,
         theme: {
           id: themeId,
-          name: (themeConfig == null ? void 0 : themeConfig.name) || themeId,
+          name: themeConfig?.name || themeId,
           config: themeConfig,
           layout: {
-            header: (layoutConfig == null ? void 0 : layoutConfig.headerSections) || [],
-            footer: (layoutConfig == null ? void 0 : layoutConfig.footerSections) || []
+            header: layoutConfig?.headerSections || [],
+            footer: layoutConfig?.footerSections || []
           },
           pages: Object.keys(pages)
         },
@@ -261,42 +250,40 @@ async function generateThemeData(themePath, outputDir, themeId) {
       2
     )
   );
-  logger.info(
-    `Generated theme-data.json (${Object.keys(pages).length} pages)`
-  );
+  logger.info(`Generated theme-data.json (${Object.keys(pages).length} pages)`);
 }
 async function contentHashEntry(outputDir) {
-  const entryPath = path.join(outputDir, "bundle-entry.js");
-  const mapPath = path.join(outputDir, "bundle-entry.js.map");
+  const entryPath = path8.join(outputDir, "bundle-entry.js");
+  const mapPath = path8.join(outputDir, "bundle-entry.js.map");
   const oldFiles = await glob("bundle-entry-*.js*", { cwd: outputDir });
   for (const f of oldFiles) {
-    await fs7.unlink(path.join(outputDir, f));
+    await fs7.unlink(path8.join(outputDir, f));
   }
   let entryContent;
   try {
     entryContent = await fs7.readFile(entryPath, "utf-8");
-  } catch (e) {
-    const indexPath = path.join(outputDir, "index.js");
+  } catch {
+    const indexPath = path8.join(outputDir, "index.js");
     try {
       entryContent = await fs7.readFile(indexPath, "utf-8");
-    } catch (e2) {
+    } catch {
       logger.warning("No entry file found in output, skipping content hash");
       return;
     }
     const hash2 = crypto.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
     const hashedName2 = `bundle-entry-${hash2}.js`;
-    const indexMapPath = path.join(outputDir, "index.js.map");
+    const indexMapPath = path8.join(outputDir, "index.js.map");
     const hashedMapName2 = `bundle-entry-${hash2}.js.map`;
     entryContent = entryContent.replace(
       /\/\/# sourceMappingURL=index\.js\.map/,
       `//# sourceMappingURL=${hashedMapName2}`
     );
-    await fs7.writeFile(path.join(outputDir, hashedName2), entryContent);
+    await fs7.writeFile(path8.join(outputDir, hashedName2), entryContent);
     await fs7.unlink(indexPath);
     try {
       await fs7.access(indexMapPath);
-      await fs7.rename(indexMapPath, path.join(outputDir, hashedMapName2));
-    } catch (e2) {
+      await fs7.rename(indexMapPath, path8.join(outputDir, hashedMapName2));
+    } catch {
     }
     logger.info(`Entry hashed: ${hashedName2}`);
     return;
@@ -308,21 +295,43 @@ async function contentHashEntry(outputDir) {
     /\/\/# sourceMappingURL=bundle-entry\.js\.map/,
     `//# sourceMappingURL=${hashedMapName}`
   );
-  await fs7.writeFile(path.join(outputDir, hashedName), entryContent);
+  await fs7.writeFile(path8.join(outputDir, hashedName), entryContent);
   await fs7.unlink(entryPath);
   try {
     await fs7.access(mapPath);
-    await fs7.rename(mapPath, path.join(outputDir, hashedMapName));
-  } catch (e) {
+    await fs7.rename(mapPath, path8.join(outputDir, hashedMapName));
+  } catch {
   }
   logger.info(`Entry hashed: ${hashedName}`);
 }
+async function extractDataRequirements(themePath) {
+  const { createJiti } = await import('jiti');
+  const jiti = createJiti(import.meta.url);
+  const schemaFiles = await glob("sections/**/*.schema.ts", { cwd: themePath });
+  const requirements = {};
+  for (const file of schemaFiles) {
+    try {
+      const mod = await jiti.import(path8.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") {
+          requirements[value.type] = value.dataRequirements;
+        }
+      }
+    } catch (err) {
+      logger.warning(
+        `Could not load schema ${file}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return requirements;
+}
 async function generateManifest2(themeName, themePath, outputDir) {
   let version = "1.0.0";
   let themeId = themeName;
   try {
     const pkgContent = await fs7.readFile(
-      path.join(themePath, "package.json"),
+      path8.join(themePath, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(pkgContent);
@@ -330,18 +339,19 @@ async function generateManifest2(themeName, themePath, outputDir) {
     if (pkg.name) {
       themeId = pkg.name.replace(/^@onex-themes\//, "");
     }
-  } catch (e) {
+  } catch {
   }
   const [sectionFiles, blockFiles, schemaFiles] = await Promise.all([
     glob("sections/**/index.ts", { cwd: themePath }),
     glob("blocks/**/index.ts", { cwd: themePath }),
     glob("**/*.schema.ts", { cwd: themePath })
   ]);
+  const dataRequirements = await extractDataRequirements(themePath);
   let hasThemeConfig = false;
   try {
-    await fs7.access(path.join(themePath, "theme.config.ts"));
+    await fs7.access(path8.join(themePath, "theme.config.ts"));
     hasThemeConfig = true;
-  } catch (e) {
+  } catch {
   }
   const allFiles = await glob("**/*", { cwd: outputDir, nodir: true });
   const jsFiles = allFiles.filter((f) => f.endsWith(".js"));
@@ -376,24 +386,26 @@ async function generateManifest2(themeName, themePath, outputDir) {
       blocks: blockFiles,
       schemas: schemaFiles,
       hasThemeConfig
-    }
+    },
+    // Section data requirements for server-side prefetching (keyed by section type)
+    dataRequirements
   };
   await fs7.writeFile(
-    path.join(outputDir, "manifest.json"),
+    path8.join(outputDir, "manifest.json"),
     JSON.stringify(manifest, null, 2)
   );
 }
 async function compileStandaloneTheme(themePath, themeName) {
-  const outputDir = path.join(themePath, "dist");
-  const bundleEntry = path.join(themePath, "bundle-entry.ts");
-  const indexEntry = path.join(themePath, "index.ts");
+  const outputDir = path8.join(themePath, "dist");
+  const bundleEntry = path8.join(themePath, "bundle-entry.ts");
+  const indexEntry = path8.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
     await fs7.access(bundleEntry);
     entryPoint = bundleEntry;
-  } catch (e) {
+  } catch {
   }
-  const shimPath = path.join(outputDir, ".process-shim.js");
+  const shimPath = path8.join(outputDir, ".process-shim.js");
   await fs7.mkdir(outputDir, { recursive: true });
   await fs7.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
@@ -442,7 +454,7 @@ async function compileStandaloneTheme(themePath, themeName) {
     const result = await esbuild.build(buildOptions);
     try {
       await fs7.unlink(shimPath);
-    } catch (e) {
+    } catch {
     }
     await contentHashEntry(outputDir);
     await generateManifest2(themeName, themePath, outputDir);
@@ -460,23 +472,23 @@ async function compileStandaloneTheme(themePath, themeName) {
   } catch (error) {
     try {
       await fs7.unlink(shimPath);
-    } catch (e) {
+    } catch {
     }
     logger.error(`esbuild compilation failed: ${error}`);
     return false;
   }
 }
 async function compileStandaloneThemeDev(themePath, themeName) {
-  const outputDir = path.join(themePath, "dist");
-  const bundleEntry = path.join(themePath, "bundle-entry.ts");
-  const indexEntry = path.join(themePath, "index.ts");
+  const outputDir = path8.join(themePath, "dist");
+  const bundleEntry = path8.join(themePath, "bundle-entry.ts");
+  const indexEntry = path8.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
     await fs7.access(bundleEntry);
     entryPoint = bundleEntry;
-  } catch (e) {
+  } catch {
   }
-  const shimPath = path.join(outputDir, ".process-shim.js");
+  const shimPath = path8.join(outputDir, ".process-shim.js");
   await fs7.mkdir(outputDir, { recursive: true });
   await fs7.writeFile(shimPath, PROCESS_SHIM);
   const buildOptions = {
@@ -527,13 +539,13 @@ async function compileStandaloneThemeDev(themePath, themeName) {
   return { context: context2, outputDir };
 }
 async function compilePreviewRuntime(themePath) {
-  const outputDir = path.join(themePath, "dist");
+  const outputDir = path8.join(themePath, "dist");
   await fs7.mkdir(outputDir, { recursive: true });
-  const outputPath = path.join(outputDir, "preview-runtime.js");
+  const outputPath = path8.join(outputDir, "preview-runtime.js");
   const locations = [
-    path.join(__dirname, "..", "preview", "preview-app.tsx"),
-    path.join(__dirname, "preview", "preview-app.tsx"),
-    path.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
+    path8.join(__dirname, "..", "preview", "preview-app.tsx"),
+    path8.join(__dirname, "preview", "preview-app.tsx"),
+    path8.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
   ];
   let previewEntryPath = null;
   for (const loc of locations) {
@@ -541,7 +553,7 @@ async function compilePreviewRuntime(themePath) {
       await fs7.access(loc);
       previewEntryPath = loc;
       break;
-    } catch (e) {
+    } catch {
     }
   }
   if (!previewEntryPath) {
@@ -581,10 +593,13 @@ ${locations.join("\n")}`
         "zlib"
       ];
       for (const mod of nodeBuiltins) {
-        build2.onResolve({ filter: new RegExp(`^${mod.replace("/", "\\/")}$`) }, () => ({
-          path: mod,
-          namespace: "node-stub"
-        }));
+        build2.onResolve(
+          { filter: new RegExp(`^${mod.replace("/", "\\/")}$`) },
+          () => ({
+            path: mod,
+            namespace: "node-stub"
+          })
+        );
       }
       build2.onLoad({ filter: /.*/, namespace: "node-stub" }, (args) => {
         const stubs = {
@@ -598,8 +613,7 @@ ${locations.join("\n")}`
         };
       });
       build2.onResolve({ filter: /^lucide-react/ }, async (args) => {
-        var _a;
-        if ((_a = args.pluginData) == null ? void 0 : _a.skipStub) return void 0;
+        if (args.pluginData?.skipStub) return void 0;
         try {
           const result = await build2.resolve(args.path, {
             kind: args.kind,
@@ -609,7 +623,7 @@ ${locations.join("\n")}`
             pluginData: { skipStub: true }
           });
           if (!result.errors.length) return result;
-        } catch (e) {
+        } catch {
         }
         return { path: args.path, namespace: "lucide-stub" };
       });
@@ -631,8 +645,7 @@ export default new Proxy({}, { get: (_, name) => name === '__esModule' ? true :
         loader: "jsx"
       }));
       build2.onResolve({ filter: /^framer-motion/ }, async (args) => {
-        var _a;
-        if ((_a = args.pluginData) == null ? void 0 : _a.skipStub) return void 0;
+        if (args.pluginData?.skipStub) return void 0;
         try {
           const result = await build2.resolve(args.path, {
             kind: args.kind,
@@ -642,7 +655,7 @@ export default new Proxy({}, { get: (_, name) => name === '__esModule' ? true :
             pluginData: { skipStub: true }
           });
           if (!result.errors.length) return result;
-        } catch (e) {
+        } catch {
         }
         return { path: args.path, namespace: "motion-stub" };
       });
@@ -656,8 +669,59 @@ export default { motion, AnimatePresence };
         `.trim(),
         loader: "jsx"
       }));
+      build2.onResolve({ filter: /^next\// }, async (args) => {
+        if (args.pluginData?.skipStub) return void 0;
+        try {
+          const result = await build2.resolve(args.path, {
+            kind: args.kind,
+            resolveDir: args.resolveDir,
+            importer: args.importer,
+            namespace: "file",
+            pluginData: { skipStub: true }
+          });
+          if (!result.errors.length) return result;
+        } catch {
+        }
+        return { path: args.path, namespace: "next-stub" };
+      });
+      build2.onLoad({ filter: /.*/, namespace: "next-stub" }, (args) => {
+        const stubs = {
+          "next/image": `
+const Image = (props) => {
+  const { src, alt, width, height, fill, priority, ...rest } = props;
+  const imgSrc = typeof src === 'object' ? src.src : src;
+  return React.createElement('img', { src: imgSrc, alt, width: fill ? undefined : width, height: fill ? undefined : height, loading: priority ? 'eager' : 'lazy', ...rest });
+};
+import React from 'react';
+export default Image;
+          `,
+          "next/link": `
+const Link = ({ href, children, ...rest }) => React.createElement('a', { href, ...rest }, children);
+import React from 'react';
+export default Link;
+          `,
+          "next/navigation": `
+export function useRouter() { return { push(u){window.location.href=u}, replace(u){window.location.href=u}, back(){window.history.back()}, forward(){window.history.forward()}, refresh(){window.location.reload()}, prefetch(){} }; }
+export function usePathname() { return window.location.pathname; }
+export function useSearchParams() { return new URLSearchParams(window.location.search); }
+export function useParams() { return {}; }
+export function redirect(url) { window.location.href = url; }
+export function notFound() { throw new Error('Not Found'); }
+          `,
+          "next/headers": `
+export function cookies() { return { get(){}, getAll(){ return []; }, set(){}, delete(){}, has(){ return false; } }; }
+export function headers() { return new Headers(); }
+          `
+        };
+        return {
+          contents: stubs[args.path] || "export default {};",
+          loader: "jsx"
+        };
+      });
     }
   };
+  const shimPath = path8.join(outputDir, ".process-shim-preview.js");
+  await fs7.writeFile(shimPath, PROCESS_SHIM);
   await esbuild.build({
     entryPoints: [previewEntryPath],
     bundle: true,
@@ -667,6 +731,7 @@ export default { motion, AnimatePresence };
     // Bundle React + core INTO the output (NOT externalized)
     external: [],
     plugins: [serverStubPlugin],
+    inject: [shimPath],
     minify: false,
     sourcemap: true,
     target: "es2020",
@@ -674,6 +739,12 @@ export default { motion, AnimatePresence };
     jsxImportSource: "react",
     define: {
       "process.env.NODE_ENV": JSON.stringify("development"),
+      "process.env.NEXT_PUBLIC_API_URL": JSON.stringify(
+        process.env.NEXT_PUBLIC_API_URL || ""
+      ),
+      "process.env.NEXT_PUBLIC_COMPANY_ID": JSON.stringify(
+        process.env.NEXT_PUBLIC_COMPANY_ID || ""
+      ),
       global: "globalThis"
     },
     loader: { ".tsx": "tsx", ".ts": "ts" },
@@ -684,13 +755,16 @@ export default { motion, AnimatePresence };
       "ignored-bare-import": "silent"
     }
   });
+  try {
+    await fs7.unlink(shimPath);
+  } catch {
+  }
   return outputPath;
 }
-var import_meta, PROCESS_SHIM, reactGlobalPlugin;
+var PROCESS_SHIM, reactGlobalPlugin;
 var init_compile_theme = __esm({
   "src/utils/compile-theme.ts"() {
     init_logger();
-    import_meta = {};
     PROCESS_SHIM = `
 if (typeof process === "undefined") {
   globalThis.process = {
@@ -815,18 +889,18 @@ async function renderTemplate(templatePath, data) {
   return ejs.render(template, data);
 }
 async function writeFile(filePath, content) {
-  await fs.ensureDir(path.dirname(filePath));
+  await fs.ensureDir(path8.dirname(filePath));
   await fs.writeFile(filePath, content, "utf-8");
 }
 function getTemplatesDir() {
   const locations = [
-    path.join(__dirname, "../../templates"),
+    path8.join(__dirname, "../../templates"),
     // Development
-    path.join(__dirname, "../templates"),
+    path8.join(__dirname, "../templates"),
     // Production (dist/)
-    path.join(process.cwd(), "templates"),
+    path8.join(process.cwd(), "templates"),
     // Fallback
-    path.join(process.cwd(), "packages/cli/templates")
+    path8.join(process.cwd(), "packages/cli/templates")
     // Monorepo
   ];
   for (const location of locations) {
@@ -838,7 +912,7 @@ function getTemplatesDir() {
 }
 async function copyTemplate(templateName, targetDir, data) {
   const templatesDir = getTemplatesDir();
-  const templateDir = path.join(templatesDir, templateName);
+  const templateDir = path8.join(templatesDir, templateName);
   if (!fs.existsSync(templateDir)) {
     throw new Error(
       `Template "${templateName}" not found at ${templateDir}. Available templates: ${fs.readdirSync(templatesDir).join(", ")}`
@@ -847,8 +921,8 @@ async function copyTemplate(templateName, targetDir, data) {
   await fs.ensureDir(targetDir);
   const files = await fs.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path.join(templateDir, file);
-    const targetPath = path.join(targetDir, file);
+    const templatePath = path8.join(templateDir, file);
+    const targetPath = path8.join(targetDir, file);
     const stat = await fs.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -865,8 +939,8 @@ async function copyTemplateDir(templateDir, targetDir, data) {
   await fs.ensureDir(targetDir);
   const files = await fs.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path.join(templateDir, file);
-    const targetPath = path.join(targetDir, file);
+    const templatePath = path8.join(templateDir, file);
+    const targetPath = path8.join(targetDir, file);
     const stat = await fs.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
@@ -881,32 +955,32 @@ async function copyTemplateDir(templateDir, targetDir, data) {
 }
 function getProjectRoot() {
   let currentDir = process.cwd();
-  while (currentDir !== path.parse(currentDir).root) {
-    const packageJsonPath = path.join(currentDir, "package.json");
+  while (currentDir !== path8.parse(currentDir).root) {
+    const packageJsonPath = path8.join(currentDir, "package.json");
     if (fs.existsSync(packageJsonPath)) {
       const packageJson = fs.readJsonSync(packageJsonPath);
-      if (packageJson.workspaces || fs.existsSync(path.join(currentDir, "src/themes")) || fs.existsSync(path.join(currentDir, "themes"))) {
+      if (packageJson.workspaces || fs.existsSync(path8.join(currentDir, "src/themes")) || fs.existsSync(path8.join(currentDir, "themes"))) {
         return currentDir;
       }
     }
-    currentDir = path.dirname(currentDir);
+    currentDir = path8.dirname(currentDir);
   }
   return process.cwd();
 }
 function getThemesDir() {
   const root = getProjectRoot();
-  if (fs.existsSync(path.join(root, "themes")))
-    return path.join(root, "themes");
-  if (fs.existsSync(path.join(root, "src/themes")))
-    return path.join(root, "src/themes");
-  return path.dirname(root);
+  if (fs.existsSync(path8.join(root, "themes")))
+    return path8.join(root, "themes");
+  if (fs.existsSync(path8.join(root, "src/themes")))
+    return path8.join(root, "src/themes");
+  return path8.dirname(root);
 }
 function getFeaturesDir() {
-  return path.join(getProjectRoot(), "src/features");
+  return path8.join(getProjectRoot(), "src/features");
 }
 function isOneXProject() {
   const root = getProjectRoot();
-  return fs.existsSync(path.join(root, "themes")) || fs.existsSync(path.join(root, "src/themes")) || fs.existsSync(path.join(root, "theme.config.ts")) || fs.existsSync(path.join(root, "bundle-entry.ts"));
+  return fs.existsSync(path8.join(root, "themes")) || fs.existsSync(path8.join(root, "src/themes")) || fs.existsSync(path8.join(root, "theme.config.ts")) || fs.existsSync(path8.join(root, "bundle-entry.ts"));
 }
 function ensureOneXProject() {
   if (!isOneXProject()) {
@@ -922,13 +996,13 @@ function listThemes() {
     return [];
   }
   return fs.readdirSync(themesDir).filter((name) => {
-    const themePath = path.join(themesDir, name);
-    return fs.statSync(themePath).isDirectory() && (fs.existsSync(path.join(themePath, "theme.config.ts")) || fs.existsSync(path.join(themePath, "bundle-entry.ts")) || fs.existsSync(path.join(themePath, "manifest.ts")));
+    const themePath = path8.join(themesDir, name);
+    return fs.statSync(themePath).isDirectory() && (fs.existsSync(path8.join(themePath, "theme.config.ts")) || fs.existsSync(path8.join(themePath, "bundle-entry.ts")) || fs.existsSync(path8.join(themePath, "manifest.ts")));
   });
 }
 function themeExists(themeName) {
-  const themePath = path.join(getThemesDir(), themeName);
-  return fs.existsSync(themePath) && (fs.existsSync(path.join(themePath, "theme.config.ts")) || fs.existsSync(path.join(themePath, "bundle-entry.ts")) || fs.existsSync(path.join(themePath, "manifest.ts")));
+  const themePath = path8.join(getThemesDir(), themeName);
+  return fs.existsSync(themePath) && (fs.existsSync(path8.join(themePath, "theme.config.ts")) || fs.existsSync(path8.join(themePath, "bundle-entry.ts")) || fs.existsSync(path8.join(themePath, "manifest.ts")));
 }
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
@@ -936,9 +1010,9 @@ function detectPackageManager() {
   if (userAgent.includes("yarn")) return "yarn";
   if (userAgent.includes("bun")) return "bun";
   const cwd = process.cwd();
-  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs.existsSync(path.join(cwd, "bun.lockb"))) return "bun";
+  if (fs.existsSync(path8.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path8.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path8.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 async function installDependencies(projectPath, packageManager = "npm") {
@@ -1004,7 +1078,7 @@ async function initCommand(projectName, options = {}) {
           if (!validateThemeName(kebabName)) {
             return "Invalid project name. Use lowercase letters, numbers, and hyphens only.";
           }
-          if (fs2.existsSync(path.join(process.cwd(), kebabName))) {
+          if (fs2.existsSync(path8.join(process.cwd(), kebabName))) {
             return `Directory "${kebabName}" already exists`;
           }
           return true;
@@ -1015,7 +1089,7 @@ async function initCommand(projectName, options = {}) {
   } else {
     name = toKebabCase(projectName);
   }
-  const projectPath = path.join(process.cwd(), name);
+  const projectPath = path8.join(process.cwd(), name);
   if (fs2.existsSync(projectPath)) {
     logger.error(`Directory "${name}" already exists.`);
     process.exit(1);
@@ -1078,38 +1152,38 @@ async function initCommand(projectName, options = {}) {
   try {
     fs2.mkdirSync(projectPath, { recursive: true });
     await copyTemplate(template, projectPath, data);
-    const srcPath = path.join(projectPath, "src");
+    const srcPath = path8.join(projectPath, "src");
     fs2.mkdirSync(srcPath, { recursive: true });
     const manifestContent = generateManifest(data);
-    await writeFile(path.join(srcPath, "manifest.ts"), manifestContent);
+    await writeFile(path8.join(srcPath, "manifest.ts"), manifestContent);
     const configContent = generateThemeConfig(data);
-    await writeFile(path.join(srcPath, "config.ts"), configContent);
+    await writeFile(path8.join(srcPath, "config.ts"), configContent);
     const layoutContent = generateThemeLayout(data);
-    await writeFile(path.join(srcPath, "layout.ts"), layoutContent);
+    await writeFile(path8.join(srcPath, "layout.ts"), layoutContent);
     const indexContent = generateThemeIndex(data);
-    await writeFile(path.join(srcPath, "index.ts"), indexContent);
-    const sectionsPath = path.join(srcPath, "sections");
+    await writeFile(path8.join(srcPath, "index.ts"), indexContent);
+    const sectionsPath = path8.join(srcPath, "sections");
     fs2.mkdirSync(sectionsPath, { recursive: true });
     await writeFile(
-      path.join(sectionsPath, "README.md"),
+      path8.join(sectionsPath, "README.md"),
       `# ${displayName} Sections
 
 Add your theme-specific sections here.
 `
     );
-    const blocksPath = path.join(srcPath, "blocks");
+    const blocksPath = path8.join(srcPath, "blocks");
     fs2.mkdirSync(blocksPath, { recursive: true });
     await writeFile(
-      path.join(blocksPath, "README.md"),
+      path8.join(blocksPath, "README.md"),
       `# ${displayName} Blocks
 
 Add your theme-specific blocks here.
 `
     );
-    const pagesPath = path.join(srcPath, "pages");
+    const pagesPath = path8.join(srcPath, "pages");
     fs2.mkdirSync(pagesPath, { recursive: true });
     const homePageContent = generateHomePage(data);
-    await writeFile(path.join(pagesPath, "home.ts"), homePageContent);
+    await writeFile(path8.join(pagesPath, "home.ts"), homePageContent);
     logger.stopSpinner(true, "Project structure created!");
     if (options.git) {
       logger.startSpinner("Initializing git repository...");
@@ -1121,7 +1195,7 @@ Add your theme-specific blocks here.
           stdio: "ignore"
         });
         logger.stopSpinner(true, "Git repository initialized!");
-      } catch (e) {
+      } catch {
         logger.stopSpinner(false, "Failed to initialize git");
       }
     }
@@ -1132,7 +1206,7 @@ Add your theme-specific blocks here.
       try {
         await installDependencies(projectPath, packageManager);
         logger.stopSpinner(true, "Dependencies installed!");
-      } catch (e) {
+      } catch {
         logger.stopSpinner(false, "Failed to install dependencies");
         logger.info(
           "You can install dependencies manually by running: cd " + name + " && npm install"
@@ -1408,10 +1482,10 @@ async function createSectionCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs.existsSync(path.join(process.cwd(), f))
+      (f) => fs.existsSync(path8.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path.basename(process.cwd());
+      options.theme = path8.basename(process.cwd());
     }
   }
   const sectionName = toKebabCase(name);
@@ -1474,35 +1548,35 @@ async function createSectionCommand(name, options) {
   };
   logger.startSpinner("Creating section files...");
   try {
-    const themePath = path.join(getThemesDir(), themeName);
-    const sectionPath = path.join(themePath, "sections", sectionName);
+    const themePath = path8.join(getThemesDir(), themeName);
+    const sectionPath = path8.join(themePath, "sections", sectionName);
     const schemaContent = generateSectionSchema(data);
     await writeFile(
-      path.join(sectionPath, `${sectionName}.schema.ts`),
+      path8.join(sectionPath, `${sectionName}.schema.ts`),
       schemaContent
     );
     if (createTemplate) {
       const templateContent = generateSectionTemplate(data);
       await writeFile(
-        path.join(sectionPath, `${sectionName}-default.tsx`),
+        path8.join(sectionPath, `${sectionName}-default.tsx`),
         templateContent
       );
     }
     const indexContent = generateSectionIndex(data, createTemplate);
-    await writeFile(path.join(sectionPath, "index.ts"), indexContent);
+    await writeFile(path8.join(sectionPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Section files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path.relative(process.cwd(), path.join(sectionPath, `${sectionName}.schema.ts`))}`
+      `  1. Edit schema: ${path8.relative(process.cwd(), path8.join(sectionPath, `${sectionName}.schema.ts`))}`
     );
     if (createTemplate) {
       logger.log(
-        `  2. Edit template: ${path.relative(process.cwd(), path.join(sectionPath, `${sectionName}-default.tsx`))}`
+        `  2. Edit template: ${path8.relative(process.cwd(), path8.join(sectionPath, `${sectionName}-default.tsx`))}`
       );
     }
     logger.log(
-      `  3. Add to theme manifest: ${path.relative(process.cwd(), path.join(themePath, "manifest.ts"))}`
+      `  3. Add to theme manifest: ${path8.relative(process.cwd(), path8.join(themePath, "manifest.ts"))}`
     );
     logger.newLine();
     logger.success("Section created successfully!");
@@ -1650,10 +1724,10 @@ async function createBlockCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs.existsSync(path.join(process.cwd(), f))
+      (f) => fs.existsSync(path8.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path.basename(process.cwd());
+      options.theme = path8.basename(process.cwd());
     }
   }
   const blockName = toKebabCase(name);
@@ -1728,24 +1802,24 @@ async function createBlockCommand(name, options) {
   };
   logger.startSpinner("Creating block files...");
   try {
-    const blockPath = scope === "shared" ? path.join(getFeaturesDir(), "blocks", blockName) : path.join(getThemesDir(), themeName, "blocks", blockName);
+    const blockPath = scope === "shared" ? path8.join(getFeaturesDir(), "blocks", blockName) : path8.join(getThemesDir(), themeName, "blocks", blockName);
     const schemaContent = generateBlockSchema(data);
     await writeFile(
-      path.join(blockPath, `${blockName}.schema.ts`),
+      path8.join(blockPath, `${blockName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateBlockComponent(data);
-    await writeFile(path.join(blockPath, `${blockName}.tsx`), componentContent);
+    await writeFile(path8.join(blockPath, `${blockName}.tsx`), componentContent);
     const indexContent = generateBlockIndex(data);
-    await writeFile(path.join(blockPath, "index.ts"), indexContent);
+    await writeFile(path8.join(blockPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Block files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path.relative(process.cwd(), path.join(blockPath, `${blockName}.schema.ts`))}`
+      `  1. Edit schema: ${path8.relative(process.cwd(), path8.join(blockPath, `${blockName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path.relative(process.cwd(), path.join(blockPath, `${blockName}.tsx`))}`
+      `  2. Edit component: ${path8.relative(process.cwd(), path8.join(blockPath, `${blockName}.tsx`))}`
     );
     logger.log(
       `  3. Register in block registry: src/lib/registry/block-registry.ts`
@@ -1923,31 +1997,31 @@ async function createComponentCommand(name, options) {
   };
   logger.startSpinner("Creating component files...");
   try {
-    const componentPath = path.join(
+    const componentPath = path8.join(
       getFeaturesDir(),
       "components",
       componentName
     );
     const schemaContent = generateComponentSchema(data);
     await writeFile(
-      path.join(componentPath, `${componentName}.schema.ts`),
+      path8.join(componentPath, `${componentName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateComponent(data);
     await writeFile(
-      path.join(componentPath, `${componentName}.tsx`),
+      path8.join(componentPath, `${componentName}.tsx`),
       componentContent
     );
     const indexContent = generateComponentIndex(data);
-    await writeFile(path.join(componentPath, "index.ts"), indexContent);
+    await writeFile(path8.join(componentPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Component files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path.relative(process.cwd(), path.join(componentPath, `${componentName}.schema.ts`))}`
+      `  1. Edit schema: ${path8.relative(process.cwd(), path8.join(componentPath, `${componentName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path.relative(process.cwd(), path.join(componentPath, `${componentName}.tsx`))}`
+      `  2. Edit component: ${path8.relative(process.cwd(), path8.join(componentPath, `${componentName}.tsx`))}`
     );
     logger.log(
       `  3. Register in component registry: src/lib/registry/component-registry.ts`
@@ -2104,13 +2178,13 @@ async function listSections(themeFilter) {
     return;
   }
   for (const theme of themes) {
-    const sectionsDir = path.join(getThemesDir(), theme, "sections");
+    const sectionsDir = path8.join(getThemesDir(), theme, "sections");
     if (!fs.existsSync(sectionsDir)) {
       continue;
     }
     const sections = fs.readdirSync(sectionsDir).filter((name) => {
-      const sectionPath = path.join(sectionsDir, name);
-      return fs.statSync(sectionPath).isDirectory() && fs.existsSync(path.join(sectionPath, "index.ts"));
+      const sectionPath = path8.join(sectionsDir, name);
+      return fs.statSync(sectionPath).isDirectory() && fs.existsSync(path8.join(sectionPath, "index.ts"));
     });
     if (sections.length > 0) {
       logger.log(chalk4.cyan(`
@@ -2124,11 +2198,11 @@ async function listSections(themeFilter) {
 }
 async function listBlocks(themeFilter) {
   logger.section("\u{1F9F1} Blocks");
-  const sharedBlocksDir = path.join(getFeaturesDir(), "blocks");
+  const sharedBlocksDir = path8.join(getFeaturesDir(), "blocks");
   if (fs.existsSync(sharedBlocksDir)) {
     const sharedBlocks = fs.readdirSync(sharedBlocksDir).filter((name) => {
-      const blockPath = path.join(sharedBlocksDir, name);
-      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path.join(blockPath, "index.ts"));
+      const blockPath = path8.join(sharedBlocksDir, name);
+      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path8.join(blockPath, "index.ts"));
     });
     if (sharedBlocks.length > 0) {
       logger.log(chalk4.cyan("\n  Shared:"));
@@ -2139,13 +2213,13 @@ async function listBlocks(themeFilter) {
   }
   const themes = themeFilter ? [themeFilter] : listThemes();
   for (const theme of themes) {
-    const blocksDir = path.join(getThemesDir(), theme, "blocks");
+    const blocksDir = path8.join(getThemesDir(), theme, "blocks");
     if (!fs.existsSync(blocksDir)) {
       continue;
     }
     const blocks = fs.readdirSync(blocksDir).filter((name) => {
-      const blockPath = path.join(blocksDir, name);
-      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path.join(blockPath, "index.ts"));
+      const blockPath = path8.join(blocksDir, name);
+      return fs.statSync(blockPath).isDirectory() && fs.existsSync(path8.join(blockPath, "index.ts"));
     });
     if (blocks.length > 0) {
       logger.log(chalk4.cyan(`
@@ -2159,14 +2233,14 @@ async function listBlocks(themeFilter) {
 }
 async function listComponents() {
   logger.section("\u2699\uFE0F  Components");
-  const componentsDir = path.join(getFeaturesDir(), "components");
+  const componentsDir = path8.join(getFeaturesDir(), "components");
   if (!fs.existsSync(componentsDir)) {
     logger.warning("No components directory found");
     return;
   }
   const components = fs.readdirSync(componentsDir).filter((name) => {
-    const componentPath = path.join(componentsDir, name);
-    return fs.statSync(componentPath).isDirectory() && fs.existsSync(path.join(componentPath, "index.ts"));
+    const componentPath = path8.join(componentsDir, name);
+    return fs.statSync(componentPath).isDirectory() && fs.existsSync(path8.join(componentPath, "index.ts"));
   });
   if (components.length === 0) {
     logger.warning("No components found");
@@ -2187,11 +2261,11 @@ async function listThemesInfo() {
   }
   logger.log("");
   for (const theme of themes) {
-    const themeDir = path.join(getThemesDir(), theme);
+    const themeDir = path8.join(getThemesDir(), theme);
     const candidates = ["theme.config.ts", "bundle-entry.ts", "manifest.ts"];
     let manifestContent = "";
     for (const candidate of candidates) {
-      const candidatePath = path.join(themeDir, candidate);
+      const candidatePath = path8.join(themeDir, candidate);
       if (fs.existsSync(candidatePath)) {
         manifestContent = fs.readFileSync(candidatePath, "utf-8");
         break;
@@ -2229,9 +2303,9 @@ async function validateCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path8.join(process.cwd(), f)));
     if (isThemeDir) {
-      themeToValidate = path.basename(process.cwd());
+      themeToValidate = path8.basename(process.cwd());
       logger.info(`Validating current theme: ${themeToValidate}`);
     } else {
       logger.error(
@@ -2240,11 +2314,11 @@ async function validateCommand(options) {
       process.exit(1);
     }
   }
-  const themePath = path.join(getThemesDir(), themeToValidate);
+  const themePath = path8.join(getThemesDir(), themeToValidate);
   logger.startSpinner("Running validation checks...");
   const entryFiles = ["manifest.ts", "theme.config.ts", "bundle-entry.ts"];
   const foundEntry = entryFiles.find(
-    (f) => fs.existsSync(path.join(themePath, f))
+    (f) => fs.existsSync(path8.join(themePath, f))
   );
   if (!foundEntry) {
     issues.push({
@@ -2254,7 +2328,7 @@ async function validateCommand(options) {
     });
   } else if (foundEntry === "manifest.ts") {
     const manifestContent = fs.readFileSync(
-      path.join(themePath, foundEntry),
+      path8.join(themePath, foundEntry),
       "utf-8"
     );
     if (!manifestContent.includes("export const") && !manifestContent.includes("export default") && !manifestContent.includes("export interface")) {
@@ -2265,7 +2339,7 @@ async function validateCommand(options) {
       });
     }
   }
-  const configPath = path.join(themePath, "theme.config.ts");
+  const configPath = path8.join(themePath, "theme.config.ts");
   if (!fs.existsSync(configPath)) {
     issues.push({
       type: "warning",
@@ -2273,7 +2347,7 @@ async function validateCommand(options) {
       message: "Theme config file not found (recommended)"
     });
   }
-  const indexPath = path.join(themePath, "index.ts");
+  const indexPath = path8.join(themePath, "index.ts");
   if (!fs.existsSync(indexPath)) {
     issues.push({
       type: "warning",
@@ -2281,7 +2355,7 @@ async function validateCommand(options) {
       message: "Index file not found (recommended)"
     });
   }
-  const sectionsDir = path.join(themePath, "sections");
+  const sectionsDir = path8.join(themePath, "sections");
   if (!fs.existsSync(sectionsDir)) {
     issues.push({
       type: "warning",
@@ -2290,16 +2364,16 @@ async function validateCommand(options) {
     });
   } else {
     const sections = fs.readdirSync(sectionsDir).filter(
-      (name) => fs.statSync(path.join(sectionsDir, name)).isDirectory()
+      (name) => fs.statSync(path8.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
-      const sectionPath = path.join(sectionsDir, sectionName);
-      const schemaFile = path.join(sectionPath, `${sectionName}.schema.ts`);
-      const defaultTemplate = path.join(
+      const sectionPath = path8.join(sectionsDir, sectionName);
+      const schemaFile = path8.join(sectionPath, `${sectionName}.schema.ts`);
+      const defaultTemplate = path8.join(
         sectionPath,
         `${sectionName}-default.tsx`
       );
-      const indexFile = path.join(sectionPath, "index.ts");
+      const indexFile = path8.join(sectionPath, "index.ts");
       if (!fs.existsSync(schemaFile)) {
         issues.push({
           type: "error",
@@ -2323,14 +2397,14 @@ async function validateCommand(options) {
       }
     }
   }
-  const blocksDir = path.join(themePath, "blocks");
+  const blocksDir = path8.join(themePath, "blocks");
   if (fs.existsSync(blocksDir)) {
-    const blocks = fs.readdirSync(blocksDir).filter((name) => fs.statSync(path.join(blocksDir, name)).isDirectory());
+    const blocks = fs.readdirSync(blocksDir).filter((name) => fs.statSync(path8.join(blocksDir, name)).isDirectory());
     for (const blockName of blocks) {
-      const blockPath = path.join(blocksDir, blockName);
-      const schemaFile = path.join(blockPath, `${blockName}.schema.ts`);
-      const componentFile = path.join(blockPath, `${blockName}.tsx`);
-      const indexFile = path.join(blockPath, "index.ts");
+      const blockPath = path8.join(blocksDir, blockName);
+      const schemaFile = path8.join(blockPath, `${blockName}.schema.ts`);
+      const componentFile = path8.join(blockPath, `${blockName}.tsx`);
+      const indexFile = path8.join(blockPath, "index.ts");
       if (!fs.existsSync(schemaFile)) {
         issues.push({
           type: "error",
@@ -2396,21 +2470,20 @@ async function validateCommand(options) {
 // src/commands/build.ts
 init_logger();
 async function buildCommand(options) {
-  var _a;
   logger.header("Build Theme");
   let themePath;
   let themeName;
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path.join(getThemesDir(), themeName);
+      const workspaceThemePath = path8.join(getThemesDir(), themeName);
       if (fs.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path.join(process.cwd(), themeName);
+        themePath = path8.join(process.cwd(), themeName);
       }
-    } catch (e) {
-      themePath = path.join(process.cwd(), themeName);
+    } catch {
+      themePath = path8.join(process.cwd(), themeName);
     }
     if (!fs.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
@@ -2421,10 +2494,10 @@ async function buildCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path8.join(process.cwd(), f)));
     if (isThemeDir) {
       themePath = process.cwd();
-      themeName = path.basename(themePath);
+      themeName = path8.basename(themePath);
       logger.info(`Building current theme: ${themeName}`);
     } else {
       logger.error(
@@ -2433,7 +2506,7 @@ async function buildCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path.join(themePath, "package.json");
+  const packageJsonPath = path8.join(themePath, "package.json");
   const hasPkgJson = fs.existsSync(packageJsonPath);
   if (!hasPkgJson) {
     logger.warning(
@@ -2466,7 +2539,7 @@ async function buildCommand(options) {
   }
   logger.stopSpinner(true, "Lint passed");
   const pkgJson = fs.readJsonSync(packageJsonPath);
-  const buildScript = ((_a = pkgJson.scripts) == null ? void 0 : _a.build) || "";
+  const buildScript = pkgJson.scripts?.build || "";
   const isRecursive = buildScript.includes("onex build") || buildScript.includes("onex-cli build");
   logger.startSpinner(
     options.watch ? "Building (watch mode)..." : "Building..."
@@ -2489,9 +2562,9 @@ async function buildCommand(options) {
     logger.success("\u2713 Theme built successfully!");
     logger.newLine();
     logger.info(`Theme: ${themeName}`);
-    const distPath = path.join(themePath, "dist");
+    const distPath = path8.join(themePath, "dist");
     if (fs.existsSync(distPath)) {
-      logger.log(`Output: ${path.relative(process.cwd(), distPath)}`);
+      logger.log(`Output: ${path8.relative(process.cwd(), distPath)}`);
       const files = fs.readdirSync(distPath);
       logger.log(`Files: ${files.length}`);
     }
@@ -2529,7 +2602,7 @@ async function packageCommand(options) {
   let themeName;
   if (options.theme) {
     themeName = options.theme;
-    themePath = path.join(getThemesDir(), themeName);
+    themePath = path8.join(getThemesDir(), themeName);
     if (!fs.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
       process.exit(1);
@@ -2539,10 +2612,10 @@ async function packageCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path8.join(process.cwd(), f)));
     if (isThemeDir) {
       themePath = process.cwd();
-      themeName = path.basename(themePath);
+      themeName = path8.basename(themePath);
       logger.info(`Packaging current theme: ${themeName}`);
     } else {
       logger.error(
@@ -2551,7 +2624,7 @@ async function packageCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path.join(themePath, "package.json");
+  const packageJsonPath = path8.join(themePath, "package.json");
   let version = "1.0.0";
   if (fs.existsSync(packageJsonPath)) {
     const packageJson = await fs.readJson(packageJsonPath);
@@ -2561,7 +2634,7 @@ async function packageCommand(options) {
   logger.info(`Theme: ${themeName}`);
   logger.info(`Version: ${version}`);
   logger.newLine();
-  const compiledThemePath = path.join(
+  const compiledThemePath = path8.join(
     process.cwd(),
     "themes",
     themeName,
@@ -2595,8 +2668,8 @@ async function packageCommand(options) {
   logger.newLine();
   logger.section("Step 2: Create Package");
   const packageName = options.name || `${themeName}-${version}`;
-  const outputDir = options.output || path.join(process.cwd(), "dist");
-  const outputPath = path.join(outputDir, `${packageName}.zip`);
+  const outputDir = options.output || path8.join(process.cwd(), "dist");
+  const outputPath = path8.join(outputDir, `${packageName}.zip`);
   await fs.ensureDir(outputDir);
   logger.startSpinner("Creating zip archive...");
   try {
@@ -2609,11 +2682,11 @@ async function packageCommand(options) {
     logger.newLine();
     logger.info(`Package: ${packageName}.zip`);
     logger.log(`Size: ${sizeMB} MB`);
-    logger.log(`Location: ${path.relative(process.cwd(), outputPath)}`);
+    logger.log(`Location: ${path8.relative(process.cwd(), outputPath)}`);
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  onex deploy --package ${path.relative(process.cwd(), outputPath)}`
+      `  onex deploy --package ${path8.relative(process.cwd(), outputPath)}`
     );
   } catch (error) {
     logger.stopSpinner(false, "Failed to create package");
@@ -2671,9 +2744,9 @@ async function deployCommand(options) {
   ensureOneXProject();
   let packagePath;
   if (options.package) {
-    packagePath = path.resolve(options.package);
+    packagePath = path8.resolve(options.package);
   } else if (options.theme) {
-    const distDir = path.join(process.cwd(), "dist");
+    const distDir = path8.join(process.cwd(), "dist");
     if (!fs.existsSync(distDir)) {
       logger.error("No dist/ directory found. Run 'onex package' first.");
       process.exit(1);
@@ -2688,7 +2761,7 @@ async function deployCommand(options) {
       process.exit(1);
     }
     packageFiles.sort().reverse();
-    packagePath = path.join(distDir, packageFiles[0]);
+    packagePath = path8.join(distDir, packageFiles[0]);
   } else {
     logger.error("Either --package or --theme must be specified.");
     logger.info("Examples:");
@@ -2702,11 +2775,11 @@ async function deployCommand(options) {
   }
   const stats = await fs.stat(packagePath);
   const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-  const fileName = path.basename(packagePath);
+  const fileName = path8.basename(packagePath);
   logger.newLine();
   logger.info(`Package: ${fileName}`);
   logger.log(`Size: ${sizeMB} MB`);
-  logger.log(`Path: ${path.relative(process.cwd(), packagePath)}`);
+  logger.log(`Path: ${path8.relative(process.cwd(), packagePath)}`);
   logger.newLine();
   const apiUrl = options.apiUrl || process.env.ONEX_API_URL || "http://localhost:3001";
   const uploadEndpoint = `${apiUrl}/api/themes/upload`;
@@ -2810,11 +2883,11 @@ function getBucketName(env) {
   return environment === "production" ? "onex-themes-prod" : "onex-themes-staging";
 }
 async function findCompiledThemeDir(themeId, version) {
-  const searchPaths = [path.resolve(process.cwd(), "dist")];
+  const searchPaths = [path8.resolve(process.cwd(), "dist")];
   for (const dir of searchPaths) {
     if (await fs.pathExists(dir)) {
-      const hasManifest = await fs.pathExists(path.join(dir, "manifest.json"));
-      const hasThemeEntry = await fs.pathExists(path.join(dir, "bundle-entry.js")) || await fs.pathExists(path.join(dir, "theme.config.js")) || await fs.pathExists(path.join(dir, "index.js"));
+      const hasManifest = await fs.pathExists(path8.join(dir, "manifest.json"));
+      const hasThemeEntry = await fs.pathExists(path8.join(dir, "bundle-entry.js")) || await fs.pathExists(path8.join(dir, "theme.config.js")) || await fs.pathExists(path8.join(dir, "index.js"));
       if (hasManifest || hasThemeEntry) {
         return dir;
       }
@@ -2823,8 +2896,7 @@ async function findCompiledThemeDir(themeId, version) {
   return null;
 }
 async function readManifest() {
-  var _a;
-  const manifestTsPath = path.resolve(process.cwd(), "manifest.ts");
+  const manifestTsPath = path8.resolve(process.cwd(), "manifest.ts");
   if (await fs.pathExists(manifestTsPath)) {
     try {
       const module = await import(manifestTsPath);
@@ -2833,11 +2905,11 @@ async function readManifest() {
       logger.warning("Failed to import manifest.ts, trying package.json");
     }
   }
-  const packageJsonPath = path.resolve(process.cwd(), "package.json");
+  const packageJsonPath = path8.resolve(process.cwd(), "package.json");
   if (await fs.pathExists(packageJsonPath)) {
     const pkg = await fs.readJson(packageJsonPath);
     return {
-      themeId: ((_a = pkg.name) == null ? void 0 : _a.replace("@onex-themes/", "")) || "unknown",
+      themeId: pkg.name?.replace("@onex-themes/", "") || "unknown",
       version: pkg.version || "1.0.0"
     };
   }
@@ -2867,13 +2939,13 @@ async function findSourceDir(themeId, explicitDir) {
   }
   const searchPaths = [
     process.cwd(),
-    path.resolve(process.cwd(), `../../themes/${themeId}`),
-    path.resolve(process.cwd(), `../themes/${themeId}`)
+    path8.resolve(process.cwd(), `../../themes/${themeId}`),
+    path8.resolve(process.cwd(), `../themes/${themeId}`)
   ];
   const markers = ["theme.config.ts", "bundle-entry.ts"];
   for (const dir of searchPaths) {
     for (const marker of markers) {
-      if (await fs.pathExists(path.join(dir, marker))) {
+      if (await fs.pathExists(path8.join(dir, marker))) {
         return dir;
       }
     }
@@ -2925,7 +2997,7 @@ async function uploadCommand(options) {
     spinner.succeed(`Found compiled theme at: ${compiledDir}`);
     spinner.start("Creating bundle.zip...");
     const tmpDir = os.tmpdir();
-    const bundleZipPath = path.join(tmpDir, `${themeId}-${version}-bundle.zip`);
+    const bundleZipPath = path8.join(tmpDir, `${themeId}-${version}-bundle.zip`);
     await createZipFromDir(compiledDir, bundleZipPath);
     const bundleZipBuffer = await fs.readFile(bundleZipPath);
     const bundleSizeMB = (bundleZipBuffer.length / 1024 / 1024).toFixed(2);
@@ -2979,7 +3051,7 @@ async function uploadCommand(options) {
       if (sourceDir) {
         spinner.succeed(`Found source at: ${sourceDir}`);
         spinner.start("Creating source.zip...");
-        const sourceZipPath = path.join(
+        const sourceZipPath = path8.join(
           tmpDir,
           `${themeId}-${version}-source.zip`
         );
@@ -3081,39 +3153,15 @@ function getBucketName2(env) {
 }
 async function streamToString(stream) {
   const chunks = [];
-  try {
-    for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-      const chunk = temp.value;
-      chunks.push(Buffer.from(chunk));
-    }
-  } catch (temp) {
-    error = [temp];
-  } finally {
-    try {
-      more && (temp = iter.return) && await temp.call(iter);
-    } finally {
-      if (error)
-        throw error[0];
-    }
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
 async function streamToBuffer(stream) {
   const chunks = [];
-  try {
-    for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-      const chunk = temp.value;
-      chunks.push(Buffer.from(chunk));
-    }
-  } catch (temp) {
-    error = [temp];
-  } finally {
-    try {
-      more && (temp = iter.return) && await temp.call(iter);
-    } finally {
-      if (error)
-        throw error[0];
-    }
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
   }
   return Buffer.concat(chunks);
 }
@@ -3135,11 +3183,10 @@ async function resolveLatestVersion(s3Client, bucket, themeId) {
   }
 }
 async function createCompatibilityFiles(outputDir, manifest) {
-  var _a;
-  const entryFile = ((_a = manifest.output) == null ? void 0 : _a.entry) || "bundle-entry.js";
+  const entryFile = manifest.output?.entry || "bundle-entry.js";
   if (entryFile !== "bundle-entry.js" && entryFile.startsWith("bundle-entry-")) {
-    const hashedPath = path.join(outputDir, entryFile);
-    const stablePath = path.join(outputDir, "bundle-entry.js");
+    const hashedPath = path8.join(outputDir, entryFile);
+    const stablePath = path8.join(outputDir, "bundle-entry.js");
     if (await fs.pathExists(hashedPath)) {
       await fs.copy(hashedPath, stablePath);
       const mapPath = hashedPath + ".map";
@@ -3148,13 +3195,13 @@ async function createCompatibilityFiles(outputDir, manifest) {
       }
     }
   }
-  const sectionsRegistryPath = path.join(outputDir, "sections-registry.js");
+  const sectionsRegistryPath = path8.join(outputDir, "sections-registry.js");
   const content = `// Re-export all sections from bundle-entry
 // This file exists to maintain compatibility with the import path
 export * from './bundle-entry.js';
 `;
   await fs.writeFile(sectionsRegistryPath, content, "utf-8");
-  const pkgJsonPath = path.join(outputDir, "package.json");
+  const pkgJsonPath = path8.join(outputDir, "package.json");
   await fs.writeFile(pkgJsonPath, '{\n  "type": "module"\n}\n', "utf-8");
 }
 function showDownloadFailureHelp(themeId, bucket) {
@@ -3237,7 +3284,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 = path.join(outputDir, "manifest.json");
+    const manifestPath = path8.join(outputDir, "manifest.json");
     const manifest = await fs.readJson(manifestPath);
     await createCompatibilityFiles(outputDir, manifest);
     console.log();
@@ -3307,39 +3354,15 @@ function getBucketName3(env) {
 }
 async function streamToString2(stream) {
   const chunks = [];
-  try {
-    for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-      const chunk = temp.value;
-      chunks.push(Buffer.from(chunk));
-    }
-  } catch (temp) {
-    error = [temp];
-  } finally {
-    try {
-      more && (temp = iter.return) && await temp.call(iter);
-    } finally {
-      if (error)
-        throw error[0];
-    }
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
   }
   return Buffer.concat(chunks).toString("utf-8");
 }
 async function streamToBuffer2(stream) {
   const chunks = [];
-  try {
-    for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-      const chunk = temp.value;
-      chunks.push(Buffer.from(chunk));
-    }
-  } catch (temp) {
-    error = [temp];
-  } finally {
-    try {
-      more && (temp = iter.return) && await temp.call(iter);
-    } finally {
-      if (error)
-        throw error[0];
-    }
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
   }
   return Buffer.concat(chunks);
 }
@@ -3395,7 +3418,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 = path.join(themeDir, "package.json");
+  const pkgPath = path8.join(themeDir, "package.json");
   if (await fs.pathExists(pkgPath)) {
     const pkg = await fs.readJson(pkgPath);
     pkg.name = `@onex-themes/${newName}`;
@@ -3408,7 +3431,7 @@ async function renameTheme(themeDir, oldName, newName) {
     pkg.version = "1.0.0";
     await fs.writeJson(pkgPath, pkg, { spaces: 2 });
   }
-  const configPath = path.join(themeDir, "theme.config.ts");
+  const configPath = path8.join(themeDir, "theme.config.ts");
   if (await fs.pathExists(configPath)) {
     let content = await fs.readFile(configPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
@@ -3418,7 +3441,7 @@ async function renameTheme(themeDir, oldName, newName) {
     );
     await fs.writeFile(configPath, content);
   }
-  const layoutPath = path.join(themeDir, "theme.layout.ts");
+  const layoutPath = path8.join(themeDir, "theme.layout.ts");
   if (await fs.pathExists(layoutPath)) {
     let content = await fs.readFile(layoutPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
@@ -3431,7 +3454,7 @@ async function renameTheme(themeDir, oldName, newName) {
   const oldDisplayName = oldName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
   const tsFiles = await glob("**/*.ts", { cwd: themeDir, nodir: true });
   for (const file of tsFiles) {
-    const filePath = path.join(themeDir, file);
+    const filePath = path8.join(themeDir, file);
     let content = await fs.readFile(filePath, "utf-8");
     const original = content;
     content = content.replace(
@@ -3460,7 +3483,7 @@ async function cloneCommand(themeName, options) {
   const spinner = ora("Initializing clone...").start();
   try {
     const bucket = options.bucket || getBucketName3(options.environment);
-    const outputDir = options.output || path.resolve(process.cwd(), newName);
+    const outputDir = options.output || path8.resolve(process.cwd(), newName);
     const s3Client = getS3Client3();
     if (await fs.pathExists(outputDir)) {
       spinner.fail(chalk4.red(`Directory already exists: ${outputDir}`));
@@ -3515,9 +3538,22 @@ async function cloneCommand(themeName, options) {
     spinner.succeed(
       `Renamed theme: ${chalk4.gray(themeName)} \u2192 ${chalk4.cyan(newName)}`
     );
+    const envExamplePath = path8.join(outputDir, ".env.example");
+    if (!await fs.pathExists(envExamplePath)) {
+      await fs.writeFile(
+        envExamplePath,
+        [
+          "# API Configuration (enables real data in preview)",
+          "# Get your Company ID from the OneX dashboard",
+          "NEXT_PUBLIC_API_URL=https://api-dev.onexeos.com",
+          "NEXT_PUBLIC_COMPANY_ID=",
+          ""
+        ].join("\n")
+      );
+    }
     if (options.install !== false) {
       const hasPkgJson = await fs.pathExists(
-        path.join(outputDir, "package.json")
+        path8.join(outputDir, "package.json")
       );
       if (hasPkgJson) {
         spinner.start("Installing dependencies...");
@@ -3544,7 +3580,8 @@ async function cloneCommand(themeName, options) {
     console.log(chalk4.cyan("   Files:    ") + chalk4.white(entries.length));
     console.log();
     console.log(chalk4.cyan("Next steps:"));
-    console.log(chalk4.gray(`   cd ${path.relative(process.cwd(), outputDir)}`));
+    console.log(chalk4.gray(`   cd ${path8.relative(process.cwd(), outputDir)}`));
+    console.log(chalk4.gray("   cp .env.example .env  # then add your Company ID"));
     if (options.install === false) {
       console.log(chalk4.gray("   pnpm install"));
     }
@@ -3596,7 +3633,7 @@ function createDevServer(options) {
       serveFile(res, options.previewRuntimePath);
       return;
     }
-    const filePath = path.join(options.distDir, pathname);
+    const filePath = path8.join(options.distDir, pathname);
     if (!filePath.startsWith(options.distDir)) {
       res.writeHead(403);
       res.end("Forbidden");
@@ -3637,12 +3674,12 @@ function serveFile(res, filePath) {
       res.end("Not Found");
       return;
     }
-    const ext = path.extname(filePath);
+    const ext = path8.extname(filePath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     const content = fs2.readFileSync(filePath);
     res.writeHead(200, { "Content-Type": contentType });
     res.end(content);
-  } catch (e) {
+  } catch {
     res.writeHead(500);
     res.end("Internal Server Error");
   }
@@ -3697,14 +3734,14 @@ async function devCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path.join(getThemesDir(), themeName);
+      const workspaceThemePath = path8.join(getThemesDir(), themeName);
       if (fs.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path.join(process.cwd(), themeName);
+        themePath = path8.join(process.cwd(), themeName);
       }
-    } catch (e) {
-      themePath = path.join(process.cwd(), themeName);
+    } catch {
+      themePath = path8.join(process.cwd(), themeName);
     }
     if (!fs.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
@@ -3715,10 +3752,10 @@ async function devCommand(options) {
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs.existsSync(path.join(process.cwd(), f)));
+    ].some((f) => fs.existsSync(path8.join(process.cwd(), f)));
     if (isThemeDir) {
       themePath = process.cwd();
-      themeName = path.basename(themePath);
+      themeName = path8.basename(themePath);
     } else {
       logger.error(
         "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
@@ -3786,10 +3823,10 @@ async function devCommand(options) {
     watcher.close();
     await context2.dispose();
     server.close();
-    const shimPath = path.join(outputDir, ".process-shim.js");
+    const shimPath = path8.join(outputDir, ".process-shim.js");
     try {
       await fs7.unlink(shimPath);
-    } catch (e) {
+    } catch {
     }
     process.exit(0);
   });
@@ -3799,14 +3836,14 @@ async function devCommand(options) {
 try {
   const projectRoot = getProjectRoot();
   dotenv.config({
-    path: path.join(projectRoot, ".env.local"),
+    path: path8.join(projectRoot, ".env.local"),
     quiet: true
   });
-  dotenv.config({ path: path.join(projectRoot, ".env"), quiet: true });
-} catch (e) {
+  dotenv.config({ path: path8.join(projectRoot, ".env"), quiet: true });
+} catch {
 }
 dotenv.config({
-  path: path.join(os.homedir(), ".onex", ".env"),
+  path: path8.join(os.homedir(), ".onex", ".env"),
   quiet: true
 });
 var program = new Command();