docs-i18n 0.1.0

package/dist/rescan-VB2PILB2.js

@@ -0,0 +1,74 @@
+import {
+  init_parser,
+  parseMdx
+} from "./chunk-SUIDX6IZ.js";
+import {
+  TranslationCache
+} from "./chunk-XEOYZUHS.js";
+import {
+  flattenSources
+} from "./chunk-3YNFMSJH.js";
+import "./chunk-AKLW2MUS.js";
+
+// src/commands/rescan.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+init_parser();
+function walkFiles(dir, patterns) {
+  const results = [];
+  if (!existsSync(dir)) return results;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkFiles(fullPath, patterns));
+    } else if (patterns.some((p) => entry.name.endsWith(p.replace("**/*", "")))) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function rescan(config, opts) {
+  const cacheDir = resolve(config.cacheDir ?? ".cache");
+  const cache = new TranslationCache(cacheDir);
+  const sources = flattenSources(config);
+  const extensions = (config.include ?? ["**/*.mdx", "**/*.md"]).map(
+    (p) => p.replace("**/*", "")
+  );
+  const t0 = Date.now();
+  for (const source of sources) {
+    if (opts.project && source.project !== opts.project) continue;
+    if (opts.version && source.version !== opts.version) continue;
+    const enDir = resolve(source.sourcePath);
+    if (!existsSync(enDir)) {
+      console.log(`\u26A0 ${source.versionKey}: source dir not found, skipping`);
+      continue;
+    }
+    const files = walkFiles(enDir, extensions);
+    cache.clearSources("", source.versionKey);
+    let nodeCount = 0;
+    for (const file of files) {
+      const relPath = file.slice(enDir.length + 1);
+      const content = readFileSync(file, "utf8");
+      const nodes = parseMdx(content);
+      for (const node of nodes) {
+        if (node.needsTranslation && node.md5) {
+          const line = content.substring(0, node.startOffset).split("\n").length;
+          cache.setSource(node.md5, node.rawText, node.type);
+          cache.updateSource("", node.md5, relPath, line, source.versionKey);
+          nodeCount++;
+        }
+      }
+    }
+    console.log(`\u2705 ${source.versionKey}: ${files.length} files, ${nodeCount} nodes`);
+  }
+  const orphanT = cache.db.prepare("DELETE FROM translations WHERE key NOT IN (SELECT DISTINCT key FROM source_files)").run();
+  if (orphanT.changes > 0) console.log(`\u{1F5D1}\uFE0F  Deleted ${orphanT.changes} orphan translations`);
+  const orphanS = cache.db.prepare("DELETE FROM sources WHERE key NOT IN (SELECT DISTINCT key FROM source_files)").run();
+  if (orphanS.changes > 0) console.log(`\u{1F5D1}\uFE0F  Deleted ${orphanS.changes} orphan sources`);
+  console.log(`
+Done in ${((Date.now() - t0) / 1e3).toFixed(1)}s`);
+  cache.db.close();
+}
+export {
+  rescan
+};

package/dist/serve.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Runtime translation middleware for Cloudflare Workers + D1.
+ * Used by projects that do SSR (e.g., TanStack).
+ *
+ * @example
+ * ```ts
+ * import { createTranslator } from 'docs-i18n/serve';
+ *
+ * const translator = createTranslator();
+ * const translated = await translator.translate(enMarkdown, 'zh-hans', env.DB);
+ * ```
+ */
+interface D1Database {
+    prepare(sql: string): {
+        bind(...args: unknown[]): {
+            all(): Promise<{
+                results: Array<{
+                    key: string;
+                    value: string;
+                }>;
+            }>;
+        };
+    };
+}
+/**
+ * Create a runtime translator that queries D1 for cached translations.
+ */
+declare function createTranslator(): {
+    /**
+     * Translate markdown content using D1 cache.
+     * Parses into nodes, batch-queries translations, assembles result.
+     * Untranslated nodes fall back to original English.
+     */
+    translate(markdown: string, lang: string, db: D1Database): Promise<string>;
+};
+
+export { createTranslator };

package/dist/serve.js

