@onexapis/cli 1.1.66 → 1.1.70

package/dist/cli.js

@@ -3,15 +3,15 @@
 
 var chalk4 = require('chalk');
 var ora = require('ora');
-var path11 = require('path');
+var fs3 = require('fs');
+var path13 = require('path');
 var glob = require('glob');
-var fs = require('fs-extra');
+var fs8 = require('fs-extra');
 var crypto = require('crypto');
+var fs11 = require('fs/promises');
 var esbuild = require('esbuild');
-var fs9 = require('fs/promises');
 var module$1 = require('module');
 var http = require('http');
-var fs3 = require('fs');
 var ws = require('ws');
 var os = require('os');
 var dotenv = require('dotenv');
@@ -49,13 +49,13 @@ function _interopNamespace(e) {
 
 var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
-var path11__default = /*#__PURE__*/_interopDefault(path11);
-var fs__default = /*#__PURE__*/_interopDefault(fs);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var path13__default = /*#__PURE__*/_interopDefault(path13);
+var fs8__default = /*#__PURE__*/_interopDefault(fs8);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var fs11__default = /*#__PURE__*/_interopDefault(fs11);
 var esbuild__namespace = /*#__PURE__*/_interopNamespace(esbuild);
-var fs9__default = /*#__PURE__*/_interopDefault(fs9);
 var http__default = /*#__PURE__*/_interopDefault(http);
-var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
 var ejs__default = /*#__PURE__*/_interopDefault(ejs);
@@ -132,6 +132,13 @@ var init_logger = __esm({
     logger = new Logger();
   }
 });
