@docubook/flame 1.4.4 → 1.5.1

package/.docu/lib/chunk-PTRZ2S2C.js

@@ -0,0 +1,298 @@
+import {
+  loadDocuConfig
+} from "./chunk-J5NMYSBJ.js";
+
+// package.json
+var package_default = {
+  name: "@docubook/flame",
+  version: "1.5.1",
+  description: "A blazing-fast React + MDX framework powered by Bun, built for modern documentation experiences.",
+  type: "module",
+  bin: {
+    flame: "./bin/cli.js"
+  },
+  files: [
+    "bin",
+    "template",
+    "docu.schema.json",
+    ".docu",
+    "!.docu/__tests__",
+    "!.docu/dist",
+    "!.docu/build-cache.json",
+    "README.md",
+    "LICENSE"
+  ],
+  publishConfig: {
+    registry: "https://registry.npmjs.org/",
+    access: "public"
+  },
+  engines: {
+    node: ">=20.11",
+    bun: ">=1.1.0"
+  },
+  scripts: {
+    dev: "bun .docu/node/server.ts",
+    build: "NODE_ENV=production bun .docu/node/build.ts",
+    clean: "bun .docu/node/clean.ts",
+    preview: "bun .docu/node/preview.ts",
+    deploy: "bun .docu/node/deploy.ts",
+    "compile:lib": "node bin/compile-lib.mjs",
+    test: "vitest run",
+    lint: "eslint .",
+    prepublishOnly: "bun .docu/node/clean.ts && eslint . && vitest run && node bin/compile-lib.mjs"
+  },
+  keywords: [
+    "docubook",
+    "documentation",
+    "static-site",
+    "daisyui",
+    "bun",
+    "docs framework",
+    "react",
+    "react-dom"
+  ],
+  homepage: "https://github.com/DocuBook/docubook/tree/main/packages/flame",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/DocuBook/docubook.git",
+    directory: "packages/flame"
+  },
+  author: "wildan.nrs",
+  "author-url": "https://wildan.dev",
+  license: "MIT",
+  dependencies: {
+    "@docubook/core": "workspace:^",
+    "@docubook/mdx-content": "workspace:^",
+    "@docubook/runt": "workspace:^",
+    "@docubook/themes-colors": "workspace:^",
+    "@docubook/ui-react": "workspace:^",
+    "@tailwindcss/cli": "4.3.0",
+    "@tailwindcss/typography": "0.5.16",
+    "bun-plugin-tailwind": "^0.1.2",
+    daisyui: "^5.5.19",
+    esbuild: "^0.28.1",
+    "lucide-react": "^1.14.0",
+    react: "^19.2.7",
+    "react-dom": "^19.2.7",
+    unified: "^11.0.0"
+  },
+  peerDependencies: {
+    "@sentry/bun": "^10.0.0"
+  },
+  peerDependenciesMeta: {
+    "@sentry/bun": {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "bun-types": "^1.3.0",
+    eslint: "^10.3.0",
+    "eslint-plugin-perfectionist": "^5.9.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    tailwindcss: "^4.3.0",
+    typescript: "^5.9.3",
+    "typescript-eslint": "^8.59.2"
+  }
+};
+
+// .docu/node/logger.ts
+var docuConfig = loadDocuConfig();
+var isCI = !!(process.env.CI || process.env.NO_COLOR || !process.stdout.isTTY);
+var LOG_FORMAT = process.env.LOG_FORMAT || "pretty";
+var isJSON = LOG_FORMAT === "json";
+var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+var currentLevel = LEVELS[process.env.LOG_LEVEL || "info"] ?? LEVELS.info;
+function shouldLog(level) {
+  return LEVELS[level] >= currentLevel;
+}
+function jsonLog(level, msg, meta) {
+  if (!shouldLog(level)) return;
+  const entry = { ts: (/* @__PURE__ */ new Date()).toISOString(), ...meta, level, msg };
+  const out = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
+  out(JSON.stringify(entry));
+}
+function guard(level, msg, meta) {
+  if (isJSON) {
+    jsonLog(level, msg, meta);
+    return true;
+  }
+  return !shouldLog(level);
+}
+var c = isCI || isJSON ? {
+  reset: "",
+  bold: "",
+  dim: "",
+  green: "",
+  cyan: "",
+  magenta: "",
+  yellow: "",
+  red: "",
+  white: "",
+  gray: ""
+} : {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var Spinner = class {
+  frame = 0;
+  message = "";
+  timer = null;
+  info(finalMsg) {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (isCI) {
+      console.log(`\u2139 ${finalMsg}`);
+    } else {
+      process.stdout.write(`\r\x1B[K${c.cyan}\u2139${c.reset} ${finalMsg}
+`);
+      process.stdout.write("\x1B[?25h");
+    }
+  }
+  start(msg) {
+    this.message = msg;
+    if (isCI) {
+      console.log(`\u2026 ${msg}`);
+      return;
+    }
+    this.frame = 0;
+    process.stdout.write("\x1B[?25l");
+    this.render();
+    this.timer = setInterval(() => this.render(), 80);
+  }
+  stop(finalMsg) {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (isCI) {
+      console.log(`\u2713 ${finalMsg}`);
+      return;
+    }
+    process.stdout.write(`\r\x1B[K${c.green}\u2713${c.reset} ${finalMsg}
+`);
+    process.stdout.write("\x1B[?25h");
+  }
+  render() {
+    const f = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length];
+    process.stdout.write(`\r${c.cyan}${f}${c.reset} ${this.message}`);
+    this.frame++;
+  }
+};
+var MAX_ROUTE_LINES = 5;
+var routeLineCount = 0;
+var routeTruncated = false;
+function printRouteTree(routes, prefix = "", isRoot = true) {
+  for (let i = 0; i < routes.length; i++) {
+    if (routeTruncated) return;
+    if (routeLineCount >= MAX_ROUTE_LINES) {
+      routeTruncated = true;
+      process.stdout.write(`${prefix}${c.dim}...${c.reset}
+`);
+      return;
+    }
+    const route = routes[i];
+    const last = i === routes.length - 1;
+    const connector = isRoot ? "" : last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const childPrefix = isRoot ? "" : last ? "    " : "\u2502   ";
+    const path = route.noLink ? `${c.dim}${route.href}${c.reset}` : `${c.white}${route.href}${c.reset}`;
+    const label = route.noLink ? `${c.gray}(group)${c.reset}` : "";
+    process.stdout.write(`${prefix}${connector}${path} ${label}
+`);
+    routeLineCount++;
+    if (route.items?.length) {
+      printRouteTree(route.items, prefix + childPrefix, false);
+    }
+  }
+}
+var logger = {
+  spinner: new Spinner(),
+  buildStart() {
+    if (guard("info", "build_start", { package: "@docubook/flame", version: package_default.version })) return;
+    console.log(
+      `
+${c.bold}${c.cyan}  \u{1F525} DocuBook Flame${c.reset} ${c.dim}v${package_default.version}${c.reset}
+`
+    );
+  },
+  bundleStart() {
+    if (guard("info", "bundle_start")) return;
+    this.spinner.start("Building client bundle...");
+  },
+  bundleDone(ms) {
+    if (guard("info", "bundle_done", { duration_ms: ms })) return;
+    this.spinner.stop(`Client bundle compiled ${c.dim}(${ms}ms)${c.reset}`);
+  },
+  indexStart() {
+    if (guard("info", "index_start")) return;
+    this.spinner.start("Generating search index...");
+  },
+  indexDone(records, ms) {
+    if (guard("info", "index_done", { records, duration_ms: ms })) return;
+    this.spinner.stop(`Search index generated ${c.dim}(${records} records, ${ms}ms)${c.reset}`);
+  },
+  routes() {
+    if (guard("debug", "routes")) return;
+    const routes = docuConfig.routes;
+    if (!routes?.length) return;
+    console.log(`
+${c.bold}  Routes${c.reset} ${c.dim}(${countRoutes(routes)} pages)${c.reset}
+`);
+    routeLineCount = 0;
+    routeTruncated = false;
+    printRouteTree(routes, "  ");
+  },
+  ready(port, hmr = false) {
+    if (guard("info", "server_ready", { port, hmr })) return;
+    console.log(
+      `
+${c.green}${c.bold}  \u2713 Ready${c.reset} in ${c.bold}http://localhost:${port}/docs/${c.reset}`
+    );
+    if (hmr) console.log(`${c.dim}  HMR enabled \u2014 watching docs/ for changes${c.reset}`);
+    console.log("");
+  },
+  request(method, pathname, status, duration_ms) {
+    if (guard("info", "http_request", { method, path: pathname, status, duration_ms })) return;
+    const color = status >= 500 ? c.red : status >= 400 ? c.gray : c.green;
+    const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    const dur = duration_ms != null ? ` ${c.dim}${duration_ms}ms${c.reset}` : "";
+    console.log(
+      `${c.dim}  ${ts}${c.reset} ${method} ${pathname} ${color}${status}${c.reset}${dur}`
+    );
+  },
+  debug(msg, meta) {
+    if (guard("debug", msg, meta)) return;
+    console.log(`${c.gray}  [debug] ${msg}${c.reset}`);
+  },
+  warn(msg, meta) {
+    if (guard("warn", msg, meta)) return;
+    console.warn(`${c.yellow}  \u26A0 ${msg}${c.reset}`);
+  },
+  error(msg, meta) {
+    if (guard("error", msg, meta)) return;
+    console.error(`${c.red}  \u2716 ${msg}${c.reset}`);
+  }
+};
+function countRoutes(routes) {
+  let count = 0;
+  for (const r of routes) {
+    if (!r.noLink) count++;
+    if (r.items) count += countRoutes(r.items);
+  }
+  return count;
+}
+
+export {
+  logger
+};

