@iowarp/clio-coder 0.3.0

package/dist/context-E3KIFVXI.js

@@ -0,0 +1,185 @@
+import {
+  ContextDomainModule,
+  OPERATOR_PROFILE_MAX_CHARS,
+  WIKI_DEPTH_STRATEGY,
+  adoptionSnapshotsHash,
+  adoptionSourcesChanged,
+  assembleWikiTree,
+  buildCandidatePlan,
+  buildWikiPagePrompt,
+  buildWikiPlanPrompt,
+  createContextDomainModule,
+  fallbackBootstrapOutput,
+  loadOperatorProfile,
+  loadProjectRules,
+  pagePathForArea,
+  parseClioMd,
+  planWikiGeneration,
+  renderImportedAgentContext,
+  renderOperatorProfile,
+  renderPromptContext,
+  runBootstrap,
+  runContextClear,
+  runContextRefresh,
+  runWikiGenerate,
+  scanAgentConfigs,
+  selectActiveRules,
+  serializeClioMd,
+  tryReadClioMd
+} from "./chunk-UWIJNAOB.js";
+import {
+  renderCodewikiDigest
+} from "./chunk-X3BR7HWV.js";
+import "./chunk-VOO7NYPP.js";
+import {
+  MAX_PAGE_ATTEMPTS,
+  WIKI_INDEX,
+  WIKI_PLAN_FILE,
+  WIKI_QUICKSTART,
+  changedPathsSince,
+  computeWikiContentHash,
+  computeWikiContentHashOfDir,
+  currentWikiGitHead,
+  isGeneratedWikiFile,
+  isWikiMeta,
+  listWikiPages,
+  listWikiPagesInDir,
+  pendingPages,
+  readWikiMeta,
+  readWikiPage,
+  readWikiPlanFile,
+  renderWikiPage,
+  sanitizePagePath,
+  sanitizeWikiPlan,
+  scopePlanForUpdate,
+  validateWikiMeta,
+  wikiCompleteness,
+  wikiCompletenessFromMeta,
+  wikiDir,
+  wikiMarkdownFilesInDir,
+  wikiMetaPath,
+  wikiStaleness,
+  wikiStalenessAsync,
+  writeWikiMeta,
+  writeWikiPlanFile
+} from "./chunk-GNGDQYDU.js";
+import "./chunk-2J63S4SF.js";
+import {
+  computeFingerprint,
+  computeFingerprintAsync,
+  isStale,
+  readClioState,
+  writeClioState
+} from "./chunk-RQDWMVRB.js";
+import "./chunk-7BHLZB3A.js";
+import {
+  CODEWIKI_VERSION,
+  INDEX_SLICE_MS,
+  buildCodewiki,
+  codewikiEntries,
+  codewikiNeedsBackfill,
+  createSlicer,
+  readCodewiki,
+  readCodewikiAsync,
+  structuralCodewikiHash,
+  syncCodewiki,
+  updateCodewikiPaths,
+  writeCodewiki
+} from "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import "./chunk-XV4ZJ6ZM.js";
+import "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-KBR4MZZR.js";
+import "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+export {
+  CODEWIKI_VERSION,
+  ContextDomainModule,
+  INDEX_SLICE_MS,
+  MAX_PAGE_ATTEMPTS,
+  OPERATOR_PROFILE_MAX_CHARS,
+  WIKI_DEPTH_STRATEGY,
+  WIKI_INDEX,
+  WIKI_PLAN_FILE,
+  WIKI_QUICKSTART,
+  adoptionSnapshotsHash,
+  adoptionSourcesChanged,
+  assembleWikiTree,
+  buildCandidatePlan,
+  buildCodewiki,
+  buildWikiPagePrompt,
+  buildWikiPlanPrompt,
+  changedPathsSince,
+  codewikiEntries,
+  codewikiNeedsBackfill,
+  computeFingerprint,
+  computeFingerprintAsync,
+  computeWikiContentHash,
+  computeWikiContentHashOfDir,
+  createContextDomainModule,
+  createSlicer,
+  currentWikiGitHead,
+  fallbackBootstrapOutput,
+  isGeneratedWikiFile,
+  isStale,
+  isWikiMeta,
+  listWikiPages,
+  listWikiPagesInDir,
+  loadOperatorProfile,
+  loadProjectRules,
+  pagePathForArea,
+  parseClioMd,
+  pendingPages,
+  planWikiGeneration,
+  readClioState,
+  readCodewiki,
+  readCodewikiAsync,
+  readWikiMeta,
+  readWikiPage,
+  readWikiPlanFile,
+  renderCodewikiDigest,
+  renderImportedAgentContext,
+  renderOperatorProfile,
+  renderPromptContext,
+  renderWikiPage,
+  runBootstrap,
+  runContextClear,
+  runContextRefresh,
+  runWikiGenerate,
+  sanitizePagePath,
+  sanitizeWikiPlan,
+  scanAgentConfigs,
+  scopePlanForUpdate,
+  selectActiveRules,
+  serializeClioMd,
+  structuralCodewikiHash,
+  syncCodewiki,
+  tryReadClioMd,
+  updateCodewikiPaths,
+  validateWikiMeta,
+  wikiCompleteness,
+  wikiCompletenessFromMeta,
+  wikiDir,
+  wikiMarkdownFilesInDir,
+  wikiMetaPath,
+  wikiStaleness,
+  wikiStalenessAsync,
+  writeClioState,
+  writeCodewiki,
+  writeWikiMeta,
+  writeWikiPlanFile
+};
+//# sourceMappingURL=context-E3KIFVXI.js.map