+function isNextjsProject(dir) {
+  return fs3__default.default.existsSync(path13__default.default.join(dir, "next.config.ts")) || fs3__default.default.existsSync(path13__default.default.join(dir, "next.config.js")) || fs3__default.default.existsSync(path13__default.default.join(dir, "next.config.mjs"));
+}
+var init_detect_nextjs = __esm({
+  "src/utils/detect-nextjs.ts"() {
+  }
+});
 function sortedCopy(value) {
   if (Array.isArray(value)) {
     return value.map((v) => sortedCopy(v));
@@ -214,7 +221,7 @@ async function extractSchemas(themePath) {
   const sections = {};
   for (const file of schemaFiles) {
     try {
-      const mod = await jiti.import(path11__default.default.join(themePath, file));
+      const mod = await jiti.import(path13__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)) {
@@ -246,24 +253,24 @@ function isVideoAsset(filePath) {
   return VIDEO_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
 function mimeFor(filename) {
-  const ext = path11__default.default.extname(filename).toLowerCase();
+  const ext = path13__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);
+  const buf = await fs8__default.default.readFile(absPath);
   return crypto__default.default.createHash("sha256").update(buf).digest("hex").slice(0, len);
 }
 function insertHashIntoName(relPath, hash) {
-  const dir = path11__default.default.posix.dirname(relPath);
-  const base = path11__default.default.posix.basename(relPath);
-  const ext = path11__default.default.posix.extname(base);
+  const dir = path13__default.default.posix.dirname(relPath);
+  const base = path13__default.default.posix.basename(relPath);
+  const ext = path13__default.default.posix.extname(base);
   const stem = ext ? base.slice(0, -ext.length) : base;
   const hashed = `${stem}-${hash}${ext}`;
   return dir === "." ? hashed : `${dir}/${hashed}`;
 }
 async function scanThemeAssets(distDir) {
-  const assetsDir = path11__default.default.join(distDir, "theme-assets");
-  if (!await fs__default.default.pathExists(assetsDir)) return [];
+  const assetsDir = path13__default.default.join(distDir, "theme-assets");
+  if (!await fs8__default.default.pathExists(assetsDir)) return [];
   const files = await glob.glob("**/*", {
     cwd: assetsDir,
     nodir: true,
@@ -271,10 +278,10 @@ async function scanThemeAssets(distDir) {
   });
   const results = [];
   for (const rel of files) {
-    const absPath = path11__default.default.join(assetsDir, rel);
-    const stat = await fs__default.default.stat(absPath);
+    const absPath = path13__default.default.join(assetsDir, rel);
+    const stat = await fs8__default.default.stat(absPath);
     if (!stat.isFile()) continue;
-    const originalPath = rel.split(path11__default.default.sep).join("/");
+    const originalPath = rel.split(path13__default.default.sep).join("/");
     const hash = await sha256Prefix(absPath, HASH_LEN);
     const hashedPath = insertHashIntoName(originalPath, hash);
     const contentType = mimeFor(rel);
@@ -332,6 +339,101 @@ var init_scan_theme_assets = __esm({
     ];
   }
 });
+async function scanAppDirectory(themePath) {
+  const appDir = path13__default.default.join(themePath, "app");
+  let pageFiles;
+  try {
+    pageFiles = await glob.glob("**/page.{tsx,ts,jsx,js}", { cwd: appDir });
+  } catch {
+    return [];
+  }
+  if (pageFiles.length === 0) return [];
+  const pages = [];
+  for (const pageFile of pageFiles) {
+    const routePath = deriveRoutePath(pageFile);
+    const absPageFile = path13__default.default.join(appDir, pageFile);
+    let source;
+    try {
+      source = await fs11__default.default.readFile(absPageFile, "utf-8");
+    } catch {
+      continue;
+    }
+    const sections = await extractSectionsFromPage(source, themePath);
+    pages.push({
+      routePath,
+      sourceFile: path13__default.default.join("app", pageFile),
+      sections
+    });
+  }
+  return pages;
+}
+function deriveRoutePath(pageFile) {
+  const dir = path13__default.default.dirname(pageFile);
+  if (dir === ".") return "/";
+  return "/" + dir;
+}
+async function extractSectionsFromPage(source, themePath) {
+  const importRegex = /import\s+\w+\s+from\s+["'](@\/|\.\.?\/)(components\/[^"']+)["']/g;
+  const sections = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of source.matchAll(importRegex)) {
+    const rawImportPath = match[2];
+    const componentDir = path13__default.default.dirname(rawImportPath);
+    const absComponentDir = path13__default.default.join(themePath, componentDir);
+    if (seen.has(componentDir)) continue;
+    seen.add(componentDir);
+    const sectionJsonPath = path13__default.default.join(absComponentDir, "section.json");
+    let sectionJson;
+    try {
+      const raw = await fs11__default.default.readFile(sectionJsonPath, "utf-8");
+      sectionJson = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (sectionJson.type !== "opaque-react") continue;
+    if (!sectionJson.entry) continue;
+    sections.push({
+      type: "opaque-react",
+      name: sectionJson.name ?? path13__default.default.basename(componentDir),
+      entry: path13__default.default.join(componentDir, sectionJson.entry),
+      componentDir
+    });
+  }
+  return sections;
+}
+function buildNextjsPagesMap(pages, themeId) {
+  const result = {};
+  for (const page of pages) {
+    const id = page.routePath === "/" ? "home" : page.routePath.replace(/\//g, "-").replace(/^-/, "");
+    const makeSectionType = (name) => `${themeId}-${name.toLowerCase().replace(/\s+/g, "-")}`;
+    result[id] = {
+      id,
+      name: id.charAt(0).toUpperCase() + id.slice(1),
+      path: page.routePath,
+      config: {
+        id,
+        path: page.routePath,
+        sections: page.sections.map((s, i) => ({
+          id: `${id}-section-${i}`,
+          type: makeSectionType(s.name),
+          sectionType: "opaque-react",
+          settings: {}
+        }))
+      },
+      sections: page.sections.map((s, i) => ({
+        id: `${id}-section-${i}`,
+        type: makeSectionType(s.name),
+        sectionType: "opaque-react",
+        settings: {}
+      }))
+    };
+  }
+  return result;
+}
+var init_nextjs_page_scanner = __esm({
+  "src/utils/nextjs-page-scanner.ts"() {
+  }
+});
 
 // src/utils/compile-theme.ts
 var compile_theme_exports = {};
@@ -347,8 +449,8 @@ async function generateThemeCSS(themePath, outDir) {
     const tailwindcss = (await import('tailwindcss')).default;
     const tailwindConfig = {
       content: [
-        path11__default.default.join(themePath, "sections/**/*.{ts,tsx}"),
-        path11__default.default.join(themePath, "components/**/*.{ts,tsx}")
+        path13__default.default.join(themePath, "sections/**/*.{ts,tsx}"),
+        path13__default.default.join(themePath, "components/**/*.{ts,tsx}")
       ],
       theme: { extend: {} },
       plugins: []
@@ -358,7 +460,7 @@ async function generateThemeCSS(themePath, outDir) {
       inputCSS,
       { from: void 0 }
     );
-    await fs9__default.default.writeFile(path11__default.default.join(outDir, "bundle.css"), result.css);
+    await fs11__default.default.writeFile(path13__default.default.join(outDir, "bundle.css"), result.css);
     logger.info("Generated bundle.css");
   } catch (err) {
     logger.warning(
@@ -369,12 +471,12 @@ async function generateThemeCSS(themePath, outDir) {
 async function resolveNodeModulesFile(startDir, relativePath) {
   let dir = startDir;
   while (true) {
-    const candidate = path11__default.default.join(dir, "node_modules", relativePath);
+    const candidate = path13__default.default.join(dir, "node_modules", relativePath);
     try {
-      await fs9__default.default.access(candidate);
+      await fs11__default.default.access(candidate);
       return candidate;
     } catch {
-      const parent = path11__default.default.dirname(dir);
+      const parent = path13__default.default.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -398,7 +500,7 @@ async function scanImportsFromPackage(sourceDir, packageName) {
   });
   for (const file of sourceFiles) {
     try {
-      const content = await fs9__default.default.readFile(path11__default.default.join(sourceDir, file), "utf-8");
+      const content = await fs11__default.default.readFile(path13__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();
@@ -452,17 +554,17 @@ function createCoreGlobalPlugin(themePath) {
           const distFileName = subpath ? `${subpath}.mjs` : "index.mjs";
           let distPath = await resolveNodeModulesFile(
             themePath,
-            path11__default.default.join("@onexapis", "core", "dist", distFileName)
+            path13__default.default.join("@onexapis", "core", "dist", distFileName)
           );
           if (!distPath) {
             distPath = await resolveNodeModulesFile(
               __dirname,
-              path11__default.default.join("@onexapis", "core", "dist", distFileName)
+              path13__default.default.join("@onexapis", "core", "dist", distFileName)
             );
           }
           try {
             if (!distPath) throw new Error("not found");
-            const distContent = await fs9__default.default.readFile(distPath, "utf-8");
+            const distContent = await fs11__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) => {
@@ -509,180 +611,6 @@ ${namedExportLines}
     }
   };
 }
-function createThemeDepsStubPlugin(themePath) {
-  return {
-    name: "theme-deps-stub",
-    setup(build2) {
-      const tryResolveOrStub = (filter, namespace) => {
-        build2.onResolve({ filter }, async (args) => {
-          if (args.pluginData?.skipStub) return void 0;
-          try {
-            const result = await build2.resolve(args.path, {
-              kind: args.kind,
-              resolveDir: args.resolveDir || themePath,
-              importer: args.importer,
-              namespace: "file",
-              pluginData: { skipStub: true }
-            });
-            if (!result.errors.length) return result;
-          } catch {
-          }
-          try {
-            const req = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)) || __filename);
-            const resolved = req.resolve(args.path);
-            if (resolved) return { path: resolved, namespace: "file" };
-          } catch {
-          }
-          return { path: args.path, namespace };
-        });
-      };
-      tryResolveOrStub(/^next\//, "next-stub");
-      build2.onLoad({ filter: /.*/, namespace: "next-stub" }, (args) => {
-        const stubs = {
-          "next/image": `
-import React from 'react';
-const Image = React.forwardRef((props, ref) => {
-  const { src, alt, width, height, fill, priority, sizes, quality, placeholder, blurDataURL, onLoad, onError, style, className, ...rest } = props;
-  const imgSrc = typeof src === 'object' ? src.src : src;
-  const fillStyle = fill ? { position: 'absolute', inset: 0, width: '100%', height: '100%', objectFit: style?.objectFit || 'cover', display: 'block' } : {};
-  const mergedStyle = { ...fillStyle, ...style };
-  return React.createElement('img', {
-    ref, src: imgSrc, alt,
-    width: fill ? undefined : width, height: fill ? undefined : height,
-    loading: priority ? 'eager' : 'lazy',
-    style: Object.keys(mergedStyle).length > 0 ? mergedStyle : undefined,
-    className, onLoad, onError, ...rest,
-  });
-});
-export default Image;
-          `,
-          "next/link": `
-import React from 'react';
-const Link = ({ href, children, ...rest }) => React.createElement('a', { href, ...rest }, children);
-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",
-          resolveDir: themePath
-        };
-      });
-      const lucideImports = /* @__PURE__ */ new Set();
-      let lucideThemeScanned = false;
-      tryResolveOrStub(/^lucide-react/, "lucide-stub");
-      build2.onLoad({ filter: /.*/, namespace: "lucide-stub" }, async () => {
-        if (!lucideThemeScanned) {
-          lucideThemeScanned = true;
-          try {
-            const scanned = await scanImportsFromPackage(
-              themePath,
-              "lucide-react"
-            );
-            for (const names of Object.values(scanned)) {
-              for (const name of names) lucideImports.add(name);
-            }
-          } catch {
-          }
-        }
-        const iconNames = [...lucideImports];
-        const exports$1 = iconNames.map((n) => `icon as ${n}`).join(", ");
-        return {
-          contents: `
-const icon = (props) => null;
-export { ${exports$1} };
-export default new Proxy({}, { get: (_, name) => name === '__esModule' ? true : icon });
-          `.trim(),
-          loader: "jsx"
-        };
-      });
-      tryResolveOrStub(/^framer-motion/, "motion-stub");
-      build2.onLoad({ filter: /.*/, namespace: "motion-stub" }, () => ({
-        contents: `
-import React from 'react';
-const handler = { get: (_, name) => {
-  if (name === '__esModule') return true;
-  return React.forwardRef((props, ref) => React.createElement(name, { ...props, ref }));
-}};
-export const motion = new Proxy({}, handler);
-export const AnimatePresence = ({ children }) => children || null;
-export function useInView() { return true; }
-export default { motion, AnimatePresence, useInView };
-        `.trim(),
-        loader: "jsx",
-        resolveDir: themePath
-      }));
-      tryResolveOrStub(/^sonner$/, "sonner-stub");
-      build2.onLoad({ filter: /.*/, namespace: "sonner-stub" }, () => ({
-        contents: `
-export const toast = new Proxy(() => {}, { get: () => () => {} });
-export const Toaster = () => null;
-export default { toast, Toaster };
-        `.trim(),
-        loader: "jsx"
-      }));
-      tryResolveOrStub(/^react-hook-form$/, "rhf-stub");
-      build2.onLoad({ filter: /.*/, namespace: "rhf-stub" }, () => ({
-        contents: `
-export function useForm() {
-  return {
-    register: () => ({}),
-    handleSubmit: (fn) => (e) => { e?.preventDefault?.(); fn({}); },
-    formState: { errors: {}, isSubmitting: false, isValid: true },
-    watch: () => undefined,
-    setValue: () => {},
-    reset: () => {},
-    control: {},
-  };
-}
-export function useController() { return { field: {}, fieldState: {} }; }
-export function useFormContext() { return useForm(); }
-        `.trim(),
-        loader: "js"
-      }));
-      tryResolveOrStub(/^@hookform\/resolvers/, "hookform-resolvers-stub");
-      build2.onLoad(
-        { filter: /.*/, namespace: "hookform-resolvers-stub" },
-        () => ({
-          contents: `export function zodResolver() { return () => ({ values: {}, errors: {} }); }`,
-          loader: "js"
-        })
-      );
-      tryResolveOrStub(/^next-intl$/, "next-intl-stub");
-      build2.onLoad({ filter: /.*/, namespace: "next-intl-stub" }, () => ({
-        contents: `
-export function useTranslations(ns) {
-  return (key) => ns ? ns + '.' + key : key;
-}
-export function useLocale() { return 'en'; }
-export function useMessages() { return {}; }
-        `.trim(),
-        loader: "js"
-      }));
-      tryResolveOrStub(/^zod$/, "zod-stub");
-      build2.onLoad({ filter: /.*/, namespace: "zod-stub" }, () => ({
-        contents: `
-const schema = () => ({ parse: (v) => v, safeParse: (v) => ({ success: true, data: v }), optional: schema, min: schema, max: schema, email: schema, url: schema, regex: schema, refine: schema, transform: schema });
-export const z = { string: schema, number: schema, boolean: schema, object: (s) => ({ ...schema(), shape: s }), array: schema, enum: schema, union: schema, literal: schema, infer: undefined };
-export default z;
-        `.trim(),
-        loader: "js"
-      }));
-    }
-  };
-}
 async function generateThemeData(themePath, outputDir, themeId) {
   const { createJiti } = await import('jiti');
   const jiti = createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)));
@@ -691,7 +619,7 @@ async function generateThemeData(themePath, outputDir, themeId) {
   const pages = {};
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path11__default.default.join(themePath, `theme.config${ext}`));
+      const mod = await jiti.import(path13__default.default.join(themePath, `theme.config${ext}`));
       themeConfig = mod.default || mod;
       break;
     } catch {
@@ -699,20 +627,20 @@ async function generateThemeData(themePath, outputDir, themeId) {
   }
   for (const ext of [".ts", ".js"]) {
     try {
-      const mod = await jiti.import(path11__default.default.join(themePath, `theme.layout${ext}`));
+      const mod = await jiti.import(path13__default.default.join(themePath, `theme.layout${ext}`));
       layoutConfig = mod.default || mod;
       break;
     } catch {
     }
   }
   const schemas = {};
-  const sectionsDir = path11__default.default.join(themePath, "sections");
+  const sectionsDir = path13__default.default.join(themePath, "sections");
   try {
-    const sectionDirs = await fs9__default.default.readdir(sectionsDir);
+    const sectionDirs = await fs11__default.default.readdir(sectionsDir);
     for (const dir of sectionDirs) {
-      const schemaFile = path11__default.default.join(sectionsDir, dir, `${dir}.schema.ts`);
+      const schemaFile = path13__default.default.join(sectionsDir, dir, `${dir}.schema.ts`);
       try {
-        await fs9__default.default.access(schemaFile);
+        await fs11__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) {
@@ -724,14 +652,14 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  const pagesDir = path11__default.default.join(themePath, "pages");
+  const pagesDir = path13__default.default.join(themePath, "pages");
   try {
-    const files = await fs9__default.default.readdir(pagesDir);
+    const files = await fs11__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(path11__default.default.join(pagesDir, file));
+        const mod = await jiti.import(path13__default.default.join(pagesDir, file));
         const config = mod.default || mod;
         const sections = (config.sections || []).map((section) => {
           const schema = schemas[section.type];
@@ -759,8 +687,16 @@ async function generateThemeData(themePath, outputDir, themeId) {
     }
   } catch {
   }
-  await fs9__default.default.writeFile(
-    path11__default.default.join(outputDir, "theme-data.json"),
+  if (isNextjsProject(themePath)) {
+    const nextjsPages = await scanAppDirectory(themePath);
+    if (nextjsPages.length > 0) {
+      const nextjsPagesMap = buildNextjsPagesMap(nextjsPages, themeId);
+      Object.assign(pages, nextjsPagesMap);
+      logger.info(`Scanned ${nextjsPages.length} Next.js app/ pages`);
+    }
+  }
+  await fs11__default.default.writeFile(
+    path13__default.default.join(outputDir, "theme-data.json"),
     JSON.stringify(
       {
         themeId,
@@ -783,22 +719,22 @@ async function generateThemeData(themePath, outputDir, themeId) {
   logger.info(`Generated theme-data.json (${Object.keys(pages).length} pages)`);
 }
 async function contentHashEntry(outputDir) {
-  const entryPath = path11__default.default.join(outputDir, "bundle-entry.js");
-  const mapPath = path11__default.default.join(outputDir, "bundle-entry.js.map");
+  const entryPath = path13__default.default.join(outputDir, "bundle-entry.js");
+  const mapPath = path13__default.default.join(outputDir, "bundle-entry.js.map");
   let entryContent;
   try {
-    entryContent = await fs9__default.default.readFile(entryPath, "utf-8");
+    entryContent = await fs11__default.default.readFile(entryPath, "utf-8");
   } catch {
-    const indexPath = path11__default.default.join(outputDir, "index.js");
+    const indexPath = path13__default.default.join(outputDir, "index.js");
     try {
-      entryContent = await fs9__default.default.readFile(indexPath, "utf-8");
+      entryContent = await fs11__default.default.readFile(indexPath, "utf-8");
     } catch {
       logger.warning("No entry file found in output, skipping content hash");
       return;
     }
     const hash2 = crypto__default.default.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
     const hashedName2 = `bundle-entry-${hash2}.js`;
-    const indexMapPath = path11__default.default.join(outputDir, "index.js.map");
+    const indexMapPath = path13__default.default.join(outputDir, "index.js.map");
     const hashedMapName2 = `bundle-entry-${hash2}.js.map`;
     entryContent = entryContent.replace(
       /\/\/# sourceMappingURL=index\.js\.map/,
@@ -806,18 +742,18 @@ async function contentHashEntry(outputDir) {
     );
     const oldFiles2 = await glob.glob("bundle-entry-*.js*", { cwd: outputDir });
     for (const f of oldFiles2) {
-      await fs9__default.default.unlink(path11__default.default.join(outputDir, f));
+      await fs11__default.default.unlink(path13__default.default.join(outputDir, f));
     }
-    await fs9__default.default.writeFile(path11__default.default.join(outputDir, hashedName2), entryContent);
-    await fs9__default.default.unlink(indexPath);
+    await fs11__default.default.writeFile(path13__default.default.join(outputDir, hashedName2), entryContent);
+    await fs11__default.default.unlink(indexPath);
     try {
-      await fs9__default.default.unlink(entryPath);
+      await fs11__default.default.unlink(entryPath);
     } catch {
     }
-    await fs9__default.default.writeFile(entryPath, entryContent);
+    await fs11__default.default.writeFile(entryPath, entryContent);
     try {
-      await fs9__default.default.access(indexMapPath);
-      await fs9__default.default.rename(indexMapPath, path11__default.default.join(outputDir, hashedMapName2));
+      await fs11__default.default.access(indexMapPath);
+      await fs11__default.default.rename(indexMapPath, path13__default.default.join(outputDir, hashedMapName2));
     } catch {
     }
     logger.info(`Entry hashed: ${hashedName2}`);
@@ -832,17 +768,17 @@ async function contentHashEntry(outputDir) {
   );
   const oldFiles = await glob.glob("bundle-entry-*.js*", { cwd: outputDir });
   for (const f of oldFiles) {
-    await fs9__default.default.unlink(path11__default.default.join(outputDir, f));
+    await fs11__default.default.unlink(path13__default.default.join(outputDir, f));
   }
-  await fs9__default.default.writeFile(path11__default.default.join(outputDir, hashedName), entryContent);
+  await fs11__default.default.writeFile(path13__default.default.join(outputDir, hashedName), entryContent);
   try {
-    await fs9__default.default.unlink(entryPath);
+    await fs11__default.default.unlink(entryPath);
   } catch {
   }
-  await fs9__default.default.writeFile(entryPath, entryContent);
+  await fs11__default.default.writeFile(entryPath, entryContent);
   try {
-    await fs9__default.default.access(mapPath);
-    await fs9__default.default.rename(mapPath, path11__default.default.join(outputDir, hashedMapName));
+    await fs11__default.default.access(mapPath);
+    await fs11__default.default.rename(mapPath, path13__default.default.join(outputDir, hashedMapName));
   } catch {
   }
   logger.info(`Entry hashed: ${hashedName}`);
@@ -854,7 +790,7 @@ async function extractDataRequirements(themePath) {
   const requirements = {};
   for (const file of schemaFiles) {
     try {
-      const mod = await jiti.import(path11__default.default.join(themePath, file));
+      const mod = await jiti.import(path13__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") {
@@ -872,8 +808,8 @@ async function extractDataRequirements(themePath) {
 async function writeGateManifests(themePath, outputDir) {
   try {
     const schemas = await extractSchemas(themePath);
-    await fs9__default.default.writeFile(
-      path11__default.default.join(outputDir, "schemas.json"),
+    await fs11__default.default.writeFile(
+      path13__default.default.join(outputDir, "schemas.json"),
       serializeManifest(schemas)
     );
     logger.info(
@@ -892,8 +828,8 @@ async function writeGateManifests(themePath, outputDir) {
       size: e.size,
       contentType: e.contentType
     }));
-    await fs9__default.default.writeFile(
-      path11__default.default.join(outputDir, "asset-manifest.json"),
+    await fs11__default.default.writeFile(
+      path13__default.default.join(outputDir, "asset-manifest.json"),
       JSON.stringify({ manifestVersion: 1, assets }, null, 2)
     );
     logger.info(`Generated asset-manifest.json (${assets.length} assets)`);
@@ -903,12 +839,71 @@ async function writeGateManifests(themePath, outputDir) {
     );
   }
 }
+async function compileSections(themePath, outputDir) {
+  const sectionsDir = path13__default.default.join(themePath, "sections");
+  let sectionDirs;
+  try {
+    sectionDirs = await fs11__default.default.readdir(sectionsDir);
+  } catch {
+    return;
+  }
+  for (const dirName of sectionDirs) {
+    const sectionSrc = path13__default.default.join(sectionsDir, dirName);
+    const sectionOut = path13__default.default.join(outputDir, "sections", dirName);
+    let section = null;
+    try {
+      const raw = await fs11__default.default.readFile(
+        path13__default.default.join(sectionSrc, "section.manifest.json"),
+        "utf-8"
+      );
+      section = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    switch (section.type) {
+      case "editable":
+      case "opaque-react":
+        break;
+      case "html": {
+        await fs11__default.default.mkdir(sectionOut, { recursive: true });
+        const htmlSrc = path13__default.default.join(sectionSrc, section.html);
+        let htmlContent = await fs11__default.default.readFile(htmlSrc, "utf-8");
+        htmlContent = htmlContent.replace(
+          /<script[^>]+src=["']https?:\/\/[^"']*["'][^>]*><\/script>/gi,
+          ""
+        );
+        await fs11__default.default.writeFile(path13__default.default.join(sectionOut, path13__default.default.basename(section.html)), htmlContent);
+        if (section.css) {
+          await fs11__default.default.copyFile(
+            path13__default.default.join(sectionSrc, section.css),
+            path13__default.default.join(sectionOut, path13__default.default.basename(section.css))
+          );
+        }
+        break;
+      }
+      case "iframe":
+        break;
+      case "webcomponent": {
+        await fs11__default.default.mkdir(sectionOut, { recursive: true });
+        await fs11__default.default.copyFile(
+          path13__default.default.join(sectionSrc, section.bundle),
+          path13__default.default.join(sectionOut, path13__default.default.basename(section.bundle))
+        );
+        break;
+      }
+      default:
+        throw new Error(
+          `Unknown section type. Valid types: editable, opaque-react, html, iframe, webcomponent`
+        );
+    }
+  }
+}
 async function generateManifest(themeName, themePath, outputDir) {
   let version2 = "1.0.0";
   let themeId = themeName;
   try {
-    const pkgContent = await fs9__default.default.readFile(
-      path11__default.default.join(themePath, "package.json"),
+    const pkgContent = await fs11__default.default.readFile(
+      path13__default.default.join(themePath, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(pkgContent);
@@ -926,7 +921,7 @@ async function generateManifest(themeName, themePath, outputDir) {
   const dataRequirements = await extractDataRequirements(themePath);
   let hasThemeConfig = false;
   try {
-    await fs9__default.default.access(path11__default.default.join(themePath, "theme.config.ts"));
+    await fs11__default.default.access(path13__default.default.join(themePath, "theme.config.ts"));
     hasThemeConfig = true;
   } catch {
   }
@@ -967,24 +962,34 @@ async function generateManifest(themeName, themePath, outputDir) {
     // Section data requirements for server-side prefetching (keyed by section type)
     dataRequirements
   };
-  await fs9__default.default.writeFile(
-    path11__default.default.join(outputDir, "manifest.json"),
+  await fs11__default.default.writeFile(
+    path13__default.default.join(outputDir, "manifest.json"),
     JSON.stringify(manifest, null, 2)
   );
 }
 async function compileStandaloneTheme(themePath, themeName) {
-  const outputDir = path11__default.default.join(themePath, "dist");
-  const bundleEntry = path11__default.default.join(themePath, "bundle-entry.ts");
-  const indexEntry = path11__default.default.join(themePath, "index.ts");
+  const outputDir = path13__default.default.join(themePath, "dist");
+  const isNextjs = isNextjsProject(themePath);
+  if (isNextjs) {
+    logger.info("Detected Next.js project \u2014 using next/* shims");
+  }
+  const bundleEntry = path13__default.default.join(themePath, "bundle-entry.ts");
+  const indexEntry = path13__default.default.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs9__default.default.access(bundleEntry);
+    await fs11__default.default.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path11__default.default.join(outputDir, ".process-shim.js");
-  await fs9__default.default.mkdir(outputDir, { recursive: true });
-  await fs9__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path13__default.default.join(outputDir, ".process-shim.js");
+  await fs11__default.default.mkdir(outputDir, { recursive: true });
+  await fs11__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const plugins = [
+    reactGlobalPlugin,
+    reactQueryGlobalPlugin,
+    createCoreGlobalPlugin(themePath)
+  ];
+  if (isNextjs) plugins.unshift(nextShimPlugin);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -996,12 +1001,7 @@ async function compileStandaloneTheme(themePath, themeName) {
     banner: {
       js: '"use client";'
     },
-    plugins: [
-      reactGlobalPlugin,
-      reactQueryGlobalPlugin,
-      createCoreGlobalPlugin(themePath),
-      createThemeDepsStubPlugin(themePath)
-    ],
+    plugins,
     external: [],
     alias: {
       events: "events/",
@@ -1035,15 +1035,16 @@ async function compileStandaloneTheme(themePath, themeName) {
   try {
     const result = await esbuild__namespace.build(buildOptions);
     try {
-      await fs9__default.default.unlink(shimPath);
+      await fs11__default.default.unlink(shimPath);
     } catch {
     }
+    await compileSections(themePath, outputDir);
     await contentHashEntry(outputDir);
-    const themeAssetsDir = path11__default.default.join(themePath, "assets");
-    const distThemeAssets = path11__default.default.join(outputDir, "theme-assets");
+    const themeAssetsDir = path13__default.default.join(themePath, "assets");
+    const distThemeAssets = path13__default.default.join(outputDir, "theme-assets");
     try {
-      await fs9__default.default.access(themeAssetsDir);
-      await fs9__default.default.cp(themeAssetsDir, distThemeAssets, { recursive: true });
+      await fs11__default.default.access(themeAssetsDir);
+      await fs11__default.default.cp(themeAssetsDir, distThemeAssets, { recursive: true });
       logger.info("Copied static assets to dist/theme-assets/");
     } catch {
     }
@@ -1063,7 +1064,7 @@ async function compileStandaloneTheme(themePath, themeName) {
     return true;
   } catch (error) {
     try {
-      await fs9__default.default.unlink(shimPath);
+      await fs11__default.default.unlink(shimPath);
     } catch {
     }
     logger.error(`esbuild compilation failed: ${error}`);
@@ -1071,18 +1072,25 @@ async function compileStandaloneTheme(themePath, themeName) {
   }
 }
 async function compileStandaloneThemeDev(themePath, themeName) {
-  const outputDir = path11__default.default.join(themePath, "dist");
-  const bundleEntry = path11__default.default.join(themePath, "bundle-entry.ts");
-  const indexEntry = path11__default.default.join(themePath, "index.ts");
+  const outputDir = path13__default.default.join(themePath, "dist");
+  const isNextjs = isNextjsProject(themePath);
+  const bundleEntry = path13__default.default.join(themePath, "bundle-entry.ts");
+  const indexEntry = path13__default.default.join(themePath, "index.ts");
   let entryPoint = indexEntry;
   try {
-    await fs9__default.default.access(bundleEntry);
+    await fs11__default.default.access(bundleEntry);
     entryPoint = bundleEntry;
   } catch {
   }
-  const shimPath = path11__default.default.join(outputDir, ".process-shim.js");
-  await fs9__default.default.mkdir(outputDir, { recursive: true });
-  await fs9__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path13__default.default.join(outputDir, ".process-shim.js");
+  await fs11__default.default.mkdir(outputDir, { recursive: true });
+  await fs11__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const devPlugins = [
+    reactGlobalPlugin,
+    reactQueryGlobalPlugin,
+    createCoreGlobalPlugin(themePath)
+  ];
+  if (isNextjs) devPlugins.unshift(nextShimPlugin);
   const buildOptions = {
     entryPoints: [entryPoint],
     bundle: true,
@@ -1093,12 +1101,7 @@ async function compileStandaloneThemeDev(themePath, themeName) {
     banner: {
       js: '"use client";'
     },
-    plugins: [
-      reactGlobalPlugin,
-      reactQueryGlobalPlugin,
-      createCoreGlobalPlugin(themePath),
-      createThemeDepsStubPlugin(themePath)
-    ],
+    plugins: devPlugins,
     external: [],
     alias: {
       events: "events/",
@@ -1136,18 +1139,18 @@ async function compileStandaloneThemeDev(themePath, themeName) {
   return { context: context2, outputDir };
 }
 async function compilePreviewRuntime(themePath) {
-  const outputDir = path11__default.default.join(themePath, "dist");
-  await fs9__default.default.mkdir(outputDir, { recursive: true });
-  const outputPath = path11__default.default.join(outputDir, "preview-runtime.js");
+  const outputDir = path13__default.default.join(themePath, "dist");
+  await fs11__default.default.mkdir(outputDir, { recursive: true });
+  const outputPath = path13__default.default.join(outputDir, "preview-runtime.js");
   const locations = [
-    path11__default.default.join(__dirname, "..", "preview", "preview-app.tsx"),
-    path11__default.default.join(__dirname, "preview", "preview-app.tsx"),
-    path11__default.default.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
+    path13__default.default.join(__dirname, "..", "preview", "preview-app.tsx"),
+    path13__default.default.join(__dirname, "preview", "preview-app.tsx"),
+    path13__default.default.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
   ];
   let previewEntryPath = null;
   for (const loc of locations) {
     try {
-      await fs9__default.default.access(loc);
+      await fs11__default.default.access(loc);
       previewEntryPath = loc;
       break;
     } catch {
@@ -1230,10 +1233,10 @@ ${locations.join("\n")}`
         if (!lucideScanned) {
           lucideScanned = true;
           const coreSrcCandidates = [
-            path11__default.default.join(themePath, "node_modules", "@onexapis", "core", "src"),
-            path11__default.default.join(themePath, "..", "..", "packages", "core", "src"),
+            path13__default.default.join(themePath, "node_modules", "@onexapis", "core", "src"),
+            path13__default.default.join(themePath, "..", "..", "packages", "core", "src"),
             // monorepo sibling
-            path11__default.default.join(
+            path13__default.default.join(
               __dirname,
               "..",
               "..",
@@ -1248,7 +1251,7 @@ ${locations.join("\n")}`
           let coreSourceDir = null;
           for (const candidate of coreSrcCandidates) {
             try {
-              await fs9__default.default.access(candidate);
+              await fs11__default.default.access(candidate);
               coreSourceDir = candidate;
               break;
             } catch {
@@ -1267,21 +1270,21 @@ ${locations.join("\n")}`
             }
           } else {
             const coreDistCandidates = [
-              path11__default.default.join(themePath, "node_modules", "@onexapis", "core", "dist")
+              path13__default.default.join(themePath, "node_modules", "@onexapis", "core", "dist")
             ];
             const resolvedDist = await resolveNodeModulesFile(
               __dirname,
-              path11__default.default.join("@onexapis", "core", "dist")
+              path13__default.default.join("@onexapis", "core", "dist")
             );
             if (resolvedDist) coreDistCandidates.push(resolvedDist);
             for (const candidate of coreDistCandidates) {
               try {
-                await fs9__default.default.access(candidate);
+                await fs11__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 fs9__default.default.readFile(
-                    path11__default.default.join(candidate, file),
+                  const content = await fs11__default.default.readFile(
+                    path13__default.default.join(candidate, file),
                     "utf-8"
                   );
                   for (const match of content.matchAll(importRegex)) {
@@ -1336,7 +1339,7 @@ export default new Proxy({}, { get: (_, name) => name === '__esModule' ? true :
           const req = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)) || __filename);
           const cjsPath = req.resolve("framer-motion");
           const pkgDir = cjsPath.replace(/[/\\]dist[/\\].*$/, "");
-          const esmEntry = path11__default.default.join(pkgDir, "dist", "es", "index.mjs");
+          const esmEntry = path13__default.default.join(pkgDir, "dist", "es", "index.mjs");
           const { existsSync } = await import('fs');
           if (existsSync(esmEntry)) {
             return { path: esmEntry, namespace: "file" };
@@ -1435,8 +1438,8 @@ export function headers() { return new Headers(); }
       });
     }
   };
-  const shimPath = path11__default.default.join(outputDir, ".process-shim-preview.js");
-  await fs9__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const shimPath = path13__default.default.join(outputDir, ".process-shim-preview.js");
+  await fs11__default.default.writeFile(shimPath, PROCESS_SHIM);
   await esbuild__namespace.build({
     entryPoints: [previewEntryPath],
     bundle: true,
@@ -1471,17 +1474,19 @@ export function headers() { return new Headers(); }
     }
   });
   try {
-    await fs9__default.default.unlink(shimPath);
+    await fs11__default.default.unlink(shimPath);
   } catch {
   }
   return outputPath;
 }
-var PROCESS_SHIM, reactGlobalPlugin, reactQueryGlobalPlugin;
+var PROCESS_SHIM, reactGlobalPlugin, reactQueryGlobalPlugin, nextShimPlugin;
 var init_compile_theme = __esm({
   "src/utils/compile-theme.ts"() {
     init_logger();
     init_extract_schemas();
     init_scan_theme_assets();
+    init_detect_nextjs();
+    init_nextjs_page_scanner();
     PROCESS_SHIM = `
 if (typeof process === "undefined") {
   globalThis.process = {
@@ -1627,6 +1632,145 @@ export const {
         }));
       }
     };
+    nextShimPlugin = {
+      name: "next-shim",
+      setup(build2) {
+        for (const serverModule of ["next/headers", "next/server", "next/cache"]) {
+          build2.onResolve({ filter: new RegExp(`^${serverModule.replace("/", "\\/")}`) }, (args) => ({
+            path: args.path,
+            namespace: "next-server-error"
+          }));
+        }
+        build2.onLoad({ filter: /.*/, namespace: "next-server-error" }, (args) => ({
+          errors: [
+            {
+              text: `"${args.path}" is server-only and cannot be used in a OneX theme bundle. Use client-side equivalents or remove the import.`
+            }
+          ]
+        }));
+        build2.onResolve({ filter: /^next\/navigation$/ }, () => ({
+          path: "next-navigation-shim",
+          namespace: "next-shim"
+        }));
+        build2.onLoad({ filter: /^next-navigation-shim$/, namespace: "next-shim" }, () => ({
+          contents: `
+export function usePathname() {
+  if (typeof window === 'undefined') return '/';
+  return window.location.pathname;
+}
+export function useSearchParams() {
+  if (typeof window === 'undefined') return new URLSearchParams();
+  return new URLSearchParams(window.location.search);
+}
+export function useParams() {
+  if (typeof window === 'undefined') return {};
+  return (globalThis.__ONEX_ROUTE_PARAMS__) ?? {};
+}
+export function useRouter() {
+  return {
+    push(url) { if (typeof window !== 'undefined') window.location.href = url; },
+    replace(url) { if (typeof window !== 'undefined') window.location.replace(url); },
+    back() { if (typeof window !== 'undefined') window.history.back(); },
+    forward() { if (typeof window !== 'undefined') window.history.forward(); },
+    refresh() { if (typeof window !== 'undefined') window.location.reload(); },
+    prefetch() {},
+  };
+}
+export function redirect(url) {
+  if (typeof window !== 'undefined') window.location.href = url;
+  throw new Error('redirect');
+}
+export function notFound() { throw new Error('not-found'); }
+      `.trim(),
+          loader: "js"
+        }));
+        build2.onResolve({ filter: /^next\/font\// }, () => ({
+          path: "next-font-shim",
+          namespace: "next-shim"
+        }));
+        build2.onLoad({ filter: /^next-font-shim$/, namespace: "next-shim" }, () => ({
+          contents: `
+function makeFont(family) {
+  return function(_opts) {
+    return {
+      className: '',
+      style: { fontFamily: family + ', system-ui, sans-serif' },
+      variable: '--font-' + family.toLowerCase().replace(/\\s+/g, '-'),
+    };
+  };
+}
+export const Inter = makeFont('Inter');
+export const Roboto = makeFont('Roboto');
+export const Open_Sans = makeFont('Open Sans');
+export const Lato = makeFont('Lato');
+export const Montserrat = makeFont('Montserrat');
+export const Poppins = makeFont('Poppins');
+export const Raleway = makeFont('Raleway');
+export const Nunito = makeFont('Nunito');
+export const Geist = makeFont('Geist');
+export const Geist_Mono = makeFont('Geist Mono');
+export const DM_Sans = makeFont('DM Sans');
+export const Plus_Jakarta_Sans = makeFont('Plus Jakarta Sans');
+export function localFont(_opts) {
+  return { className: '', style: { fontFamily: 'system-ui, sans-serif' }, variable: '--font-local' };
+}
+      `.trim(),
+          loader: "js"
+        }));
+        build2.onResolve({ filter: /^next\/dynamic$/ }, () => ({
+          path: "next-dynamic-shim",
+          namespace: "next-shim"
+        }));
+        build2.onLoad({ filter: /^next-dynamic-shim$/, namespace: "next-shim" }, () => ({
+          contents: `
+import { lazy, Suspense, createElement } from 'react';
+export default function dynamic(loader, opts) {
+  const Lazy = lazy(loader);
+  return function DynamicComponent(props) {
+    return createElement(Suspense, { fallback: opts?.loading ? createElement(opts.loading) : null },
+      createElement(Lazy, props));
+  };
+}
+      `.trim(),
+          loader: "js"
+        }));
+        build2.onResolve({ filter: /^next\/image$/ }, () => ({
+          path: "next-image-shim",
+          namespace: "next-shim"
+        }));
+        build2.onLoad({ filter: /^next-image-shim$/, namespace: "next-shim" }, () => ({
+          contents: `
+import { createElement } from 'react';
+export default function Image({ src, alt, width, height, style, className, ...rest }) {
+  return createElement('img', { src, alt, width, height, style, className, ...rest });
+}
+      `.trim(),
+          loader: "js"
+        }));
+        build2.onResolve({ filter: /^next\/link$/ }, () => ({
+          path: "next-link-shim",
+          namespace: "next-shim"
+        }));
+        build2.onLoad({ filter: /^next-link-shim$/, namespace: "next-shim" }, () => ({
+          contents: `
+import { createElement } from 'react';
+export default function Link({ href, children, className, style, ...rest }) {
+  return createElement('a', { href, className, style, ...rest }, children);
+}
+      `.trim(),
+          loader: "js"
+        }));
+        build2.onResolve({ filter: /^next\// }, () => ({
+          path: "next-noop-shim",
+          namespace: "next-shim"
+        }));
+        build2.onLoad({ filter: /^next-noop-shim$/, namespace: "next-shim" }, () => ({
+          contents: `export default {};
+`,
+          loader: "js"
+        }));
+      }
+    };
   }
 });
 
@@ -1637,7 +1781,7 @@ __export(dev_server_exports, {
 });
 function createDevServer(options) {
   const clients = /* @__PURE__ */ new Set();
-  const themeDataPath = path11__default.default.join(options.distDir, "theme-data.json");
+  const themeDataPath = path13__default.default.join(options.distDir, "theme-data.json");
   const server = http__default.default.createServer((req, res) => {
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
@@ -1663,8 +1807,8 @@ function createDevServer(options) {
     if (pathname.startsWith("/_assets/")) {
       const parts = pathname.replace(/^\/_assets\//, "").split("/");
       const assetSubpath = parts.slice(1).join("/");
-      const assetPath = path11__default.default.join(options.themePath, "assets", assetSubpath);
-      if (!assetPath.startsWith(path11__default.default.join(options.themePath, "assets"))) {
+      const assetPath = path13__default.default.join(options.themePath, "assets", assetSubpath);
+      if (!assetPath.startsWith(path13__default.default.join(options.themePath, "assets"))) {
         res.writeHead(403);
         res.end("Forbidden");
         return;
@@ -1675,8 +1819,8 @@ function createDevServer(options) {
     if (pathname.startsWith("/themes/")) {
       const match = pathname.match(/^\/themes\/[^/]+\/assets\/(.+)/);
       if (match) {
-        const assetPath = path11__default.default.join(options.themePath, "assets", match[1]);
-        if (!assetPath.startsWith(path11__default.default.join(options.themePath, "assets"))) {
+        const assetPath = path13__default.default.join(options.themePath, "assets", match[1]);
+        if (!assetPath.startsWith(path13__default.default.join(options.themePath, "assets"))) {
           res.writeHead(403);
           res.end("Forbidden");
           return;
@@ -1688,26 +1832,26 @@ function createDevServer(options) {
     if (pathname.startsWith("/assets/")) {
       const subpath = pathname.replace(/^\/assets\//, "");
       const segments = subpath.split("/");
-      const assetsBase = path11__default.default.join(options.themePath, "assets");
+      const assetsBase = path13__default.default.join(options.themePath, "assets");
       let assetPath;
       if (segments[0] === options.themeName || segments[0] === options.themeName.replace(/^my-/, "")) {
-        assetPath = path11__default.default.join(assetsBase, segments.slice(1).join("/"));
+        assetPath = path13__default.default.join(assetsBase, segments.slice(1).join("/"));
       } else {
-        assetPath = path11__default.default.join(assetsBase, subpath);
+        assetPath = path13__default.default.join(assetsBase, subpath);
       }
       if (assetPath.startsWith(assetsBase) && fs3__default.default.existsSync(assetPath)) {
         serveFile(res, assetPath);
         return;
       }
       if (segments.length > 1) {
-        const fallbackPath = path11__default.default.join(assetsBase, segments.slice(1).join("/"));
+        const fallbackPath = path13__default.default.join(assetsBase, segments.slice(1).join("/"));
         if (fallbackPath.startsWith(assetsBase) && fs3__default.default.existsSync(fallbackPath)) {
           serveFile(res, fallbackPath);
           return;
         }
       }
     }
-    const filePath = path11__default.default.join(options.distDir, pathname);
+    const filePath = path13__default.default.join(options.distDir, pathname);
     if (!filePath.startsWith(options.distDir)) {
       res.writeHead(403);
       res.end("Forbidden");
@@ -1750,7 +1894,7 @@ function serveFile(res, filePath) {
       res.end("Not Found");
       return;
     }
-    const ext = path11__default.default.extname(filePath);
+    const ext = path13__default.default.extname(filePath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     const content = fs3__default.default.readFileSync(filePath);
     res.writeHead(200, { "Content-Type": contentType });
@@ -1867,26 +2011,26 @@ var init_dev_server = __esm({
 // src/utils/file-helpers.ts
 init_logger();
 async function renderTemplate(templatePath, data) {
-  const template = await fs__default.default.readFile(templatePath, "utf-8");
+  const template = await fs8__default.default.readFile(templatePath, "utf-8");
   return ejs__default.default.render(template, data);
 }
 async function writeFile(filePath, content) {
-  await fs__default.default.ensureDir(path11__default.default.dirname(filePath));
-  await fs__default.default.writeFile(filePath, content, "utf-8");
+  await fs8__default.default.ensureDir(path13__default.default.dirname(filePath));
+  await fs8__default.default.writeFile(filePath, content, "utf-8");
 }
 function getTemplatesDir() {
   const locations = [
-    path11__default.default.join(__dirname, "../../templates"),
+    path13__default.default.join(__dirname, "../../templates"),
     // Development
-    path11__default.default.join(__dirname, "../templates"),
+    path13__default.default.join(__dirname, "../templates"),
     // Production (dist/)
-    path11__default.default.join(process.cwd(), "templates"),
+    path13__default.default.join(process.cwd(), "templates"),
     // Fallback
-    path11__default.default.join(process.cwd(), "packages/cli/templates")
+    path13__default.default.join(process.cwd(), "packages/cli/templates")
     // Monorepo
   ];
   for (const location of locations) {
-    if (fs__default.default.existsSync(location)) {
+    if (fs8__default.default.existsSync(location)) {
       return location;
     }
   }
@@ -1894,18 +2038,18 @@ function getTemplatesDir() {
 }
 async function copyTemplate(templateName, targetDir, data) {
   const templatesDir = getTemplatesDir();
-  const templateDir = path11__default.default.join(templatesDir, templateName);
-  if (!fs__default.default.existsSync(templateDir)) {
+  const templateDir = path13__default.default.join(templatesDir, templateName);
+  if (!fs8__default.default.existsSync(templateDir)) {
     throw new Error(
-      `Template "${templateName}" not found at ${templateDir}. Available templates: ${fs__default.default.readdirSync(templatesDir).join(", ")}`
+      `Template "${templateName}" not found at ${templateDir}. Available templates: ${fs8__default.default.readdirSync(templatesDir).join(", ")}`
     );
   }
-  await fs__default.default.ensureDir(targetDir);
-  const files = await fs__default.default.readdir(templateDir);
+  await fs8__default.default.ensureDir(targetDir);
+  const files = await fs8__default.default.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path11__default.default.join(templateDir, file);
-    const targetPath = path11__default.default.join(targetDir, file);
-    const stat = await fs__default.default.stat(templatePath);
+    const templatePath = path13__default.default.join(templateDir, file);
+    const targetPath = path13__default.default.join(targetDir, file);
+    const stat = await fs8__default.default.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
     } else if (file.endsWith(".ejs")) {
@@ -1913,17 +2057,17 @@ async function copyTemplate(templateName, targetDir, data) {
       const outputPath = targetPath.replace(/\.ejs$/, "");
       await writeFile(outputPath, content);
     } else {
-      await fs__default.default.copy(templatePath, targetPath);
+      await fs8__default.default.copy(templatePath, targetPath);
     }
   }
 }
 async function copyTemplateDir(templateDir, targetDir, data) {
-  await fs__default.default.ensureDir(targetDir);
-  const files = await fs__default.default.readdir(templateDir);
+  await fs8__default.default.ensureDir(targetDir);
+  const files = await fs8__default.default.readdir(templateDir);
   for (const file of files) {
-    const templatePath = path11__default.default.join(templateDir, file);
-    const targetPath = path11__default.default.join(targetDir, file);
-    const stat = await fs__default.default.stat(templatePath);
+    const templatePath = path13__default.default.join(templateDir, file);
+    const targetPath = path13__default.default.join(targetDir, file);
+    const stat = await fs8__default.default.stat(templatePath);
     if (stat.isDirectory()) {
       await copyTemplateDir(templatePath, targetPath, data);
     } else if (file.endsWith(".ejs")) {
@@ -1931,38 +2075,38 @@ async function copyTemplateDir(templateDir, targetDir, data) {
       const outputPath = targetPath.replace(/\.ejs$/, "");
       await writeFile(outputPath, content);
     } else {
-      await fs__default.default.copy(templatePath, targetPath);
+      await fs8__default.default.copy(templatePath, targetPath);
     }
   }
 }
 function getProjectRoot() {
   let currentDir = process.cwd();
-  while (currentDir !== path11__default.default.parse(currentDir).root) {
-    const packageJsonPath = path11__default.default.join(currentDir, "package.json");
-    if (fs__default.default.existsSync(packageJsonPath)) {
-      const packageJson = fs__default.default.readJsonSync(packageJsonPath);
-      if (packageJson.workspaces || fs__default.default.existsSync(path11__default.default.join(currentDir, "src/themes")) || fs__default.default.existsSync(path11__default.default.join(currentDir, "themes"))) {
+  while (currentDir !== path13__default.default.parse(currentDir).root) {
+    const packageJsonPath = path13__default.default.join(currentDir, "package.json");
+    if (fs8__default.default.existsSync(packageJsonPath)) {
+      const packageJson = fs8__default.default.readJsonSync(packageJsonPath);
+      if (packageJson.workspaces || fs8__default.default.existsSync(path13__default.default.join(currentDir, "src/themes")) || fs8__default.default.existsSync(path13__default.default.join(currentDir, "themes"))) {
         return currentDir;
       }
     }
-    currentDir = path11__default.default.dirname(currentDir);
+    currentDir = path13__default.default.dirname(currentDir);
   }
   return process.cwd();
 }
 function getThemesDir() {
   const root = getProjectRoot();
-  if (fs__default.default.existsSync(path11__default.default.join(root, "themes")))
-    return path11__default.default.join(root, "themes");
-  if (fs__default.default.existsSync(path11__default.default.join(root, "src/themes")))
-    return path11__default.default.join(root, "src/themes");
-  return path11__default.default.dirname(root);
+  if (fs8__default.default.existsSync(path13__default.default.join(root, "themes")))
+    return path13__default.default.join(root, "themes");
+  if (fs8__default.default.existsSync(path13__default.default.join(root, "src/themes")))
+    return path13__default.default.join(root, "src/themes");
+  return path13__default.default.dirname(root);
 }
 function getFeaturesDir() {
-  return path11__default.default.join(getProjectRoot(), "src/features");
+  return path13__default.default.join(getProjectRoot(), "src/features");
 }
 function isOneXProject() {
   const root = getProjectRoot();
-  return fs__default.default.existsSync(path11__default.default.join(root, "themes")) || fs__default.default.existsSync(path11__default.default.join(root, "src/themes")) || fs__default.default.existsSync(path11__default.default.join(root, "theme.config.ts")) || fs__default.default.existsSync(path11__default.default.join(root, "bundle-entry.ts"));
+  return fs8__default.default.existsSync(path13__default.default.join(root, "themes")) || fs8__default.default.existsSync(path13__default.default.join(root, "src/themes")) || fs8__default.default.existsSync(path13__default.default.join(root, "theme.config.ts")) || fs8__default.default.existsSync(path13__default.default.join(root, "bundle-entry.ts"));
 }
 function ensureOneXProject() {
   if (!isOneXProject()) {
@@ -1974,17 +2118,17 @@ function ensureOneXProject() {
 }
 function listThemes() {
   const themesDir = getThemesDir();
-  if (!fs__default.default.existsSync(themesDir)) {
+  if (!fs8__default.default.existsSync(themesDir)) {
     return [];
   }
-  return fs__default.default.readdirSync(themesDir).filter((name) => {
-    const themePath = path11__default.default.join(themesDir, name);
-    return fs__default.default.statSync(themePath).isDirectory() && (fs__default.default.existsSync(path11__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path11__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path11__default.default.join(themePath, "manifest.ts")));
+  return fs8__default.default.readdirSync(themesDir).filter((name) => {
+    const themePath = path13__default.default.join(themesDir, name);
+    return fs8__default.default.statSync(themePath).isDirectory() && (fs8__default.default.existsSync(path13__default.default.join(themePath, "theme.config.ts")) || fs8__default.default.existsSync(path13__default.default.join(themePath, "bundle-entry.ts")) || fs8__default.default.existsSync(path13__default.default.join(themePath, "manifest.ts")));
   });
 }
 function themeExists(themeName) {
-  const themePath = path11__default.default.join(getThemesDir(), themeName);
-  return fs__default.default.existsSync(themePath) && (fs__default.default.existsSync(path11__default.default.join(themePath, "theme.config.ts")) || fs__default.default.existsSync(path11__default.default.join(themePath, "bundle-entry.ts")) || fs__default.default.existsSync(path11__default.default.join(themePath, "manifest.ts")));
+  const themePath = path13__default.default.join(getThemesDir(), themeName);
+  return fs8__default.default.existsSync(themePath) && (fs8__default.default.existsSync(path13__default.default.join(themePath, "theme.config.ts")) || fs8__default.default.existsSync(path13__default.default.join(themePath, "bundle-entry.ts")) || fs8__default.default.existsSync(path13__default.default.join(themePath, "manifest.ts")));
 }
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
@@ -1992,9 +2136,9 @@ function detectPackageManager() {
   if (userAgent.includes("yarn")) return "yarn";
   if (userAgent.includes("bun")) return "bun";
   const cwd = process.cwd();
-  if (fs__default.default.existsSync(path11__default.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs__default.default.existsSync(path11__default.default.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs__default.default.existsSync(path11__default.default.join(cwd, "bun.lockb"))) return "bun";
+  if (fs8__default.default.existsSync(path13__default.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs8__default.default.existsSync(path13__default.default.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs8__default.default.existsSync(path13__default.default.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 async function installDependencies(projectPath, packageManager = "npm") {
@@ -2043,23 +2187,23 @@ function getValidCategories() {
     "contact"
   ];
 }
-var AUTH_DIR = path11__default.default.join(os__default.default.homedir(), ".onexthm");
+var AUTH_DIR = path13__default.default.join(os__default.default.homedir(), ".onexthm");
 var ENV_URLS = {
   dev: "https://platform-dev.onexeos.com",
   staging: "https://platform-staging.onexeos.com",
   prod: "https://platform-apis.onexeos.com"
 };
 function getAuthFile(env = "dev") {
-  const newFile = path11__default.default.join(AUTH_DIR, `auth-${env}.json`);
+  const newFile = path13__default.default.join(AUTH_DIR, `auth-${env}.json`);
   if (env === "dev") {
-    const legacyFile = path11__default.default.join(AUTH_DIR, "auth.json");
-    if (fs__default.default.existsSync(legacyFile) && !fs__default.default.existsSync(newFile)) {
+    const legacyFile = path13__default.default.join(AUTH_DIR, "auth.json");
+    if (fs8__default.default.existsSync(legacyFile) && !fs8__default.default.existsSync(newFile)) {
       try {
-        fs__default.default.moveSync(legacyFile, newFile);
+        fs8__default.default.moveSync(legacyFile, newFile);
       } catch {
         try {
-          fs__default.default.copySync(legacyFile, newFile);
-          fs__default.default.removeSync(legacyFile);
+          fs8__default.default.copySync(legacyFile, newFile);
+          fs8__default.default.removeSync(legacyFile);
         } catch {
         }
       }
@@ -2071,17 +2215,17 @@ function getApiUrl(env = "dev") {
   return process.env.ONEXTHM_API_URL || ENV_URLS[env];
 }
 async function saveAuthTokens(tokens, env = "dev") {
-  await fs__default.default.ensureDir(AUTH_DIR);
+  await fs8__default.default.ensureDir(AUTH_DIR);
   const key = getMachineKey();
   const data = JSON.stringify(tokens);
   const encrypted = encrypt(data, key);
-  await fs__default.default.writeFile(getAuthFile(env), encrypted, "utf-8");
+  await fs8__default.default.writeFile(getAuthFile(env), encrypted, "utf-8");
 }
 function loadAuthTokens(env = "dev") {
   try {
     const file = getAuthFile(env);
-    if (!fs__default.default.existsSync(file)) return null;
-    const encrypted = fs__default.default.readFileSync(file, "utf-8");
+    if (!fs8__default.default.existsSync(file)) return null;
+    const encrypted = fs8__default.default.readFileSync(file, "utf-8");
     const key = getMachineKey();
     const data = decrypt(encrypted, key);
     return JSON.parse(data);
@@ -2091,7 +2235,7 @@ function loadAuthTokens(env = "dev") {
 }
 async function clearAuthTokens(env = "dev") {
   try {
-    await fs__default.default.remove(getAuthFile(env));
+    await fs8__default.default.remove(getAuthFile(env));
   } catch {
   }
 }
@@ -2150,7 +2294,7 @@ function getMachineKey() {
     seed = `onexthm:${os__default.default.hostname()}:${os__default.default.userInfo().username}`;
   } else if (process.platform === "linux") {
     try {
-      seed = `onexthm:${fs__default.default.readFileSync("/etc/machine-id", "utf-8").trim()}`;
+      seed = `onexthm:${fs8__default.default.readFileSync("/etc/machine-id", "utf-8").trim()}`;
     } catch {
       seed = `onexthm:${os__default.default.hostname()}:${os__default.default.userInfo().username}`;
     }
@@ -2188,7 +2332,7 @@ function parseJwtClaims(idToken) {
 }
 
 // src/commands/init.ts
-async function initCommand(projectName, options = {}) {
+async function initCommand(projectName, options) {
   logger.header("Create New OneX Theme Project");
   let name;
   if (!projectName) {
@@ -2203,7 +2347,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(path11__default.default.join(process.cwd(), kebabName))) {
+          if (fs3__default.default.existsSync(path13__default.default.join(process.cwd(), kebabName))) {
             return `Directory "${kebabName}" already exists`;
           }
           return true;
@@ -2214,14 +2358,14 @@ async function initCommand(projectName, options = {}) {
   } else {
     name = toKebabCase(projectName);
   }
-  const projectPath = path11__default.default.join(process.cwd(), name);
+  const projectPath = path13__default.default.join(process.cwd(), name);
   if (fs3__default.default.existsSync(projectPath)) {
     logger.error(`Directory "${name}" already exists.`);
     process.exit(1);
   }
   if (!options.yes) {
     try {
-      const apiUrl = getApiUrl(options.env ?? "dev");
+      const apiUrl = getApiUrl(options.env);
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), 3e3);
       const response = await fetch(
@@ -2330,7 +2474,7 @@ async function initCommand(projectName, options = {}) {
       description,
       author
     );
-    const mcpJsonPath = path11__default.default.join(projectPath, ".mcp.json");
+    const mcpJsonPath = path13__default.default.join(projectPath, ".mcp.json");
     if (fs3__default.default.existsSync(mcpJsonPath)) {
       let mcpContent = fs3__default.default.readFileSync(mcpJsonPath, "utf-8");
       if (figmaApiKey) {
@@ -2410,7 +2554,7 @@ async function initCommand(projectName, options = {}) {
   }
 }
 async function renameThemeInFiles(projectPath, themeName, displayName, description, author) {
-  const configPath = path11__default.default.join(projectPath, "theme.config.ts");
+  const configPath = path13__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(
@@ -2423,7 +2567,7 @@ async function renameThemeInFiles(projectPath, themeName, displayName, descripti
     );
     fs3__default.default.writeFileSync(configPath, content, "utf-8");
   }
-  const pkgPath = path11__default.default.join(projectPath, "package.json");
+  const pkgPath = path13__default.default.join(projectPath, "package.json");
   if (fs3__default.default.existsSync(pkgPath)) {
     let content = fs3__default.default.readFileSync(pkgPath, "utf-8");
     content = content.replace(
@@ -2445,10 +2589,10 @@ async function createSectionCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f))
+      (f) => fs8__default.default.existsSync(path13__default.default.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path11__default.default.basename(process.cwd());
+      options.theme = path13__default.default.basename(process.cwd());
     }
   }
   const sectionName = toKebabCase(name);
@@ -2511,35 +2655,35 @@ async function createSectionCommand(name, options) {
   };
   logger.startSpinner("Creating section files...");
   try {
-    const themePath = path11__default.default.join(getThemesDir(), themeName);
-    const sectionPath = path11__default.default.join(themePath, "sections", sectionName);
+    const themePath = path13__default.default.join(getThemesDir(), themeName);
+    const sectionPath = path13__default.default.join(themePath, "sections", sectionName);
     const schemaContent = generateSectionSchema(data);
     await writeFile(
-      path11__default.default.join(sectionPath, `${sectionName}.schema.ts`),
+      path13__default.default.join(sectionPath, `${sectionName}.schema.ts`),
       schemaContent
     );
     if (createTemplate) {
       const templateContent = generateSectionTemplate(data);
       await writeFile(
-        path11__default.default.join(sectionPath, `${sectionName}-default.tsx`),
+        path13__default.default.join(sectionPath, `${sectionName}-default.tsx`),
         templateContent
       );
     }
     const indexContent = generateSectionIndex(data, createTemplate);
-    await writeFile(path11__default.default.join(sectionPath, "index.ts"), indexContent);
+    await writeFile(path13__default.default.join(sectionPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Section files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path11__default.default.relative(process.cwd(), path11__default.default.join(sectionPath, `${sectionName}.schema.ts`))}`
+      `  1. Edit schema: ${path13__default.default.relative(process.cwd(), path13__default.default.join(sectionPath, `${sectionName}.schema.ts`))}`
     );
     if (createTemplate) {
       logger.log(
-        `  2. Edit template: ${path11__default.default.relative(process.cwd(), path11__default.default.join(sectionPath, `${sectionName}-default.tsx`))}`
+        `  2. Edit template: ${path13__default.default.relative(process.cwd(), path13__default.default.join(sectionPath, `${sectionName}-default.tsx`))}`
       );
     }
     logger.log(
-      `  3. Add to theme manifest: ${path11__default.default.relative(process.cwd(), path11__default.default.join(themePath, "manifest.ts"))}`
+      `  3. Add to theme manifest: ${path13__default.default.relative(process.cwd(), path13__default.default.join(themePath, "manifest.ts"))}`
     );
     logger.newLine();
     logger.success("Section created successfully!");
@@ -2687,10 +2831,10 @@ async function createBlockCommand(name, options) {
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
-      (f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f))
+      (f) => fs8__default.default.existsSync(path13__default.default.join(process.cwd(), f))
     );
     if (isStandaloneTheme) {
-      options.theme = path11__default.default.basename(process.cwd());
+      options.theme = path13__default.default.basename(process.cwd());
     }
   }
   const blockName = toKebabCase(name);
@@ -2765,24 +2909,24 @@ async function createBlockCommand(name, options) {
   };
   logger.startSpinner("Creating block files...");
   try {
-    const blockPath = scope === "shared" ? path11__default.default.join(getFeaturesDir(), "blocks", blockName) : path11__default.default.join(getThemesDir(), themeName, "blocks", blockName);
+    const blockPath = scope === "shared" ? path13__default.default.join(getFeaturesDir(), "blocks", blockName) : path13__default.default.join(getThemesDir(), themeName, "blocks", blockName);
     const schemaContent = generateBlockSchema(data);
     await writeFile(
-      path11__default.default.join(blockPath, `${blockName}.schema.ts`),
+      path13__default.default.join(blockPath, `${blockName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateBlockComponent(data);
-    await writeFile(path11__default.default.join(blockPath, `${blockName}.tsx`), componentContent);
+    await writeFile(path13__default.default.join(blockPath, `${blockName}.tsx`), componentContent);
     const indexContent = generateBlockIndex(data);
-    await writeFile(path11__default.default.join(blockPath, "index.ts"), indexContent);
+    await writeFile(path13__default.default.join(blockPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Block files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path11__default.default.relative(process.cwd(), path11__default.default.join(blockPath, `${blockName}.schema.ts`))}`
+      `  1. Edit schema: ${path13__default.default.relative(process.cwd(), path13__default.default.join(blockPath, `${blockName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path11__default.default.relative(process.cwd(), path11__default.default.join(blockPath, `${blockName}.tsx`))}`
+      `  2. Edit component: ${path13__default.default.relative(process.cwd(), path13__default.default.join(blockPath, `${blockName}.tsx`))}`
     );
     logger.log(
       `  3. Register in block registry: src/lib/registry/block-registry.ts`
@@ -2960,31 +3104,31 @@ async function createComponentCommand(name, options) {
   };
   logger.startSpinner("Creating component files...");
   try {
-    const componentPath = path11__default.default.join(
+    const componentPath = path13__default.default.join(
       getFeaturesDir(),
       "components",
       componentName
     );
     const schemaContent = generateComponentSchema(data);
     await writeFile(
-      path11__default.default.join(componentPath, `${componentName}.schema.ts`),
+      path13__default.default.join(componentPath, `${componentName}.schema.ts`),
       schemaContent
     );
     const componentContent = generateComponent(data);
     await writeFile(
-      path11__default.default.join(componentPath, `${componentName}.tsx`),
+      path13__default.default.join(componentPath, `${componentName}.tsx`),
       componentContent
     );
     const indexContent = generateComponentIndex(data);
-    await writeFile(path11__default.default.join(componentPath, "index.ts"), indexContent);
+    await writeFile(path13__default.default.join(componentPath, "index.ts"), indexContent);
     logger.stopSpinner(true, "Component files created successfully!");
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  1. Edit schema: ${path11__default.default.relative(process.cwd(), path11__default.default.join(componentPath, `${componentName}.schema.ts`))}`
+      `  1. Edit schema: ${path13__default.default.relative(process.cwd(), path13__default.default.join(componentPath, `${componentName}.schema.ts`))}`
     );
     logger.log(
-      `  2. Edit component: ${path11__default.default.relative(process.cwd(), path11__default.default.join(componentPath, `${componentName}.tsx`))}`
+      `  2. Edit component: ${path13__default.default.relative(process.cwd(), path13__default.default.join(componentPath, `${componentName}.tsx`))}`
     );
     logger.log(
       `  3. Register in component registry: src/lib/registry/component-registry.ts`
@@ -3141,13 +3285,13 @@ async function listSections(themeFilter) {
     return;
   }
   for (const theme of themes) {
-    const sectionsDir = path11__default.default.join(getThemesDir(), theme, "sections");
-    if (!fs__default.default.existsSync(sectionsDir)) {
+    const sectionsDir = path13__default.default.join(getThemesDir(), theme, "sections");
+    if (!fs8__default.default.existsSync(sectionsDir)) {
       continue;
     }
-    const sections = fs__default.default.readdirSync(sectionsDir).filter((name) => {
-      const sectionPath = path11__default.default.join(sectionsDir, name);
-      return fs__default.default.statSync(sectionPath).isDirectory() && fs__default.default.existsSync(path11__default.default.join(sectionPath, "index.ts"));
+    const sections = fs8__default.default.readdirSync(sectionsDir).filter((name) => {
+      const sectionPath = path13__default.default.join(sectionsDir, name);
+      return fs8__default.default.statSync(sectionPath).isDirectory() && fs8__default.default.existsSync(path13__default.default.join(sectionPath, "index.ts"));
     });
     if (sections.length > 0) {
       logger.log(chalk4__default.default.cyan(`
@@ -3161,11 +3305,11 @@ async function listSections(themeFilter) {
 }
 async function listBlocks(themeFilter) {
   logger.section("\u{1F9F1} Blocks");
-  const sharedBlocksDir = path11__default.default.join(getFeaturesDir(), "blocks");
-  if (fs__default.default.existsSync(sharedBlocksDir)) {
-    const sharedBlocks = fs__default.default.readdirSync(sharedBlocksDir).filter((name) => {
-      const blockPath = path11__default.default.join(sharedBlocksDir, name);
-      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path11__default.default.join(blockPath, "index.ts"));
+  const sharedBlocksDir = path13__default.default.join(getFeaturesDir(), "blocks");
+  if (fs8__default.default.existsSync(sharedBlocksDir)) {
+    const sharedBlocks = fs8__default.default.readdirSync(sharedBlocksDir).filter((name) => {
+      const blockPath = path13__default.default.join(sharedBlocksDir, name);
+      return fs8__default.default.statSync(blockPath).isDirectory() && fs8__default.default.existsSync(path13__default.default.join(blockPath, "index.ts"));
     });
     if (sharedBlocks.length > 0) {
       logger.log(chalk4__default.default.cyan("\n  Shared:"));
@@ -3176,13 +3320,13 @@ async function listBlocks(themeFilter) {
   }
   const themes = themeFilter ? [themeFilter] : listThemes();
   for (const theme of themes) {
-    const blocksDir = path11__default.default.join(getThemesDir(), theme, "blocks");
-    if (!fs__default.default.existsSync(blocksDir)) {
+    const blocksDir = path13__default.default.join(getThemesDir(), theme, "blocks");
+    if (!fs8__default.default.existsSync(blocksDir)) {
       continue;
     }
-    const blocks = fs__default.default.readdirSync(blocksDir).filter((name) => {
-      const blockPath = path11__default.default.join(blocksDir, name);
-      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path11__default.default.join(blockPath, "index.ts"));
+    const blocks = fs8__default.default.readdirSync(blocksDir).filter((name) => {
+      const blockPath = path13__default.default.join(blocksDir, name);
+      return fs8__default.default.statSync(blockPath).isDirectory() && fs8__default.default.existsSync(path13__default.default.join(blockPath, "index.ts"));
     });
     if (blocks.length > 0) {
       logger.log(chalk4__default.default.cyan(`
@@ -3196,14 +3340,14 @@ async function listBlocks(themeFilter) {
 }
 async function listComponents() {
   logger.section("\u2699\uFE0F  Components");
-  const componentsDir = path11__default.default.join(getFeaturesDir(), "components");
-  if (!fs__default.default.existsSync(componentsDir)) {
+  const componentsDir = path13__default.default.join(getFeaturesDir(), "components");
+  if (!fs8__default.default.existsSync(componentsDir)) {
     logger.warning("No components directory found");
     return;
   }
-  const components = fs__default.default.readdirSync(componentsDir).filter((name) => {
-    const componentPath = path11__default.default.join(componentsDir, name);
-    return fs__default.default.statSync(componentPath).isDirectory() && fs__default.default.existsSync(path11__default.default.join(componentPath, "index.ts"));
+  const components = fs8__default.default.readdirSync(componentsDir).filter((name) => {
+    const componentPath = path13__default.default.join(componentsDir, name);
+    return fs8__default.default.statSync(componentPath).isDirectory() && fs8__default.default.existsSync(path13__default.default.join(componentPath, "index.ts"));
   });
   if (components.length === 0) {
     logger.warning("No components found");
@@ -3224,13 +3368,13 @@ async function listThemesInfo() {
   }
   logger.log("");
   for (const theme of themes) {
-    const themeDir = path11__default.default.join(getThemesDir(), theme);
+    const themeDir = path13__default.default.join(getThemesDir(), theme);
     const candidates = ["theme.config.ts", "bundle-entry.ts", "manifest.ts"];
     let manifestContent = "";
     for (const candidate of candidates) {
-      const candidatePath = path11__default.default.join(themeDir, candidate);
-      if (fs__default.default.existsSync(candidatePath)) {
-        manifestContent = fs__default.default.readFileSync(candidatePath, "utf-8");
+      const candidatePath = path13__default.default.join(themeDir, candidate);
+      if (fs8__default.default.existsSync(candidatePath)) {
+        manifestContent = fs8__default.default.readFileSync(candidatePath, "utf-8");
         break;
       }
     }
@@ -3250,6 +3394,7 @@ async function listThemesInfo() {
 
 // src/commands/validate.ts
 init_logger();
+init_detect_nextjs();
 async function validateCommand(options) {
   logger.header("Validate Theme");
   ensureOneXProject();
@@ -3265,10 +3410,13 @@ async function validateCommand(options) {
     const isThemeDir2 = [
       "theme.config.ts",
       "bundle-entry.ts",
-      "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
+      "manifest.ts",
+      "next.config.ts",
+      "next.config.js",
+      "next.config.mjs"
+    ].some((f) => fs8__default.default.existsSync(path13__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
-      themeToValidate = path11__default.default.basename(process.cwd());
+      themeToValidate = path13__default.default.basename(process.cwd());
       logger.info(`Validating current theme: ${themeToValidate}`);
     } else {
       logger.error(
@@ -3277,11 +3425,11 @@ async function validateCommand(options) {
       process.exit(1);
     }
   }
-  const themePath = path11__default.default.join(getThemesDir(), themeToValidate);
+  const themePath = path13__default.default.join(getThemesDir(), themeToValidate);
   logger.startSpinner("Running validation checks...");
   const entryFiles = ["manifest.ts", "theme.config.ts", "bundle-entry.ts"];
   const foundEntry = entryFiles.find(
-    (f) => fs__default.default.existsSync(path11__default.default.join(themePath, f))
+    (f) => fs8__default.default.existsSync(path13__default.default.join(themePath, f))
   );
   if (!foundEntry) {
     issues.push({
@@ -3290,8 +3438,8 @@ async function validateCommand(options) {
       message: "No theme entry file found (need at least one of: manifest.ts, theme.config.ts, bundle-entry.ts)"
     });
   } else if (foundEntry === "manifest.ts") {
-    const manifestContent = fs__default.default.readFileSync(
-      path11__default.default.join(themePath, foundEntry),
+    const manifestContent = fs8__default.default.readFileSync(
+      path13__default.default.join(themePath, foundEntry),
       "utf-8"
     );
     if (!manifestContent.includes("export const") && !manifestContent.includes("export default") && !manifestContent.includes("export interface")) {
@@ -3302,56 +3450,56 @@ async function validateCommand(options) {
       });
     }
   }
-  const configPath = path11__default.default.join(themePath, "theme.config.ts");
-  if (!fs__default.default.existsSync(configPath)) {
+  const configPath = path13__default.default.join(themePath, "theme.config.ts");
+  if (!fs8__default.default.existsSync(configPath)) {
     issues.push({
       type: "warning",
       file: "theme.config.ts",
       message: "Theme config file not found (recommended)"
     });
   }
-  const indexPath = path11__default.default.join(themePath, "index.ts");
-  if (!fs__default.default.existsSync(indexPath)) {
+  const indexPath = path13__default.default.join(themePath, "index.ts");
+  if (!fs8__default.default.existsSync(indexPath)) {
     issues.push({
       type: "warning",
       file: "index.ts",
       message: "Index file not found (recommended)"
     });
   }
-  const sectionsDir = path11__default.default.join(themePath, "sections");
-  if (!fs__default.default.existsSync(sectionsDir)) {
+  const sectionsDir = path13__default.default.join(themePath, "sections");
+  if (!fs8__default.default.existsSync(sectionsDir)) {
     issues.push({
       type: "warning",
       file: "sections/",
       message: "Sections directory not found"
     });
   } else {
-    const sections = fs__default.default.readdirSync(sectionsDir).filter(
-      (name) => fs__default.default.statSync(path11__default.default.join(sectionsDir, name)).isDirectory()
+    const sections = fs8__default.default.readdirSync(sectionsDir).filter(
+      (name) => fs8__default.default.statSync(path13__default.default.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
-      const sectionPath = path11__default.default.join(sectionsDir, sectionName);
-      const schemaFile = path11__default.default.join(sectionPath, `${sectionName}.schema.ts`);
-      const defaultTemplate = path11__default.default.join(
+      const sectionPath = path13__default.default.join(sectionsDir, sectionName);
+      const schemaFile = path13__default.default.join(sectionPath, `${sectionName}.schema.ts`);
+      const defaultTemplate = path13__default.default.join(
         sectionPath,
         `${sectionName}-default.tsx`
       );
-      const indexFile = path11__default.default.join(sectionPath, "index.ts");
-      if (!fs__default.default.existsSync(schemaFile)) {
+      const indexFile = path13__default.default.join(sectionPath, "index.ts");
+      if (!fs8__default.default.existsSync(schemaFile)) {
         issues.push({
           type: "error",
           file: `sections/${sectionName}/${sectionName}.schema.ts`,
           message: "Section schema file missing"
         });
       }
-      if (!fs__default.default.existsSync(indexFile)) {
+      if (!fs8__default.default.existsSync(indexFile)) {
         issues.push({
           type: "error",
           file: `sections/${sectionName}/index.ts`,
           message: "Section index file missing"
         });
       }
-      if (!fs__default.default.existsSync(defaultTemplate)) {
+      if (!fs8__default.default.existsSync(defaultTemplate)) {
         issues.push({
           type: "warning",
           file: `sections/${sectionName}/${sectionName}-default.tsx`,
@@ -3360,29 +3508,29 @@ async function validateCommand(options) {
       }
     }
   }
-  const blocksDir = path11__default.default.join(themePath, "blocks");
-  if (fs__default.default.existsSync(blocksDir)) {
-    const blocks = fs__default.default.readdirSync(blocksDir).filter((name) => fs__default.default.statSync(path11__default.default.join(blocksDir, name)).isDirectory());
+  const blocksDir = path13__default.default.join(themePath, "blocks");
+  if (fs8__default.default.existsSync(blocksDir)) {
+    const blocks = fs8__default.default.readdirSync(blocksDir).filter((name) => fs8__default.default.statSync(path13__default.default.join(blocksDir, name)).isDirectory());
     for (const blockName of blocks) {
-      const blockPath = path11__default.default.join(blocksDir, blockName);
-      const schemaFile = path11__default.default.join(blockPath, `${blockName}.schema.ts`);
-      const componentFile = path11__default.default.join(blockPath, `${blockName}.tsx`);
-      const indexFile = path11__default.default.join(blockPath, "index.ts");
-      if (!fs__default.default.existsSync(schemaFile)) {
+      const blockPath = path13__default.default.join(blocksDir, blockName);
+      const schemaFile = path13__default.default.join(blockPath, `${blockName}.schema.ts`);
+      const componentFile = path13__default.default.join(blockPath, `${blockName}.tsx`);
+      const indexFile = path13__default.default.join(blockPath, "index.ts");
+      if (!fs8__default.default.existsSync(schemaFile)) {
         issues.push({
           type: "error",
           file: `blocks/${blockName}/${blockName}.schema.ts`,
           message: "Block schema file missing"
         });
       }
-      if (!fs__default.default.existsSync(componentFile)) {
+      if (!fs8__default.default.existsSync(componentFile)) {
         issues.push({
           type: "error",
           file: `blocks/${blockName}/${blockName}.tsx`,
           message: "Block component file missing"
         });
       }
-      if (!fs__default.default.existsSync(indexFile)) {
+      if (!fs8__default.default.existsSync(indexFile)) {
         issues.push({
           type: "error",
           file: `blocks/${blockName}/index.ts`,
@@ -3391,16 +3539,16 @@ async function validateCommand(options) {
       }
     }
   }
-  if (fs__default.default.existsSync(sectionsDir)) {
-    const sections = fs__default.default.readdirSync(sectionsDir).filter(
-      (name) => fs__default.default.statSync(path11__default.default.join(sectionsDir, name)).isDirectory()
+  if (fs8__default.default.existsSync(sectionsDir)) {
+    const sections = fs8__default.default.readdirSync(sectionsDir).filter(
+      (name) => fs8__default.default.statSync(path13__default.default.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
-      const sectionPath = path11__default.default.join(sectionsDir, sectionName);
-      const tsxFiles = fs__default.default.readdirSync(sectionPath).filter((f) => f.endsWith(".tsx") && !f.endsWith(".schema.ts"));
+      const sectionPath = path13__default.default.join(sectionsDir, sectionName);
+      const tsxFiles = fs8__default.default.readdirSync(sectionPath).filter((f) => f.endsWith(".tsx") && !f.endsWith(".schema.ts"));
       for (const tsxFile of tsxFiles) {
-        const filePath = path11__default.default.join(sectionPath, tsxFile);
-        const content = fs__default.default.readFileSync(filePath, "utf-8");
+        const filePath = path13__default.default.join(sectionPath, tsxFile);
+        const content = fs8__default.default.readFileSync(filePath, "utf-8");
         const relPath = `sections/${sectionName}/${tsxFile}`;
         if (!content.includes('"use client"') && !content.includes("'use client'")) {
           issues.push({
@@ -3447,12 +3595,12 @@ async function validateCommand(options) {
       }
     }
   }
-  const registryPath = path11__default.default.join(themePath, "sections-registry.ts");
-  const bundleEntryPath = path11__default.default.join(themePath, "bundle-entry.ts");
-  const registryContent = fs__default.default.existsSync(registryPath) ? fs__default.default.readFileSync(registryPath, "utf-8") : fs__default.default.existsSync(bundleEntryPath) ? fs__default.default.readFileSync(bundleEntryPath, "utf-8") : "";
-  if (fs__default.default.existsSync(sectionsDir) && registryContent) {
-    const sections = fs__default.default.readdirSync(sectionsDir).filter(
-      (name) => fs__default.default.statSync(path11__default.default.join(sectionsDir, name)).isDirectory()
+  const registryPath = path13__default.default.join(themePath, "sections-registry.ts");
+  const bundleEntryPath = path13__default.default.join(themePath, "bundle-entry.ts");
+  const registryContent = fs8__default.default.existsSync(registryPath) ? fs8__default.default.readFileSync(registryPath, "utf-8") : fs8__default.default.existsSync(bundleEntryPath) ? fs8__default.default.readFileSync(bundleEntryPath, "utf-8") : "";
+  if (fs8__default.default.existsSync(sectionsDir) && registryContent) {
+    const sections = fs8__default.default.readdirSync(sectionsDir).filter(
+      (name) => fs8__default.default.statSync(path13__default.default.join(sectionsDir, name)).isDirectory()
     );
     for (const sectionName of sections) {
       if (!registryContent.includes(`sections/${sectionName}`) && !registryContent.includes(`"${sectionName}"`)) {
@@ -3464,7 +3612,7 @@ async function validateCommand(options) {
       }
     }
   }
-  if (fs__default.default.existsSync(sectionsDir)) {
+  if (fs8__default.default.existsSync(sectionsDir)) {
     const schemaTypes = await loadSchemaTypes(themePath, sectionsDir);
     for (const { folderName, schemaType } of schemaTypes) {
       if (schemaType && schemaType !== folderName) {
@@ -3475,8 +3623,8 @@ async function validateCommand(options) {
         });
       }
     }
-    const pagesDir = path11__default.default.join(themePath, "pages");
-    if (fs__default.default.existsSync(pagesDir)) {
+    const pagesDir = path13__default.default.join(themePath, "pages");
+    if (fs8__default.default.existsSync(pagesDir)) {
       const allSchemaTypeSet = new Set(
         schemaTypes.map((s) => s.schemaType || s.folderName)
       );
@@ -3487,6 +3635,10 @@ async function validateCommand(options) {
       issues.push(...pageIssues);
     }
   }
+  if (isNextjsProject(themePath)) {
+    const nextjsIssues = await validateNextjsComponents(themePath);
+    issues.push(...nextjsIssues);
+  }
   logger.stopSpinner(true, "Validation complete");
   const errors = issues.filter((i) => i.type === "error");
   const warnings = issues.filter((i) => i.type === "warning");
@@ -3527,18 +3679,18 @@ async function validateCommand(options) {
 }
 async function loadSchemaTypes(themePath, sectionsDir) {
   const results = [];
-  const sections = fs__default.default.readdirSync(sectionsDir).filter((name) => fs__default.default.statSync(path11__default.default.join(sectionsDir, name)).isDirectory());
+  const sections = fs8__default.default.readdirSync(sectionsDir).filter((name) => fs8__default.default.statSync(path13__default.default.join(sectionsDir, name)).isDirectory());
   for (const sectionName of sections) {
-    const schemaFile = path11__default.default.join(
+    const schemaFile = path13__default.default.join(
       sectionsDir,
       sectionName,
       `${sectionName}.schema.ts`
     );
-    if (!fs__default.default.existsSync(schemaFile)) {
+    if (!fs8__default.default.existsSync(schemaFile)) {
       results.push({ folderName: sectionName, schemaType: null });
       continue;
     }
-    const content = fs__default.default.readFileSync(schemaFile, "utf-8");
+    const content = fs8__default.default.readFileSync(schemaFile, "utf-8");
     let schemaType = null;
     const schemaExportMatch = content.match(
       /:\s*SectionSchema\s*=\s*\{[\s\S]*?\btype:\s*["']([^"']+)["']/
@@ -3565,9 +3717,9 @@ async function loadSchemaTypes(themePath, sectionsDir) {
 }
 async function validatePageSectionTypes(pagesDir, validTypes) {
   const issues = [];
-  const files = fs__default.default.readdirSync(pagesDir).filter((f) => f.match(/\.(ts|js)$/));
+  const files = fs8__default.default.readdirSync(pagesDir).filter((f) => f.match(/\.(ts|js)$/));
   for (const file of files) {
-    const content = fs__default.default.readFileSync(path11__default.default.join(pagesDir, file), "utf-8");
+    const content = fs8__default.default.readFileSync(path13__default.default.join(pagesDir, file), "utf-8");
     const pageName = file.replace(/\.(ts|js)$/, "");
     const sectionsMatch = content.match(/\bsections:\s*\[/);
     if (!sectionsMatch || sectionsMatch.index === void 0) continue;
@@ -3697,9 +3849,70 @@ var BLOCK_TYPES = /* @__PURE__ */ new Set([
   "team-member",
   "hero-content"
 ]);
+var SERVER_ONLY_APIS = [
+  "next/headers",
+  "next/server",
+  "next/cache",
+  "cookies()",
+  "headers()",
+  "draftMode()"
+];
+async function validateNextjsComponents(themePath) {
+  const issues = [];
+  const { glob: glob6 } = await import('glob');
+  const componentFiles = await glob6("components/**/*.{tsx,ts}", {
+    cwd: themePath,
+    ignore: ["**/node_modules/**"]
+  });
+  for (const relFile of componentFiles) {
+    const absFile = path13__default.default.join(themePath, relFile);
+    const content = fs8__default.default.readFileSync(absFile, "utf-8");
+    const dir = path13__default.default.dirname(absFile);
+    const hasSectionJson = fs8__default.default.existsSync(path13__default.default.join(dir, "section.json"));
+    if (!hasSectionJson) continue;
+    for (const api of SERVER_ONLY_APIS) {
+      if (content.includes(`"${api}"`) || content.includes(`'${api}'`)) {
+        issues.push({
+          type: "error",
+          file: relFile,
+          message: `"${api}" is server-only and cannot be used in a OneX theme bundle. Remove this import or move data fetching to a client-side useEffect/useQuery.`
+        });
+      }
+      if (content.includes(api.replace("()", "") + "(")) {
+        issues.push({
+          type: "error",
+          file: relFile,
+          message: `${api} is server-only and cannot be called in a browser bundle. Use useQuery or fetch() inside useEffect instead.`
+        });
+      }
+    }
+    const isAsyncComponent = /export\s+default\s+async\s+function/.test(content) || /export\s+default\s+async\s+\(/.test(content);
+    if (isAsyncComponent) {
+      const hasUseClient2 = content.includes('"use client"') || content.includes("'use client'");
+      if (!hasUseClient2) {
+        issues.push({
+          type: "error",
+          file: relFile,
+          message: 'Async Server Components cannot be compiled to a browser bundle. Add "use client" at the top and convert data fetching to useQuery or useEffect.'
+        });
+      }
+    }
+    const usesHooks = /\buse[A-Z]\w+\s*\(/.test(content);
+    const hasUseClient = content.includes('"use client"') || content.includes("'use client'");
+    if (usesHooks && !hasUseClient) {
+      issues.push({
+        type: "warning",
+        file: relFile,
+        message: 'Component uses React hooks but is missing "use client" directive. Add "use client" at the top of the file.'
+      });
+    }
+  }
+  return issues;
+}
 
 // src/commands/build.ts
 init_logger();
+init_detect_nextjs();
 async function buildCommand(options) {
   logger.header("Build Theme");
   let themePath;
@@ -3707,16 +3920,16 @@ async function buildCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path11__default.default.join(getThemesDir(), themeName);
-      if (fs__default.default.existsSync(workspaceThemePath)) {
+      const workspaceThemePath = path13__default.default.join(getThemesDir(), themeName);
+      if (fs8__default.default.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path11__default.default.join(process.cwd(), themeName);
+        themePath = path13__default.default.join(process.cwd(), themeName);
       }
     } catch {
-      themePath = path11__default.default.join(process.cwd(), themeName);
+      themePath = path13__default.default.join(process.cwd(), themeName);
     }
-    if (!fs__default.default.existsSync(themePath)) {
+    if (!fs8__default.default.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
       process.exit(1);
     }
@@ -3724,11 +3937,14 @@ async function buildCommand(options) {
     const isThemeDir2 = [
       "theme.config.ts",
       "bundle-entry.ts",
-      "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
+      "manifest.ts",
+      "next.config.ts",
+      "next.config.js",
+      "next.config.mjs"
+    ].some((f) => fs8__default.default.existsSync(path13__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
-      themeName = path11__default.default.basename(themePath);
+      themeName = path13__default.default.basename(themePath);
       logger.info(`Building current theme: ${themeName}`);
     } else {
       logger.error(
@@ -3737,8 +3953,8 @@ async function buildCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path11__default.default.join(themePath, "package.json");
-  const hasPkgJson = fs__default.default.existsSync(packageJsonPath);
+  const packageJsonPath = path13__default.default.join(themePath, "package.json");
+  const hasPkgJson = fs8__default.default.existsSync(packageJsonPath);
   if (!hasPkgJson) {
     logger.warning(
       "No package.json found in theme. Skipping build (themes in monorepo are built via turbo)."
@@ -3753,30 +3969,42 @@ async function buildCommand(options) {
   }
   logger.newLine();
   logger.section("Build Steps");
-  logger.startSpinner("Running type check...");
-  const typeCheckSuccess = await runCommand("pnpm", ["type-check"], themePath);
-  if (!typeCheckSuccess) {
-    logger.stopSpinner(false, "Type check failed");
-    logger.error("Fix type errors before building.");
-    process.exit(1);
-  }
-  logger.stopSpinner(true, "Type check passed");
-  logger.startSpinner("Running linter...");
-  const lintSuccess = await runCommand("pnpm", ["lint"], themePath);
-  if (!lintSuccess) {
-    logger.stopSpinner(false, "Lint failed");
-    logger.error("Fix lint errors before building.");
-    process.exit(1);
+  const pkgJson = fs8__default.default.readJsonSync(packageJsonPath);
+  if (pkgJson.scripts?.["type-check"]) {
+    logger.startSpinner("Running type check...");
+    const typeCheckSuccess = await runCommand("pnpm", ["type-check"], themePath);
+    if (!typeCheckSuccess) {
+      logger.stopSpinner(false, "Type check failed");
+      logger.error("Fix type errors before building.");
+      process.exit(1);
+    }
+    logger.stopSpinner(true, "Type check passed");
+  } else {
+    logger.info("Skipping type check (no type-check script in package.json)");
+  }
+  const isNextjsForLint = isNextjsProject(themePath);
+  if (!isNextjsForLint && pkgJson.scripts?.lint) {
+    logger.startSpinner("Running linter...");
+    const lintSuccess = await runCommand("pnpm", ["lint"], themePath);
+    if (!lintSuccess) {
+      logger.stopSpinner(false, "Lint failed");
+      logger.error("Fix lint errors before building.");
+      process.exit(1);
+    }
+    logger.stopSpinner(true, "Lint passed");
+  } else if (isNextjsForLint) {
+    logger.info("Skipping lint (Next.js project compiled via esbuild)");
+  } else {
+    logger.info("Skipping lint (no lint script in package.json)");
   }
-  logger.stopSpinner(true, "Lint passed");
-  const pkgJson = fs__default.default.readJsonSync(packageJsonPath);
   const buildScript = pkgJson.scripts?.build || "";
   const isRecursive = buildScript.includes("onexthm build") || buildScript.includes("onex build") || buildScript.includes("onex-cli build");
+  const isNextjs = isNextjsProject(themePath);
   logger.startSpinner(
     options.watch ? "Building (watch mode)..." : "Building..."
   );
   let buildSuccess;
-  if (isRecursive) {
+  if (isRecursive || isNextjs) {
     const { compileStandaloneTheme: compileStandaloneTheme2 } = await Promise.resolve().then(() => (init_compile_theme(), compile_theme_exports));
     buildSuccess = await compileStandaloneTheme2(themePath, themeName);
   } else {
@@ -3793,10 +4021,10 @@ async function buildCommand(options) {
     logger.success("\u2713 Theme built successfully!");
     logger.newLine();
     logger.info(`Theme: ${themeName}`);
-    const distPath = path11__default.default.join(themePath, "dist");
-    if (fs__default.default.existsSync(distPath)) {
-      logger.log(`Output: ${path11__default.default.relative(process.cwd(), distPath)}`);
-      const files = fs__default.default.readdirSync(distPath);
+    const distPath = path13__default.default.join(themePath, "dist");
+    if (fs8__default.default.existsSync(distPath)) {
+      logger.log(`Output: ${path13__default.default.relative(process.cwd(), distPath)}`);
+      const files = fs8__default.default.readdirSync(distPath);
       logger.log(`Files: ${files.length}`);
     }
   }
@@ -3851,8 +4079,8 @@ async function packageCommand(options) {
   let themeName;
   if (options.theme) {
     themeName = options.theme;
-    themePath = path11__default.default.join(getThemesDir(), themeName);
-    if (!fs__default.default.existsSync(themePath)) {
+    themePath = path13__default.default.join(getThemesDir(), themeName);
+    if (!fs8__default.default.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
       process.exit(1);
     }
@@ -3860,11 +4088,14 @@ async function packageCommand(options) {
     const isThemeDir2 = [
       "theme.config.ts",
       "bundle-entry.ts",
-      "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
+      "manifest.ts",
+      "next.config.ts",
+      "next.config.js",
+      "next.config.mjs"
+    ].some((f) => fs8__default.default.existsSync(path13__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
-      themeName = path11__default.default.basename(themePath);
+      themeName = path13__default.default.basename(themePath);
       logger.info(`Packaging current theme: ${themeName}`);
     } else {
       logger.error(
@@ -3873,22 +4104,19 @@ async function packageCommand(options) {
       process.exit(1);
     }
   }
-  const packageJsonPath = path11__default.default.join(themePath, "package.json");
+  const packageJsonPath = path13__default.default.join(themePath, "package.json");
   let version2 = "1.0.0";
-  if (fs__default.default.existsSync(packageJsonPath)) {
-    const packageJson = await fs__default.default.readJson(packageJsonPath);
+  if (fs8__default.default.existsSync(packageJsonPath)) {
+    const packageJson = await fs8__default.default.readJson(packageJsonPath);
     version2 = packageJson.version || "1.0.0";
   }
   logger.newLine();
   logger.info(`Theme: ${themeName}`);
   logger.info(`Version: ${version2}`);
   logger.newLine();
-  const compiledThemePath = path11__default.default.join(
-    process.cwd(),
-    "themes",
-    themeName,
-    "dist"
-  );
+  const standaloneDistPath = path13__default.default.join(themePath, "dist");
+  const monorepoDistPath = path13__default.default.join(process.cwd(), "themes", themeName, "dist");
+  const compiledThemePath = fs8__default.default.existsSync(standaloneDistPath) ? standaloneDistPath : monorepoDistPath;
   if (!options.skipBuild) {
     logger.section("Step 1: Compile Theme");
     logger.startSpinner("Compiling theme with esbuild...");
@@ -3909,7 +4137,7 @@ async function packageCommand(options) {
   } else {
     logger.info("Skipping build (--skip-build flag)");
   }
-  if (!fs__default.default.existsSync(compiledThemePath)) {
+  if (!fs8__default.default.existsSync(compiledThemePath)) {
     logger.error(`Compiled theme not found at: ${compiledThemePath}`);
     logger.info("Run without --skip-build to compile first.");
     process.exit(1);
@@ -3917,25 +4145,25 @@ async function packageCommand(options) {
   logger.newLine();
   logger.section("Step 2: Create Package");
   const packageName = options.name || `${themeName}-${version2}`;
-  const outputDir = options.output || path11__default.default.join(process.cwd(), "dist");
-  const outputPath = path11__default.default.join(outputDir, `${packageName}.zip`);
-  await fs__default.default.ensureDir(outputDir);
+  const outputDir = options.output || path13__default.default.join(process.cwd(), "dist");
+  const outputPath = path13__default.default.join(outputDir, `${packageName}.zip`);
+  await fs8__default.default.ensureDir(outputDir);
   logger.startSpinner("Creating zip archive...");
   try {
     await createZipArchive(compiledThemePath, outputPath);
     logger.stopSpinner(true, "Package created");
-    const stats = await fs__default.default.stat(outputPath);
+    const stats = await fs8__default.default.stat(outputPath);
     const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
     logger.newLine();
     logger.success("\u2713 Theme packaged successfully!");
     logger.newLine();
     logger.info(`Package: ${packageName}.zip`);
     logger.log(`Size: ${sizeMB} MB`);
-    logger.log(`Location: ${path11__default.default.relative(process.cwd(), outputPath)}`);
+    logger.log(`Location: ${path13__default.default.relative(process.cwd(), outputPath)}`);
     logger.newLine();
     logger.section("Next steps:");
     logger.log(
-      `  onexthm deploy --package ${path11__default.default.relative(process.cwd(), outputPath)}`
+      `  onexthm deploy --package ${path13__default.default.relative(process.cwd(), outputPath)}`
     );
   } catch (error) {
     logger.stopSpinner(false, "Failed to create package");
@@ -3969,7 +4197,7 @@ function runCommand2(command, args) {
 }
 async function createZipArchive(compiledThemePath, outputPath) {
   return new Promise((resolve, reject) => {
-    const output = fs__default.default.createWriteStream(outputPath);
+    const output = fs8__default.default.createWriteStream(outputPath);
     const archive = archiver__default.default("zip", {
       zlib: { level: 9 }
       // Maximum compression
@@ -3993,14 +4221,14 @@ async function deployCommand(options) {
   ensureOneXProject();
   let packagePath;
   if (options.package) {
-    packagePath = path11__default.default.resolve(options.package);
+    packagePath = path13__default.default.resolve(options.package);
   } else if (options.theme) {
-    const distDir = path11__default.default.join(process.cwd(), "dist");
-    if (!fs__default.default.existsSync(distDir)) {
+    const distDir = path13__default.default.join(process.cwd(), "dist");
+    if (!fs8__default.default.existsSync(distDir)) {
       logger.error("No dist/ directory found. Run 'onexthm package' first.");
       process.exit(1);
     }
-    const files = fs__default.default.readdirSync(distDir);
+    const files = fs8__default.default.readdirSync(distDir);
     const packageFiles = files.filter(
       (f) => f.startsWith(options.theme) && f.endsWith(".zip")
     );
@@ -4010,7 +4238,7 @@ async function deployCommand(options) {
       process.exit(1);
     }
     packageFiles.sort().reverse();
-    packagePath = path11__default.default.join(distDir, packageFiles[0]);
+    packagePath = path13__default.default.join(distDir, packageFiles[0]);
   } else {
     logger.error("Either --package or --theme must be specified.");
     logger.info("Examples:");
@@ -4018,17 +4246,17 @@ async function deployCommand(options) {
     logger.log("  onexthm deploy --theme tinan");
     process.exit(1);
   }
-  if (!fs__default.default.existsSync(packagePath)) {
+  if (!fs8__default.default.existsSync(packagePath)) {
     logger.error(`Package not found: ${packagePath}`);
     process.exit(1);
   }
-  const stats = await fs__default.default.stat(packagePath);
+  const stats = await fs8__default.default.stat(packagePath);
   const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-  const fileName = path11__default.default.basename(packagePath);
+  const fileName = path13__default.default.basename(packagePath);
   logger.newLine();
   logger.info(`Package: ${fileName}`);
   logger.log(`Size: ${sizeMB} MB`);
-  logger.log(`Path: ${path11__default.default.relative(process.cwd(), packagePath)}`);
+  logger.log(`Path: ${path13__default.default.relative(process.cwd(), packagePath)}`);
   logger.newLine();
   const apiUrl = options.apiUrl || process.env.ONEX_API_URL || "http://localhost:3001";
   const uploadEndpoint = `${apiUrl}/website-api/themes/upload`;
@@ -4038,7 +4266,7 @@ async function deployCommand(options) {
   logger.startSpinner("Uploading theme package...");
   try {
     const formData = new FormData__default.default();
-    formData.append("theme", fs__default.default.createReadStream(packagePath), {
+    formData.append("theme", fs8__default.default.createReadStream(packagePath), {
       filename: fileName,
       contentType: "application/zip"
     });
@@ -4185,24 +4413,24 @@ async function downloadBundleZip(apiUrl, themeId, version2) {
 async function createCompatibilityFiles(outputDir, manifest) {
   const entryFile = manifest.output?.entry || "bundle-entry.js";
   if (entryFile !== "bundle-entry.js" && entryFile.startsWith("bundle-entry-")) {
-    const hashedPath = path11__default.default.join(outputDir, entryFile);
-    const stablePath = path11__default.default.join(outputDir, "bundle-entry.js");
-    if (await fs__default.default.pathExists(hashedPath)) {
-      await fs__default.default.copy(hashedPath, stablePath);
+    const hashedPath = path13__default.default.join(outputDir, entryFile);
+    const stablePath = path13__default.default.join(outputDir, "bundle-entry.js");
+    if (await fs8__default.default.pathExists(hashedPath)) {
+      await fs8__default.default.copy(hashedPath, stablePath);
       const mapPath = hashedPath + ".map";
-      if (await fs__default.default.pathExists(mapPath)) {
-        await fs__default.default.copy(mapPath, stablePath + ".map");
+      if (await fs8__default.default.pathExists(mapPath)) {
+        await fs8__default.default.copy(mapPath, stablePath + ".map");
       }
     }
   }
-  const sectionsRegistryPath = path11__default.default.join(outputDir, "sections-registry.js");
+  const sectionsRegistryPath = path13__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 = path11__default.default.join(outputDir, "package.json");
-  await fs__default.default.writeFile(pkgJsonPath, '{\n  "type": "module"\n}\n', "utf-8");
+  await fs8__default.default.writeFile(sectionsRegistryPath, content, "utf-8");
+  const pkgJsonPath = path13__default.default.join(outputDir, "package.json");
+  await fs8__default.default.writeFile(pkgJsonPath, '{\n  "type": "module"\n}\n', "utf-8");
 }
 function showDownloadFailureHelp(themeId, apiUrl) {
   console.log();
@@ -4242,7 +4470,7 @@ function showDownloadFailureHelp(themeId, apiUrl) {
 }
 async function downloadCommand(options) {
   logger.header("Download Theme");
-  const env = options.env ?? "dev";
+  const env = options.env;
   const apiUrl = getApiUrl(env);
   logger.info(`Environment: ${env}  (${apiUrl})`);
   const spinner = ora__default.default("Initializing download...").start();
@@ -4294,14 +4522,14 @@ async function downloadCommand(options) {
     const sizeMB = (zipBuffer.length / 1024 / 1024).toFixed(2);
     spinner.succeed(`Downloaded bundle.zip (${sizeMB} MB)`);
     spinner.start("Extracting bundle...");
-    await fs__default.default.remove(outputDir);
-    await fs__default.default.ensureDir(outputDir);
+    await fs8__default.default.remove(outputDir);
+    await fs8__default.default.ensureDir(outputDir);
     const zip = new AdmZip__default.default(zipBuffer);
     zip.extractAllTo(outputDir, true);
     const entries = zip.getEntries().filter((e) => !e.isDirectory);
     spinner.succeed(`Extracted ${entries.length} files to ${outputDir}`);
-    const manifestPath = path11__default.default.join(outputDir, "manifest.json");
-    const manifest = await fs__default.default.readJson(manifestPath);
+    const manifestPath = path13__default.default.join(outputDir, "manifest.json");
+    const manifest = await fs8__default.default.readJson(manifestPath);
     await createCompatibilityFiles(outputDir, manifest);
     console.log();
     logger.success(chalk4__default.default.green.bold("Theme downloaded successfully!"));
@@ -4421,9 +4649,9 @@ 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 = path11__default.default.join(themeDir, "package.json");
-  if (await fs__default.default.pathExists(pkgPath)) {
-    const pkg = await fs__default.default.readJson(pkgPath);
+  const pkgPath = path13__default.default.join(themeDir, "package.json");
+  if (await fs8__default.default.pathExists(pkgPath)) {
+    const pkg = await fs8__default.default.readJson(pkgPath);
     pkg.name = `@onex-themes/${newName}`;
     if (pkg.description) {
       pkg.description = pkg.description.replace(
@@ -4435,33 +4663,33 @@ async function renameTheme(themeDir, oldName, newName) {
     if (pkg.devDependencies?.["@onexapis/cli"]) {
       delete pkg.devDependencies["@onexapis/cli"];
     }
-    await fs__default.default.writeJson(pkgPath, pkg, { spaces: 2 });
+    await fs8__default.default.writeJson(pkgPath, pkg, { spaces: 2 });
   }
-  const configPath = path11__default.default.join(themeDir, "theme.config.ts");
-  if (await fs__default.default.pathExists(configPath)) {
-    let content = await fs__default.default.readFile(configPath, "utf-8");
+  const configPath = path13__default.default.join(themeDir, "theme.config.ts");
+  if (await fs8__default.default.pathExists(configPath)) {
+    let content = await fs8__default.default.readFile(configPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
     content = content.replace(
       /name:\s*"[^"]*Theme"/,
       `name: "${newDisplayName} Theme"`
     );
-    await fs__default.default.writeFile(configPath, content);
+    await fs8__default.default.writeFile(configPath, content);
   }
-  const layoutPath = path11__default.default.join(themeDir, "theme.layout.ts");
-  if (await fs__default.default.pathExists(layoutPath)) {
-    let content = await fs__default.default.readFile(layoutPath, "utf-8");
+  const layoutPath = path13__default.default.join(themeDir, "theme.layout.ts");
+  if (await fs8__default.default.pathExists(layoutPath)) {
+    let content = await fs8__default.default.readFile(layoutPath, "utf-8");
     content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
     content = content.replace(
       /name:\s*"[^"]*Theme"/,
       `name: "${newDisplayName} Theme"`
     );
-    await fs__default.default.writeFile(layoutPath, content);
+    await fs8__default.default.writeFile(layoutPath, content);
   }
   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 = path11__default.default.join(themeDir, file);
-    let content = await fs__default.default.readFile(filePath, "utf-8");
+    const filePath = path13__default.default.join(themeDir, file);
+    let content = await fs8__default.default.readFile(filePath, "utf-8");
     const original = content;
     content = content.replace(
       new RegExp(`"${oldPrefix}`, "g"),
@@ -4476,13 +4704,13 @@ async function renameTheme(themeDir, oldName, newName) {
       `${newDisplayName} Theme`
     );
     if (content !== original) {
-      await fs__default.default.writeFile(filePath, content);
+      await fs8__default.default.writeFile(filePath, content);
     }
   }
 }
 async function cloneCommand(themeName, options) {
   logger.header("Clone Theme Source");
-  const env = options.env ?? "dev";
+  const env = options.env;
   const apiUrl = getApiUrl(env);
   logger.info(`Environment: ${env}  (${apiUrl})`);
   if (options.bucket) {
@@ -4503,8 +4731,8 @@ async function cloneCommand(themeName, options) {
   }
   const spinner = ora__default.default("Initializing clone...").start();
   try {
-    const outputDir = options.output || path11__default.default.resolve(process.cwd(), newName);
-    if (await fs__default.default.pathExists(outputDir)) {
+    const outputDir = options.output || path13__default.default.resolve(process.cwd(), newName);
+    if (await fs8__default.default.pathExists(outputDir)) {
       spinner.fail(chalk4__default.default.red(`Directory already exists: ${outputDir}`));
       logger.info(
         chalk4__default.default.gray(
@@ -4537,7 +4765,7 @@ async function cloneCommand(themeName, options) {
     const sizeMB = (zipBuffer.length / 1024 / 1024).toFixed(2);
     spinner.succeed(`Downloaded source.zip (${sizeMB} MB)`);
     spinner.start(`Extracting to ${outputDir}...`);
-    await fs__default.default.ensureDir(outputDir);
+    await fs8__default.default.ensureDir(outputDir);
     const zip = new AdmZip__default.default(zipBuffer);
     zip.extractAllTo(outputDir, true);
     const entries = zip.getEntries().filter((e) => !e.isDirectory);
@@ -4549,9 +4777,9 @@ async function cloneCommand(themeName, options) {
     spinner.succeed(
       `Renamed theme: ${chalk4__default.default.gray(themeName)} \u2192 ${chalk4__default.default.cyan(newName)}`
     );
-    const envExamplePath = path11__default.default.join(outputDir, ".env.example");
-    if (!await fs__default.default.pathExists(envExamplePath)) {
-      await fs__default.default.writeFile(
+    const envExamplePath = path13__default.default.join(outputDir, ".env.example");
+    if (!await fs8__default.default.pathExists(envExamplePath)) {
+      await fs8__default.default.writeFile(
         envExamplePath,
         [
           "# API Configuration (enables real data in preview)",
@@ -4562,8 +4790,8 @@ async function cloneCommand(themeName, options) {
         ].join("\n")
       );
     }
-    const mcpJsonPath = path11__default.default.join(outputDir, ".mcp.json");
-    if (await fs__default.default.pathExists(mcpJsonPath)) {
+    const mcpJsonPath = path13__default.default.join(outputDir, ".mcp.json");
+    if (await fs8__default.default.pathExists(mcpJsonPath)) {
       const { default: inquirerMod } = await import('inquirer');
       const { figmaApiKey } = await inquirerMod.prompt([
         {
@@ -4572,7 +4800,7 @@ async function cloneCommand(themeName, options) {
           message: "Figma API Key (optional, for Figma-to-code MCP \u2014 press Enter to skip):"
         }
       ]);
-      let mcpContent = await fs__default.default.readFile(mcpJsonPath, "utf-8");
+      let mcpContent = await fs8__default.default.readFile(mcpJsonPath, "utf-8");
       if (figmaApiKey) {
         mcpContent = mcpContent.replace("__FIGMA_API_KEY__", figmaApiKey);
       } else {
@@ -4583,11 +4811,11 @@ async function cloneCommand(themeName, options) {
         } catch {
         }
       }
-      await fs__default.default.writeFile(mcpJsonPath, mcpContent, "utf-8");
+      await fs8__default.default.writeFile(mcpJsonPath, mcpContent, "utf-8");
     }
     if (options.install !== false) {
-      const hasPkgJson = await fs__default.default.pathExists(
-        path11__default.default.join(outputDir, "package.json")
+      const hasPkgJson = await fs8__default.default.pathExists(
+        path13__default.default.join(outputDir, "package.json")
       );
       if (hasPkgJson) {
         spinner.start("Installing dependencies...");
@@ -4615,7 +4843,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 ${path11__default.default.relative(process.cwd(), outputDir)}`));
+    console.log(chalk4__default.default.gray(`   cd ${path13__default.default.relative(process.cwd(), outputDir)}`));
     console.log(
       chalk4__default.default.gray("   cp .env.example .env  # then add your Company ID")
     );
@@ -4642,16 +4870,16 @@ async function devCommand(options) {
   if (options.theme) {
     themeName = options.theme;
     try {
-      const workspaceThemePath = path11__default.default.join(getThemesDir(), themeName);
-      if (fs__default.default.existsSync(workspaceThemePath)) {
+      const workspaceThemePath = path13__default.default.join(getThemesDir(), themeName);
+      if (fs8__default.default.existsSync(workspaceThemePath)) {
         themePath = workspaceThemePath;
       } else {
-        themePath = path11__default.default.join(process.cwd(), themeName);
+        themePath = path13__default.default.join(process.cwd(), themeName);
       }
     } catch {
-      themePath = path11__default.default.join(process.cwd(), themeName);
+      themePath = path13__default.default.join(process.cwd(), themeName);
     }
-    if (!fs__default.default.existsSync(themePath)) {
+    if (!fs8__default.default.existsSync(themePath)) {
       logger.error(`Theme "${themeName}" not found.`);
       process.exit(1);
     }
@@ -4659,11 +4887,14 @@ async function devCommand(options) {
     const isThemeDir2 = [
       "theme.config.ts",
       "bundle-entry.ts",
-      "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
+      "manifest.ts",
+      "next.config.ts",
+      "next.config.js",
+      "next.config.mjs"
+    ].some((f) => fs8__default.default.existsSync(path13__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
-      themeName = path11__default.default.basename(themePath);
+      themeName = path13__default.default.basename(themePath);
     } else {
       logger.error(
         "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
@@ -4732,9 +4963,9 @@ async function devCommand(options) {
     watcher.close();
     await context2.dispose();
     server.close();
-    const shimPath = path11__default.default.join(outputDir, ".process-shim.js");
+    const shimPath = path13__default.default.join(outputDir, ".process-shim.js");
     try {
-      await fs9__default.default.unlink(shimPath);
+      await fs11__default.default.unlink(shimPath);
     } catch {
     }
     process.exit(0);
@@ -4743,8 +4974,8 @@ async function devCommand(options) {
 
 // src/commands/config.ts
 init_logger();
-var CONFIG_DIR = path11__default.default.join(os__default.default.homedir(), ".onexthm");
-var CONFIG_FILE = path11__default.default.join(CONFIG_DIR, ".env");
+var CONFIG_DIR = path13__default.default.join(os__default.default.homedir(), ".onexthm");
+var CONFIG_FILE = path13__default.default.join(CONFIG_DIR, ".env");
 var CONFIG_ENTRIES = [
   {
     key: "AWS_ACCESS_KEY_ID",
@@ -4830,7 +5061,7 @@ async function configCommand() {
   logger.header("OneX CLI Configuration");
   let existing = {};
   try {
-    const content = await fs__default.default.readFile(CONFIG_FILE, "utf-8");
+    const content = await fs8__default.default.readFile(CONFIG_FILE, "utf-8");
     existing = parseEnvFile(content);
     logger.info(`Existing config found at: ${CONFIG_FILE}`);
     logger.newLine();
@@ -4866,8 +5097,8 @@ async function configCommand() {
   for (const key of Object.keys(merged)) {
     if (!merged[key]) delete merged[key];
   }
-  await fs__default.default.ensureDir(CONFIG_DIR);
-  await fs__default.default.writeFile(CONFIG_FILE, serializeEnv(merged));
+  await fs8__default.default.ensureDir(CONFIG_DIR);
+  await fs8__default.default.writeFile(CONFIG_FILE, serializeEnv(merged));
   logger.newLine();
   logger.success(`Config saved to: ${CONFIG_FILE}`);
   logger.newLine();
@@ -4886,8 +5117,8 @@ async function configCommand() {
 
 // src/commands/login.ts
 init_logger();
-async function loginCommand(options = {}) {
-  const env = options.env ?? "dev";
+async function loginCommand(options) {
+  const env = options.env;
   const apiUrl = getApiUrl(env);
   logger.header("OneX Theme Developer Login");
   logger.info(`Environment: ${env}  (${apiUrl})`);
@@ -4976,8 +5207,8 @@ async function loginCommand(options = {}) {
 
 // src/commands/logout.ts
 init_logger();
-async function logoutCommand(options = {}) {
-  const env = options.env ?? "dev";
+async function logoutCommand(options) {
+  const env = options.env;
   const tokens = loadAuthTokens(env);
   if (!tokens) {
     logger.info(`Not logged in to ${env} environment.`);
@@ -4989,8 +5220,8 @@ async function logoutCommand(options = {}) {
 
 // src/commands/whoami.ts
 init_logger();
-async function whoamiCommand(options = {}) {
-  const env = options.env ?? "dev";
+async function whoamiCommand(options) {
+  const env = options.env;
   const tokens = loadAuthTokens(env);
   if (!tokens) {
     logger.error(
@@ -5243,11 +5474,11 @@ function diffFieldList(prior, current, pathPrefix, out) {
     }
   }
 }
-function diffFieldPair(p, c, path23, out) {
+function diffFieldPair(p, c, path25, out) {
   if (p.type !== c.type) {
     out.push({
       kind: "breaking",
-      path: path23,
+      path: path25,
       detail: `Type changed (${p.type} \u2192 ${c.type}). Saved values may misrender.`
     });
     return;
@@ -5255,7 +5486,7 @@ function diffFieldPair(p, c, path23, out) {
   if (p.required !== true && c.required === true) {
     out.push({
       kind: "breaking",
-      path: path23,
+      path: path25,
       detail: "Field became required. Existing empty instances now invalid."
     });
   }
@@ -5263,7 +5494,7 @@ function diffFieldPair(p, c, path23, out) {
     if ((c.maxLength ?? Infinity) < (p.maxLength ?? Infinity)) {
       out.push({
         kind: "breaking",
-        path: path23,
+        path: path25,
         detail: `maxLength tightened (${p.maxLength ?? "\u221E"} \u2192 ${c.maxLength}).`
       });
     }
@@ -5272,7 +5503,7 @@ function diffFieldPair(p, c, path23, out) {
     if ((c.min ?? -Infinity) > (p.min ?? -Infinity)) {
       out.push({
         kind: "breaking",
-        path: path23,
+        path: path25,
         detail: `min raised (${p.min ?? "-\u221E"} \u2192 ${c.min}).`
       });
     }
@@ -5281,7 +5512,7 @@ function diffFieldPair(p, c, path23, out) {
     if ((c.max ?? Infinity) < (p.max ?? Infinity)) {
       out.push({
         kind: "breaking",
-        path: path23,
+        path: path25,
         detail: `max lowered (${p.max ?? "\u221E"} \u2192 ${c.max}).`
       });
     }
@@ -5294,14 +5525,14 @@ function diffFieldPair(p, c, path23, out) {
     if (removed.length > 0) {
       out.push({
         kind: "breaking",
-        path: path23,
+        path: path25,
         detail: `Option(s) removed: ${removed.join(", ")}. Existing saved values may be orphaned.`
       });
     }
     if (added.length > 0) {
       out.push({
         kind: "additive",
-        path: path23,
+        path: path25,
         detail: `Option(s) added: ${added.join(", ")}.`
       });
     }
@@ -5309,7 +5540,7 @@ function diffFieldPair(p, c, path23, out) {
   if (!deepEqual(p.default, c.default)) {
     out.push({
       kind: "defaults-only",
-      path: path23,
+      path: path25,
       detail: `Default changed: ${JSON.stringify(p.default)} \u2192 ${JSON.stringify(c.default)}.`
     });
   }
@@ -5367,7 +5598,7 @@ function deepEqual(a, b) {
 
 // src/commands/publish.ts
 async function publishCommand(options) {
-  const env = options.env ?? "dev";
+  const env = options.env;
   logger.header("OneX Theme Publish");
   logger.info(`Environment: ${env}  (${getApiUrl(env)})`);
   logger.newLine();
@@ -5381,13 +5612,13 @@ async function publishCommand(options) {
   logger.info(`Logged in as: ${tokens.user.email}`);
   let themePath;
   if (options.theme) {
-    themePath = path11__default.default.resolve(options.theme);
+    themePath = path13__default.default.resolve(options.theme);
   } else {
     const isThemeDir2 = [
       "theme.config.ts",
       "bundle-entry.ts",
       "manifest.ts"
-    ].some((f) => fs__default.default.existsSync(path11__default.default.join(process.cwd(), f)));
+    ].some((f) => fs8__default.default.existsSync(path13__default.default.join(process.cwd(), f)));
     if (isThemeDir2) {
       themePath = process.cwd();
     } else {
@@ -5397,13 +5628,13 @@ async function publishCommand(options) {
       process.exit(1);
     }
   }
-  const pkgPath = path11__default.default.join(themePath, "package.json");
-  if (!fs__default.default.existsSync(pkgPath)) {
+  const pkgPath = path13__default.default.join(themePath, "package.json");
+  if (!fs8__default.default.existsSync(pkgPath)) {
     logger.error("No package.json found in theme directory");
     process.exit(1);
   }
-  const pkg = fs__default.default.readJsonSync(pkgPath);
-  const themeId = pkg.name?.replace("@onex-themes/", "") || path11__default.default.basename(themePath);
+  const pkg = fs8__default.default.readJsonSync(pkgPath);
+  const themeId = pkg.name?.replace("@onex-themes/", "") || path13__default.default.basename(themePath);
   if (options.bump) {
     const currentVersion = pkg.version || "1.0.0";
     const newVersion = semver__default.default.inc(currentVersion, options.bump);
@@ -5412,7 +5643,7 @@ async function publishCommand(options) {
       process.exit(1);
     }
     pkg.version = newVersion;
-    fs__default.default.writeJsonSync(pkgPath, pkg, { spaces: 2 });
+    fs8__default.default.writeJsonSync(pkgPath, pkg, { spaces: 2 });
     logger.info(`Bumped version: ${currentVersion} -> ${newVersion}`);
   }
   const version2 = pkg.version || "1.0.0";
@@ -5519,7 +5750,7 @@ Or use the --bump flag:
     logger.error(error instanceof Error ? error.message : "Build error");
     process.exit(1);
   }
-  const distDir = path11__default.default.join(themePath, "dist");
+  const distDir = path13__default.default.join(themePath, "dist");
   const classification = await runSchemaDiffGate(
     themeId,
     distDir,
@@ -5568,8 +5799,8 @@ Or use the --bump flag:
     for (const [originalPath, url] of Object.entries(videoUrls)) {
       assetMap[originalPath] = url;
     }
-    const assetMapPath = path11__default.default.join(distDir, "asset-map.json");
-    await fs__default.default.writeFile(assetMapPath, JSON.stringify(assetMap, null, 2));
+    const assetMapPath = path13__default.default.join(distDir, "asset-map.json");
+    await fs8__default.default.writeFile(assetMapPath, JSON.stringify(assetMap, null, 2));
   } catch (error) {
     logger.error(
       `Failed to write asset-map.json: ${error instanceof Error ? error.message : "unknown"}`
@@ -5644,7 +5875,7 @@ Or use the --bump flag:
           continue;
         }
         try {
-          const buf = await fs__default.default.promises.readFile(entry.absPath);
+          const buf = await fs8__default.default.promises.readFile(entry.absPath);
           const res = await fetch(item.upload_url, {
             method: "PUT",
             headers: {
@@ -5686,12 +5917,12 @@ Or use the --bump flag:
   }
   logger.startSpinner("Uploading bundle...");
   try {
-    if (!fs__default.default.existsSync(distDir)) {
+    if (!fs8__default.default.existsSync(distDir)) {
       logger.stopSpinner(false, "No dist/ directory");
       logger.error("Build the theme first: onexthm build");
       process.exit(1);
     }
-    const bundleZipPath = path11__default.default.join(themePath, "dist", "bundle.zip");
+    const bundleZipPath = path13__default.default.join(themePath, "dist", "bundle.zip");
     await createZip(distDir, bundleZipPath, [
       "bundle.zip",
       "source.zip",
@@ -5700,7 +5931,7 @@ Or use the --bump flag:
       "theme-assets",
       "theme-assets/**"
     ]);
-    const bundleBuffer = fs__default.default.readFileSync(bundleZipPath);
+    const bundleBuffer = fs8__default.default.readFileSync(bundleZipPath);
     const bundleRes = await fetch(bundleUploadUrl, {
       method: "PUT",
       headers: { "Content-Type": "application/zip" },
@@ -5718,7 +5949,7 @@ Or use the --bump flag:
   }
   logger.startSpinner("Uploading source...");
   try {
-    const sourceZipPath = path11__default.default.join(themePath, "dist", "source.zip");
+    const sourceZipPath = path13__default.default.join(themePath, "dist", "source.zip");
     await createZip(themePath, sourceZipPath, [
       "node_modules",
       "dist",
@@ -5726,7 +5957,7 @@ Or use the --bump flag:
       ".env",
       ".env.local"
     ]);
-    const sourceBuffer = fs__default.default.readFileSync(sourceZipPath);
+    const sourceBuffer = fs8__default.default.readFileSync(sourceZipPath);
     const sourceRes = await fetch(sourceUploadUrl, {
       method: "PUT",
       headers: { "Content-Type": "application/zip" },
@@ -5804,9 +6035,9 @@ async function uploadThumbnail(apiUrl, themeId, themePath, distDir, env = "dev")
   let imageBase64 = null;
   let mimeType = "image/png";
   for (const { file, mime } of THUMBNAIL_CANDIDATES) {
-    const candidate = path11__default.default.join(themePath, file);
-    if (fs__default.default.existsSync(candidate)) {
-      const buf = fs__default.default.readFileSync(candidate);
+    const candidate = path13__default.default.join(themePath, file);
+    if (fs8__default.default.existsSync(candidate)) {
+      const buf = fs8__default.default.readFileSync(candidate);
       imageBase64 = `data:${mime};base64,${buf.toString("base64")}`;
       mimeType = mime;
       logger.info(`Using local thumbnail: ${file}`);
@@ -5906,7 +6137,7 @@ async function screenshotHomePage(themePath, distDir) {
   const { compilePreviewRuntime: compilePreviewRuntime2 } = await Promise.resolve().then(() => (init_compile_theme(), compile_theme_exports));
   const { createDevServer: createDevServer2 } = await Promise.resolve().then(() => (init_dev_server(), dev_server_exports));
   const previewRuntimePath = await compilePreviewRuntime2(themePath);
-  const themeName = path11__default.default.basename(themePath);
+  const themeName = path13__default.default.basename(themePath);
   const port = await findFreePort(4500);
   const server = createDevServer2({
     port,
@@ -5963,7 +6194,7 @@ async function findFreePort(start) {
   });
 }
 async function uploadVideoMultipart(apiUrl, themeId, video, env = "dev") {
-  const fileName = path11__default.default.basename(video.originalPath);
+  const fileName = path13__default.default.basename(video.originalPath);
   const videoInitUrl = `${apiUrl}/media/videos/multipart/init`;
   const videoInitBody = {
     file_name: fileName,
@@ -5999,7 +6230,7 @@ async function uploadVideoMultipart(apiUrl, themeId, video, env = "dev") {
     );
   }
   const { upload_id, file_key, chunk_size, chunk_urls } = initBody;
-  const fileBuffer = await fs__default.default.promises.readFile(video.absPath);
+  const fileBuffer = await fs8__default.default.promises.readFile(video.absPath);
   const CHUNK_CONCURRENCY = 4;
   const queue = [...chunk_urls];
   const parts = [];
@@ -6108,7 +6339,7 @@ async function runSchemaDiffGate(themeId, distDir, env, options) {
   let currentAssets;
   try {
     currentSchemas = JSON.parse(
-      await fs__default.default.readFile(path11__default.default.join(distDir, "schemas.json"), "utf-8")
+      await fs8__default.default.readFile(path13__default.default.join(distDir, "schemas.json"), "utf-8")
     );
   } catch (err) {
     logger.warning(
@@ -6118,7 +6349,7 @@ async function runSchemaDiffGate(themeId, distDir, env, options) {
   }
   try {
     currentAssets = JSON.parse(
-      await fs__default.default.readFile(path11__default.default.join(distDir, "asset-manifest.json"), "utf-8")
+      await fs8__default.default.readFile(path13__default.default.join(distDir, "asset-manifest.json"), "utf-8")
     );
   } catch {
     currentAssets = { manifestVersion: 1, assets: [] };
@@ -6188,24 +6419,24 @@ var AI_CONTEXT_FILES = [
   ".mcp.json"
 ];
 function resolveTargetDir(opts) {
-  return path11__default.default.resolve(opts.cwd ?? process.cwd());
+  return path13__default.default.resolve(opts.cwd ?? process.cwd());
 }
 function resolveDefaultTemplateDir() {
-  return path11__default.default.join(getTemplatesDir(), "default");
+  return path13__default.default.join(getTemplatesDir(), "default");
 }
 function isThemeDir(dir) {
-  return fs__default.default.existsSync(path11__default.default.join(dir, "theme.config.ts")) || fs__default.default.existsSync(path11__default.default.join(dir, "theme.config.js"));
+  return fs8__default.default.existsSync(path13__default.default.join(dir, "theme.config.ts")) || fs8__default.default.existsSync(path13__default.default.join(dir, "theme.config.js"));
 }
 function inspectFiles(templateDir, targetDir) {
   return AI_CONTEXT_FILES.map((name) => {
-    const templatePath = path11__default.default.join(templateDir, name);
-    const targetPath = path11__default.default.join(targetDir, name);
-    const exists = fs__default.default.existsSync(targetPath);
+    const templatePath = path13__default.default.join(templateDir, name);
+    const targetPath = path13__default.default.join(targetDir, name);
+    const exists = fs8__default.default.existsSync(targetPath);
     let identical = false;
-    if (exists && fs__default.default.existsSync(templatePath)) {
+    if (exists && fs8__default.default.existsSync(templatePath)) {
       try {
-        const a = fs__default.default.readFileSync(templatePath, "utf-8");
-        const b = fs__default.default.readFileSync(targetPath, "utf-8");
+        const a = fs8__default.default.readFileSync(templatePath, "utf-8");
+        const b = fs8__default.default.readFileSync(targetPath, "utf-8");
         identical = a.replace(/\r\n/g, "\n") === b.replace(/\r\n/g, "\n");
       } catch {
         identical = false;
@@ -6255,11 +6486,11 @@ async function mcpSetupCommand(options = {}) {
     }
   }
   for (const s of missing) {
-    if (!fs__default.default.existsSync(s.templatePath)) {
+    if (!fs8__default.default.existsSync(s.templatePath)) {
       logger.warning(`  ! ${s.name} not in template \u2014 skipped`);
       continue;
     }
-    await fs__default.default.copy(s.templatePath, s.targetPath);
+    await fs8__default.default.copy(s.templatePath, s.targetPath);
     logger.success(`  \u2713 ${s.name}`);
   }
   logger.log("");
@@ -6320,11 +6551,11 @@ async function mcpUpgradeCommand(options = {}) {
     }
   }
   for (const s of toUpgrade) {
-    if (!fs__default.default.existsSync(s.templatePath)) {
+    if (!fs8__default.default.existsSync(s.templatePath)) {
       logger.warning(`  ! ${s.name} not in template \u2014 skipped`);
       continue;
     }
-    await fs__default.default.copy(s.templatePath, s.targetPath, { overwrite: true });
+    await fs8__default.default.copy(s.templatePath, s.targetPath, { overwrite: true });
     logger.success(`  \u2713 ${s.name}`);
   }
   logger.log("");
@@ -6342,12 +6573,12 @@ async function mcpDoctorCommand(options = {}) {
     return;
   }
   logger.success("theme.config.ts present");
-  const mcpJsonPath = path11__default.default.join(targetDir, ".mcp.json");
-  if (!fs__default.default.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path13__default.default.join(targetDir, ".mcp.json");
+  if (!fs8__default.default.existsSync(mcpJsonPath)) {
     logger.error(".mcp.json missing \u2014 run `onexthm mcp setup`");
   } else {
     try {
-      const mcpJson = JSON.parse(fs__default.default.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs8__default.default.readFileSync(mcpJsonPath, "utf-8"));
       const servers = mcpJson?.mcpServers ?? {};
       if (servers.onexthm) {
         logger.success(".mcp.json registers `onexthm`");
@@ -6380,8 +6611,8 @@ async function mcpDoctorCommand(options = {}) {
       logger.success(`${s.name} up to date`);
     }
   }
-  const registryPath = path11__default.default.join(targetDir, "sections-registry.ts");
-  if (fs__default.default.existsSync(registryPath)) {
+  const registryPath = path13__default.default.join(targetDir, "sections-registry.ts");
+  if (fs8__default.default.existsSync(registryPath)) {
     logger.success("sections-registry.ts present");
   } else {
     logger.warning(
@@ -6392,24 +6623,27 @@ async function mcpDoctorCommand(options = {}) {
 
 // src/cli.ts
 dotenv__default.default.config({
-  path: path11__default.default.join(process.cwd(), ".env.local"),
+  path: path13__default.default.join(process.cwd(), ".env.local"),
   override: true
 });
-dotenv__default.default.config({ path: path11__default.default.join(process.cwd(), ".env") });
+dotenv__default.default.config({ path: path13__default.default.join(process.cwd(), ".env") });
 try {
   const projectRoot = getProjectRoot();
-  if (path11__default.default.resolve(projectRoot) !== path11__default.default.resolve(process.cwd())) {
+  if (path13__default.default.resolve(projectRoot) !== path13__default.default.resolve(process.cwd())) {
     dotenv__default.default.config({
-      path: path11__default.default.join(projectRoot, ".env.local")
+      path: path13__default.default.join(projectRoot, ".env.local")
     });
-    dotenv__default.default.config({ path: path11__default.default.join(projectRoot, ".env") });
+    dotenv__default.default.config({ path: path13__default.default.join(projectRoot, ".env") });
   }
 } catch {
 }
 dotenv__default.default.config({
-  path: path11__default.default.join(os__default.default.homedir(), ".onexthm", ".env"),
+  path: path13__default.default.join(os__default.default.homedir(), ".onexthm", ".env"),
   quiet: true
 });
+function envOpt() {
+  return new commander.Option("--env <env>", "Target environment: dev, staging, or prod").choices(["dev", "staging", "prod"]).makeOptionMandatory();
+}
 var require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)));
 var { version } = require2("../package.json");
 var program = new commander.Command();
@@ -6418,11 +6652,7 @@ program.command("init").description("Create a new OneX theme project").argument(
   "-t, --template <template>",
   "Template to use (default, minimal)",
   "default"
-).option("--no-install", "Skip installing dependencies").option("--git", "Initialize git repository").option("-y, --yes", "Skip prompts and use defaults").option(
-  "--env <env>",
-  "Target environment: dev, staging, or prod (default: dev)",
-  "dev"
-).action(initCommand);
+).option("--no-install", "Skip installing dependencies").option("--git", "Initialize git repository").option("-y, --yes", "Skip prompts and use defaults").addOption(envOpt()).action(initCommand);
 program.command("create:section").alias("cs").description("Create a new section").argument("<name>", "Name of the section (e.g., hero, features)").option("-t, --theme <theme>", "Theme to create section in").option(
   "-c, --category <category>",
   "Section category (headers, content, footers)"
@@ -6449,36 +6679,16 @@ program.command("download").description("Download a published theme via the webs
   "-v, --version <version>",
   "Theme version (default: latest)",
   "latest"
-).option(
-  "--env <env>",
-  "Target environment: dev, staging, or prod (default: dev)",
-  "dev"
-).option("-b, --bucket <name>", "[deprecated] ignored").option("-o, --output <dir>", "Output directory", "./active-theme").action(downloadCommand);
+).addOption(envOpt()).option("-b, --bucket <name>", "[deprecated] ignored").option("-o, --output <dir>", "Output directory", "./active-theme").action(downloadCommand);
 program.command("clone").description("Clone theme source code via the website-api").argument("<theme-name>", "Theme to clone").option(
   "-v, --version <version>",
   "Theme version (default: latest)",
   "latest"
-).option("-n, --name <name>", "New theme name (skips interactive prompt)").option("-o, --output <dir>", "Output directory").option(
-  "--env <env>",
-  "Target environment: dev, staging, or prod (default: dev)",
-  "dev"
-).option("-b, --bucket <name>", "[deprecated] ignored").option("--no-install", "Skip running pnpm install after clone").action(cloneCommand);
+).option("-n, --name <name>", "New theme name (skips interactive prompt)").option("-o, --output <dir>", "Output directory").addOption(envOpt()).option("-b, --bucket <name>", "[deprecated] ignored").option("--no-install", "Skip running pnpm install after clone").action(cloneCommand);
 program.command("config").description("Configure OneX CLI credentials (AWS, API keys)").action(configCommand);
-program.command("login").description("Login to OneX platform").option(
-  "--env <env>",
-  "Target environment: dev, staging, or prod (default: dev)",
-  "dev"
-).action(loginCommand);
-program.command("logout").description("Logout from OneX platform").option(
-  "--env <env>",
-  "Target environment: dev, staging, or prod (default: dev)",
-  "dev"
-).action(logoutCommand);
-program.command("whoami").description("Show current logged-in developer").option(
-  "--env <env>",
-  "Target environment: dev, staging, or prod (default: dev)",
-  "dev"
-).action(whoamiCommand);
+program.command("login").description("Login to OneX platform").addOption(envOpt()).action(loginCommand);
+program.command("logout").description("Logout from OneX platform").addOption(envOpt()).action(logoutCommand);
+program.command("whoami").description("Show current logged-in developer").addOption(envOpt()).action(whoamiCommand);
 var mcpCmd = program.command("mcp").description("Manage MCP server registration and AI-context files");
 mcpCmd.command("setup").description(
   "Install .mcp.json + CLAUDE.md + AGENTS.md + .cursorrules into the current theme"
@@ -6490,11 +6700,7 @@ mcpCmd.command("doctor").description("Diagnose MCP setup in the current theme di
 program.command("publish").description("Build, scan, and publish theme to marketplace (requires login)").option("-t, --theme <path>", "Theme directory path").option(
   "--bump <type>",
   "Auto-bump version before publish (patch|minor|major)"
-).option(
-  "--env <env>",
-  "Target environment: dev, staging, or prod (default: dev)",
-  "dev"
-).option(
+).addOption(envOpt()).option(
   "--dry-run",
   "Build locally and print the schema-diff classification without publishing"
 ).option(