docmedown 0.1.0 → 0.1.2

package/dist/cli.js

@@ -24,34 +24,354 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli/index.ts
+var import_node_fs7 = __toESM(require("fs"));
+var import_node_path7 = __toESM(require("path"));
 var import_commander = require("commander");
-var import_fs7 = __toESM(require("fs"));
-var import_path7 = __toESM(require("path"));
 
-// src/cli/commands/init.ts
-var import_fs4 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
-var import_chalk3 = __toESM(require("chalk"));
-var import_prompts = __toESM(require("prompts"));
-
-// src/cli/utils/server.ts
-var import_http = __toESM(require("http"));
-var import_fs3 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
-var import_mime_types = __toESM(require("mime-types"));
-var import_ws = require("ws");
-var import_chokidar2 = __toESM(require("chokidar"));
-var import_chalk2 = __toESM(require("chalk"));
+// package.json
+var package_default = {
+  name: "docmedown",
+  version: "0.1.2",
+  description: "The simplest MarkDown documenter yet. CLI & Web Script React SPA documentation engine.",
+  main: "./dist/docmedown.cjs",
+  module: "./dist/docmedown.mjs",
+  types: "./dist/types/runtime/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/types/runtime/index.d.ts",
+      import: "./dist/docmedown.mjs",
+      require: "./dist/docmedown.cjs"
+    },
+    "./iife": "./dist/docmedown.iife.js"
+  },
+  unpkg: "./dist/docmedown.iife.js",
+  jsdelivr: "./dist/docmedown.iife.js",
+  bin: {
+    docmedown: "bin/docmedown.js",
+    dmd: "bin/docmedown.js"
+  },
+  files: [
+    "dist",
+    "bin",
+    "templates",
+    "schemas",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    "dev:runtime": "vite build --watch",
+    "build:runtime": "vite build",
+    "build:cli": "tsup",
+    typecheck: "tsc --noEmit",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    format: "biome format --write .",
+    "build:types": "tsc -p tsconfig.runtime.json",
+    build: "npm run build:runtime && npm run build:cli && npm run build:types",
+    docmedown: "node ./bin/docmedown.js",
+    dmd: "node ./bin/docmedown.js",
+    "init:docs": "node ./bin/docmedown.js init",
+    serve: "node ./bin/docmedown.js serve ./docs",
+    dev: "node ./bin/docmedown.js serve ./docs",
+    "build:docs": "node ./bin/docmedown.js build ./docs",
+    "build:docs:watch": "node ./bin/docmedown.js build ./docs --watch",
+    "build:offline": "node ./bin/docmedown.js build ./docs",
+    "config:docs": "node ./bin/docmedown.js config ./docs/docs.json",
+    test: "npx tsx --test tests/parser.test.ts tests/scanner.test.ts tests/theme-schema.test.ts tests/runtime-integration.test.ts tests/package-smoke.test.ts tests/hosting.test.ts",
+    "test:artifacts": "npx tsx --test tests/offline-artifact.test.ts",
+    "test:release": "npm run typecheck && npm run lint && npm run test && npm run build && npm run build:docs && npm run test:artifacts && npm pack --dry-run",
+    deploy: "node ./scripts/deploy.mjs",
+    "deploy:dry-run": "npm run deploy -- --dry-run",
+    prepublishOnly: "npm run test:release"
+  },
+  keywords: [
+    "markdown",
+    "documentation",
+    "docs",
+    "docusaurus",
+    "docsify",
+    "react",
+    "spa",
+    "cli",
+    "offline-docs",
+    "github-docs"
+  ],
+  author: "Gabriel M. Silva",
+  license: "MIT",
+  engines: {
+    node: ">=20.19.0"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/gabrielmsilva00/docmedown.git"
+  },
+  bugs: {
+    url: "https://github.com/gabrielmsilva00/docmedown/issues"
+  },
+  homepage: "https://github.com/gabrielmsilva00/docmedown#readme",
+  packageManager: "npm@11.16.0",
+  overrides: {
+    tsup: {
+      esbuild: "0.28.2"
+    }
+  },
+  dependencies: {
+    chalk: "^4.1.2",
+    chokidar: "^3.6.0",
+    commander: "^12.1.0",
+    esbuild: "^0.28.2",
+    "gray-matter": "^4.0.3",
+    "mime-types": "^2.1.35",
+    open: "^10.1.0",
+    prompts: "^2.4.2",
+    ws: "^8.18.0",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.5.10",
+    "@types/node": "^22.5.0",
+    "@types/prismjs": "^1.26.6",
+    "@types/prompts": "^2.4.9",
+    "@types/react": "^18.3.5",
+    "@types/react-dom": "^18.3.0",
+    "@types/ws": "^8.5.12",
+    "@vitejs/plugin-react": "^6.1.0",
+    katex: "^0.16.11",
+    marked: "^14.1.1",
+    mermaid: "^11.17.2",
+    minisearch: "^7.1.0",
+    prismjs: "^1.29.0",
+    react: "^18.3.1",
+    "react-dom": "^18.3.1",
+    tsup: "^8.2.4",
+    tsx: "^4.19.0",
+    typescript: "^5.5.4",
+    vite: "^8.2.2",
+    "vite-plugin-css-injected-by-js": "^5.0.2"
+  }
+};
 
 // src/cli/commands/build.ts
-var import_fs2 = __toESM(require("fs"));
-var import_path2 = __toESM(require("path"));
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var import_node_zlib = require("zlib");
 var import_chalk = __toESM(require("chalk"));
 var import_chokidar = __toESM(require("chokidar"));
