mixdog 0.7.1

package/src/channels/lib/event-queue.mjs

@@ -0,0 +1,345 @@
+import { readdirSync, readFileSync, existsSync as fsExistsSync } from "fs";
+import { join } from "path";
+import { DATA_DIR } from "./config.mjs";
+import { ensureDir } from "./state-file.mjs";
+import { logEvent } from "./executor.mjs";
+import { renameWithRetrySync, writeJsonAtomicSync } from "../../shared/atomic-file.mjs";
+const QUEUE_DIR = join(DATA_DIR, "events", "queue");
+const IN_PROGRESS_DIR = join(DATA_DIR, "events", "in-progress");
+const PROCESSED_DIR = join(DATA_DIR, "events", "processed");
+function finiteInt(value, { min, max, def }) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return def;
+  const i = Math.trunc(n);
+  if (i < min) return min;
+  if (i > max) return max;
+  return i;
+}
+class EventQueue {
+  config;
+  channelsConfig;
+  tickTimer = null;
+  batchTimer = null;
+  _processQueueRunning = false;
+  _processBatchRunning = false;
+  injectFn = null;
+  ownerGetter = null;
+  ownerSkipLogged = false;
+  // Monotonic enqueue counter — prevents same-millisecond enqueue ordering
+  // from being decided by Math.random() (lex sort on the random suffix).
+  // Counter is 8-digit zero-padded so lex sort matches numeric order.
+  enqueueSeq = 0;
+  // track files already notified during active state
+  constructor(config, channelsConfig) {
+    this.config = config ?? {};
+    this.channelsConfig = channelsConfig ?? null;
+  }
+  setInjectHandler(fn) {
+    this.injectFn = fn;
+  }
+  setOwnerGetter(fn) {
+    this.ownerGetter = fn;
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────
+  start() {
+    if (this.tickTimer) return;
+    ensureDir(QUEUE_DIR);
+    ensureDir(IN_PROGRESS_DIR);
+    ensureDir(PROCESSED_DIR);
+    // Recover events that were claimed (renamed into in-progress/) but never
+    // executed because the process crashed between claim and execute. The
+    // tick/batch loops only ever scan queue/, so without this they would be
+    // stranded forever. Move them back to queue/ so the next tick re-claims.
+    this.requeueStrandedInProgress();
+    const tickSec = finiteInt(this.config.tickInterval, { min: 1, max: 3600, def: 2 });
+    const tickMs = tickSec * 1e3;
+    this.tickTimer = setInterval(() => this.processQueue(), tickMs);
+    this.initialTickTimer = setTimeout(() => {
+      this.initialTickTimer = null;
+      this.processQueue();
+    }, 3e3);
+    const batchMin = finiteInt(this.config.batchInterval, { min: 1, max: 1440, def: 30 });
+    const batchMs = batchMin * 6e4;
+    this.batchTimer = setInterval(() => this.processBatch(), batchMs);
+    logEvent("queue started");
+  }
+  stop() {
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.batchTimer) {
+      clearInterval(this.batchTimer);
+      this.batchTimer = null;
+    }
+    if (this.initialTickTimer) {
+      clearTimeout(this.initialTickTimer);
+      this.initialTickTimer = null;
+    }
+  }
+  reloadConfig(config, channelsConfig) {
+    this.stop();
+    this.config = config ?? {};
+    this.channelsConfig = channelsConfig ?? null;
+    this.start();
+  }
+  // ── Enqueue ───────────────────────────────────────────────────────
+  enqueue(item) {
+    ensureDir(QUEUE_DIR);
+    const seq = String(this.enqueueSeq++).padStart(8, "0");
+    const id = `${Date.now()}-${seq}-${Math.random().toString(36).slice(2, 6)}`;
+    // Filename is plain <id>.json — ordering is by enqueue sequence (monotonic).
+    // Priority is stored inside the item JSON; callers sort/filter by item.priority.
+    const filename = `${id}.json`;
+    const finalPath = join(QUEUE_DIR, filename);
+    writeJsonAtomicSync(finalPath, item, { fsyncDir: true });
+    logEvent(`${item.name}: enqueued (${item.priority})`);
+    if (item.priority === "high") {
+      setImmediate(() => this.processQueue());
+    }
+  }
+  // ── Process queue ─────────────────────────────────────────────────
+  processQueue() {
+    if (this._processQueueRunning) return;
+    this._processQueueRunning = true;
+    try {
+      // Belt-and-suspenders ownership guard: if this process is not the
+      // active owner, do nothing. The runtime should only have started this
+      // queue on the owner path, but an ownership hand-off can briefly leave
+      // two processes both ticking — this short-circuits that window.
+      // This is multi-process active-owner gating, not HTTP authentication.
+      if (this.ownerGetter) {
+        // Fail closed: a probe exception must NOT be treated as ownership.
+        // Duplicate-owner queue ticks are exactly what this guard prevents.
+        let isOwner = false;
+        try { isOwner = !!this.ownerGetter(); } catch { isOwner = false; }
+        if (!isOwner) {
+          if (!this.ownerSkipLogged) {
+            logEvent("queue: skipping tick — not owner");
+            this.ownerSkipLogged = true;
+          }
+          return;
+        }
+        this.ownerSkipLogged = false;
+      }
+      const files = this.readQueueFiles();
+      if (files.length === 0) return;
+      for (const file of files) {
+        const item = this.readItem(file);
+        if (!item) continue;
+        // Low-priority items are coalesced by processBatch() on its own
+        // interval; the per-tick loop must skip them or it would dispatch
+        // each low item individually and starve the batching feature.
+        if (item.priority === "low") continue;
+        // Atomic claim: rename into in-progress/ before executing. If the
+        // rename fails (another tick / cleanup raced, or file vanished),
+        // skip this handle.
+        const claimed = this.claimFile(file);
+        if (!claimed) continue;
+        this.executeItem(item, claimed);
+      }
+    } finally {
+      this._processQueueRunning = false;
+    }
+  }
+  processBatch() {
+    // Belt-and-suspenders ownership guard: if this process is not the
+    // active owner, do nothing. The runtime should only have started this
+    // queue on the owner path, but an ownership hand-off can briefly leave
+    // two processes both ticking — this short-circuits that window.
+    // This is multi-process active-owner gating, not HTTP authentication.
+    if (this.ownerGetter) {
+      // Fail closed: a probe exception must NOT be treated as ownership.
+      let isOwner = false;
+      try { isOwner = !!this.ownerGetter(); } catch { isOwner = false; }
+      if (!isOwner) {
+        if (!this.ownerSkipLogged) {
+          logEvent("queue: skipping batch tick — not owner");
+          this.ownerSkipLogged = true;
+        }
+        return;
+      }
+      this.ownerSkipLogged = false;
+    }
+    const files = this.readQueueFiles();
+    const lowFiles = files.filter((f) => {
+      const item = this.readItem(f);
+      return item?.priority === "low";
+    });
+    if (lowFiles.length === 0) return;
+    const groups = /* @__PURE__ */ new Map();
+    for (const file of lowFiles) {
+      const item = this.readItem(file);
+      if (!item) continue;
+      const group = groups.get(item.name) ?? { items: [], files: [] };
+      group.items.push(item);
+      group.files.push(file);
+      groups.set(item.name, group);
+    }
+    for (const [name, group] of groups) {
+      // Claim all batch files atomically BEFORE building the combined
+      // prompt so overlapping batch ticks don't double-process. Files
+      // that fail to claim are dropped from this batch, and their
+      // corresponding items are excluded from the prompt.
+      const claimedPairs = [];
+      for (let i = 0; i < group.files.length; i++) {
+        const claimed = this.claimFile(group.files[i]);
+        if (claimed) claimedPairs.push({ file: claimed, item: group.items[i] });
+      }
+      if (claimedPairs.length === 0) continue;
+      const combined = claimedPairs.length === 1 ? claimedPairs[0].item.prompt : `Batch of ${claimedPairs.length} events:
+
+${claimedPairs.map((p, i) => `--- Event ${i + 1} ---
+${p.item.prompt}`).join("\n\n")}`;
+      const batchItem = {
+        ...claimedPairs[0].item,
+        prompt: combined
+      };
+      logEvent(`${name}: processing batch of ${claimedPairs.length}`);
+      this.executeItem(batchItem, null);
+      for (const { file: claimedPath } of claimedPairs) {
+        this.moveInProgressToProcessed(claimedPath, "batched");
+      }
+    }
+  }
+  // ── Execute ───────────────────────────────────────────────────────
+  // Only interactive items pass through the queue now. Delegate-mode
+  // webhooks invoke bridge directly and never enqueue here; the legacy
+  // non-interactive / script exec branches were removed.
+  executeItem(item, file) {
+    if (this.injectFn) {
+      const opts = { type: "webhook" };
+      const chatId = this.resolveChannel(item.channel) || "";
+      if (item.instruction) {
+        opts.instruction = `${item.instruction}\n\n${item.prompt}`;
+      } else {
+        opts.instruction = item.prompt;
+      }
+      this.injectFn(chatId, `event:${item.name}`, " ", opts);
+    }
+    if (file) this.moveToProcessed(file, "injected");
+  }
+  // ── Helpers ───────────────────────────────────────────────────────
+  readQueueFiles() {
+    try {
+      return readdirSync(QUEUE_DIR).filter((f) => f.endsWith(".json")).sort();
+    } catch {
+      return [];
+    }
+  }
+  readItem(file) {
+    try {
+      return JSON.parse(readFileSync(join(QUEUE_DIR, file), "utf8"));
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        logEvent(`queue: corrupt file ${file}`);
+      }
+      return null;
+    }
+  }
+  // Atomically rename from queue/ to in-progress/. Returns the new
+  // filename on success, or null if another worker already claimed it /
+  // the file vanished. Same-volume rename stays atomic; Windows transient
+  // EPERM/EACCES/EBUSY gets a short retry window.
+  claimFile(file) {
+    try {
+      ensureDir(IN_PROGRESS_DIR);
+      const claimed = `in-progress-${Date.now()}-${file}`;
+      renameWithRetrySync(join(QUEUE_DIR, file), join(IN_PROGRESS_DIR, claimed));
+      return claimed;
+    } catch (err) {
+      // ENOENT: another tick grabbed it; EEXIST: target collision (very rare).
+      if (err && err.code && err.code !== "ENOENT" && err.code !== "EEXIST") {
+        logEvent(`queue: claim failed for ${file}: ${err.message ?? err}`);
+      }
+      return null;
+    }
+  }
+  // Move any leftover in-progress/ handles back to queue/ so a crash between
+  // claim and execute does not strand the event. Claim names are
+  // `in-progress-<ts>-<originalFile>`; strip the prefix to restore the
+  // original queue filename (which preserves enqueue-sequence ordering).
+  requeueStrandedInProgress() {
+    let entries;
+    try {
+      entries = readdirSync(IN_PROGRESS_DIR).filter((f) => f.endsWith(".json"));
+    } catch {
+      return;
+    }
+    let count = 0;
+    for (const claimed of entries) {
+      const match = /^in-progress-\d+-(.+)$/.exec(claimed);
+      const original = match ? match[1] : claimed;
+      try {
+        renameWithRetrySync(join(IN_PROGRESS_DIR, claimed), join(QUEUE_DIR, original));
+        count++;
+      } catch (err) {
+        if (err && err.code && err.code !== "ENOENT") {
+          logEvent(`queue: requeue failed for ${claimed}: ${err.message ?? err}`);
+        }
+      }
+    }
+    if (count > 0) logEvent(`queue: requeued ${count} stranded in-progress events`);
+  }
+  moveToProcessed(file, status) {
+    // `file` may already live under in-progress/ (claimed) or still in
+    // queue/ (batch paths). Try both locations.
+    try {
+      ensureDir(PROCESSED_DIR);
+      const fromInProgress = join(IN_PROGRESS_DIR, file);
+      const fromQueue = join(QUEUE_DIR, file);
+      const src = this.existsSync(fromInProgress) ? fromInProgress : fromQueue;
+      renameWithRetrySync(src, join(PROCESSED_DIR, `${status}-${file}`));
+    } catch {
+    }
+  }
+  moveInProgressToProcessed(file, status) {
+    try {
+      ensureDir(PROCESSED_DIR);
+      renameWithRetrySync(join(IN_PROGRESS_DIR, file), join(PROCESSED_DIR, `${status}-${file}`));
+    } catch {
+    }
+  }
+  existsSync(p) {
+    try {
+      // readdirSync-free existence check via rename would be destructive —
+      // fall back to a cheap stat via readFileSync on non-content probe.
+      // Use fs.existsSync semantics without importing it twice.
+      return fsExistsSync(p);
+    } catch {
+      return false;
+    }
+  }
+  resolveChannel(label) {
+    if (!label || !this.channelsConfig) return "";
+    const entry = this.channelsConfig?.[label];
+    return entry?.channelId ?? label;
+  }
+  /** Remove items from queue — after processing, dismissal, or any resolution */
+  resolveItems(name, status = "done") {
+    const files = this.readQueueFiles();
+    let count = 0;
+    for (const file of files) {
+      const item = this.readItem(file);
+      if (!item) continue;
+      if (item.name === name || name === "*") {
+        this.moveToProcessed(file, status);
+        count++;
+      }
+    }
+    if (count > 0) logEvent(`queue: resolved ${count} items (name=${name}, status=${status})`);
+    return count;
+  }
+  /** Get queue status */
+  getStatus() {
+    const pending = this.readQueueFiles().length;
+    return { pending, running: 0 };
+  }
+  /** List pending interactive items */
+  getPendingInteractive() {
+    return this.readQueueFiles().map((f) => this.readItem(f)).filter((item) => item !== null && item.exec === "interactive");
+  }
+}
+export {
+  EventQueue
+};

