@ladderkitlab/hub-kb 0.1.0

package/dist/main.js

@@ -0,0 +1,1683 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import { fileURLToPath } from "node:url";
+
+// src/stdio.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+
+// ../runtime-core/src/index.ts
+function makeTableT2s(table) {
+  return (s) => {
+    let out = "";
+    for (const ch of s) out += table[ch] ?? ch;
+    return out;
+  };
+}
+function normalize(text, cfg, t2s) {
+  let t = text;
+  if (cfg.normalize.fullwidth_to_halfwidth) t = t.replace(/[！-～]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 65248)).replace(/　/g, " ");
+  if (cfg.normalize.lowercase) t = t.toLowerCase();
+  if (cfg.normalize.traditional_to_simplified) t = t2s(t);
+  if (cfg.normalize.strip_version_numbers) t = t.replace(/\d+(\.\d+)+/g, "");
+  return t.replace(/\s+/g, " ").trim();
+}
+var cjkRuns = (n) => n.split(/[^一-鿿]+/).filter(Boolean);
+function tokens(text, cfg, t2s) {
+  return tokenize(normalize(text, cfg, t2s), cfg);
+}
+function tokenize(n, cfg) {
+  const out = /* @__PURE__ */ new Set();
+  for (const w of n.match(/[a-z0-9_]+/g) ?? []) out.add(w);
+  const k = cfg.tokenizer.cjk_ngram;
+  for (const run2 of cjkRuns(n)) {
+    for (let i = 0; i + k <= run2.length; i++) out.add(run2.slice(i, i + k));
+    if (run2.length < k) out.add(run2);
+  }
+  return [...out];
+}
+var QUESTION_WORDS = ["\u4EC0\u4E48\u610F\u601D", "\u4E3A\u4EC0\u4E48", "\u600E\u4E48\u6837", "\u4EC0\u4E48\u6837", "\u600E\u4E48", "\u4EC0\u4E48", "\u600E\u6837", "\u4E3A\u5565", "\u5982\u4F55", "\u662F\u5426", "\u54EA\u4E9B", "\u54EA\u4E2A", "\u54EA\u91CC", "\u5417", "\u5462", "\u5565", "\u548B"];
+var UNKNOWN_TOKEN_WEIGHT = 0.5;
+function questionTokens(n, cfg) {
+  const out = /* @__PURE__ */ new Set();
+  const k = cfg.tokenizer.cjk_ngram;
+  for (const run2 of cjkRuns(n)) {
+    const mark = new Array(run2.length).fill(false);
+    for (const w of QUESTION_WORDS) for (let i = run2.indexOf(w); i >= 0; i = run2.indexOf(w, i + 1)) mark.fill(true, i, i + w.length);
+    for (let i = 0; i + k <= run2.length; i++) if (mark.slice(i, i + k).some(Boolean)) out.add(run2.slice(i, i + k));
+    if (run2.length < k && mark.some(Boolean)) out.add(run2);
+  }
+  return out;
+}
+function dimMatchAny(d, vs, cfg) {
+  if (!vs?.some(Boolean)) return cfg.filters.applicability_context_missing === "drop" && d !== "any" ? null : 1;
+  if (d === "any") return 1;
+  if (d === "unknown") return cfg.filters.unknown_applicability_multiplier;
+  return vs.some((v) => v && d.includes(v)) ? 1 : null;
+}
+var dimMatch = (d, v, cfg) => dimMatchAny(d, v === void 0 ? void 0 : [v], cfg);
+function intersect(sets) {
+  const common = sets.length ? sets[0].filter((v) => sets.every((s) => s.includes(v))) : [];
+  return common.length ? common : void 0;
+}
+var MAX_SEARCH_RESULTS = 5;
+function osMentions(n, terms, groups) {
+  const os = /* @__PURE__ */ new Set();
+  const mentions = [];
+  const byWord = /* @__PURE__ */ new Map();
+  for (const [id, words] of Object.entries(terms ?? {})) for (const w of words) byWord.set(w, [id]);
+  for (const g of Object.values(groups ?? {})) for (const w of g.aliases) byWord.set(w, g.members);
+  if (byWord.size === 0) return { text: n, os, mentions };
+  const alt = [...byWord.keys()].sort((a, b) => b.length - a.length).join("|");
+  const text = n.replace(new RegExp(`(?<![a-z0-9_])(${alt})(?:\\s*\\d+)?(?![a-z0-9_])`, "g"), (m, w) => {
+    const set = byWord.get(w);
+    mentions.push(set);
+    if (set.length === 1) os.add(set[0]);
+    return /^[a-z0-9 ]+$/.test(w) ? " " : m === w ? w : `${w} `;
+  });
+  return { text, os, mentions };
+}
+var MAX_GAP = 12;
+var MIN_FIXED = 3;
+var wordSeq = (n) => n.match(/[a-z0-9_]+|[一-鿿]+/g) ?? [];
+var segAt = (q, seg, i) => seg.every((w, j) => q[i + j] === w);
+function matchSegments(q, segs, from, first) {
+  if (segs.length === 0) return true;
+  const [seg, ...rest2] = segs;
+  const last = first ? q.length - seg.length : Math.min(q.length - seg.length, from + MAX_GAP);
+  for (let i = from; i <= last; i++) if (segAt(q, seg, i) && matchSegments(q, rest2, i + seg.length, false)) return true;
+  return false;
+}
+var fixedWords = (p) => p.segments.reduce((a, s) => a + s.length, 0);
+function errorLineHits(patterns, n) {
+  const q = wordSeq(n);
+  return (patterns ?? []).filter((p) => fixedWords(p) >= MIN_FIXED && matchSegments(q, p.segments, 0, true)).sort((a, b) => fixedWords(b) - fixedWords(a));
+}
+function explicitContext(ctx) {
+  return { client: ctx.client?.trim() ? ctx.client : void 0, os: ctx.os?.trim() ? ctx.os : void 0 };
+}
+function search(index, query, ctx, t2s) {
+  const cfg = index.config;
+  const normalized = normalize(query, cfg, t2s);
+  const mentioned = osMentions(normalized, index.os_terms, index.os_groups);
+  const clients = osMentions(mentioned.text, index.client_terms);
+  const q = tokenize(clients.text, cfg);
+  if (q.length === 0) return { results: [], abstained: true };
+  const { os: ctxOs, client: ctxClient } = explicitContext(ctx);
+  const os = ctxOs !== void 0 ? [ctxOs] : intersect(mentioned.mentions);
+  const client = ctxClient ?? (clients.os.size === 1 ? [...clients.os][0] : void 0);
+  const hits = errorLineHits(index.error_patterns, normalized).filter((h) => dimMatch(h.client ?? "any", client, cfg) !== null && dimMatchAny(h.os ?? "any", os, cfg) !== null);
+  if (hits.length) {
+    const byId = new Map(index.docs.map((d) => [d.id, d]));
+    const lines = [];
+    const add = (id) => {
+      const d = byId.get(id);
+      if (!d || lines.some((r) => r.id === id)) return;
+      const mc = dimMatch(d.client, client, cfg), mo = dimMatchAny(d.os, os, cfg);
+      if (mc === null || mo === null) return;
+      lines.push({ id, type: d.type, score: (cfg.weights.error_messages ?? 0) * mc * mo * (d.stale ? cfg.freshness.stale_multiplier : 1) });
+    };
+    for (const h of hits) {
+      if (h.maps_to !== "unmapped") add(h.maps_to);
+      add(h.owner);
+    }
+    if (lines.length) {
+      const results2 = lines.slice(0, Math.min(cfg.max_results, MAX_SEARCH_RESULTS));
+      const abstained2 = results2[0].score < cfg.abstain.min_score;
+      return { results: abstained2 ? [] : results2, abstained: abstained2 };
+    }
+  }
+  const latin = q.filter((t) => /^[a-z0-9_]+$/.test(t));
+  const question = questionTokens(clients.text, cfg);
+  const candidates = index.docs.flatMap((d) => {
+    const mc = dimMatch(d.client, client, cfg), mo = dimMatchAny(d.os, os, cfg);
+    return mc === null || mo === null ? [] : [{ d, mc, mo, tokens: new Set(Object.entries(d.fields).filter(([f]) => cfg.weights[f]).flatMap(([, toks]) => toks)) }];
+  });
+  const n = candidates.length;
+  const weigh = (has) => new Map(q.map((t) => {
+    const df = candidates.filter((c) => c.tokens.has(t)).length;
+    const shared = candidates.filter((c) => has(c, t)).length;
+    return [t, question.has(t) || n > 1 && shared === n ? 0 : df === 0 ? UNKNOWN_TOKEN_WEIGHT : 1];
+  }));
+  let weight = weigh((c, t) => c.tokens.has(t));
+  if (q.every((t) => weight.get(t) === 0 || !candidates.some((c) => c.tokens.has(t)))) {
+    const strong = new Map(candidates.map((c) => [c, new Set(Object.entries(c.d.fields).filter(([f]) => f !== "body" && cfg.weights[f]).flatMap(([, toks]) => toks))]));
+    weight = weigh((c, t) => strong.get(c).has(t));
+  }
+  const total = q.reduce((a, t) => a + weight.get(t), 0);
+  if (total === 0) return { results: [], abstained: true };
+  const scored = [];
+  for (const { d, mc, mo } of candidates) {
+    const matched = /* @__PURE__ */ new Set();
+    let s = 0;
+    for (const [field2, toks] of Object.entries(d.fields)) {
+      const w = cfg.weights[field2] ?? 0;
+      if (!w) continue;
+      const set = new Set(toks);
+      let hit = 0;
+      for (const t of q) if (set.has(t)) {
+        hit++;
+        matched.add(t);
+      }
+      s += w * (hit / q.length);
+    }
+    if ([...matched].reduce((a, t) => a + weight.get(t), 0) / total < cfg.abstain.min_token_coverage) continue;
+    if (latin.some((t) => !matched.has(t))) continue;
+    s *= mc * mo;
+    if (d.stale) s *= cfg.freshness.stale_multiplier;
+    if (s > 0) scored.push({ id: d.id, type: d.type, score: s, lv: d.last_verified });
+  }
+  scored.sort((a, b) => b.score - a.score || (b.lv > a.lv ? 1 : b.lv < a.lv ? -1 : 0) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  const results = scored.slice(0, Math.min(cfg.max_results, MAX_SEARCH_RESULTS)).map(({ id, type, score }) => ({ id, type, score }));
+  const abstained = results.length === 0 || results[0].score < cfg.abstain.min_score;
+  return { results: abstained ? [] : results, abstained };
+}
+
+// ../redact/context.ts
+var CONFIG_ROOT_KEYS = ["proxies", "proxy-providers", "outbounds", "inbounds", "rules"];
+var ROOTS = new Set(CONFIG_ROOT_KEYS);
+var MAX_DEPTH = 64;
+var BLOCK_PREFIX = /[\s，,。：:]/;
+var isKeyChar = (c) => c !== void 0 && /[A-Za-z0-9_-]/.test(c);
+var isNewline = (c) => c === "\n" || c === "\r";
+function configRegions(s) {
+  const t = s.text;
+  const n = s.n;
+  const out = [];
+  let depth = 0;
+  let outerStart = -1;
+  let outerHasRoot = false;
+  let deep = false;
+  const opens = [];
+  let lastKey = null;
+  let i = 0;
+  const closeOuter = (end) => {
+    if (outerHasRoot) out.push({ index: outerStart, end: deep ? n : end });
+    outerStart = -1;
+    outerHasRoot = false;
+    deep = false;
+  };
+  while (i < n) {
+    if (!s.budget.tick()) {
+      s.unfinished = Math.min(s.unfinished, outerStart >= 0 ? outerStart : i);
+      return out;
+    }
+    const c = t[i];
+    if (c === '"' || c === "'") {
+      let j = i + 1;
+      while (j < n && !isNewline(t[j])) {
+        if (c === '"' && t[j] === "\\" && j + 1 < n && !isNewline(t[j + 1])) {
+          j += 2;
+          continue;
+        }
+        if (t[j] === c) {
+          if (c === "'" && t[j + 1] === "'") {
+            j += 2;
+            continue;
+          }
+          break;
+        }
+        j++;
+      }
+      s.budget.tick(j - i);
+      const closed = j < n && t[j] === c;
+      lastKey = depth > 0 ? { value: t.slice(i + 1, j) } : null;
+      i = closed ? j + 1 : j;
+      continue;
+    }
+    if (depth === 0 && c === "#" && (i === 0 || /\s/.test(t[i - 1]))) {
+      let j = i;
+      while (j < n && !isNewline(t[j])) j++;
+      s.budget.tick(j - i);
+      lastKey = null;
+      i = j;
+      continue;
+    }
+    if (c === "{" || c === "[") {
+      if (depth === 0) {
+        outerStart = i;
+        outerHasRoot = false;
+        deep = false;
+      }
+      opens.push(c);
+      depth++;
+      if (depth > MAX_DEPTH) deep = true;
+      lastKey = null;
+      i++;
+      continue;
+    }
+    if (c === "}" || c === "]") {
+      if (depth > 0 && opens[depth - 1] === (c === "}" ? "{" : "[")) {
+        opens.pop();
+        depth--;
+        if (depth === 0) {
+          const toEnd = deep && outerHasRoot;
+          closeOuter(i + 1);
+          if (toEnd) return out;
+        }
+      }
+      lastKey = null;
+      i++;
+      continue;
+    }
+    if (depth > 0) {
+      if (isKeyChar(c)) {
+        let j = i;
+        while (j < n && isKeyChar(t[j])) j++;
+        s.budget.tick(j - i);
+        lastKey = { value: t.slice(i, j) };
+        i = j;
+        continue;
+      }
+      if (c === ":") {
+        if (lastKey && ROOTS.has(lastKey.value.toLowerCase())) outerHasRoot = true;
+        lastKey = null;
+        i++;
+        continue;
+      }
+      if (!/\s/.test(c)) lastKey = null;
+      i++;
+      continue;
+    }
+    if (isKeyChar(c) && (i === 0 || BLOCK_PREFIX.test(t[i - 1]))) {
+      let j = i;
+      while (j < n && isKeyChar(t[j])) j++;
+      s.budget.tick(j - i);
+      if (ROOTS.has(t.slice(i, j).toLowerCase())) {
+        let k = j;
+        while (k < n && /\s/.test(t[k])) k++;
+        s.budget.tick(k - j);
+        if (t[k] === ":") {
+          out.push({ index: i === 0 ? 0 : i - 1, end: n });
+          return out;
+        }
+      }
+      i = j;
+      continue;
+    }
+    i++;
+  }
+  if (depth > 0 && outerHasRoot) out.push({ index: outerStart, end: n });
+  return out;
+}
+
+// ../redact/budget.ts
+var BUDGET_FACTOR = 64;
+var BUDGET_CONSTANT = 4096;
+var Budget = class {
+  visits = 0;
+  exhausted = false;
+  limit;
+  constructor(n, limit) {
+    this.limit = limit ?? BUDGET_FACTOR * n + BUDGET_CONSTANT;
+  }
+  /** 计入 k 次访问；返回是否仍在预算之内。 */
+  tick(k = 1) {
+    this.visits += k;
+    if (this.visits > this.limit) this.exhausted = true;
+    return !this.exhausted;
+  }
+};
+
+// ../redact/placeholders.ts
+var CREDENTIAL_MASK = "(\u7591\u4F3C\u51ED\u636E\uFF0C\u4E0D\u56DE\u663E)";
+var RULE_LABELS = {
+  subscription: "[sub]",
+  url: "[url]",
+  email: "[email]",
+  uuid: "[uuid]",
+  ipv6: "[ip]",
+  ipv4: "[ip]",
+  token: "[token]",
+  urlcred: "[token]",
+  userinfo: "[token]",
+  invite: "\u9080\u8BF7\u7801 [invite]",
+  config: "\n[config]"
+};
+var ATOMS = [...new Set([...Object.values(RULE_LABELS), CREDENTIAL_MASK].map((s) => s.trim()))].sort((a, b) => b.length - a.length);
+var FIRST = new Set(ATOMS.map((a) => a[0]));
+function placeholderAt(text, i) {
+  if (i >= text.length || !FIRST.has(text[i])) return 0;
+  for (const a of ATOMS) if (text.startsWith(a, i)) return a.length;
+  return 0;
+}
+
+// ../redact/value.ts
+function newScan(text, limit) {
+  return { text, n: text.length, budget: new Budget(text.length, limit), values: /* @__PURE__ */ new Map(), unfinished: text.length };
+}
+var IP_LITERAL_MAX = 64;
+var isHexCode = (c) => c >= 48 && c <= 57 || c >= 97 && c <= 102 || c >= 65 && c <= 70;
+function isIpv6(a) {
+  if (a === "") return false;
+  const halves = a.split("::");
+  if (halves.length > 2) return false;
+  const compressed = halves.length === 2;
+  const parts = halves.map((h) => h === "" ? [] : h.split(":"));
+  if (!compressed && parts[0].length < 3) return false;
+  let count = 0;
+  for (const side of parts) {
+    for (let k = 0; k < side.length; k++) {
+      const seg = side[k];
+      const isLast = side === parts[parts.length - 1] && k === side.length - 1;
+      if (isLast && seg.includes(".")) {
+        const oct = seg.split(".");
+        if (oct.length !== 4 || !oct.every((o) => /^\d{1,3}$/.test(o) && Number(o) <= 255)) return false;
+        count += 2;
+        continue;
+      }
+      if (!/^[0-9a-f]{1,4}$/i.test(seg)) return false;
+      count++;
+    }
+  }
+  return compressed ? count < 8 : count === 8;
+}
+function ipLiteralAt(s, i) {
+  const t = s.text;
+  if (t[i] !== "[") return 0;
+  let j = i + 1;
+  while (j < s.n && j - i <= IP_LITERAL_MAX && (isHexCode(t.charCodeAt(j)) || t[j] === ":" || t[j] === ".")) j++;
+  s.budget.tick(j - i);
+  if (t[j] !== "]") return 0;
+  s.budget.tick(j - i - 1);
+  return isIpv6(t.slice(i + 1, j)) ? j + 1 - i : 0;
+}
+var CJK_STOPS = "\uFF0C\u3002\uFF1B\uFF01\uFF1F\u3001";
+var isNewline2 = (c) => c === "\n" || c === "\r";
+var isWs = (c) => c !== void 0 && /\s/.test(c);
+var isInlineWs = (c) => c !== void 0 && c !== "\n" && c !== "\r" && /\s/.test(c);
+var isPrintableAscii = (code) => code >= 33 && code <= 126;
+function restEnd(s, from) {
+  const t = s.text;
+  let j = from;
+  while (j < s.n && !isNewline2(t[j]) && !CJK_STOPS.includes(t[j])) j++;
+  s.budget.tick(j - from + 1);
+  return j;
+}
+function isAdjacentTerminator(c) {
+  return isWs(c) || c === '"' || c === "'" || c === "<" || c === ">" || c === ")" || c === "]" || c === "&" || c === "#" || c === ";" || CJK_STOPS.includes(c);
+}
+var isCloser = (c) => c === ")" || c === "]" || c === ">";
+var isAsciiAlnum = (c) => c !== void 0 && /^[A-Za-z0-9]$/.test(c);
+function continuationStarts(t, n, pos) {
+  if (pos >= n) return false;
+  const c = t[pos];
+  if (isWs(c) || CJK_STOPS.includes(c) || c === "&" || c === "#" || c === ";") return false;
+  return !isCloser(c) || isAsciiAlnum(t[pos + 1]);
+}
+function readWrapped(s, open) {
+  const t = s.text;
+  const close = t[open] === "<" ? ">" : t[open];
+  let j = open + 1;
+  let raw = "";
+  let placeholder = false;
+  while (j < s.n) {
+    if (!s.budget.tick()) break;
+    const len = placeholderAt(t, j);
+    if (len) {
+      placeholder = true;
+      j += len;
+      continue;
+    }
+    const c = t[j];
+    if (c === close || isNewline2(c)) break;
+    raw += c;
+    j++;
+  }
+  const closed = j < s.n && t[j] === close;
+  return { kind: close === ">" ? "angle" : "quote", end: closed ? j + 1 : j, raw, placeholder, closed, atomTail: false };
+}
+function readAdjacent(s, pos, continuation = false) {
+  const t = s.text;
+  let j = pos;
+  let raw = "";
+  let placeholder = false;
+  let atomTail = false;
+  while (j < s.n) {
+    if (!s.budget.tick()) break;
+    const len = placeholderAt(t, j);
+    if (len) {
+      placeholder = true;
+      j += len;
+      atomTail = true;
+      continue;
+    }
+    if (t[j] === "[") {
+      const ip = ipLiteralAt(s, j);
+      if (ip) {
+        raw += t.slice(j, j + ip);
+        j += ip;
+        atomTail = false;
+        continue;
+      }
+    }
+    if (isAdjacentTerminator(t[j]) && !(continuation && j === pos)) break;
+    raw += t[j];
+    j++;
+    atomTail = false;
+  }
+  return j === pos ? null : { kind: "adjacent", end: j, raw, placeholder, closed: false, atomTail };
+}
+function readSegmentAt(s, pos, continuation = false) {
+  const c = s.text[pos];
+  return c === '"' || c === "'" || c === "<" ? readWrapped(s, pos) : readAdjacent(s, pos, continuation);
+}
+function isContent(s, raw) {
+  s.budget.tick(raw.length + 1);
+  let decoded;
+  try {
+    decoded = decodeURIComponent(raw.replace(/\+/g, " "));
+  } catch {
+    return true;
+  }
+  return decoded.trim() !== "";
+}
+function interpretUrlValue(s, start) {
+  const cached = s.values.get(start);
+  if (cached) {
+    s.budget.tick();
+    return cached;
+  }
+  const t = s.text;
+  const n = s.n;
+  let wide = false;
+  let seg = null;
+  let j = start;
+  while (j < n && isInlineWs(t[j])) j++;
+  s.budget.tick(j - start + 1);
+  if (j < n && (t[j] === '"' || t[j] === "'")) {
+    seg = readWrapped(s, j);
+    wide = true;
+  } else if (t[start] === "<") seg = readWrapped(s, start);
+  else if (j > start) {
+    if (j < n && (isPrintableAscii(t.charCodeAt(j)) || placeholderAt(t, j) > 0)) {
+      seg = readSegmentAt(s, j);
+      wide = true;
+    }
+  } else seg = readAdjacent(s, start);
+  let segments = 0;
+  let lastEnd = start;
+  let placeholder = false;
+  let content = false;
+  while (seg) {
+    segments++;
+    lastEnd = seg.end;
+    if (seg.placeholder) placeholder = true;
+    if (isContent(s, seg.raw)) {
+      content = true;
+      break;
+    }
+    if (s.budget.exhausted || seg.end >= n) break;
+    const c = t[seg.end];
+    if ((seg.kind !== "adjacent" && seg.closed || seg.atomTail) && continuationStarts(t, n, seg.end)) {
+      seg = readSegmentAt(s, seg.end, true);
+      continue;
+    }
+    if (isInlineWs(c)) {
+      let k = seg.end;
+      while (k < n && isInlineWs(t[k])) k++;
+      s.budget.tick(k - seg.end);
+      if (k >= n) break;
+      const d = t[k];
+      const ok = placeholderAt(t, k) > 0 || isPrintableAscii(t.charCodeAt(k)) && d !== "&" && d !== "#" && d !== ";" && d !== ")";
+      if (!ok) break;
+      seg = readSegmentAt(s, k);
+      if (seg) wide = true;
+      continue;
+    }
+    break;
+  }
+  let record;
+  if (s.budget.exhausted && !content) {
+    s.unfinished = Math.min(s.unfinished, start);
+    record = { state: "uncertain", judgeEnd: lastEnd, displayEnd: n, next: n };
+  } else if (segments === 0) {
+    record = { state: "none", judgeEnd: start, displayEnd: start, next: start };
+  } else if (content) {
+    if (!wide && lastEnd < n && isInlineWs(t[lastEnd])) {
+      let k = lastEnd;
+      while (k < n && isInlineWs(t[k])) k++;
+      s.budget.tick(k - lastEnd);
+      const d = t[k];
+      if (k < n && (placeholderAt(t, k) > 0 || isPrintableAscii(t.charCodeAt(k)) && d !== "&" && d !== "#" && d !== ";" && d !== ")")) wide = true;
+    } else if (!wide && continuationStarts(t, n, lastEnd)) wide = true;
+    const displayEnd = wide ? restEnd(s, lastEnd) : lastEnd;
+    record = { state: "content", judgeEnd: lastEnd, displayEnd, next: displayEnd };
+  } else {
+    record = { state: placeholder ? "placeholder" : "blank", judgeEnd: lastEnd, displayEnd: lastEnd, next: lastEnd };
+  }
+  s.values.set(start, record);
+  return record;
+}
+var hasCredentialValue = (v) => v.state === "content" || v.state === "uncertain";
+
+// ../redact/named-credential.ts
+var URL_CREDENTIAL_NAMES = ["token", "access_token", "auth", "authorization", "key", "api_key", "apikey", "secret", "password", "pwd", "sig", "signature", "session", "sid"];
+var PROSE_CREDENTIAL_NAMES = ["token", "secret", "password", "pwd", "session_id", "sessionid", "cookie", "\u5BC6\u7801", "\u53E3\u4EE4", "\u4EE4\u724C", "\u5BC6\u94A5", "\u79D8\u94A5"];
+var PROSE_KEY_NAME = "key";
+var PROSE_KEY_MIN_LENGTH = 8;
+var AUTH_SCHEME_NAME = "bearer";
+var PROXY_URI_SCHEMES = ["ss", "ssr", "vmess", "vless", "trojan", "hysteria", "hysteria2", "hy2", "tuic", "anytls"];
+var SCHEMES_LONGEST_FIRST = [...PROXY_URI_SCHEMES].sort((a, b) => b.length - a.length);
+var PROSE_NAMES_LONGEST_FIRST = [...PROSE_CREDENTIAL_NAMES, PROSE_KEY_NAME, AUTH_SCHEME_NAME].sort((a, b) => b.length - a.length);
+var PROSE_NAME_FIRST = new Set(PROSE_NAMES_LONGEST_FIRST.map((n) => n[0]));
+var isAsciiName = (name) => name.charCodeAt(0) < 128;
+var SEPARATORS = "=:\uFF1A";
+var isAlnumCode = (x) => x >= 48 && x <= 57 || x >= 65 && x <= 90 || x >= 97 && x <= 122;
+var isAlnumAt = (t, i) => i >= 0 && i < t.length && isAlnumCode(t.charCodeAt(i));
+var isConnector = (c) => c === "_" || c === "-" || c === ".";
+var isTokenCharAt = (t, i) => i < t.length && (isAlnumCode(t.charCodeAt(i)) || t[i] === "_" || t[i] === "-");
+function compoundNameStart(text, nameStart, s) {
+  let start = nameStart;
+  for (; ; ) {
+    let j = start;
+    while (j > 0 && isConnector(text[j - 1])) j--;
+    if (j === start) break;
+    let k = j;
+    while (k > 0 && isAlnumAt(text, k - 1)) k--;
+    s?.budget.tick(start - k + 1);
+    if (k === j) {
+      let u = start;
+      while (u > 0 && text[u - 1] === "_") u--;
+      return u;
+    }
+    start = k;
+  }
+  return start;
+}
+var URL_NAME_SET = new Set(URL_CREDENTIAL_NAMES);
+var COMPOUND_URL_NAME = new RegExp(`^_*(?:[a-z0-9]+[_.\\-]+)*(${[...PROSE_CREDENTIAL_NAMES, PROSE_KEY_NAME].join("|")})$`);
+function decodeOnce(s) {
+  try {
+    return decodeURIComponent(s.replace(/\+/g, " "));
+  } catch {
+    return s;
+  }
+}
+function urlNameClass(rawName) {
+  const name = decodeOnce(rawName).toLowerCase();
+  const m = COMPOUND_URL_NAME.exec(name);
+  if (m) return m[1] === PROSE_KEY_NAME ? "key" : "prose";
+  return URL_NAME_SET.has(name) ? "url" : null;
+}
+function keyThresholdEnd(s, from) {
+  const t = s.text;
+  let k = from;
+  while (k < s.n && isWs(t[k])) k++;
+  if (k < s.n && (t[k] === '"' || t[k] === "'")) k++;
+  let c = 0;
+  while (c < PROSE_KEY_MIN_LENGTH && isTokenCharAt(t, k + c)) c++;
+  s.budget.tick(k - from + c + 1);
+  return c < PROSE_KEY_MIN_LENGTH ? -1 : k + PROSE_KEY_MIN_LENGTH;
+}
+function proseNameAt(text, i) {
+  if (!PROSE_NAME_FIRST.has(text[i].toLowerCase())) return null;
+  for (const name of PROSE_NAMES_LONGEST_FIRST) if (text.length - i >= name.length && text.slice(i, i + name.length).toLowerCase() === name) return name;
+  return null;
+}
+function breakBefore(s) {
+  if (s.breakBefore) return s.breakBefore;
+  const t = s.text;
+  const arr = new Int32Array(s.n + 1);
+  let last = -1;
+  for (let i = 0; i <= s.n; i++) {
+    arr[i] = last;
+    if (i < s.n) {
+      const code = t.charCodeAt(i);
+      if (!isPrintableAscii(code) || `?&#;=<>"'()[]{}`.includes(t[i])) last = i;
+    }
+  }
+  s.budget.tick(s.n + 1);
+  s.breakBefore = arr;
+  return arr;
+}
+function inUrlParamName(s, pos) {
+  const b = breakBefore(s)[pos];
+  return b >= 0 && "?&#;".includes(s.text[b]);
+}
+function proseNamedHits(s) {
+  if (s.named) return s.named;
+  const t = s.text;
+  const n = s.n;
+  const out = [];
+  let i = 0;
+  while (i < n) {
+    if (!s.budget.tick()) {
+      s.unfinished = Math.min(s.unfinished, i);
+      break;
+    }
+    const name = proseNameAt(t, i);
+    if (!name || isAsciiName(name) && isAlnumAt(t, i - 1)) {
+      i++;
+      continue;
+    }
+    const nameEnd = i + name.length;
+    if (name === AUTH_SCHEME_NAME) {
+      let k = nameEnd;
+      while (k < n && isInlineWs(t[k])) k++;
+      let c = 0;
+      while (c < PROSE_KEY_MIN_LENGTH && isTokenCharAt(t, k + c)) c++;
+      s.budget.tick(k - nameEnd + c + 1);
+      if (k === nameEnd || c < PROSE_KEY_MIN_LENGTH) {
+        i++;
+        continue;
+      }
+      const end2 = restEnd(s, k + PROSE_KEY_MIN_LENGTH);
+      out.push({ index: i, end: end2 });
+      i = end2;
+      continue;
+    }
+    let j = nameEnd;
+    while (j < n && isWs(t[j])) j++;
+    if (j < n && (t[j] === '"' || t[j] === "'")) {
+      j++;
+      while (j < n && isWs(t[j])) j++;
+    }
+    s.budget.tick(j - nameEnd + 1);
+    if (j >= n || !SEPARATORS.includes(t[j])) {
+      i++;
+      continue;
+    }
+    const sepEnd = j + 1;
+    let headEnd;
+    if (name === PROSE_KEY_NAME) {
+      headEnd = keyThresholdEnd(s, sepEnd);
+      if (headEnd < 0) {
+        i++;
+        continue;
+      }
+    } else {
+      let k = sepEnd;
+      while (k < n && isInlineWs(t[k])) k++;
+      for (let a = placeholderAt(t, k); a > 0; a = placeholderAt(t, k)) k += a;
+      s.budget.tick(k - sepEnd + 1);
+      if (k >= n || !isPrintableAscii(t.charCodeAt(k))) {
+        i++;
+        continue;
+      }
+      headEnd = k + 1;
+    }
+    const start = compoundNameStart(t, i, s);
+    let urlEnd = -1;
+    if (t[j] === "=" && j === nameEnd && inUrlParamName(s, start)) {
+      const v = interpretUrlValue(s, sepEnd);
+      if (!hasCredentialValue(v) && v.state !== "none") {
+        i = nameEnd;
+        continue;
+      }
+      urlEnd = v.displayEnd;
+    }
+    const end = Math.max(restEnd(s, headEnd), urlEnd);
+    out.push({ index: start, end });
+    i = end > i ? end : i + 1;
+  }
+  s.named = out;
+  return out;
+}
+var PARAM_NAME_CHAR = (t, i) => isAlnumAt(t, i) || t[i] === "_" || t[i] === "." || t[i] === "-";
+var isHex = (c) => c !== void 0 && /[0-9A-Fa-f]/.test(c);
+function paramNameEnd(t, at) {
+  let j = at;
+  while (j < t.length) {
+    if (PARAM_NAME_CHAR(t, j)) {
+      j++;
+      continue;
+    }
+    if (t[j] === "%" && isHex(t[j + 1]) && isHex(t[j + 2])) {
+      j += 3;
+      continue;
+    }
+    break;
+  }
+  return j > at && t[j] === "=" ? j : -1;
+}
+function urlCredentialSpans(s) {
+  if (s.urlcred) return s.urlcred;
+  const t = s.text;
+  const n = s.n;
+  const out = [];
+  let i = 0;
+  while (i < n) {
+    if (!s.budget.tick()) {
+      s.unfinished = Math.min(s.unfinished, i);
+      break;
+    }
+    const c = t[i];
+    if (c !== "?" && c !== "&" && c !== "#" && c !== ";") {
+      i++;
+      continue;
+    }
+    const eq = paramNameEnd(t, i + 1);
+    if (eq < 0) {
+      i++;
+      continue;
+    }
+    s.budget.tick(eq - i);
+    const cls = urlNameClass(t.slice(i + 1, eq));
+    if (!cls) {
+      i = eq;
+      continue;
+    }
+    const v = interpretUrlValue(s, eq + 1);
+    if (hasCredentialValue(v)) {
+      const withName = cls === "prose" || cls === "key" && keyThresholdEnd(s, eq + 1) >= 0;
+      out.push({ index: withName ? i + 1 : eq + 1, end: v.displayEnd });
+      i = Math.max(v.next, eq + 1);
+    } else i = Math.max(v.next, eq + 1);
+  }
+  s.urlcred = out;
+  return out;
+}
+function proxySchemeStart(t, colon) {
+  for (const scheme of SCHEMES_LONGEST_FIRST) {
+    const from = colon - scheme.length;
+    if (from >= 0 && t.slice(from, colon).toLowerCase() === scheme) return from;
+  }
+  return -1;
+}
+
+// ../redact/index.ts
+var isAlnumCode2 = (x) => x >= 48 && x <= 57 || x >= 65 && x <= 90 || x >= 97 && x <= 122;
+var isWordCode = (x) => isAlnumCode2(x) || x === 95;
+var isTokenCode = (x) => isWordCode(x) || x === 45;
+var isHexCode2 = (x) => x >= 48 && x <= 57 || x >= 65 && x <= 70 || x >= 97 && x <= 102;
+function stopPositions(s) {
+  return /* @__PURE__ */ new Set([...proseNamedHits(s).map((h) => h.index), ...inviteSpans(s).map((h) => h.index)]);
+}
+var LINK_END = (c) => isWs(c) || c === ")" || c === "]" || c === ">" || c === '"' || c === "'";
+function httpHeadAt(t, i) {
+  if (t[i] !== "h" && t[i] !== "H") return 0;
+  const head = t.slice(i, i + 8).toLowerCase();
+  return head.startsWith("https://") ? 8 : head.startsWith("http://") ? 7 : 0;
+}
+function valueLimits(s, creds = urlCredentialSpans(s)) {
+  const t = s.text;
+  const ends = creds.filter((sp) => sp.end < s.n && (t[sp.end] === "&" || t[sp.end] === "#" || t[sp.end] === ";" || CJK_STOPS.includes(t[sp.end])));
+  let k = 0;
+  return (pos) => {
+    while (k < ends.length && ends[k].end <= pos) k++;
+    return k < ends.length && ends[k].index <= pos ? ends[k].end : -1;
+  };
+}
+function bracketSpan(t, i, end) {
+  const stop = Math.min(end, i + IP_LITERAL_MAX + 2);
+  for (let j = i + 1; j < stop; j++) {
+    if (t[j] === "]") return { len: j - i + 1, scanned: j - i };
+    if (t[j] === "[" || /\s/.test(t[j])) return { len: 0, scanned: j - i };
+  }
+  return { len: 0, scanned: stop - i };
+}
+var AUTHORITY_END = /* @__PURE__ */ new Set(["/", "?", "#"]);
+function spanHasStop(stops, from, to) {
+  for (let k = from; k < to; k++) if (stops.has(k)) return true;
+  return false;
+}
+function urlSpans(s) {
+  const t = s.text;
+  const n = s.n;
+  const out = [];
+  const stops = stopPositions(s);
+  const creds = urlCredentialSpans(s);
+  let ci = 0;
+  const inCredValue = (pos) => {
+    while (ci < creds.length && creds[ci].end <= pos) ci++;
+    return ci < creds.length && creds[ci].index <= pos;
+  };
+  const limitAt = valueLimits(s, creds);
+  let i = 0;
+  while (i < n) {
+    if (!s.budget.tick()) {
+      s.unfinished = Math.min(s.unfinished, i);
+      break;
+    }
+    const len = httpHeadAt(t, i);
+    if (!len) {
+      i++;
+      continue;
+    }
+    if (placeholderAt(t, i + len) > 0) {
+      i++;
+      continue;
+    }
+    const limit = limitAt(i);
+    const end = limit >= 0 ? limit : n;
+    let j = i + len;
+    let lastAt = -1;
+    let k = i + len;
+    for (; k < end && !stops.has(k) && !AUTHORITY_END.has(t[k]); k++) {
+      if (t[k] === "[") {
+        const b = bracketSpan(t, k, end);
+        if (!b.len) {
+          s.budget.tick(b.scanned);
+          break;
+        }
+        k += b.len - 1;
+        continue;
+      }
+      if (LINK_END(t[k])) break;
+      if (t[k] === "@") lastAt = k;
+    }
+    s.budget.tick(k - (i + len));
+    const ipl = lastAt >= 0 ? 0 : ipLiteralAt(s, j);
+    if (ipl && j + ipl <= end && !spanHasStop(stops, j, j + ipl)) j += ipl;
+    let inAuthority = true;
+    while (j < end && !LINK_END(t[j]) && !stops.has(j)) {
+      if (AUTHORITY_END.has(t[j])) inAuthority = false;
+      if (t[j] === "[") {
+        const host = inAuthority && j - 1 === lastAt ? ipLiteralAt(s, j) : 0;
+        if (!host || j + host > end || spanHasStop(stops, j, j + host)) break;
+        j += host;
+        continue;
+      }
+      j++;
+    }
+    s.budget.tick(j - i);
+    if (j > i + len) {
+      out.push({ index: i, end: j });
+      i = j;
+    } else i++;
+  }
+  return out;
+}
+function userinfoSpans(s) {
+  const t = s.text;
+  const n = s.n;
+  const out = [];
+  let i = 0;
+  while (i < n) {
+    if (!s.budget.tick()) {
+      s.unfinished = Math.min(s.unfinished, i);
+      break;
+    }
+    const len = httpHeadAt(t, i);
+    if (!len) {
+      i++;
+      continue;
+    }
+    const from = i + len;
+    let j = from;
+    let at = -1;
+    while (j < n && !isWs(t[j]) && t[j] !== "/" && t[j] !== "?" && t[j] !== "#") {
+      if (t[j] === "@") at = j;
+      j++;
+    }
+    s.budget.tick(j - i);
+    if (at > from && userinfoHasContent(s, from, at)) out.push({ index: from, end: at });
+    i = from;
+  }
+  return out;
+}
+function userinfoHasContent(s, from, end) {
+  const t = s.text;
+  s.budget.tick(end - from);
+  for (let k = from; k < end; ) {
+    const a = placeholderAt(t, k);
+    if (a > 0 && k + a <= end) {
+      k += a;
+      continue;
+    }
+    if (t[k] !== ":") return true;
+    k++;
+  }
+  return false;
+}
+var SUB_END = (c) => isWs(c) || c === ")" || c === "]" || c === ">" || c === '"' || c === "'";
+function subscriptionKeywordEnd(t, i) {
+  if (i > 0 && isWordCode(t.charCodeAt(i - 1))) return -1;
+  const c = t[i];
+  if (c === "s" || c === "S") {
+    const head = t.slice(i, i + 12).toLowerCase();
+    if (head === "subscription") return i + 12;
+    if (head.startsWith("subscribe")) return i + 9;
+    return -1;
+  }
+  if ((c === "a" || c === "A") && t.slice(i, i + 5).toLowerCase() === "api/v") {
+    let j = i + 5;
+    const d = j;
+    while (j < t.length && t.charCodeAt(j) >= 48 && t.charCodeAt(j) <= 57) j++;
+    if (j > d && t.slice(j, j + 7).toLowerCase() === "/client") return j + 7;
+  }
+  return -1;
+}
+function subscriptionSpans(s) {
+  const t = s.text;
+  const n = s.n;
+  const cands = [];
+  const stops = stopPositions(s);
+  const limitAt = valueLimits(s);
+  const endAt = (pos) => {
+    const l = limitAt(pos);
+    return l >= 0 ? l : n;
+  };
+  const extend = (from, end) => {
+    let j = from;
+    while (j < end && !SUB_END(t[j]) && !stops.has(j)) j++;
+    s.budget.tick(j - from + 1);
+    return j;
+  };
+  const extendNoStops = (from, end) => {
+    let j = from;
+    while (j < end && !SUB_END(t[j]) && !CJK_STOPS.includes(t[j])) j++;
+    s.budget.tick(j - from + 1);
+    return j;
+  };
+  const authorityAt = (from, end) => {
+    let j = from, at = -1;
+    while (j < end && !isWs(t[j]) && t[j] !== "/" && t[j] !== "?" && t[j] !== "#") {
+      if (t[j] === "@") at = j;
+      j++;
+    }
+    s.budget.tick(j - from + 1);
+    return at;
+  };
+  const extendNoAt = (from, end) => {
+    let j = from;
+    while (j < end && !isWs(t[j]) && !CJK_STOPS.includes(t[j])) j++;
+    const scanned = j - from;
+    while (j > from && SUB_END(t[j - 1])) j--;
+    s.budget.tick(scanned * 2 + 1);
+    return j;
+  };
+  const proxyExtend = (from, end) => {
+    const at = authorityAt(from, end);
+    return at < 0 ? extendNoAt(from, end) : extendNoStops(at + 1, end);
+  };
+  let i = 0;
+  while (i < n) {
+    if (!s.budget.tick()) {
+      s.unfinished = Math.min(s.unfinished, i);
+      break;
+    }
+    if (t[i] === ":" && t[i + 1] === "/" && t[i + 2] === "/") {
+      const start = proxySchemeStart(t, i);
+      s.budget.tick(9);
+      if (start >= 0) {
+        const j = proxyExtend(i + 3, endAt(i));
+        if (j > i + 3) {
+          cands.push({ index: start, end: j });
+          i = j;
+          continue;
+        }
+      }
+      i++;
+      continue;
+    }
+    const kw = subscriptionKeywordEnd(t, i);
+    if (kw >= 0) {
+      const j = extend(kw, endAt(i));
+      cands.push({ index: i, end: j });
+      i = j;
+      continue;
+    }
+    i++;
+  }
+  return disjoint(cands);
+}
+function disjoint(spans) {
+  const out = [];
+  let last = -1;
+  for (const sp of [...spans].sort((a, b) => a.index - b.index)) if (sp.index >= last && sp.end > sp.index) {
+    out.push(sp);
+    last = sp.end;
+  }
+  return out;
+}
+var REGISTERED_ERROR_CODE = /^(?:INSTALL_FAILED|INSTALL_PARSE_FAILED|ERR)(?:_[A-Z]{2,})+$/;
+function tokenSpans(s) {
+  const t = s.text;
+  const n = s.n;
+  const named = proseNamedHits(s);
+  const runs = [];
+  let i = 0;
+  while (i < n) {
+    if (!s.budget.tick()) {
+      s.unfinished = Math.min(s.unfinished, i);
+      break;
+    }
+    if (!isTokenCode(t.charCodeAt(i))) {
+      i++;
+      continue;
+    }
+    const runStart = i;
+    while (i < n && isTokenCode(t.charCodeAt(i))) i++;
+    s.budget.tick(i - runStart);
+    let p = runStart;
+    while (p < i && t[p] === "-") p++;
+    let e = i;
+    while (e > p && t[e - 1] === "-") e--;
+    const exempt = REGISTERED_ERROR_CODE.test(t.slice(p, e));
+    while (p < e) {
+      let q = p;
+      while (q < e && t[q] !== "-") q++;
+      let hex = q - p >= 32;
+      for (let k2 = p; hex && k2 < q; k2++) hex = isHexCode2(t.charCodeAt(k2));
+      if (hex) {
+        runs.push({ index: p, end: q, branch: "hex" });
+        p = q;
+        while (p < e && t[p] === "-") p++;
+        continue;
+      }
+      if (e - p >= 24 && !exempt) runs.push({ index: p, end: e, branch: "long" });
+      break;
+    }
+  }
+  const pieces = [];
+  let k = 0;
+  for (const r of runs) {
+    let from = r.index;
+    while (k < named.length && named[k].end <= from) k++;
+    for (let m = k; m < named.length && named[m].index < r.end; m++) {
+      if (named[m].index > from) pieces.push({ index: from, end: named[m].index, branch: r.branch });
+      from = Math.max(from, named[m].end);
+    }
+    if (from < r.end) pieces.push({ index: from, end: r.end, branch: r.branch });
+  }
+  return [...named.map((h) => ({ ...h, branch: "named" })), ...pieces].sort((a, b) => a.index - b.index);
+}
+function regexInRuns(isClass, re, minLen) {
+  return (s) => {
+    const t = s.text;
+    const n = s.n;
+    const out = [];
+    let i = 0;
+    while (i < n) {
+      if (!s.budget.tick()) {
+        s.unfinished = Math.min(s.unfinished, i);
+        break;
+      }
+      if (!isClass(t.charCodeAt(i))) {
+        i++;
+        continue;
+      }
+      const a = i;
+      while (i < n && isClass(t.charCodeAt(i))) i++;
+      s.budget.tick(i - a);
+      if (i - a < minLen) continue;
+      const from = Math.max(0, a - 1);
+      const slice = t.slice(from, Math.min(n, i + 1));
+      s.budget.tick(slice.length);
+      for (const m of slice.matchAll(re)) {
+        const index = from + (m.index ?? 0);
+        const end = index + m[0].length;
+        if (end > index && index >= a && end <= i) out.push({ index, end });
+      }
+    }
+    return out;
+  };
+}
+var EMAIL = regexInRuns((x) => isAlnumCode2(x) || x === 46 || x === 95 || x === 37 || x === 43 || x === 45 || x === 64, /(?<![A-Za-z0-9._%+-])[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+/g, 5);
+var UUID = regexInRuns((x) => isHexCode2(x) || x === 45, /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, 36);
+var IPV6 = regexInRuns((x) => isHexCode2(x) || x === 58 || x === 46, /(?<![0-9a-f:])(?:[0-9a-f]{0,4}:){2,}(?:\d{1,3}\.){3}\d{1,3}|(?<![0-9a-f:])(?!(?<=[a-z])::[0-9a-f:]*[g-z])(?:[0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}(?![0-9a-f:])/gi, 2);
+var IPV4 = regexInRuns((x) => x >= 48 && x <= 57 || x === 46, /(?<!\d)(?:\d{1,3}\.){3}\d{1,3}(?!\d)/g, 7);
+function inviteSpans(s) {
+  if (s.invites) return s.invites;
+  const t = s.text;
+  const n = s.n;
+  const out = [];
+  const valueEnd = (from) => {
+    let k = from;
+    while (k < n && isWs(t[k])) k++;
+    if (k < n && (t[k] === ":" || t[k] === "\uFF1A" || t[k] === "=")) {
+      k++;
+      while (k < n && isWs(t[k])) k++;
+    }
+    let c = 0;
+    while (k + c < n && isAlnumCode2(t.charCodeAt(k + c))) c++;
+    s.budget.tick(k - from + c + 1);
+    if (c < 6 || c > 12 || k + c < n && t[k + c] === "_") return -1;
+    return k + c;
+  };
+  let i = 0;
+  while (i < n) {
+    if (!s.budget.tick()) {
+      s.unfinished = Math.min(s.unfinished, i);
+      break;
+    }
+    let end = -1;
+    if (t.startsWith("\u9080\u8BF7\u7801", i)) end = valueEnd(i + 3);
+    else if ((t[i] === "i" || t[i] === "I") && t.slice(i, i + 6).toLowerCase() === "invite") {
+      let k = i + 6;
+      while (k < n && isWs(t[k])) k++;
+      s.budget.tick(k - i);
+      if (t.slice(k, k + 4).toLowerCase() === "code") end = valueEnd(k + 4);
+      if (end < 0) end = valueEnd(i + 6);
+    }
+    if (end < 0) {
+      i++;
+      continue;
+    }
+    out.push({ index: i, end });
+    i = end;
+  }
+  s.invites = out;
+  return out;
+}
+var RULES = [
+  ["subscription", subscriptionSpans],
+  ["url", urlSpans],
+  ["email", EMAIL],
+  ["uuid", UUID],
+  ["ipv6", IPV6],
+  ["ipv4", IPV4],
+  ["token", tokenSpans],
+  ["urlcred", urlCredentialSpans],
+  ["userinfo", userinfoSpans],
+  ["invite", inviteSpans],
+  ["config", configRegions]
+];
+var RULE_NAMES = RULES.map(([name]) => name);
+var TOKEN_ORDER = RULE_NAMES.indexOf("token");
+function sensitiveMatches(text, opts = {}) {
+  const s = newScan(text, opts.budget);
+  const out = [];
+  let exhaustedAt = -1;
+  for (let order = 0; order < RULES.length; order++) {
+    const [name, run2] = RULES[order];
+    for (const sp of run2(s)) if (sp.end > sp.index) out.push({ rule: name, text: text.slice(sp.index, sp.end), index: sp.index, order, ..."branch" in sp ? { branch: sp.branch } : {} });
+    if (s.budget.exhausted) {
+      exhaustedAt = order;
+      break;
+    }
+  }
+  let coverFrom = null;
+  if (exhaustedAt >= 0) {
+    coverFrom = exhaustedAt < RULES.length - 1 ? 0 : Math.min(s.unfinished, text.length);
+    if (coverFrom < text.length) out.push({ rule: "token", text: text.slice(coverFrom), index: coverFrom, order: TOKEN_ORDER, branch: "cover" });
+  }
+  if (opts.stats) {
+    opts.stats.visits = s.budget.visits;
+    opts.stats.exhausted = s.budget.exhausted;
+    opts.stats.coverFrom = coverFrom;
+  }
+  return out;
+}
+function render(text, ms, label) {
+  if (ms.length === 0) return text;
+  const owner = new Array(text.length);
+  for (const m of [...ms].sort((a, b) => b.order - a.order)) for (let i2 = m.index; i2 < m.index + m.text.length; i2++) owner[i2] = m;
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    if (!owner[i]) {
+      out += text[i];
+      i++;
+      continue;
+    }
+    let last;
+    while (i < text.length && owner[i]) {
+      const cur = owner[i];
+      const l = label(cur);
+      if (l !== last) {
+        out += l;
+        last = l;
+      }
+      while (i < text.length && owner[i] === cur) i++;
+    }
+  }
+  return out;
+}
+function redactSensitive(text, mask, opts = {}) {
+  const ms = sensitiveMatches(text, opts);
+  const hits = RULE_NAMES.filter((name) => ms.some((m) => m.rule === name));
+  return { text: render(text, ms, (m) => mask ?? RULE_LABELS[m.rule]), hits };
+}
+var SECRET_RULES = /* @__PURE__ */ new Set(["token", "urlcred", "userinfo", "subscription", "ipv4", "ipv6", "invite", "config", "uuid", "email"]);
+var SHORT_WORD_KEBAB = /^[a-z0-9]+(?:-[a-z0-9]+)+$/;
+function isKnownFalsePositive(m) {
+  if (m.rule === "subscription") return /^subscri/i.test(m.text) && !m.text.includes("://");
+  if (m.rule === "token") return SHORT_WORD_KEBAB.test(m.text) && m.text.split("-").every((p) => p.length <= 16);
+  return false;
+}
+function credentialRules(text) {
+  return [...new Set(sensitiveMatches(text).filter((m) => SECRET_RULES.has(m.rule) && !isKnownFalsePositive(m)).map((m) => m.rule))];
+}
+function maskSensitive(text, policy, opts = {}) {
+  const ms = sensitiveMatches(text, opts).filter((m) => policy === "exception" || SECRET_RULES.has(m.rule) && !isKnownFalsePositive(m));
+  return render(text, ms, () => CREDENTIAL_MASK);
+}
+
+// ../runtime-core/src/usage-rules.ts
+var PARTIAL_PREFIX = "\u6761\u76EE\u6CA1\u6709\u8986\u76D6\uFF1A";
+var NOT_KB_LABEL = "\u4EE5\u4E0B\u4E0D\u662F\u77E5\u8BC6\u5E93\u5185\u5BB9\uFF0C\u672A\u7ECF\u6838\u5B9E\uFF1A";
+var OUT_OF_SCOPE_REPLY = "\u8FD9\u7C7B\u95EE\u9898\u4E0D\u5728\u672C\u77E5\u8BC6\u5E93\u7684\u8303\u56F4\u5185\u3002";
+var ADJACENT_SCOPE = ["\u63A8\u8350\u6216\u6BD4\u8F83\u673A\u573A\u3001\u670D\u52A1\u5546\uFF08\u542B\u5BBD\u5E26\u8FD0\u8425\u5546\uFF09", "\u670D\u52A1\u5546\uFF08\u673A\u573A\u3001VPS / \u4E91\u670D\u52A1\u5668\u5546\uFF09\u7684\u8D26\u53F7\u4E0E\u552E\u540E\uFF08\u7EED\u8D39\u3001\u9000\u6B3E\u3001\u5C01\u53F7\uFF0C\u542B\u670D\u52A1\u5546\u81EA\u5DF1\u7684\u7FA4\u7EC4\u4E0E\u9891\u9053\uFF09", "\u670D\u52A1\u7AEF\u642D\u5EFA\u4E0E\u8FD0\u7EF4\uFF08VPS\u3001\u9762\u677F\u3001xray / sing-box \u670D\u52A1\u7AEF\uFF09"];
+var UNRELATED_SCOPE = ["\u7FA4\u52A1\uFF08\u7981\u8A00\u3001\u5165\u7FA4\u9A8C\u8BC1\uFF09", "\u5F00\u53D1\u4E0E\u7F16\u8BD1", "\u8D21\u732E\u4EE3\u7801", "\u653F\u6CBB\u4E0E\u95F2\u804A", "\u4E0E\u4EE3\u7406\u5BA2\u6237\u7AEF\u65E0\u5173\u7684\u8F6F\u786C\u4EF6"];
+var USAGE_RULES = [
+  `**\u9002\u7528\u8303\u56F4**\uFF1A\u95EE\u9898\u4E0E\u4EE3\u7406\u5BA2\u6237\u7AEF\u7684\u4F7F\u7528\u6709\u5173\uFF0C\u6216\u5C5E\u4E8E\u7B2C 4 \u6B65\u300C\u76F8\u90BB\u4F46\u4E0D\u505A\u300D\u7684\u90A3\u51E0\u7C7B\u65F6\uFF0C\u6309\u4E0B\u9762\u7684\u6D41\u7A0B\u505A\u2014\u2014\u540E\u8005\u6B63\u8981\u9760\u8FD9\u4E2A\u6D41\u7A0B\u56DE\u56FA\u5B9A\u53E5\u3002\u4E0E\u77E5\u8BC6\u5E93\u65E0\u5173\u7684\u95EE\u9898\u2014\u2014${UNRELATED_SCOPE.join("\u3001")}\u2014\u2014\u4E0D\u8C03\u7528\u8FD9\u4E9B\u5DE5\u5177\uFF0C\u4E5F\u4E0D\u7528\u4E0B\u9762\u7684\u56FA\u5B9A\u6587\u5B57\uFF0C\u7167\u5E38\u56DE\u7B54\u3002\u8D70\u8FD9\u4E2A\u6D41\u7A0B\u65F6\uFF0C\u8C03\u7528\u5DE5\u5177\u524D\u540E\u90FD\u4E0D\u5199\u8BF4\u660E\u6216\u8FC7\u7A0B\u6587\u5B57\uFF08\u4E2D\u82F1\u6587\u90FD\u4E0D\u884C\uFF0C\u4F8B\u5982\u300CMost relevant: \u2026\u300D\u300CStep 1 \u2026\u300D\uFF09\uFF0C\u7528\u6237\u770B\u5230\u7684\u53EA\u6709\u6700\u7EC8\u56DE\u7B54\u3002`,
+  "",
+  "1. \u8C03 `list_entries`\uFF0C`query` \u7528\u7528\u6237\u539F\u8BDD\uFF1B\u539F\u8BDD\u8D85\u8FC7 200 \u5B57\u65F6\uFF0C\u622A\u53D6\u6700\u80FD\u4EE3\u8868\u95EE\u9898\u7684\u4E00\u6BB5\u2014\u2014\u6709\u62A5\u9519\u539F\u6587\u5C31\u53D6\u62A5\u9519\u539F\u6587\u2014\u2014\u4E0D\u6539\u5199\u63AA\u8F9E\u3002\u8C03\u7528\u672C skill \u65F6\u4F20\u5165\u7684\u53C2\u6570\u662F\u4F60\u81EA\u5DF1\u7684\u8F6C\u8FF0\uFF0C\u4E0D\u80FD\u4EE3\u66FF\u7528\u6237\u539F\u8BDD\u3002\u7528\u6237\u9644\u4E86\u622A\u56FE\u3001\u4F60\u770B\u5F97\u5230\u65F6\uFF0C\u628A\u56FE\u91CC\u7684\u62A5\u9519\u539F\u6587\u9010\u5B57\u3001\u8FDE\u540C\u5BA2\u6237\u7AEF\u540D\u79F0\u63A5\u5728\u539F\u8BDD\u540E\u9762\u4E00\u8D77\u4F5C\u4E3A `query`\uFF1B\u8D85\u8FC7 200 \u5B57\u65F6\u4F18\u5148\u4FDD\u7559\u62A5\u9519\u539F\u6587\u3002",
+  `2. \u5148\u5224\u65AD\u95EE\u9898\u662F\u5426\u5C5E\u4E8E\u7B2C 4 \u6B65\u300C\u76F8\u90BB\u4F46\u4E0D\u505A\u300D\u7684\u90A3\u51E0\u7C7B\u2014\u2014\u770B\u95EE\u9898\u8981\u7684\u7B54\u6848\u5728\u54EA\u4E00\u4FA7\uFF0C\u4E0D\u770B\u95EE\u9898\u91CC\u63D0\u5230\u4E86\u4EC0\u4E48\uFF1A\u8981\u7684\u662F\u5BA2\u6237\u7AEF\u600E\u4E48\u7528\u3001\u600E\u4E48\u8BBE\u7F6E\u3001\u600E\u4E48\u6392\u9519\uFF0C\u6216\u5BA2\u6237\u7AEF\u600E\u4E48\u53D6\u7528\u3001\u663E\u793A\u670D\u52A1\u65B9\u7ED9\u7684\u8BA2\u9605\u3001\u6D41\u91CF\u4FE1\u606F\u4E0E\u8282\u70B9\u51ED\u636E\uFF0C\u662F\u77E5\u8BC6\u5E93\u7684\u4E8B\uFF0C\u8D77\u56E0\u5728\u670D\u52A1\u5546\u6216\u670D\u52A1\u7AEF\u4E5F\u4E00\u6837\uFF1B\u8981\u7684\u662F\u670D\u52A1\u5546\uFF08\u542B\u5BBD\u5E26\u8FD0\u8425\u5546\uFF09\u81EA\u5DF1\u7684\u89C4\u5219\u6216\u51B3\u5B9A\uFF08\u5982\u5957\u9910\u3001\u8BA1\u8D39\u3001\u8D26\u53F7\u4E0E\u552E\u540E\uFF09\uFF0C\u6216\u53EA\u95EE\u5B83\u7684\u7EBF\u8DEF\u3001\u7F51\u7EDC\u662F\u4E0D\u662F\u51FA\u4E86\u6545\u969C\uFF0C\u6216\u670D\u52A1\u7AEF\u4E0E\u4E2D\u8F6C\u7EBF\u8DEF\u65B9\u6848\u672C\u8EAB\uFF08\u600E\u4E48\u642D\u5EFA\u3001\u6548\u679C\u4E0E\u53D6\u820D\u3001\u9009\u54EA\u79CD\uFF09\uFF0C\u5C31\u7B97\u76F8\u90BB\uFF0C\u95EE\u6CD5\u518D\u6280\u672F\u3001\u63D0\u5230\u7684\u5BA2\u6237\u7AEF\u6216\u73B0\u8C61\u518D\u5177\u4F53\u4E5F\u4E00\u6837\uFF1B\u5E26\u7740\u5BA2\u6237\u7AEF\u91CC\u7684\u4F7F\u7528\u5F02\u5E38\u95EE\u662F\u4E0D\u662F\u670D\u52A1\u5546\u6216\u7F51\u7EDC\u90A3\u8FB9\u51FA\u4E86\u95EE\u9898\u7684\uFF0C\u8981\u7684\u662F\u6392\u9519\uFF0C\u5F52\u77E5\u8BC6\u5E93\u3002\u662F\u5C31\u4E0D\u6311\u6761\u76EE\u3001\u4E0D\u8BFB\u6B63\u6587\uFF0C\u76F4\u63A5\u56DE\u300C${OUT_OF_SCOPE_REPLY}\u300D\uFF0C\u9664\u8FD9\u4E00\u53E5\u5916\u4E0D\u8F93\u51FA\u4EFB\u4F55\u6587\u5B57\uFF08\u7B2C 1 \u6B65\u7684 \`list_entries\` \u7167\u8C03\uFF09\u3002\u95EE\u9898\u542B\u7CCA\u2014\u2014\u4E0D\u8FFD\u95EE\u5C31\u4E0D\u77E5\u9053\u5177\u4F53\u95EE\u7684\u662F\u4EC0\u4E48\uFF0C\u4F8B\u5982\u53EA\u8BF4\u300C\u7528\u4E0D\u4E86\u4E86\u300D\uFF0C\u6216\u8BF4\u4E86\u300C\u6709\u4E00\u5904\u7A7A\u767D\u300D\u5374\u6CA1\u8BF4\u662F\u54EA\u4E00\u5904\uFF0C\u6216\u53EA\u8BF4\u62A5\u9519\u53CD\u590D\u5F39\u51FA\u5374\u6CA1\u7ED9\u51FA\u539F\u6587\u2014\u2014\u65F6\uFF0C\u4E0D\u6311\u6761\u76EE\u3001\u4E0D\u8BFB\u6B63\u6587\uFF0C\u53EA\u7528\u4E00\u53E5\u8BDD\u8FFD\u95EE\u7528\u7684\u662F\u4EC0\u4E48\u5BA2\u6237\u7AEF\u3001\u9047\u5230\u4E86\u4EC0\u4E48\u73B0\u8C61\u3001\u662F\u54EA\u4E00\u5904\u3002\u7528\u6237\u53EA\u8BF4\u9644\u4E86\u622A\u56FE\u3001\u6CA1\u5199\u51FA\u73B0\u8C61\u6216\u62A5\u9519\u539F\u6587\uFF0C\u800C\u4F60\u770B\u4E0D\u5230\u56FE\u65F6\uFF0C\u4E5F\u6309\u542B\u7CCA\u5904\u7406\uFF1A\u4E0D\u6311\u6761\u76EE\u3001\u4E0D\u8BFB\u6B63\u6587\uFF0C\u53EA\u7528\u4E00\u53E5\u8BDD\u8BF7\u7528\u6237\u628A\u56FE\u91CC\u7684\u62A5\u9519\u6587\u5B57\u590D\u5236\u8FC7\u6765\uFF0C\u4E0D\u95EE\u522B\u7684\uFF1B\u95EE\u9898\u672C\u8EAB\u5DF2\u5199\u6E05\u73B0\u8C61\u6216\u62A5\u9519\u7684\uFF0C\u770B\u4E0D\u5230\u56FE\u4E5F\u7167\u5E38\u5F80\u4E0B\u8D70\uFF0C\u4E0D\u7B97\u542B\u7CCA\u3002\u770B\u5F97\u5230\u622A\u56FE\u65F6\uFF0C\u6309\u56FE\u91CC\u7684\u73B0\u8C61\u5904\u7406\uFF0C\u4E0D\u7B97\u542B\u7CCA\uFF1B\u770B\u5F97\u51FA\u4E0E\u4EE3\u7406\u5BA2\u6237\u7AEF\u6709\u5173\u65F6\u7167\u5E38\u5148\u8C03 \`list_entries\`\uFF0C\u770B\u4E0D\u51FA\u65F6\u76F4\u63A5\u8FFD\u95EE\u3002\u5426\u5219\u4ECE\u76EE\u5F55\u6311 1\u20133 \u6761\u53EF\u80FD\u76F8\u5173\u7684\u6761\u76EE\uFF1B\u4E00\u6761\u90FD\u4E0D\u6CBE\u8FB9\u5C31\u8DF3\u5230\u7B2C 4 \u6B65\u3002`,
+  "3. \u7528 `get_entry` \u9010\u6761\u8BFB\u6B63\u6587\uFF1B\u8FD4\u56DE\u300C\u6761\u76EE\u4E0D\u5B58\u5728\u300D\u65F6\uFF0C\u91CD\u65B0\u8C03\u4E00\u6B21 `list_entries` \u53D6\u5F53\u524D\u76EE\u5F55\uFF0C\u4ECD\u6CA1\u6709\u5C31\u6309\u7B2C 4 \u6B65\u300C\u6CA1\u6709\u6761\u76EE\u80FD\u56DE\u7B54\u300D\u5904\u7406\u3002",
+  "4. \u56DE\u7B54\uFF08\u56DE\u7B54\u6B63\u6587\u4E0D\u5199\u6761\u76EE id\uFF0C\u4F9D\u636E\u653E\u5728\u672B\u5C3E\u7684\u6761\u76EE\u9875\u9762\u94FE\u63A5\u91CC\uFF1B\u5F15\u7528\u6761\u76EE\u65F6\uFF0C\u4F5C\u4E3A\u4F9D\u636E\u7684\u53EA\u80FD\u662F\u8BFB\u8FC7\u6B63\u6587\u7684\u6761\u76EE\uFF1B\u6761\u76EE\u6B63\u6587\u91CC\u63D0\u5230\u7684\u5176\u4ED6\u6761\u76EE\u53EF\u4EE5\u70B9\u540D\u4F9B\u7528\u6237\u5EF6\u4F38\u9605\u8BFB\uFF0C\u4F46\u4E0D\u5F53\u4F5C\u4F9D\u636E\uFF1B\u76EE\u5F55\u91CC\u770B\u5230\u4F46\u6CA1\u8BFB\u8FC7\u6B63\u6587\u7684\u6761\u76EE\u4E0D\u70B9\u540D\u3002\u8BFB\u8FC7\u6B63\u6587\u540E\u8FD8\u9700\u8981\u8FFD\u95EE\u7684\uFF0C\u4E5F\u5148\u6309\u4E0B\u9762\u7684\u4E09\u79CD\u56DE\u7B54\u4E4B\u4E00\u4F5C\u7B54\uFF0C\u518D\u8FFD\u95EE\uFF09\u3002\u56DE\u7B54\u8981\u77ED\uFF0C\u7EC6\u8282\u7B49\u7528\u6237\u8FFD\u95EE\u518D\u7ED9\u3002\u7B2C\u4E00\u6B21\u56DE\u7B54\u8981\u80FD\u4E00\u773C\u770B\u5B8C\uFF1A\u4E0D\u8D85\u8FC7 8 \u884C\u3001300 \u5B57\uFF08\u672B\u5C3E\u7684\u6761\u76EE\u94FE\u63A5\u4E0D\u7B97\uFF09\uFF0C\u6BCF\u884C\u53EA\u5199\u4E00\u53E5\u8BDD\uFF1B\u653E\u4E0D\u4E0B\u7684\u7559\u7ED9\u8FFD\u95EE\u3002\u5199\u6CD5\uFF1A\u7528\u81EA\u7136\u7684\u51E0\u6BB5\u8BDD\uFF0C\u4E0D\u52A0\u300C\u7ED3\u8BBA\u300D\u300C\u786E\u8BA4\u300D\u300C\u4F9D\u636E\u300D\u8FD9\u7C7B\u5C0F\u6807\u9898\u6216\u6807\u7B7E\uFF0C\u4E0D\u7528\u8868\u683C\u3001\u5D4C\u5957\u5217\u8868\u548C\u7C97\u4F53\uFF1B\u4E00\u53E5\u53EA\u8BF4\u4E00\u4EF6\u4E8B\uFF1B\u7528\u7948\u4F7F\u53E5\uFF1B\u540C\u4E00\u4E2A\u4E1C\u897F\u59CB\u7EC8\u7528\u540C\u4E00\u4E2A\u8BCD\uFF1B\u4E0D\u7528\u300C\u5927\u6982\u300D\u300C\u4E00\u4E9B\u300D\u8FD9\u7C7B\u542B\u7CCA\u7684\u8BCD\uFF1B\u6309\u94AE\u540D\u3001\u83DC\u5355\u540D\u3001\u62A5\u9519\u539F\u6587\u548C\u547D\u4EE4\u7167\u539F\u6837\u5199\uFF1B\u4E0D\u4E3B\u52A8\u8BB2\u539F\u7406\uFF0C\u7528\u6237\u95EE\u4E3A\u4EC0\u4E48\u518D\u8BB2\u3002\u7528\u4E86\u6761\u76EE\u5185\u5BB9\u7684\u56DE\u7B54\uFF08\u80FD\u5B8C\u6574\u56DE\u7B54\u3001\u53EA\u80FD\u90E8\u5206\u56DE\u7B54\uFF09\uFF0C\u77E5\u9053\u672C\u77E5\u8BC6\u5E93\u4E3B\u7AD9\u5730\u5740\u65F6\uFF08\u89C1\u672C skill \u7684\u300C\u56DE\u9000\u300D\u4E00\u8282\uFF09\uFF0C\u5FC5\u987B\u5728\u672B\u5C3E\u5355\u72EC\u4E00\u884C\u7ED9\u51FA\u7528\u5230\u7684\u6761\u76EE\u9875\u9762\u94FE\u63A5 `<\u4E3B\u7AD9>/<type>/<id>/`\uFF0C`<type>` \u53D6\u76EE\u5F55\u91CC\u7684\u6761\u76EE\u7C7B\u578B\uFF1B\u4E0D\u77E5\u9053\u5C31\u4E0D\u7ED9\u3002\u7528\u6237\u8FFD\u95EE\u7EC6\u8282\u65F6\uFF0C\u6309\u6761\u76EE\u7ED9\u51FA\u5B8C\u6574\u6B65\u9AA4\uFF0C\u4E0D\u53D7\u4E0B\u9762\u7684\u957F\u5EA6\u9650\u5236\uFF1A",
+  "   - \u80FD\u5B8C\u6574\u56DE\u7B54\uFF1A\u8981\u52A8\u624B\u64CD\u4F5C\u7684\u95EE\u9898\uFF0C\u5148\u7528\u4E00\u53E5\u8BDD\u8BF4\u662F\u4EC0\u4E48\u60C5\u51B5\u3001\u8BE5\u505A\u4EC0\u4E48\uFF0C\u518D\u5217\u6700\u591A 3 \u6B65\uFF0C\u6BCF\u6B65\u4E00\u4E2A\u52A8\u4F5C\uFF0C\u7136\u540E\u7528\u4E00\u53E5\u8BDD\u8BF4\u505A\u5B8C\u540E\u770B\u5230\u4EC0\u4E48\u5C31\u8BF4\u660E\u597D\u4E86\uFF08\u53D6\u81EA\u6761\u76EE\u7684\u300C\u9A8C\u8BC1\u300D\uFF09\uFF1B\u95EE\u300C\u80FD\u4E0D\u80FD\u300D\u300C\u662F\u4E0D\u662F\u300D\u300C\u662F\u4EC0\u4E48\u300D\u7684\u95EE\u9898\uFF0C\u76F4\u63A5\u7528 2\u20133 \u53E5\u8BDD\u56DE\u7B54\uFF0C\u4E0D\u5217\u6B65\u9AA4\uFF0C\u4E5F\u4E0D\u5199\u600E\u4E48\u786E\u8BA4\u3002\u6761\u76EE\u6709\u591A\u4E2A\u5206\u652F\u65F6\uFF0C\u6309\u7528\u6237\u8BF4\u7684\u73B0\u8C61\u6311\u4E00\u652F\uFF1B\u7528\u6237\u6CA1\u8BF4\u73B0\u8C61\uFF0C\u6311\u6700\u5E38\u89C1\u7684\u4E00\u652F\uFF1B\u5176\u4F59\u5206\u652F\u4E0D\u5C55\u5F00\uFF0C\u53EA\u5728\u6700\u540E\u4E00\u884C\u70B9\u540D 2\u20133 \u79CD\u522B\u7684\u60C5\u51B5\u8BA9\u7528\u6237\u9009\uFF08\u4F8B\u5982\u300C\u5982\u679C\u4F60\u770B\u5230\u7684\u662F A \u6216 B\uFF0C\u544A\u8BC9\u6211\u662F\u54EA\u4E2A\u300D\uFF09\uFF1B\u6CA1\u6709\u522B\u7684\u5206\u652F\u65F6\uFF0C\u6700\u540E\u4E00\u53E5\u544A\u8BC9\u7528\u6237\u8FD8\u80FD\u600E\u4E48\u7EE7\u7EED\u3002\u4E0D\u5199\u7528\u6237\u6CA1\u95EE\u7684\u63D0\u9192\u548C\u6CE8\u610F\u4E8B\u9879\uFF1B",
+  `   - \u53EA\u80FD\u90E8\u5206\u56DE\u7B54\uFF1A\u6761\u76EE\u5BF9\u8FD9\u4E2A\u95EE\u9898\u6709\u5B9E\u8D28\u5E2E\u52A9\uFF08\u7B54\u6848\u6216\u6392\u67E5\u6B65\u9AA4\u7684\u4E00\u90E8\u5206\uFF09\u3001\u4F46\u7B54\u4E0D\u5168\u2014\u2014\u56DE\u7B54\u91CC\u7528\u4E86\u6761\u76EE\u91CC\u7684\u6392\u67E5\u6B65\u9AA4\uFF0C\u5C31\u6309\u8FD9\u4E00\u79CD\u4F5C\u7B54\uFF1B\u6761\u76EE\u8986\u76D6\u7684\u90E8\u5206\u6309\u4E0A\u9762\u7684\u77ED\u7B54\u5199\uFF0C\u5E76\u4EE5\u56FA\u5B9A\u524D\u7F00\u300C${PARTIAL_PREFIX}\u300D\u7528\u4E00\u53E5\u8BDD\u5199\u51FA\u7F3A\u7684\u90E8\u5206\uFF08\u524D\u7F00\u5355\u72EC\u8D77\u4E00\u884C\u5199\u5728\u884C\u9996\uFF0C\u4E0D\u5199\u6210\u6807\u9898\uFF09\uFF1B\u7F3A\u7684\u90E8\u5206\u8981\u7528\u81EA\u5DF1\u7684\u77E5\u8BC6\u8865\uFF0C\u5C31\u5728\u524D\u7F00\u540E\u5148\u5199\u56FA\u5B9A\u6807\u6CE8\u300C${NOT_KB_LABEL}\u300D\u518D\u8865\uFF0C\u81EA\u5DF1\u8865\u7684\u53EA\u5199 1\u20132 \u53E5\uFF1B`,
+  `   - \u6CA1\u6709\u6761\u76EE\u80FD\u56DE\u7B54\uFF08\u4E3B\u9898\u76F8\u8FD1\u3001\u5374\u7B54\u4E0D\u4E86\u7528\u6237\u5177\u4F53\u95EE\u9898\u7684\u6761\u76EE\u4E5F\u7B97\u6CA1\u6709\uFF09\uFF1A\u56DE\u7B54\u4EE5\u56FA\u5B9A\u6807\u6CE8\u300C${NOT_KB_LABEL}\u300D\u5F00\u5934\u2014\u2014\u8981\u81EA\u7B54\uFF0C\u5C31\u5728\u6807\u6CE8\u540E\u7528\u81EA\u5DF1\u7684\u77E5\u8BC6\u56DE\u7B54\uFF0C\u53EA\u5199 1\u20132 \u53E5\uFF0C\u5E76\u4E0E\u6761\u76EE\u5185\u5BB9\u5206\u5F00\uFF1B\u4E0D\u81EA\u7B54\uFF0C\u5C31\u5728\u6807\u6CE8\u540E\u8BF4\u660E\u77E5\u8BC6\u5E93\u6CA1\u6709\u8986\u76D6\uFF1B`,
+  `   - \u4E0E\u77E5\u8BC6\u5E93\u76F8\u90BB\u4F46\u523B\u610F\u4E0D\u505A\u2014\u2014${ADJACENT_SCOPE.join("\uFF1B")}\u2014\u2014\u4E0D\u4F5C\u7B54\uFF0C\u4E5F\u4E0D\u7528\u81EA\u5DF1\u7684\u77E5\u8BC6\u8865\uFF0C\u53EA\u56DE\u7B54\u300C${OUT_OF_SCOPE_REPLY}\u300D\u3002\u8FD9\u6761\u4F18\u5148\u4E8E\u524D\u9762\u4E09\u79CD\u56DE\u7B54\uFF1A\u5373\u4F7F\u76EE\u5F55\u91CC\u6709\u770B\u8D77\u6765\u76F8\u5173\u7684\u6761\u76EE\uFF0C\u4E5F\u4E0D\u6309\u6761\u76EE\u4F5C\u7B54\u3001\u4E0D\u90E8\u5206\u4F5C\u7B54\u3001\u4E0D\u81EA\u7B54\uFF1B\u76F8\u90BB\u95EE\u9898\u4E0D\u8D70\u300C\u6CA1\u6709\u6761\u76EE\u80FD\u56DE\u7B54\u300D\u90A3\u6761\u8DEF\uFF0C\u5E26\u4E0A\u300C${NOT_KB_LABEL}\u300D\u6807\u6CE8\u81EA\u7B54\u540C\u6837\u4E0D\u884C\u3002`,
+  "5. \u4E0D\u56DE\u663E\u8BA2\u9605\u94FE\u63A5\u3001\u5BC6\u94A5\u3001\u8282\u70B9 IP\uFF0C\u622A\u56FE\u91CC\u7684\u4E5F\u4E00\u6837\uFF1B\u53EA\u94FE\u63A5\u6761\u76EE\u91CC\u5217\u51FA\u7684\u5B98\u65B9\u6765\u6E90\u548C\u672C\u77E5\u8BC6\u5E93\u4E3B\u7AD9\u4E0A\u7684\u6761\u76EE\u9875\u9762\uFF1B\u6807\u4E3A\u300C\u4FE1\u606F\u8BF4\u660E\u300D\u7684\u6761\u76EE\u4E0D\u7ED9\u64CD\u4F5C\u6B65\u9AA4\u3002"
+].join("\n");
+var SKILL_DESCRIPTION = `\u4E2D\u7ACB\u7684\u4EE3\u7406\u5BA2\u6237\u7AEF\u77E5\u8BC6\u5E93\u3002\u7528\u6237\u95EE Clash Verge Rev\u3001Clash Party\u3001FlClash\u3001v2rayN\u3001v2rayNG\u3001Clash Meta for Android\u3001sing-box\u3001Karing\u3001Shadowrocket \u7B49\u4EE3\u7406\u5BA2\u6237\u7AEF\u6216 mihomo\u3001Xray \u5185\u6838\u7684\u95EE\u9898\u65F6\u4F7F\u7528\uFF1A\u8BA2\u9605\u3001\u8282\u70B9\u3001\u534F\u8BAE\u3001\u5206\u6D41\u89C4\u5219\u3001TUN\uFF08\u865A\u62DF\u7F51\u5361\uFF09\u3001\u7CFB\u7EDF\u4EE3\u7406\u662F\u4EC0\u4E48\uFF0C\u5BA2\u6237\u7AEF\u4E0E\u5185\u6838\u7684\u7248\u672C\u3001\u66F4\u65B0\u3001\u4E0B\u8F7D\uFF08\u542B\u9884\u53D1\u5E03\u4E0E autobuild\uFF09\u600E\u4E48\u9009\uFF0C\u60F3\u5B8C\u6210\u5BFC\u5165\u8BA2\u9605\u3001\u5207\u6362\u8282\u70B9\u7B49\u64CD\u4F5C\uFF0C\u6216\u9047\u5230\u8282\u70B9\u4E3A\u7A7A\u3001\u8BA2\u9605\u66F4\u65B0\u5931\u8D25\u3001\u8FDE\u4E0A\u4F46\u6253\u4E0D\u5F00\u7F51\u9875\u7B49\u95EE\u9898\uFF08\u9644\u622A\u56FE\u6C42\u52A9\u4E5F\u7B97\uFF09\uFF1B\u7528\u6237\u95EE${ADJACENT_SCOPE.join("\u3001")}\u65F6\u540C\u6837\u4F7F\u7528\uFF08\u6309\u89C4\u5219\u53EA\u56DE\u4E00\u53E5\u56FA\u5B9A\u8BDD\uFF09\u3002\u53EA\u8BFB\uFF0C\u4E0D\u8BFB\u53D6\u7528\u6237\u673A\u5668\u72B6\u6001\uFF0C\u4E0D\u5199\u5165\u3002`;
+
+// ../runtime-core/src/mcp.ts
+var ID = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var MAX_BYTES = 131072;
+var MAX_ID_UNITS = 256;
+function channelOf(v, cfg) {
+  return typeof v === "string" && (cfg.channels ?? []).includes(v) ? v : null;
+}
+var RESULT_SIZE_CHARS = 131072;
+var LIST_ENTRIES_DESCRIPTION = `\u4ECE\u8FD9\u91CC\u5F00\u59CB\uFF1A\u8FD4\u56DE\u77E5\u8BC6\u5E93\u7684\u6761\u76EE\u76EE\u5F55\uFF08\u6BCF\u884C\u4E00\u6761\uFF1Aid | \u7C7B\u578B | \u6807\u9898 | \u522B\u540D\u2026\uFF09\uFF0C\u518D\u7528 get_entry \u8BFB\u6B63\u6587\u3002query \u586B\u7528\u6237\u539F\u8BDD\uFF081\u2013200 \u5B57\uFF09\u3002
+
+${USAGE_RULES}`;
+var TOOLS = [
+  { name: "search", description: "\u6309\u7528\u6237\u539F\u8BDD\u68C0\u7D22\u4EE3\u7406\u5BA2\u6237\u7AEF\u77E5\u8BC6\u5E93\u6761\u76EE\u3002\u53EF\u9009 client\u3001os \u7F29\u5C0F\u8303\u56F4\u3002", inputSchema: { type: "object", properties: { query: { type: "string", minLength: 1, maxLength: 200 }, client: { type: "string" }, os: { type: "string" }, channel: { type: "string", maxLength: 32 } }, required: ["query"], additionalProperties: false } },
+  { name: "list_entries", description: LIST_ENTRIES_DESCRIPTION, inputSchema: { type: "object", properties: { query: { type: "string", minLength: 1, maxLength: 200 } }, required: ["query"], additionalProperties: false } },
+  { name: "get_entry", description: "\u6309\u6761\u76EE id \u53D6\u56DE\u5B8C\u6574\u5185\u5BB9\uFF08Markdown\uFF09\u3002", inputSchema: { type: "object", properties: { id: { type: "string" } }, required: ["id"], additionalProperties: false } }
+];
+var MCP_TOOLS = ["list_entries", "get_entry"].map((n) => ({ ...TOOLS.find((t) => t.name === n), name: n, _meta: { "anthropic/maxResultSizeChars": RESULT_SIZE_CHARS } }));
+function catalogOf(projection) {
+  const ids = Object.keys(projection.entries).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  return { content_version: projection.content_version, entries: ids.map((id) => {
+    const e = projection.entries[id];
+    return { id: e.id, type: e.type, title: e.title, aliases: [...e.aliases] };
+  }) };
+}
+var field = (s) => s.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r\n|\r|\n/g, " ");
+function catalogText(c) {
+  return [`content_version: ${c.content_version}`, ...c.entries.map((e) => [e.id, e.type, e.title, ...e.aliases].map(field).join(" | "))].join("\n");
+}
+var bytes = (s) => new TextEncoder().encode(s).length;
+function vocabulary(index) {
+  const v = /* @__PURE__ */ new Set();
+  for (const d of index.docs) for (const toks of Object.values(d.fields)) for (const t of toks) v.add(t);
+  return v;
+}
+var vocabCache = null;
+function queryText(query, redact) {
+  return redact(query, " ").text;
+}
+var LOG_WAIT_MS = 1e3;
+async function boundedWait(p, ms) {
+  let t;
+  await Promise.race([p, new Promise((resolve) => {
+    t = setTimeout(resolve, ms);
+  })]);
+  clearTimeout(t);
+}
+async function logQuery(deps, cleanQuery, rec) {
+  if (!deps.log) return;
+  const index = deps.index;
+  const log = deps.log;
+  const task = (async () => {
+    if (!vocabCache || vocabCache.key !== index.content_version) vocabCache = { key: index.content_version, set: vocabulary(index) };
+    const vocab = vocabCache.set;
+    const terms = tokens(cleanQuery, index.config, deps.t2s).filter((t) => vocab.has(t)).sort().join(" ");
+    await log({ day: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), terms, content_version: index.content_version, fingerprint: await deps.sha256(`${deps.salt}|${terms}`), ...rec });
+  })().catch(() => {
+  });
+  if (deps.waitUntil) deps.waitUntil(task);
+  else await boundedWait(task, LOG_WAIT_MS);
+}
+async function handleToolCall(name, args, deps, measure = (r) => bytes(JSON.stringify(r))) {
+  const a = args ?? {};
+  const tool = TOOLS.find((t) => t.name === name);
+  if (!tool) return { ok: false, code: -32602, message: "unknown tool" };
+  const props = tool.inputSchema.properties;
+  for (const k of Object.keys(a)) if (!(k in props)) return { ok: false, code: -32602, message: "unexpected argument" };
+  for (const [k, v] of Object.entries(a)) {
+    const p = props[k];
+    if (v !== void 0 && (typeof v !== p.type || p.maxLength !== void 0 && v.length > p.maxLength)) return { ok: false, code: -32602, message: `argument ${k} must be ${p.type}${p.maxLength ? ` \u2264${p.maxLength}` : ""}` };
+  }
+  for (const k of tool.inputSchema.required) if (a[k] === void 0) return { ok: false, code: -32602, message: `missing argument ${k}` };
+  if (name === "search") {
+    const query = typeof a.query === "string" ? a.query : "";
+    if (query.length < 1 || query.length > 200) return { ok: false, code: -32602, message: "query must be 1..200 chars" };
+    const ctx = { client: typeof a.client === "string" ? a.client : void 0, os: typeof a.os === "string" ? a.os : void 0 };
+    const cleanQuery = queryText(query, deps.redact);
+    const r = search(deps.index, cleanQuery, ctx, deps.t2s);
+    const results = r.results.map((x) => ({ id: x.id, type: x.type, title: deps.projection.entries[x.id]?.title ?? x.id, score: Number(x.score.toFixed(4)) }));
+    const top = results[0] ? deps.projection.entries[results[0].id] : void 0;
+    await logQuery(deps, cleanQuery, { tool: "search", intent: top?.intents[0] ?? null, top_id: results[0]?.id ?? null, top_type: results[0]?.type ?? null, abstained: r.abstained ? 1 : 0, channel: channelOf(a.channel, deps.index.config) });
+    return { ok: true, result: { results, abstained: r.abstained, content_version: deps.index.content_version, sponsored: null } };
+  }
+  if (name === "list_entries") {
+    const query = typeof a.query === "string" ? a.query : "";
+    if (query.length < 1 || query.length > 200) return { ok: false, code: -32602, message: "query must be 1..200 chars" };
+    await logQuery(deps, queryText(query, deps.redact), { tool: "list_entries", intent: null, top_id: null, top_type: null, abstained: 0, channel: channelOf(deps.channel, deps.index.config) });
+    return { ok: true, result: catalogOf(deps.projection) };
+  }
+  if (name === "get_entry") {
+    const id = typeof a.id === "string" ? a.id : "";
+    if (!ID.test(id)) return { ok: false, code: -32602, message: "bad id" };
+    const e = Object.hasOwn(deps.projection.entries, id) ? deps.projection.entries[id] : void 0;
+    if (!e) return { ok: false, code: -32004, message: "entry not found" };
+    const make = (md, truncated) => ({ id: e.id, type: e.type, title: e.title, markdown: md, truncated, last_verified_at: e.last_verified_at, freshness: e.freshness, content_version: deps.projection.content_version, sponsored: null });
+    if (measure(make("", true)) > MAX_BYTES) return { ok: false, code: -32603, message: "entry too large" };
+    let result = make(e.markdown, false);
+    if (measure(result) > MAX_BYTES) {
+      const cps = [...e.markdown];
+      if (cps.length === 0) return { ok: false, code: -32603, message: "entry too large" };
+      let lo = 0, hi = cps.length - 1;
+      while (lo < hi) {
+        const mid = Math.ceil((lo + hi) / 2);
+        if (measure(make(cps.slice(0, mid).join(""), true)) <= MAX_BYTES) lo = mid;
+        else hi = mid - 1;
+      }
+      result = make(cps.slice(0, lo).join(""), true);
+    }
+    return { ok: true, result };
+  }
+  return { ok: false, code: -32602, message: "unknown tool" };
+}
+function toolEnvelope(name, result) {
+  const text = name === "get_entry" ? result.markdown : name === "list_entries" ? catalogText(result) : JSON.stringify(result);
+  return { content: [{ type: "text", text }], structuredContent: result };
+}
+var MODERN_VERSIONS = ["2026-07-28"];
+var LEGACY_VERSIONS = ["2025-11-25", "2025-06-18"];
+var SUPPORTED_VERSIONS = [...MODERN_VERSIONS, ...LEGACY_VERSIONS];
+var PV = "io.modelcontextprotocol/protocolVersion";
+var CAPS = "io.modelcontextprotocol/clientCapabilities";
+var SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+var VERSION_SHAPE = /^\d{4}-\d{2}-\d{2}$/;
+var CACHE_HINT = { ttlMs: 36e5, cacheScope: "public" };
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function metaVersion(m) {
+  if (m.method === "initialize" || !isObj(m.params) || !isObj(m.params._meta)) return void 0;
+  return m.params._meta[PV];
+}
+function acceptedId(rawId) {
+  if (rawId !== void 0 && rawId !== null && typeof rawId !== "number" && (typeof rawId !== "string" || rawId.length > MAX_ID_UNITS || credentialRules(rawId).length > 0)) return false;
+  return rawId;
+}
+function modernMetaError(meta) {
+  const pv = meta[PV];
+  if (typeof pv !== "string" || !VERSION_SHAPE.test(pv)) return { code: -32602, message: "invalid protocol version" };
+  if (!MODERN_VERSIONS.includes(pv)) return { code: -32022, message: "unsupported protocol version", data: { supported: SUPPORTED_VERSIONS, requested: pv } };
+  if (!isObj(meta[CAPS])) return { code: -32602, message: "missing client capabilities" };
+  return null;
+}
+async function callTool(params, deps, measure) {
+  const p = isObj(params) ? params : {};
+  const name = typeof p.name === "string" ? p.name : "";
+  if (p.arguments !== void 0 && !isObj(p.arguments)) return { error: { code: -32602, message: "invalid params" } };
+  if (!MCP_TOOLS.some((t) => t.name === name)) return { error: { code: -32602, message: "unknown tool" } };
+  const r = await handleToolCall(name, p.arguments, deps, (result) => measure(toolEnvelope(name, result)));
+  if (r.ok && name === "get_entry" && deps.openLog) {
+    const res = r.result;
+    const openLog = deps.openLog;
+    const task = openLog({ day: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), entry_id: res.id, content_version: res.content_version, channel: channelOf(deps.channel, deps.index.config) }).catch(() => {
+    });
+    if (deps.waitUntil) deps.waitUntil(task);
+    else await boundedWait(task, LOG_WAIT_MS);
+  }
+  if (r.ok) return { result: toolEnvelope(name, r.result) };
+  if (r.code === -32004 || r.code === -32602 && MCP_TOOLS.some((t) => t.name === name)) return { result: { content: [{ type: "text", text: r.message }], isError: true } };
+  return { error: { code: r.code, message: r.message } };
+}
+async function handleJsonRpc(message, deps) {
+  if (Array.isArray(message)) return { jsonrpc: "2.0", id: null, error: { code: -32600, message: "batch requests are not supported (MCP 2025-06-18)" } };
+  const m = message;
+  const id = acceptedId(m?.id);
+  if (id === false) return { jsonrpc: "2.0", id: null, error: { code: -32600, message: "invalid request" } };
+  if (!m || m.jsonrpc !== "2.0" || typeof m.method !== "string") return { jsonrpc: "2.0", id: id ?? null, error: { code: -32600, message: "invalid request" } };
+  if (id === void 0) return null;
+  const reply = (result) => ({ jsonrpc: "2.0", id, result });
+  const fail2 = (e) => ({ jsonrpc: "2.0", id, error: e });
+  const serverInfo = () => ({ name: "hub-kb", version: deps.index.content_version });
+  const pv = metaVersion(m);
+  if (pv === void 0 && m.method === "server/discover") return fail2({ code: -32602, message: "invalid params" });
+  if (pv !== void 0) {
+    const bad = modernMetaError(m.params._meta);
+    if (bad) return fail2(bad);
+    const done = (result) => reply({ ...result, resultType: "complete", _meta: { [SERVER_INFO]: serverInfo() } });
+    switch (m.method) {
+      case "server/discover":
+        return done({ supportedVersions: SUPPORTED_VERSIONS, capabilities: { tools: {} }, ...CACHE_HINT });
+      case "tools/list":
+        return done({ tools: MCP_TOOLS, ...CACHE_HINT });
+      case "tools/call": {
+        const r = await callTool(m.params, deps, (env) => bytes(JSON.stringify(done(env))));
+        return "error" in r ? fail2(r.error) : done(r.result);
+      }
+      // ISS-135（cycle 16）：不回显客户端给的方法名。新版删掉了 ping 与 initialize 之外的握手方法，一律 -32601。
+      default:
+        return fail2({ code: -32601, message: "method not found" });
+    }
+  }
+  switch (m.method) {
+    // 旧版版本协商：客户端要的版本我们支持就回同一个，否则回我们支持的最新旧版；只回我们自己的常量，不回显客户端给的串。
+    case "initialize": {
+      const want = m.params?.protocolVersion;
+      return reply({ protocolVersion: typeof want === "string" && LEGACY_VERSIONS.includes(want) ? want : LEGACY_VERSIONS[0], capabilities: { tools: {} }, serverInfo: serverInfo() });
+    }
+    case "ping":
+      return reply({});
+    case "tools/list":
+      return reply({ tools: MCP_TOOLS });
+    case "tools/call": {
+      const r = await callTool(m.params, deps, (env) => bytes(JSON.stringify(reply(env))));
+      return "error" in r ? fail2(r.error) : reply(r.result);
+    }
+    // ISS-135（cycle 16）：不回显客户端给的方法名。
+    default:
+      return fail2({ code: -32601, message: "method not found" });
+  }
+}
+
+// ../runtime-core/src/body.ts
+var MAX_JSON_BODY_BYTES = 64 * 1024;
+
+// src/stdio.ts
+var ASSET_FILES = ["index.json", "projection.json", "t2s-min.json"];
+async function loadDepsFromDir(dir, extra) {
+  const manifestText = await fs.readFile(path.join(dir, "release-manifest.json"), "utf8").catch((e) => {
+    if (e.code === "ENOENT") throw new Error(`release-manifest.json missing in ${dir}`);
+    throw e;
+  });
+  const manifest = JSON.parse(manifestText);
+  const [index, projection, table] = await Promise.all(ASSET_FILES.map(async (f) => {
+    const buf = await fs.readFile(path.join(dir, f));
+    const want = manifest?.assets?.[f];
+    if (!want || want.bytes !== buf.length || want.sha256 !== createHash("sha256").update(buf).digest("hex")) throw new Error(`${f} does not match release-manifest.json in ${dir}`);
+    return JSON.parse(buf.toString("utf8"));
+  }));
+  return { index, projection, t2s: makeTableT2s(table), salt: extra.salt, sha256: extra.sha256, redact: redactSensitive };
+}
+var TOO_LARGE = Symbol("request too large");
+async function* boundedLines(input, maxBytes = MAX_JSON_BODY_BYTES) {
+  const enc = new TextEncoder();
+  const dec = new TextDecoder();
+  let parts = [];
+  let size = 0;
+  let skipping = false;
+  const take = () => {
+    const buf = new Uint8Array(size);
+    let o = 0;
+    for (const p of parts) {
+      buf.set(p, o);
+      o += p.length;
+    }
+    parts = [];
+    size = 0;
+    const line = dec.decode(buf);
+    return line.endsWith("\r") ? line.slice(0, -1) : line;
+  };
+  for await (const raw of input) {
+    const chunk = typeof raw === "string" ? enc.encode(raw) : raw;
+    let start = 0;
+    for (; ; ) {
+      const nl = chunk.indexOf(10, start);
+      const end = nl < 0 ? chunk.length : nl;
+      if (!skipping) {
+        const piece = chunk.subarray(start, end);
+        if (size + piece.length > maxBytes) {
+          parts = [];
+          size = 0;
+          skipping = true;
+          yield TOO_LARGE;
+        } else if (piece.length) {
+          parts.push(new Uint8Array(piece));
+          size += piece.length;
+        }
+      }
+      if (nl < 0) break;
+      if (skipping) skipping = false;
+      else yield take();
+      start = nl + 1;
+    }
+  }
+  if (!skipping && size > 0) yield take();
+}
+async function createStdioServer(deps, io) {
+  for (; ; ) {
+    const line = await io.readLine();
+    if (line === null) return;
+    if (line === TOO_LARGE) {
+      await io.write(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "request too large" } }));
+      continue;
+    }
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      await io.write(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } }));
+      continue;
+    }
+    const r = await handleJsonRpc(msg, deps);
+    if (r !== null) await io.write(JSON.stringify(r));
+  }
+}
+
+// src/static.ts
+import http from "node:http";
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+var TYPES = { ".html": "text/html; charset=utf-8", ".js": "text/javascript", ".css": "text/css", ".json": "application/json", ".svg": "image/svg+xml", ".png": "image/png", ".webp": "image/webp", ".mp4": "video/mp4", ".webm": "video/webm", ".txt": "text/plain; charset=utf-8" };
+function createStaticServer(root) {
+  return http.createServer(async (req, res) => {
+    let p;
+    try {
+      p = decodeURIComponent((req.url ?? "/").split("?")[0]);
+    } catch {
+      res.writeHead(400);
+      res.end("bad request");
+      return;
+    }
+    if (p.endsWith("/")) p += "index.html";
+    const candidate = path2.resolve(root, `.${p}`);
+    if (candidate !== root && !candidate.startsWith(root + path2.sep)) {
+      res.writeHead(403);
+      res.end();
+      return;
+    }
+    const file = await fs2.realpath(candidate).catch(() => null);
+    if (!file || file !== root && !file.startsWith(root + path2.sep)) {
+      res.writeHead(404);
+      res.end("not found");
+      return;
+    }
+    try {
+      const data = await fs2.readFile(file);
+      res.writeHead(200, { "content-type": TYPES[path2.extname(file)] ?? "application/octet-stream" });
+      res.end(data);
+    } catch {
+      res.writeHead(404);
+      res.end("not found");
+    }
+  });
+}
+
+// src/exit.ts
+var FALLBACK = "\u52A0\u8F7D\u6216\u8FD0\u884C\u5931\u8D25\uFF08\u8BE6\u60C5\u4E0D\u56DE\u663E\uFF09";
+var FLUSH_TIMEOUT_MS = 2e3;
+function makeFail(raw) {
+  const deps = {
+    ...raw,
+    timer: raw.timer ?? ((cb, ms) => setTimeout(cb, ms)),
+    clear: raw.clear ?? ((h) => clearTimeout(h))
+  };
+  let exiting = null;
+  const report = async (e) => {
+    let msg = FALLBACK;
+    try {
+      msg = maskSensitive(String(e?.message ?? e), "exception");
+    } catch {
+    }
+    deps.error(msg);
+    for (const st of deps.streams) {
+      if (st.writableEnded || st.destroyed) continue;
+      await new Promise((resolve) => {
+        const done = deps.timer(resolve, FLUSH_TIMEOUT_MS);
+        const finish = () => {
+          deps.clear(done);
+          resolve();
+        };
+        st.write("", finish);
+        st.once("error", finish);
+      });
+    }
+  };
+  return (e) => {
+    if (exiting) return exiting;
+    exiting = Promise.resolve().then(() => report(e)).catch(() => {
+    }).then(() => deps.exit(1));
+    return exiting;
+  };
+}
+function installProcessHandlers(proc, fail2) {
+  proc.on("unhandledRejection", fail2);
+  proc.on("uncaughtException", fail2);
+}
+
+// src/main.ts
+var [cmd, ...rest] = process.argv.slice(2);
+var opt = (name, def) => {
+  const i = rest.indexOf(`--${name}`);
+  return i >= 0 && rest[i + 1] ? rest[i + 1] : def;
+};
+var fail = makeFail({ error: (m) => console.error(m), exit: (c) => process.exit(c), streams: [process.stdout, process.stderr] });
+installProcessHandlers(process, fail);
+async function run() {
+  if (cmd === "mcp") {
+    const defaultAssets = path3.join(path3.dirname(fileURLToPath(import.meta.url)), "..", "snapshot");
+    const deps = await loadDepsFromDir(path3.resolve(opt("assets", defaultAssets)), { salt: "local", sha256: async (s) => createHash2("sha256").update(s).digest("hex") });
+    const it = boundedLines(process.stdin)[Symbol.asyncIterator]();
+    await createStdioServer(deps, { readLine: async () => {
+      const n = await it.next();
+      return n.done ? null : n.value;
+    }, write: (l) => new Promise((resolve, reject) => {
+      const onDrain = () => {
+        process.stdout.off("error", onError);
+        resolve();
+      };
+      const onError = (e) => {
+        process.stdout.off("drain", onDrain);
+        reject(e);
+      };
+      if (process.stdout.write(l + "\n")) resolve();
+      else {
+        process.stdout.once("drain", onDrain);
+        process.stdout.once("error", onError);
+      }
+    }) });
+  } else if (cmd === "open") {
+    const root = await fs3.realpath(path3.resolve(opt("dir", "./site/dist")));
+    const port = Number(opt("port", "4321"));
+    createStaticServer(root).on("error", fail).listen(port, "127.0.0.1", () => console.log(`http://127.0.0.1:${port}/`));
+  } else {
+    console.log("usage: hub-kb mcp [--assets <dir>, default: bundled snapshot/] | hub-kb open [--dir ./site/dist] [--port 4321]");
+    process.exit(1);
+  }
+}
+try {
+  await run();
+} catch (e) {
+  await fail(e);
+}