@onexapis/cli 1.0.4 → 1.1.0

package/dist/index.js

@@ -1,11 +1,15 @@
 'use strict';
 
+var chalk4 = require('chalk');
+var ora = require('ora');
+var esbuild = require('esbuild');
 var path = require('path');
+var fs6 = require('fs/promises');
+var crypto = require('crypto');
+var glob = require('glob');
 var fs2 = require('fs');
 var child_process = require('child_process');
 var inquirer = require('inquirer');
-var chalk4 = require('chalk');
-var ora = require('ora');
 var fs = require('fs-extra');
 var ejs = require('ejs');
 var clientS3 = require('@aws-sdk/client-s3');
@@ -15,17 +19,40 @@ var AdmZip = require('adm-zip');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+var esbuild__namespace = /*#__PURE__*/_interopNamespace(esbuild);
 var path__default = /*#__PURE__*/_interopDefault(path);
+var fs6__default = /*#__PURE__*/_interopDefault(fs6);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var fs2__default = /*#__PURE__*/_interopDefault(fs2);
 var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
-var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
-var ora__default = /*#__PURE__*/_interopDefault(ora);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var ejs__default = /*#__PURE__*/_interopDefault(ejs);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var archiver__default = /*#__PURE__*/_interopDefault(archiver);
 var AdmZip__default = /*#__PURE__*/_interopDefault(AdmZip);
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -33,58 +60,644 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
-var Logger = class {
-  constructor() {
-    this.spinner = null;
-  }
-  success(message) {
-    console.log(chalk4__default.default.green("\u2713"), message);
-  }
-  error(message) {
-    console.log(chalk4__default.default.red("\u2717"), message);
+exports.Logger = void 0; exports.logger = void 0;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    exports.Logger = class {
+      constructor() {
+        this.spinner = null;
+      }
+      success(message) {
+        console.log(chalk4__default.default.green("\u2713"), message);
+      }
+      error(message) {
+        console.log(chalk4__default.default.red("\u2717"), message);
+      }
+      warning(message) {
+        console.log(chalk4__default.default.yellow("\u26A0"), message);
+      }
+      info(message) {
+        console.log(chalk4__default.default.blue("\u2139"), message);
+      }
+      log(message) {
+        console.log(message);
+      }
+      startSpinner(message) {
+        this.spinner = ora__default.default(message).start();
+      }
+      stopSpinner(success = true, message) {
+        if (!this.spinner) return;
+        if (success) {
+          this.spinner.succeed(message);
+        } else {
+          this.spinner.fail(message);
+        }
+        this.spinner = null;
+      }
+      updateSpinner(message) {
+        if (this.spinner) {
+          this.spinner.text = message;
+        }
+      }
+      newLine() {
+        console.log();
+      }
+      header(message) {
+        console.log();
+        console.log(chalk4__default.default.bold.cyan(message));
+        console.log(chalk4__default.default.cyan("=".repeat(message.length)));
+        console.log();
+      }
+      section(message) {
+        console.log();
+        console.log(chalk4__default.default.bold(message));
+      }
+    };
+    exports.logger = new exports.Logger();
   }
-  warning(message) {
-    console.log(chalk4__default.default.yellow("\u26A0"), message);
+});
+
+// src/utils/compile-theme.ts
+var compile_theme_exports = {};
+__export(compile_theme_exports, {
+  compilePreviewRuntime: () => compilePreviewRuntime,
+  compileStandaloneTheme: () => compileStandaloneTheme,
+  compileStandaloneThemeDev: () => compileStandaloneThemeDev,
+  generateManifest: () => generateManifest2
+});
+async function resolveNodeModulesFile(startDir, relativePath) {
+  let dir = startDir;
+  while (true) {
+    const candidate = path__default.default.join(dir, "node_modules", relativePath);
+    try {
+      await fs6__default.default.access(candidate);
+      return candidate;
+    } catch (e) {
+      const parent = path__default.default.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
   }
-  info(message) {
-    console.log(chalk4__default.default.blue("\u2139"), message);
+  return null;
+}
+function createCoreGlobalPlugin(themePath) {
+  const exportsBySubpath = {};
+  return {
+    name: "core-global",
+    setup(build2) {
+      build2.onResolve({ filter: /^@onexapis\/core(\/.*)?$/ }, (args) => ({
+        path: args.path,
+        namespace: "core-global"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "core-global" }, async (args) => {
+        const match = args.path.match(/^@onexapis\/core(\/(.+))?$/);
+        const subpath = (match == null ? void 0 : match[2]) || "";
+        const moduleAccess = subpath ? `['${subpath}']` : "";
+        let namedExports = [];
+        const cacheKey = subpath || "__root__";
+        if (exportsBySubpath[cacheKey]) {
+          namedExports = exportsBySubpath[cacheKey];
+        } else {
+          const distFileName = subpath ? `${subpath}.mjs` : "index.mjs";
+          const distPath = await resolveNodeModulesFile(
+            themePath,
+            path__default.default.join("@onexapis", "core", "dist", distFileName)
+          );
+          try {
+            if (!distPath) throw new Error("not found");
+            const distContent = await fs6__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) => {
+                const parts = n.trim().split(/\s+as\s+/);
+                return (parts[1] || parts[0]).trim();
+              }).filter((n) => n.length > 0);
+              namedExports.push(...names);
+            }
+            namedExports = [...new Set(namedExports)];
+          } catch (e) {
+          }
+          exportsBySubpath[cacheKey] = namedExports;
+        }
+        const namedExportLines = namedExports.length > 0 ? `
+export const {
+  ${namedExports.join(",\n  ")}
+} = _module;
+` : "";
+        return {
+          contents: `
+if (!globalThis.__ONEX_CORE__) {
+  throw new Error('[Theme Bundle] @onexapis/core not initialized. Ensure globalThis.__ONEX_CORE__ is set before loading theme.');
+}
+
+const _module = globalThis.__ONEX_CORE__${moduleAccess};
+if (!_module) {
+  const subpath = ${subpath ? `'${subpath}'` : "null"};
+  const modulePath = subpath ? '/' + subpath : '';
+  const moduleKey = subpath ? '["' + subpath + '"]' : '';
+  throw new Error('[Theme Bundle] @onexapis/core' + modulePath + ' not available in globalThis.__ONEX_CORE__' + moduleKey);
+}
+
+export default _module;
+${namedExportLines}
+            `.trim(),
+          loader: "js"
+        };
+      });
+    }
+  };
+}
+async function contentHashEntry(outputDir) {
+  const entryPath = path__default.default.join(outputDir, "bundle-entry.js");
+  const mapPath = path__default.default.join(outputDir, "bundle-entry.js.map");
+  const oldFiles = await glob.glob("bundle-entry-*.js*", { cwd: outputDir });
+  for (const f of oldFiles) {
+    await fs6__default.default.unlink(path__default.default.join(outputDir, f));
   }
-  log(message) {
-    console.log(message);
+  let entryContent;
+  try {
+    entryContent = await fs6__default.default.readFile(entryPath, "utf-8");
+  } catch (e) {
+    const indexPath = path__default.default.join(outputDir, "index.js");
+    try {
+      entryContent = await fs6__default.default.readFile(indexPath, "utf-8");
+    } catch (e2) {
+      exports.logger.warning("No entry file found in output, skipping content hash");
+      return;
+    }
+    const hash2 = crypto__default.default.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
+    const hashedName2 = `bundle-entry-${hash2}.js`;
+    const indexMapPath = path__default.default.join(outputDir, "index.js.map");
+    const hashedMapName2 = `bundle-entry-${hash2}.js.map`;
+    entryContent = entryContent.replace(
+      /\/\/# sourceMappingURL=index\.js\.map/,
+      `//# sourceMappingURL=${hashedMapName2}`
+    );
+    await fs6__default.default.writeFile(path__default.default.join(outputDir, hashedName2), entryContent);
+    await fs6__default.default.unlink(indexPath);
+    try {
+      await fs6__default.default.access(indexMapPath);
+      await fs6__default.default.rename(indexMapPath, path__default.default.join(outputDir, hashedMapName2));
+    } catch (e2) {
+    }
+    exports.logger.info(`Entry hashed: ${hashedName2}`);
+    return;
   }
-  startSpinner(message) {
-    this.spinner = ora__default.default(message).start();
+  const hash = crypto__default.default.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
+  const hashedName = `bundle-entry-${hash}.js`;
+  const hashedMapName = `bundle-entry-${hash}.js.map`;
+  entryContent = entryContent.replace(
+    /\/\/# sourceMappingURL=bundle-entry\.js\.map/,
+    `//# sourceMappingURL=${hashedMapName}`
+  );
+  await fs6__default.default.writeFile(path__default.default.join(outputDir, hashedName), entryContent);
+  await fs6__default.default.unlink(entryPath);
+  try {
+    await fs6__default.default.access(mapPath);
+    await fs6__default.default.rename(mapPath, path__default.default.join(outputDir, hashedMapName));
+  } catch (e) {
   }
-  stopSpinner(success = true, message) {
-    if (!this.spinner) return;
-    if (success) {
-      this.spinner.succeed(message);
-    } else {
-      this.spinner.fail(message);
+  exports.logger.info(`Entry hashed: ${hashedName}`);
+}
+async function generateManifest2(themeName, themePath, outputDir) {
+  let version = "1.0.0";
+  let themeId = themeName;
+  try {
+    const pkgContent = await fs6__default.default.readFile(
+      path__default.default.join(themePath, "package.json"),
+      "utf-8"
+    );
+    const pkg = JSON.parse(pkgContent);
+    version = pkg.version || version;
+    if (pkg.name) {
+      themeId = pkg.name.replace(/^@onex-themes\//, "");
     }
-    this.spinner = null;
+  } catch (e) {
   }
-  updateSpinner(message) {
-    if (this.spinner) {
-      this.spinner.text = message;
+  const [sectionFiles, blockFiles, schemaFiles] = await Promise.all([
+    glob.glob("sections/**/index.ts", { cwd: themePath }),
+    glob.glob("blocks/**/index.ts", { cwd: themePath }),
+    glob.glob("**/*.schema.ts", { cwd: themePath })
+  ]);
+  let hasThemeConfig = false;
+  try {
+    await fs6__default.default.access(path__default.default.join(themePath, "theme.config.ts"));
+    hasThemeConfig = true;
+  } catch (e) {
+  }
+  const allFiles = await glob.glob("**/*", { cwd: outputDir, nodir: true });
+  const jsFiles = allFiles.filter((f) => f.endsWith(".js"));
+  const cssFiles = allFiles.filter((f) => f.endsWith(".css"));
+  const entryFile = jsFiles.find((f) => f.includes("bundle-entry")) || "bundle-entry.js";
+  const manifest = {
+    themeId,
+    version,
+    name: themeId.charAt(0).toUpperCase() + themeId.slice(1),
+    compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    format: "esm",
+    platform: "browser",
+    target: "es2020",
+    counts: {
+      sections: sectionFiles.length,
+      blocks: blockFiles.length,
+      schemas: schemaFiles.length
+    },
+    output: {
+      entry: entryFile,
+      chunks: jsFiles.filter((f) => f !== entryFile && !f.endsWith(".map")),
+      assets: allFiles.filter(
+        (f) => [".png", ".jpg", ".jpeg", ".svg", ".gif", ".webp"].some(
+          (ext) => f.endsWith(ext)
+        )
+      ),
+      stylesheets: cssFiles
+    },
+    external: ["react", "react-dom", "@onexapis/core"],
+    source: {
+      sections: sectionFiles,
+      blocks: blockFiles,
+      schemas: schemaFiles,
+      hasThemeConfig
     }
+  };
+  await fs6__default.default.writeFile(
+    path__default.default.join(outputDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2)
+  );
+}
+async function compileStandaloneTheme(themePath, themeName) {
+  const outputDir = path__default.default.join(themePath, "dist");
+  const bundleEntry = path__default.default.join(themePath, "bundle-entry.ts");
+  const indexEntry = path__default.default.join(themePath, "index.ts");
+  let entryPoint = indexEntry;
+  try {
+    await fs6__default.default.access(bundleEntry);
+    entryPoint = bundleEntry;
+  } catch (e) {
+  }
+  const shimPath = path__default.default.join(outputDir, ".process-shim.js");
+  await fs6__default.default.mkdir(outputDir, { recursive: true });
+  await fs6__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const buildOptions = {
+    entryPoints: [entryPoint],
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    outdir: outputDir,
+    splitting: false,
+    chunkNames: "[name]-[hash]",
+    banner: {
+      js: '"use client";'
+    },
+    plugins: [reactGlobalPlugin, createCoreGlobalPlugin(themePath)],
+    external: [],
+    alias: {
+      events: "events/",
+      buffer: "buffer/"
+    },
+    inject: [shimPath],
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("production"),
+      global: "globalThis"
+    },
+    minify: true,
+    sourcemap: true,
+    logLevel: "warning",
+    target: "es2020",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    loader: {
+      ".tsx": "tsx",
+      ".ts": "ts",
+      ".jpg": "file",
+      ".jpeg": "file",
+      ".png": "file",
+      ".gif": "file",
+      ".svg": "file",
+      ".webp": "file"
+    },
+    assetNames: "assets/[name]-[hash]",
+    publicPath: "./",
+    metafile: true
+  };
+  try {
+    const result = await esbuild__namespace.build(buildOptions);
+    try {
+      await fs6__default.default.unlink(shimPath);
+    } catch (e) {
+    }
+    await contentHashEntry(outputDir);
+    await generateManifest2(themeName, themePath, outputDir);
+    if (result.metafile) {
+      const outputs = result.metafile.outputs;
+      let totalSize = 0;
+      for (const output of Object.values(outputs)) {
+        totalSize += output.bytes;
+      }
+      const totalKB = (totalSize / 1024).toFixed(2);
+      exports.logger.info(`Bundle size: ${totalKB} KB`);
+    }
+    return true;
+  } catch (error) {
+    try {
+      await fs6__default.default.unlink(shimPath);
+    } catch (e) {
+    }
+    exports.logger.error(`esbuild compilation failed: ${error}`);
+    return false;
   }
-  newLine() {
-    console.log();
+}
+async function compileStandaloneThemeDev(themePath, themeName) {
+  const outputDir = path__default.default.join(themePath, "dist");
+  const bundleEntry = path__default.default.join(themePath, "bundle-entry.ts");
+  const indexEntry = path__default.default.join(themePath, "index.ts");
+  let entryPoint = indexEntry;
+  try {
+    await fs6__default.default.access(bundleEntry);
+    entryPoint = bundleEntry;
+  } catch (e) {
+  }
+  const shimPath = path__default.default.join(outputDir, ".process-shim.js");
+  await fs6__default.default.mkdir(outputDir, { recursive: true });
+  await fs6__default.default.writeFile(shimPath, PROCESS_SHIM);
+  const buildOptions = {
+    entryPoints: [entryPoint],
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    outdir: outputDir,
+    splitting: false,
+    banner: {
+      js: '"use client";'
+    },
+    plugins: [reactGlobalPlugin, createCoreGlobalPlugin(themePath)],
+    external: [],
+    alias: {
+      events: "events/",
+      buffer: "buffer/"
+    },
+    inject: [shimPath],
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("development"),
+      global: "globalThis"
+    },
+    minify: false,
+    sourcemap: true,
+    logLevel: "warning",
+    target: "es2020",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    loader: {
+      ".tsx": "tsx",
+      ".ts": "ts",
+      ".jpg": "file",
+      ".jpeg": "file",
+      ".png": "file",
+      ".gif": "file",
+      ".svg": "file",
+      ".webp": "file"
+    },
+    assetNames: "assets/[name]-[hash]",
+    publicPath: "./",
+    metafile: true
+  };
+  const context2 = await esbuild__namespace.context(buildOptions);
+  await context2.rebuild();
+  await generateManifest2(themeName, themePath, outputDir);
+  return { context: context2, outputDir };
+}
+async function compilePreviewRuntime(themePath) {
+  const outputDir = path__default.default.join(themePath, "dist");
+  await fs6__default.default.mkdir(outputDir, { recursive: true });
+  const outputPath = path__default.default.join(outputDir, "preview-runtime.js");
+  const locations = [
+    path__default.default.join(__dirname, "..", "preview", "preview-app.tsx"),
+    path__default.default.join(__dirname, "preview", "preview-app.tsx"),
+    path__default.default.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
+  ];
+  let previewEntryPath = null;
+  for (const loc of locations) {
+    try {
+      await fs6__default.default.access(loc);
+      previewEntryPath = loc;
+      break;
+    } catch (e) {
+    }
   }
-  header(message) {
-    console.log();
-    console.log(chalk4__default.default.bold.cyan(message));
-    console.log(chalk4__default.default.cyan("=".repeat(message.length)));
-    console.log();
+  if (!previewEntryPath) {
+    throw new Error(
+      `Preview app source not found. Searched:
+${locations.join("\n")}`
+    );
   }
-  section(message) {
-    console.log();
-    console.log(chalk4__default.default.bold(message));
+  const serverStubPlugin = {
+    name: "server-stub",
+    setup(build2) {
+      build2.onResolve({ filter: /^server-only$/ }, () => ({
+        path: "server-only",
+        namespace: "server-stub"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "server-stub" }, () => ({
+        contents: "// server-only stub for browser",
+        loader: "js"
+      }));
+      const nodeBuiltins = [
+        "fs",
+        "fs/promises",
+        "path",
+        "os",
+        "crypto",
+        "stream",
+        "url",
+        "http",
+        "https",
+        "net",
+        "tls",
+        "child_process",
+        "util",
+        "events",
+        "buffer",
+        "querystring",
+        "zlib"
+      ];
+      for (const mod of nodeBuiltins) {
+        build2.onResolve({ filter: new RegExp(`^${mod.replace("/", "\\/")}$`) }, () => ({
+          path: mod,
+          namespace: "node-stub"
+        }));
+      }
+      build2.onLoad({ filter: /.*/, namespace: "node-stub" }, (args) => {
+        const stubs = {
+          events: "export class EventEmitter { on(){return this} off(){return this} emit(){return false} addListener(){return this} removeListener(){return this} } export default { EventEmitter };",
+          path: "export function join(){return ''} export function resolve(){return ''} export function dirname(){return ''} export function basename(){return ''} export function extname(){return ''} export default {};",
+          fs: "export const promises = {}; export function readFileSync(){return ''} export function existsSync(){return false} export default {};"
+        };
+        return {
+          contents: stubs[args.path] || "export default {};",
+          loader: "js"
+        };
+      });
+    }
+  };
+  await esbuild__namespace.build({
+    entryPoints: [previewEntryPath],
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    outfile: outputPath,
+    // Bundle React + core INTO the output (NOT externalized)
+    external: [],
+    plugins: [serverStubPlugin],
+    minify: false,
+    sourcemap: true,
+    target: "es2020",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("development"),
+      global: "globalThis"
+    },
+    loader: { ".tsx": "tsx", ".ts": "ts" },
+    // Force CJS resolution to avoid sideEffects:false dropping ESM chunk imports
+    conditions: ["require", "default"],
+    mainFields: ["main"],
+    logOverride: {
+      "ignored-bare-import": "silent"
+    }
+  });
+  return outputPath;
+}
+var PROCESS_SHIM, reactGlobalPlugin;
+var init_compile_theme = __esm({
+  "src/utils/compile-theme.ts"() {
+    init_logger();
+    PROCESS_SHIM = `
+if (typeof process === "undefined") {
+  globalThis.process = {
+    env: {},
+    browser: true,
+  };
+}
+`;
+    reactGlobalPlugin = {
+      name: "react-global",
+      setup(build2) {
+        build2.onResolve({ filter: /^react$/ }, () => ({
+          path: "react-external",
+          namespace: "react-global"
+        }));
+        build2.onResolve({ filter: /^react-dom$/ }, () => ({
+          path: "react-dom-external",
+          namespace: "react-global"
+        }));
+        build2.onResolve({ filter: /^react\/jsx-runtime$/ }, () => ({
+          path: "react-jsx-runtime-external",
+          namespace: "react-global"
+        }));
+        build2.onLoad({ filter: /.*/, namespace: "react-global" }, (args) => {
+          if (args.path === "react-external") {
+            return {
+              contents: `
+if (!globalThis.__ONEX_REACT__) {
+  throw new Error('[Theme Bundle] React not initialized. Ensure globalThis.__ONEX_REACT__ is set before loading theme.');
+}
+
+const React = globalThis.__ONEX_REACT__;
+export default React;
+
+export const {
+  useState,
+  useEffect,
+  useContext,
+  useReducer,
+  useCallback,
+  useMemo,
+  useRef,
+  useImperativeHandle,
+  useLayoutEffect,
+  useDebugValue,
+  useDeferredValue,
+  useTransition,
+  useId,
+  useSyncExternalStore,
+  useInsertionEffect,
+  createContext,
+  forwardRef,
+  lazy,
+  memo,
+  startTransition,
+  createElement,
+  cloneElement,
+  isValidElement,
+  Children,
+  Fragment,
+  Profiler,
+  StrictMode,
+  Suspense,
+  Component,
+  PureComponent,
+  useActionState,
+  use,
+} = React;
+          `.trim(),
+              loader: "js"
+            };
+          }
+          if (args.path === "react-dom-external") {
+            return {
+              contents: `
+if (!globalThis.__ONEX_REACT_DOM__) {
+  throw new Error('[Theme Bundle] ReactDOM not initialized. Ensure globalThis.__ONEX_REACT_DOM__ is set before loading theme.');
+}
+
+const ReactDOM = globalThis.__ONEX_REACT_DOM__;
+export default ReactDOM;
+
+export const {
+  createRoot,
+  hydrateRoot,
+  flushSync,
+  createPortal,
+  findDOMNode,
+  render,
+  hydrate,
+  unmountComponentAtNode,
+} = ReactDOM;
+          `.trim(),
+              loader: "js"
+            };
+          }
+          if (args.path === "react-jsx-runtime-external") {
+            return {
+              contents: `
+if (!globalThis.__ONEX_JSX_RUNTIME__) {
+  throw new Error('[Theme Bundle] React JSX runtime not initialized. Ensure globalThis.__ONEX_JSX_RUNTIME__ is set before loading theme.');
+}
+const _jsxRuntime = globalThis.__ONEX_JSX_RUNTIME__;
+export const jsx = _jsxRuntime.jsx;
+export const jsxs = _jsxRuntime.jsxs;
+export const Fragment = _jsxRuntime.Fragment;
+          `.trim(),
+              loader: "js"
+            };
+          }
+          return null;
+        });
+      }
+    };
   }
-};
-var logger = new Logger();
+});
+
+// src/commands/init.ts
+init_logger();
 
 // src/utils/validators.ts
 function validateName(name) {
@@ -104,8 +717,8 @@ function validateThemeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name);
 }
 function pathExists(filePath) {
-  const fs10 = __require("fs-extra");
-  return fs10.existsSync(filePath);
+  const fs11 = __require("fs-extra");
+  return fs11.existsSync(filePath);
 }
 function validateCategory(category) {
   const validCategories = [
@@ -138,6 +751,9 @@ function getValidCategories() {
     "contact"
   ];
 }
+
+// src/utils/file-helpers.ts
+init_logger();
 async function renderTemplate(templatePath, data) {
   const template = await fs__default.default.readFile(templatePath, "utf-8");
   return ejs__default.default.render(template, data);
@@ -223,8 +839,10 @@ function getProjectRoot() {
 }
 function getThemesDir() {
   const root = getProjectRoot();
-  if (fs__default.default.existsSync(path__default.default.join(root, "themes"))) return path__default.default.join(root, "themes");
-  if (fs__default.default.existsSync(path__default.default.join(root, "src/themes"))) return path__default.default.join(root, "src/themes");
+  if (fs__default.default.existsSync(path__default.default.join(root, "themes")))
+    return path__default.default.join(root, "themes");
+  if (fs__default.default.existsSync(path__default.default.join(root, "src/themes")))
+    return path__default.default.join(root, "src/themes");
   return path__default.default.dirname(root);
 }
 function getFeaturesDir() {
@@ -236,7 +854,7 @@ function isOneXProject() {
 }
 function ensureOneXProject() {
   if (!isOneXProject()) {
-    logger.error(
+    exports.logger.error(
       "Not in a OneX project. Please run this command from a OneX project root."
     );
     process.exit(1);
@@ -284,7 +902,7 @@ async function installDependencies(projectPath, packageManager = "npm") {
 
 // src/commands/init.ts
 async function initCommand(projectName, options = {}) {
-  logger.header("Create New OneX Theme Project");
+  exports.logger.header("Create New OneX Theme Project");
   let name;
   if (!projectName) {
     const { inputName } = await inquirer__default.default.prompt([
@@ -311,7 +929,7 @@ async function initCommand(projectName, options = {}) {
   }
   const projectPath = path__default.default.join(process.cwd(), name);
   if (fs2__default.default.existsSync(projectPath)) {
-    logger.error(`Directory "${name}" already exists.`);
+    exports.logger.error(`Directory "${name}" already exists.`);
     process.exit(1);
   }
   let displayName;
@@ -368,7 +986,7 @@ async function initCommand(projectName, options = {}) {
     author,
     template
   };
-  logger.startSpinner("Creating project structure...");
+  exports.logger.startSpinner("Creating project structure...");
   try {
     fs2__default.default.mkdirSync(projectPath, { recursive: true });
     await copyTemplate(template, projectPath, data);
@@ -404,9 +1022,9 @@ Add your theme-specific blocks here.
     fs2__default.default.mkdirSync(pagesPath, { recursive: true });
     const homePageContent = generateHomePage(data);
     await writeFile(path__default.default.join(pagesPath, "home.ts"), homePageContent);
-    logger.stopSpinner(true, "Project structure created!");
+    exports.logger.stopSpinner(true, "Project structure created!");
     if (options.git) {
-      logger.startSpinner("Initializing git repository...");
+      exports.logger.startSpinner("Initializing git repository...");
       try {
         child_process.execSync("git init", { cwd: projectPath, stdio: "ignore" });
         child_process.execSync("git add .", { cwd: projectPath, stdio: "ignore" });
@@ -414,52 +1032,52 @@ Add your theme-specific blocks here.
           cwd: projectPath,
           stdio: "ignore"
         });
-        logger.stopSpinner(true, "Git repository initialized!");
+        exports.logger.stopSpinner(true, "Git repository initialized!");
       } catch (e) {
-        logger.stopSpinner(false, "Failed to initialize git");
+        exports.logger.stopSpinner(false, "Failed to initialize git");
       }
     }
     if (!options.noInstall) {
-      logger.newLine();
+      exports.logger.newLine();
       const packageManager = detectPackageManager();
-      logger.startSpinner(`Installing dependencies with ${packageManager}...`);
+      exports.logger.startSpinner(`Installing dependencies with ${packageManager}...`);
       try {
         await installDependencies(projectPath, packageManager);
-        logger.stopSpinner(true, "Dependencies installed!");
+        exports.logger.stopSpinner(true, "Dependencies installed!");
       } catch (e) {
-        logger.stopSpinner(false, "Failed to install dependencies");
-        logger.info(
+        exports.logger.stopSpinner(false, "Failed to install dependencies");
+        exports.logger.info(
           "You can install dependencies manually by running: cd " + name + " && npm install"
         );
       }
     }
-    logger.newLine();
-    logger.section("Success! \u{1F389}");
-    logger.newLine();
-    logger.info(`Created OneX theme project at: ${projectPath}`);
-    logger.newLine();
-    logger.section("Next steps:");
-    logger.log(`  cd ${name}`);
+    exports.logger.newLine();
+    exports.logger.section("Success! \u{1F389}");
+    exports.logger.newLine();
+    exports.logger.info(`Created OneX theme project at: ${projectPath}`);
+    exports.logger.newLine();
+    exports.logger.section("Next steps:");
+    exports.logger.log(`  cd ${name}`);
     if (options.noInstall) {
-      logger.log(`  npm install`);
-    }
-    logger.log(`  npm run build      # Build your theme`);
-    logger.log(`  npm run dev        # Start development mode`);
-    logger.newLine();
-    logger.section("Theme structure:");
-    logger.log("  src/manifest.ts    - Theme manifest and exports");
-    logger.log(
+      exports.logger.log(`  npm install`);
+    }
+    exports.logger.log(`  npm run build      # Build your theme`);
+    exports.logger.log(`  npm run dev        # Start development mode`);
+    exports.logger.newLine();
+    exports.logger.section("Theme structure:");
+    exports.logger.log("  src/manifest.ts    - Theme manifest and exports");
+    exports.logger.log(
       "  src/config.ts      - Design tokens (colors, typography, etc.)"
     );
-    logger.log("  src/layout.ts      - Header and footer configuration");
-    logger.log("  src/sections/      - Custom sections for your theme");
-    logger.log("  src/blocks/        - Reusable blocks");
-    logger.log("  src/pages/         - Page configurations");
-    logger.newLine();
-    logger.success(`Happy theming! \u{1F3A8}`);
+    exports.logger.log("  src/layout.ts      - Header and footer configuration");
+    exports.logger.log("  src/sections/      - Custom sections for your theme");
+    exports.logger.log("  src/blocks/        - Reusable blocks");
+    exports.logger.log("  src/pages/         - Page configurations");
+    exports.logger.newLine();
+    exports.logger.success(`Happy theming! \u{1F3A8}`);
   } catch (error) {
-    logger.stopSpinner(false, "Failed to create project");
-    logger.error(
+    exports.logger.stopSpinner(false, "Failed to create project");
+    exports.logger.error(
       error instanceof Error ? error.message : "Unknown error occurred"
     );
     if (fs2__default.default.existsSync(projectPath)) {
@@ -694,8 +1312,11 @@ export const homePageConfig: PageConfig = {
 };
 `;
 }
+
+// src/commands/create-section.ts
+init_logger();
 async function createSectionCommand(name, options) {
-  logger.header("Create New Section");
+  exports.logger.header("Create New Section");
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
@@ -707,7 +1328,7 @@ async function createSectionCommand(name, options) {
   }
   const sectionName = toKebabCase(name);
   if (!validateName(sectionName)) {
-    logger.error(
+    exports.logger.error(
       `Invalid section name: ${sectionName}. Use kebab-case (e.g., hero, featured-products)`
     );
     process.exit(1);
@@ -752,7 +1373,7 @@ async function createSectionCommand(name, options) {
   const description = answers.description;
   const createTemplate = answers.createTemplate;
   if (!themeExists(themeName)) {
-    logger.error(`Theme "${themeName}" does not exist.`);
+    exports.logger.error(`Theme "${themeName}" does not exist.`);
     process.exit(1);
   }
   const data = {
@@ -763,7 +1384,7 @@ async function createSectionCommand(name, options) {
     displayName,
     description
   };
-  logger.startSpinner("Creating section files...");
+  exports.logger.startSpinner("Creating section files...");
   try {
     const themePath = path__default.default.join(getThemesDir(), themeName);
     const sectionPath = path__default.default.join(themePath, "sections", sectionName);
@@ -781,25 +1402,25 @@ async function createSectionCommand(name, options) {
     }
     const indexContent = generateSectionIndex(data, createTemplate);
     await writeFile(path__default.default.join(sectionPath, "index.ts"), indexContent);
-    logger.stopSpinner(true, "Section files created successfully!");
-    logger.newLine();
-    logger.section("Next steps:");
-    logger.log(
+    exports.logger.stopSpinner(true, "Section files created successfully!");
+    exports.logger.newLine();
+    exports.logger.section("Next steps:");
+    exports.logger.log(
       `  1. Edit schema: ${path__default.default.relative(process.cwd(), path__default.default.join(sectionPath, `${sectionName}.schema.ts`))}`
     );
     if (createTemplate) {
-      logger.log(
+      exports.logger.log(
         `  2. Edit template: ${path__default.default.relative(process.cwd(), path__default.default.join(sectionPath, `${sectionName}-default.tsx`))}`
       );
     }
-    logger.log(
+    exports.logger.log(
       `  3. Add to theme manifest: ${path__default.default.relative(process.cwd(), path__default.default.join(themePath, "manifest.ts"))}`
     );
-    logger.newLine();
-    logger.success("Section created successfully!");
+    exports.logger.newLine();
+    exports.logger.success("Section created successfully!");
   } catch (error) {
-    logger.stopSpinner(false, "Failed to create section");
-    logger.error(
+    exports.logger.stopSpinner(false, "Failed to create section");
+    exports.logger.error(
       error instanceof Error ? error.message : "Unknown error occurred"
     );
     process.exit(1);
@@ -933,8 +1554,11 @@ export { ${data.sectionName}Schema } from "./${data.sectionName}.schema";
 ${hasTemplate ? `export { ${data.sectionNamePascal}Default } from "./${data.sectionName}-default";` : ""}
 `;
 }
+
+// src/commands/create-block.ts
+init_logger();
 async function createBlockCommand(name, options) {
-  logger.header("Create New Block");
+  exports.logger.header("Create New Block");
   ensureOneXProject();
   if (!options.theme) {
     const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
@@ -946,7 +1570,7 @@ async function createBlockCommand(name, options) {
   }
   const blockName = toKebabCase(name);
   if (!validateName(blockName)) {
-    logger.error(
+    exports.logger.error(
       `Invalid block name: ${blockName}. Use kebab-case (e.g., product-card, testimonial-item)`
     );
     process.exit(1);
@@ -1001,7 +1625,7 @@ async function createBlockCommand(name, options) {
   const hasComponents = answers.hasComponents;
   const hasNestedBlocks = answers.hasNestedBlocks;
   if (scope === "theme" && !themeExists(themeName)) {
-    logger.error(`Theme "${themeName}" does not exist.`);
+    exports.logger.error(`Theme "${themeName}" does not exist.`);
     process.exit(1);
   }
   const data = {
@@ -1014,7 +1638,7 @@ async function createBlockCommand(name, options) {
     scope,
     themeName
   };
-  logger.startSpinner("Creating block files...");
+  exports.logger.startSpinner("Creating block files...");
   try {
     const blockPath = scope === "shared" ? path__default.default.join(getFeaturesDir(), "blocks", blockName) : path__default.default.join(getThemesDir(), themeName, "blocks", blockName);
     const schemaContent = generateBlockSchema(data);
@@ -1026,23 +1650,23 @@ async function createBlockCommand(name, options) {
     await writeFile(path__default.default.join(blockPath, `${blockName}.tsx`), componentContent);
     const indexContent = generateBlockIndex(data);
     await writeFile(path__default.default.join(blockPath, "index.ts"), indexContent);
-    logger.stopSpinner(true, "Block files created successfully!");
-    logger.newLine();
-    logger.section("Next steps:");
-    logger.log(
+    exports.logger.stopSpinner(true, "Block files created successfully!");
+    exports.logger.newLine();
+    exports.logger.section("Next steps:");
+    exports.logger.log(
       `  1. Edit schema: ${path__default.default.relative(process.cwd(), path__default.default.join(blockPath, `${blockName}.schema.ts`))}`
     );
-    logger.log(
+    exports.logger.log(
       `  2. Edit component: ${path__default.default.relative(process.cwd(), path__default.default.join(blockPath, `${blockName}.tsx`))}`
     );
-    logger.log(
+    exports.logger.log(
       `  3. Register in block registry: src/lib/registry/block-registry.ts`
     );
-    logger.newLine();
-    logger.success("Block created successfully!");
+    exports.logger.newLine();
+    exports.logger.success("Block created successfully!");
   } catch (error) {
-    logger.stopSpinner(false, "Failed to create block");
-    logger.error(
+    exports.logger.stopSpinner(false, "Failed to create block");
+    exports.logger.error(
       error instanceof Error ? error.message : "Unknown error occurred"
     );
     process.exit(1);
@@ -1157,12 +1781,15 @@ export { ${data.blockName}Definition } from "./${data.blockName}.schema";
 export { ${data.blockNamePascal} } from "./${data.blockName}";
 `;
 }
+
+// src/commands/create-component.ts
+init_logger();
 async function createComponentCommand(name, options) {
-  logger.header("Create New Component");
+  exports.logger.header("Create New Component");
   ensureOneXProject();
   const componentName = toKebabCase(name);
   if (!validateName(componentName)) {
-    logger.error(
+    exports.logger.error(
       `Invalid component name: ${componentName}. Use kebab-case (e.g., button, icon-badge)`
     );
     process.exit(1);
@@ -1206,7 +1833,7 @@ async function createComponentCommand(name, options) {
     displayName,
     description
   };
-  logger.startSpinner("Creating component files...");
+  exports.logger.startSpinner("Creating component files...");
   try {
     const componentPath = path__default.default.join(
       getFeaturesDir(),
@@ -1225,23 +1852,23 @@ async function createComponentCommand(name, options) {
     );
     const indexContent = generateComponentIndex(data);
     await writeFile(path__default.default.join(componentPath, "index.ts"), indexContent);
-    logger.stopSpinner(true, "Component files created successfully!");
-    logger.newLine();
-    logger.section("Next steps:");
-    logger.log(
+    exports.logger.stopSpinner(true, "Component files created successfully!");
+    exports.logger.newLine();
+    exports.logger.section("Next steps:");
+    exports.logger.log(
       `  1. Edit schema: ${path__default.default.relative(process.cwd(), path__default.default.join(componentPath, `${componentName}.schema.ts`))}`
     );
-    logger.log(
+    exports.logger.log(
       `  2. Edit component: ${path__default.default.relative(process.cwd(), path__default.default.join(componentPath, `${componentName}.tsx`))}`
     );
-    logger.log(
+    exports.logger.log(
       `  3. Register in component registry: src/lib/registry/component-registry.ts`
     );
-    logger.newLine();
-    logger.success("Component created successfully!");
+    exports.logger.newLine();
+    exports.logger.success("Component created successfully!");
   } catch (error) {
-    logger.stopSpinner(false, "Failed to create component");
-    logger.error(
+    exports.logger.stopSpinner(false, "Failed to create component");
+    exports.logger.error(
       error instanceof Error ? error.message : "Unknown error occurred"
     );
     process.exit(1);
@@ -1361,8 +1988,11 @@ export { ${data.componentName}Definition } from "./${data.componentName}.schema"
 export { ${data.componentNamePascal} } from "./${data.componentName}";
 `;
 }
+
+// src/commands/list.ts
+init_logger();
 async function listCommand(options) {
-  logger.header("OneX Project Inventory");
+  exports.logger.header("OneX Project Inventory");
   ensureOneXProject();
   const showAll = !options.sections && !options.blocks && !options.components;
   if (showAll || options.sections) {
@@ -1379,10 +2009,10 @@ async function listCommand(options) {
   }
 }
 async function listSections(themeFilter) {
-  logger.section("\u{1F4C4} Sections");
+  exports.logger.section("\u{1F4C4} Sections");
   const themes = themeFilter ? [themeFilter] : listThemes();
   if (themes.length === 0) {
-    logger.warning("No themes found");
+    exports.logger.warning("No themes found");
     return;
   }
   for (const theme of themes) {
@@ -1395,17 +2025,17 @@ async function listSections(themeFilter) {
       return fs__default.default.statSync(sectionPath).isDirectory() && fs__default.default.existsSync(path__default.default.join(sectionPath, "index.ts"));
     });
     if (sections.length > 0) {
-      logger.log(chalk4__default.default.cyan(`
+      exports.logger.log(chalk4__default.default.cyan(`
   ${theme}:`));
       sections.forEach((section) => {
-        logger.log(`    \u2022 ${section}`);
+        exports.logger.log(`    \u2022 ${section}`);
       });
     }
   }
-  logger.newLine();
+  exports.logger.newLine();
 }
 async function listBlocks(themeFilter) {
-  logger.section("\u{1F9F1} Blocks");
+  exports.logger.section("\u{1F9F1} Blocks");
   const sharedBlocksDir = path__default.default.join(getFeaturesDir(), "blocks");
   if (fs__default.default.existsSync(sharedBlocksDir)) {
     const sharedBlocks = fs__default.default.readdirSync(sharedBlocksDir).filter((name) => {
@@ -1413,9 +2043,9 @@ async function listBlocks(themeFilter) {
       return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path__default.default.join(blockPath, "index.ts"));
     });
     if (sharedBlocks.length > 0) {
-      logger.log(chalk4__default.default.cyan("\n  Shared:"));
+      exports.logger.log(chalk4__default.default.cyan("\n  Shared:"));
       sharedBlocks.forEach((block) => {
-        logger.log(`    \u2022 ${block}`);
+        exports.logger.log(`    \u2022 ${block}`);
       });
     }
   }
@@ -1430,20 +2060,20 @@ async function listBlocks(themeFilter) {
       return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path__default.default.join(blockPath, "index.ts"));
     });
     if (blocks.length > 0) {
-      logger.log(chalk4__default.default.cyan(`
+      exports.logger.log(chalk4__default.default.cyan(`
   ${theme}:`));
       blocks.forEach((block) => {
-        logger.log(`    \u2022 ${block}`);
+        exports.logger.log(`    \u2022 ${block}`);
       });
     }
   }
-  logger.newLine();
+  exports.logger.newLine();
 }
 async function listComponents() {
-  logger.section("\u2699\uFE0F  Components");
+  exports.logger.section("\u2699\uFE0F  Components");
   const componentsDir = path__default.default.join(getFeaturesDir(), "components");
   if (!fs__default.default.existsSync(componentsDir)) {
-    logger.warning("No components directory found");
+    exports.logger.warning("No components directory found");
     return;
   }
   const components = fs__default.default.readdirSync(componentsDir).filter((name) => {
@@ -1451,23 +2081,23 @@ async function listComponents() {
     return fs__default.default.statSync(componentPath).isDirectory() && fs__default.default.existsSync(path__default.default.join(componentPath, "index.ts"));
   });
   if (components.length === 0) {
-    logger.warning("No components found");
+    exports.logger.warning("No components found");
     return;
   }
-  logger.log("");
+  exports.logger.log("");
   components.forEach((component) => {
-    logger.log(`  \u2022 ${component}`);
+    exports.logger.log(`  \u2022 ${component}`);
   });
-  logger.newLine();
+  exports.logger.newLine();
 }
 async function listThemesInfo() {
-  logger.section("\u{1F3A8} Themes");
+  exports.logger.section("\u{1F3A8} Themes");
   const themes = listThemes();
   if (themes.length === 0) {
-    logger.warning("No themes found");
+    exports.logger.warning("No themes found");
     return;
   }
-  logger.log("");
+  exports.logger.log("");
   for (const theme of themes) {
     const themeDir = path__default.default.join(getThemesDir(), theme);
     const candidates = ["theme.config.ts", "bundle-entry.ts", "manifest.ts"];
@@ -1485,15 +2115,19 @@ async function listThemesInfo() {
     const displayName = nameMatch ? nameMatch[1] : theme;
     const version = versionMatch ? versionMatch[1] : "unknown";
     const description = descMatch ? descMatch[1] : "";
-    logger.log(chalk4__default.default.cyan(`  ${displayName}`) + chalk4__default.default.gray(` (v${version})`));
+    exports.logger.log(chalk4__default.default.cyan(`  ${displayName}`) + chalk4__default.default.gray(` (v${version})`));
     if (description) {
-      logger.log(chalk4__default.default.gray(`    ${description}`));
+      exports.logger.log(chalk4__default.default.gray(`    ${description}`));
     }
   }
-  logger.newLine();
+  exports.logger.newLine();
 }
+
+// src/commands/build.ts
+init_logger();
 async function buildCommand(options) {
-  logger.header("Build Theme");
+  var _a;
+  exports.logger.header("Build Theme");
   let themePath;
   let themeName;
   if (options.theme) {
@@ -1509,17 +2143,21 @@ async function buildCommand(options) {
       themePath = path__default.default.join(process.cwd(), themeName);
     }
     if (!fs__default.default.existsSync(themePath)) {
-      logger.error(`Theme "${themeName}" not found.`);
+      exports.logger.error(`Theme "${themeName}" not found.`);
       process.exit(1);
     }
   } else {
-    const isThemeDir = ["theme.config.ts", "bundle-entry.ts", "manifest.ts"].some((f) => fs__default.default.existsSync(path__default.default.join(process.cwd(), f)));
+    const isThemeDir = [
+      "theme.config.ts",
+      "bundle-entry.ts",
+      "manifest.ts"
+    ].some((f) => fs__default.default.existsSync(path__default.default.join(process.cwd(), f)));
     if (isThemeDir) {
       themePath = process.cwd();
       themeName = path__default.default.basename(themePath);
-      logger.info(`Building current theme: ${themeName}`);
+      exports.logger.info(`Building current theme: ${themeName}`);
     } else {
-      logger.error(
+      exports.logger.error(
         "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
       );
       process.exit(1);
@@ -1528,55 +2166,64 @@ async function buildCommand(options) {
   const packageJsonPath = path__default.default.join(themePath, "package.json");
   const hasPkgJson = fs__default.default.existsSync(packageJsonPath);
   if (!hasPkgJson) {
-    logger.warning(
+    exports.logger.warning(
       "No package.json found in theme. Skipping build (themes in monorepo are built via turbo)."
     );
-    logger.newLine();
-    logger.info("To build all packages, run:");
-    logger.log("  pnpm turbo build");
-    logger.newLine();
-    logger.info("To build specific theme components:");
-    logger.log("  pnpm turbo build --filter=./src/themes/*");
+    exports.logger.newLine();
+    exports.logger.info("To build all packages, run:");
+    exports.logger.log("  pnpm turbo build");
+    exports.logger.newLine();
+    exports.logger.info("To build specific theme components:");
+    exports.logger.log("  pnpm turbo build --filter=./src/themes/*");
     return;
   }
-  logger.newLine();
-  logger.section("Build Steps");
-  logger.startSpinner("Running type check...");
+  exports.logger.newLine();
+  exports.logger.section("Build Steps");
+  exports.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.");
+    exports.logger.stopSpinner(false, "Type check failed");
+    exports.logger.error("Fix type errors before building.");
     process.exit(1);
   }
-  logger.stopSpinner(true, "Type check passed");
-  logger.startSpinner("Running linter...");
+  exports.logger.stopSpinner(true, "Type check passed");
+  exports.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.");
+    exports.logger.stopSpinner(false, "Lint failed");
+    exports.logger.error("Fix lint errors before building.");
     process.exit(1);
   }
-  logger.stopSpinner(true, "Lint passed");
-  const buildArgs = options.watch ? ["build", "--watch"] : ["build"];
-  logger.startSpinner(
+  exports.logger.stopSpinner(true, "Lint passed");
+  const pkgJson = fs__default.default.readJsonSync(packageJsonPath);
+  const buildScript = ((_a = pkgJson.scripts) == null ? void 0 : _a.build) || "";
+  const isRecursive = buildScript.includes("onex build") || buildScript.includes("onex-cli build");
+  exports.logger.startSpinner(
     options.watch ? "Building (watch mode)..." : "Building..."
   );
-  const buildSuccess = await runCommand("pnpm", buildArgs, themePath);
+  let buildSuccess;
+  if (isRecursive) {
+    const { compileStandaloneTheme: compileStandaloneTheme2 } = await Promise.resolve().then(() => (init_compile_theme(), compile_theme_exports));
+    buildSuccess = await compileStandaloneTheme2(themePath, themeName);
+  } else {
+    const buildArgs = options.watch ? ["build", "--watch"] : ["build"];
+    buildSuccess = await runCommand("pnpm", buildArgs, themePath);
+  }
   if (!buildSuccess && !options.watch) {
-    logger.stopSpinner(false, "Build failed");
+    exports.logger.stopSpinner(false, "Build failed");
     process.exit(1);
   }
   if (!options.watch) {
-    logger.stopSpinner(true, "Build complete");
-    logger.newLine();
-    logger.success("\u2713 Theme built successfully!");
-    logger.newLine();
-    logger.info(`Theme: ${themeName}`);
+    exports.logger.stopSpinner(true, "Build complete");
+    exports.logger.newLine();
+    exports.logger.success("\u2713 Theme built successfully!");
+    exports.logger.newLine();
+    exports.logger.info(`Theme: ${themeName}`);
     const distPath = path__default.default.join(themePath, "dist");
     if (fs__default.default.existsSync(distPath)) {
-      logger.log(`Output: ${path__default.default.relative(process.cwd(), distPath)}`);
+      exports.logger.log(`Output: ${path__default.default.relative(process.cwd(), distPath)}`);
       const files = fs__default.default.readdirSync(distPath);
-      logger.log(`Files: ${files.length}`);
+      exports.logger.log(`Files: ${files.length}`);
     }
   }
 }
@@ -1602,6 +2249,9 @@ function runCommand(command, args, cwd) {
     });
   });
 }
+
+// src/commands/upload.ts
+init_logger();
 function getS3Client() {
   const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
   if (adapterMode === "vps") {
@@ -1641,21 +2291,12 @@ function getBucketName(env) {
   return environment === "production" ? "onex-themes-prod" : "onex-themes-staging";
 }
 async function findCompiledThemeDir(themeId, version) {
-  const searchPaths = [
-    path__default.default.resolve(process.cwd(), "dist"),
-    path__default.default.resolve(
-      process.cwd(),
-      `../../apps/api-server/compiled-themes/${themeId}@${version}`
-    ),
-    path__default.default.resolve(
-      process.cwd(),
-      `../api-server/compiled-themes/${themeId}@${version}`
-    )
-  ];
+  const searchPaths = [path__default.default.resolve(process.cwd(), "dist")];
   for (const dir of searchPaths) {
     if (await fs__default.default.pathExists(dir)) {
-      const manifestPath = path__default.default.join(dir, "manifest.json");
-      if (await fs__default.default.pathExists(manifestPath)) {
+      const hasManifest = await fs__default.default.pathExists(path__default.default.join(dir, "manifest.json"));
+      const hasThemeEntry = await fs__default.default.pathExists(path__default.default.join(dir, "bundle-entry.js")) || await fs__default.default.pathExists(path__default.default.join(dir, "theme.config.js")) || await fs__default.default.pathExists(path__default.default.join(dir, "index.js"));
+      if (hasManifest || hasThemeEntry) {
         return dir;
       }
     }
@@ -1670,7 +2311,7 @@ async function readManifest() {
       const module = await import(manifestTsPath);
       return module.default || module;
     } catch (error) {
-      logger.warning("Failed to import manifest.ts, trying package.json");
+      exports.logger.warning("Failed to import manifest.ts, trying package.json");
     }
   }
   const packageJsonPath = path__default.default.resolve(process.cwd(), "package.json");
@@ -1735,7 +2376,7 @@ async function updateLatestPointer(s3Client, bucket, themeId, version) {
   );
 }
 async function uploadCommand(options) {
-  logger.header("Upload Theme to S3");
+  exports.logger.header("Upload Theme to S3");
   const spinner = ora__default.default("Preparing theme upload...").start();
   try {
     let themeId;
@@ -1758,13 +2399,8 @@ async function uploadCommand(options) {
           `Compiled theme not found for ${themeId}@${version}. Run 'onex build' first.`
         )
       );
-      logger.info(
-        chalk4__default.default.gray(
-          `Expected locations:
-  - ./dist/
-  - ../../apps/api-server/compiled-themes/${themeId}@${version}/`
-        )
-      );
+      exports.logger.info(chalk4__default.default.gray(`Expected location:
+  - ./dist/`));
       process.exit(1);
     }
     spinner.succeed(`Found compiled theme at: ${compiledDir}`);
@@ -1864,16 +2500,14 @@ async function uploadCommand(options) {
     await updateLatestPointer(s3Client, bucket, themeId, version);
     spinner.succeed("Updated latest.json pointer");
     console.log();
-    logger.success(chalk4__default.default.green.bold("Theme uploaded successfully!"));
+    exports.logger.success(chalk4__default.default.green.bold("Theme uploaded successfully!"));
     console.log();
     console.log(
       chalk4__default.default.cyan("   Theme:   ") + chalk4__default.default.white(`${themeId}@${version}`)
     );
     console.log(chalk4__default.default.cyan("   Bucket:  ") + chalk4__default.default.white(bucket));
     console.log(
-      chalk4__default.default.cyan("   Files:   ") + chalk4__default.default.white(
-        `bundle.zip${sourceUploaded ? " + source.zip" : ""}`
-      )
+      chalk4__default.default.cyan("   Files:   ") + chalk4__default.default.white(`bundle.zip${sourceUploaded ? " + source.zip" : ""}`)
     );
     console.log(
       chalk4__default.default.cyan("   Path:    ") + chalk4__default.default.gray(`s3://${bucket}/themes/${themeId}/${version}/`)
@@ -1881,10 +2515,13 @@ async function uploadCommand(options) {
     console.log();
   } catch (error) {
     spinner.fail(chalk4__default.default.red(`Upload failed: ${error.message}`));
-    logger.error(error.stack || error.message);
+    exports.logger.error(error.stack || error.message);
     process.exit(1);
   }
 }
+
+// src/commands/download.ts
+init_logger();
 function getS3Client2() {
   const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
   if (adapterMode === "vps") {
@@ -2003,7 +2640,7 @@ export * from './bundle-entry.js';
 }
 function showDownloadFailureHelp(themeId, bucket) {
   console.log();
-  logger.error(chalk4__default.default.red.bold("Theme download failed"));
+  exports.logger.error(chalk4__default.default.red.bold("Theme download failed"));
   console.log();
   console.log(chalk4__default.default.yellow("Possible reasons:"));
   console.log(chalk4__default.default.gray("  1. Theme not uploaded to S3 yet"));
@@ -2032,15 +2669,11 @@ function showDownloadFailureHelp(themeId, bucket) {
   );
   console.log();
   console.log(chalk4__default.default.white("4. Verify theme exists in S3:"));
-  console.log(
-    chalk4__default.default.gray(
-      `   aws s3 ls s3://${bucket}/themes/${themeId}/`
-    )
-  );
+  console.log(chalk4__default.default.gray(`   aws s3 ls s3://${bucket}/themes/${themeId}/`));
   console.log();
 }
 async function downloadCommand(options) {
-  logger.header("Download Theme from S3");
+  exports.logger.header("Download Theme from S3");
   const spinner = ora__default.default("Initializing download...").start();
   try {
     const themeId = options.themeId || process.env.NEXT_PUBLIC_THEME_ID || process.env.THEME_ID;
@@ -2089,7 +2722,7 @@ async function downloadCommand(options) {
     const manifest = await fs__default.default.readJson(manifestPath);
     await createCompatibilityFiles(outputDir, manifest);
     console.log();
-    logger.success(chalk4__default.default.green.bold("Theme downloaded successfully!"));
+    exports.logger.success(chalk4__default.default.green.bold("Theme downloaded successfully!"));
     console.log();
     console.log(
       chalk4__default.default.cyan("   Theme:   ") + chalk4__default.default.white(`${themeId}@${resolvedVersion}`)
@@ -2105,13 +2738,16 @@ async function downloadCommand(options) {
     console.log();
   } catch (error) {
     spinner.fail(chalk4__default.default.red("Download failed"));
-    logger.error(error.message);
+    exports.logger.error(error.message);
     const themeId = options.themeId || process.env.NEXT_PUBLIC_THEME_ID || "unknown";
     const bucket = options.bucket || getBucketName2(options.environment);
     showDownloadFailureHelp(themeId, bucket);
     process.exit(1);
   }
 }
+
+// src/commands/clone.ts
+init_logger();
 function getS3Client3() {
   const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
   if (adapterMode === "vps") {
@@ -2215,18 +2851,101 @@ function runInstall(cwd) {
     proc.on("error", () => resolve(false));
   });
 }
+async function promptThemeName(originalName) {
+  const { default: inquirer5 } = await import('inquirer');
+  const { themeName } = await inquirer5.prompt([
+    {
+      type: "input",
+      name: "themeName",
+      message: "New theme name (kebab-case):",
+      default: `my-${originalName}`,
+      validate: (input) => {
+        if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+          return "Theme name must be kebab-case (lowercase letters, numbers, hyphens)";
+        }
+        if (input === originalName) {
+          return `Name must differ from the original theme "${originalName}"`;
+        }
+        return true;
+      }
+    }
+  ]);
+  return themeName;
+}
+async function renameTheme(themeDir, oldName, newName) {
+  const oldPrefix = `${oldName}-`;
+  const newPrefix = `${newName}-`;
+  const newDisplayName = newName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  const pkgPath = path__default.default.join(themeDir, "package.json");
+  if (await fs__default.default.pathExists(pkgPath)) {
+    const pkg = await fs__default.default.readJson(pkgPath);
+    pkg.name = `@onex-themes/${newName}`;
+    if (pkg.description) {
+      pkg.description = pkg.description.replace(
+        new RegExp(oldName, "gi"),
+        newDisplayName
+      );
+    }
+    pkg.version = "1.0.0";
+    await fs__default.default.writeJson(pkgPath, pkg, { spaces: 2 });
+  }
+  const configPath = path__default.default.join(themeDir, "theme.config.ts");
+  if (await fs__default.default.pathExists(configPath)) {
+    let content = await fs__default.default.readFile(configPath, "utf-8");
+    content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
+    content = content.replace(
+      /name:\s*"[^"]*Theme"/,
+      `name: "${newDisplayName} Theme"`
+    );
+    await fs__default.default.writeFile(configPath, content);
+  }
+  const layoutPath = path__default.default.join(themeDir, "theme.layout.ts");
+  if (await fs__default.default.pathExists(layoutPath)) {
+    let content = await fs__default.default.readFile(layoutPath, "utf-8");
+    content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
+    content = content.replace(
+      /name:\s*"[^"]*Theme"/,
+      `name: "${newDisplayName} Theme"`
+    );
+    await fs__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 = path__default.default.join(themeDir, file);
+    let content = await fs__default.default.readFile(filePath, "utf-8");
+    const original = content;
+    content = content.replace(
+      new RegExp(`"${oldPrefix}`, "g"),
+      `"${newPrefix}`
+    );
+    content = content.replace(
+      new RegExp(`themeId:\\s*"${oldName}"`, "g"),
+      `themeId: "${newName}"`
+    );
+    content = content.replace(
+      new RegExp(`${oldDisplayName} Theme`, "g"),
+      `${newDisplayName} Theme`
+    );
+    if (content !== original) {
+      await fs__default.default.writeFile(filePath, content);
+    }
+  }
+}
 async function cloneCommand(themeName, options) {
-  logger.header("Clone Theme Source");
+  exports.logger.header("Clone Theme Source");
+  let newName = options.name;
+  if (!newName) {
+    newName = await promptThemeName(themeName);
+  }
   const spinner = ora__default.default("Initializing clone...").start();
   try {
     const bucket = options.bucket || getBucketName3(options.environment);
-    const outputDir = options.output || path__default.default.resolve(process.cwd(), themeName);
+    const outputDir = options.output || path__default.default.resolve(process.cwd(), newName);
     const s3Client = getS3Client3();
     if (await fs__default.default.pathExists(outputDir)) {
-      spinner.fail(
-        chalk4__default.default.red(`Directory already exists: ${outputDir}`)
-      );
-      logger.info(
+      spinner.fail(chalk4__default.default.red(`Directory already exists: ${outputDir}`));
+      exports.logger.info(
         chalk4__default.default.gray(
           "Use -o to specify a different output directory, or remove the existing directory."
         )
@@ -2239,9 +2958,7 @@ async function cloneCommand(themeName, options) {
       version = await resolveLatestVersion2(s3Client, bucket, themeName);
       spinner.succeed(`Resolved latest version: ${chalk4__default.default.cyan(version)}`);
     }
-    spinner.start(
-      `Downloading source.zip for ${themeName}@${version}...`
-    );
+    spinner.start(`Downloading source.zip for ${themeName}@${version}...`);
     const s3Key = `themes/${themeName}/${version}/source.zip`;
     let zipBuffer;
     try {
@@ -2259,9 +2976,7 @@ async function cloneCommand(themeName, options) {
         chalk4__default.default.yellow("The theme source may not have been uploaded yet.")
       );
       console.log(
-        chalk4__default.default.gray(
-          `Upload source with: onex upload --theme ${themeName}`
-        )
+        chalk4__default.default.gray(`Upload source with: onex upload --theme ${themeName}`)
       );
       console.log();
       process.exit(1);
@@ -2274,6 +2989,13 @@ async function cloneCommand(themeName, options) {
     zip.extractAllTo(outputDir, true);
     const entries = zip.getEntries().filter((e) => !e.isDirectory);
     spinner.succeed(`Extracted ${entries.length} files`);
+    spinner.start(
+      `Renaming theme: ${chalk4__default.default.gray(themeName)} \u2192 ${chalk4__default.default.cyan(newName)}...`
+    );
+    await renameTheme(outputDir, themeName, newName);
+    spinner.succeed(
+      `Renamed theme: ${chalk4__default.default.gray(themeName)} \u2192 ${chalk4__default.default.cyan(newName)}`
+    );
     if (options.install !== false) {
       const hasPkgJson = await fs__default.default.pathExists(
         path__default.default.join(outputDir, "package.json")
@@ -2293,18 +3015,17 @@ async function cloneCommand(themeName, options) {
       }
     }
     console.log();
-    logger.success(chalk4__default.default.green.bold("Theme cloned successfully!"));
+    exports.logger.success(chalk4__default.default.green.bold("Theme cloned successfully!"));
     console.log();
     console.log(
-      chalk4__default.default.cyan("   Theme:    ") + chalk4__default.default.white(`${themeName}@${version}`)
+      chalk4__default.default.cyan("   Source:   ") + chalk4__default.default.gray(`${themeName}@${version}`)
     );
+    console.log(chalk4__default.default.cyan("   Theme:    ") + chalk4__default.default.white(newName));
     console.log(chalk4__default.default.cyan("   Location: ") + chalk4__default.default.white(outputDir));
     console.log(chalk4__default.default.cyan("   Files:    ") + chalk4__default.default.white(entries.length));
     console.log();
     console.log(chalk4__default.default.cyan("Next steps:"));
-    console.log(
-      chalk4__default.default.gray(`   cd ${path__default.default.relative(process.cwd(), outputDir)}`)
-    );
+    console.log(chalk4__default.default.gray(`   cd ${path__default.default.relative(process.cwd(), outputDir)}`));
     if (options.install === false) {
       console.log(chalk4__default.default.gray("   pnpm install"));
     }
@@ -2312,12 +3033,14 @@ async function cloneCommand(themeName, options) {
     console.log();
   } catch (error) {
     spinner.fail(chalk4__default.default.red(`Clone failed: ${error.message}`));
-    logger.error(error.stack || error.message);
+    exports.logger.error(error.stack || error.message);
     process.exit(1);
   }
 }
 
-exports.Logger = Logger;
+// src/index.ts
+init_logger();
+
 exports.buildCommand = buildCommand;
 exports.cloneCommand = cloneCommand;
 exports.copyTemplate = copyTemplate;
@@ -2336,7 +3059,6 @@ exports.installDependencies = installDependencies;
 exports.isOneXProject = isOneXProject;
 exports.listCommand = listCommand;
 exports.listThemes = listThemes;
-exports.logger = logger;
 exports.pathExists = pathExists;
 exports.renderTemplate = renderTemplate;
 exports.themeExists = themeExists;