@@ -0,0 +1,38 @@
+import {
+  parseMdx
+} from "./chunk-7HWWVRNS.js";
+
+// src/serve.ts
+function createTranslator() {
+  return {
+    /**
+     * Translate markdown content using D1 cache.
+     * Parses into nodes, batch-queries translations, assembles result.
+     * Untranslated nodes fall back to original English.
+     */
+    async translate(markdown, lang, db) {
+      if (lang === "en") return markdown;
+      const nodes = parseMdx(markdown);
+      const translatableNodes = nodes.filter((n) => n.md5);
+      const keys = translatableNodes.map((n) => n.md5);
+      if (keys.length === 0) return markdown;
+      const placeholders = keys.map(() => "?").join(",");
+      const { results } = await db.prepare(
+        `SELECT key, value FROM translations WHERE lang = ? AND key IN (${placeholders})`
+      ).bind(lang, ...keys).all();
+      const cache = /* @__PURE__ */ new Map();
+      for (const row of results) {
+        cache.set(row.key, row.value);
+      }
+      return nodes.map((n) => {
+        if (n.md5 && cache.has(n.md5)) {
+          return cache.get(n.md5);
+        }
+        return n.rawText;
+      }).join("\n\n");
+    }
+  };
+}
+export {
+  createTranslator
+};

package/dist/server-ER56DGPR.js