package/dist/context-clear-3F4PLXOS.js

@@ -0,0 +1,102 @@
+import {
+  runContextClear
+} from "./chunk-UWIJNAOB.js";
+import "./chunk-X3BR7HWV.js";
+import "./chunk-VOO7NYPP.js";
+import "./chunk-GNGDQYDU.js";
+import "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import "./chunk-XV4ZJ6ZM.js";
+import "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-KBR4MZZR.js";
+import "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/context-clear.ts
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+var HELP = `Usage:
+  clio-coder context reset [--all] [--yes]
+
+Clear accumulated project context owned by the context engine:
+.clio-coder/codewiki.json, .clio-coder/state.json, .clio-coder/handoffs/, and .clio-coder/proposals/.
+
+Preserves by default: CLIO-CODER.md, .clio-coder/agents/, .clio-coder/skills/, and .clio-coder/wiki/.
+
+Options:
+  --all       also remove CLIO-CODER.md after a second confirmation
+  --yes, -y   answer every confirmation, required when stdin is not a terminal
+`;
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+async function confirm(question) {
+  if (!input.isTTY) return false;
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question(question);
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function runContextClearCommand(args) {
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  for (const arg of args) {
+    if (arg !== "--all" && arg !== "--yes" && arg !== "-y") {
+      process.stderr.write(`clio-coder context reset: unknown flag ${arg}
+`);
+      process.stdout.write(HELP);
+      return 2;
+    }
+  }
+  const all = hasFlag(args, "--all");
+  const assumeYes = hasFlag(args, "--yes") || hasFlag(args, "-y");
+  if (!assumeYes && !input.isTTY) {
+    process.stderr.write("clio-coder context reset: stdin is not a terminal; pass --yes to confirm non-interactively\n");
+  }
+  const answer = (question) => assumeYes ? Promise.resolve(true) : confirm(question);
+  try {
+    await runContextClear({
+      cwd: process.cwd(),
+      all,
+      io: {
+        stdout: (s) => process.stdout.write(s),
+        stderr: (s) => process.stderr.write(s)
+      },
+      confirmContext: () => answer(
+        "Clear .clio-coder/codewiki.json, .clio-coder/state.json, .clio-coder/handoffs/, and .clio-coder/proposals/? [y/N] "
+      ),
+      confirmAll: () => answer("Also remove CLIO-CODER.md? [y/N] ")
+    });
+    return 0;
+  } catch (err) {
+    process.stderr.write(`clio-coder context reset failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+export {
+  runContextClearCommand
+};
+//# sourceMappingURL=context-clear-3F4PLXOS.js.map

package/dist/context-index-Q7YSYTR3.js

@@ -0,0 +1,106 @@
+import {
+  computeFingerprint,
+  readClioState,
+  statePath,
+  writeClioState
+} from "./chunk-RQDWMVRB.js";
+import {
+  buildCodewiki,
+  codewikiPath,
+  detectProjectProfile,
+  structuralCodewikiHash,
+  writeCodewiki
+} from "./chunk-TPOCL34A.js";
+import "./chunk-VPAWTYLY.js";
+
+// src/cli/context-index.ts
+var HELP = `Usage:
+  clio-coder context index [--json]
+
+Build the structural codewiki index for the current repository without model calls.
+Writes .clio-coder/codewiki.json and .clio-coder/state.json, then prints source coverage.
+
+Options:
+  --json          print machine-readable coverage and hash details
+`;
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+function languageCounts(profile) {
+  return Object.fromEntries(
+    Object.entries(profile.languageCounts).filter(([, count]) => count > 0).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+function formatCounts(counts) {
+  const parts = Object.entries(counts).map(([language, count]) => `${language}=${count}`);
+  return parts.length > 0 ? parts.join(", ") : "none";
+}
+function indexedSourceCount(codewiki) {
+  return codewiki.files.filter((file) => file.lang !== "config").length;
+}
+async function runContextIndexCommand(args) {
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const allowed = /* @__PURE__ */ new Set(["--json"]);
+  for (const arg of args) {
+    if (!allowed.has(arg)) {
+      process.stderr.write(`clio-coder context index: unknown flag ${arg}
+`);
+      return 2;
+    }
+  }
+  const cwd = process.cwd();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const profile = detectProjectProfile(cwd);
+  const codewiki = await buildCodewiki({ cwd, language: profile.projectType });
+  writeCodewiki(cwd, codewiki);
+  const prev = readClioState(cwd);
+  const fingerprint = computeFingerprint(cwd, codewiki);
+  writeClioState(cwd, {
+    version: 1,
+    projectType: profile.projectType,
+    fingerprint,
+    codewikiVersion: codewiki.version,
+    ...prev?.contextSources ? { contextSources: prev.contextSources } : {},
+    ...prev?.contextSourceHash ? { contextSourceHash: prev.contextSourceHash } : {},
+    ...prev?.lastBootstrap ? { lastBootstrap: prev.lastBootstrap } : {},
+    ...prev?.lastInitAt ? { lastInitAt: prev.lastInitAt } : {},
+    lastSessionAt: prev?.lastSessionAt ?? now,
+    lastIndexedAt: now
+  });
+  const indexed = indexedSourceCount(codewiki);
+  const coverage = profile.sourceFiles === 0 ? 1 : indexed / profile.sourceFiles;
+  const counts = languageCounts(profile);
+  const payload = {
+    projectType: profile.projectType,
+    sourceFiles: profile.sourceFiles,
+    indexedSourceFiles: indexed,
+    coverage,
+    languageCounts: counts,
+    codewikiPath: codewikiPath(cwd),
+    statePath: statePath(cwd),
+    structuralHash: structuralCodewikiHash(codewiki)
+  };
+  if (hasFlag(args, "--json")) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    return 0;
+  }
+  process.stdout.write(
+    [
+      `clio-coder context index indexed ${indexed}/${profile.sourceFiles} source file${profile.sourceFiles === 1 ? "" : "s"} (${(coverage * 100).toFixed(1)}%)`,
+      `  language ${profile.projectType}; counts ${formatCounts(counts)}`,
+      `  codewiki ${payload.codewikiPath}`,
+      `  state ${payload.statePath}`,
+      `  structural hash ${payload.structuralHash}`,
+      ""
+    ].join("\n")
+  );
+  return 0;
+}
+export {
+  runContextIndexCommand
+};
+//# sourceMappingURL=context-index-Q7YSYTR3.js.map

package/dist/docs-YIETIWZI.js

@@ -0,0 +1,280 @@
+import "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printHeader
+} from "./chunk-67MTHP2E.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import {
+  resolvePackageRoot
+} from "./chunk-DXQNI4PC.js";
+
+// src/cli/docs.ts
+import { spawn } from "node:child_process";
+import { createReadStream, readdirSync, statSync } from "node:fs";
+import { createServer } from "node:http";
+import { relative, resolve } from "node:path";
+import chalk from "chalk";
+var HOST = "127.0.0.1";
+var HELP = `clio-coder docs [topic] [--no-open]
+
+Serve Clio Coder's bundled HTML documentation locally and open it in a browser.
+The server binds an ephemeral port on 127.0.0.1 only; it keeps no state, runs no
+daemon, and reaches no external network. Press Ctrl+C to stop it.
+
+Arguments:
+  [topic]      deep-link a specific blueprint (for example: safety, configuration,
+               tools). Omit to open the documentation menu.
+
+Flags:
+  --no-open    do not launch a browser; just print the URL.
+  --help, -h   this message.
+`;
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8"
+};
+function resolveDocsHtmlDir() {
+  return resolve(resolvePackageRoot(), "docs", "html");
+}
+function contentTypeFor(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  if (dot === -1) return "application/octet-stream";
+  return CONTENT_TYPES[filePath.slice(dot).toLowerCase()] ?? "application/octet-stream";
+}
+function resolveRequestPath(rawUrl) {
+  const pathPart = (rawUrl.split(/[?#]/, 1)[0] ?? "").trim();
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathPart);
+  } catch {
+    return { ok: false, reason: "bad-request" };
+  }
+  if (decoded.includes("\0")) return { ok: false, reason: "forbidden" };
+  const segments = decoded.split(/[/\\]/).filter((segment) => segment.length > 0 && segment !== ".");
+  if (segments.length === 0) return { ok: true, relative: "index.html" };
+  for (const segment of segments) {
+    if (segment === "..") return { ok: false, reason: "forbidden" };
+  }
+  return { ok: true, relative: segments.join("/") };
+}
+function titleize(topic) {
+  return topic.split(/[-_]+/).filter((word) => word.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function synthesizeMenu(fileNames) {
+  const entries = [];
+  for (const name of fileNames) {
+    if (!name.toLowerCase().endsWith(".html")) continue;
+    if (name.toLowerCase() === "index.html") continue;
+    const topic = name.replace(/\.html$/i, "").replace(/_blueprint$/i, "");
+    entries.push({ topic, file: name, label: titleize(topic) });
+  }
+  entries.sort((a, b) => a.topic.localeCompare(b.topic));
+  return entries;
+}
+function topicToFile(topic, fileNames) {
+  const wanted = topic.trim().toLowerCase().replace(/\.html$/i, "");
+  if (wanted.length === 0) return null;
+  for (const candidate of [`${wanted}.html`, `${wanted}_blueprint.html`]) {
+    const match = fileNames.find((name) => name.toLowerCase() === candidate);
+    if (match) return match;
+  }
+  const hit = synthesizeMenu(fileNames).find((entry) => entry.topic.toLowerCase() === wanted);
+  return hit ? hit.file : null;
+}
+function isWithin(child, parent) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !rel.startsWith(`..${"/"}`) && !/^([A-Za-z]:)?[/\\]/.test(rel);
+}
+function listHtmlFiles(htmlDir) {
+  try {
+    return readdirSync(htmlDir).filter((name) => name.toLowerCase().endsWith(".html")).sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+function createDocsRequestHandler(htmlDir) {
+  const root = resolve(htmlDir);
+  return (req, res) => {
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405, { "content-type": "text/plain; charset=utf-8", allow: "GET, HEAD" });
+      res.end("method not allowed");
+      return;
+    }
+    const resolved = resolveRequestPath(req.url ?? "/");
+    if (!resolved.ok) {
+      const status = resolved.reason === "forbidden" ? 403 : 400;
+      res.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
+      res.end(resolved.reason);
+      return;
+    }
+    const target = resolve(root, resolved.relative);
+    if (!isWithin(target, root)) {
+      res.writeHead(403, { "content-type": "text/plain; charset=utf-8" });
+      res.end("forbidden");
+      return;
+    }
+    let size = null;
+    try {
+      const stat = statSync(target);
+      if (stat.isFile()) size = stat.size;
+    } catch {
+      size = null;
+    }
+    if (size === null) {
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+      res.end("not found");
+      return;
+    }
+    const headers = {
+      "content-type": contentTypeFor(target),
+      "content-length": String(size),
+      "cache-control": "no-store"
+    };
+    if (req.method === "HEAD") {
+      res.writeHead(200, headers);
+      res.end();
+      return;
+    }
+    res.writeHead(200, headers);
+    const stream = createReadStream(target);
+    stream.on("error", () => {
+      if (!res.writableEnded) res.end();
+    });
+    stream.pipe(res);
+  };
+}
+async function startDocsServer(options) {
+  const host = options.host ?? HOST;
+  const server = createServer(createDocsRequestHandler(options.htmlDir));
+  await new Promise((resolveListen, rejectListen) => {
+    const onError = (err) => rejectListen(err);
+    server.once("error", onError);
+    server.listen(options.port ?? 0, host, () => {
+      server.removeListener("error", onError);
+      resolveListen();
+    });
+  });
+  const address = server.address();
+  const port = address.port;
+  return {
+    server,
+    port,
+    url: `http://${host}:${port}/`,
+    close: () => new Promise((resolveClose) => server.close(() => resolveClose()))
+  };
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function waitForShutdown() {
+  return new Promise((resolveShutdown) => {
+    const onSignal = () => {
+      process.removeListener("SIGINT", onSignal);
+      process.removeListener("SIGTERM", onSignal);
+      resolveShutdown();
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+  });
+}
+async function runDocsCommand(args = []) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  let noOpen = false;
+  const positionals = [];
+  for (const arg of args) {
+    if (arg === "--no-open") {
+      noOpen = true;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      printError(`unknown flag: ${arg}`);
+      process.stdout.write(HELP);
+      return 2;
+    }
+    positionals.push(arg);
+  }
+  if (positionals.length > 1) {
+    printError("docs accepts at most one [topic]");
+    process.stdout.write(HELP);
+    return 2;
+  }
+  let htmlDir;
+  try {
+    htmlDir = resolveDocsHtmlDir();
+  } catch (err) {
+    printError(`could not resolve bundled docs: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  const files = listHtmlFiles(htmlDir);
+  if (files.length === 0) {
+    printError(`no bundled HTML docs found at ${htmlDir}`);
+    return 1;
+  }
+  let landing = "index.html";
+  const topic = positionals[0];
+  if (topic !== void 0) {
+    const file = topicToFile(topic, files);
+    if (!file) {
+      printError(`unknown docs topic: ${topic}`);
+      const topics = synthesizeMenu(files).map((entry) => entry.topic);
+      if (topics.length > 0) process.stdout.write(`  available topics: ${topics.join(", ")}
+`);
+      return 2;
+    }
+    landing = file;
+  }
+  const handle = await startDocsServer({ htmlDir });
+  const landingUrl = landing === "index.html" ? handle.url : `${handle.url}${landing}`;
+  printHeader("Clio docs viewer");
+  process.stdout.write(`  serving ${htmlDir}
+`);
+  process.stdout.write(`  open ${chalk.cyan(landingUrl)}
+`);
+  process.stdout.write("  bound to 127.0.0.1 only: no external network, no daemon, no state.\n");
+  process.stdout.write("  press Ctrl+C to stop.\n");
+  if (!noOpen) openBrowser(landingUrl);
+  await waitForShutdown();
+  await handle.close();
+  process.stdout.write("docs viewer stopped.\n");
+  return 0;
+}
+export {
+  contentTypeFor,
+  resolveDocsHtmlDir,
+  resolveRequestPath,
+  runDocsCommand,
+  startDocsServer,
+  synthesizeMenu,
+  topicToFile
+};
+//# sourceMappingURL=docs-YIETIWZI.js.map