@xyd-js/documan 0.1.0-build.189

package/dist/index.js

@@ -0,0 +1,1943 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/build.ts
+import path3 from "path";
+import fs2 from "fs";
+import { build as viteBuild } from "vite";
+import tsconfigPaths from "vite-tsconfig-paths";
+
+// src/utils.ts
+import path2 from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { execSync as execSync2 } from "child_process";
+import crypto from "crypto";
+import { realpathSync } from "fs";
+import { createServer } from "vite";
+import { reactRouter } from "@react-router/dev/vite";
+import { IconSet } from "@iconify/tools";
+import { readSettings, pluginDocs } from "@xyd-js/plugin-docs";
+import { vitePlugins as xydContentVitePlugins } from "@xyd-js/content/vite";
+
+// src/const.ts
+var XYD_FOLDER_PATH = ".xyd";
+var HOST_FOLDER_PATH = `${XYD_FOLDER_PATH}/host`;
+var CACHE_FOLDER_PATH = `${XYD_FOLDER_PATH}/.cache`;
+var BUILD_FOLDER_PATH = `${XYD_FOLDER_PATH}/build`;
+var SUPPORTED_SETTINGS_FILES = [
+  "docs.json",
+  "docs.ts",
+  "docs.tsx"
+];
+var SUPPORTED_CONTENT_FILES = [
+  ".md",
+  ".mdx"
+];
+
+// src/cli.ts
+import readline from "readline";
+import cliSpinners from "cli-spinners";
+var CLI = class {
+  spinner;
+  spinnerInterval = null;
+  currentFrame = 0;
+  currentMessage = "";
+  isSpinning = false;
+  constructor(spinnerType = "dots") {
+    this.spinner = cliSpinners[spinnerType];
+  }
+  startSpinner(message) {
+    if (this.isSpinning) {
+      this.stopSpinner();
+    }
+    this.currentMessage = message;
+    this.isSpinning = true;
+    this.currentFrame = 0;
+    this.write(`${this.spinner.frames[0]} ${this.currentMessage}`);
+    this.spinnerInterval = setInterval(() => {
+      const frame = this.spinner.frames[this.currentFrame];
+      this.write(`${frame} ${this.currentMessage}`);
+      this.currentFrame = (this.currentFrame + 1) % this.spinner.frames.length;
+    }, this.spinner.interval);
+  }
+  stopSpinner() {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = null;
+    }
+    this.isSpinning = false;
+    this.clearLine();
+  }
+  clearLine() {
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+  }
+  write(message) {
+    this.clearLine();
+    process.stdout.write(message);
+  }
+  log(message) {
+    if (this.isSpinning) {
+      this.stopSpinner();
+    }
+    console.log(message);
+  }
+  error(message) {
+    if (this.isSpinning) {
+      this.stopSpinner();
+    }
+    console.error(message);
+  }
+  updateMessage(message) {
+    this.currentMessage = message;
+  }
+};
+var cli = new CLI();
+
+// src/componentsInstall.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import path, { join } from "path";
+import { createRequire } from "module";
+function resolveModuleV2(fromDir, pkgName) {
+  const req = createRequire(import.meta.url);
+  let entry;
+  try {
+    entry = req.resolve(pkgName, { paths: [fromDir] });
+  } catch {
+    return null;
+  }
+  let dir = path.dirname(entry);
+  while (true) {
+    const pj = path.join(dir, "package.json");
+    if (existsSync(pj)) {
+      try {
+        const json = JSON.parse(readFileSync(pj, "utf8"));
+        if (json && json.name === pkgName) return dir;
+      } catch {
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+var xydContentPath = resolveModuleV2(getCLIRoot(), "@xyd-js/content");
+var COMPONENTS = {
+  diagrams: {
+    packages: ["rehype-mermaid@^3.0.0", "playwright@^1.54.2"],
+    postInstall: ["npx playwright install --with-deps chromium"],
+    xydModules: [
+      xydContentPath || ""
+    ]
+  }
+};
+async function componentsInstall(component, host) {
+  const config = resolveComponent(component, host);
+  if (!config) {
+    return false;
+  }
+  await installComponent(config, component);
+  if (!host) {
+    saveComponent(component);
+  }
+  return true;
+}
+function saveComponent(component) {
+  const cliComponentsJson = getCLIComponentsJsonPath();
+  let shouldWriteJson = true;
+  try {
+    const existingComponents = JSON.parse(readFileSync(cliComponentsJson, "utf8"));
+    if (existingComponents.diagrams === true) {
+      shouldWriteJson = false;
+    }
+  } catch (error) {
+    shouldWriteJson = true;
+  }
+  const componentsConfig = { [component]: true };
+  writeFileSync(cliComponentsJson, JSON.stringify(componentsConfig, null, 2));
+  console.debug(import_picocolors.default.green(`\u2705 Components configuration written to ${cliComponentsJson}`));
+}
+function resolveComponent(component, host) {
+  if (!component) {
+    console.error(import_picocolors.default.red("Error: Component name is required"));
+    console.log(`Usage: xyd components install <component-name>`);
+    console.log(`Available components: ${Object.keys(COMPONENTS).join(", ")}`);
+    return false;
+  }
+  if (!COMPONENTS[component]) {
+    console.error(import_picocolors.default.red(`Error: Unknown component '${component}'`));
+    console.log(`Available components: ${Object.keys(COMPONENTS).join(", ")}`);
+    return false;
+  }
+  const config = COMPONENTS[component];
+  if (host) {
+    config.xydModules = [
+      path.resolve(getHostPath(), "node_modules/@xyd-js/content"),
+      getHostPath()
+    ];
+  }
+  return config;
+}
+function componentDependencies(config, host) {
+  const deps = {};
+  if (typeof config === "string") {
+    const resolvedConfig = resolveComponent(config, host);
+    if (!resolvedConfig) {
+      return false;
+    }
+    config = resolvedConfig;
+  }
+  for (const pkg of config.packages) {
+    const [pkgName, version] = pkg.includes("@") && !pkg.startsWith("@") ? pkg.split("@") : [pkg, "latest"];
+    deps[pkgName] = version;
+  }
+  return deps;
+}
+async function installComponent(config, componentName) {
+  function install2(pathname) {
+    if (!config) {
+      return;
+    }
+    console.log("\n", import_picocolors.default.gray(`Installing ${componentName} component...`));
+    try {
+      if (config.packages.length > 0) {
+        console.log(import_picocolors.default.gray(`Installing packages: ${config.packages.join(", ")}`));
+        const packageJsonPath = join(pathname, "package.json");
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        const packageJsonOriginal = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        for (const pkg of config.packages) {
+          const [pkgName, version] = pkg.includes("@") && !pkg.startsWith("@") ? pkg.split("@") : [pkg, "latest"];
+          packageJson.dependencies = packageJson.dependencies || {};
+          packageJson.dependencies[pkgName] = version;
+        }
+        writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        nodeInstallPackages(pathname);
+        if (process.env.XYD_DEV_MODE) {
+          writeFileSync(packageJsonPath, JSON.stringify(packageJsonOriginal, null, 2));
+        }
+      }
+      if (config.postInstall) {
+        for (const cmd of config.postInstall) {
+          console.log(import_picocolors.default.gray(`Running: ${cmd}`));
+          execSync(cmd, {
+            cwd: pathname,
+            stdio: "inherit",
+            encoding: "utf8"
+          });
+        }
+      }
+      console.log(import_picocolors.default.green(`\u2705 ${componentName} component installed successfully!`));
+    } catch (error) {
+      console.error(import_picocolors.default.red(`\u274C Failed to install ${componentName} component:`));
+      console.error(error);
+      process.exit(1);
+    }
+  }
+  for (const module of config.xydModules || []) {
+    install2(module);
+  }
+}
+
+// src/utils.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+var ANALYTICS_INTEGRATION_DEPENDENCIES = {
+  livesession: {
+    "@pluganalytics/provider-livesession": "0.0.0-pre.7"
+  }
+};
+var EXTERNAL_XYD_PLUGINS = {
+  "@xyd-js/plugin-supademo": "0.0.0",
+  "@xyd-js/plugin-chatwoot": "0.0.0",
+  "@xyd-js/plugin-intercom": "0.0.0",
+  "@xyd-js/plugin-livechat": "0.0.0"
+};
+async function appInit(options) {
+  const readPreloadSettings = await readSettings();
+  if (!readPreloadSettings) {
+    return null;
+  }
+  const preloadSettings = typeof readPreloadSettings === "string" ? JSON.parse(readPreloadSettings) : readPreloadSettings;
+  {
+    if (!preloadSettings.integrations?.search) {
+      preloadSettings.integrations = {
+        ...preloadSettings.integrations || {},
+        search: {
+          orama: true
+        }
+      };
+    }
+    const plugins = integrationsToPlugins(preloadSettings.integrations);
+    if (preloadSettings.plugins) {
+      preloadSettings.plugins = [...plugins, ...preloadSettings.plugins];
+    } else {
+      preloadSettings.plugins = plugins;
+    }
+  }
+  let resolvedPlugins = [];
+  {
+    resolvedPlugins = await loadPlugins(preloadSettings, options) || [];
+    const userUniformVitePlugins = [];
+    const componentPlugins = [];
+    resolvedPlugins?.forEach((p) => {
+      if (p.uniform) {
+        userUniformVitePlugins.push(...p.uniform);
+      }
+      if (p.components) {
+        const components = [];
+        if (!Array.isArray(p.components) && typeof p.components === "object") {
+          const mapComponents = [];
+          Object.keys(p.components).forEach((key) => {
+            if (!p?.components?.[key]) {
+              return;
+            }
+            const component = p.components[key];
+            mapComponents.push({
+              component,
+              name: key
+            });
+          });
+          p.components = mapComponents;
+        }
+        if (Array.isArray(p.components)) {
+          for (const component of p.components) {
+            if (!component.component) {
+              console.error("No component function");
+              continue;
+            }
+            if (!component.name) {
+              component.name = component.component.name;
+            }
+            if (!component.dist) {
+              component.dist = p._pluginPkg + "/" + component.name;
+              continue;
+            }
+            if (!component.name) {
+              console.error("No component name");
+              continue;
+            }
+          }
+          components.push(...p.components);
+        }
+        componentPlugins.push(...components);
+      }
+      const head = p.head;
+      if (head?.length && preloadSettings?.theme?.head) {
+        preloadSettings.theme.head.push(
+          ...head
+        );
+      }
+    });
+    globalThis.__xydUserUniformVitePlugins = userUniformVitePlugins;
+    globalThis.__xydUserComponents = componentPlugins;
+  }
+  const respPluginDocs = await pluginDocs({
+    ...options,
+    appInit
+  });
+  if (!respPluginDocs) {
+    throw new Error("PluginDocs not found");
+  }
+  if (!respPluginDocs.settings) {
+    throw new Error("Settings not found in respPluginDocs");
+  }
+  respPluginDocs.settings.plugins = [
+    ...respPluginDocs.settings?.plugins || [],
+    ...preloadSettings.plugins || []
+  ];
+  if (respPluginDocs.settings?.theme) {
+    respPluginDocs.settings.theme.head = [
+      ...respPluginDocs.settings?.theme?.head || [],
+      ...preloadSettings.theme?.head || []
+    ];
+  }
+  globalThis.__xydBasePath = respPluginDocs.basePath;
+  globalThis.__xydSettings = respPluginDocs.settings;
+  globalThis.__xydPagePathMapping = respPluginDocs.pagePathMapping;
+  globalThis.__xydHasIndexPage = respPluginDocs.hasIndexPage;
+  globalThis.__xydSettingsClone = JSON.parse(JSON.stringify(respPluginDocs.settings));
+  if (respPluginDocs.settings.integrations?.diagrams) {
+    if (!componentExists("diagrams")) {
+      await componentsInstall("diagrams");
+    }
+  }
+  return {
+    respPluginDocs,
+    resolvedPlugins
+  };
+}
+function virtualComponentsPlugin() {
+  return {
+    name: "xyd-plugin-virtual-components",
+    resolveId(id) {
+      if (id === "virtual:xyd-user-components") {
+        return id + ".jsx";
+      }
+      return null;
+    },
+    async load(id) {
+      if (id === "virtual:xyd-user-components.jsx") {
+        const userComponents = globalThis.__xydUserComponents || [];
+        if (userComponents.length > 0 && userComponents[0]?.component) {
+          const imports = userComponents.map(
+            (component, index) => `import Component${index} from '${component.dist}';`
+          ).join("\n");
+          const componentObjects = userComponents.map(
+            (component, index) => `{
+                                component: Component${index},
+                                name: '${component.name}',
+                                dist: '${component.dist}'
+                            }`
+          ).join(",\n                            ");
+          return `
+                        // Pre-bundled at build time - no async loading needed
+                        ${imports}
+                        
+                        export const components = [
+                            ${componentObjects}
+                        ];
+                    `;
+        }
+        return `
+                    export const components = globalThis.__xydUserComponents || []
+                `;
+      }
+      return null;
+    }
+  };
+}
+function virtualProvidersPlugin(settings) {
+  return {
+    name: "xyd-plugin-virtual-providers",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "virtual:xyd-analytics-providers") {
+        return id;
+      }
+    },
+    async load(id) {
+      if (id === "virtual:xyd-analytics-providers") {
+        const providers = Object.keys(settings?.integrations?.analytics || {});
+        const imports = providers.map(
+          (provider) => `import { default as ${provider}Provider } from '@pluganalytics/provider-${provider}'`
+        ).join("\n");
+        const cases = providers.map(
+          (provider) => `case '${provider}': return ${provider}Provider`
+        ).join("\n");
+        return `
+                    ${imports}
+
+                    export const loadProvider = async (provider) => {
+                        switch (provider) {
+                            ${cases}
+                            default:
+                                console.error(\`Provider \${provider} not found\`)
+                                return null
+                        }
+                    }
+                `;
+      }
+    }
+  };
+}
+async function commonVitePlugins(respPluginDocs, resolvedPlugins) {
+  const userVitePlugins = resolvedPlugins.map((p) => p.vite).flat() || [];
+  return [
+    ...await xydContentVitePlugins({
+      toc: {
+        maxDepth: respPluginDocs.settings.theme?.writer?.maxTocDepth || 2
+      },
+      settings: respPluginDocs.settings
+    }),
+    ...respPluginDocs.vitePlugins,
+    reactRouter(),
+    virtualComponentsPlugin(),
+    virtualProvidersPlugin(respPluginDocs.settings),
+    pluginIconSet(respPluginDocs.settings),
+    ...userVitePlugins
+  ];
+}
+function commonPostInstallVitePlugins(respPluginDocs, resolvedPlugins) {
+  return [
+    vitePluginThemePresets(respPluginDocs.settings)
+  ];
+}
+async function vitePluginThemePresets(settings) {
+  const themeName = settings.theme?.name;
+  const VIRTUAL_ID = "virtual:xyd-theme-presets";
+  const RESOLVED_ID = "\0" + VIRTUAL_ID;
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = path2.dirname(__filename2);
+  let themeRoot = "";
+  if (process.env.XYD_CLI) {
+    themeRoot = path2.join(getHostPath(), `node_modules/@xyd-js/theme-${themeName}/dist`);
+  } else {
+    themeRoot = path2.join(path2.resolve(__dirname2, "../../"), `xyd-theme-${themeName}/dist`);
+  }
+  const presetsDir = path2.join(themeRoot, "presets");
+  let cssFiles = [];
+  try {
+    const files = fs.readdirSync(presetsDir);
+    cssFiles = files.filter((f) => f.endsWith(".css"));
+  } catch (err) {
+  }
+  const importStmts = [];
+  const mapEntries = [];
+  cssFiles.forEach((file, index) => {
+    const name = file.replace(/\.css$/, "");
+    const varName = `preset${index}`;
+    const pkgPath = `@xyd-js/theme-${themeName}/presets/${file}`;
+    importStmts.push(`import ${varName} from '${pkgPath}?url';`);
+    mapEntries.push(`  '${name}': ${varName}`);
+  });
+  return {
+    name: "xyd:virtual-theme-presets",
+    resolveId(id) {
+      return id === VIRTUAL_ID ? RESOLVED_ID : null;
+    },
+    load(id) {
+      if (id !== RESOLVED_ID) return null;
+      return `
+${importStmts.join("\n")}
+
+export const presetUrls = {
+${mapEntries.join(",\n")}
+};
+`;
+    }
+  };
+}
+function pluginIconSet(settings) {
+  const DEFAULT_ICON_SET = "lucide";
+  async function fetchIconSet(name, version) {
+    if (name.startsWith("http://") || name.startsWith("https://")) {
+      try {
+        const iconsResp = await fetch(name);
+        const iconsData = await iconsResp.json();
+        const iconSet = new IconSet(iconsData);
+        return { icons: iconsData, iconSet };
+      } catch (error) {
+        console.warn(`Failed to fetch from URL ${name}:`, error);
+      }
+    }
+    const tryReadFile = (filePath) => {
+      try {
+        if (!fs.existsSync(filePath)) {
+          console.warn(`File does not exist: ${filePath}`);
+          return null;
+        }
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        try {
+          const iconsData = JSON.parse(fileContent);
+          const iconSet = new IconSet(iconsData);
+          return { icons: iconsData, iconSet };
+        } catch (parseError) {
+          console.warn(`Invalid JSON in file ${filePath}:`, parseError);
+          return null;
+        }
+      } catch (error) {
+        console.warn(`Failed to read file ${filePath}:`, error);
+        return null;
+      }
+    };
+    if (path2.isAbsolute(name)) {
+      const result = tryReadFile(name);
+      if (result) return result;
+    }
+    if (name.startsWith(".")) {
+      const fullPath = path2.join(process.cwd(), name);
+      const result = tryReadFile(fullPath);
+      if (result) return result;
+    }
+    const cdnUrl = version ? `https://cdn.jsdelivr.net/npm/@iconify-json/${name}@${version}/icons.json` : `https://cdn.jsdelivr.net/npm/@iconify-json/${name}/icons.json`;
+    try {
+      const iconsResp = await fetch(cdnUrl);
+      const iconsData = await iconsResp.json();
+      const iconSet = new IconSet(iconsData);
+      return { icons: iconsData, iconSet };
+    } catch (error) {
+      throw new Error(`Failed to load icon set from any source (file or CDN): ${name}`);
+    }
+  }
+  async function processIconSet(iconSet, icons, noPrefix) {
+    const resp = /* @__PURE__ */ new Map();
+    for (const icon of Object.keys(icons.icons)) {
+      const svg = iconSet.toSVG(icon);
+      if (!svg) continue;
+      let prefix = noPrefix ? void 0 : iconSet.prefix;
+      const iconName = prefix ? `${prefix}:${icon}` : icon;
+      resp.set(iconName, { svg: svg.toString() });
+    }
+    return resp;
+  }
+  async function addIconsToMap(resp, name, version, noPrefix) {
+    const { icons, iconSet } = await fetchIconSet(name, version);
+    const newIcons = await processIconSet(iconSet, icons, noPrefix);
+    newIcons.forEach((value, key) => resp.set(key, value));
+  }
+  async function processIconLibrary(library) {
+    const resp = /* @__PURE__ */ new Map();
+    if (typeof library === "string") {
+      await addIconsToMap(resp, library);
+    } else if (Array.isArray(library)) {
+      for (const item of library) {
+        if (typeof item === "string") {
+          await addIconsToMap(resp, item);
+        } else {
+          const { name, version, default: isDefault, noprefix } = item;
+          const noPrefix = isDefault || noprefix === true;
+          await addIconsToMap(resp, name, version, noPrefix);
+        }
+      }
+    } else {
+      const { name, version, default: isDefault, noprefix } = library;
+      const noPrefix = isDefault || noprefix === true;
+      await addIconsToMap(resp, name, version, noPrefix);
+    }
+    return resp;
+  }
+  return {
+    name: "xyd-plugin-icon-set",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "virtual:xyd-icon-set") {
+        return id;
+      }
+    },
+    async load(id) {
+      if (id === "virtual:xyd-icon-set") {
+        let resp;
+        if (settings.theme?.icons?.library) {
+          resp = await processIconLibrary(settings.theme.icons.library);
+        } else {
+          resp = await processIconLibrary([
+            {
+              name: DEFAULT_ICON_SET,
+              default: true
+            }
+          ]);
+        }
+        return `
+                    export const iconSet = ${JSON.stringify(Object.fromEntries(resp))};
+                `;
+      }
+    }
+  };
+}
+function getXydFolderPath() {
+  return path2.join(
+    process.cwd(),
+    XYD_FOLDER_PATH
+  );
+}
+function getCLIRoot() {
+  const cliPath = realpathSync(process.argv[1]);
+  return path2.dirname(path2.dirname(cliPath));
+}
+function getCLIComponentsJsonPath() {
+  return path2.join(getCLIRoot(), "cliComponents.json");
+}
+function componentExists(component) {
+  const cliComponentsJson = getCLIComponentsJsonPath();
+  try {
+    const components = JSON.parse(fs.readFileSync(cliComponentsJson, "utf8"));
+    return components[component] === true;
+  } catch (error) {
+    return false;
+  }
+}
+function getHostPath() {
+  if (process.env.XYD_DEV_MODE) {
+    if (process.env.XYD_HOST) {
+      return path2.resolve(process.env.XYD_HOST);
+    }
+    return path2.join(__dirname, "../../../", HOST_FOLDER_PATH);
+  }
+  return path2.join(process.cwd(), HOST_FOLDER_PATH);
+}
+function getAppRoot() {
+  return getHostPath();
+}
+function getPublicPath() {
+  return path2.join(process.cwd(), "public");
+}
+function getBuildPath() {
+  return path2.join(
+    process.cwd(),
+    BUILD_FOLDER_PATH
+  );
+}
+function getDocsPluginBasePath() {
+  return path2.join(getHostPath(), "./plugins/xyd-plugin-docs");
+}
+async function loadPlugins(settings, options) {
+  const resolvedPlugins = [];
+  if (settings.plugins?.length && !options?.doNotInstallPluginDependencies) {
+    await setupPluginDependencies(settings, true);
+  }
+  const pluginSettingsFreeze = deepCloneAndFreeze(settings);
+  for (const plugin of settings.plugins || []) {
+    let pluginName;
+    let pluginArgs = [];
+    if (typeof plugin === "string") {
+      pluginName = plugin;
+      pluginArgs = [];
+    } else if (Array.isArray(plugin)) {
+      pluginName = plugin[0];
+      pluginArgs = plugin.slice(1);
+    } else {
+      console.error(`Currently only string and array plugins are supported, got: ${plugin}`);
+      return [];
+    }
+    let mod;
+    try {
+      mod = await import(pluginName);
+    } catch (e) {
+      pluginName = path2.join(process.cwd(), pluginName);
+      const pluginPreview = await createServer({
+        optimizeDeps: {
+          include: []
+        }
+      });
+      mod = await pluginPreview.ssrLoadModule(pluginName);
+    }
+    if (!mod.default) {
+      console.error(`Plugin ${plugin} has no default export`);
+      continue;
+    }
+    let pluginInstance = mod.default(...pluginArgs);
+    if (typeof pluginInstance === "function") {
+      const plug = pluginInstance(pluginSettingsFreeze);
+      resolvedPlugins.push({
+        ...plug,
+        _pluginPkg: pluginName
+      });
+      continue;
+    }
+    resolvedPlugins.push({
+      ...pluginInstance,
+      _pluginPkg: pluginName
+    });
+  }
+  return resolvedPlugins;
+}
+function deepCloneAndFreeze(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  const clone = Array.isArray(obj) ? [] : {};
+  for (const key in obj) {
+    if (Object.hasOwn(obj, key)) {
+      clone[key] = deepCloneAndFreeze(obj[key]);
+    }
+  }
+  return Object.freeze(clone);
+}
+function integrationsToPlugins(integrations) {
+  const plugins = [];
+  let foundSearchIntegation = 0;
+  if (integrations?.search?.orama) {
+    if (typeof integrations.search.orama === "boolean") {
+      plugins.push("@xyd-js/plugin-orama");
+    } else {
+      plugins.push(["@xyd-js/plugin-orama", integrations.search.orama]);
+    }
+    foundSearchIntegation++;
+  }
+  if (integrations?.search?.algolia) {
+    plugins.push(["@xyd-js/plugin-algolia", integrations.search.algolia]);
+    foundSearchIntegation++;
+  }
+  if (foundSearchIntegation > 1) {
+    throw new Error("Only one search integration is allowed");
+  }
+  if (integrations?.[".apps"]?.supademo) {
+    plugins.push(["@xyd-js/plugin-supademo", integrations[".apps"].supademo]);
+  }
+  if (integrations?.support?.chatwoot) {
+    plugins.push([
+      "@xyd-js/plugin-chatwoot",
+      integrations.support.chatwoot
+    ]);
+  }
+  if (integrations?.support?.intercom) {
+    plugins.push([
+      "@xyd-js/plugin-intercom",
+      integrations.support.intercom
+    ]);
+  }
+  if (integrations?.support?.livechat) {
+    plugins.push([
+      "@xyd-js/plugin-livechat",
+      integrations.support.livechat
+    ]);
+  }
+  return plugins;
+}
+async function preWorkspaceSetup(options = {}) {
+  await ensureFoldersExist();
+  if (!options.force) {
+    if (await shouldSkipHostSetup()) {
+      return true;
+    }
+  }
+  const hostTemplate = process.env.XYD_DEV_MODE ? path2.resolve(__dirname, "../../xyd-host") : path2.resolve(__dirname, "../../host");
+  const hostPath = getHostPath();
+  await copyHostTemplate(hostTemplate, hostPath);
+  let pluginDocsPath;
+  if (process.env.XYD_DEV_MODE) {
+    pluginDocsPath = path2.resolve(__dirname, "../../xyd-plugin-docs");
+  } else {
+    pluginDocsPath = path2.resolve(__dirname, "../../plugin-docs");
+  }
+  const pagesSourcePath = path2.join(pluginDocsPath, "src/pages");
+  const pagesTargetPath = path2.join(hostPath, "plugins/xyd-plugin-docs/src/pages");
+  if (fs.existsSync(pagesSourcePath)) {
+    await copyHostTemplate(pagesSourcePath, pagesTargetPath);
+  } else {
+    console.warn(`Pages source path does not exist: ${pagesSourcePath}`);
+  }
+}
+function calculateFolderChecksum(folderPath) {
+  const hash = crypto.createHash("sha256");
+  const ignorePatterns = [...getGitignorePatterns(folderPath), ".xydchecksum", "node_modules", "dist", ".react-router", "package-lock.json", "pnpm-lock.yaml", "cliComponents.json"];
+  function processFile(filePath) {
+    const relativePath = path2.relative(folderPath, filePath);
+    const content = fs.readFileSync(filePath);
+    hash.update(relativePath);
+    hash.update(content);
+  }
+  function processDirectory(dirPath) {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const sourceEntry = path2.join(dirPath, entry.name);
+      if (shouldIgnoreEntry(entry.name, ignorePatterns)) {
+        continue;
+      }
+      if (entry.name === ".git") {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        processDirectory(sourceEntry);
+      } else {
+        processFile(sourceEntry);
+      }
+    }
+  }
+  processDirectory(folderPath);
+  return hash.digest("hex");
+}
+function getGitignorePatterns(folderPath) {
+  const gitignorePath = path2.join(folderPath, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+    return gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  }
+  return [];
+}
+function shouldIgnoreEntry(entryName, ignorePatterns) {
+  return ignorePatterns.some((pattern) => {
+    const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+    return regex.test(entryName);
+  });
+}
+async function copyHostTemplate(sourcePath, targetPath) {
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error(`Host template source path does not exist: ${sourcePath}`);
+  }
+  if (fs.existsSync(targetPath)) {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  }
+  fs.mkdirSync(targetPath, { recursive: true });
+  const ignorePatterns = getGitignorePatterns(sourcePath);
+  const entries = fs.readdirSync(sourcePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourceEntry = path2.join(sourcePath, entry.name);
+    const targetEntry = path2.join(targetPath, entry.name);
+    if (shouldIgnoreEntry(entry.name, ignorePatterns)) {
+      continue;
+    }
+    if (entry.name === ".git") {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await copyHostTemplate(sourceEntry, targetEntry);
+    } else {
+      fs.copyFileSync(sourceEntry, targetEntry);
+      if (entry.name === "package.json" && process.env.XYD_DEV_MODE) {
+        const packageJsonPath = targetEntry;
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        packageJson.name = "xyd-host-dev";
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+      }
+    }
+  }
+}
+async function ensureFoldersExist() {
+  const folders = [CACHE_FOLDER_PATH];
+  for (const folder of folders) {
+    const fullPath = path2.resolve(process.cwd(), folder);
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+    }
+  }
+}
+async function postWorkspaceSetup(settings) {
+  const spinner = new CLI("dots");
+  try {
+    spinner.startSpinner("Installing xyd framework...");
+    const hostPath = getHostPath();
+    const packageJsonPath = path2.join(hostPath, "package.json");
+    const packageJson = await hostPackageJson();
+    const integrationDeps = await setupIntegationDependencies(settings);
+    const pluginDeps = await setupPluginDependencies(settings);
+    packageJson.dependencies = {
+      ...integrationDeps,
+      ...packageJson.dependencies,
+      ...pluginDeps
+    };
+    if (settings.integrations?.diagrams) {
+      const componentDeps = componentDependencies("diagrams", true);
+      if (componentDeps) {
+        packageJson.dependencies = {
+          ...packageJson.dependencies,
+          ...componentDeps
+        };
+      }
+    }
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    await nodeInstallPackages(hostPath);
+    spinner.stopSpinner();
+    spinner.log("\u2714 Local xyd framework installed successfully");
+  } catch (error) {
+    spinner.stopSpinner();
+    spinner.error("\u274C Failed to install xyd framework");
+    throw error;
+  }
+}
+async function hostPackageJson() {
+  const hostPath = getHostPath();
+  const packageJsonPath = path2.join(hostPath, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    console.warn("No package.json found in host path");
+    return;
+  }
+  let packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  if (!packageJson.dependencies) {
+    packageJson.dependencies = {};
+  }
+  return packageJson;
+}
+async function setupIntegationDependencies(settings) {
+  const dependencies = {};
+  for (const [key, value] of Object.entries(ANALYTICS_INTEGRATION_DEPENDENCIES)) {
+    const analytics = settings.integrations?.analytics?.[key];
+    if (analytics) {
+      for (const [depName, depVersion] of Object.entries(value)) {
+        dependencies[depName] = depVersion;
+      }
+    }
+  }
+  return dependencies;
+}
+async function setupPluginDependencies(settings, install2 = false) {
+  const spinner = new CLI("dots");
+  const hostPath = getHostPath();
+  const dependencies = {};
+  for (const plugin of settings.plugins || []) {
+    let pluginName;
+    if (typeof plugin === "string") {
+      pluginName = plugin;
+    } else if (Array.isArray(plugin)) {
+      pluginName = plugin[0];
+    } else {
+      continue;
+    }
+    if (pluginName.startsWith("@xyd-js/") && (!EXTERNAL_XYD_PLUGINS[pluginName] || process.env.XYD_DEV_MODE === "2")) {
+      continue;
+    }
+    const isValidNpmPackage = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(pluginName);
+    if (isValidNpmPackage) {
+      const xydPluginVersion = EXTERNAL_XYD_PLUGINS[pluginName];
+      const hostPackageJsonPath = path2.join(hostPath, "package.json");
+      const cwdPackageJsonPath = path2.join(process.cwd(), "package.json");
+      let userDeps = {};
+      if (fs.existsSync(cwdPackageJsonPath)) {
+        const cwdPackageJson = JSON.parse(fs.readFileSync(cwdPackageJsonPath, "utf-8"));
+        userDeps = cwdPackageJson.dependencies || {};
+      }
+      if (fs.existsSync(hostPackageJsonPath)) {
+        const hostPackageJson2 = JSON.parse(fs.readFileSync(hostPackageJsonPath, "utf-8"));
+        const deps = hostPackageJson2.dependencies || {};
+        const matchingUserDep = Object.entries(userDeps).find(([depName]) => {
+          return depName === pluginName;
+        });
+        if (matchingUserDep) {
+          dependencies[pluginName] = matchingUserDep[1];
+        } else {
+          const matchingHostDep = Object.entries(deps).find(([depName]) => {
+            return depName === pluginName;
+          });
+          if (matchingHostDep) {
+            dependencies[pluginName] = matchingHostDep[1];
+          } else if (xydPluginVersion) {
+            dependencies[pluginName] = xydPluginVersion;
+          } else {
+            dependencies[pluginName] = "latest";
+          }
+        }
+      } else {
+        console.warn(`no host package.json found in: ${hostPath}`);
+      }
+    } else if (!pluginName.startsWith(".") && !pluginName.startsWith("/")) {
+      console.warn(`invalid plugin name: ${pluginName}`);
+    }
+  }
+  if (install2) {
+    spinner.startSpinner("Installing plugin dependencies...");
+    const packageJson = await hostPackageJson();
+    const packageJsonPath = path2.join(hostPath, "package.json");
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    await nodeInstallPackages(hostPath);
+    spinner.stopSpinner();
+    spinner.log("\u2714 Plugin dependencies installed successfully");
+  }
+  return dependencies;
+}
+function nodeInstallPackages(hostPath) {
+  const cmdInstall = pmInstall();
+  const execOptions = {
+    cwd: hostPath,
+    env: {
+      ...process.env,
+      NODE_ENV: ""
+      // since 'production' does not install it well,
+    }
+  };
+  const customRegistry = process.env.XYD_NPM_REGISTRY || process.env.npm_config_registry;
+  if (customRegistry) {
+    if (!execOptions.env) {
+      execOptions.env = {};
+    }
+    execOptions.env["npm_config_registry"] = customRegistry;
+  }
+  if (process.env.XYD_VERBOSE) {
+    execOptions.stdio = "inherit";
+  }
+  execSync2(cmdInstall, execOptions);
+}
+function pmInstall() {
+  if (process.env.XYD_NODE_PM) {
+    switch (process.env.XYD_NODE_PM) {
+      case "npm": {
+        return npmInstall();
+      }
+      case "pnpm": {
+        return pnpmInstall();
+      }
+      case "bun": {
+        return bunInstall();
+      }
+      default: {
+        console.warn(`Unknown package manager: ${process.env.XYD_NODE_PM}, falling back to npm`);
+        return npmInstall();
+      }
+    }
+  }
+  if (hasBun()) {
+    return bunInstall();
+  }
+  const { pnpm } = runningPm();
+  console.log("\u2139\uFE0F consider install `bun` for better performance \n");
+  if (pnpm) {
+    return pnpmInstall();
+  }
+  return npmInstall();
+}
+function hasBun() {
+  try {
+    execSync2("bun --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runningPm() {
+  let pnpm = false;
+  let bun = false;
+  if (process.env.npm_execpath) {
+    if (process.env.npm_execpath.includes("pnpm")) {
+      pnpm = true;
+    } else if (process.env.npm_execpath.includes("bun")) {
+      bun = true;
+    }
+  }
+  if (process.env.NODE_PATH) {
+    const nodePath = process.env.NODE_PATH;
+    if (nodePath.includes(".pnpm")) {
+      pnpm = true;
+    } else if (nodePath.includes(".bun")) {
+      bun = true;
+    }
+  }
+  if (process.execPath.includes("bun") || path2.dirname(process.argv?.[1] || "").includes("bun")) {
+    bun = true;
+  }
+  return {
+    pnpm,
+    bun
+  };
+}
+function pnpmInstall() {
+  return "pnpm install";
+}
+function bunInstall() {
+  return "bun install";
+}
+function npmInstall() {
+  return "npm install";
+}
+async function shouldSkipHostSetup() {
+  const hostPath = getHostPath();
+  if (!fs.existsSync(hostPath)) {
+    return false;
+  }
+  const currentChecksum = calculateFolderChecksum(hostPath);
+  const storedChecksum = getStoredChecksum();
+  if (!storedChecksum || storedChecksum !== currentChecksum) {
+    return false;
+  }
+  return true;
+}
+function getStoredChecksum() {
+  const checksumPath = path2.join(getHostPath(), ".xydchecksum");
+  if (!fs.existsSync(checksumPath)) {
+    return null;
+  }
+  try {
+    return fs.readFileSync(checksumPath, "utf-8").trim();
+  } catch (error) {
+    console.error("Error reading checksum file:", error);
+    return null;
+  }
+}
+function storeChecksum(checksum) {
+  const checksumPath = path2.join(getHostPath(), ".xydchecksum");
+  try {
+    fs.writeFileSync(checksumPath, checksum);
+  } catch (error) {
+    console.error("Error writing checksum file:", error);
+  }
+}
+
+// src/build.ts
+async function build() {
+  const skip = await preWorkspaceSetup({
+    force: true
+  });
+  const inited = await appInit();
+  if (!inited) {
+    return;
+  }
+  const { respPluginDocs, resolvedPlugins } = inited;
+  const commonRunVitePlugins = await commonVitePlugins(respPluginDocs, resolvedPlugins);
+  const appRoot = getAppRoot();
+  if (!skip) {
+    await postWorkspaceSetup(respPluginDocs.settings);
+    const newChecksum = calculateFolderChecksum(getHostPath());
+    storeChecksum(newChecksum);
+  }
+  const postInstallVitePlugins = commonPostInstallVitePlugins(respPluginDocs, resolvedPlugins);
+  {
+    await setupInstallableEnvironmentV2();
+  }
+  const enableMermaid = !!respPluginDocs?.settings?.integrations?.diagrams;
+  const externalPackages = enableMermaid ? [] : ["rehype-mermaid"];
+  try {
+    await viteBuild({
+      mode: "production",
+      root: appRoot,
+      plugins: [
+        ...commonRunVitePlugins,
+        ...postInstallVitePlugins,
+        tsconfigPaths()
+      ],
+      optimizeDeps: {
+        include: ["react/jsx-runtime"]
+      },
+      define: {
+        "process.env.NODE_ENV": JSON.stringify("production"),
+        "process.env": {}
+      },
+      resolve: {
+        alias: {
+          process: "process/browser",
+          // When rehype-mermaid is externalized, resolve it from CLI's node_modules
+          ...enableMermaid ? {} : { "rehype-mermaid": path3.resolve(getHostPath(), "./node_modules/rehype-mermaid") }
+        }
+      },
+      build: {
+        rollupOptions: {
+          external: externalPackages
+        }
+      },
+      ssr: {
+        external: externalPackages
+      }
+      // ssr: {
+      //     noExternal: ["react", "react-dom", "react-router"]
+      // }
+    });
+    await viteBuild({
+      mode: "production",
+      root: appRoot,
+      build: {
+        ssr: true,
+        rollupOptions: {
+          external: externalPackages
+        }
+        // rollupOptions: {
+        //     external: ["@xyd-js/framework/hydration", "fs"]
+        // }
+      },
+      plugins: [
+        fixManifestPlugin(appRoot),
+        ...commonRunVitePlugins,
+        ...postInstallVitePlugins,
+        tsconfigPaths()
+      ],
+      optimizeDeps: {
+        include: ["react/jsx-runtime"]
+        // include: ["react", "react-dom", "react/jsx-runtime", "react-router"],
+        // force: true
+      },
+      define: {
+        "process.env.NODE_ENV": JSON.stringify("production"),
+        "process.env": {}
+      },
+      resolve: {
+        alias: {
+          process: "process/browser",
+          // When rehype-mermaid is externalized, resolve it from CLI's node_modules
+          ...enableMermaid ? {} : { "rehype-mermaid": path3.resolve(getHostPath(), "./node_modules/rehype-mermaid") }
+          // react: path.resolve(workspaceNodeModulesPath, "react"),
+          // "react-dom": path.resolve(workspaceNodeModulesPath, "react-dom")
+        }
+      },
+      ssr: {
+        external: externalPackages
+      }
+      // ssr: {
+      //     noExternal: ["react", "react-dom", "react-router"]
+      // }
+    });
+  } catch (error) {
+    console.error("Build failed:", error);
+  }
+}
+function setupInstallableEnvironmentV2() {
+  const symbolicXydNodeModules = path3.join(getXydFolderPath(), "node_modules");
+  const hostNodeModules = path3.join(getHostPath(), "node_modules");
+  if (fs2.existsSync(symbolicXydNodeModules)) {
+    if (fs2.lstatSync(symbolicXydNodeModules).isSymbolicLink()) {
+      fs2.unlinkSync(symbolicXydNodeModules);
+    } else {
+      fs2.rmSync(symbolicXydNodeModules, { recursive: true, force: true });
+    }
+  }
+  fs2.symlinkSync(hostNodeModules, symbolicXydNodeModules, "dir");
+}
+function fixManifestPlugin(appRoot) {
+  const manifestPath = path3.join(
+    getBuildPath(),
+    // getAppRoot(),
+    "./server/.vite/manifest.json"
+  );
+  return {
+    name: "xyd-fix-rr-manifest",
+    apply: "build",
+    // run after manifest is generated
+    // 2) after bundle is written, compute prefix and strip it
+    writeBundle(_, bundle) {
+      const cwdDir = process.cwd();
+      let prefix = path3.relative(appRoot, cwdDir).replace(/\\/g, "/");
+      if (prefix) prefix += "/";
+      const esc = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const stripRe = new RegExp(`^${esc}`);
+      for (const fileName in bundle) {
+        const asset = bundle[fileName];
+        if (asset.type !== "asset") continue;
+        if (fileName.endsWith("manifest.json")) {
+          const manifest = JSON.parse(asset.source.toString());
+          const fixed = {};
+          for (const key of Object.keys(manifest)) {
+            const entry = manifest[key];
+            const newKey = key.replace(stripRe, "");
+            if (typeof entry.src === "string") {
+              entry.src = entry.src.replace(stripRe, "");
+            }
+            fixed[newKey] = entry;
+          }
+          asset.source = JSON.stringify(fixed, null, 2);
+          fs2.writeFileSync(manifestPath, asset.source, "utf8");
+        }
+      }
+    }
+  };
+}
+
+// src/dev.ts
+import path4 from "path";
+import fs3 from "fs";
+import { createServer as createServer2, searchForWorkspaceRoot } from "vite";
+if (!process.env.ENABLE_TIMERS) {
+  ["time", "timeLog", "timeEnd"].forEach((method) => {
+    console[method] = () => {
+    };
+  });
+}
+var fullReloadOptions = {
+  "theme.name": true,
+  "plugins": true
+  // TODO: in the future better
+};
+function extractNestedProperty(obj, path5) {
+  const keys = path5.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current && typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return null;
+    }
+  }
+  return current;
+}
+function hasValueChanged(oldValue, newValue) {
+  if (!oldValue && newValue) return true;
+  if (oldValue && !newValue) return true;
+  if (!oldValue && !newValue) return false;
+  const oldStr = JSON.stringify(oldValue);
+  const newStr = JSON.stringify(newValue);
+  return oldStr !== newStr;
+}
+function hasFullReloadPropertiesChanged(oldSettings, newSettings) {
+  if (!oldSettings || !newSettings) {
+    return oldSettings !== newSettings;
+  }
+  for (const [propertyPath, shouldCheck] of Object.entries(fullReloadOptions)) {
+    if (shouldCheck) {
+      const oldValue = extractNestedProperty(oldSettings, propertyPath);
+      const newValue = extractNestedProperty(newSettings, propertyPath);
+      if (hasValueChanged(oldValue, newValue)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var RELOADING = false;
+async function dev(options) {
+  const spinner = new CLI("dots");
+  spinner.startSpinner("Preparing local xyd instance...");
+  const skip = await preWorkspaceSetup();
+  let onUpdateCallback = () => {
+  };
+  const inited = await appInit({
+    onUpdate: (callback) => {
+      onUpdateCallback = callback;
+    }
+  });
+  if (!inited) {
+    return;
+  }
+  const { respPluginDocs, resolvedPlugins } = inited;
+  const allowCwd = searchForWorkspaceRoot(process.cwd());
+  const watchAllow = process.cwd();
+  const appRoot = getAppRoot();
+  const commonRunVitePlugins = await commonVitePlugins(respPluginDocs, resolvedPlugins);
+  spinner.stopSpinner();
+  if (!skip) {
+    await postWorkspaceSetup(respPluginDocs.settings);
+    const newChecksum = calculateFolderChecksum(getHostPath());
+    storeChecksum(newChecksum);
+  }
+  const postInstallVitePlugins = commonPostInstallVitePlugins(respPluginDocs, resolvedPlugins);
+  spinner.log("\u2714 Local xyd instance is ready");
+  spinner.log("\u{1F504} Starting server...");
+  let server = null;
+  const port = options?.port ?? parseInt(process.env.XYD_PORT ?? "5175");
+  const enableMermaid = !!respPluginDocs?.settings?.integrations?.diagrams;
+  const externalPackages = enableMermaid ? [] : ["rehype-mermaid"];
+  const optimizeDepsExclude = enableMermaid ? [] : ["rehype-mermaid"];
+  let initialSettings = respPluginDocs.settings || {};
+  let USE_CONTEXT_ISSUE_PACKAGES = [];
+  {
+    if (process.env.XYD_DEV_MODE) {
+      USE_CONTEXT_ISSUE_PACKAGES = [
+        "react-github-btn",
+        "radix-ui",
+        "@code-hike/lighter",
+        "lucide-react",
+        "openux-js",
+        "pluganalytics",
+        "@orama/orama",
+        "@orama/react-components"
+        // TODO: optimize plugin deps only if loaded 
+        // "@pluganalytics/provider-livesession"
+      ];
+    } else {
+      USE_CONTEXT_ISSUE_PACKAGES = [
+        "@xyd-js/theme-cosmo",
+        "@xyd-js/theme-gusto",
+        "@xyd-js/theme-opener",
+        "@xyd-js/theme-picasso",
+        "@xyd-js/theme-poetry",
+        "@xyd-js/theme-solar"
+        // TODO: optimize plugin deps only if loaded 
+        // "@pluganalytics/provider-livesession"
+      ];
+    }
+  }
+  const preview = await createServer2({
+    root: appRoot,
+    publicDir: "/public",
+    server: {
+      allowedHosts: [],
+      port,
+      fs: {
+        allow: [
+          allowCwd,
+          appRoot
+        ]
+      }
+    },
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV),
+      "process.env": {}
+    },
+    resolve: {
+      alias: {
+        process: "process/browser",
+        // When rehype-mermaid is externalized, resolve it from CLI's node_modules
+        ...enableMermaid ? {} : { "rehype-mermaid": path4.resolve(getHostPath(), "./node_modules/rehype-mermaid") }
+      }
+      // preserveSymlinks: true
+    },
+    build: {
+      rollupOptions: {
+        external: externalPackages
+      }
+    },
+    ssr: {
+      external: externalPackages
+    },
+    optimizeDeps: {
+      include: [
+        "react/jsx-runtime",
+        ...USE_CONTEXT_ISSUE_PACKAGES
+      ],
+      exclude: optimizeDepsExclude
+      // exclude: ["react", "react-dom"]
+    },
+    plugins: [
+      ...commonRunVitePlugins,
+      ...postInstallVitePlugins,
+      {
+        name: "xyd-configureServer",
+        configureServer(s) {
+          server = s;
+        }
+      }
+    ]
+  });
+  const watcher = fs3.watch(watchAllow, { recursive: true }, async (eventType, filename) => {
+    if (RELOADING) {
+      return;
+    }
+    if (!filename) {
+      console.log("[xyd:dev-watcher] Received empty filename");
+      return;
+    }
+    if (!server) {
+      console.log("[xyd:dev-watcher] Server not ready");
+      return;
+    }
+    const filePath = path4.join(watchAllow, filename);
+    if (filePath.includes(CACHE_FOLDER_PATH)) {
+      return;
+    }
+    let apiPaths = {};
+    if (respPluginDocs?.settings?.api) {
+      apiPaths = resolveApiFilePaths(process.cwd(), respPluginDocs.settings.api);
+    }
+    let iconPaths = {};
+    if (respPluginDocs?.settings) {
+      iconPaths = resolveIconFilePaths(process.cwd(), respPluginDocs.settings);
+    }
+    let syntaxHighlightPaths = {};
+    if (respPluginDocs?.settings) {
+      syntaxHighlightPaths = resolveSyntaxHighlightFilePaths(process.cwd(), respPluginDocs.settings);
+    }
+    const apiChanged = !!apiPaths[filePath];
+    const iconChanged = !!iconPaths[filePath];
+    const syntaxHighlightChanged = !!syntaxHighlightPaths[filePath];
+    const isSettingsFile = SUPPORTED_SETTINGS_FILES.some((ext) => filePath.endsWith(ext));
+    const isContentFile = SUPPORTED_CONTENT_FILES.some((ext) => filePath.endsWith(ext));
+    const isPublicPathReload = filePath.includes(getPublicPath());
+    const isEnvFile = isEnvFilePath(filePath);
+    const isWatchFile = isSettingsFile || isContentFile || apiChanged || iconChanged || syntaxHighlightChanged || isPublicPathReload || isEnvFile;
+    if (!isWatchFile) {
+      return;
+    }
+    const renameContentFile = isContentFile && eventType === "rename";
+    if (isContentFile && !renameContentFile) {
+      console.log("\u{1F504} Content file changed, refresh...");
+      invalidateSettings(server);
+      await touchLayoutPage();
+      console.log("\u2714 xyd content file changed\n");
+      return;
+    }
+    const isReloadFile = isSettingsFile || renameContentFile || isPublicPathReload || iconChanged || apiChanged || syntaxHighlightChanged || isEnvFile;
+    if (isReloadFile) {
+      if (renameContentFile) {
+        console.log("\u{1F504} Content file renamed, refresh...");
+      } else if (isPublicPathReload) {
+        console.log("\u{1F504} Public path changed, refresh...");
+      } else if (iconChanged) {
+        console.log("\u{1F504} Icon file changed, refresh...");
+        invalidateIconSet(server);
+      } else if (syntaxHighlightChanged) {
+        console.log("\u{1F504} Syntax highlight theme file changed, refresh...");
+      } else if (apiChanged) {
+        console.log("\u{1F504} API file changed, refresh...");
+      } else if (syntaxHighlightChanged) {
+        console.log("\u{1F504} Syntax highlight theme file changed, refresh...");
+      } else if (isEnvFile) {
+        console.log("\u{1F504} Environment file changed, refresh...");
+        await reloadServer(watcher, preview, options);
+        return;
+      } else {
+        console.log("\u{1F504} Settings file changed, refresh...");
+      }
+      let newSettings = null;
+      if (respPluginDocs?.settings.engine?.uniform?.store) {
+        const resp = await appInit({
+          disableFSWrite: true,
+          doNotInstallPluginDependencies: true
+        });
+        const respSettings = resp?.respPluginDocs?.settings;
+        if (respSettings) {
+          newSettings = respSettings;
+        }
+      } else {
+        const resp = await appInit({
+          doNotInstallPluginDependencies: true
+        });
+        const respSettings = resp?.respPluginDocs?.settings;
+        if (respSettings) {
+          newSettings = respSettings;
+        }
+      }
+      if (!newSettings) {
+        console.log("[xyd:dev-watcher] Settings is not an object or is null");
+        return;
+      }
+      {
+        const needsFullReload = hasFullReloadPropertiesChanged(initialSettings, newSettings);
+        if (needsFullReload) {
+          console.log("\u{1F504} Full reload properties changed, restarting server...");
+          await reloadServer(watcher, preview, options);
+          return;
+        }
+      }
+      {
+        invalidateSettings(server);
+        onUpdateCallback(newSettings);
+        await touchReactRouterConfig();
+        await touchRootPage();
+        await touchLayoutPage();
+        server.ws.send({ type: "full-reload" });
+      }
+    }
+  });
+  watcher.on("error", (error) => {
+    console.error("[xyd:dev] File watcher error:", error);
+  });
+  await preview.listen(port);
+  await optimizeDepsFix(port, respPluginDocs.settings.navigation);
+  preview.printUrls();
+  preview.bindCLIShortcuts({ print: true });
+  preview.httpServer?.once("close", () => {
+    watcher.close();
+  });
+}
+async function reloadServer(watcher, preview, options) {
+  RELOADING = true;
+  watcher.close();
+  await preview.close();
+  RELOADING = false;
+  await dev(options);
+}
+function resolveApiFilePaths(basePath, api) {
+  const result = {};
+  const apis = [api.openapi, api.graphql, api.sources].filter((s) => s !== void 0);
+  apis.forEach((section) => {
+    flattenApiFile(section).forEach((p) => {
+      const apiAbsPath = path4.resolve(basePath, p);
+      result[apiAbsPath] = true;
+    });
+  });
+  return result;
+}
+function resolveIconFilePaths(basePath, settings) {
+  const result = {};
+  const icons = settings?.theme?.icons?.library;
+  if (!icons) {
+    return result;
+  }
+  const isLocalPath = (path5) => {
+    return path5.startsWith("./") || path5.startsWith("/");
+  };
+  if (typeof icons === "string") {
+    if (isLocalPath(icons)) {
+      const iconAbsPath = path4.resolve(basePath, icons);
+      result[iconAbsPath] = true;
+    }
+    return result;
+  }
+  if (Array.isArray(icons)) {
+    icons.forEach((library) => {
+      if (typeof library === "string") {
+        if (isLocalPath(library)) {
+          const iconAbsPath = path4.resolve(basePath, library);
+          result[iconAbsPath] = true;
+        }
+      } else if (typeof library === "object" && library.name) {
+        if (isLocalPath(library.name)) {
+          const iconAbsPath = path4.resolve(basePath, library.name);
+          result[iconAbsPath] = true;
+        }
+      }
+    });
+  } else if (typeof icons === "object" && icons.name) {
+    if (isLocalPath(icons.name)) {
+      const iconAbsPath = path4.resolve(basePath, icons.name);
+      result[iconAbsPath] = true;
+    }
+  }
+  return result;
+}
+function resolveSyntaxHighlightFilePaths(basePath, settings) {
+  const result = {};
+  const syntaxHighlight = settings?.theme?.coder?.syntaxHighlight;
+  if (!syntaxHighlight) {
+    return result;
+  }
+  const isLocalPath = (path5) => {
+    return path5.startsWith("./") || path5.startsWith("/");
+  };
+  if (typeof syntaxHighlight === "string") {
+    if (isLocalPath(syntaxHighlight)) {
+      const syntaxHighlightAbsPath = path4.resolve(basePath, syntaxHighlight);
+      result[syntaxHighlightAbsPath] = true;
+    }
+    return result;
+  }
+  if (Array.isArray(syntaxHighlight)) {
+    syntaxHighlight.forEach((theme) => {
+      if (typeof theme === "string") {
+        if (isLocalPath(theme)) {
+          const syntaxHighlightAbsPath = path4.resolve(basePath, theme);
+          result[syntaxHighlightAbsPath] = true;
+        }
+      } else if (typeof theme === "object" && theme.name) {
+        if (isLocalPath(theme.name)) {
+          const syntaxHighlightAbsPath = path4.resolve(basePath, theme.name);
+          result[syntaxHighlightAbsPath] = true;
+        }
+      }
+    });
+  } else if (typeof syntaxHighlight === "object" && syntaxHighlight.name) {
+    if (isLocalPath(syntaxHighlight.name)) {
+      const syntaxHighlightAbsPath = path4.resolve(basePath, syntaxHighlight.name);
+      result[syntaxHighlightAbsPath] = true;
+    }
+  }
+  return result;
+}
+function flattenApiFile(file) {
+  if (!file) return [];
+  if (typeof file === "string") {
+    return [file];
+  }
+  if (Array.isArray(file)) {
+    return file.flatMap(flattenApiFile);
+  }
+  if (typeof file === "object") {
+    const obj = file;
+    if (typeof obj.source === "string") {
+      return [obj.source];
+    }
+    return Object.values(obj).flatMap(flattenApiFile);
+  }
+  return [];
+}
+function isEnvFilePath(filePath) {
+  return filePath.endsWith(".env") || filePath.endsWith(".env.local") || filePath.endsWith(".env.development") || filePath.endsWith(".env.production");
+}
+function getFirstPageFromNavigation(navigation) {
+  if (!navigation?.sidebar?.length) {
+    return null;
+  }
+  function extractFirstPage(pages) {
+    for (const page of pages) {
+      if (typeof page === "string") {
+        return normalizePagePath(page);
+      }
+      if (typeof page === "object") {
+        if ("route" in page && page.pages) {
+          const firstPage = extractFirstPage(page.pages);
+          if (firstPage) return firstPage;
+        }
+        if ("pages" in page && page.pages) {
+          const firstPage = extractFirstPage(page.pages);
+          if (firstPage) return firstPage;
+        }
+        if ("page" in page && typeof page.page === "string") {
+          return normalizePagePath(page.page);
+        }
+      }
+    }
+    return null;
+  }
+  return extractFirstPage(navigation.sidebar || []);
+}
+function normalizePagePath(pagePath) {
+  let normalized = pagePath.replace(/\.(md|mdx)$/, "");
+  if (normalized.endsWith("/index") || normalized === "index") {
+    normalized = normalized.replace(/\/?index$/, "");
+  }
+  if (normalized.startsWith("/")) {
+    normalized = normalized.slice(1);
+  }
+  return normalized;
+}
+async function fetchFirstPage(firstPage, port) {
+  const urlsToTry = [
+    `http://localhost:${port}/${firstPage}`,
+    `http://localhost:${port}/${firstPage}/`,
+    `http://localhost:${port}/${firstPage}.html`,
+    `http://localhost:${port}/${firstPage}/index.html`
+  ];
+  for (const url of urlsToTry) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        return;
+      }
+    } catch (error) {
+      continue;
+    }
+  }
+}
+function invalidateSettings(server) {
+  const resolvedId = invalidateSettingsOnly(server);
+  server.ws.send({
+    type: "update",
+    updates: [
+      {
+        type: "js-update",
+        path: `/@id/${resolvedId}`,
+        acceptedPath: `/@id/${resolvedId}`,
+        timestamp: Date.now()
+      }
+    ]
+  });
+  console.debug("\u2705 [xyd:dev-watcher] Settings module invalidated and HMR update sent");
+}
+function invalidateSettingsOnly(server) {
+  const virtualId = "virtual:xyd-settings";
+  const resolvedId = virtualId + ".jsx";
+  const mod = server.moduleGraph.getModuleById(resolvedId);
+  if (!mod) {
+    console.log("[xyd:dev-watcher] Settings module not found");
+    return;
+  }
+  server.moduleGraph.invalidateModule(mod);
+  return resolvedId;
+}
+function invalidateIconSet(server) {
+  const virtualId = "virtual:xyd-icon-set";
+  const mod = server.moduleGraph.getModuleById(virtualId);
+  if (!mod) {
+    console.log("[xyd:dev-watcher] Icon set module not found");
+    return;
+  }
+  console.debug("\u{1F504} [xyd:dev-watcher] Invalidating icon set module...");
+  server.moduleGraph.invalidateModule(mod);
+  server.ws.send({
+    type: "update",
+    updates: [
+      {
+        type: "js-update",
+        path: `/@id/${virtualId}`,
+        acceptedPath: `/@id/${virtualId}`,
+        timestamp: Date.now()
+      }
+    ]
+  });
+  console.debug("\u2705 [xyd:dev-watcher] Icon set module invalidated and HMR update sent");
+}
+async function touchReactRouterConfig() {
+  const hostPath = getHostPath();
+  const hostReactRouterConfig = path4.join(hostPath, "react-router.config.ts");
+  await fs3.promises.utimes(hostReactRouterConfig, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+}
+async function touchLayoutPage() {
+  const docsPluginBasePath = getDocsPluginBasePath();
+  const layoutPath = path4.join(docsPluginBasePath, "./src/pages/layout.tsx");
+  await fs3.promises.utimes(layoutPath, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+}
+async function touchRootPage() {
+  const hostPath = getHostPath();
+  const hostReactRouterConfig = path4.join(hostPath, "./app/root.tsx");
+  await fs3.promises.utimes(hostReactRouterConfig, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+}
+async function optimizeDepsFix(port, navigation) {
+  let firstPage = "";
+  if (navigation) {
+    firstPage = getFirstPageFromNavigation(navigation);
+  }
+  await fetchFirstPage(firstPage || "", port);
+}
+
+// src/install.ts
+import fs4 from "fs";
+import { readSettings as readSettings2 } from "@xyd-js/plugin-docs";
+async function install() {
+  const settings = await readSettings2();
+  if (!settings) {
+    throw new Error("cannot preload settings");
+  }
+  if (typeof settings === "string") {
+    throw new Error("install does not support string settings");
+  }
+  const hostPath = getHostPath();
+  if (fs4.existsSync(hostPath)) {
+    fs4.rmSync(hostPath, { recursive: true, force: true });
+  }
+  await preWorkspaceSetup({
+    force: true
+  });
+  await postWorkspaceSetup(settings);
+}
+export {
+  build,
+  componentsInstall,
+  dev,
+  getCLIComponentsJsonPath,
+  getHostPath,
+  install,
+  nodeInstallPackages,
+  pmInstall
+};
+//# sourceMappingURL=index.js.map