package/.docu/lib/chunk-RE4NGTMT.js

@@ -0,0 +1,185 @@
+// .docu/node/security.ts
+import { resolve } from "node:path";
+import { realpathSync } from "node:fs";
+var SECURITY_HEADERS = {
+  "Strict-Transport-Security": "max-age=63072000; includeSubDomains; preload",
+  "X-Frame-Options": "DENY",
+  "X-Content-Type-Options": "nosniff",
+  "Referrer-Policy": "strict-origin-when-cross-origin",
+  "Permissions-Policy": "camera=(), microphone=(), geolocation=()"
+};
+function generateNonce() {
+  return crypto.randomUUID();
+}
+function cspHeader(nonce, allowEval = false) {
+  const scriptSrc = allowEval ? `script-src 'self' 'nonce-${nonce}' 'unsafe-eval'` : `script-src 'self' 'nonce-${nonce}'`;
+  return [
+    "default-src 'self'",
+    scriptSrc,
+    "style-src 'self' 'unsafe-inline'",
+    "img-src 'self' https: data:",
+    "font-src 'self' data:",
+    "connect-src 'self' https:",
+    "frame-src https://www.youtube-nocookie.com",
+    "frame-ancestors 'none'"
+  ].join("; ");
+}
+function isPathSafe(pathname, baseDir) {
+  const decoded = decodeURIComponent(pathname);
+  const resolved = resolve(baseDir, decoded.slice(1));
+  const baseDirSlash = baseDir.endsWith("/") ? baseDir : baseDir + "/";
+  if (!(resolved === baseDir || resolved.startsWith(baseDirSlash))) {
+    return false;
+  }
+  if (resolved === baseDir) return true;
+  try {
+    const real = realpathSync(resolved);
+    const realBase = realpathSync(baseDir);
+    const realBaseDirSlash = realBase.endsWith("/") ? realBase : realBase + "/";
+    return real.startsWith(realBaseDirSlash);
+  } catch (err) {
+    const nodeErr = err;
+    if (nodeErr.code === "ENOENT") {
+      return true;
+    }
+    console.error(
+      `[security] isPathSafe error for pathname="${pathname}": ${nodeErr.message} (code=${nodeErr.code})`
+    );
+    return false;
+  }
+}
+function isSlugSafe(slug, docsDir) {
+  const resolved = resolve(docsDir, slug);
+  const docsDirSlash = docsDir.endsWith("/") ? docsDir : docsDir + "/";
+  if (!(resolved === docsDir || resolved.startsWith(docsDirSlash))) {
+    return false;
+  }
+  if (resolved === docsDir) return true;
+  try {
+    const real = realpathSync(resolved);
+    const realDocsDir = realpathSync(docsDir);
+    const realDocsDirSlash = realDocsDir.endsWith("/") ? realDocsDir : realDocsDir + "/";
+    return real.startsWith(realDocsDirSlash);
+  } catch (err) {
+    const nodeErr = err;
+    if (nodeErr.code === "ENOENT") {
+      return true;
+    }
+    console.error(
+      `[security] isSlugSafe error for slug="${slug}": ${nodeErr.message} (code=${nodeErr.code})`
+    );
+    return false;
+  }
+}
+function normalizeImporterPath(importer) {
+  return resolve(importer).replace(/\\/g, "/");
+}
+function injectNonce(html, nonce) {
+  return html.replace(/<script\b(?![^>]*\bsrc\s*=)([^>]*)>/gi, (match) => {
+    if (/nonce\s*=/i.test(match)) {
+      return match.replace(/nonce="[^"]*"/i, `nonce="${nonce}"`);
+    }
+    return match.replace(/>$/, ` nonce="${nonce}">`);
+  });
+}
+function wrapPluginResponse(pluginResponse, allowEval = false) {
+  const securedHeaders = new Headers(pluginResponse.headers);
+  for (const [key, value] of Object.entries(SECURITY_HEADERS)) {
+    if (!securedHeaders.has(key)) {
+      securedHeaders.set(key, value);
+    }
+  }
+  const contentType = securedHeaders.get("Content-Type") || "";
+  if (contentType.includes("text/html") && !securedHeaders.has("Content-Security-Policy")) {
+    securedHeaders.set("Content-Security-Policy", cspHeader(generateNonce(), allowEval));
+  }
+  return new Response(pluginResponse.body, {
+    status: pluginResponse.status,
+    statusText: pluginResponse.statusText,
+    headers: securedHeaders
+  });
+}
+function htmlResponse(html, nonce, status = 200, allowEval = false) {
+  return new Response(html, {
+    status,
+    headers: {
+      "Content-Type": "text/html",
+      ...SECURITY_HEADERS,
+      "Content-Security-Policy": cspHeader(nonce, allowEval)
+    }
+  });
+}
+
+// .docu/node/utils.ts
+import { cn, parseDate, formatDate, formatDate2 } from "@docubook/core";
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+async function scanMdxFiles(dir, baseDir = "") {
+  const files = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relativePath = baseDir ? `${baseDir}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      if (entry.name === "assets" || entry.name.startsWith(".")) continue;
+      files.push(...await scanMdxFiles(fullPath, relativePath));
+    } else if (entry.name.endsWith(".mdx") || entry.name.endsWith(".md")) {
+      if (entry.name === "index.mdx" && !baseDir) continue;
+      const stats = await stat(fullPath);
+      let path = relativePath.replace(/\.(mdx|md)$/, "");
+      if (/\/index$/.test(path)) {
+        path = path.replace(/\/index$/, "");
+      }
+      files.push({ path, absPath: fullPath, mtime: stats.mtimeMs });
+    }
+  }
+  return files;
+}
+function isExternalUrl(url) {
+  return /^(https?:\/\/|\/\/)/.test(url);
+}
+function docsHtmlHref(path) {
+  return `${path}.html`;
+}
+function stripDocsHtmlSuffix(pathname) {
+  if (pathname === "/docs.html") return "/docs";
+  if (pathname.startsWith("/docs/") && pathname.endsWith(".html"))
+    return pathname.slice(0, -".html".length);
+  return pathname;
+}
+var MIME_TYPES = {
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript",
+  json: "application/json",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  svg: "image/svg+xml",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2"
+};
+function getContentType(pathname) {
+  const ext = pathname.split(".").pop()?.toLowerCase();
+  return MIME_TYPES[ext || ""] || "application/octet-stream";
+}
+
+export {
+  SECURITY_HEADERS,
+  generateNonce,
+  cspHeader,
+  isPathSafe,
+  isSlugSafe,
+  normalizeImporterPath,
+  injectNonce,
+  wrapPluginResponse,
+  htmlResponse,
+  scanMdxFiles,
+  isExternalUrl,
+  docsHtmlHref,
+  stripDocsHtmlSuffix,
+  getContentType,
+  cn,
+  formatDate2
+};

package/.docu/lib/chunk-TE52TIEW.js

@@ -0,0 +1,92 @@
+import {
+  SECURITY_HEADERS,
+  cspHeader,
+  generateNonce,
+  getContentType,
+  injectNonce
+} from "./chunk-RE4NGTMT.js";
+import {
+  logger
+} from "./chunk-PTRZ2S2C.js";
+import {
+  DIST_DIR
+} from "./chunk-J5NMYSBJ.js";
+
+// .docu/node/preview.impl.ts
+import { existsSync, statSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+function resolveFile(pathname) {
+  const path = pathname.slice(1);
+  const isWithinDist = (p) => p === DIST_DIR || p.startsWith(DIST_DIR + "/");
+  if (!path.includes(".")) {
+    const withIndex = resolve(DIST_DIR, path, "index.html");
+    if (isWithinDist(withIndex) && existsSync(withIndex)) return withIndex;
+    const withHtml = resolve(DIST_DIR, path + ".html");
+    if (isWithinDist(withHtml) && existsSync(withHtml)) return withHtml;
+  }
+  const exact = resolve(DIST_DIR, path);
+  if (!isWithinDist(exact)) return null;
+  try {
+    if (statSync(exact).isFile()) return exact;
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  return null;
+}
+async function runPreview(adapter) {
+  const PORT = parseInt(process.env.PORT || "4173", 10);
+  logger.buildStart();
+  if (!existsSync(DIST_DIR)) {
+    logger.spinner.start("Checking build output...");
+    logger.spinner.info("dist not found. Run \x1B[1mflame build\x1B[0m first.");
+    process.exit(0);
+  }
+  const notFoundPath = resolve(DIST_DIR, "404.html");
+  const handle = await adapter.serve(
+    async (req) => {
+      const url = new URL(req.url);
+      const pathname = decodeURIComponent(url.pathname);
+      const filePath = resolveFile(pathname);
+      if (filePath) {
+        const contentType = getContentType(filePath);
+        if (contentType === "text/html") {
+          const nonce = generateNonce();
+          const html = await readFile(filePath, "utf-8");
+          const modified = injectNonce(html, nonce);
+          return new Response(modified, {
+            headers: {
+              "Content-Type": "text/html",
+              ...SECURITY_HEADERS,
+              "Content-Security-Policy": cspHeader(nonce, true)
+            }
+          });
+        }
+        return new Response(readFileSync(filePath), {
+          headers: { "Content-Type": contentType }
+        });
+      }
+      if (existsSync(notFoundPath)) {
+        const nonce = generateNonce();
+        const html = await readFile(notFoundPath, "utf-8");
+        const modified = injectNonce(html, nonce);
+        return new Response(modified, {
+          status: 404,
+          headers: {
+            "Content-Type": "text/html",
+            ...SECURITY_HEADERS,
+            "Content-Security-Policy": cspHeader(nonce, true)
+          }
+        });
+      }
+      return new Response("404 - Not Found", { status: 404 });
+    },
+    { port: PORT }
+  );
+  logger.ready(handle.port);
+  return handle;
+}
+
+export {
+  runPreview
+};

package/.docu/lib/clean.js

@@ -0,0 +1,32 @@
+import {
+  logger
+} from "./chunk-PTRZ2S2C.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/clean.ts
+import { rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+var DIST = ".docu/dist";
+var CACHE = ".docu/build-cache.json";
+async function clean() {
+  logger.buildStart();
+  logger.spinner.start("Cleaning build artifacts...");
+  let removed = 0;
+  if (existsSync(DIST)) {
+    await rm(DIST, { recursive: true, force: true });
+    removed++;
+  }
+  if (existsSync(CACHE)) {
+    await rm(CACHE, { force: true });
+    removed++;
+  }
+  if (removed === 0) {
+    logger.spinner.info("Nothing to clean");
+  } else {
+    logger.spinner.stop(`Cleaned ${removed} item(s)`);
+  }
+}
+clean().catch((err) => {
+  console.error("Clean failed:", err);
+  process.exit(1);
+});

package/.docu/lib/deploy.deno.js

@@ -0,0 +1,13 @@
+import {
+  runDeploy
+} from "./chunk-IR5TVJOV.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/deploy.deno.ts
+try {
+  await runDeploy();
+} catch (err) {
+  console.error("Deploy failed:", err);
+  process.exit(1);
+}
+process.exit(0);

package/.docu/lib/deploy.node.js

@@ -0,0 +1,10 @@
+import {
+  runDeploy
+} from "./chunk-IR5TVJOV.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/deploy.node.ts
+runDeploy().catch((err) => {
+  console.error("Deploy failed:", err);
+  process.exit(1);
+});

package/.docu/lib/preview.deno.js

@@ -0,0 +1,10 @@
+import {
+  runPreview
+} from "./chunk-TE52TIEW.js";
+import "./chunk-RE4NGTMT.js";
+import "./chunk-PTRZ2S2C.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/preview.deno.ts
+import { denoAdapter } from "@docubook/runt";
+await runPreview(denoAdapter);

package/.docu/lib/preview.node.js

@@ -0,0 +1,10 @@
+import {
+  runPreview
+} from "./chunk-TE52TIEW.js";
+import "./chunk-RE4NGTMT.js";
+import "./chunk-PTRZ2S2C.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/preview.node.ts
+import { nodeAdapter } from "@docubook/runt";
+await runPreview(nodeAdapter);

package/.docu/lib/server.deno.js

@@ -0,0 +1,11 @@
+import {
+  runServer
+} from "./chunk-7ZEUL6PR.js";
+import "./chunk-AI7QAMMZ.js";
+import "./chunk-RE4NGTMT.js";
+import "./chunk-PTRZ2S2C.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/server.deno.ts
+import { denoAdapter } from "@docubook/runt";
+await runServer(denoAdapter);

package/.docu/lib/server.node.js

@@ -0,0 +1,11 @@
+import {
+  runServer
+} from "./chunk-7ZEUL6PR.js";
+import "./chunk-AI7QAMMZ.js";
+import "./chunk-RE4NGTMT.js";
+import "./chunk-PTRZ2S2C.js";
+import "./chunk-J5NMYSBJ.js";
+
+// .docu/node/server.node.ts
+import { nodeAdapter } from "@docubook/runt";
+await runServer(nodeAdapter);

package/.docu/node/build.deno.ts

@@ -0,0 +1,7 @@
+import { runBuildCli } from "./build.impl";
+
+await runBuildCli();
+// Deno resolves react-dom/server to server.browser.js (its `deno` export
+// condition), which opens a module-scope MessageChannel that keeps the event
+// loop alive after the build completes — force a clean exit.
+process.exit(0);