@lynn123411/dsh-chat-translate 3.0.1 → 3.2.0

package/lib/index.js

@@ -999,168 +999,8 @@ function dshHomePath(...segments) {
   return join(resolveDshHome(), ...segments);
 }
 
-// src/server/pipeline/mask-tokens.ts
-var RANDOM_LETTERS = "abcdefghijklmnopqrstuvwxyz";
-function randomTokenId() {
-  let out = "";
-  for (let i = 0; i < 4; i++) {
-    out += RANDOM_LETTERS[Math.floor(Math.random() * RANDOM_LETTERS.length)];
-  }
-  return out;
-}
-function createMaskTokenFormat() {
-  const id = randomTokenId();
-  return {
-    id,
-    token: (index) => `\u27E6${id}${index}\u27E7`
-  };
-}
-var MASK_TOKEN_PATTERN_SOURCE = "\u27E6([a-z]{4})(\\d+)\u27E7";
-var MASK_TOKEN_PREFIX_PATTERN_SOURCE = "\u27E6\\s*([a-z]{4})(\\d+)";
-function matchMaskToken(text, start, id) {
-  const complete = new RegExp(`^(?:${MASK_TOKEN_PATTERN_SOURCE})`, "iu").exec(text.slice(start));
-  const truncated = complete ? null : new RegExp(`^(?:${MASK_TOKEN_PREFIX_PATTERN_SOURCE})`, "iu").exec(text.slice(start));
-  const anchored = complete ?? truncated;
-  if (!anchored) return null;
-  if (anchored[1].toLowerCase() !== id.toLowerCase()) return null;
-  const index = Number.parseInt(anchored[2], 10);
-  if (Number.isNaN(index)) return null;
-  return { index, length: anchored[0].length, truncated: complete === null };
-}
-function hasMaskResidue(text) {
-  if (!text) return false;
-  return new RegExp(MASK_TOKEN_PATTERN_SOURCE, "iu").test(text);
-}
-
-// src/server/pipeline/masking.ts
-var MAX_UNMASK_PASSES = 1e4;
-var ASCII_WORD = /[A-Za-z0-9_]/;
-var INSERTED_SPACE = /^ | $/;
-var MaskRestoreError = class extends Error {
-  expectedCount;
-  foundCount;
-  constructor(message, expectedCount, foundCount) {
-    super(message);
-    this.name = "MaskRestoreError";
-    this.expectedCount = expectedCount;
-    this.foundCount = foundCount;
-  }
-};
-var ContentMaskingPipeline = class {
-  mask(text) {
-    if (!text || typeof text !== "string") {
-      return {
-        maskedText: text,
-        unmask: (t) => t
-      };
-    }
-    const masks = [];
-    const inserted = [];
-    const format = createMaskTokenFormat();
-    const addFragment = (match, before, after, onPlace) => {
-      if (hasMaskResidue(match)) return match;
-      const index = masks.length;
-      masks.push(match);
-      const leading = before !== void 0 && ASCII_WORD.test(before);
-      const trailing = after !== void 0 && ASCII_WORD.test(after);
-      inserted.push({ leading, trailing });
-      onPlace?.(index);
-      return `${leading ? " " : ""}${format.token(index)}${trailing ? " " : ""}`;
-    };
-    const wrapRule = (input, pattern2, onPlace) => input.replace(pattern2, (...args) => {
-      const match = args[0];
-      const offset = args[args.length - 2];
-      const whole = args[args.length - 1];
-      return addFragment(match, whole[offset - 1], whole[offset + match.length], onPlace);
-    });
-    let processed = wrapRule(text, /(?:```|~~~)[\s\S]*?(?:```|~~~)/g);
-    processed = wrapRule(processed, /`[^`\n]+`/g);
-    processed = wrapRule(processed, /https?:\/\/[^\s)\];,;"'<>]+/g);
-    processed = wrapRule(
-      processed,
-      /(?:\/[\w.\-\\\/]+|(?<=[\w.\-])\.\.?[\\\/][\w.\-\\\/]+|(?<=^|[\s([{"'`])[a-zA-Z]:[\\\/][\w.\-\\\/]+|(?<![^\s([{"'`])\b(?:[\w.\-]+\/)+[\w.\-]+\.[a-zA-Z0-9]+\b|(?<![^\s([{"'`])\b[\w.\-]+\.(?:ts|tsx|js|jsx|json|ya?ml|md|py|go|rs|c|cpp|h|hpp|css|scss|html|sh|bash|mjs|cjs|toml|lock|log|env|svg|png|jpe?g|gif|tar|gz|zip|xml|sql)\b)/g
-    );
-    processed = wrapRule(
-      processed,
-      /(?<=^|[\s(\[{"'])((?:--[a-zA-Z0-9_\-]+(?:=[^\s"'<>]+)?)|(?:-[a-zA-Z0-9]+))(?=[\s)\]}",:;!?]|$)/g
-    );
-    const unmask = (translatedText) => {
-      if (!translatedText) return translatedText;
-      if (masks.length === 0) {
-        if (hasMaskResidue(translatedText)) {
-          throw new MaskRestoreError(
-            "translation carries a mask token while the source had none",
-            0,
-            0
-          );
-        }
-        return translatedText;
-      }
-      return replaceMaskTokens(translatedText, format.id, masks, inserted);
-    };
-    return {
-      maskedText: processed,
-      unmask
-    };
-  }
-};
-function replaceMaskTokens(text, id, masks, inserted) {
-  const complete = new RegExp(MASK_TOKEN_PATTERN_SOURCE, "giu");
-  const prefix = new RegExp(MASK_TOKEN_PREFIX_PATTERN_SOURCE, "giu");
-  const seen = /* @__PURE__ */ new Set();
-  let out = "";
-  let cursor = 0;
-  let passes = 0;
-  let whole = complete.exec(text);
-  let prefixCandidate = prefix.exec(text);
-  const nextStart = (wholeMatch, prefixMatch) => Math.min(
-    wholeMatch ? wholeMatch.index : Number.POSITIVE_INFINITY,
-    prefixMatch ? prefixMatch.index : Number.POSITIVE_INFINITY
-  );
-  let start = nextStart(whole, prefixCandidate);
-  while (start !== Number.POSITIVE_INFINITY && passes++ < MAX_UNMASK_PASSES) {
-    const isPrefix = prefixCandidate !== null && prefixCandidate.index === start && whole?.index !== start;
-    const raw = isPrefix ? prefixCandidate[0] : whole[0];
-    const match = matchMaskToken(text, start, id);
-    if (!match) {
-      out += text.slice(cursor, start) + raw;
-      cursor = start + raw.length;
-    } else {
-      if (match.index < 0 || match.index >= masks.length || seen.has(match.index)) {
-        throw new MaskRestoreError(
-          `translation does not reproduce every protected fragment (bad index ${match.index})`,
-          masks.length,
-          seen.size
-        );
-      }
-      seen.add(match.index);
-      const spacing = isPrefix ? void 0 : inserted?.[match.index];
-      let before = text.slice(cursor, start);
-      if (spacing?.leading) before = before.replace(INSERTED_SPACE, "");
-      if (spacing?.trailing) out = out.replace(INSERTED_SPACE, "");
-      out += before + masks[match.index];
-      cursor = start + raw.length;
-    }
-    while (whole && whole.index < cursor) whole = complete.exec(text);
-    while (prefixCandidate && prefixCandidate.index < cursor) prefixCandidate = prefix.exec(text);
-    start = nextStart(whole, prefixCandidate);
-  }
-  out += text.slice(cursor);
-  if (seen.size !== masks.length || hasMaskResidue(out)) {
-    throw new MaskRestoreError(
-      `translation does not reproduce every protected fragment (expected ${masks.length}, found ${seen.size})`,
-      masks.length,
-      seen.size
-    );
-  }
-  return out;
-}
-function isMaskLeak(translatedText) {
-  return hasMaskResidue(translatedText);
-}
-
 // src/server/prompt-revision.ts
-var PROMPT_REVISION = "r1";
+var PROMPT_REVISION = "r2";
 
 // src/server/cache.ts
 var TTL_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -1186,14 +1026,12 @@ var LruDiskCache = class {
     } catch {
     }
   }
-  /** Adopt loaded entries, dropping poisoned or malformed ones. */
+  /** Adopt loaded entries, dropping malformed ones. */
   loadEntries(raw) {
     for (const [k, entry] of Object.entries(raw)) {
-      if (entry && typeof entry === "object" && typeof entry.v === "string") {
-        const value = entry;
-        if (typeof value.t === "number" && Number.isFinite(value.t) && !isMaskLeak(value.v)) {
-          this.cache.set(k, value);
-        }
+      const value = entry;
+      if (value && typeof value === "object" && typeof value.v === "string" && typeof value.t === "number" && Number.isFinite(value.t)) {
+        this.cache.set(k, value);
       }
     }
   }
@@ -1204,19 +1042,11 @@ var LruDiskCache = class {
       this.cache.delete(key);
       return void 0;
     }
-    if (isMaskLeak(entry.v)) {
-      this.cache.delete(key);
-      return void 0;
-    }
     this.cache.delete(key);
     this.cache.set(key, entry);
     return entry.v;
   }
   set(key, value) {
-    if (isMaskLeak(value)) {
-      console.warn("[dsh-chat-translate] refusing to cache a translation with a leaked mask placeholder");
-      return;
-    }
     if (this.cache.has(key)) {
       this.cache.delete(key);
     } else if (this.cache.size >= this.maxEntries) {
@@ -1307,7 +1137,7 @@ function describeError(err) {
 // src/server/adapters/openai.ts
 var TARGET_LANGUAGE = "Simplified Chinese";
 function buildSystemPrompt(mode) {
-  const base = `You are a professional translator and editor. Rewrite the user's message as natural, idiomatic ${TARGET_LANGUAGE} the way a native writer would produce it. This applies to every passage, including passages already written in ${TARGET_LANGUAGE}: smooth out stiff or machine-translated phrasing while keeping the meaning, tone, proper names, numbers and technical terms unchanged. Never drop content and never add content. The message is Markdown that will be re-rendered as Markdown: translate the prose only, and keep every Markdown construct exactly as authored \u2014 headings, list markers, table pipes and cell order, quote markers, bold and emphasis runs, links, and inline code. Never add, remove, reorder, or nest Markdown syntax of your own. Output ONLY the resulting text \u2014 no explanations, no quotation marks, no extra words, no code fence around the whole answer. Some fragments of the message are opaque code between the bracket characters U+27E6 and U+27E7. Copy each such fragment into your output character-for-character, keeping its position in the sentence. Never invent such a fragment and never remove one.`;
+  const base = `You are a professional translator and editor. Rewrite the user's message as natural, idiomatic ${TARGET_LANGUAGE} the way a native writer would produce it. This applies to every passage, including passages already written in ${TARGET_LANGUAGE}: smooth out stiff or machine-translated phrasing while keeping the meaning, tone, proper names, numbers and technical terms unchanged. Never drop content and never add content. The message is Markdown that will be re-rendered as Markdown, and its structure is verified line by line: keep the same number of lines, the same indentation, the same heading, quote and list markers, the same table rows and pipe counts, and the same number of links. Inline code contents may stay as they are or be translated where that reads better. For a link [text](target), translate only the text and copy the target inside the parentheses character-for-character. Never add, remove, reorder or nest Markdown syntax of your own. Output ONLY the resulting text \u2014 no explanations, no quotation marks, no extra words, no code fence around the whole answer.`;
   if (mode === "plain") return base;
   return base + ` The message is a sequence of parts. Each part starts with its own line holding a marker: an index between the bracket characters U+27EA and U+27EB. For every part, output its marker line unchanged, then that part's rewrite on the following lines. Rewrite each part on its own, keep the parts in the original order, and never merge two parts into one answer.`;
 }
@@ -1368,6 +1198,13 @@ var OpenAiCompatibleAdapter = class {
 };
 
 // src/server/pipeline/blocks.ts
+function randomTokenId() {
+  let out = "";
+  for (let i = 0; i < 4; i++) {
+    out += "abcdefghijklmnopqrstuvwxyz"[Math.floor(Math.random() * 26)];
+  }
+  return out;
+}
 var REPLY_MAX_INPUT_TOKENS = 4096;
 var REPLY_MAX_OUTPUT_TOKENS = 8192;
 var CJK_CHAR = /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\u3000-\u303f\uff00-\uffef]/;
@@ -1486,31 +1323,246 @@ function splitBatchTranslation(translated, format, count) {
   }
   return parts;
 }
-function hasBatchResidue(text) {
-  return new RegExp(BATCH_TOKEN_PATTERN_SOURCE, "u").test(text);
+function stripBatchMarkers(text) {
+  return text.replace(new RegExp(BATCH_TOKEN_PATTERN_SOURCE, "gu"), "");
+}
+
+// src/server/pipeline/segments.ts
+var FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+var FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})[ \t]*\r?$/;
+function closesFence(open, line) {
+  const close = FENCE_CLOSE.exec(line);
+  if (!close) return false;
+  const marker = close[1] ?? "";
+  return marker[0] === open[0] && marker.length >= open.length;
+}
+function splitMarkdownSegments(text) {
+  const segments = [];
+  const lines = text.split("\n");
+  let start = 0;
+  let offset = 0;
+  let fence = null;
+  let kind = "prose";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const last = i === lines.length - 1;
+    const lineEnd = offset + line.length + (last ? 0 : 1);
+    if (fence === null) {
+      const open = FENCE_OPEN.exec(line);
+      if (open) {
+        if (offset > start) segments.push({ kind: "prose", text: text.slice(start, offset) });
+        start = offset;
+        kind = "code";
+        fence = open[1] ?? "```";
+      }
+    } else if (closesFence(fence, line)) {
+      segments.push({ kind: "code", text: text.slice(start, lineEnd) });
+      start = lineEnd;
+      kind = "prose";
+      fence = null;
+    }
+    offset = lineEnd;
+  }
+  if (text.length > start) segments.push({ kind, text: text.slice(start) });
+  return segments;
+}
+var LINE_SHAPE_PREFIX = /^[ \t]*(#{1,6}[ \t]|>+[ \t]?|[-*+][ \t]|\d{1,3}[.)][ \t])/;
+var LINK_SPAN = /\[[^\]]*\]\(((?:[^()]|\([^()]*\))*)\)/g;
+var LINK_DEF_LINE = /^( {0,3}\[[^\]]+\]:[ \t]*)(\S+)([ \t]*\r?)$/;
+function markerClass(marker) {
+  if (marker === "") return "";
+  const head = marker[0];
+  if (head === "#") return "h";
+  if (head === ">") return "q";
+  if (head === "-" || head === "*" || head === "+") return "l";
+  return "n";
+}
+function lineSignature(line) {
+  const marker = LINE_SHAPE_PREFIX.exec(line)?.[1]?.trim() ?? "";
+  const cls = markerClass(marker);
+  const indent = cls === "" ? (/^[ \t]*/.exec(line) ?? [""])[0].replace(/\t/g, "  ").length : "i";
+  const pipes = (line.match(/\|/g) ?? []).length;
+  const links = (line.match(LINK_SPAN) ?? []).length + (LINK_DEF_LINE.test(line) ? 1 : 0);
+  return `${indent}|${cls}|${pipes}|${links}`;
+}
+function isBlankLine(line) {
+  return line.trim() === "";
+}
+function indentWidth(line) {
+  return (/^[ \t]*/.exec(line) ?? [""])[0].replace(/\t/g, "  ").length;
+}
+function isStructuralLine(line) {
+  if (isBlankLine(line)) return false;
+  return LINE_SHAPE_PREFIX.test(line) || line.includes("|") || LINK_DEF_LINE.test(line) || indentWidth(line) > 3;
+}
+function paragraphBlocks(text) {
+  const blocks = [];
+  let cur = null;
+  for (const line of text.split("\n")) {
+    if (isBlankLine(line)) {
+      if (cur !== null) blocks.push(cur);
+      cur = null;
+    } else {
+      (cur ??= []).push(line);
+    }
+  }
+  if (cur !== null) blocks.push(cur);
+  return blocks;
+}
+function blockLinks(block) {
+  let n = 0;
+  for (const line of block) {
+    n += (line.match(LINK_SPAN) ?? []).length + (LINK_DEF_LINE.test(line) ? 1 : 0);
+  }
+  return n;
+}
+function spliceLineShape(want, got) {
+  const w = LINE_SHAPE_PREFIX.exec(want);
+  if (w === null) return got;
+  const g = LINE_SHAPE_PREFIX.exec(got);
+  if (g === null || markerClass((w[1] ?? "").trim()) !== markerClass((g[1] ?? "").trim())) {
+    return got;
+  }
+  return `${w[0]}${got.slice(g[0].length)}`;
+}
+function repairShape(original, translated) {
+  const wantLines = original.split("\n");
+  const gotLines = translated.split("\n");
+  const wantBlocks = paragraphBlocks(original);
+  let gotBlocks = paragraphBlocks(translated);
+  if (wantBlocks.length !== gotBlocks.length) {
+    const wantFilled = wantLines.filter((line) => !isBlankLine(line));
+    const gotFilled = gotLines.filter((line) => !isBlankLine(line));
+    if (wantFilled.length !== gotFilled.length) {
+      return { text: null, error: `line count changed (${wantLines.length} -> ${gotLines.length})` };
+    }
+    for (let index = 0; index < wantFilled.length; index++) {
+      const sw = lineSignature(wantFilled[index] ?? "");
+      const sg = lineSignature(gotFilled[index] ?? "");
+      if (sw !== sg) {
+        return { text: null, error: `structure changed at line ${index + 1} (${sw} -> ${sg})` };
+      }
+    }
+    let cursor = 0;
+    gotBlocks = wantBlocks.map((block) => block.map(() => gotFilled[cursor++] ?? ""));
+  }
+  const repaired = [];
+  let hint = 0;
+  for (let index = 0; index < wantBlocks.length; index++) {
+    const wb = wantBlocks[index];
+    const gb = gotBlocks[index] ?? [];
+    while (hint < wantLines.length && wantLines[hint] !== wb[0]) hint++;
+    const start = hint + 1;
+    const wStruct = wb.filter(isStructuralLine);
+    const gStruct = gb.filter(isStructuralLine);
+    if (wStruct.length !== gStruct.length) {
+      return { text: null, error: `structure changed at line ${start} (markers ${wStruct.length} -> ${gStruct.length})` };
+    }
+    if (isStructuralLine(wb[0] ?? "") !== isStructuralLine(gb[0] ?? "")) {
+      return { text: null, error: `structure changed at line ${start} (block start swapped)` };
+    }
+    if (blockLinks(wb) !== blockLinks(gb)) {
+      return { text: null, error: `structure changed at line ${start} (links ${blockLinks(wb)} -> ${blockLinks(gb)})` };
+    }
+    for (let k = 0; k < wStruct.length; k++) {
+      const sw = lineSignature(wStruct[k] ?? "");
+      const sg = lineSignature(gStruct[k] ?? "");
+      if (sw !== sg) {
+        return { text: null, error: `structure changed at line ${start} (${sw} -> ${sg})` };
+      }
+    }
+    let cursor = 0;
+    repaired.push(
+      gb.map((line) => {
+        if (!isStructuralLine(line)) return line;
+        return spliceLineShape(wStruct[cursor++] ?? line, line);
+      })
+    );
+    hint += wb.length;
+  }
+  const out = [];
+  let bi = 0;
+  let inBlock = false;
+  for (const line of wantLines) {
+    if (isBlankLine(line)) {
+      inBlock = false;
+      out.push(line);
+      continue;
+    }
+    if (!inBlock) {
+      out.push(...repaired[bi++] ?? [line]);
+      inBlock = true;
+    }
+  }
+  return { text: out.join("\n"), error: null };
+}
+function restoreLinkTargets(original, translated) {
+  const urls = [];
+  for (const match of original.matchAll(LINK_SPAN)) urls.push(match[1] ?? "");
+  let out = translated;
+  if (urls.length > 0) {
+    let cursor = 0;
+    out = out.replace(LINK_SPAN, (span) => {
+      const open = span.indexOf("(", span.lastIndexOf("]"));
+      const close = span.lastIndexOf(")");
+      const url = urls[cursor++] ?? "";
+      return `${span.slice(0, open + 1)}${url}${span.slice(close)}`;
+    });
+  }
+  const defs = [];
+  for (const line of original.split("\n")) {
+    const def = LINK_DEF_LINE.exec(line);
+    if (def) defs.push(def[2] ?? "");
+  }
+  if (defs.length > 0) {
+    let cursor = 0;
+    out = out.split("\n").map((line) => {
+      const def = LINK_DEF_LINE.exec(line);
+      if (!def) return line;
+      return `${def[1] ?? ""}${defs[cursor++] ?? def[2] ?? ""}${def[3] ?? ""}`;
+    }).join("\n");
+  }
+  return out;
+}
+function linkCountsMatch(a, b) {
+  return blockLinks(a.split("\n")) === blockLinks(b.split("\n"));
 }
 
 // src/server/dispatcher.ts
 var CHANNEL_ID = "openai";
-var ContentRejectedError = class extends Error {
-};
 function replyPieceKey(piece) {
   return `${piece.block}:${piece.index}`;
 }
+function recordLedgerFailure(ledger, keys, detail) {
+  for (const key of keys) {
+    if (!ledger.has(key)) ledger.set(key, detail);
+  }
+}
+function blockFailureDetail(ledger, block, missing) {
+  for (const index of missing) {
+    const detail = ledger.get(replyPieceKey({ block, index }));
+    if (detail !== void 0) return detail;
+  }
+  return "no translation came back";
+}
+function stripEdges(chunk) {
+  const head = /^[ \t\r\n]*/.exec(chunk)[0];
+  if (head.length >= chunk.length) return null;
+  const body = chunk.slice(head.length);
+  const tail = /[ \t\r\n]*$/.exec(body)[0];
+  const core = body.slice(0, body.length - tail.length);
+  return core === "" ? null : { core, head, tail };
+}
 var TranslationDispatcher = class {
   configManager;
   cache;
-  credentials;
-  masking = new ContentMaskingPipeline();
   adapters = /* @__PURE__ */ new Map();
-  circuitStates = /* @__PURE__ */ new Map();
   /** 正文请求的串行队列尾，保证同时最多一个在途请求。 */
   replyTail = Promise.resolve();
   constructor(configManager, cache, credentials) {
     this.configManager = configManager;
     this.cache = cache;
-    this.credentials = credentials ?? { getApiKey: () => "" };
-    this.registerAdapter(new OpenAiCompatibleAdapter(this.credentials));
+    this.registerAdapter(new OpenAiCompatibleAdapter(credentials ?? { getApiKey: () => "" }));
   }
   registerAdapter(adapter) {
     this.adapters.set(adapter.id, adapter);
@@ -1518,81 +1570,97 @@ var TranslationDispatcher = class {
   /**
    * 翻译回答正文的块：本次唯一的翻译入口。
    *
-   * 每个块先按输入上限切成片段，再各自掩码、相邻片段打包成一个请求；整批失败
-   * 时退回逐片段单发。调用方传进来的每个块要么整块译出、要么整块保持原文：
-   * 任一片段缺失（含掩码还原不通过）都让该块作废，避免半中半英的段落。
+   * 每个块先按 markdown 结构切成段：代码围栏与纯空白段**逐字保留、永不送
+   * 模型**；散文段再按输入上限切片、各自成片段。相邻片段打包成一个请求；整批
+   * 失败时退回逐片段单发。每个片段的译文过 `repairShape`（段落块对齐 + 前缀
+   * 修回 + 空行重排）并通过链接目标回填才算修好。
+   *
+   * **形状问题不否决内容**：修不好的片段自动重掷一次；再修不好就照收模型的
+   * 译文（链接数不等时不回填，其余原样）——原文一键可回，可读的译文优先于
+   * 一根红线。失败只剩通道伤一种：超时、断流、空返回，红实线 + 悬停报细节，
+   * 救活由用户的点击发起。
    *
-   * 客户端按 2048 估算 token 分块，所以一个 markdown 块可能跨多次调用；每次
-   * 调用都独立决定成败，不会出现「前一段已挂译文、后一段失败」的半截结果。
+   * 调用方传进来的每个块要么整块译出、要么整块保持原文：任一片段缺失都让该块
+   * 作废，避免半中半英的段落；失败块带 `detail` 一句技术细节。每行只跑首跑
+   * 一次，通道恢复后由点击救活。
+   *
+   * 客户端按与宿主同源的 4096 估算 token 切批，所以一个 markdown 块可能跨多次
+   * 调用；每次调用都独立决定成败，不会出现「前一段已挂译文、后一段失败」的
+   * 半截结果。
    */
   async translateReplyBlocks(blocks) {
     const results = blocks.map((original) => ({
       original,
       translated: original,
       ok: false,
-      cached: false,
-      channel: "none"
+      cached: false
     }));
     const config = this.configManager.getConfig();
     if (!config.enabled) return results;
     const adapter = this.adapters.get(CHANNEL_ID);
     if (!adapter || !adapter.isAvailable(config)) return results;
-    if (this.isCircuitOpen(CHANNEL_ID)) return results;
-    try {
-      return await this.serveReplyBlocks(blocks, results, adapter, config);
-    } finally {
-      const state = this.circuitStates.get(CHANNEL_ID);
-      if (state) state.probeInFlight = false;
-    }
+    return this.serveReplyBlocks(blocks, results, adapter, config);
   }
-  /** 熔断授予之后的正文执行段：切块、打包、请求、拼装。 */
+  /** 通道可用之后的正文执行段：切段、打包、请求、拼装。 */
   async serveReplyBlocks(blocks, results, adapter, config) {
     const pieces = [];
+    const partsByBlock = /* @__PURE__ */ new Map();
     for (let block = 0; block < blocks.length; block++) {
-      const text = (blocks[block] ?? "").trim();
-      if (!text) continue;
-      const cached = this.cache.get(text.toLowerCase());
+      const raw = blocks[block] ?? "";
+      if (raw.trim() === "") continue;
+      const cached = this.cache.get(raw.trim().toLowerCase());
       if (cached) {
-        results[block] = {
-          original: blocks[block],
-          translated: cached,
-          ok: true,
-          cached: true,
-          channel: "cache"
-        };
+        results[block] = { original: raw, translated: cached, ok: true, cached: true };
         continue;
       }
-      for (const [index, part] of splitOversizedBlock(text).entries()) {
-        const mask = this.masking.mask(part);
-        pieces.push({
-          block,
-          index,
-          text: mask.maskedText,
-          mask
-        });
+      const parts = [];
+      let count = 0;
+      for (const segment of splitMarkdownSegments(raw)) {
+        const edges = segment.kind === "code" ? null : stripEdges(segment.text);
+        if (edges === null) {
+          parts.push({ verbatim: segment.text });
+          continue;
+        }
+        for (const chunk of splitOversizedBlock(segment.text)) {
+          const pieceEdges = stripEdges(chunk);
+          if (pieceEdges === null) {
+            parts.push({ verbatim: chunk });
+            continue;
+          }
+          parts.push({ piece: count });
+          pieces.push({ block, index: count, text: pieceEdges.core, head: pieceEdges.head, tail: pieceEdges.tail });
+          count += 1;
+        }
       }
+      partsByBlock.set(block, parts);
     }
+    const ledger = /* @__PURE__ */ new Map();
     const translated = /* @__PURE__ */ new Map();
     for (const batch of packPieces(pieces)) {
       const outcome = await this.runReplySerial(
-        () => this.translateReplyBatch(adapter, batch, config)
+        () => this.translateReplyBatch(adapter, batch, config, ledger)
       );
       for (const [key, value] of outcome) translated.set(key, value);
     }
-    const totals = /* @__PURE__ */ new Map();
-    for (const piece of pieces) totals.set(piece.block, (totals.get(piece.block) ?? 0) + 1);
-    for (const [block, total] of totals) {
+    for (const block of partsByBlock.keys()) {
       const parts = [];
-      let complete = true;
-      for (let index = 0; index < total; index++) {
-        const part = translated.get(`${block}:${index}`);
-        if (part === void 0) {
-          complete = false;
-          break;
+      const missing = [];
+      for (const part of partsByBlock.get(block) ?? []) {
+        if ("verbatim" in part) {
+          parts.push(part.verbatim);
+          continue;
         }
-        parts.push(part);
+        const value = translated.get(replyPieceKey({ block, index: part.piece }));
+        if (value === void 0) {
+          missing.push(part.piece);
+          continue;
+        }
+        parts.push(value);
+      }
+      if (missing.length > 0) {
+        results[block].detail = blockFailureDetail(ledger, block, missing);
+        continue;
       }
-      if (!complete) continue;
       const original = blocks[block];
       const finalText = parts.join("");
       this.cache.set(original.trim().toLowerCase(), finalText);
@@ -1600,57 +1668,80 @@ var TranslationDispatcher = class {
         original,
         translated: finalText,
         ok: true,
-        cached: false,
-        channel: CHANNEL_ID
+        cached: false
       };
     }
     return results;
   }
   /**
-   * 一整批一次请求；失败则该批逐片段单发重试一次，仍失败的片段直接放弃
-   * （保留原文），不在界面上留提示。失败的片段不进缓存，因此下一次滚回视口
-   * 时会自然重试。
+   * 一整批一次请求；批内修不好的片段与整批的失败都退回逐片段单发。单发仍
+   * 修不好的**照收**（见 {@link translateReplyBlocks}）——只有通道伤才让片段
+   * 缺失，失败的片段不进缓存。
    *
-   * 熔断记账按「批」算：一次批请求失败记一次，逐片段重试失败再各记一次。
-   * 内容级拒收除外：响应都正常回来了，通道是活的——拒收记一次成功，
-   * 坏内容只作废坏内容自己，不把其他行挡在冷却期外。
+   * 每次通道失败都记进片段账本（{@link FailureLedger}）：批请求的失败摊到
+   * 批内每个片段，单发的失败只记该片段；块级细节由缺失片段的账本合成。
    */
-  async translateReplyBatch(adapter, batch, config) {
+  async translateReplyBatch(adapter, batch, config, ledger) {
+    const out = /* @__PURE__ */ new Map();
+    const stragglers = [];
     try {
-      const outcome = await this.requestReplyBatch(adapter, batch, config);
-      this.recordSuccess(CHANNEL_ID);
-      return outcome;
+      const answers = await this.fetchReplyAnswers(adapter, batch, config);
+      batch.forEach((piece, index) => {
+        const answer = answers[index] ?? "";
+        const repair = repairShape(piece.text, answer);
+        if (repair.text !== null) {
+          out.set(replyPieceKey(piece), this.assemble(piece, repair.text, true));
+        } else {
+          stragglers.push(piece);
+        }
+      });
     } catch (err) {
-      this.accountBatch(err);
+      recordLedgerFailure(ledger, batch.map((piece) => replyPieceKey(piece)), describeError(err));
       console.warn(
         `[dsh-chat-translate] reply batch of ${batch.length} failed, retrying per block: ${describeError(err)}`
       );
+      stragglers.push(...batch);
     }
-    const out = /* @__PURE__ */ new Map();
-    for (const piece of batch) {
-      try {
-        for (const [key, value] of await this.requestReplyBatch(adapter, [piece], config)) {
-          out.set(key, value);
+    for (const piece of stragglers) {
+      const key = replyPieceKey(piece);
+      if (out.has(key)) continue;
+      let answer = null;
+      for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+          answer = (await this.fetchReplyAnswers(adapter, [piece], config))[0] ?? "";
+        } catch (err) {
+          if (answer === null) {
+            recordLedgerFailure(ledger, [key], describeError(err));
+            console.warn(
+              `[dsh-chat-translate] reply block ${piece.block} #${piece.index} failed, keeping the original: ${describeError(err)}`
+            );
+          }
+          break;
         }
-      } catch (err) {
-        this.accountBatch(err);
-        console.warn(
-          `[dsh-chat-translate] reply block ${piece.block} #${piece.index} failed, keeping the original: ${describeError(err)}`
-        );
+        if (repairShape(piece.text, answer).text !== null) break;
+      }
+      if (answer === null) continue;
+      const repair = repairShape(piece.text, answer);
+      if (repair.text !== null) {
+        out.set(key, this.assemble(piece, repair.text, true));
+        continue;
       }
+      console.warn(
+        `[dsh-chat-translate] reply block ${piece.block} #${piece.index} shape kept as the model wrote it: ${repair.error}`
+      );
+      out.set(key, this.assemble(piece, answer, linkCountsMatch(piece.text, answer)));
     }
     return out;
   }
-  /** 失败记账的分类：传输故障计数，内容拒收证明通道活着。 */
-  accountBatch(err) {
-    if (err instanceof ContentRejectedError) {
-      this.recordSuccess(CHANNEL_ID);
-    } else {
-      this.recordFailure(CHANNEL_ID);
-    }
+  /** 片段的最终拼装：头尾空白 + （可选）链接回填 + 译文。 */
+  assemble(piece, text, restoreLinks) {
+    return piece.head + (restoreLinks ? restoreLinkTargets(piece.text, text) : text) + piece.tail;
   }
-  /** 发出一次正文请求并把结果还原成每个片段的最终译文。 */
-  async requestReplyBatch(adapter, batch, config) {
+  /**
+   * 发出一次正文请求，返回逐片段的裸答案（打包标记已剥除、首尾已 trim）。
+   * 空返回与打包拆不回都按通道失败抛出——形状对不对在这里不算败因。
+   */
+  async fetchReplyAnswers(adapter, batch, config) {
     const timeout = config.aiTimeoutMs || 6e5;
     const abortCtrl = new AbortController();
     const timer = setTimeout(() => abortCtrl.abort(), timeout);
@@ -1666,41 +1757,33 @@ var TranslationDispatcher = class {
       } else {
         const format = createBatchFormat();
         const answer = await adapter.translate(
-          buildBatchPayload(batch.map((piece) => piece.text), format),
+          buildBatchPayload(
+            batch.map((piece) => piece.text),
+            format
+          ),
           abortCtrl.signal,
           config,
           { maxTokens: REPLY_MAX_OUTPUT_TOKENS, mode: "blocks" }
         );
         const parts = splitBatchTranslation(answer, format, batch.length);
         if (parts === null) {
-          throw new ContentRejectedError("reply block markers did not survive the translation");
+          throw new Error("batch markers did not survive the answer");
         }
         answers = parts;
       }
+    } catch (err) {
+      if (abortCtrl.signal.aborted) {
+        throw new Error(`channel timed out after ${timeout}ms`);
+      }
+      throw err;
     } finally {
       clearTimeout(timer);
     }
-    const out = /* @__PURE__ */ new Map();
-    batch.forEach((piece, index) => {
-      const answer = (answers[index] ?? "").trim();
-      if (!answer) {
-        throw new Error(`reply block ${piece.block} #${piece.index} came back empty`);
-      }
-      if (hasBatchResidue(answer)) {
-        throw new ContentRejectedError("reply translation left a block marker behind");
-      }
-      let finalText;
-      try {
-        finalText = piece.mask.unmask(answer);
-      } catch (unmaskErr) {
-        throw new ContentRejectedError(describeError(unmaskErr));
-      }
-      if (hasMaskResidue(finalText)) {
-        throw new ContentRejectedError("reply translation left a mask placeholder behind");
-      }
-      out.set(replyPieceKey(piece), finalText);
-    });
-    return out;
+    const stripped = answers.map((answer) => stripBatchMarkers(answer).trim());
+    if (stripped.some((answer) => answer === "")) {
+      throw new Error("translation came back empty");
+    }
+    return stripped;
   }
   /** 串行执行器：同时最多一个在途请求。 */
   runReplySerial(task) {
@@ -1713,10 +1796,7 @@ var TranslationDispatcher = class {
   }
   /**
    * 通道探针：设置面板的「测试 AI 通道」按钮走这里。探测文本用一句英文正文，
-   * 与真实请求同形。
-   *
-   * 探针是用户主动发起的连通性检查，因此不写也不读熔断账本：连点几次测试
-   * 不该把正文翻译挡在冷却期外，正文的失败也不该让按钮变哑。
+   * 与真实请求同形；它一次请求都不写正文账本，正文的成败也不影响按钮。
    */
   async testChannel(channelId) {
     const adapter = this.adapters.get(channelId);
@@ -1748,52 +1828,6 @@ var TranslationDispatcher = class {
       return { ok: false, latencyMs: Date.now() - start, error: describeError(err) };
     }
   }
-  isCircuitOpen(channelId) {
-    let state = this.circuitStates.get(channelId);
-    if (!state) return false;
-    if (state.state === "open") {
-      if (Date.now() >= state.openUntil) {
-        state.state = "half-open";
-        state.probeInFlight = true;
-        return false;
-      }
-      return true;
-    }
-    if (state.state === "half-open") {
-      if (state.probeInFlight) return true;
-      state.probeInFlight = true;
-      return false;
-    }
-    return false;
-  }
-  recordSuccess(channelId) {
-    const state = this.circuitStates.get(channelId);
-    if (state) {
-      state.state = "closed";
-      state.failureCount = 0;
-      state.openUntil = 0;
-      state.probeInFlight = false;
-    }
-  }
-  recordFailure(channelId) {
-    let state = this.circuitStates.get(channelId);
-    if (!state) {
-      state = { state: "closed", failureCount: 0, openUntil: 0, probeInFlight: false };
-      this.circuitStates.set(channelId, state);
-    }
-    if (state.state === "half-open") {
-      state.state = "open";
-      state.failureCount = 3;
-      state.openUntil = Date.now() + 3e4;
-      state.probeInFlight = false;
-      return;
-    }
-    state.failureCount++;
-    if (state.failureCount >= 3) {
-      state.state = "open";
-      state.openUntil = Date.now() + 3e4;
-    }
-  }
 };
 
 // src/server/router.ts