+var import_esbuild = require("esbuild");
+
+// src/runtime/config-schema.ts
+var import_zod = require("zod");
+var nonEmptyString = import_zod.z.string().trim().min(1, "Must not be empty.");
+var themePresetSchema = import_zod.z.enum(["indigo", "emerald", "sunset", "violet", "rose", "slate", "cyberpunk"]);
+var themeFamilySchema = import_zod.z.enum(["atlas", "blueprint", "terminal", "editorial"]);
+var themeDensitySchema = import_zod.z.enum(["comfortable", "compact"]);
+var colorModeSchema = import_zod.z.enum(["light", "dark", "auto"]);
+var socialTypeSchema = import_zod.z.enum(["github", "gitlab", "twitter", "x", "discord", "custom"]);
+var badgeTypeSchema = import_zod.z.enum(["info", "success", "warning", "new"]);
+var navLinkSchema = import_zod.z.object({
+  label: nonEmptyString,
+  href: nonEmptyString,
+  external: import_zod.z.boolean().optional(),
+  icon: import_zod.z.string().optional()
+}).strict();
+var socialLinkSchema = import_zod.z.object({
+  type: socialTypeSchema,
+  url: import_zod.z.string().url("Must be an absolute URL."),
+  label: import_zod.z.string().optional(),
+  icon: import_zod.z.string().optional()
+}).strict();
+var remoteSourceSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({
+    type: import_zod.z.literal("github"),
+    repo: nonEmptyString.regex(/^[^/\s]+\/[^/\s]+$/, "Use the owner/repository format."),
+    branch: nonEmptyString.optional(),
+    docsDir: import_zod.z.string().optional(),
+    token: import_zod.z.string().optional(),
+    baseUrl: import_zod.z.string().url("Must be an absolute URL.").optional()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("gitlab"),
+    repo: nonEmptyString.regex(/^[^/\s]+\/[^/\s]+$/, "Use the namespace/repository format."),
+    branch: nonEmptyString.optional(),
+    docsDir: import_zod.z.string().optional(),
+    token: import_zod.z.string().optional(),
+    baseUrl: import_zod.z.string().url("Must be an absolute URL.").optional()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("raw"),
+    baseUrl: import_zod.z.string().url("Must be an absolute URL."),
+    branch: nonEmptyString.optional(),
+    docsDir: import_zod.z.string().optional(),
+    token: import_zod.z.string().optional()
+  }).strict()
+]);
+var sidebarItemSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    title: import_zod.z.string().optional(),
+    path: import_zod.z.string().optional(),
+    slug: import_zod.z.string().optional(),
+    icon: import_zod.z.string().optional(),
+    badge: import_zod.z.string().optional(),
+    badgeType: badgeTypeSchema.optional(),
+    collapsed: import_zod.z.boolean().optional(),
+    children: import_zod.z.array(sidebarItemSchema).optional()
+  }).strict()
+);
+var docThemeConfigSchema = import_zod.z.object({
+  family: themeFamilySchema.optional(),
+  density: themeDensitySchema.optional(),
+  /** @deprecated Use `family`. Preserved to migrate existing docs.json files. */
+  preset: themePresetSchema.optional(),
+  defaultMode: colorModeSchema.optional(),
+  accentColor: import_zod.z.string().optional(),
+  accentColorDark: import_zod.z.string().optional(),
+  fontFamily: import_zod.z.string().optional(),
+  codeTheme: import_zod.z.enum(["github", "dracula", "one-dark", "synthwave"]).optional(),
+  logo: import_zod.z.object({
+    light: import_zod.z.string().optional(),
+    dark: import_zod.z.string().optional(),
+    alt: import_zod.z.string().optional(),
+    text: import_zod.z.string().optional()
+  }).strict().optional(),
+  favicon: import_zod.z.string().optional()
+}).strict();
+var docSearchConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().optional(),
+  placeholder: import_zod.z.string().optional(),
+  maxResults: import_zod.z.number().int().positive().max(100).optional()
+}).strict();
+var docConfigSchema = import_zod.z.object({
+  $schema: import_zod.z.string().url("Must be an absolute URL.").optional(),
+  name: nonEmptyString.optional(),
+  tagline: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  version: import_zod.z.string().optional(),
+  rootDoc: nonEmptyString.optional(),
+  source: remoteSourceSchema.optional(),
+  theme: docThemeConfigSchema.optional(),
+  nav: import_zod.z.array(navLinkSchema).optional(),
+  socials: import_zod.z.array(socialLinkSchema).optional(),
+  sidebar: import_zod.z.array(sidebarItemSchema).optional(),
+  autoIndex: import_zod.z.object({
+    enabled: import_zod.z.boolean().optional(),
+    exclude: import_zod.z.array(nonEmptyString).optional(),
+    sort: import_zod.z.enum(["alphabetical", "frontmatter", "natural"]).optional(),
+    defaultCollapsed: import_zod.z.boolean().optional()
+  }).strict().optional(),
+  search: docSearchConfigSchema.optional(),
+  footer: import_zod.z.object({
+    copyright: import_zod.z.string().optional(),
+    links: import_zod.z.array(navLinkSchema).optional(),
+    showBuiltWith: import_zod.z.boolean().optional()
+  }).strict().optional(),
+  componentsUrl: import_zod.z.string().optional(),
+  editUrl: import_zod.z.string().optional()
+}).strict();
+var normalizedDocConfigSchema = docConfigSchema.extend({
+  name: nonEmptyString
+});
+function formatConfigIssues(error) {
+  return error.issues.map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "config"}: ${issue.message}`).join("\n");
+}
+function parseDocConfig(input) {
+  const result = docConfigSchema.safeParse(input);
+  if (result.success) return result.data;
+  throw new Error(`Invalid DocMeDown configuration:
+${formatConfigIssues(result.error)}`);
+}
+
+// src/runtime/config.ts
+var LEGACY_PRESET_FAMILIES = {
+  indigo: "atlas",
+  emerald: "atlas",
+  sunset: "editorial",
+  violet: "atlas",
+  rose: "editorial",
+  slate: "blueprint",
+  cyberpunk: "terminal"
+};
+var DEFAULT_CONFIG = {
+  name: "DocMeDown",
+  tagline: "The simplest Markdown documenter yet",
+  description: "Instant documentation site powered by DocMeDown",
+  version: "1.0.0",
+  rootDoc: "README.md",
+  theme: {
+    family: "atlas",
+    density: "comfortable",
+    defaultMode: "auto",
+    codeTheme: "github"
+  },
+  autoIndex: {
+    enabled: true,
+    sort: "natural",
+    defaultCollapsed: false,
+    exclude: ["node_modules", ".git", ".dmd", "dist", "bin", "package.json", "tsconfig.json"]
+  },
+  search: {
+    enabled: true,
+    placeholder: "Search documentation...",
+    maxResults: 10
+  },
+  footer: {
+    copyright: `\xA9 ${(/* @__PURE__ */ new Date()).getFullYear()} DocMeDown. All rights reserved.`,
+    showBuiltWith: true
+  }
+};
+function normalizeConfig(userConfig = {}) {
+  const parsedConfig = parseDocConfig(userConfig);
+  const legacyPreset = parsedConfig.theme?.preset;
+  const family = parsedConfig.theme?.family || (legacyPreset ? LEGACY_PRESET_FAMILIES[legacyPreset] : DEFAULT_CONFIG.theme?.family);
+  const { preset: _legacyPreset, ...resolvedTheme } = parsedConfig.theme ?? {};
+  void _legacyPreset;
+  const mergedConfig = {
+    ...DEFAULT_CONFIG,
+    ...parsedConfig,
+    theme: {
+      ...DEFAULT_CONFIG.theme,
+      ...resolvedTheme,
+      family,
+      logo: {
+        ...DEFAULT_CONFIG.theme?.logo,
+        ...parsedConfig.theme?.logo
+      }
+    },
+    autoIndex: {
+      ...DEFAULT_CONFIG.autoIndex,
+      ...parsedConfig.autoIndex
+    },
+    search: {
+      ...DEFAULT_CONFIG.search,
+      ...parsedConfig.search
+    },
+    footer: {
+      ...DEFAULT_CONFIG.footer,
+      ...parsedConfig.footer
+    }
+  };
+  return normalizedDocConfigSchema.parse(mergedConfig);
+}
+function parseDocConfigJson(json, source) {
+  try {
+    return parseDocConfig(JSON.parse(json));
+  } catch (error) {
+    throw new Error(`${source}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/runtime/offline-export.ts
+var OFFLINE_FORMAT_VERSION = 1;
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function createCompressedOfflineHtml(encodedGzip, title) {
+  const bootstrap = `(async()=>{try{const b=Uint8Array.from(atob(document.getElementById("d").textContent.trim()),c=>c.charCodeAt(0)),s=await new Response(new Blob([b]).stream().pipeThrough(new DecompressionStream("gzip"))).text(),e=JSON.parse(s);if(e.version!==${OFFLINE_FORMAT_VERSION})throw new Error("Unsupported offline format");window.__DOCMEDOWN_OFFLINE__=true;window.__DOCMEDOWN_DATA__=e.data;window.__DOCMEDOWN_CONFIG__=e.data.manifest.config;const u=URL.createObjectURL(new Blob([e.runtime],{type:"text/javascript"})),j=document.createElement("script");j.src=u;j.onload=()=>URL.revokeObjectURL(u);j.onerror=()=>{URL.revokeObjectURL(u);throw new Error("Runtime bootstrap failed")};document.head.appendChild(j)}catch(e){document.getElementById("dmd-app").textContent="Could not open this offline documentation copy: "+e.message}})();`;
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><link rel="icon" href="data:,"><title>${escapeHtml(title)}</title></head><body><div id="dmd-app">Opening offline documentation\u2026</div><script id="d" type="application/octet-stream">${encodedGzip}</script><script>${bootstrap}</script></body></html>`;
+}
 
 // src/cli/utils/scanner.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
 var import_gray_matter = __toESM(require("gray-matter"));
 
 // src/runtime/loader/auto-indexer.ts
@@ -181,16 +501,16 @@ function extractHeadings(content) {
 }
 function scanDirectory(dir, baseDir = dir, excludeList = ["node_modules", ".git", ".dmd", "dist", "bin"], stopAtNestedDocsRoots = true) {
   const results = [];
-  if (!import_fs.default.existsSync(dir)) return results;
-  const entries = import_fs.default.readdirSync(dir, { withFileTypes: true });
+  if (!import_node_fs.default.existsSync(dir)) return results;
+  const entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (excludeList.includes(entry.name) || entry.name.startsWith(".")) {
       continue;
     }
-    const fullPath = import_path.default.join(dir, entry.name);
-    const relPath = import_path.default.relative(baseDir, fullPath).replace(/\\/g, "/");
+    const fullPath = import_node_path.default.join(dir, entry.name);
+    const relPath = import_node_path.default.relative(baseDir, fullPath).replace(/\\/g, "/");
     if (entry.isDirectory()) {
-      const isNestedDocsRoot = stopAtNestedDocsRoots && fullPath !== baseDir && import_fs.default.existsSync(import_path.default.join(fullPath, "docs.json"));
+      const isNestedDocsRoot = stopAtNestedDocsRoots && fullPath !== baseDir && import_node_fs.default.existsSync(import_node_path.default.join(fullPath, "docs.json"));
       if (!isNestedDocsRoot) {
         results.push(...scanDirectory(fullPath, baseDir, excludeList, stopAtNestedDocsRoots));
       }
@@ -205,13 +525,13 @@ function generateManifest(docDir, config) {
   const docItems = [];
   const frontmatters = {};
   for (const relFile of files) {
-    const fullPath = import_path.default.join(docDir, relFile);
-    const raw = import_fs.default.readFileSync(fullPath, "utf-8");
+    const fullPath = import_node_path.default.join(docDir, relFile);
+    const raw = import_node_fs.default.readFileSync(fullPath, "utf-8");
     const { data: fm, content } = (0, import_gray_matter.default)(raw);
     const cleanSlug = relFile.replace(/\.(md|mdx)$/i, "");
     const isOverview = cleanSlug.toLowerCase() === "readme" || cleanSlug.toLowerCase() === "index";
     const slug = isOverview ? "README" : cleanSlug;
-    const title = fm.title || fm.sidebar_label || formatTitleFromFilename(import_path.default.basename(relFile));
+    const title = fm.title || fm.sidebar_label || formatTitleFromFilename(import_node_path.default.basename(relFile));
     frontmatters[relFile] = fm;
     const headings = extractHeadings(content);
     const words = content.trim().split(/\s+/).length;
@@ -225,7 +545,7 @@ function generateManifest(docDir, config) {
       headings,
       content,
       readingTimeMinutes,
-      lastModified: import_fs.default.statSync(fullPath).mtime.toISOString()
+      lastModified: import_node_fs.default.statSync(fullPath).mtime.toISOString()
     });
   }
   const tree = buildSidebarTree(files, frontmatters, config.sidebar);
@@ -238,63 +558,52 @@ function generateManifest(docDir, config) {
   };
 }
 
-// src/runtime/config.ts
-var DEFAULT_CONFIG = {
-  name: "DocMeDown",
-  tagline: "The simplest Markdown documenter yet",
-  description: "Instant documentation site powered by DocMeDown",
-  version: "1.0.0",
-  rootDoc: "README.md",
-  theme: {
-    preset: "indigo",
-    defaultMode: "auto",
-    codeTheme: "github"
-  },
-  autoIndex: {
-    enabled: true,
-    sort: "natural",
-    defaultCollapsed: false,
-    exclude: ["node_modules", ".git", ".dmd", "dist", "bin", "package.json", "tsconfig.json"]
-  },
-  search: {
-    enabled: true,
-    placeholder: "Search documentation...",
-    maxResults: 10
-  },
-  footer: {
-    copyright: `\xA9 ${(/* @__PURE__ */ new Date()).getFullYear()} DocMeDown. All rights reserved.`,
-    showBuiltWith: true
-  }
-};
-
 // src/cli/commands/build.ts
 var DEFAULT_OFFLINE_OUTPUT_DIRECTORY = ".dist";
 function getBuildOutputPaths(targetDir, offlineOutDir) {
   return {
     onlineDir: targetDir,
-    offlineDir: offlineOutDir ? import_path2.default.resolve(process.cwd(), offlineOutDir) : import_path2.default.join(targetDir, DEFAULT_OFFLINE_OUTPUT_DIRECTORY)
+    offlineDir: offlineOutDir ? import_node_path2.default.resolve(process.cwd(), offlineOutDir) : import_node_path2.default.join(targetDir, DEFAULT_OFFLINE_OUTPUT_DIRECTORY)
   };
 }
-function encodeOfflinePayload(value) {
-  return Buffer.from(JSON.stringify(value), "utf-8").toString("base64");
+function encodeCompressedOfflineEnvelope(envelope) {
+  return (0, import_node_zlib.gzipSync)(Buffer.from(JSON.stringify(envelope), "utf-8"), { level: 9 }).toString("base64");
 }
-function escapeInlineScriptContent(value) {
-  return value.replace(/<\/script/gi, "<\\/script");
-}
-function escapeHtml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+function bundleCustomComponents(componentsPath) {
+  if (!import_node_fs2.default.existsSync(componentsPath)) return void 0;
+  try {
+    const result = (0, import_esbuild.buildSync)({
+      entryPoints: [componentsPath],
+      bundle: true,
+      format: "esm",
+      platform: "browser",
+      target: "es2022",
+      write: false,
+      minify: true,
+      legalComments: "none"
+    });
+    const bundledSource = result.outputFiles[0]?.text;
+    if (!bundledSource) {
+      throw new Error("esbuild did not produce an output module.");
+    }
+    return bundledSource;
+  } catch (error) {
+    throw new Error(
+      `Could not bundle custom components from ${componentsPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
 }
 var GENERATED_DOC_OUTPUTS = ["_manifest.json", "_docs.js", "docmedown.iife.js"];
 function findNestedDocumentationRoots(targetDir) {
   const roots = [];
   function visit(directory) {
-    if (!import_fs2.default.existsSync(directory)) return;
-    for (const entry of import_fs2.default.readdirSync(directory, { withFileTypes: true })) {
+    if (!import_node_fs2.default.existsSync(directory)) return;
+    for (const entry of import_node_fs2.default.readdirSync(directory, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith(".") || ["node_modules", ".git", "dist", "bin"].includes(entry.name)) {
         continue;
       }
-      const fullPath = import_path2.default.join(directory, entry.name);
-      if (import_fs2.default.existsSync(import_path2.default.join(fullPath, "docs.json"))) {
+      const fullPath = import_node_path2.default.join(directory, entry.name);
+      if (import_node_fs2.default.existsSync(import_node_path2.default.join(fullPath, "docs.json"))) {
         roots.push(fullPath);
         visit(fullPath);
       } else {
@@ -306,132 +615,113 @@ function findNestedDocumentationRoots(targetDir) {
   return roots;
 }
 function shouldWatchDocumentationSource(rootDir, changedPath) {
-  const relativePath = import_path2.default.relative(rootDir, changedPath).replace(/\\/g, "/");
+  const relativePath = import_node_path2.default.relative(rootDir, changedPath).replace(/\\/g, "/");
   const firstSegment = relativePath.split("/")[0];
   const isCustomComponentModule = /(^|\/)\.dmd\/(components|index)\.js$/i.test(relativePath);
   return Boolean(relativePath) && !relativePath.startsWith("..") && (!relativePath.startsWith(".") || isCustomComponentModule) && !GENERATED_DOC_OUTPUTS.includes(relativePath) && firstSegment !== "node_modules" && firstSegment !== "dist";
 }
 async function buildCommand(targetDirArg = "./docs", options = {}) {
-  const targetDir = import_path2.default.resolve(process.cwd(), targetDirArg);
+  const targetDir = import_node_path2.default.resolve(process.cwd(), targetDirArg);
   const { onlineDir, offlineDir } = getBuildOutputPaths(targetDir, options.outDir);
   const buildOfflineBundle = options.singleFile !== false;
   console.log(import_chalk.default.bold.magenta("\n\u26A1 DocMeDown Build\n"));
-  if (!import_fs2.default.existsSync(targetDir)) {
+  if (!import_node_fs2.default.existsSync(targetDir)) {
     console.error(import_chalk.default.red(`\u2716 Directory not found: ${targetDir}`));
     process.exit(1);
   }
-  if (!import_fs2.default.existsSync(onlineDir)) {
-    import_fs2.default.mkdirSync(onlineDir, { recursive: true });
+  if (!import_node_fs2.default.existsSync(onlineDir)) {
+    import_node_fs2.default.mkdirSync(onlineDir, { recursive: true });
   }
-  if (buildOfflineBundle && !import_fs2.default.existsSync(offlineDir)) {
-    import_fs2.default.mkdirSync(offlineDir, { recursive: true });
+  import_node_fs2.default.writeFileSync(import_node_path2.default.join(onlineDir, ".nojekyll"), "", "utf-8");
+  if (buildOfflineBundle && !import_node_fs2.default.existsSync(offlineDir)) {
+    import_node_fs2.default.mkdirSync(offlineDir, { recursive: true });
   }
-  let config = DEFAULT_CONFIG;
-  const configPath = import_path2.default.join(targetDir, "docs.json");
-  if (import_fs2.default.existsSync(configPath)) {
+  let config = normalizeConfig();
+  const configPath = import_node_path2.default.join(targetDir, "docs.json");
+  if (import_node_fs2.default.existsSync(configPath)) {
     try {
-      config = { ...DEFAULT_CONFIG, ...JSON.parse(import_fs2.default.readFileSync(configPath, "utf-8")) };
-    } catch (err) {
-      console.warn(import_chalk.default.yellow(`\u26A0 Could not parse docs.json, using defaults.`));
+      config = normalizeConfig(parseDocConfigJson(import_node_fs2.default.readFileSync(configPath, "utf-8"), configPath));
+    } catch (error) {
+      throw new Error(`Could not validate ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   console.log(import_chalk.default.cyan("  Indexing documentation pages..."));
   const manifest = generateManifest(targetDir, config);
-  const manifestPath = import_path2.default.join(onlineDir, "_manifest.json");
-  import_fs2.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  const manifestPath = import_node_path2.default.join(onlineDir, "_manifest.json");
+  import_node_fs2.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   console.log(import_chalk.default.green(`  \u2714 Generated _manifest.json (${manifest.docs.length} pages indexed)`));
   const docsMap = {};
   const files = scanDirectory(targetDir);
   for (const file of files) {
-    const full = import_path2.default.join(targetDir, file);
-    const raw = import_fs2.default.readFileSync(full, "utf-8");
+    const full = import_node_path2.default.join(targetDir, file);
+    const raw = import_node_fs2.default.readFileSync(full, "utf-8");
     const slug = file.replace(/\.(md|mdx)$/i, "");
     const cleanSlug = slug.toLowerCase() === "readme" || slug.toLowerCase() === "index" ? "README" : slug;
     docsMap[cleanSlug] = raw;
     docsMap[file] = raw;
   }
-  const componentsPath = import_path2.default.join(targetDir, ".dmd", "components.js");
-  const componentsSource = import_fs2.default.existsSync(componentsPath) ? import_fs2.default.readFileSync(componentsPath, "utf-8") : void 0;
+  const componentsPath = import_node_path2.default.join(targetDir, ".dmd", "components.js");
+  const componentsSource = bundleCustomComponents(componentsPath);
   const docsJsContent = `window.__DOCMEDOWN_DATA__ = ${JSON.stringify({ manifest, docs: docsMap, componentsSource }, null, 2)};
 `;
-  const docsJsPath = import_path2.default.join(onlineDir, "_docs.js");
-  import_fs2.default.writeFileSync(docsJsPath, docsJsContent, "utf-8");
+  const docsJsPath = import_node_path2.default.join(onlineDir, "_docs.js");
+  import_node_fs2.default.writeFileSync(docsJsPath, docsJsContent, "utf-8");
   console.log(import_chalk.default.green(`  \u2714 Generated _docs.js for offline file:/// double-click usage`));
   if (buildOfflineBundle) {
     console.log(import_chalk.default.cyan("\n  Compiling standalone single-file offline index.html..."));
     const candidates2 = [
-      import_path2.default.resolve(__dirname, "docmedown.iife.js"),
-      import_path2.default.resolve(__dirname, "../dist/docmedown.iife.js"),
-      import_path2.default.resolve(__dirname, "../docmedown.iife.js")
+      import_node_path2.default.resolve(__dirname, "docmedown.iife.js"),
+      import_node_path2.default.resolve(__dirname, "../dist/docmedown.iife.js"),
+      import_node_path2.default.resolve(__dirname, "../docmedown.iife.js")
     ];
-    const distIifePath2 = candidates2.find((p) => import_fs2.default.existsSync(p));
+    const distIifePath2 = candidates2.find((p) => import_node_fs2.default.existsSync(p));
     let bundleJs = "";
     if (distIifePath2) {
-      bundleJs = import_fs2.default.readFileSync(distIifePath2, "utf-8");
+      bundleJs = import_node_fs2.default.readFileSync(distIifePath2, "utf-8");
     } else {
       console.warn(import_chalk.default.yellow("  \u26A0 Local runtime bundle not found, linking CDN script."));
     }
-    const offlinePayload = encodeOfflinePayload({ manifest, docs: docsMap, componentsSource });
-    const safeBundleJs = escapeInlineScriptContent(bundleJs);
-    const singleFileHtml = `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>${escapeHtml(config.name || "Documentation")}</title>
-</head>
-<body>
-  <div id="dmd-app"></div>
-  <script>
-    (function () {
-      const encoded = '${offlinePayload}';
-      const bytes = Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0));
-      const data = JSON.parse(new TextDecoder().decode(bytes));
-      window.__DOCMEDOWN_DATA__ = data;
-      window.__DOCMEDOWN_CONFIG__ = data.manifest.config;
-      if (data.componentsSource) {
-        const componentModule = new Blob([data.componentsSource], { type: 'text/javascript' });
-        const componentModuleUrl = URL.createObjectURL(componentModule);
-        window.__DOCMEDOWN_COMPONENTS_READY__ = import(componentModuleUrl)
-          .then((module) => module.default || module)
-          .finally(() => URL.revokeObjectURL(componentModuleUrl));
-      }
-    })();
-  </script>
-  <script>
-${safeBundleJs}
-  </script>
-</body>
-</html>`;
-    const singleFilePath = import_path2.default.join(offlineDir, "index.html");
-    import_fs2.default.writeFileSync(singleFilePath, singleFileHtml, "utf-8");
+    const envelope = {
+      version: OFFLINE_FORMAT_VERSION,
+      data: { manifest, docs: docsMap, componentsSource },
+      runtime: bundleJs
+    };
+    const encodedEnvelope = encodeCompressedOfflineEnvelope(envelope);
+    const singleFileHtml = createCompressedOfflineHtml(encodedEnvelope, config.name || "Documentation");
+    const singleFilePath = import_node_path2.default.join(offlineDir, "index.html");
+    import_node_fs2.default.writeFileSync(singleFilePath, singleFileHtml, "utf-8");
     console.log(import_chalk.default.bold.green(`  \u2714 Built self-contained offline bundle: ${singleFilePath}`));
+    console.log(
+      import_chalk.default.dim(
+        `    Compressed ${Buffer.byteLength(JSON.stringify(envelope), "utf-8").toLocaleString()} bytes to ${Buffer.byteLength(singleFileHtml, "utf-8").toLocaleString()} bytes.`
+      )
+    );
     console.log(import_chalk.default.dim(`    You can now double-click index.html to view offline without any server!
 `));
   }
   const candidates = [
-    import_path2.default.resolve(__dirname, "docmedown.iife.js"),
-    import_path2.default.resolve(__dirname, "../dist/docmedown.iife.js"),
-    import_path2.default.resolve(__dirname, "../docmedown.iife.js")
+    import_node_path2.default.resolve(__dirname, "docmedown.iife.js"),
+    import_node_path2.default.resolve(__dirname, "../dist/docmedown.iife.js"),
+    import_node_path2.default.resolve(__dirname, "../docmedown.iife.js")
   ];
-  const distIifePath = candidates.find((p) => import_fs2.default.existsSync(p));
-  const targetBundlePath = import_path2.default.join(onlineDir, "docmedown.iife.js");
+  const distIifePath = candidates.find((p) => import_node_fs2.default.existsSync(p));
+  const targetBundlePath = import_node_path2.default.join(onlineDir, "docmedown.iife.js");
   if (distIifePath) {
-    import_fs2.default.copyFileSync(distIifePath, targetBundlePath);
+    import_node_fs2.default.copyFileSync(distIifePath, targetBundlePath);
     console.log(import_chalk.default.green(`  \u2714 Updated serveable runtime: ${targetBundlePath}`));
   }
   if (options.buildNested !== false) {
     const nestedRoots = findNestedDocumentationRoots(targetDir);
     for (const nestedRoot of nestedRoots) {
       console.log(import_chalk.default.cyan(`
-  Building nested documentation site: ${import_path2.default.relative(targetDir, nestedRoot)}...`));
+  Building nested documentation site: ${import_node_path2.default.relative(targetDir, nestedRoot)}...`));
       await buildCommand(nestedRoot, { buildNested: false });
     }
   }
   console.log(import_chalk.default.bold.green("\u2728 Build completed successfully!\n"));
 }
 async function watchBuildCommand(targetDirArg = "./docs", options = {}) {
-  const targetDir = import_path2.default.resolve(process.cwd(), targetDirArg);
+  const targetDir = import_node_path2.default.resolve(process.cwd(), targetDirArg);
   await buildCommand(targetDir, { ...options, watch: false });
   console.log(import_chalk.default.dim(`  Watching source files in: ${targetDir}`));
   console.log(import_chalk.default.dim("  Source changes rebuild serveable files and .dist/index.html. Press Ctrl+C to stop.\n"));
@@ -452,7 +742,7 @@ async function watchBuildCommand(targetDirArg = "./docs", options = {}) {
     if (!shouldWatchDocumentationSource(targetDir, changedPath)) return;
     if (rebuildTimeout) clearTimeout(rebuildTimeout);
     rebuildTimeout = setTimeout(async () => {
-      const relativePath = import_path2.default.relative(targetDir, changedPath);
+      const relativePath = import_node_path2.default.relative(targetDir, changedPath);
       console.log(import_chalk.default.cyan(`[DocMeDown] Changed: ${relativePath} -> Rebuilding documentation...`));
       try {
         await buildCommand(targetDir, { ...options, watch: false });
@@ -464,54 +754,211 @@ async function watchBuildCommand(targetDirArg = "./docs", options = {}) {
   return new Promise(() => void 0);
 }
 
-// src/cli/utils/server.ts
-function shouldRebuildDocumentation(rootDir, changedPath) {
-  return shouldWatchDocumentationSource(rootDir, changedPath);
-}
-function startDevServer(options) {
-  const { rootDir, host = "localhost", port: initialPort = 3e3, onSourceChange } = options;
-  return new Promise((resolve, reject) => {
-    let port = initialPort;
-    const liveReloadScript = `
-<script>
-(function() {
-  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-  let ws = null;
-  function connect() {
-    ws = new WebSocket(protocol + '//' + window.location.host + '/__dmd_reload');
-    ws.onmessage = function(e) {
-      if (e.data === 'reload') {
-        console.log('[DocMeDown] File changed, reloading...');
-        window.location.reload();
-      }
-    };
-    ws.onclose = function() {
-      setTimeout(connect, 1500);
-    };
+// src/cli/commands/config-tui.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_prompts = __toESM(require("prompts"));
+async function configTuiCommand(configPathArg) {
+  console.log(import_chalk2.default.bold.magenta("\n\u26A1 DocMeDown - Interactive Configuration Wizard\n"));
+  let configPath = "";
+  if (configPathArg) {
+    configPath = import_node_path3.default.resolve(process.cwd(), configPathArg);
+    if (import_node_fs3.default.existsSync(configPath) && import_node_fs3.default.statSync(configPath).isDirectory()) {
+      configPath = import_node_path3.default.join(configPath, "docs.json");
+    }
+  } else {
+    const candidates = [
+      import_node_path3.default.resolve(process.cwd(), "docs.json"),
+      import_node_path3.default.resolve(process.cwd(), "docs/docs.json"),
+      import_node_path3.default.resolve(process.cwd(), "dmd.json")
+    ];
+    configPath = candidates.find((p) => import_node_fs3.default.existsSync(p)) || import_node_path3.default.resolve(process.cwd(), "docs/docs.json");
   }
-  connect();
-})();
-</script>
-`;
-    const server = import_http.default.createServer((req, res) => {
-      res.setHeader("Access-Control-Allow-Origin", "*");
-      res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
-      if (req.method === "OPTIONS") {
-        res.writeHead(204);
-        res.end();
-        return;
-      }
-      let reqPath = decodeURIComponent(req.url?.split("?")[0] || "/");
-      if (reqPath === "/" || reqPath === "") {
-        reqPath = "/index.html";
-      }
-      let filePath = import_path3.default.join(rootDir, reqPath);
-      if (!import_fs3.default.existsSync(filePath) || import_fs3.default.statSync(filePath).isDirectory()) {
-        const potentialIndex = import_path3.default.join(rootDir, "index.html");
-        if (import_fs3.default.existsSync(potentialIndex)) {
-          filePath = potentialIndex;
-        } else {
-          res.writeHead(200, { "Content-Type": "text/html" });
+  let existingConfig = normalizeConfig();
+  if (import_node_fs3.default.existsSync(configPath)) {
+    try {
+      existingConfig = normalizeConfig(parseDocConfigJson(import_node_fs3.default.readFileSync(configPath, "utf-8"), configPath));
+      console.log(import_chalk2.default.dim(`  Loaded existing configuration from: ${configPath}
+`));
+    } catch (error) {
+      console.warn(import_chalk2.default.yellow(`  \u26A0 ${error instanceof Error ? error.message : String(error)}
+`));
+    }
+  } else {
+    console.log(import_chalk2.default.dim(`  Creating new configuration at: ${configPath}
+`));
+  }
+  const response = await (0, import_prompts.default)([
+    {
+      type: "text",
+      name: "name",
+      message: "Project Name:",
+      initial: existingConfig.name || "My Project Docs"
+    },
+    {
+      type: "text",
+      name: "tagline",
+      message: "Tagline / Short description:",
+      initial: existingConfig.tagline || "The simplest Markdown documenter yet"
+    },
+    {
+      type: "select",
+      name: "family",
+      message: "Select Documentation Theme Family:",
+      choices: [
+        { title: "Atlas (Editorial technical reference)", value: "atlas" },
+        { title: "Blueprint (Structured and schematic)", value: "blueprint" },
+        { title: "Terminal (Compact operational console)", value: "terminal" },
+        { title: "Editorial (Spacious publication reading)", value: "editorial" }
+      ],
+      initial: ["atlas", "blueprint", "terminal", "editorial"].indexOf(existingConfig.theme?.family || "atlas")
+    },
+    {
+      type: "select",
+      name: "defaultMode",
+      message: "Default Color Mode:",
+      choices: [
+        { title: "Auto (Follows OS system preference)", value: "auto" },
+        { title: "Dark (Default dark theme)", value: "dark" },
+        { title: "Light (Default light theme)", value: "light" }
+      ],
+      initial: ["auto", "dark", "light"].indexOf(existingConfig.theme?.defaultMode || "auto")
+    },
+    {
+      type: "select",
+      name: "sourceType",
+      message: "Documentation Source Mode:",
+      choices: [
+        { title: "Local Markdown Files (hosted together in folder)", value: "local" },
+        { title: "Remote GitHub Repository (live dynamic fetch)", value: "github" },
+        { title: "Remote GitLab Repository (live dynamic fetch)", value: "gitlab" }
+      ],
+      initial: existingConfig.source?.type ? existingConfig.source.type === "github" ? 1 : 2 : 0
+    },
+    {
+      type: (prev) => prev === "github" ? "text" : null,
+      name: "githubRepo",
+      message: "GitHub Repository (owner/repo):",
+      initial: existingConfig.source?.type === "raw" ? "facebook/react" : existingConfig.source?.repo || "facebook/react"
+    },
+    {
+      type: (_prev, values) => values.sourceType === "github" ? "text" : null,
+      name: "githubBranch",
+      message: "GitHub Branch:",
+      initial: existingConfig.source?.branch || "main"
+    },
+    {
+      type: (_prev, values) => values.sourceType === "github" ? "text" : null,
+      name: "githubDocsDir",
+      message: "GitHub Docs Subfolder (leave empty for root):",
+      initial: existingConfig.source?.docsDir || "docs"
+    },
+    {
+      type: "text",
+      name: "githubSocial",
+      message: "GitHub Repository URL for Navbar link (optional):",
+      initial: existingConfig.socials?.find((s) => s.type === "github")?.url || ""
+    }
+  ]);
+  if (!response.name) {
+    console.log(import_chalk2.default.yellow("\nConfiguration cancelled."));
+    return;
+  }
+  const updatedConfig = normalizeConfig({
+    ...existingConfig,
+    name: response.name,
+    tagline: response.tagline,
+    theme: {
+      ...existingConfig.theme,
+      family: response.family,
+      defaultMode: response.defaultMode
+    },
+    socials: response.githubSocial ? [{ type: "github", url: response.githubSocial }] : existingConfig.socials
+  });
+  if (response.sourceType === "github") {
+    updatedConfig.source = {
+      type: "github",
+      repo: response.githubRepo,
+      branch: response.githubBranch,
+      docsDir: response.githubDocsDir
+    };
+  } else if (response.sourceType === "local") {
+    delete updatedConfig.source;
+  }
+  const dir = import_node_path3.default.dirname(configPath);
+  if (!import_node_fs3.default.existsSync(dir)) {
+    import_node_fs3.default.mkdirSync(dir, { recursive: true });
+  }
+  const validatedConfig = normalizeConfig(updatedConfig);
+  import_node_fs3.default.writeFileSync(configPath, JSON.stringify(validatedConfig, null, 2), "utf-8");
+  console.log(import_chalk2.default.bold.green(`
+\u2714 Configuration successfully saved to: ${configPath}
+`));
+}
+
+// src/cli/commands/init.ts
+var import_node_fs5 = __toESM(require("fs"));
+var import_node_path5 = __toESM(require("path"));
+var import_chalk4 = __toESM(require("chalk"));
+var import_open = __toESM(require("open"));
+var import_prompts2 = __toESM(require("prompts"));
+
+// src/cli/utils/server.ts
+var import_node_fs4 = __toESM(require("fs"));
+var import_node_http = __toESM(require("http"));
+var import_node_path4 = __toESM(require("path"));
+var import_chalk3 = __toESM(require("chalk"));
+var import_chokidar2 = __toESM(require("chokidar"));
+var import_mime_types = __toESM(require("mime-types"));
+var import_ws = require("ws");
+function shouldRebuildDocumentation(rootDir, changedPath) {
+  return shouldWatchDocumentationSource(rootDir, changedPath);
+}
+function startDevServer(options) {
+  const { rootDir, host = "localhost", port: initialPort = 3e3, onSourceChange } = options;
+  return new Promise((resolve, reject) => {
+    let port = initialPort;
+    const liveReloadScript = `
+<script>
+(function() {
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  let ws = null;
+  function connect() {
+    ws = new WebSocket(protocol + '//' + window.location.host + '/__dmd_reload');
+    ws.onmessage = function(e) {
+      if (e.data === 'reload') {
+        console.log('[DocMeDown] File changed, reloading...');
+        window.location.reload();
+      }
+    };
+    ws.onclose = function() {
+      setTimeout(connect, 1500);
+    };
+  }
+  connect();
+})();
+</script>
+`;
+    const server = import_node_http.default.createServer((req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      let reqPath = decodeURIComponent(req.url?.split("?")[0] || "/");
+      if (reqPath === "/" || reqPath === "") {
+        reqPath = "/index.html";
+      }
+      let filePath = import_node_path4.default.join(rootDir, reqPath);
+      if (!import_node_fs4.default.existsSync(filePath) || import_node_fs4.default.statSync(filePath).isDirectory()) {
+        const potentialIndex = import_node_path4.default.join(rootDir, "index.html");
+        if (import_node_fs4.default.existsSync(potentialIndex)) {
+          filePath = potentialIndex;
+        } else {
+          res.writeHead(200, { "Content-Type": "text/html" });
           res.end(`
 <!DOCTYPE html>
 <html>
@@ -526,37 +973,37 @@ function startDevServer(options) {
           return;
         }
       }
-      if (reqPath === "/docmedown.iife.js" && !import_fs3.default.existsSync(filePath)) {
+      if (reqPath === "/docmedown.iife.js" && !import_node_fs4.default.existsSync(filePath)) {
         const bundleCandidates = [
-          import_path3.default.resolve(__dirname, "docmedown.iife.js"),
-          import_path3.default.resolve(__dirname, "../dist/docmedown.iife.js"),
-          import_path3.default.resolve(__dirname, "../docmedown.iife.js")
+          import_node_path4.default.resolve(__dirname, "docmedown.iife.js"),
+          import_node_path4.default.resolve(__dirname, "../dist/docmedown.iife.js"),
+          import_node_path4.default.resolve(__dirname, "../docmedown.iife.js")
         ];
-        const distFile = bundleCandidates.find((p) => import_fs3.default.existsSync(p));
+        const distFile = bundleCandidates.find((p) => import_node_fs4.default.existsSync(p));
         if (distFile) {
           filePath = distFile;
         }
       }
       try {
-        const stat = import_fs3.default.statSync(filePath);
+        const stat = import_node_fs4.default.statSync(filePath);
         if (stat.isDirectory()) {
-          filePath = import_path3.default.join(filePath, "index.html");
+          filePath = import_node_path4.default.join(filePath, "index.html");
         }
         const mimeType = import_mime_types.default.lookup(filePath) || "application/octet-stream";
         res.setHeader("Content-Type", mimeType);
         if (mimeType.includes("html")) {
-          let content = import_fs3.default.readFileSync(filePath, "utf-8");
+          let content = import_node_fs4.default.readFileSync(filePath, "utf-8");
           if (!content.includes("/__dmd_reload")) {
             content = content.replace("</body>", `${liveReloadScript}</body>`);
           }
           res.writeHead(200);
           res.end(content);
         } else {
-          const stream = import_fs3.default.createReadStream(filePath);
+          const stream = import_node_fs4.default.createReadStream(filePath);
           res.writeHead(200);
           stream.pipe(res);
         }
-      } catch (err) {
+      } catch (_err) {
         res.writeHead(404, { "Content-Type": "text/plain" });
         res.end("404 Not Found");
       }
@@ -590,16 +1037,16 @@ function startDevServer(options) {
       if (!shouldRebuildDocumentation(rootDir, changedPath)) return;
       if (reloadTimeout) clearTimeout(reloadTimeout);
       reloadTimeout = setTimeout(async () => {
-        const rel = import_path3.default.relative(rootDir, changedPath);
+        const rel = import_node_path4.default.relative(rootDir, changedPath);
         try {
           if (onSourceChange) {
-            console.log(import_chalk2.default.cyan(`[DocMeDown] Changed: ${rel} -> Rebuilding documentation...`));
+            console.log(import_chalk3.default.cyan(`[DocMeDown] Changed: ${rel} -> Rebuilding documentation...`));
             await onSourceChange(event, changedPath);
           } else {
-            console.log(import_chalk2.default.cyan(`[DocMeDown] Changed: ${rel} -> Reloading preview...`));
+            console.log(import_chalk3.default.cyan(`[DocMeDown] Changed: ${rel} -> Reloading preview...`));
           }
         } catch (err) {
-          console.error(import_chalk2.default.red(`[DocMeDown] Rebuild failed: ${err.message}`));
+          console.error(import_chalk3.default.red(`[DocMeDown] Rebuild failed: ${err.message}`));
         }
         clients.forEach((ws) => {
           if (ws.readyState === import_ws.WebSocket.OPEN) {
@@ -634,108 +1081,107 @@ function startDevServer(options) {
 }
 
 // src/cli/commands/init.ts
-var import_open = __toESM(require("open"));
 async function initCommand(targetDirArg = "./docs", options = {}) {
-  const targetDir = import_path4.default.resolve(process.cwd(), targetDirArg);
-  console.log(import_chalk3.default.bold.magenta("\n\u26A1 DocMeDown - Instant Documentation Initializer\n"));
-  if (!import_fs4.default.existsSync(targetDir)) {
-    import_fs4.default.mkdirSync(targetDir, { recursive: true });
+  const targetDir = import_node_path5.default.resolve(process.cwd(), targetDirArg);
+  console.log(import_chalk4.default.bold.magenta("\n\u26A1 DocMeDown - Instant Documentation Initializer\n"));
+  if (!import_node_fs5.default.existsSync(targetDir)) {
+    import_node_fs5.default.mkdirSync(targetDir, { recursive: true });
   }
-  const templatesDir = import_path4.default.resolve(__dirname, "../../templates");
-  const fallbackTemplatesDir = import_path4.default.resolve(__dirname, "../templates");
-  const activeTemplateDir = import_fs4.default.existsSync(templatesDir) ? templatesDir : fallbackTemplatesDir;
-  const indexPath = import_path4.default.join(targetDir, "index.html");
-  if (!import_fs4.default.existsSync(indexPath)) {
-    const templateHtml = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "index.html"), "utf-8");
-    import_fs4.default.writeFileSync(indexPath, templateHtml, "utf-8");
-    console.log(import_chalk3.default.green("  \u2714 Created index.html"));
+  const templatesDir = import_node_path5.default.resolve(__dirname, "../../templates");
+  const fallbackTemplatesDir = import_node_path5.default.resolve(__dirname, "../templates");
+  const activeTemplateDir = import_node_fs5.default.existsSync(templatesDir) ? templatesDir : fallbackTemplatesDir;
+  const indexPath = import_node_path5.default.join(targetDir, "index.html");
+  if (!import_node_fs5.default.existsSync(indexPath)) {
+    const templateHtml = import_node_fs5.default.readFileSync(import_node_path5.default.join(activeTemplateDir, "index.html"), "utf-8");
+    import_node_fs5.default.writeFileSync(indexPath, templateHtml, "utf-8");
+    console.log(import_chalk4.default.green("  \u2714 Created index.html"));
   }
-  const configPath = import_path4.default.join(targetDir, "docs.json");
-  if (!import_fs4.default.existsSync(configPath)) {
-    const templateConfig = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "docs.json"), "utf-8");
-    import_fs4.default.writeFileSync(configPath, templateConfig, "utf-8");
-    console.log(import_chalk3.default.green("  \u2714 Created docs.json"));
+  const configPath = import_node_path5.default.join(targetDir, "docs.json");
+  if (!import_node_fs5.default.existsSync(configPath)) {
+    const templateConfig = import_node_fs5.default.readFileSync(import_node_path5.default.join(activeTemplateDir, "docs.json"), "utf-8");
+    import_node_fs5.default.writeFileSync(configPath, templateConfig, "utf-8");
+    console.log(import_chalk4.default.green("  \u2714 Created docs.json"));
   }
-  const readmePath = import_path4.default.join(targetDir, "README.md");
-  if (!import_fs4.default.existsSync(readmePath)) {
-    const templateReadme = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "README.md"), "utf-8");
-    import_fs4.default.writeFileSync(readmePath, templateReadme, "utf-8");
-    console.log(import_chalk3.default.green("  \u2714 Created README.md"));
+  const readmePath = import_node_path5.default.join(targetDir, "README.md");
+  if (!import_node_fs5.default.existsSync(readmePath)) {
+    const templateReadme = import_node_fs5.default.readFileSync(import_node_path5.default.join(activeTemplateDir, "README.md"), "utf-8");
+    import_node_fs5.default.writeFileSync(readmePath, templateReadme, "utf-8");
+    console.log(import_chalk4.default.green("  \u2714 Created README.md"));
   }
-  const gsPath = import_path4.default.join(targetDir, "getting-started.md");
-  if (!import_fs4.default.existsSync(gsPath)) {
-    const templateGs = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "getting-started.md"), "utf-8");
-    import_fs4.default.writeFileSync(gsPath, templateGs, "utf-8");
-    console.log(import_chalk3.default.green("  \u2714 Created getting-started.md"));
+  const gsPath = import_node_path5.default.join(targetDir, "getting-started.md");
+  if (!import_node_fs5.default.existsSync(gsPath)) {
+    const templateGs = import_node_fs5.default.readFileSync(import_node_path5.default.join(activeTemplateDir, "getting-started.md"), "utf-8");
+    import_node_fs5.default.writeFileSync(gsPath, templateGs, "utf-8");
+    console.log(import_chalk4.default.green("  \u2714 Created getting-started.md"));
   }
-  const guidesDir = import_path4.default.join(targetDir, "guides");
-  if (!import_fs4.default.existsSync(guidesDir)) {
-    import_fs4.default.mkdirSync(guidesDir, { recursive: true });
+  const guidesDir = import_node_path5.default.join(targetDir, "guides");
+  if (!import_node_fs5.default.existsSync(guidesDir)) {
+    import_node_fs5.default.mkdirSync(guidesDir, { recursive: true });
   }
-  const guidePath = import_path4.default.join(guidesDir, "custom-components.md");
-  if (!import_fs4.default.existsSync(guidePath)) {
-    const templateGuide = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "guides/custom-components.md"), "utf-8");
-    import_fs4.default.writeFileSync(guidePath, templateGuide, "utf-8");
-    console.log(import_chalk3.default.green("  \u2714 Created guides/custom-components.md"));
+  const guidePath = import_node_path5.default.join(guidesDir, "custom-components.md");
+  if (!import_node_fs5.default.existsSync(guidePath)) {
+    const templateGuide = import_node_fs5.default.readFileSync(import_node_path5.default.join(activeTemplateDir, "guides/custom-components.md"), "utf-8");
+    import_node_fs5.default.writeFileSync(guidePath, templateGuide, "utf-8");
+    console.log(import_chalk4.default.green("  \u2714 Created guides/custom-components.md"));
   }
-  const dmdDir = import_path4.default.join(targetDir, ".dmd");
-  if (!import_fs4.default.existsSync(dmdDir)) {
-    import_fs4.default.mkdirSync(dmdDir, { recursive: true });
+  const dmdDir = import_node_path5.default.join(targetDir, ".dmd");
+  if (!import_node_fs5.default.existsSync(dmdDir)) {
+    import_node_fs5.default.mkdirSync(dmdDir, { recursive: true });
   }
-  const dmdComponentPath = import_path4.default.join(dmdDir, "components.js");
-  if (!import_fs4.default.existsSync(dmdComponentPath)) {
-    const templateDmd = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, ".dmd/components.js"), "utf-8");
-    import_fs4.default.writeFileSync(dmdComponentPath, templateDmd, "utf-8");
-    console.log(import_chalk3.default.green("  \u2714 Created .dmd/components.js"));
+  const dmdComponentPath = import_node_path5.default.join(dmdDir, "components.js");
+  if (!import_node_fs5.default.existsSync(dmdComponentPath)) {
+    const templateDmd = import_node_fs5.default.readFileSync(import_node_path5.default.join(activeTemplateDir, ".dmd/components.js"), "utf-8");
+    import_node_fs5.default.writeFileSync(dmdComponentPath, templateDmd, "utf-8");
+    console.log(import_chalk4.default.green("  \u2714 Created .dmd/components.js"));
   }
   await buildCommand(targetDir);
-  console.log(import_chalk3.default.bold.green("\n\u2728 DocMeDown site successfully initialized!\n"));
-  console.log(import_chalk3.default.dim(`  Location: ${targetDir}
+  console.log(import_chalk4.default.bold.green("\n\u2728 DocMeDown site successfully initialized!\n"));
+  console.log(import_chalk4.default.dim(`  Location: ${targetDir}
 `));
-  console.log(import_chalk3.default.cyan("  To preview your docs:"));
-  console.log(import_chalk3.default.white(`    npx docmedown serve ${targetDirArg}
+  console.log(import_chalk4.default.cyan("  To preview your docs:"));
+  console.log(import_chalk4.default.white(`    npx docmedown serve ${targetDirArg}
 `));
-  console.log(import_chalk3.default.cyan("  To customize settings:"));
-  console.log(import_chalk3.default.white(`    npx docmedown config ${targetDirArg}/docs.json
+  console.log(import_chalk4.default.cyan("  To customize settings:"));
+  console.log(import_chalk4.default.white(`    npx docmedown config ${targetDirArg}/docs.json
 `));
   if (options.start !== false && process.stdout.isTTY) {
-    const response = await (0, import_prompts.default)({
+    const response = await (0, import_prompts2.default)({
       type: "confirm",
       name: "startServer",
       message: "Would you like to start the local preview server now?",
       initial: true
     });
     if (response.startServer) {
-      console.log(import_chalk3.default.cyan("\n\u{1F680} Starting local live preview server..."));
+      console.log(import_chalk4.default.cyan("\n\u{1F680} Starting local live preview server..."));
       const devServer = await startDevServer({ rootDir: targetDir, port: 3e3 });
       const url = `http://localhost:${devServer.port}`;
-      console.log(import_chalk3.default.bold.green(`
-\u2714 Documentation live at: ${import_chalk3.default.underline(url)}
+      console.log(import_chalk4.default.bold.green(`
+\u2714 Documentation live at: ${import_chalk4.default.underline(url)}
 `));
-      console.log(import_chalk3.default.dim("  Press Ctrl+C to stop the server\n"));
+      console.log(import_chalk4.default.dim("  Press Ctrl+C to stop the server\n"));
       await (0, import_open.default)(url);
     }
   }
 }
 
 // src/cli/commands/serve.ts
-var import_path5 = __toESM(require("path"));
-var import_fs5 = __toESM(require("fs"));
-var import_chalk4 = __toESM(require("chalk"));
+var import_node_fs6 = __toESM(require("fs"));
+var import_node_path6 = __toESM(require("path"));
+var import_chalk5 = __toESM(require("chalk"));
 var import_open2 = __toESM(require("open"));
 async function serveCommand(targetDirArg = "./docs", options = {}) {
-  let targetDir = import_path5.default.resolve(process.cwd(), targetDirArg);
-  if (!import_fs5.default.existsSync(targetDir)) {
-    if (import_fs5.default.existsSync(import_path5.default.resolve(process.cwd(), "docs"))) {
-      targetDir = import_path5.default.resolve(process.cwd(), "docs");
+  let targetDir = import_node_path6.default.resolve(process.cwd(), targetDirArg);
+  if (!import_node_fs6.default.existsSync(targetDir)) {
+    if (import_node_fs6.default.existsSync(import_node_path6.default.resolve(process.cwd(), "docs"))) {
+      targetDir = import_node_path6.default.resolve(process.cwd(), "docs");
     } else {
       targetDir = process.cwd();
     }
   }
-  console.log(import_chalk4.default.bold.magenta("\n\u26A1 DocMeDown Dev Server\n"));
-  console.log(import_chalk4.default.dim(`  Serving directory: ${targetDir}`));
+  console.log(import_chalk5.default.bold.magenta("\n\u26A1 DocMeDown Dev Server\n"));
+  console.log(import_chalk5.default.dim(`  Serving directory: ${targetDir}`));
   try {
-    console.log(import_chalk4.default.dim("  Building serveable and offline documentation artifacts..."));
+    console.log(import_chalk5.default.dim("  Building serveable and offline documentation artifacts..."));
     await buildCommand(targetDir);
     const devServer = await startDevServer({
       rootDir: targetDir,
@@ -744,290 +1190,31 @@ async function serveCommand(targetDirArg = "./docs", options = {}) {
       onSourceChange: () => buildCommand(targetDir)
     });
     const url = `http://${options.host || "localhost"}:${devServer.port}`;
-    console.log(import_chalk4.default.bold.green(`
+    console.log(import_chalk5.default.bold.green(`
 \u2714 Live Documentation Server running at:`));
-    console.log(import_chalk4.default.bold.cyan(`  \u279C  Local:   ${import_chalk4.default.underline(url)}`));
-    console.log(import_chalk4.default.dim(`  \u279C  Watch: Source changes rebuild preview and .dist/index.html`));
-    console.log(import_chalk4.default.dim(`
+    console.log(import_chalk5.default.bold.cyan(`  \u279C  Local:   ${import_chalk5.default.underline(url)}`));
+    console.log(import_chalk5.default.dim(`  \u279C  Watch: Source changes rebuild preview and .dist/index.html`));
+    console.log(import_chalk5.default.dim(`
   Press Ctrl+C to stop.
 `));
     if (options.open !== false) {
       await (0, import_open2.default)(url);
     }
   } catch (err) {
-    console.error(import_chalk4.default.red(`
+    console.error(import_chalk5.default.red(`
 \u2716 Error starting server: ${err.message}
 `));
     process.exit(1);
   }
 }
 
-// src/cli/commands/config-tui.ts
-var import_fs6 = __toESM(require("fs"));
-var import_path6 = __toESM(require("path"));
-var import_chalk5 = __toESM(require("chalk"));
-var import_prompts2 = __toESM(require("prompts"));
-async function configTuiCommand(configPathArg) {
-  console.log(import_chalk5.default.bold.magenta("\n\u26A1 DocMeDown - Interactive Configuration Wizard\n"));
-  let configPath = "";
-  if (configPathArg) {
-    configPath = import_path6.default.resolve(process.cwd(), configPathArg);
-    if (import_fs6.default.existsSync(configPath) && import_fs6.default.statSync(configPath).isDirectory()) {
-      configPath = import_path6.default.join(configPath, "docs.json");
-    }
-  } else {
-    const candidates = [
-      import_path6.default.resolve(process.cwd(), "docs.json"),
-      import_path6.default.resolve(process.cwd(), "docs/docs.json"),
-      import_path6.default.resolve(process.cwd(), "dmd.json")
-    ];
-    configPath = candidates.find((p) => import_fs6.default.existsSync(p)) || import_path6.default.resolve(process.cwd(), "docs/docs.json");
-  }
-  let existingConfig = DEFAULT_CONFIG;
-  if (import_fs6.default.existsSync(configPath)) {
-    try {
-      existingConfig = { ...DEFAULT_CONFIG, ...JSON.parse(import_fs6.default.readFileSync(configPath, "utf-8")) };
-      console.log(import_chalk5.default.dim(`  Loaded existing configuration from: ${configPath}
-`));
-    } catch {
-      console.warn(import_chalk5.default.yellow(`  \u26A0 Error reading ${configPath}, starting fresh.
-`));
-    }
-  } else {
-    console.log(import_chalk5.default.dim(`  Creating new configuration at: ${configPath}
-`));
-  }
-  const response = await (0, import_prompts2.default)([
-    {
-      type: "text",
-      name: "name",
-      message: "Project Name:",
-      initial: existingConfig.name || "My Project Docs"
-    },
-    {
-      type: "text",
-      name: "tagline",
-      message: "Tagline / Short description:",
-      initial: existingConfig.tagline || "The simplest Markdown documenter yet"
-    },
-    {
-      type: "select",
-      name: "preset",
-      message: "Select Theme Color Palette:",
-      choices: [
-        { title: "Indigo (Modern & Clean)", value: "indigo" },
-        { title: "Emerald (Fresh & Tech)", value: "emerald" },
-        { title: "Sunset (Warm Amber)", value: "sunset" },
-        { title: "Violet (Vibrant Purple)", value: "violet" },
-        { title: "Rose (Bold Quartz)", value: "rose" },
-        { title: "Slate (Minimalist Monochrome)", value: "slate" },
-        { title: "Cyberpunk (Neon Glow)", value: "cyberpunk" }
-      ],
-      initial: ["indigo", "emerald", "sunset", "violet", "rose", "slate", "cyberpunk"].indexOf(
-        existingConfig.theme?.preset || "indigo"
-      )
-    },
-    {
-      type: "select",
-      name: "defaultMode",
-      message: "Default Color Mode:",
-      choices: [
-        { title: "Auto (Follows OS system preference)", value: "auto" },
-        { title: "Dark (Default dark theme)", value: "dark" },
-        { title: "Light (Default light theme)", value: "light" }
-      ],
-      initial: ["auto", "dark", "light"].indexOf(existingConfig.theme?.defaultMode || "auto")
-    },
-    {
-      type: "select",
-      name: "sourceType",
-      message: "Documentation Source Mode:",
-      choices: [
-        { title: "Local Markdown Files (hosted together in folder)", value: "local" },
-        { title: "Remote GitHub Repository (live dynamic fetch)", value: "github" },
-        { title: "Remote GitLab Repository (live dynamic fetch)", value: "gitlab" }
-      ],
-      initial: existingConfig.source?.type ? existingConfig.source.type === "github" ? 1 : 2 : 0
-    },
-    {
-      type: (prev) => prev === "github" ? "text" : null,
-      name: "githubRepo",
-      message: "GitHub Repository (owner/repo):",
-      initial: existingConfig.source?.repo || "facebook/react"
-    },
-    {
-      type: (prev, values) => values.sourceType === "github" ? "text" : null,
-      name: "githubBranch",
-      message: "GitHub Branch:",
-      initial: existingConfig.source?.branch || "main"
-    },
-    {
-      type: (prev, values) => values.sourceType === "github" ? "text" : null,
-      name: "githubDocsDir",
-      message: "GitHub Docs Subfolder (leave empty for root):",
-      initial: existingConfig.source?.docsDir || "docs"
-    },
-    {
-      type: "text",
-      name: "githubSocial",
-      message: "GitHub Repository URL for Navbar link (optional):",
-      initial: existingConfig.socials?.find((s) => s.type === "github")?.url || ""
-    }
-  ]);
-  if (!response.name) {
-    console.log(import_chalk5.default.yellow("\nConfiguration cancelled."));
-    return;
-  }
-  const updatedConfig = {
-    ...existingConfig,
-    name: response.name,
-    tagline: response.tagline,
-    theme: {
-      ...existingConfig.theme,
-      preset: response.preset,
-      defaultMode: response.defaultMode
-    },
-    socials: response.githubSocial ? [{ type: "github", url: response.githubSocial }] : existingConfig.socials
-  };
-  if (response.sourceType === "github") {
-    updatedConfig.source = {
-      type: "github",
-      repo: response.githubRepo,
-      branch: response.githubBranch,
-      docsDir: response.githubDocsDir
-    };
-  } else if (response.sourceType === "local") {
-    delete updatedConfig.source;
-  }
-  const dir = import_path6.default.dirname(configPath);
-  if (!import_fs6.default.existsSync(dir)) {
-    import_fs6.default.mkdirSync(dir, { recursive: true });
-  }
-  import_fs6.default.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2), "utf-8");
-  console.log(import_chalk5.default.bold.green(`
-\u2714 Configuration successfully saved to: ${configPath}
-`));
-}
-
-// package.json
-var package_default = {
-  name: "docmedown",
-  version: "0.1.0",
-  description: "The simplest MarkDown documenter yet. CLI & Web Script React SPA documentation engine.",
-  main: "./dist/docmedown.cjs",
-  module: "./dist/docmedown.mjs",
-  types: "./dist/types/runtime/index.d.ts",
-  exports: {
-    ".": {
-      types: "./dist/types/runtime/index.d.ts",
-      import: "./dist/docmedown.mjs",
-      require: "./dist/docmedown.cjs"
-    },
-    "./iife": "./dist/docmedown.iife.js"
-  },
-  unpkg: "./dist/docmedown.iife.js",
-  jsdelivr: "./dist/docmedown.iife.js",
-  bin: {
-    docmedown: "bin/docmedown.js",
-    dmd: "bin/docmedown.js"
-  },
-  files: [
-    "dist",
-    "bin",
-    "templates",
-    "README.md",
-    "LICENSE"
-  ],
-  scripts: {
-    "dev:runtime": "vite build --watch",
-    "build:runtime": "vite build",
-    "build:cli": "tsup",
-    typecheck: "tsc --noEmit",
-    "build:types": "tsc -p tsconfig.runtime.json",
-    build: "npm run build:runtime && npm run build:cli && npm run build:types",
-    docmedown: "node ./bin/docmedown.js",
-    dmd: "node ./bin/docmedown.js",
-    "init:docs": "node ./bin/docmedown.js init",
-    serve: "node ./bin/docmedown.js serve ./docs",
-    dev: "node ./bin/docmedown.js serve ./docs",
-    "build:docs": "node ./bin/docmedown.js build ./docs",
-    "build:docs:watch": "node ./bin/docmedown.js build ./docs --watch",
-    "build:offline": "node ./bin/docmedown.js build ./docs",
-    "config:docs": "node ./bin/docmedown.js config ./docs/docs.json",
-    test: "npx tsx --test tests/parser.test.ts tests/scanner.test.ts tests/runtime-integration.test.ts tests/package-smoke.test.ts",
-    "test:release": "npm run typecheck && npm run test && npm run build && npm run build:docs && npm pack --dry-run",
-    prepublishOnly: "npm run test:release"
-  },
-  keywords: [
-    "markdown",
-    "documentation",
-    "docs",
-    "docusaurus",
-    "docsify",
-    "react",
-    "spa",
-    "cli",
-    "offline-docs",
-    "github-docs"
-  ],
-  author: "Gabriel M. Silva",
-  license: "MIT",
-  engines: {
-    node: ">=20.19.0"
-  },
-  repository: {
-    type: "git",
-    url: "git+https://github.com/gabrielmsilva00/docmedown.git"
-  },
-  bugs: {
-    url: "https://github.com/gabrielmsilva00/docmedown/issues"
-  },
-  homepage: "https://github.com/gabrielmsilva00/docmedown#readme",
-  packageManager: "npm@11.16.0",
-  overrides: {
-    tsup: {
-      esbuild: "0.28.2"
-    }
-  },
-  dependencies: {
-    chalk: "^4.1.2",
-    chokidar: "^3.6.0",
-    commander: "^12.1.0",
-    "gray-matter": "^4.0.3",
-    "mime-types": "^2.1.35",
-    open: "^10.1.0",
-    prompts: "^2.4.2",
-    ws: "^8.18.0"
-  },
-  devDependencies: {
-    "@types/node": "^22.5.0",
-    "@types/prismjs": "^1.26.6",
-    "@types/prompts": "^2.4.9",
-    "@types/react": "^18.3.5",
-    "@types/react-dom": "^18.3.0",
-    "@types/ws": "^8.5.12",
-    "@vitejs/plugin-react": "^6.1.0",
-    katex: "^0.16.11",
-    marked: "^14.1.1",
-    minisearch: "^7.1.0",
-    prismjs: "^1.29.0",
-    react: "^18.3.1",
-    "react-dom": "^18.3.1",
-    tsup: "^8.2.4",
-    tsx: "^4.19.0",
-    typescript: "^5.5.4",
-    vite: "^8.2.2",
-    "vite-plugin-css-injected-by-js": "^5.0.2"
-  }
-};
-
 // src/cli/index.ts
 var program = new import_commander.Command();
 program.name("docmedown").description("DocMeDown - The simplest MarkDown documenter yet. CLI & Web Script React SPA.").version(package_default.version);
 program.argument("[dir]", "Documentation directory to initialize or serve", "./docs").option("-p, --port <number>", "Port for local dev server", "3000").option("--no-open", "Do not automatically open the browser").action(async (dir, options) => {
-  const targetDir = import_path7.default.resolve(process.cwd(), dir);
-  const hasIndex = import_fs7.default.existsSync(import_path7.default.join(targetDir, "index.html"));
-  const hasDocs = import_fs7.default.existsSync(import_path7.default.join(targetDir, "README.md")) || import_fs7.default.existsSync(import_path7.default.join(targetDir, "docs.json"));
+  const targetDir = import_node_path7.default.resolve(process.cwd(), dir);
+  const hasIndex = import_node_fs7.default.existsSync(import_node_path7.default.join(targetDir, "index.html"));
+  const hasDocs = import_node_fs7.default.existsSync(import_node_path7.default.join(targetDir, "README.md")) || import_node_fs7.default.existsSync(import_node_path7.default.join(targetDir, "docs.json"));
   if (!hasIndex && !hasDocs) {
     await initCommand(dir, { start: options.open });
   } else {