package/src/channels/lib/executor.mjs

@@ -0,0 +1,168 @@
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, appendFileSync, appendFile as _appendFileAsync } from "fs";
+import { join, normalize, extname, sep } from "path";
+import { tmpdir } from "os";
+import { DATA_DIR } from "./config.mjs";
+const SCRIPTS_DIR = join(DATA_DIR, "scripts");
+const NOPLUGIN_DIR = join(tmpdir(), "mixdog-noplugin");
+const EVENT_LOG = join(DATA_DIR, "event.log");
+// Buffered async logger — coalesces per-line appends into batched writes.
+let _eventLogBuf = [];
+let _eventLogTimer = null;
+function _flushEventLog() {
+  _eventLogTimer = null;
+  if (_eventLogBuf.length === 0) return;
+  const lines = _eventLogBuf.join("");
+  _eventLogBuf = [];
+  _appendFileAsync(EVENT_LOG, lines, () => {});
+}
+function _flushEventLogSync() {
+  if (_eventLogBuf.length === 0) return;
+  const lines = _eventLogBuf.join("");
+  _eventLogBuf = [];
+  try { appendFileSync(EVENT_LOG, lines); } catch {}
+}
+process.on('exit', _flushEventLogSync);
+function logEvent(msg) {
+  try { process.stderr.write(`mixdog event: ${msg}\n`); } catch {}
+  _eventLogBuf.push(`[${new Date().toISOString()}] ${msg}\n`);
+  if (!_eventLogTimer) _eventLogTimer = setTimeout(_flushEventLog, 2000);
+}
+function parseGithub(body, headers) {
+  const event = headers["x-github-event"] || "";
+  const action = body.action || "";
+  const pr = body.pull_request || body.issue || {};
+  return {
+    event,
+    action,
+    title: pr.title || body.head_commit?.message || "",
+    author: pr.user?.login || body.sender?.login || "",
+    repo: body.repository?.full_name || "",
+    url: pr.html_url || body.compare || "",
+    branch: body.ref || pr.head?.ref || "",
+    message: body.head_commit?.message || ""
+  };
+}
+function parseSentry(body) {
+  const data = body.data || {};
+  const evt = data.event || data.issue || {};
+  return {
+    title: evt.title || body.message || "",
+    level: evt.level || body.level || "",
+    project: body.project_name || body.project || "",
+    url: evt.web_url || body.url || ""
+  };
+}
+function parseGeneric(body) {
+  const result = {};
+  const keys = Object.keys(body).slice(0, 5);
+  for (const k of keys) {
+    result[k] = typeof body[k] === "string" ? body[k] : JSON.stringify(body[k]);
+  }
+  return result;
+}
+function applyParser(parser, body, headers) {
+  switch (parser) {
+    case "github":
+      return parseGithub(body, headers);
+    case "sentry":
+      return parseSentry(body);
+    case "generic":
+      return parseGeneric(body);
+    default:
+      return { raw: JSON.stringify(body) };
+  }
+}
+function evaluateFilter(expr, data) {
+  const orParts = expr.split("||").map((s) => s.trim());
+  for (const orPart of orParts) {
+    const andParts = orPart.split("&&").map((s) => s.trim());
+    let andResult = true;
+    for (const condition of andParts) {
+      const match = condition.match(/^(\w+)\s*==\s*['"](.*)['"]$/);
+      if (!match) {
+        const neqMatch = condition.match(/^(\w+)\s*!=\s*['"](.*)['"]$/);
+        if (neqMatch) {
+          const [, field2, value2] = neqMatch;
+          if ((data[field2] ?? "") === value2) {
+            andResult = false;
+            break;
+          }
+        } else {
+          andResult = false;
+          break;
+        }
+        continue;
+      }
+      const [, field, value] = match;
+      if ((data[field] ?? "") !== value) {
+        andResult = false;
+        break;
+      }
+    }
+    if (andResult) return true;
+  }
+  return false;
+}
+function applyTemplate(template, data) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => data[key] ?? "");
+}
+function ensureNopluginDir() {
+  mkdirSync(NOPLUGIN_DIR, { recursive: true });
+}
+function runScript(name, scriptName, onResult) {
+  if (!existsSync(SCRIPTS_DIR)) {
+    mkdirSync(SCRIPTS_DIR, { recursive: true });
+  }
+  const scriptPath = normalize(join(SCRIPTS_DIR, scriptName));
+  // Boundary-correct containment: startsWith(SCRIPTS_DIR) by itself accepts
+  // sibling roots like `<SCRIPTS_DIR>2/...`. Require either an exact match
+  // OR the path-separator-prefixed form.
+  const SCRIPTS_PREFIX = SCRIPTS_DIR.endsWith(sep) ? SCRIPTS_DIR : SCRIPTS_DIR + sep;
+  if (scriptPath !== SCRIPTS_DIR && !scriptPath.startsWith(SCRIPTS_PREFIX)) {
+    logEvent(`${name}: script path escapes directory: ${scriptName}`);
+    onResult("", null);
+    return;
+  }
+  if (!existsSync(scriptPath)) {
+    logEvent(`${name}: script not found: ${scriptPath}`);
+    onResult("", null);
+    return;
+  }
+  const ext = extname(scriptName).toLowerCase();
+  const cmd = ext === ".py" ? "python3" : "node";
+  const proc = spawn(cmd, [scriptPath], {
+    timeout: 3e4,
+    env: { ...process.env },
+    windowsHide: true
+  });
+  let stdout = "";
+  let stderr = "";
+  if (proc.stdout) proc.stdout.on("data", (d) => {
+    stdout += d;
+  });
+  if (proc.stderr) proc.stderr.on("data", (d) => {
+    stderr += d;
+  });
+  proc.on("close", (code) => {
+    if (code !== 0) {
+      logEvent(`${name}: script exited ${code}: ${stderr.substring(0, 500)}`);
+    }
+    onResult(stdout.substring(0, 2e3), code);
+  });
+  proc.on("error", (err) => {
+    logEvent(`${name}: script spawn error: ${err.message}`);
+    onResult("", null);
+  });
+}
+export {
+  applyParser,
+  applyTemplate,
+  ensureNopluginDir,
+  evaluateFilter,
+  logEvent,
+  parseGeneric,
+  parseGithub,
+  parseSentry,
+  runScript
+};

package/src/channels/lib/format.mjs

@@ -0,0 +1,188 @@
+function getDisplayWidth(str) {
+  let width = 0;
+  for (const ch of str) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code >= 4352 && code <= 4447 || code >= 11904 && code <= 12350 || code >= 12352 && code <= 13247 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 40959 || code >= 44032 && code <= 55215 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65103 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 131072 && code <= 195103 || code >= 127744 && code <= 129535) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function replaceEmojiInCodeBlock(text) {
+  return text.replace(/✅/g, "[O]").replace(/❌/g, "[X]").replace(/⭕/g, "[O]").replace(/🔴/g, "[X]");
+}
+function parseTableCells(line) {
+  return line.replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
+}
+// Render a parsed table as a monospace ASCII block wrapped in a code fence.
+// allRows[0] is the header row; the rest are data rows.
+function renderTableAsCode(allRows) {
+  const colCount = allRows[0].length;
+  const widths = [];
+  for (let c = 0; c < colCount; c++) {
+    let max = 2;
+    for (const row of allRows) {
+      const cellLen = row[c] ? getDisplayWidth(row[c]) : 0;
+      if (cellLen > max) max = cellLen;
+    }
+    widths.push(max);
+  }
+  const padCell = (str, w) => {
+    const visLen = getDisplayWidth(str || "");
+    return (str || "") + " ".repeat(Math.max(0, w - visLen));
+  };
+  const outLines = [];
+  outLines.push(allRows[0].map((c, ci) => padCell(c, widths[ci])).join("  "));
+  outLines.push(widths.map((w) => "-".repeat(w)).join("  "));
+  for (let r = 1; r < allRows.length; r++) {
+    outLines.push(allRows[r].map((c, ci) => padCell(c, widths[ci])).join("  "));
+  }
+  const tableText = replaceEmojiInCodeBlock(outLines.join("\n"));
+  return "```\n" + tableText + "\n```";
+}
+// Render a parsed table as a bullet list (mobile-safe, never wraps/breaks).
+// Multi-column tables use the first cell as a bold row label and emit
+// `• Header: Value` bullets for the remaining columns; empty values are
+// skipped. Single-column tables fall back to a flat bullet list.
+function renderTableAsBullets(allRows) {
+  const headers = allRows[0] ?? [];
+  const dataRows = allRows.slice(1);
+  if (headers.length === 0 && dataRows.length === 0) return "";
+  const useFirstColAsLabel = headers.length > 1 && dataRows.length > 0;
+  const out = [];
+  if (useFirstColAsLabel) {
+    for (const row of dataRows) {
+      if (row.length === 0) continue;
+      const rowLabel = row[0];
+      if (rowLabel) out.push("**" + rowLabel + "**");
+      for (let i = 1; i < row.length; i++) {
+        const value = row[i];
+        if (!value) continue;
+        const header = headers[i];
+        out.push(header ? "• " + header + ": " + value : "• Column " + i + ": " + value);
+      }
+      out.push("");
+    }
+  } else {
+    for (const row of dataRows) {
+      for (let i = 0; i < row.length; i++) {
+        const value = row[i];
+        if (!value) continue;
+        const header = headers[i];
+        if (header) out.push("• " + header + ": " + value);
+      }
+      out.push("");
+    }
+  }
+  return out.join("\n").replace(/\n+$/, "");
+}
+// Convert GitHub-flavored Markdown tables for Discord delivery.
+// mode: "bullets" (default, mobile-safe) | "code" (monospace block) | "off".
+function isTableSeparator(line) {
+  return /^\|[\s-:]+(\|[\s-:]+)*\|?\s*$/.test(line);
+}
+function convertMarkdownTables(text, mode = "bullets") {
+  if (!text || mode === "off") return text;
+  const lines = text.split("\n");
+  const result = [];
+  let i = 0;
+  while (i < lines.length) {
+    // A separator row turns the previously pushed header line into a table.
+    // We pop that header off `result` and push the rendered block in its place,
+    // so collapsing a multi-line table never desyncs array indices across
+    // subsequent tables.
+    if (i > 0 && isTableSeparator(lines[i]) && result.length > 0 && /\|/.test(lines[i - 1])) {
+      const headerLine = lines[i - 1];
+      const tableLines = [headerLine];
+      let j = i + 1;
+      while (j < lines.length && /^\|/.test(lines[j]) && !isTableSeparator(lines[j])) {
+        tableLines.push(lines[j]);
+        j++;
+      }
+      const allRows = tableLines.map(parseTableCells);
+      result.pop();
+      result.push(mode === "code" ? renderTableAsCode(allRows) : renderTableAsBullets(allRows));
+      i = j;
+      continue;
+    }
+    result.push(lines[i]);
+    i++;
+  }
+  return result.join("\n");
+}
+function escapeNestedCodeBlocks(text) {
+  let fenceLen = 0;
+  const lines = text.split("\n");
+  return lines.map((line) => {
+    const match = line.match(/^(`{3,})/);
+    if (match) {
+      if (fenceLen === 0) {
+        fenceLen = match[1].length;
+      } else if (match[1].length >= fenceLen) {
+        fenceLen = 0;
+      }
+      return line;
+    }
+    if (fenceLen > 0 && line.includes("```")) {
+      return line.replace(/```/g, "`​``");
+    }
+    return line;
+  }).join("\n");
+}
+// opts.tables selects the table rendering mode: "bullets" | "code" | "off".
+function formatForDiscord(text, opts = {}) {
+  const mode = opts.tables ?? "bullets";
+  return escapeNestedCodeBlocks(convertMarkdownTables(text, mode));
+}
+function safeCodeBlock(content, lang = "") {
+  const escaped = content.replace(/```/g, "`​``");
+  return "```" + lang + "\n" + escaped + "\n```";
+}
+function chunk(text, limit = 2e3) {
+  if (text.length <= limit) return [text];
+  const out = [];
+  let rest = text;
+  while (rest.length > limit) {
+    let cut = -1;
+    const cbEnd1 = rest.lastIndexOf("\n```\n", limit);
+    const cbEnd2 = rest.lastIndexOf("\n```", limit);
+    if (cbEnd1 > limit / 2) {
+      cut = cbEnd1 + 4;
+    } else if (cbEnd2 > limit / 2) {
+      cut = cbEnd2 + 4;
+    }
+    if (cut <= 0 || cut > limit) {
+      const para = rest.lastIndexOf("\n\n", limit);
+      const line = rest.lastIndexOf("\n", limit);
+      const space = rest.lastIndexOf(" ", limit);
+      cut = para > limit / 2 ? para : line > limit / 2 ? line : space > 0 ? space : limit;
+    }
+    let part = rest.slice(0, cut);
+    rest = rest.slice(cut).replace(/^\n+/, "");
+    const backtickCount = (part.match(/```/g) || []).length;
+    if (backtickCount % 2 === 1) {
+      const langMatch = part.match(/```(\w+)/);
+      const lang = langMatch ? langMatch[1] : "";
+      const closing = "\n```";
+      if (part.length + closing.length > limit) {
+        const overflow = part.length + closing.length - limit;
+        const moved = part.slice(part.length - overflow);
+        part = part.slice(0, part.length - overflow) + closing;
+        rest = "```" + lang + "\n" + moved + rest;
+      } else {
+        part += closing;
+        rest = "```" + lang + "\n" + rest;
+      }
+    }
+    out.push(part);
+  }
+  if (rest) out.push(rest);
+  return out;
+}
+export {
+  chunk,
+  formatForDiscord,
+  safeCodeBlock
+};