@@ -0,0 +1,548 @@
+import {
+  init_parser,
+  parseMdx
+} from "./chunk-SUIDX6IZ.js";
+import {
+  TranslationCache
+} from "./chunk-XEOYZUHS.js";
+import {
+  flattenSources
+} from "./chunk-3YNFMSJH.js";
+import "./chunk-AKLW2MUS.js";
+
+// src/admin/server/index.ts
+import { createServer } from "http";
+import { resolve as resolve2 } from "path";
+import { Hono as Hono4 } from "hono";
+
+// src/admin/server/services/status.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+init_parser();
+var _config;
+var _cache = null;
+function initStatus(config) {
+  _config = config;
+  _cache = null;
+}
+function getVersions() {
+  return flattenSources(_config).map((s) => s.versionKey);
+}
+function getLangs() {
+  return _config.languages;
+}
+function getCache() {
+  if (!_cache) {
+    _cache = new TranslationCache(resolve(_config.cacheDir ?? ".cache"));
+  }
+  return _cache;
+}
+function getSourcePath(versionKey) {
+  const source = flattenSources(_config).find((s) => s.versionKey === versionKey);
+  return source ? resolve(source.sourcePath) : null;
+}
+function walkFiles(dir) {
+  const results = [];
+  if (!existsSync(dir)) return results;
+  const exts = (_config.include ?? ["**/*.mdx", "**/*.md"]).map((p) => p.replace("**/*", ""));
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) results.push(...walkFiles(fullPath));
+    else if (exts.some((ext) => entry.name.endsWith(ext))) results.push(fullPath);
+  }
+  return results;
+}
+function ensureScanned(version) {
+  const cache = getCache();
+  const enDir = getSourcePath(version);
+  if (!enDir || !existsSync(enDir)) return;
+  const files = walkFiles(enDir);
+  const currentCount = cache.sourceCount(version);
+  if (currentCount >= files.length) return;
+  cache.clearSources("", version);
+  for (const file of files) {
+    const relPath = file.slice(enDir.length + 1);
+    const content = readFileSync(file, "utf8");
+    const nodes = parseMdx(content);
+    for (const node of nodes) {
+      if (node.needsTranslation && node.md5) {
+        const line = content.substring(0, node.startOffset).split("\n").length;
+        cache.setSource(node.md5, node.rawText, node.type);
+        cache.updateSource("", node.md5, relPath, line, version);
+      }
+    }
+  }
+}
+function rescan(version) {
+  const cache = getCache();
+  const enDir = getSourcePath(version);
+  if (!enDir || !existsSync(enDir)) return 0;
+  const files = walkFiles(enDir);
+  cache.clearSources("", version);
+  for (const file of files) {
+    const relPath = file.slice(enDir.length + 1);
+    const content = readFileSync(file, "utf8");
+    const nodes = parseMdx(content);
+    for (const node of nodes) {
+      if (node.needsTranslation && node.md5) {
+        const line = content.substring(0, node.startOffset).split("\n").length;
+        cache.setSource(node.md5, node.rawText, node.type);
+        cache.updateSource("", node.md5, relPath, line, version);
+      }
+    }
+  }
+  return files.length;
+}
+function getOverview() {
+  const cache = getCache();
+  const versions = getVersions();
+  const langs = getLangs();
+  const result = {};
+  for (const version of versions) {
+    ensureScanned(version);
+    const enDir = getSourcePath(version);
+    const enFileCount = enDir && existsSync(enDir) ? walkFiles(enDir).length : 0;
+    const langStats = {};
+    for (const lang of langs) {
+      const sections = cache.sectionStats(version, lang);
+      let totalFiles = 0, translatedFiles = 0, totalNodes = 0, translatedNodes = 0;
+      const sectionMap = {};
+      for (const s of sections) {
+        sectionMap[s.section] = s;
+        totalFiles += s.totalFiles;
+        translatedFiles += s.translatedFiles;
+        totalNodes += s.totalNodes;
+        translatedNodes += s.translatedNodes;
+      }
+      langStats[lang] = { sections: sectionMap, totalFiles, translatedFiles, totalNodes, translatedNodes };
+    }
+    result[version] = { enFileCount, langs: langStats };
+  }
+  return result;
+}
+function getFileCoverage(version, lang) {
+  ensureScanned(version);
+  return getCache().fileCoverage(version, lang);
+}
+function getFileBlocks(version, lang, file) {
+  const enDir = getSourcePath(version);
+  if (!enDir) return null;
+  const enPath = join(enDir, file);
+  if (!existsSync(enPath)) return null;
+  const cache = getCache();
+  const content = readFileSync(enPath, "utf8");
+  const nodes = parseMdx(content);
+  const blocks = [];
+  let lastEnd = 0;
+  for (const node of nodes) {
+    if (node.startOffset > lastEnd) {
+      const gap = content.substring(lastEnd, node.startOffset);
+      blocks.push({ md5: null, type: "gap", source: gap, translation: null });
+    }
+    if (node.needsTranslation && node.md5) {
+      const translation = lang === "en" ? null : cache.get(lang, node.md5) ?? null;
+      blocks.push({ md5: node.md5, type: node.type, source: node.rawText, translation });
+    } else {
+      blocks.push({ md5: null, type: node.type, source: node.rawText, translation: null });
+    }
+    lastEnd = node.endOffset;
+  }
+  if (lastEnd < content.length) {
+    const tail = content.substring(lastEnd);
+    if (tail.trim()) blocks.push({ md5: null, type: "gap", source: tail, translation: null });
+  }
+  return blocks;
+}
+
+// src/admin/server/routes/jobs.ts
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+
+// src/admin/server/services/job-manager.ts
+import { spawn } from "child_process";
+var PROJECT_ROOT = process.cwd();
+var JobManager = class {
+  jobs = /* @__PURE__ */ new Map();
+  processes = /* @__PURE__ */ new Map();
+  subscribers = /* @__PURE__ */ new Map();
+  nextId = 1;
+  start(opts) {
+    for (const [, job2] of this.jobs) {
+      if (job2.lang === opts.lang && job2.version === opts.version && job2.status === "running") {
+        throw new Error(`Job already running for ${opts.lang}/${opts.version}`);
+      }
+    }
+    const id = `job-${this.nextId++}`;
+    const job = {
+      id,
+      lang: opts.lang,
+      version: opts.version,
+      project: opts.project ?? "",
+      status: "running",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      logLines: [],
+      translatedFiles: 0,
+      totalFiles: 0,
+      toTranslate: 0,
+      errorFiles: 0
+    };
+    this.jobs.set(id, job);
+    const args = [
+      "src/cli.ts",
+      // In dev; in production would be the installed bin
+      "translate",
+      "--lang",
+      opts.lang,
+      "--version",
+      opts.version,
+      "--max",
+      String(opts.max ?? 999),
+      "--concurrency",
+      String(opts.concurrency ?? 3)
+    ];
+    if (opts.project) args.push("--project", opts.project);
+    if (opts.model) args.push("--model", opts.model);
+    if (opts.files?.length) args.push("--files", opts.files.join(","));
+    const proc = spawn("bun", args, {
+      cwd: PROJECT_ROOT,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, NO_TTY: "1", FORCE_COLOR: "0" }
+    });
+    this.processes.set(id, proc);
+    proc.stdout?.on("data", (d) => {
+      for (const line of d.toString().split("\n").filter(Boolean)) {
+        this.addLog(id, line);
+        this.parseProgress(job, line);
+      }
+    });
+    proc.stderr?.on("data", (d) => {
+      for (const line of d.toString().split("\n").filter(Boolean)) {
+        this.addLog(id, line);
+      }
+    });
+    proc.on("exit", (code) => {
+      job.status = code === 0 ? "completed" : "failed";
+      job.exitCode = code;
+      job.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      job.currentFile = void 0;
+      this.addLog(id, `Process exited with code ${code}`);
+      this.processes.delete(id);
+      this.emit(id, { type: "exit", code });
+    });
+    proc.on("error", (err) => {
+      job.status = "failed";
+      job.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.addLog(id, `Process error: ${err.message}`);
+      this.processes.delete(id);
+      this.emit(id, { type: "exit", code: -1 });
+    });
+    return job;
+  }
+  cancel(id) {
+    const proc = this.processes.get(id);
+    const job = this.jobs.get(id);
+    if (!proc || !job) return false;
+    proc.kill("SIGTERM");
+    job.status = "cancelled";
+    job.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.processes.delete(id);
+    this.emit(id, { type: "exit", code: null });
+    return true;
+  }
+  list() {
+    return [...this.jobs.values()].sort(
+      (a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()
+    );
+  }
+  get(id) {
+    return this.jobs.get(id);
+  }
+  remove(id) {
+    const job = this.jobs.get(id);
+    if (!job || job.status === "running") return false;
+    this.jobs.delete(id);
+    this.subscribers.delete(id);
+    return true;
+  }
+  subscribe(id, callback) {
+    if (!this.subscribers.has(id)) this.subscribers.set(id, /* @__PURE__ */ new Set());
+    this.subscribers.get(id)?.add(callback);
+    return () => {
+      this.subscribers.get(id)?.delete(callback);
+    };
+  }
+  addLog(id, line) {
+    const job = this.jobs.get(id);
+    if (!job) return;
+    const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+    const entry = `[${ts}] ${line}`;
+    job.logLines = job.logLines ?? [];
+    job.logLines.push(entry);
+    if (job.logLines.length > 500) job.logLines.shift();
+    this.emit(id, { type: "log", data: entry });
+  }
+  emit(id, event) {
+    this.subscribers.get(id)?.forEach((cb) => cb(event));
+  }
+  parseProgress(job, line) {
+    const cached = line.match(/\+(\d+) cached/);
+    if (cached) job.translatedFiles += Number.parseInt(cached[1], 10);
+    const untranslated = line.match(/(\d+) untranslated keys/);
+    if (untranslated) job.toTranslate = Number.parseInt(untranslated[1], 10);
+    const chunk = line.match(/chunk \d+\/(\d+)/);
+    if (chunk) job.totalFiles = Number.parseInt(chunk[1], 10);
+    if (line.includes("\u23F3")) job.currentFile = line.replace(/^⏳\s*/, "");
+  }
+};
+var jobManager = new JobManager();
+
+// src/admin/server/routes/jobs.ts
+var app = new Hono();
+app.get("/", (c) => {
+  return c.json(
+    jobManager.list().map((j) => ({
+      ...j,
+      logLines: (j.logLines ?? []).slice(-20)
+      // Last 20 lines in list view
+    }))
+  );
+});
+app.post("/", async (c) => {
+  const body = await c.req.json();
+  if (!body.lang || !body.version) {
+    return c.json({ error: "Missing lang or version" }, 400);
+  }
+  try {
+    const job = jobManager.start(body);
+    return c.json(job, 201);
+  } catch (err) {
+    return c.json(
+      { error: err instanceof Error ? err.message : "Unknown error" },
+      409
+    );
+  }
+});
+app.get("/:id", (c) => {
+  const job = jobManager.get(c.req.param("id"));
+  if (!job) return c.json({ error: "Job not found" }, 404);
+  return c.json(job);
+});
+app.delete("/:id", (c) => {
+  const id = c.req.param("id");
+  const job = jobManager.get(id);
+  if (!job) return c.json({ error: "Job not found" }, 404);
+  if (job.status === "running") {
+    jobManager.cancel(id);
+  } else {
+    jobManager.remove(id);
+  }
+  return c.json({ ok: true });
+});
+app.get("/:id/stream", (c) => {
+  const id = c.req.param("id");
+  const job = jobManager.get(id);
+  if (!job) return c.json({ error: "Job not found" }, 404);
+  return streamSSE(c, async (stream) => {
+    await stream.writeSSE({
+      data: JSON.stringify({
+        type: "state",
+        data: { ...job, logLines: (job.logLines ?? []).slice(-50) }
+      }),
+      event: "message"
+    });
+    const unsubscribe = jobManager.subscribe(id, async (event) => {
+      try {
+        await stream.writeSSE({
+          data: JSON.stringify(event),
+          event: "message"
+        });
+      } catch {
+        unsubscribe();
+      }
+    });
+    while (true) {
+      const currentJob = jobManager.get(id);
+      if (!currentJob || currentJob.status !== "running") {
+        await stream.writeSSE({
+          data: JSON.stringify({ type: "done", data: currentJob }),
+          event: "message"
+        });
+        break;
+      }
+      await stream.sleep(1e3);
+    }
+    unsubscribe();
+  });
+});
+var jobs_default = app;
+
+// src/admin/server/routes/models.ts
+import { Hono as Hono2 } from "hono";
+var app2 = new Hono2();
+var cachedResult = null;
+var cacheTime = 0;
+var CACHE_TTL = 5 * 60 * 1e3;
+app2.get("/", async (c) => {
+  const now = Date.now();
+  if (cachedResult && now - cacheTime < CACHE_TTL) {
+    return c.json(cachedResult);
+  }
+  try {
+    const res = await fetch("https://openrouter.ai/api/v1/models");
+    if (!res.ok) {
+      return c.json({ error: `OpenRouter API error: ${res.status}` }, 502);
+    }
+    const { data } = await res.json();
+    cachedResult = formatModels(data);
+    cacheTime = now;
+    return c.json(cachedResult);
+  } catch (err) {
+    return c.json(
+      { error: err instanceof Error ? err.message : "Failed to fetch models" },
+      500
+    );
+  }
+});
+function formatModels(models) {
+  return models.filter((m) => {
+    if (!m.pricing) return false;
+    const pp = Number.parseFloat(m.pricing.prompt);
+    const cp = Number.parseFloat(m.pricing.completion);
+    if (pp < 0 || cp < 0) return false;
+    if (!m.architecture?.modality?.startsWith("text")) return false;
+    if (!m.architecture.output_modalities?.includes("text")) return false;
+    return true;
+  }).map((m) => {
+    const pp = Number.parseFloat(m.pricing.prompt) * 1e6;
+    const cp = Number.parseFloat(m.pricing.completion) * 1e6;
+    return {
+      id: m.id,
+      name: m.name,
+      promptPrice: pp,
+      completionPrice: cp,
+      contextLength: m.context_length,
+      maxOutput: m.top_provider?.max_completion_tokens ?? 0,
+      isFree: pp === 0 && cp === 0,
+      supportsJson: m.supported_parameters?.includes("response_format") || m.supported_parameters?.includes("structured_outputs"),
+      supportsTools: m.supported_parameters?.includes("tools"),
+      provider: m.id.split("/")[0]
+    };
+  }).sort((a, b) => a.promptPrice - b.promptPrice);
+}
+var models_default = app2;
+
+// src/admin/server/routes/status.ts
+import { Hono as Hono3 } from "hono";
+var app3 = new Hono3();
+app3.get("/", (c) => {
+  return c.json({
+    versions: getVersions(),
+    langs: ["en", ...getLangs()],
+    data: getOverview()
+  });
+});
+app3.get("/:version/:lang", (c) => {
+  const { version, lang } = c.req.param();
+  if (lang === "en") {
+    const anyLang = getLangs()[0];
+    const coverage = getFileCoverage(version, anyLang);
+    return c.json(coverage.map((f) => ({ file: f.file, total: f.total, translated: f.total })));
+  }
+  return c.json(getFileCoverage(version, lang));
+});
+app3.get("/:version/:lang/blocks", (c) => {
+  const { version, lang } = c.req.param();
+  const filePath = c.req.query("path");
+  if (!filePath) return c.json({ error: "Missing path query param" }, 400);
+  const blocks = getFileBlocks(version, lang, filePath);
+  if (!blocks) return c.json({ error: "File not found" }, 404);
+  return c.json({ file: filePath, lang, version, blocks });
+});
+app3.delete("/:version/:lang/cache", (c) => {
+  const { lang } = c.req.param();
+  const key = c.req.query("key");
+  if (!key) return c.json({ error: "Missing key query param" }, 400);
+  const cache = getCache();
+  cache.db.prepare("DELETE FROM translations WHERE lang = ? AND key = ?").run(lang, key);
+  return c.json({ deleted: key, lang });
+});
+app3.post("/:version/rescan", (c) => {
+  const { version } = c.req.param();
+  const count = rescan(version);
+  return c.json({ version, files: count });
+});
+var status_default = app3;
+
+// src/admin/server/index.ts
+async function startAdmin(config, port = 3456) {
+  initStatus(config);
+  const app4 = new Hono4();
+  app4.route("/api/status", status_default);
+  app4.route("/api/jobs", jobs_default);
+  app4.route("/api/models", models_default);
+  app4.get("/api/health", (c) => c.json({ ok: true }));
+  app4.get("/api/config", (c) => c.json({ projectRoot: process.cwd() }));
+  app4.post("/api/open-file", async (c) => {
+    const { file } = await c.req.json();
+    if (!file) return c.json({ error: "Missing file" }, 400);
+    const fullPath = resolve2(process.cwd(), file);
+    if (!fullPath.startsWith(process.cwd())) return c.json({ error: "Invalid path" }, 400);
+    const candidates = process.env.EDITOR_CMD ? [process.env.EDITOR_CMD] : ["code", "cursor", "zed"];
+    for (const cmd of candidates) {
+      const which = Bun.spawn(["which", cmd], { stdio: ["ignore", "pipe", "ignore"] });
+      await which.exited;
+      if (which.exitCode === 0) {
+        Bun.spawn([cmd, fullPath], { stdio: ["ignore", "ignore", "ignore"] });
+        return c.json({ opened: fullPath, editor: cmd });
+      }
+    }
+    const fallback = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    Bun.spawn([fallback, fullPath], { stdio: ["ignore", "ignore", "ignore"] });
+    return c.json({ opened: fullPath, editor: fallback });
+  });
+  const adminRoot = resolve2(import.meta.dir, "..");
+  try {
+    const { createServer: createViteServer } = await import("./node-NUDVMOF2.js");
+    const vite = await createViteServer({
+      root: adminRoot,
+      server: { middlewareMode: true },
+      appType: "spa"
+    });
+    const server = createServer(async (req, res) => {
+      const url = req.url ?? "/";
+      if (url.startsWith("/api")) {
+        const headers = new Headers();
+        for (const [k, v] of Object.entries(req.headers)) {
+          if (v) headers.set(k, Array.isArray(v) ? v.join(", ") : v);
+        }
+        const body = req.method !== "GET" && req.method !== "HEAD" ? await new Promise((r) => {
+          let data = "";
+          req.on("data", (c) => {
+            data += c.toString();
+          });
+          req.on("end", () => r(data));
+        }) : void 0;
+        const webReq = new Request(`http://localhost:${port}${url}`, {
+          method: req.method,
+          headers,
+          body
+        });
+        const webRes = await app4.fetch(webReq);
+        res.writeHead(webRes.status, Object.fromEntries(webRes.headers.entries()));
+        res.end(Buffer.from(await webRes.arrayBuffer()));
+        return;
+      }
+      vite.middlewares(req, res);
+    });
+    server.listen(port, () => {
+      console.log(`\u{1F310} docs-i18n admin \u2192 http://localhost:${port}`);
+    });
+  } catch {
+    console.error("Failed to start admin UI (vite not available). API-only mode.");
+    const server = Bun.serve({ port, fetch: app4.fetch });
+    console.log(`\u{1F310} docs-i18n admin (API only) \u2192 http://localhost:${port}`);
+  }
+}
+export {
+  startAdmin
+};