bc-observatory 0.2.0 → 0.4.0

package/dist/server.js

@@ -1,19 +1,6 @@
 #!/usr/bin/env node
-/**
- * bc-observatory MCP server (PLAN 4.7, D35): BC Observatory's knowledge base for agents, over stdio.
- *
- * Data: the site's search index (index-manifest.json + pages-<n>.json, cached by sha256 in
- * ~/.cache/bc-observatory/<site hash>/, refreshed daily) and its markdown twins (<path>.md). Set
- * BC_OBSERVATORY_LOCAL=<repo checkout> to read content/ and data/ from disk instead (offline, tests), or
- * BC_OBSERVATORY_SITE to point at another deployment.
- *
- * Tools: search, ls, cat, get_object, diff_object, localization, whats_new, blog_footprint, feedback.
- *
- * Search is hybrid (D63): MiniSearch keywords fused with static embeddings (model2vec potion-base-8M, MIT) by
- * reciprocal rank, so "client" finds Customer. The model (30 MB) is downloaded once on the first search, pinned by
- * revision and checked by SHA-256, into ~/.cache/bc-observatory/models/. BC_OBSERVATORY_EMBEDDINGS=0 turns it off;
- * BC_OBSERVATORY_MODEL_DIR uses a model on disk (offline, tests). Without a model, search is keyword-only.
- */
+
+// src/server.ts
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -21,272 +8,1608 @@ import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import MiniSearch from "minisearch";
 import { z } from "zod";
-import { dot, embed, parseModel } from "./embed.js";
-const VERSION = "0.2.0";
-const SITE = (process.env.BC_OBSERVATORY_SITE ?? "https://waldo1001.github.io/waldo.BCObservatory/").replace(/\/?$/, "/");
-const LOCAL = process.env.BC_OBSERVATORY_LOCAL ? resolve(process.env.BC_OBSERVATORY_LOCAL) : null;
-const REPO = "https://github.com/waldo1001/waldo.BCObservatory";
-const DAY = 86_400_000;
-// ---------------------------------------------------------------------------------------------- data access
-const cacheDir = join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "bc-observatory", createHash("sha256").update(SITE).digest("hex").slice(0, 12));
-async function fetchText(url) {
-    const res = await fetch(url, { headers: { "user-agent": `bc-observatory-mcp/${VERSION}` } });
-    if (!res.ok)
-        throw new Error(`HTTP ${res.status} for ${url}`);
-    return res.text();
-}
-/** A data file (index manifest, shard, diff): from disk in local mode, else from the site. */
+
+// ../search/src/types.ts
+var OBJECT_TYPES = [
+  "table",
+  "tableextension",
+  "page",
+  "pageextension",
+  "codeunit",
+  "report",
+  "reportextension",
+  "query",
+  "xmlport",
+  "enum",
+  "enumextension",
+  "interface",
+  "permissionset",
+  "permissionsetextension",
+  "entitlement",
+  "profile",
+  "controladdin",
+  "pagecustomization"
+];
+var KIND_OF = { fields: "field", events: "event", procs: "proc", values: "value" };
+
+// ../search/src/normalize.ts
+var fold = (s) => s.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase();
+var TOKEN = /[\p{L}\p{N}]+(?:[.\-/][\p{L}\p{N}]+)*/gu;
+var keep = (t) => t.length > 1 || /\d/.test(t);
+function tokenize(s) {
+  const out = [];
+  for (const m of fold(s).matchAll(TOKEN)) if (keep(m[0])) out.push(m[0]);
+  return out;
+}
+function parts(token) {
+  if (!/[.\-/]/.test(token)) return [];
+  return token.split(/[.\-/]/).filter(keep);
+}
+function camelParts(raw) {
+  if (!/[a-z][A-Z]|[A-Z]{2}[a-z]/.test(raw)) return [];
+  return (raw.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z]+|\d+/g) ?? []).map((w) => fold(w)).filter(keep);
+}
+function indexTokens(raw, camel = false) {
+  const out = /* @__PURE__ */ new Set();
+  for (const t of tokenize(raw)) {
+    out.add(t);
+    for (const p of parts(t)) out.add(p);
+  }
+  if (camel) for (const w of raw.split(/[^\p{L}\p{N}]+/u)) for (const p of camelParts(w)) out.add(p);
+  return [...out];
+}
+function stem(t) {
+  if (t.length < 5 || /\d/.test(t) || /[.\-/]/.test(t)) return t;
+  let s = t;
+  if (s.endsWith("ies")) s = `${s.slice(0, -3)}y`;
+  else if (/(ss|x|z|ch|sh)es$/.test(s)) s = s.slice(0, -2);
+  else if (s.endsWith("s") && !/(ss|us|is)$/.test(s)) s = s.slice(0, -1);
+  if (s.length >= 6 && s.endsWith("ing")) s = s.slice(0, -3);
+  else if (s.length >= 5 && s.endsWith("ed")) s = s.slice(0, -2);
+  return s;
+}
+function editDistance(a, b, max = 2) {
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  const n = a.length, m = b.length;
+  let prev2 = new Array(m + 1).fill(0), prev = Array.from({ length: m + 1 }, (_, j) => j), cur = new Array(m + 1).fill(0);
+  for (let i = 1; i <= n; i++) {
+    cur[0] = i;
+    let best2 = cur[0];
+    for (let j = 1; j <= m; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      let v = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) v = Math.min(v, prev2[j - 2] + 1);
+      cur[j] = v;
+      if (v < best2) best2 = v;
+    }
+    if (best2 > max) return max + 1;
+    [prev2, prev, cur] = [prev, cur, prev2];
+  }
+  return prev[m];
+}
+
+// ../search/src/synonyms.ts
+var ABBR = {
+  t: "table",
+  te: "tableextension",
+  p: "page",
+  pe: "pageextension",
+  c: "codeunit",
+  cu: "codeunit",
+  r: "report",
+  q: "query",
+  e: "enum",
+  ee: "enumextension",
+  x: "xmlport",
+  i: "interface",
+  ps: "permissionset",
+  cod: "codeunit",
+  tab: "table",
+  pag: "page",
+  rep: "report",
+  xml: "xmlport",
+  enu: "enum",
+  pse: "permissionsetextension"
+};
+var SYNONYM_PAIRS = [
+  ["cust", "customer"],
+  ["vend", "vendor"],
+  ["g/l", "general ledger"],
+  ["gl", "general ledger"],
+  ["fa", "fixed asset"],
+  ["no", "number"],
+  ["qty", "quantity"],
+  ["amt", "amount"],
+  ["jnl", "journal"],
+  ["sku", "stockkeeping unit"],
+  ["uom", "unit of measure"],
+  ["po", "purchase order"],
+  ["so", "sales order"],
+  ["cu", "codeunit"],
+  ["inv", "invoice"],
+  ["invt", "inventory"],
+  ["cr", "credit"],
+  ["dim", "dimension"],
+  ["acc", "account"],
+  ["acct", "account"],
+  ["doc", "document"],
+  ["ic", "intercompany"],
+  ["bom", "bill of materials"],
+  ["wip", "work in process"],
+  ["mfg", "manufacturing"],
+  ["prod", "production"],
+  ["purch", "purchase"],
+  ["whse", "warehouse"],
+  ["pmt", "payment"],
+  ["rcpt", "receipt"],
+  ["shpt", "shipment"],
+  ["curr", "currency"],
+  ["exch", "exchange"],
+  ["gen", "general"],
+  ["bus", "business"],
+  ["prepmt", "prepayment"],
+  ["req", "requisition"],
+  ["mgt", "management"],
+  ["mgmt", "management"],
+  ["hdr", "header"],
+  ["job", "project"],
+  ["emp", "employee"],
+  ["res", "resource"],
+  ["pstd", "posted"]
+];
+var SYNONYMS_ONE_WAY = [["client", "customer"], ["supplier", "vendor"], ["stock", "inventory"], ["debtor", "customer"], ["creditor", "vendor"]];
+var SYSTEM_ALIASES = {
+  finance: ["general ledger", "g/l", "accounting", "vat", "bank", "cash flow", "dimensions", "posting groups", "cost accounting", "consolidation", "intercompany"],
+  sales: ["sales order", "customer", "quote", "invoice", "credit memo", "prices", "discounts", "receivables", "reminders"],
+  purchasing: ["purchase order", "vendor", "payables", "requisition", "approval"],
+  inventory: ["item", "item tracking", "costing", "planning", "mrp", "stockkeeping", "transfer order", "availability", "quality management"],
+  warehouse: ["bin", "pick", "put-away", "shipment", "receipt", "wms", "directed put-away"],
+  manufacturing: ["production order", "bom", "routing", "capacity", "work center", "subcontracting"],
+  projects: ["job", "jobs", "project", "resource", "time sheet", "wip"],
+  service: ["service order", "service contract", "service item"],
+  assembly: ["assembly order", "assemble-to-order", "kit"],
+  "fixed-assets": ["fa", "depreciation", "insurance", "maintenance"],
+  crm: ["contact", "campaign", "opportunity", "segment", "interaction", "outlook"],
+  hr: ["employee", "absence"],
+  sustainability: ["esg", "emissions", "carbon", "csrd"],
+  reporting: ["report", "power bi", "financial reports", "account schedules", "analysis mode", "excel", "word layout", "query"],
+  copilot: ["copilot", "agent", "ai", "mcp", "sales order agent", "payables agent", "chat", "prompt", "azure openai", "autofill", "summarize"],
+  integration: ["api", "odata", "web service", "dataverse", "dynamics 365 sales", "shopify", "e-document", "edi", "power automate", "power apps", "fabric", "data mirroring", "connector"],
+  administration: ["admin center", "tenant", "environment", "company", "permission", "security group", "setup", "assisted setup", "data migration", "retention", "profile", "role center"],
+  localization: ["country", "local functionality", "intrastat", "sepa", "e-invoicing", "tax", "1099", "gdpdu", "qr-bill"],
+  development: ["al", "extension", "codeunit", "table", "page", "event", "interface", "namespace", "al language", "vs code", "analyzer", "compiler", "testability", "permission set"],
+  platform: ["al-go", "pipeline", "docker", "container", "telemetry", "application insights", "performance", "database", "sql", "upgrade", "update", "release", "wave", "deprecation", "obsolete", "web client", "user experience"]
+};
+var QUESTION_WORDS = /* @__PURE__ */ new Set(["how", "what", "why", "where", "when", "which", "who", "do", "does", "did", "can", "could", "should", "is", "are", "was", "were", "the", "an", "to", "in", "of", "for", "on", "my", "me", "it", "from", "with", "and", "or", "changed", "change"]);
+var norm = (s) => s.toLowerCase().replace(/\.(?=\s|$)/g, "").trim();
+var table = null;
+function synonymsOf(word) {
+  table ??= (() => {
+    const m = /* @__PURE__ */ new Map();
+    const add = (a, b) => {
+      const l = m.get(a);
+      if (l) {
+        if (!l.includes(b)) l.push(b);
+      } else m.set(a, [b]);
+    };
+    for (const [a, b] of SYNONYM_PAIRS) {
+      add(norm(a), norm(b));
+      add(norm(b), norm(a));
+    }
+    for (const [a, b] of SYNONYMS_ONE_WAY) add(norm(a), norm(b));
+    return m;
+  })();
+  return table.get(norm(word)) ?? [];
+}
+function synonymPhrases() {
+  synonymsOf("");
+  return [...table.keys()].filter((k) => k.includes(" "));
+}
+function systemOf(word) {
+  const w = word.toLowerCase().trim();
+  if (SYSTEM_ALIASES[w]) return w;
+  for (const [id, aliases] of Object.entries(SYSTEM_ALIASES)) if (aliases.includes(w)) return id;
+  return null;
+}
+
+// ../search/src/parse.ts
+var TYPE_WORDS = Object.fromEntries(
+  OBJECT_TYPES.flatMap((t) => [[t, t], [`${t}s`, t], ...t === "query" ? [["queries", t]] : []])
+);
+var typeOfWord = (w) => TYPE_WORDS[w.toLowerCase()] ?? ABBR[w.toLowerCase()] ?? null;
+var KINDS = { field: "field", fields: "field", event: "event", events: "event", proc: "proc", procs: "proc", procedure: "proc", procedures: "proc", value: "value", values: "value" };
+function term(text2, phrase = false, raw = text2) {
+  const alts = [...synonymsOf(text2)];
+  const camel = camelParts(raw);
+  if (camel.length > 1) alts.push(camel.join(" "));
+  return { text: text2, stem: phrase ? text2.split(" ").map(stem).join(" ") : stem(text2), alts, phrase, numeric: /^\d+$/.test(text2) };
+}
+function parseQuery(raw, opts) {
+  const countries = new Set(opts.countries.map((c) => c.toLowerCase()));
+  const q = { raw, ref: null, number: null, types: [], kind: null, major: null, countries: [], question: false, terms: [], warnings: [] };
+  let s = raw.trim();
+  const phrases = [];
+  s = s.replace(/"([^"]*)"/g, (_, p) => {
+    const t = tokenize(p);
+    if (t.length) phrases.push({ text: t.join(" "), raw: p });
+    return " ";
+  }).trim();
+  const k = /^(fields?|events?|procs?|procedures?|values?)\s*:\s*/i.exec(s);
+  if (k) {
+    q.kind = KINDS[k[1].toLowerCase()];
+    s = s.slice(k[0].length).trim();
+  }
+  if (!q.kind && !phrases.length) {
+    const m = /^([a-z]+)\s*(\d+)(?:(?:\s+|\s*-\s*)([a-z]{2}))?$/i.exec(s);
+    if (m) {
+      const type = typeOfWord(m[1]);
+      const cc = m[3]?.toLowerCase() ?? null;
+      if (type && (!cc || countries.has(cc))) {
+        q.ref = { type, id: Number(m[2]), country: cc };
+        if (cc) q.countries.push(cc);
+        return q;
+      }
+      const version = /^(bc|v)$/i.test(m[1]) && /^(2[3-9]|3\d)$/.test(m[2]);
+      if (!type && !version && m[1].length <= 4 && !cc) q.warnings.push(`unknown abbreviation ${m[1].toLowerCase()}`);
+    }
+    if (/^\d+$/.test(s)) {
+      q.number = Number(s);
+      return q;
+    }
+  }
+  s = s.replace(/(?:^|\s)(?:bc|v)\s?(2[3-9]|3\d)(?=\s|$)/i, (_, v) => {
+    q.major = v;
+    return " ";
+  }).trim();
+  q.question = /^(how|what|why|where|when|which)\b/i.test(s) || /\bchanged in\b/i.test(s);
+  const words = s.split(/\s+/).filter(Boolean);
+  const typeAt = (i) => i >= 0 && i < words.length && !!TYPE_WORDS[words[i].toLowerCase()];
+  const typeWords = [];
+  const rest = [];
+  words.forEach((w, i) => {
+    const lw = w.toLowerCase();
+    if (TYPE_WORDS[lw]) {
+      q.types.push(TYPE_WORDS[lw]);
+      typeWords.push(w);
+      return;
+    }
+    if (words.length === 1 && lw.length > 1 && ABBR[lw]) {
+      q.types.push(ABBR[lw]);
+      typeWords.push(w);
+      return;
+    }
+    if (/^[a-z]{2}$/i.test(w) && countries.has(lw) && (w === w.toUpperCase() || typeAt(i - 1) || typeAt(i + 1))) {
+      if (!q.countries.includes(lw)) q.countries.push(lw);
+      return;
+    }
+    rest.push(w);
+  });
+  if (!rest.length && !phrases.length && !q.countries.length && !q.kind) rest.push(...typeWords);
+  let toks = [];
+  for (const w of rest) {
+    const t = tokenize(w);
+    for (const x of t) toks.push({ text: x, raw: t.length === 1 ? w.replace(/[^\p{L}\p{N}.\-/]/gu, "") : x });
+  }
+  if (q.question) toks = toks.filter((t) => !QUESTION_WORDS.has(t.text) && !(t.text.length === 1));
+  const multi = synonymPhrases().map((p) => p.split(" ")).sort((a, b) => b.length - a.length);
+  for (let i = 0; i < toks.length; i++) {
+    const hit = multi.find((p) => p.every((w, j) => toks[i + j]?.text === w));
+    if (hit) {
+      q.terms.push(term(hit.join(" "), true));
+      i += hit.length - 1;
+      continue;
+    }
+    q.terms.push(term(toks[i].text, false, toks[i].raw));
+  }
+  for (const p of phrases) q.terms.push(p.text.includes(" ") ? term(p.text, true, p.raw) : term(p.text, false, p.raw));
+  return q;
+}
+
+// ../search/src/anchors.ts
+var anchorOf = (kind, key) => `#${kind}-${key}`;
+
+// ../search/src/score.ts
+var nameOf = (title) => /"(.*)"/.exec(title)?.[1] ?? title;
+function layerOf(p) {
+  if (p.type !== "object") return 0;
+  if (countryOf(p)) return 2;
+  return !p.app || p.app === "Base Application" ? 0 : 1;
+}
+function countryOf(p) {
+  if (p.country) return String(p.country).toLowerCase();
+  if (p.type === "object" && p.object_id != null) return /-([a-z]{2})$/.exec(p.path)?.[1] ?? null;
+  return null;
+}
+function pageToRecord(p) {
+  const object = p.type === "object";
+  const country = object ? countryOf(p) : p.country ? String(p.country).toLowerCase() : null;
+  return {
+    id: p.path,
+    kind: "page",
+    type: p.type,
+    name: object ? p.name ?? nameOf(p.title) : p.title,
+    title: p.title,
+    ...p.caption ? { caption: p.caption } : {},
+    text: p.summary ?? "",
+    ...p.tags?.length ? { tags: p.tags } : {},
+    ...object ? { objectType: p.object_type, objectId: p.object_id ?? null, app: p.app ?? null, inbound: p.inbound ?? 0, subscribers: p.subscribers ?? 0 } : {},
+    country,
+    layer: layerOf(p),
+    importance: 0,
+    system: p.system ?? null,
+    date: p.date ?? null,
+    ...p.members !== void 0 ? { members: p.members } : {},
+    ...p.narrative ? { narrative: p.narrative } : {},
+    ...p.present_in ? { major: p.present_in } : {},
+    tier: p.tier,
+    page: p
+  };
+}
+function symbolToRecord(kind, row, owner) {
+  const name = String(row[1]);
+  const key = kind === "field" || kind === "value" ? Number(row[2]) : name;
+  const base = {
+    id: `${owner.id}${anchorOf(kind, key)}`,
+    kind,
+    type: owner.type,
+    name,
+    title: name,
+    objectType: owner.objectType,
+    objectId: owner.objectId ?? null,
+    country: owner.country ?? null,
+    app: owner.app ?? null,
+    layer: owner.layer,
+    importance: owner.importance,
+    inbound: owner.inbound ?? 0,
+    system: owner.system ?? null,
+    major: owner.major,
+    tier: owner.tier,
+    owner: { path: owner.id, title: owner.title }
+  };
+  if (kind === "field") return { ...base, text: row[4] ?? "", extra: { id: Number(row[2]), type: String(row[3]) } };
+  if (kind === "event") return { ...base, text: row[4] ?? "", subscribers: Number(row[3]) || 0, extra: { kind: String(row[2]), subscribers: Number(row[3]) || 0, obsolete: row[5] ?? null } };
+  if (kind === "proc") return { ...base, text: row[4] ?? "", extra: { params: Number(row[2]) || 0, returns: row[3] ?? null, obsolete: row[5] ?? null } };
+  return { ...base, ...row[3] ? { caption: String(row[3]) } : {}, text: "", extra: { ordinal: Number(row[2]), caption: row[3] ?? null } };
+}
+function hasMajor(r, major) {
+  if (!r.major) return false;
+  const m = Number(major);
+  return r.major.split(/[\s,]+/).some((part) => {
+    const [a, b] = part.split("-").map(Number);
+    return b === void 0 || Number.isNaN(b) ? a === m : a <= m && m <= b;
+  });
+}
+var STATE = /* @__PURE__ */ new WeakMap();
+var NORM = /* @__PURE__ */ new WeakMap();
+var push = (m, k, v) => {
+  const l = m.get(k);
+  if (l) l.push(v);
+  else m.set(k, [v]);
+};
+function normOf(r) {
+  const cached = NORM.get(r);
+  if (cached) return cached;
+  const symbol = r.kind !== "page";
+  const main = /* @__PURE__ */ new Set([...indexTokens(r.name, symbol), ...indexTokens(r.title, symbol), ...r.caption ? indexTokens(r.caption) : []]);
+  const own = r.type === "topic" ? new Set(tokenize(r.title)) : null;
+  const tags = (r.tags ?? []).flatMap((t) => indexTokens(t)).filter((t) => !own?.has(t));
+  const eqs = r.type === "object" || symbol ? [tokenize(r.name), ...r.caption ? [tokenize(r.caption)] : []] : [tokenize(r.title)];
+  const n = { main: [...main], tags: [...new Set(tags)], text: symbol ? null : indexTokens(r.text ?? ""), eqs };
+  NORM.set(r, n);
+  return n;
+}
+var textOf = (r, n) => n.text ??= indexTokens(r.text ?? "");
+function prepare(records, prev) {
+  const index2 = prev ?? { records: [], postings: /* @__PURE__ */ new Map(), vocab: /* @__PURE__ */ new Map(), byType: /* @__PURE__ */ new Map(), maxInbound: /* @__PURE__ */ new Map() };
+  let st = STATE.get(index2);
+  if (!st) {
+    st = { norms: [], stems: /* @__PURE__ */ new Map(), buckets: /* @__PURE__ */ new Map(), sorted: null, byObject: /* @__PURE__ */ new Map(), byId: /* @__PURE__ */ new Map(), byCountry: /* @__PURE__ */ new Map(), maxSubs: 0, matchers: /* @__PURE__ */ new WeakMap() };
+    STATE.set(index2, st);
+  }
+  for (const r of records) {
+    const i = index2.records.length;
+    index2.records.push(r);
+    const n = normOf(r);
+    st.norms[i] = n;
+    const toks = /* @__PURE__ */ new Set([...n.main, ...n.tags, ...n.text ?? []]);
+    for (const t of toks) {
+      const df = index2.vocab.get(t);
+      if (df === void 0) {
+        index2.vocab.set(t, 1);
+        const s = stem(t);
+        (st.stems.get(s) ?? st.stems.set(s, /* @__PURE__ */ new Set()).get(s)).add(t);
+        if (/^[a-z]{4,}$/.test(t)) push(st.buckets, `${t[0]}${t.length}`, t);
+        st.sorted = null;
+      } else index2.vocab.set(t, df + 1);
+      push(index2.postings, t, i);
+    }
+    push(index2.byType, r.kind === "page" ? r.type : r.kind, i);
+    if (r.kind === "page" && r.type === "object" && r.objectType) {
+      push(st.byObject, `${r.objectType}/${r.objectId ?? fold(r.name)}`, i);
+      if (r.objectId != null) push(st.byId, r.objectId, i);
+      index2.maxInbound.set(r.objectType, Math.max(index2.maxInbound.get(r.objectType) ?? 0, r.inbound ?? 0));
+    }
+    if (r.country && r.kind === "page") push(st.byCountry, r.country, i);
+    if (r.kind === "event") st.maxSubs = Math.max(st.maxSubs, r.subscribers ?? 0);
+  }
+  for (const r of index2.records) r.importance = importance(index2, r);
+  st.matchers = /* @__PURE__ */ new WeakMap();
+  return index2;
+}
+function importance(index2, r) {
+  if (!r.objectType) return 0;
+  const max = index2.maxInbound.get(r.objectType) ?? 0;
+  let v = max > 0 ? Math.log2(1 + (r.inbound ?? 0)) / Math.log2(1 + max) : 0;
+  if (r.kind === "event") {
+    const ms = STATE.get(index2)?.maxSubs ?? 0;
+    if (ms > 0) v += 0.5 * Math.log2(1 + (r.subscribers ?? 0)) / Math.log2(1 + ms);
+  }
+  return Math.min(1, v);
+}
+function sortedVocab(index2, st) {
+  return st.sorted ??= [...index2.vocab.keys()].sort();
+}
+function prefixed(sorted, p) {
+  let lo = 0, hi = sorted.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (sorted[mid] < p) lo = mid + 1;
+    else hi = mid;
+  }
+  const out = [];
+  for (let i = lo; i < sorted.length && sorted[i].startsWith(p); i++) out.push(sorted[i]);
+  return out;
+}
+function fuzzyCandidates(index2, word) {
+  const st = STATE.get(index2);
+  if (!st || word.length < 5 || !/^[a-z]+$/.test(word)) return [];
+  const max = word.length >= 9 ? 2 : 1, out = [];
+  for (let len = word.length - 2; len <= word.length + 2; len++) for (const t of st.buckets.get(`${word[0]}${len}`) ?? []) if (editDistance(word, t, max) <= max) out.push(t);
+  return out;
+}
+function matcherOf(index2, st, t) {
+  const words = /* @__PURE__ */ new Map(), phrases = [];
+  const set = (w, f) => {
+    const o = words.get(w);
+    if (!o || o.f < f.f) words.set(w, f);
+  };
+  const rarest = (ws) => {
+    let best2 = [], n = Infinity;
+    for (const w of ws) {
+      const forms = [.../* @__PURE__ */ new Set([w, ...st.stems.get(stem(w)) ?? []])].filter((x) => index2.vocab.has(x));
+      const c = forms.reduce((a, x) => a + (index2.vocab.get(x) ?? 0), 0);
+      if (c < n) {
+        n = c;
+        best2 = forms;
+      }
+    }
+    return best2;
+  };
+  const seeds = [];
+  if (t.phrase) {
+    phrases.push({ words: t.text.split(" "), f: 1, how: "exact" });
+    seeds.push(...rarest(t.text.split(" ")));
+  } else if (t.numeric) {
+    if (index2.vocab.has(t.text)) set(t.text, { f: 1, how: "exact" });
+  } else {
+    if (index2.vocab.has(t.text)) set(t.text, { f: 1, how: "exact" });
+    for (const w of st.stems.get(t.stem) ?? []) set(w, { f: 0.75, how: "stem" });
+    if (t.text.length >= 3) for (const w of prefixed(sortedVocab(index2, st), t.text)) set(w, { f: 0.75, how: "prefix" });
+    if (!words.size) for (const w of fuzzyCandidates(index2, t.text)) set(w, { f: 0.5, how: "fuzzy", via: w });
+  }
+  for (const alt of t.alts) {
+    if (alt.includes(" ")) {
+      const ws = alt.split(" ");
+      const camel = t.text === ws.join("") || ws.join("") === t.text.replace(/[^a-z0-9]/g, "");
+      phrases.push({ words: ws, f: camel ? 0.75 : 0.8, how: camel ? "prefix" : "syn", ...camel ? {} : { via: alt } });
+      seeds.push(...rarest(ws));
+    } else {
+      if (index2.vocab.has(alt)) set(alt, { f: 0.8, how: "syn", via: alt });
+      for (const w of st.stems.get(stem(alt)) ?? []) set(w, { f: 0.6, how: "syn", via: alt });
+    }
+  }
+  seeds.push(...words.keys());
+  return { term: t, words, phrases, seeds: [...new Set(seeds)] };
+}
+function matchersOf(index2, q) {
+  const st = STATE.get(index2);
+  let m = st.matchers.get(q);
+  if (!m) {
+    m = q.terms.map((t) => matcherOf(index2, st, t));
+    st.matchers.set(q, m);
+  }
+  return m;
+}
+function best(m, toks) {
+  let b = null;
+  for (const t of toks) {
+    const f = m.words.get(t);
+    if (f && (!b || f.f > b.f)) b = f;
+  }
+  for (const p of m.phrases) {
+    if (b && b.f >= p.f) continue;
+    const f = phraseForm(p.words, toks);
+    if (f) {
+      const v = p.f * f;
+      if (!b || v > b.f) b = { f: v, how: p.how, ...p.via ? { via: p.via } : {} };
+    }
+  }
+  return b;
+}
+function phraseForm(words, toks) {
+  let bestF = 0;
+  for (let i = 0; i + words.length <= toks.length; i++) {
+    let f = 1;
+    for (let j = 0; j < words.length && f; j++) {
+      const t = toks[i + j], w = words[j];
+      f = t === w ? f : stem(t) === stem(w) ? Math.min(f, 0.75) : 0;
+    }
+    if (f > bestF) bestF = f;
+    if (bestF === 1) break;
+  }
+  return bestF;
+}
+function nameMatch(eq, ms, plural) {
+  let pos = 0, f = 1, lastPrefix = false;
+  for (const m of ms) {
+    const ws = m.term.phrase ? m.term.text.split(" ") : null;
+    if (ws) {
+      for (const w of ws) {
+        const t2 = eq[pos++];
+        if (t2 === void 0) return { eq: 0, starts: 0 };
+        f = Math.min(f, t2 === w ? 1 : stem(t2) === stem(w) ? plural ? 1 : 0.75 : 0);
+      }
+      if (!f) return { eq: 0, starts: 0 };
+      lastPrefix = false;
+      continue;
+    }
+    const t = eq[pos++];
+    if (t === void 0) return { eq: 0, starts: 0 };
+    const form = m.words.get(t);
+    if (!form) {
+      const p = m.phrases.find((x) => x.words.every((w, j) => eq[pos - 1 + j] === w));
+      if (!p) return { eq: 0, starts: 0 };
+      pos += p.words.length - 1;
+      f = Math.min(f, p.f);
+      lastPrefix = p.how === "prefix";
+      continue;
+    }
+    f = Math.min(f, form.how === "stem" && plural ? 1 : form.f);
+    lastPrefix = form.how === "prefix";
+  }
+  if (pos === eq.length && !lastPrefix && (plural || f === 1)) return { eq: f, starts: 0 };
+  return { eq: 0, starts: pos <= eq.length ? f : 0 };
+}
+var NARRATIVE = { reviewed: 2, unreviewed: 0, none: -2, derived: -2 };
+var TYPE_PRIOR = { table: 0.3, page: 0.2, codeunit: 0.2, report: 0.1 };
+var LAYER = [1, 0.5, 0];
+var OBJECT_WORDS = /\b(field|fields|event|events|procedure|procedures|proc|member|members)\b/i;
+function scoreRecord(index2, r, q) {
+  const why = [];
+  const object = r.kind === "page" && r.type === "object", symbol = r.kind !== "page", objectish = object || symbol;
+  const none = { s: 0, why };
+  if (q.kind && r.kind !== q.kind) return none;
+  if (q.major && !hasMajor(r, q.major)) return none;
+  if (q.types.length && objectish && !q.types.includes(r.objectType)) return none;
+  const country = r.country ? r.country.toLowerCase() : null;
+  if (q.ref) {
+    if (!object || r.objectType !== q.ref.type || r.objectId !== q.ref.id) return none;
+    why.push("reference");
+    if (q.ref.country) return { s: country === q.ref.country ? 1e3 : country === null ? 900 : 850, why };
+    return { s: country === null ? 1e3 : 900, why };
+  }
+  const prior = object ? TYPE_PRIOR[r.objectType ?? ""] ?? 0 : 0;
+  const lift = (base) => base + (object ? LAYER[r.layer] : symbol ? 0 : 1) + (objectish ? 2 * r.importance : 0) + prior;
+  if (q.number !== null) {
+    if (!object || r.objectId !== q.number) return none;
+    why.push("id");
+    return { s: lift(8) + countryPoints(q, r, country), why };
+  }
+  if (!q.terms.length) {
+    if (!q.countries.length) return none;
+    if (r.type === "localization" && country && q.countries.includes(country)) {
+      why.push("name");
+      return { s: 20, why };
+    }
+    if (object && country && q.countries.includes(country)) return { s: 3 + 2 * r.importance + prior, why };
+    return none;
+  }
+  const n = normOf(r), ms = matchersOf(index2, q);
+  let s = 0, named = false, gate = !symbol || !!q.kind;
+  for (const m of ms) {
+    const main = best(m, n.main), tags = best(m, n.tags), text2 = best(m, textOf(r, n));
+    if (!main && !tags && !text2) return none;
+    if (main || tags) named = true;
+    if (symbol && !gate && n.eqs[0].some((t) => {
+      const f = m.words.get(t);
+      return f && (f.how === "exact" || f.how === "prefix");
+    })) gate = true;
+    if (symbol && /^on[a-z]/.test(m.term.text)) gate = true;
+    s += 3 * (main?.f ?? 0) + 2 * (tags?.f ?? 0) + (text2?.f ?? 0);
+    const via = [main, tags, text2].find((x) => x?.via && (x.how === "syn" || x.how === "fuzzy"))?.via;
+    if (via && !why.includes(`matched "${via}"`)) why.push(`matched "${via}"`);
+  }
+  if (!gate) return none;
+  let eq = 0, starts = 0, byName = false;
+  n.eqs.forEach((e, k) => {
+    const x = nameMatch(e, ms, objectish);
+    if (x.eq > eq) {
+      eq = x.eq;
+      byName = k === 0;
+    }
+    starts = Math.max(starts, x.starts);
+  });
+  if (eq) {
+    s += 10 * eq;
+    why.push(!byName ? "caption" : eq >= 0.75 ? "name" : "name~");
+  } else if (starts) {
+    s += 3 * starts;
+    why.push("starts");
+  }
+  if ((r.type === "topic" || r.type === "app") && !symbol && named) s += Math.log2((r.members ?? 0) + 1);
+  if ((r.type === "topic" || r.type === "app") && !symbol) s += NARRATIVE[r.narrative ?? (r.type === "app" ? "none" : "unreviewed")] ?? 0;
+  s += countryPoints(q, r, country);
+  if (q.types.length && objectish) s += 3;
+  s = lift(s);
+  const lifted = q.kind || q.types.length || /\d/.test(q.raw) || OBJECT_WORDS.test(q.raw) || object && eq && byName || symbol && ms.some((m) => /^on[a-z]/.test(m.term.text) && m.term.alts.some((a) => a.startsWith("on ")));
+  if (objectish && !lifted) {
+    s *= 0.6;
+    why.push("demoted");
+  }
+  return { s, why };
+}
+function countryPoints(q, r, country) {
+  if (!q.countries.length || !country) return 0;
+  if (q.countries.includes(country)) return 3;
+  return r.type === "object" ? -1 : 0;
+}
+var byRank = (a, b) => b.s - a.s || (b.r.date ?? "").localeCompare(a.r.date ?? "") || (b.r.members ?? 0) - (a.r.members ?? 0) || b.r.importance - a.r.importance || a.r.title.localeCompare(b.r.title);
+function search(index2, q, opts = {}) {
+  const st = STATE.get(index2);
+  if (!st) return [];
+  let cand;
+  if (q.ref) cand = st.byObject.get(`${q.ref.type}/${q.ref.id}`) ?? [];
+  else if (q.number !== null) cand = st.byId.get(q.number) ?? [];
+  else if (!q.terms.length) cand = q.countries.flatMap((c) => st.byCountry.get(c) ?? []);
+  else {
+    const ms = matchersOf(index2, q), N = index2.records.length;
+    const count = new Uint8Array(N);
+    ms.forEach((m, k) => {
+      for (const w of m.seeds) for (const i of index2.postings.get(w) ?? []) if (count[i] === k) count[i] = k + 1;
+    });
+    const out = [];
+    for (let i = 0; i < N; i++) if (count[i] === ms.length) out.push(i);
+    cand = out;
+  }
+  const hits = [];
+  for (const i of cand) {
+    const r = index2.records[i];
+    if (opts.kinds && !opts.kinds.includes(r.kind)) continue;
+    if (opts.filter && !opts.filter(r)) continue;
+    const { s, why } = scoreRecord(index2, r, q);
+    if (s > 0) hits.push({ r, s, why, band: s >= 900 || why.includes("name") && !why.includes("demoted") ? "exact" : "match" });
+  }
+  hits.sort(byRank);
+  return opts.limit ? hits.slice(0, opts.limit) : hits;
+}
+function symbolLine(r) {
+  const of = r.owner ? ` of ${r.owner.title}` : "", x = r.extra ?? {};
+  if (r.kind === "field") return `field ${x.id}${of} \xB7 ${x.type}`;
+  if (r.kind === "event") return `event${of} \xB7 ${x.kind} \xB7 ${x.subscribers} ${x.subscribers === 1 ? "subscriber" : "subscribers"}${x.obsolete ? ` \xB7 obsolete ${x.obsolete}` : ""}`;
+  if (r.kind === "proc") return `procedure${of} \xB7 ${x.params} ${x.params === 1 ? "parameter" : "parameters"}${x.returns ? ` \xB7 returns ${x.returns}` : ""}${x.obsolete ? ` \xB7 obsolete ${x.obsolete}` : ""}`;
+  if (r.kind === "value") return `value ${x.ordinal}${of}${x.caption && x.caption !== r.name ? ` \xB7 "${x.caption}"` : ""}`;
+  return r.title;
+}
+function objectsAt(index2, type, id) {
+  return (STATE.get(index2)?.byObject.get(`${type}/${id}`) ?? []).map((i) => index2.records[i]);
+}
+function idsOf(index2, type) {
+  const out = /* @__PURE__ */ new Set();
+  for (const i of index2.byType.get("object") ?? []) {
+    const r = index2.records[i];
+    if (r.objectType === type && r.objectId != null) out.add(r.objectId);
+  }
+  return [...out];
+}
+function typoWords(index2, q) {
+  if (!STATE.get(index2)) return [];
+  return matchersOf(index2, q).filter((m) => m.words.size && [...m.words.values()].every((f) => f.how === "fuzzy")).map((m) => ({ term: m.term.text, words: [...m.words.keys()] }));
+}
+function namedBy(index2, r, q) {
+  if (!STATE.get(index2)) return 0;
+  const n = normOf(r);
+  return matchersOf(index2, q).reduce((a, m) => a + (best(m, n.main)?.f ?? best(m, n.tags)?.f ?? 0), 0);
+}
+function symbolRecords(kind, rows, ownerOf) {
+  const out = [];
+  for (const row of rows) {
+    const o = ownerOf(String(row[0]));
+    if (o) out.push(symbolToRecord(kind, row, o));
+  }
+  return out;
+}
+function countriesOf(index2) {
+  const st = STATE.get(index2);
+  return st ? [...st.byCountry.keys()].sort() : [];
+}
+
+// ../search/src/hints.ts
+function hints(index2, q, hits) {
+  const out = [];
+  const unknown = q.warnings.map((w) => /^unknown abbreviation (\w+)$/.exec(w)?.[1]).find(Boolean);
+  const digits = /(\d+)\s*$/.exec(q.raw)?.[1];
+  if (unknown && digits) {
+    const seen = /* @__PURE__ */ new Set();
+    const words = [...Object.entries(ABBR), ...Object.entries(TYPE_WORDS).filter(([w, t]) => w === t)];
+    const cands = words.map(([w, type]) => ({ w, type, e: editDistance(unknown, w, 1) })).filter((c) => c.e <= 1).map((c) => ({ ...c, d: c.e + (c.w[0] === unknown[0] ? 0 : 0.5) + (c.w.length === unknown.length ? 0 : 0.25) })).sort((a, b) => a.d - b.d || a.w.length - b.w.length || a.w.localeCompare(b.w));
+    for (const c of cands) {
+      if (seen.has(c.type) || out.length >= 3) continue;
+      if (!objectsAt(index2, c.type, Number(digits)).length) continue;
+      seen.add(c.type);
+      out.push({ text: `Did you mean "${c.w} ${digits}" (${c.type} ${digits})?`, query: `${c.w} ${digits}` });
+    }
+  }
+  if (q.ref) {
+    const there = objectsAt(index2, q.ref.type, q.ref.id);
+    if (!there.length) {
+      const ids = idsOf(index2, q.ref.type).sort((a, b) => Math.abs(a - q.ref.id) - Math.abs(b - q.ref.id) || a - b).slice(0, 3).sort((a, b) => a - b);
+      out.push({ text: `No ${q.ref.type} ${q.ref.id}.${ids.length ? ` Nearest ids: ${ids.map((i) => `${q.ref.type} ${i}`).join(", ")}.` : ""}`, ...ids.length ? { query: `${q.ref.type} ${ids[0]}` } : {} });
+    } else if (q.ref.country && !there.some((r) => r.country === q.ref.country) && there.some((r) => !r.country)) {
+      const w1 = there.find((r) => !r.country);
+      out.push({ text: `${q.ref.country.toUpperCase()} has no ${q.ref.type} ${q.ref.id} of its own; the W1 ${q.ref.type} applies.`, path: w1.id });
+    }
+  }
+  for (const t of typoWords(index2, q)) {
+    const pagesWith = (w) => (index2.postings.get(w) ?? []).reduce((n, i) => n + (index2.records[i].kind === "page" ? 1 : 0), 0);
+    const words = t.words.map((w) => ({ w, n: pagesWith(w) })).sort((a, b) => b.n - a.n).slice(0, 3);
+    const swap = (w) => q.raw.replace(new RegExp(t.term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i"), w);
+    out.push({ text: `${t.term}: no page; ${words.map((x) => `${x.w} (${x.n.toLocaleString("en")} ${x.n === 1 ? "page" : "pages"})`).join(", ")}`, query: swap(words[0].w) });
+  }
+  if (q.question) {
+    let hub = null, best2 = 0;
+    for (const i of index2.byType.get("topic") ?? []) {
+      const r = index2.records[i], named = namedBy(index2, r, q);
+      if (!named) continue;
+      const s = 3 * named + Math.log2((r.members ?? 0) + 1) + (r.narrative === "reviewed" ? 2 : r.narrative === "none" ? -2 : 0);
+      if (s > best2) {
+        best2 = s;
+        hub = r;
+      }
+    }
+    out.push({ text: `For what changed, open the object's Versions section or Changes; for how-to, start with the hub${hub ? `: ${hub.title}` : ""}.`, ...hub ? { path: hub.id } : {} });
+  }
+  void hits;
+  return out;
+}
+
+// src/embed.ts
+var MAX_TOKENS = 512;
+function parseModel(tokenizerJson, safetensors, config = {}) {
+  const t = JSON.parse(tokenizerJson);
+  if (t.model.type !== "WordPiece") throw new Error(`unsupported tokenizer model ${t.model.type}`);
+  const vocab = new Map(Object.entries(t.model.vocab));
+  const view = new DataView(safetensors.buffer, safetensors.byteOffset, safetensors.byteLength);
+  const headerLen = Number(view.getBigUint64(0, true));
+  const header = JSON.parse(new TextDecoder().decode(safetensors.subarray(8, 8 + headerLen)));
+  const name = Object.keys(header).find((k) => k !== "__metadata__");
+  if (!name) throw new Error("safetensors file has no tensor");
+  const { dtype, shape, data_offsets: [start, end] } = header[name];
+  if (dtype !== "F32" || shape.length !== 2) throw new Error(`unsupported tensor ${name}: ${dtype} ${shape.join("x")}`);
+  const bytes = safetensors.slice(8 + headerLen + start, 8 + headerLen + end);
+  const matrix = new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+  if (matrix.length !== shape[0] * shape[1]) throw new Error("tensor size does not match its shape");
+  const unk = t.model.unk_token !== void 0 ? vocab.get(t.model.unk_token) ?? null : null;
+  return { dims: shape[1], vocab, unk, matrix, normalize: config.normalize !== false, maxWordChars: t.model.max_input_chars_per_word ?? 100, prefix: t.model.continuing_subword_prefix ?? "##" };
+}
+var CJK = [[19968, 40959], [13312, 19903], [131072, 173791], [173824, 177983], [177984, 178207], [178208, 183983], [63744, 64255], [194560, 195103]];
+var isCjk = (cp) => CJK.some(([a, b]) => cp >= a && cp <= b);
+var isPunct = (ch, cp) => cp >= 33 && cp <= 47 || cp >= 58 && cp <= 64 || cp >= 91 && cp <= 96 || cp >= 123 && cp <= 126 || new RegExp("\\p{P}", "u").test(ch);
+function normalize(text2) {
+  let out = "";
+  for (const ch of text2) {
+    const cp = ch.codePointAt(0);
+    if (cp === 0 || cp === 65533) continue;
+    if (ch === "	" || ch === "\n" || ch === "\r" || /\s/u.test(ch)) {
+      out += " ";
+      continue;
+    }
+    if (/[\p{Cc}\p{Cf}]/u.test(ch)) continue;
+    out += isCjk(cp) ? ` ${ch} ` : ch;
+  }
+  return out.normalize("NFD").replace(new RegExp("\\p{Mn}", "gu"), "").toLowerCase();
+}
+function preTokenize(text2) {
+  const words = [];
+  let cur = "";
+  for (const ch of text2) {
+    if (/\s/u.test(ch)) {
+      if (cur) words.push(cur);
+      cur = "";
+      continue;
+    }
+    if (isPunct(ch, ch.codePointAt(0))) {
+      if (cur) words.push(cur);
+      words.push(ch);
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur) words.push(cur);
+  return words;
+}
+function tokenize2(m, text2) {
+  const ids = [];
+  for (const word of preTokenize(normalize(text2))) {
+    const chars = [...word];
+    if (chars.length > m.maxWordChars) continue;
+    const pieces = [];
+    let start = 0, bad = false;
+    while (start < chars.length) {
+      let end = chars.length, found;
+      while (start < end) {
+        const sub = (start > 0 ? m.prefix : "") + chars.slice(start, end).join("");
+        found = m.vocab.get(sub);
+        if (found !== void 0) break;
+        end--;
+      }
+      if (found === void 0) {
+        bad = true;
+        break;
+      }
+      pieces.push(found);
+      start = end;
+    }
+    if (!bad) {
+      for (const id of pieces) if (id !== m.unk) ids.push(id);
+    }
+    if (ids.length >= MAX_TOKENS) return ids.slice(0, MAX_TOKENS);
+  }
+  return ids;
+}
+function embed(m, text2) {
+  const v = new Float32Array(m.dims);
+  const ids = tokenize2(m, text2);
+  if (!ids.length) return v;
+  for (const id of ids) {
+    const off = id * m.dims;
+    for (let d = 0; d < m.dims; d++) v[d] += m.matrix[off + d];
+  }
+  for (let d = 0; d < m.dims; d++) v[d] /= ids.length;
+  if (m.normalize) {
+    let n = 0;
+    for (let d = 0; d < m.dims; d++) n += v[d] * v[d];
+    n = Math.sqrt(n);
+    if (n > 0) for (let d = 0; d < m.dims; d++) v[d] /= n;
+  }
+  return v;
+}
+function dot(a, b, bOffset = 0) {
+  let s = 0;
+  for (let d = 0; d < a.length; d++) s += a[d] * b[bOffset + d];
+  return s;
+}
+
+// src/sections.ts
+var DEFAULT_BUDGET = 3e4;
+var MIN_BUDGET = 5e3;
+var PREVIEW_ROWS = 5;
+var ROW_CLIP = 200;
+var PROSE_CLIP = 800;
+var HEAD_LINE_MAX = 120;
+var FM_LIST_CHARS = 600;
+var FM_LIST_MIN = 3;
+var RESERVE = 300;
+var OBJECT_KEYS = {
+  "Properties": "properties",
+  "Fields": "fields",
+  "Fields on this page": "controls",
+  "Actions": "actions",
+  "Keys": "keys",
+  "Values": "values",
+  "Events published": "events",
+  "Trigger event subscribers": "trigger_subscribers",
+  "Event subscriptions": "subscriptions",
+  "Procedures": "procedures",
+  "Triggers": "triggers",
+  "Relations": "relations",
+  "Referenced by": "referenced_by",
+  "Pages and codeunits on this table": "pages",
+  "Extended by": "extended_by",
+  "Calls": "calls",
+  "Called by": "called_by",
+  "Implements": "implements",
+  "Implemented by": "implemented_by",
+  "Recent changes": "changes",
+  "Across versions": "versions",
+  "Countries that replace it": "countries",
+  "Documented on Microsoft Learn": "learn",
+  "Deprecations": "deprecations",
+  "Ask your agent": "ask"
+};
+var snake = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+var blank = (l) => l.trim() === "";
+var fmt = (n) => n.toLocaleString("en-US");
+var FENCE = /^\s*```/;
+var SEPARATOR = /^\|\s*:?-/;
+var CAP_NOTE = /^- and \d+ more/;
+function budgetOf(env) {
+  const n = env === void 0 || env.trim() === "" ? NaN : Number(env);
+  if (!Number.isFinite(n) || n < 0) return DEFAULT_BUDGET;
+  if (n === 0) return Infinity;
+  return Math.max(MIN_BUDGET, Math.floor(n));
+}
+function sectionKey(heading) {
+  return OBJECT_KEYS[heading] ?? snake(heading);
+}
+function splitSection(lines) {
+  const head = [], rows = [];
+  let pending = [];
+  let table2 = null, group = null;
+  let inTable = false, afterRow = false, fence = null;
+  const other = (line2, kind = "text") => {
+    if (rows.length) pending.push({ line: line2, kind });
+    else head.push(line2);
+  };
+  const addRow = (first) => {
+    if (rows.length) {
+      const prev = rows[rows.length - 1];
+      for (const p of pending) {
+        if (p.kind === "group" && p.line === group) continue;
+        if (p.kind === "table" && table2 && (p.line === table2[0] || p.line === table2[1])) continue;
+        if (!blank(p.line)) prev.lines.push(p.line);
+      }
+    }
+    pending = [];
+    rows.push({ lines: [first], table: table2, group });
+    afterRow = true;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i];
+    if (fence) {
+      if (fence === "row") rows[rows.length - 1].lines.push(l);
+      else other(l);
+      if (FENCE.test(l)) fence = null;
+      continue;
+    }
+    if (FENCE.test(l)) {
+      if (afterRow && /^ {2,}/.test(l)) {
+        rows[rows.length - 1].lines.push(l);
+        fence = "row";
+      } else {
+        other(l);
+        fence = "text";
+        afterRow = false;
+        inTable = false;
+        table2 = null;
+      }
+      continue;
+    }
+    if (afterRow && /^ {2,}\S/.test(l)) {
+      rows[rows.length - 1].lines.push(l);
+      continue;
+    }
+    if (l.startsWith("|")) {
+      if (!inTable && i + 1 < lines.length && SEPARATOR.test(lines[i + 1])) {
+        table2 = [l, lines[i + 1]];
+        inTable = true;
+        afterRow = false;
+        other(l, "table");
+        other(lines[++i], "table");
+        continue;
+      }
+      if (inTable) {
+        addRow(l);
+        continue;
+      }
+    } else if (inTable) {
+      inTable = false;
+      table2 = null;
+    }
+    if (l.startsWith("- ") && !CAP_NOTE.test(l)) {
+      addRow(l);
+      continue;
+    }
+    afterRow = false;
+    if (l.startsWith("### ")) {
+      group = l;
+      other(l, "group");
+      continue;
+    }
+    other(l);
+  }
+  const tail = pending.map((p) => p.line);
+  return { head, rows, tail };
+}
+var memo = null;
+function parsePage(md) {
+  if (memo && memo.md === md) return memo.page;
+  const all = md.split("\n");
+  let i = 0, frontmatter = "";
+  if (all[0] === "---") {
+    const end = all.indexOf("---", 1);
+    if (end > 0) {
+      frontmatter = all.slice(1, end).join("\n");
+      i = end + 1;
+    }
+  }
+  const pre = [], chunks = [];
+  let fence = false;
+  for (; i < all.length; i++) {
+    const l = all[i];
+    if (!fence && l.startsWith("## ")) {
+      chunks.push({ heading: l.slice(3).trim(), lines: [] });
+      continue;
+    }
+    if (FENCE.test(l)) fence = !fence;
+    (chunks.length ? chunks[chunks.length - 1].lines : pre).push(l);
+  }
+  const seen = /* @__PURE__ */ new Map();
+  const sections = chunks.map(({ heading, lines }) => {
+    while (lines.length && blank(lines[lines.length - 1])) lines.pop();
+    const base = sectionKey(heading), n = (seen.get(base) ?? 0) + 1;
+    seen.set(base, n);
+    return { heading, key: n === 1 ? base : `${base}_${n}`, lines, ...splitSection(lines) };
+  });
+  const preamble = pre.join("\n").replace(/^\s*\n/, "").replace(/\s+$/, "");
+  const page = { frontmatter, preamble, sections };
+  memo = { md, page };
+  return page;
+}
+function frontmatterSection(p) {
+  const lines = p.frontmatter ? p.frontmatter.split("\n") : [];
+  return { heading: "", key: "frontmatter", lines, head: [], rows: lines.map((l) => ({ lines: [l], table: null, group: null })), tail: [] };
+}
+function findSection(p, want) {
+  const w = want.trim().toLowerCase(), ws = snake(want);
+  if (w === "frontmatter") return frontmatterSection(p);
+  return p.sections.find((s) => s.key === w) ?? p.sections.find((s) => s.heading.toLowerCase() === w) ?? p.sections.find((s) => ws !== "" && snake(s.heading) === ws) ?? null;
+}
+var keyList = (p, counts = false) => [...p.sections.map((s) => counts && s.rows.length ? `${s.key} (${s.rows.length})` : s.key), "frontmatter"].join(", ");
+var titleOf = (p, path) => p.preamble.split("\n").find((l) => l.startsWith("# "))?.slice(2).trim() || path;
+function clip(s, n, mark = "\u2026") {
+  if (s.length <= n) return s;
+  const end = /[\uD800-\uDBFF]/.test(s[n - 2]) ? n - 2 : n - 1;
+  return `${s.slice(0, end)}${mark}`;
+}
+var indentOf = (l) => l.length - l.trimStart().length;
+var BLOCK_SCALAR = /(?:^|:|-)\s*[|>][-+0-9]*\s*$/;
+var LIST_ITEM = /^( *)-(?: |$)/;
+function cutLists(lines) {
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const l = lines[i], m = LIST_ITEM.exec(l);
+    if (!m) {
+      out.push(l);
+      i++;
+      if (BLOCK_SCALAR.test(l)) {
+        const ind2 = indentOf(l);
+        while (i < lines.length && (blank(lines[i]) || indentOf(lines[i]) > ind2)) out.push(lines[i++]);
+      }
+      continue;
+    }
+    const ind = m[1].length, items = [];
+    while (i < lines.length && indentOf(lines[i]) === ind && LIST_ITEM.test(lines[i])) {
+      const item = [lines[i++]];
+      while (i < lines.length && (indentOf(lines[i]) > ind || blank(lines[i]) && i + 1 < lines.length && indentOf(lines[i + 1]) > ind)) item.push(lines[i++]);
+      items.push(BLOCK_SCALAR.test(item[0]) ? item : [item[0], ...cutLists(item.slice(1))]);
+    }
+    const size = (k2) => items.slice(0, k2).map((it) => it.join("\n")).join("\n").length;
+    if (size(items.length) <= FM_LIST_CHARS) {
+      out.push(...items.flat());
+      continue;
+    }
+    let k = 0;
+    while (k < items.length && size(k + 1) <= FM_LIST_CHARS) k++;
+    k = Math.max(k, FM_LIST_MIN);
+    out.push(...items.slice(0, k).flat());
+    if (k < items.length) out.push(`${" ".repeat(ind)}# \u2026 ${items.length - k} more; section: "frontmatter"`);
+  }
+  return out;
+}
+function compactFrontmatter(yaml) {
+  const lines = yaml.split("\n"), kept = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (/^generated:/.test(lines[i])) {
+      while (i + 1 < lines.length && (indentOf(lines[i + 1]) > 0 || blank(lines[i + 1]))) i++;
+      continue;
+    }
+    kept.push(lines[i]);
+  }
+  return cutLists(kept).join("\n");
+}
+function compactView(md, path, budget) {
+  const p = parsePage(md);
+  const out = [];
+  if (md.startsWith("---\n") && p.frontmatter !== "") out.push("---", compactFrontmatter(p.frontmatter), "---", "");
+  if (p.preamble) out.push(p.preamble, "");
+  out.push(`Compact view: this page is ${fmt(md.length)} characters and one answer holds ${fmt(budget)}, so each section shows its first ${PREVIEW_ROWS} rows. Sections: ${keyList(p, true)}. Read one with cat("${path}", section: "<key>"); offset and limit page through a long one.`, "");
+  for (const s of p.sections) {
+    out.push(`## ${s.heading}`);
+    const more = `\u2026 (section: "${s.key}")`;
+    if (!s.rows.length) {
+      const text2 = s.head.filter((l) => !blank(l)).join("\n");
+      if (text2) out.push(clip(text2, PROSE_CLIP, more));
+    } else {
+      const lead = s.head.find((l) => !blank(l) && !l.startsWith("|") && !l.startsWith("### "));
+      if (lead && lead.length <= HEAD_LINE_MAX) out.push(lead);
+      let group = null, table2 = null;
+      for (const r of s.rows.slice(0, PREVIEW_ROWS)) {
+        if (r.group && r.group !== group) {
+          out.push(r.group);
+          group = r.group;
+        }
+        const t = r.table ? r.table.join("\n") : null;
+        if (r.table && t !== table2) out.push(...r.table);
+        table2 = t;
+        out.push(clip(r.lines[0], ROW_CLIP));
+      }
+      if (s.rows.length > PREVIEW_ROWS) out.push(`\u2192 ${s.rows.length - PREVIEW_ROWS} more of ${s.rows.length}: cat("${path}", section: "${s.key}", offset: ${PREVIEW_ROWS})`);
+      else {
+        const text2 = s.tail.filter((l) => !blank(l)).join("\n");
+        if (text2) out.push(clip(text2, PROSE_CLIP, more));
+      }
+    }
+    out.push("");
+  }
+  return `${out.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\n+$/, "")}
+`;
+}
+var dropLeadingBlank = (lines) => {
+  let i = 0;
+  while (i < lines.length && blank(lines[i])) i++;
+  return lines.slice(i);
+};
+function sectionView(md, path, want, offset, limit, budget, site) {
+  const p = parsePage(md);
+  const nl = (lines) => `${lines.join("\n")}
+`;
+  const s = findSection(p, want);
+  if (!s) return `No section "${want}" on ${path}. Sections: ${keyList(p)}.`;
+  const fm = s.key === "frontmatter" && s.heading === "";
+  const first = `${titleOf(p, path)}, section "${s.key}": ${site}${path}/`;
+  const heading = fm ? [] : [`## ${s.heading}`];
+  const n = s.rows.length, off = Math.max(0, Math.floor(offset ?? 0));
+  const verbatim = nl(fm ? [first, "", "---", ...s.lines, "---"] : [first, "", ...heading, ...s.lines]);
+  if (!n || off === 0 && limit === void 0 && verbatim.length <= budget) return verbatim;
+  const tail = dropLeadingBlank(s.tail);
+  if (off >= n) return nl([first, "", ...heading, "", ...tail.length ? tail : [`No rows after ${n} in section "${s.key}" of ${path}.`]]);
+  const out = [first, "", ...heading, ...fm ? [] : [""]];
+  let group = null, table2 = null;
+  if (off === 0) {
+    out.push(...dropLeadingBlank(s.head));
+    group = s.rows[0].group;
+    table2 = s.rows[0].table ? s.rows[0].table.join("\n") : null;
+  }
+  let len = out.join("\n").length, b = off;
+  const end = limit === void 0 ? n : Math.min(n, off + Math.max(1, Math.floor(limit)));
+  for (let r = off; r < end; r++) {
+    const row = s.rows[r], add = [];
+    let g = group, t = table2;
+    if (row.group && row.group !== g) {
+      add.push(...out.length && !blank(out[out.length - 1]) ? [""] : [], row.group, "");
+      g = row.group;
+      t = null;
+    }
+    const rt = row.table ? row.table.join("\n") : null;
+    if (row.table && rt !== t) add.push(...row.table);
+    t = rt;
+    add.push(...row.lines);
+    const size = add.join("\n").length + 1;
+    if (r > off && len + size > budget - RESERVE) break;
+    out.push(...add);
+    len += size;
+    group = g;
+    table2 = t;
+    b = r + 1;
+  }
+  const rows = `Rows ${off + 1}-${b} of ${n}.`;
+  if (b < n) return nl([...out, "", `${rows} Next: cat("${path}", section: "${s.key}", offset: ${b})`]);
+  if (!tail.length) return nl([...out, "", rows]);
+  const withTail = nl([...out, "", ...tail, "", rows]);
+  if (limit === void 0 && withTail.length <= budget) return withTail;
+  return nl([...out, "", `${rows} The section's closing text: cat("${path}", section: "${s.key}", offset: ${n})`]);
+}
+var ANCHOR_SECTION = { field: ["fields", "field"], value: ["values", "value"], event: ["events", "event"], proc: ["procedures", "procedure"] };
+function anchorView(md, path, anchor, site) {
+  const a = anchor.replace(/^#/, ""), m = /^(field|value|event|proc)-(.+)$/.exec(a);
+  if (!m) return null;
+  const [key, label] = ANCHOR_SECTION[m[1]];
+  const p = parsePage(md);
+  const s = p.sections.find((x) => x.key === key);
+  if (!s) return null;
+  const match = m[1] === "field" || m[1] === "value" ? (l) => l.startsWith(`| ${m[2]} |`) : (l) => l.startsWith(`- \`${m[2]}(`);
+  const rows = s.rows.filter((r) => match(r.lines[0]));
+  if (!rows.length) return null;
+  return `${[`${titleOf(p, path)}, ${label} ${m[2]}: ${site}${path}/#${a}`, "", `## ${s.heading}`, ...rows[0].table ?? [], ...rows.flatMap((r) => r.lines)].join("\n")}
+`;
+}
+function pageView(md, path, a, budget, site) {
+  const hash = path.indexOf("#");
+  if (hash >= 0) {
+    const clean = path.slice(0, hash), anchor = path.slice(hash);
+    return anchorView(md, clean, anchor, site) ?? `(No row for ${anchor} on this page.)
+
+${pageView(md, clean, {}, budget, site)}`;
+  }
+  if (a.section !== void 0 && a.section.trim() !== "") return sectionView(md, path, a.section, a.offset, a.limit, budget, site);
+  if (a.offset !== void 0 || a.limit !== void 0) {
+    return `offset and limit read one section: cat("${path}", section: "<key>", offset: ${a.offset ?? 0}). Sections: ${keyList(parsePage(md))}.`;
+  }
+  if (md.length <= budget) return md;
+  return compactView(md, path, budget);
+}
+
+// src/server.ts
+var VERSION = "0.4.0";
+var SITE = (process.env.BC_OBSERVATORY_SITE ?? "https://waldo1001.github.io/waldo.BCObservatory/").replace(/\/?$/, "/");
+var LOCAL = process.env.BC_OBSERVATORY_LOCAL ? resolve(process.env.BC_OBSERVATORY_LOCAL) : null;
+var BUDGET = budgetOf(process.env.BC_OBSERVATORY_MAX_CHARS);
+var B = (Number.isFinite(BUDGET) ? BUDGET : DEFAULT_BUDGET).toLocaleString("en-US");
+var REPO = "https://github.com/waldo1001/waldo.BCObservatory";
+var DAY = 864e5;
+var cacheDir = join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "bc-observatory", createHash("sha256").update(SITE).digest("hex").slice(0, 12));
+async function fetchText(url2) {
+  const res = await fetch(url2, { headers: { "user-agent": `bc-observatory-mcp/${VERSION}` } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} for ${url2}`);
+  return res.text();
+}
 async function dataFile(rel) {
-    if (LOCAL)
-        return readFileSync(join(LOCAL, "data", rel), "utf8");
-    return fetchText(`${SITE}${rel}`);
+  if (LOCAL) return readFileSync(join(LOCAL, "data", rel), "utf8");
+  return fetchText(`${SITE}${rel}`);
 }
-/** A page's markdown: content/<path>.md locally, the site's markdown twin otherwise. */
 async function pageMarkdown(path) {
-    const clean = path.replace(/^\/+|\/+$/g, "").replace(/\.md$/, "");
-    if (LOCAL) {
-        const p = join(LOCAL, "content", `${clean}.md`);
-        if (!existsSync(p))
-            throw new Error(`no page at ${clean}`);
-        return readFileSync(p, "utf8");
-    }
-    return fetchText(`${SITE}${clean}.md`);
-}
-let pages = [];
-let search = null;
-let loadedAt = 0;
-/** Index shards by sha256: cached on disk, downloaded only when the manifest names a new hash. */
+  const clean = path.replace(/^\/+|\/+$/g, "").replace(/\.md$/, "");
+  if (LOCAL) {
+    const p = join(LOCAL, "content", `${clean}.md`);
+    if (!existsSync(p)) throw new Error(`no page at ${clean}`);
+    return readFileSync(p, "utf8");
+  }
+  return fetchText(`${SITE}${clean}.md`);
+}
+var pages = [];
+var index = null;
+var loadedAt = 0;
+async function shard(file, sha) {
+  const cached = join(cacheDir, `${sha}.json`);
+  if (!LOCAL && existsSync(cached)) return readFileSync(cached, "utf8");
+  const text2 = await dataFile(`index/${file}`);
+  if (!LOCAL) writeFileSync(cached, text2);
+  return text2;
+}
 async function loadIndex() {
-    if (search && Date.now() - loadedAt < DAY)
-        return;
-    const manifest = JSON.parse(await dataFile("index/index-manifest.json"));
-    const all = [];
-    if (!LOCAL)
-        mkdirSync(cacheDir, { recursive: true });
-    for (const s of manifest.shards) {
-        const cached = join(cacheDir, `${s.sha256}.json`);
-        let text;
-        if (!LOCAL && existsSync(cached))
-            text = readFileSync(cached, "utf8");
-        else {
-            text = await dataFile(`index/${s.file}`);
-            if (!LOCAL)
-                writeFileSync(cached, text);
-        }
-        all.push(...JSON.parse(text));
+  if (index && Date.now() - loadedAt < DAY) return;
+  const manifest = JSON.parse(await dataFile("index/index-manifest.json"));
+  const all = [];
+  if (!LOCAL) mkdirSync(cacheDir, { recursive: true });
+  for (const s of manifest.shards) all.push(...JSON.parse(await shard(s.file, s.sha256)));
+  pages = all;
+  const idx = prepare(all.map(pageToRecord));
+  let sm = null;
+  try {
+    sm = JSON.parse(await dataFile("index/symbols-manifest.json"));
+  } catch {
+    sm = null;
+  }
+  if (sm) {
+    const byPath = new Map(idx.records.map((r) => [r.id, r]));
+    for (const [k, e] of Object.entries(sm.kinds)) {
+      const files = e.files ?? (e.file ? [e.file] : []);
+      for (const f of files) {
+        const doc = JSON.parse(await shard(f, files.length === 1 ? e.sha256 : `${e.sha256}-${f}`));
+        prepare(symbolRecords(KIND_OF[k], doc.rows, (pk) => byPath.get(`objects/${pk}`)), idx);
+      }
     }
-    const ms = new MiniSearch({
-        idField: "path", fields: ["title", "summary", "tagText", "path"],
-        storeFields: ["path", "type", "title", "summary", "tier", "system", "date", "object_type", "object_id", "app", "country", "source", "status", "obsolete"],
-        extractField: (doc, f) => (f === "tagText" ? (doc.tags ?? []).join(" ") : doc[f]),
-        searchOptions: { boost: { title: 3, tagText: 1.5 }, prefix: true, fuzzy: 0.15 },
-    });
-    ms.addAll(all);
-    pages = all;
-    search = ms;
-    loadedAt = Date.now();
-}
-const url = (path) => `${SITE}${path}/`;
-const line = (r) => `- ${r.title} [${r.type}${r.tier ? `, ${r.tier}` : ""}${r.date ? `, ${r.date}` : ""}] path=${r.path}\n  ${r.summary}`;
-const text = (t) => ({ content: [{ type: "text", text: t }] });
-// ---------------------------------------------------------------------------------------------- embeddings (D63)
-const MODEL = {
-    repo: "minishlab/potion-base-8M", revision: "bf8b056651a2c21b8d2565580b8569da283cab23",
-    sha256: {
-        "config.json": "2a6ac0e9aaa356a68a5688070db78fc3a464fefe85d2f06a1905ce3718687553",
-        "tokenizer.json": "e67e803f624fb4d67dea1c730d06e1067e1b14d830e2c2202569e3ef0f70bb50",
-        "model.safetensors": "f65d0f325faadc1e121c319e2faa41170d3fa07d8c89abd48ca5358d9a223de2",
-    },
+  }
+  index = idx;
+  loadedAt = Date.now();
+}
+var url = (path) => `${SITE}${path}/`;
+var line = (r, tag = "") => `- ${r.title}${r.caption ? ` (captioned "${r.caption}")` : ""} [${r.type}${r.tier ? `, ${r.tier}` : ""}${r.date ? `, ${r.date}` : ""}] path=${r.path}${tag}${r.path_label ? `
+  in: ${r.path_label}` : ""}${r.stats ? `
+  ${r.stats}` : ""}
+  ${r.summary}`;
+var text = (t) => ({ content: [{ type: "text", text: t }] });
+var symbolHit = (r, tag = "") => `- ${r.name} (${symbolLine(r).replace(/ · /g, ", ")}) path=${r.id}${tag}${r.text ? `
+  ${r.text}` : ""}`;
+var hitLine = (r, tag = "") => r.kind === "page" && r.page ? line(r.page, tag) : symbolHit(r, tag);
+var MODEL = {
+  repo: "minishlab/potion-base-8M",
+  revision: "bf8b056651a2c21b8d2565580b8569da283cab23",
+  sha256: {
+    "config.json": "2a6ac0e9aaa356a68a5688070db78fc3a464fefe85d2f06a1905ce3718687553",
+    "tokenizer.json": "e67e803f624fb4d67dea1c730d06e1067e1b14d830e2c2202569e3ef0f70bb50",
+    "model.safetensors": "f65d0f325faadc1e121c319e2faa41170d3fa07d8c89abd48ca5358d9a223de2"
+  }
 };
-const MODEL_DIR = process.env.BC_OBSERVATORY_MODEL_DIR ? resolve(process.env.BC_OBSERVATORY_MODEL_DIR) : null;
-// a local checkout is for offline use and tests: no download there unless a model directory is named
-const EMBEDDINGS = process.env.BC_OBSERVATORY_EMBEDDINGS !== "0" && (!LOCAL || !!MODEL_DIR);
-let model = null;
-let modelError = EMBEDDINGS ? null : "turned off";
-let vectors = null;
+var MODEL_DIR = process.env.BC_OBSERVATORY_MODEL_DIR ? resolve(process.env.BC_OBSERVATORY_MODEL_DIR) : null;
+var EMBEDDINGS = process.env.BC_OBSERVATORY_EMBEDDINGS !== "0" && (!LOCAL || !!MODEL_DIR);
+var model = null;
+var modelError = EMBEDDINGS ? null : "turned off";
+var vectors = null;
 async function loadModel() {
-    if (model || modelError)
-        return model;
-    try {
-        let dir = MODEL_DIR;
-        if (!dir) {
-            dir = join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "bc-observatory", "models", `potion-base-8M@${MODEL.revision.slice(0, 12)}`);
-            mkdirSync(dir, { recursive: true });
-            for (const [file, sha] of Object.entries(MODEL.sha256)) {
-                const p = join(dir, file);
-                if (existsSync(p))
-                    continue;
-                const res = await fetch(`https://huggingface.co/${MODEL.repo}/resolve/${MODEL.revision}/${file}`, { headers: { "user-agent": `bc-observatory-mcp/${VERSION}` } });
-                if (!res.ok)
-                    throw new Error(`HTTP ${res.status} for ${file}`);
-                const buf = Buffer.from(await res.arrayBuffer());
-                if (createHash("sha256").update(buf).digest("hex") !== sha)
-                    throw new Error(`${file} does not match its pinned SHA-256`);
-                writeFileSync(p, buf);
-            }
-        }
-        model = parseModel(readFileSync(join(dir, "tokenizer.json"), "utf8"), new Uint8Array(readFileSync(join(dir, "model.safetensors"))), JSON.parse(readFileSync(join(dir, "config.json"), "utf8")));
+  if (model || modelError) return model;
+  try {
+    let dir = MODEL_DIR;
+    if (!dir) {
+      dir = join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "bc-observatory", "models", `potion-base-8M@${MODEL.revision.slice(0, 12)}`);
+      mkdirSync(dir, { recursive: true });
+      for (const [file, sha] of Object.entries(MODEL.sha256)) {
+        const p = join(dir, file);
+        if (existsSync(p)) continue;
+        const res = await fetch(`https://huggingface.co/${MODEL.repo}/resolve/${MODEL.revision}/${file}`, { headers: { "user-agent": `bc-observatory-mcp/${VERSION}` } });
+        if (!res.ok) throw new Error(`HTTP ${res.status} for ${file}`);
+        const buf = Buffer.from(await res.arrayBuffer());
+        if (createHash("sha256").update(buf).digest("hex") !== sha) throw new Error(`${file} does not match its pinned SHA-256`);
+        writeFileSync(p, buf);
+      }
     }
-    catch (e) {
-        modelError = String(e.message).slice(0, 160);
-    }
-    return model;
+    model = parseModel(readFileSync(join(dir, "tokenizer.json"), "utf8"), new Uint8Array(readFileSync(join(dir, "model.safetensors"))), JSON.parse(readFileSync(join(dir, "config.json"), "utf8")));
+  } catch (e) {
+    modelError = String(e.message).slice(0, 160);
+  }
+  return model;
 }
-/** One vector per page (title, summary, tags), rebuilt when the index reloads: 22k pages take about 0.3 s. */
 function pageVectors(m) {
-    if (vectors && vectors.at === loadedAt)
-        return vectors.data;
-    const data = new Float32Array(pages.length * m.dims);
-    pages.forEach((p, i) => data.set(embed(m, [p.title, p.summary, ...(p.tags ?? [])].filter(Boolean).join(". ")), i * m.dims));
-    vectors = { at: loadedAt, data };
-    return data;
-}
-/** Reciprocal rank fusion of ranked lists of paths (k = 60). */
-export function fuse(lists, k = 60) {
-    const score = new Map();
-    for (const list of lists)
-        list.forEach((p, i) => score.set(p, (score.get(p) ?? 0) + 1 / (k + i + 1)));
-    return [...score].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([p]) => p);
-}
-// ---------------------------------------------------------------------------------------------- tools
-export async function toolSearch(a) {
-    await loadIndex();
-    const keep = (r) => (!a.type || r.type === a.type) && (!a.tier || r.tier === a.tier) && (!a.system || r.system === a.system);
-    const limit = a.limit ?? 10, mode = a.mode ?? "hybrid", POOL = 50;
-    const keyword = mode === "semantic" ? [] : search.search(a.query, { filter: (r) => keep(r) }).slice(0, POOL).map((r) => r.path);
-    let semantic = [], note = "";
-    if (mode !== "keyword") {
-        const m = await loadModel();
-        if (m) {
-            const q = embed(m, a.query), data = pageVectors(m);
-            if (q.some((x) => x !== 0)) {
-                const scored = [];
-                pages.forEach((p, i) => { if (keep(p))
-                    scored.push([dot(q, data, i * m.dims), i]); });
-                semantic = scored.sort((x, y) => y[0] - x[0]).slice(0, POOL).map(([, i]) => pages[i].path);
-            }
-        }
-        else if (mode === "semantic")
-            note = ` (semantic search unavailable: ${modelError}; keyword results instead)`;
-        if (!m && mode === "semantic")
-            semantic = search.search(a.query, { filter: (r) => keep(r) }).slice(0, POOL).map((r) => r.path);
-    }
-    const byPath = new Map(pages.map((p) => [p.path, p]));
-    const hits = fuse([keyword, semantic].filter((l) => l.length)).slice(0, limit).map((p) => byPath.get(p)).filter(Boolean);
-    if (!hits.length)
-        return `No pages match "${a.query}". Try fewer words, or ls("") to browse sections.`;
-    const how = semantic.length && keyword.length ? "keyword + semantic" : semantic.length ? "semantic" : "keyword";
-    return `${hits.length} results, ${how}${note} (read one with cat(path)):\n${hits.map(line).join("\n")}`;
-}
-export async function toolLs(a) {
-    await loadIndex();
-    const prefix = (a.path ?? "").replace(/^\/+|\/+$/g, "");
-    const under = pages.filter((p) => !prefix || p.path === prefix || p.path.startsWith(`${prefix}/`));
-    if (!under.length)
-        return `Nothing under "${prefix}". Sections: ${[...new Set(pages.map((p) => p.path.split("/")[0]))].sort().join(", ")}.`;
-    const depth = prefix ? prefix.split("/").length : 0;
-    const dirs = new Map(), files = [];
-    for (const p of under) {
-        const parts = p.path.split("/");
-        if (parts.length === depth + 1)
-            files.push(p);
-        else if (parts.length > depth + 1)
-            dirs.set(parts.slice(0, depth + 1).join("/"), (dirs.get(parts.slice(0, depth + 1).join("/")) ?? 0) + 1);
-    }
-    const MAX = 200;
-    const out = [...[...dirs].sort().map(([d, n]) => `${d}/ (${n} pages)`), ...files.slice(0, MAX).map((f) => `${f.path}: ${f.title}`)];
-    return `${out.join("\n")}${files.length > MAX ? `\n... and ${files.length - MAX} more pages; use search() to narrow down` : ""}`;
-}
-export async function toolCat(a) {
-    return pageMarkdown(a.path);
-}
-export async function toolGetObject(a) {
-    await loadIndex();
-    const type = a.type.toLowerCase().replace(/\s+/g, "");
-    const want = a.idOrName.trim().replace(/^"|"$/g, "");
-    const objs = pages.filter((p) => p.type === "object" && p.object_type === type);
-    const hit = /^\d+$/.test(want) ? objs.find((p) => p.object_id === Number(want))
-        : objs.find((p) => p.title.toLowerCase().endsWith(`"${want.toLowerCase()}"`));
-    if (!hit)
-        return `No ${type} "${want}" in W1 or Microsoft's first-party apps (BC28-30). Never invent object ids; country-only objects are listed on localization pages.`;
-    return pageMarkdown(hit.path);
-}
-export async function toolDiffObject(a) {
-    const key = `${a.type.toLowerCase()}/${a.id.toLowerCase()}`;
-    let diff;
-    try {
-        diff = JSON.parse(await dataFile(`code/diffs/version/${a.from}__${a.to}.json`));
-    }
-    catch {
-        return `No version diff ${a.from} -> ${a.to}. Diffs exist between consecutive majors from BC23 to BC30 (23 -> 24, ..., 29 -> 30); a changed member lists only what differs, as [from, to].`;
-    }
-    const o = diff.objects.find((x) => x.key === key);
-    if (!o)
-        return `${key} did not change between BC${a.from} and BC${a.to} (or is not a W1 object).`;
-    return `${key} "${o.name}" BC${a.from} -> BC${a.to}: ${o.change}\n${JSON.stringify(o, null, 1)}`;
-}
-export async function toolLocalization(a) {
-    return pageMarkdown(`localizations/${a.country.toLowerCase()}`);
-}
-export async function toolWhatsNew(a) {
-    await loadIndex();
-    const since = a.since.slice(0, 10);
-    const items = pages.filter((p) => p.date && p.date >= since && (!a.type || p.type === a.type)).sort((x, y) => y.date.localeCompare(x.date)).slice(0, a.limit ?? 30);
-    if (!items.length)
-        return `Nothing dated on or after ${since}.`;
-    return `${items.length} items since ${since}, newest first:\n${items.map(line).join("\n")}`;
-}
-export async function toolBlogFootprint(a) {
-    await loadIndex();
-    const items = pages.filter((p) => p.source === a.source).sort((x, y) => (y.date ?? "").localeCompare(x.date ?? ""));
-    if (!items.length)
-        return `No posts or videos from source "${a.source}" yet. Source ids are listed in ${REPO}/blob/main/sources.yaml.`;
-    const systems = new Map();
-    for (const p of items)
-        if (p.system)
-            systems.set(p.system, (systems.get(p.system) ?? 0) + 1);
-    return `${a.source}: ${items.length} items, ${items.at(-1).date ?? "?"} to ${items[0].date ?? "?"}. Systems: ${[...systems].sort((x, y) => y[1] - x[1]).map(([s, n]) => `${s} ${n}`).join(", ")}.\n${items.slice(0, 20).map(line).join("\n")}`;
-}
-export function toolFeedback(a) {
-    const title = `Feedback on ${a.path}`;
-    const body = `Page: ${url(a.path)}\n\n${a.message}\n\n(sent from the bc-observatory MCP server ${VERSION})`;
-    return `Open this link to file the issue (no sign-in through the agent): ${REPO}/issues/new?title=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}&labels=feedback`;
-}
-// ---------------------------------------------------------------------------------------------- server
-export function createServer() {
-    const server = new McpServer({ name: "bc-observatory", version: VERSION }, {
-        instructions: "BC Observatory: an agent-first knowledge base of Microsoft Dynamics 365 Business Central (Learn hubs, AL objects from the code for BC28-30, localizations, roadmap features, videos, community posts). Every page carries a trust tier (official = Microsoft, community = everyone else) and a review state: say which tier a claim comes from. Never invent AL object ids or version numbers: look them up with get_object. Start with search(), read pages with cat(path), browse with ls(path).",
-    });
-    server.registerTool("search", { title: "Search the knowledge base", description: "Search every page (title, summary, tags). Hybrid by default: keywords plus meaning, so a synonym or a paraphrase still finds the page; mode 'keyword' for exact terms such as an object name, 'semantic' for meaning only. Filter by type (topic, feature, object, localization, video, post), tier (official, community) or galaxy system (finance, sales, development, ...).",
-        inputSchema: { query: z.string(), type: z.string().optional(), tier: z.string().optional(), system: z.string().optional(), limit: z.number().int().min(1).max(50).optional(), mode: z.enum(["hybrid", "keyword", "semantic"]).optional() } }, async (a) => text(await toolSearch(a)));
-    server.registerTool("ls", { title: "List pages", description: "Browse the page tree, e.g. ls('objects/table') or ls('localizations'); empty path lists the sections.", inputSchema: { path: z.string().optional() } }, async (a) => text(await toolLs(a)));
-    server.registerTool("cat", { title: "Read a page", description: "The full markdown of a page (frontmatter with evidence and links, then the body), by its path from search or ls.", inputSchema: { path: z.string() } }, async (a) => text(await toolCat(a)));
-    server.registerTool("get_object", { title: "Look up an AL object", description: "An AL object of W1 or a Microsoft first-party app by type and id or exact name, e.g. ('table', '18') or ('codeunit', 'Sales-Post'): fields, keys, events, public procedures, obsolete state, versions, countries that replace it, Learn pages.",
-        inputSchema: { type: z.string(), idOrName: z.string() } }, async (a) => text(await toolGetObject(a)));
-    server.registerTool("diff_object", { title: "What changed in an object", description: "Member-level changes of a W1 object between two consecutive versions (fields, events, procedures, keys, properties, obsolete state).",
-        inputSchema: { type: z.string(), id: z.string(), from: z.string(), to: z.string() } }, async (a) => text(await toolDiffObject(a)));
-    server.registerTool("localization", { title: "A country localization", description: "What a country layer (BE, NL, DE, ...) adds to or changes in W1, with its Learn local functionality hub.", inputSchema: { country: z.string().length(2) } }, async (a) => text(await toolLocalization(a)));
-    server.registerTool("whats_new", { title: "What is new", description: "Videos, posts and roadmap features dated on or after a date (YYYY-MM-DD), newest first.",
-        inputSchema: { since: z.string(), type: z.string().optional(), limit: z.number().int().min(1).max(100).optional() } }, async (a) => text(await toolWhatsNew(a)));
-    server.registerTool("blog_footprint", { title: "A source's footprint", description: "What a blog or channel (source id from sources.yaml, e.g. 'kauffmann-nl', 'yt-hougaard') covers: its posts or videos and the systems they touch.",
-        inputSchema: { source: z.string() } }, async (a) => text(await toolBlogFootprint(a)));
-    server.registerTool("feedback", { title: "Report a problem with a page", description: "Returns a prefilled GitHub issue link for a page (wrong fact, missing evidence, broken link). Nothing is sent by the agent.",
-        inputSchema: { path: z.string(), message: z.string() } }, async (a) => text(toolFeedback(a)));
-    return server;
-}
-/** Started as a program (npx, bin symlink, node dist/server.js, tsx src/server.ts) rather than imported by a test. */
-function isMain() {
-    if (!process.argv[1])
-        return false;
-    try {
-        return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  if (vectors && vectors.at === loadedAt) return vectors.data;
+  const data = new Float32Array(pages.length * m.dims);
+  pages.forEach((p, i) => data.set(embed(m, [p.title, p.summary, ...p.tags ?? []].filter(Boolean).join(". ")), i * m.dims));
+  vectors = { at: loadedAt, data };
+  return data;
+}
+function fuse(lists, k = 60) {
+  const score = /* @__PURE__ */ new Map();
+  for (const list of lists) list.forEach((p, i) => score.set(p, (score.get(p) ?? 0) + 1 / (k + i + 1)));
+  return [...score].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([p]) => p);
+}
+function keepOf(a) {
+  const lc = (x) => x?.trim().toLowerCase() || void 0;
+  const type = lc(a.type), tier = lc(a.tier), country = lc(a.country), app = lc(a.app), kind = lc(a.kind);
+  const system = a.system ? systemOf(a.system) ?? lc(a.system) : void 0;
+  const objectType = a.object_type ? typeOfWord(a.object_type.replace(/\s+/g, "")) ?? lc(a.object_type) : void 0;
+  return (r) => (!type || r.type === type) && (!tier || r.tier === tier) && (!system || r.system === system) && (!country || (r.country ?? "") === country) && (!app || (r.app ?? "").toLowerCase() === app) && (!objectType || r.objectType === objectType) && (!kind || r.kind === kind);
+}
+async function toolSearch(a) {
+  await loadIndex();
+  const keep2 = keepOf(a);
+  const limit = a.limit ?? 10, mode = a.mode ?? "hybrid", POOL = 50;
+  const q = parseQuery(a.query, { countries: countriesOf(index) });
+  const hits = search(index, q, { filter: keep2 });
+  const byId = new Map(hits.map((h) => [h.r.id, h.r]));
+  let semantic = [], note = "";
+  if (mode !== "keyword") {
+    const m = await loadModel();
+    if (m) {
+      const v = embed(m, a.query), data = pageVectors(m);
+      if (v.some((x) => x !== 0)) {
+        const scored = [];
+        index.records.forEach((r, i) => {
+          if (r.kind === "page" && i < pages.length && keep2(r)) scored.push([dot(v, data, i * m.dims), i]);
+        });
+        semantic = scored.sort((x, y) => y[0] - x[0]).slice(0, POOL).map(([, i]) => {
+          const r = index.records[i];
+          byId.set(r.id, r);
+          return r.id;
+        });
+      }
+    } else if (mode === "semantic") note = ` (semantic search unavailable: ${modelError}; keyword results instead)`;
+  }
+  const keyword = hits.map((h) => h.r.id);
+  let order, exactBand = 0;
+  if (mode === "semantic") order = semantic.length ? semantic : keyword.slice(0, POOL);
+  else if (mode === "keyword" || !semantic.length) order = keyword;
+  else {
+    const exact = hits.filter((h) => h.band === "exact").map((h) => h.r.id), pinned = new Set(exact);
+    exactBand = exact.length;
+    order = [...exact, ...fuse([hits.filter((h) => h.band !== "exact").slice(0, POOL).map((h) => h.r.id), semantic.filter((p) => !pinned.has(p))])];
+  }
+  if (mode !== "semantic" && mode !== "keyword" && !semantic.length) exactBand = hits.filter((h) => h.band === "exact").length;
+  const inKeyword = new Set(keyword.slice(0, Math.max(POOL, limit))), inMeaning = new Set(semantic);
+  const tag = (id) => inKeyword.has(id) && inMeaning.has(id) ? " [both]" : inMeaning.has(id) ? " [meaning]" : " [keyword]";
+  const shown = order.slice(0, limit).map((id) => byId.get(id)).filter(Boolean);
+  const hs = hints(index, q, hits).filter((h) => !hits.length || hits[0].s < 6 || q.question || !!q.ref || /: no page; /.test(h.text));
+  const hintText = hs.length ? `
+${hs.map((h) => `Hint: ${h.text}${h.query ? ` (search "${h.query}")` : h.path ? ` (cat("${h.path}"))` : ""}`).join("\n")}` : "";
+  if (!shown.length) return `No pages match "${a.query}". Try fewer words, or ls("") to browse sections.${note}${hintText}`;
+  const how = semantic.length && keyword.length && mode === "hybrid" ? "keyword + meaning" : mode === "semantic" && semantic.length ? "meaning" : "keyword";
+  return `${shown.length} results, ${how}${note}${how === "keyword + meaning" || mode === "hybrid" ? ` (exact band: ${exactBand})` : ""} (read one with cat(path)):
+${shown.map((r) => hitLine(r, tag(r.id))).join("\n")}${hintText}`;
+}
+async function toolLs(a) {
+  await loadIndex();
+  const prefix = (a.path ?? "").replace(/^\/+|\/+$/g, "");
+  const under = pages.filter((p) => !prefix || p.path === prefix || p.path.startsWith(`${prefix}/`));
+  if (!under.length) return `Nothing under "${prefix}". Sections: ${[...new Set(pages.map((p) => p.path.split("/")[0]))].sort().join(", ")}.`;
+  const depth = prefix ? prefix.split("/").length : 0;
+  const dirs = /* @__PURE__ */ new Map(), files = [];
+  for (const p of under) {
+    const parts2 = p.path.split("/");
+    if (parts2.length === depth + 1) files.push(p);
+    else if (parts2.length > depth + 1) dirs.set(parts2.slice(0, depth + 1).join("/"), (dirs.get(parts2.slice(0, depth + 1).join("/")) ?? 0) + 1);
+  }
+  const MAX = 200;
+  const out = [...[...dirs].sort().map(([d, n]) => `${d}/ (${n} pages)`), ...files.slice(0, MAX).map((f) => `${f.path}: ${f.title}`)];
+  return `${out.join("\n")}${files.length > MAX ? `
+... and ${files.length - MAX} more pages; use search() to narrow down` : ""}`;
+}
+async function toolCat(a) {
+  const [base, anchor] = a.path.split(/(?=#)/);
+  const clean = `${base.replace(/^\/+|\/+$/g, "").replace(/\.md$/, "")}${anchor ?? ""}`;
+  return pageView(await pageMarkdown(clean.replace(/#.*$/, "")), clean, a, BUDGET, SITE);
+}
+async function toolGetObject(a) {
+  await loadIndex();
+  const type = typeOfWord(a.type.toLowerCase().replace(/\s+/g, "")) ?? a.type.toLowerCase().replace(/\s+/g, "");
+  let want = a.idOrName.trim().replace(/^"|"$/g, "");
+  let country = a.country?.trim().toLowerCase() || null;
+  const objs = index.records.filter((r) => r.kind === "page" && r.type === "object" && r.objectType === type);
+  let id = null;
+  const q = parseQuery(want, { countries: countriesOf(index) });
+  if (q.ref && q.ref.type === type) {
+    id = q.ref.id;
+    country ??= q.ref.country;
+  } else if (q.number !== null) id = q.number;
+  else {
+    const m = /^(\d+)-([a-z]{2})$/i.exec(want);
+    if (m) {
+      id = Number(m[1]);
+      country ??= m[2].toLowerCase();
     }
-    catch {
-        return false;
+  }
+  const cc = /^(.*?)\s*\(([A-Za-z]{2})\)$/.exec(want);
+  if (id === null && cc) {
+    want = cc[1];
+    country ??= cc[2].toLowerCase();
+  }
+  const lw = want.toLowerCase();
+  const tiers = id !== null ? [objs.filter((r) => r.objectId === id)] : [objs.filter((r) => r.name.toLowerCase() === lw), objs.filter((r) => (r.caption ?? "").toLowerCase() === lw)];
+  for (const found of tiers) {
+    if (!found.length) continue;
+    const inCountry = country ? found.filter((r) => r.country === country) : [];
+    const w1 = found.filter((r) => !r.country);
+    const pick = country ? inCountry.length ? inCountry : w1 : w1.length ? w1 : found;
+    if (pick.length === 1) {
+      const twins = found.filter((r) => r !== pick[0] && r.country).map((r) => r.country.toUpperCase());
+      const note = country && !inCountry.length ? `(${country.toUpperCase()} has no ${type} of its own here; the W1 ${type} applies.)
+
+` : "";
+      const also = !country && twins.length ? `
+
+(Also in ${twins.join(", ")}: get_object("${type}", "${pick[0].objectId ?? pick[0].name}", country).)` : "";
+      return `${note}${pageView(await pageMarkdown(pick[0].id), pick[0].id, a, BUDGET, SITE)}${a.section ? "" : also}`;
     }
+    if (pick.length > 1) return `${pick.length} ${type} objects match "${a.idOrName}"; read one with cat(path):
+${pick.map((r) => `- ${r.title} path=${r.id}`).join("\n")}`;
+  }
+  return `No ${type} "${a.idOrName}" in W1, Microsoft's first-party apps or the country layers (BC28-30). Never invent object ids; search("${want}") lists near names.`;
+}
+async function toolDiffObject(a) {
+  const key = `${a.type.toLowerCase()}/${a.id.toLowerCase()}`;
+  let diff;
+  try {
+    diff = JSON.parse(await dataFile(`code/diffs/version/${a.from}__${a.to}.json`));
+  } catch {
+    return `No version diff ${a.from} -> ${a.to}. Diffs exist between consecutive majors from BC23 to BC30 (23 -> 24, ..., 29 -> 30); a changed member lists only what differs, as [from, to].`;
+  }
+  const o = diff.objects.find((x) => x.key === key);
+  if (!o) return `${key} did not change between BC${a.from} and BC${a.to} (or is not a W1 object).`;
+  return `${key} "${o.name}" BC${a.from} -> BC${a.to}: ${o.change}
+${JSON.stringify(o, null, 1)}`;
+}
+async function toolLocalization(a) {
+  const p = `localizations/${a.country.toLowerCase()}`;
+  return pageView(await pageMarkdown(p), p, a, BUDGET, SITE);
+}
+async function toolWhatsNew(a, today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)) {
+  await loadIndex();
+  const since = a.since.slice(0, 10);
+  const dated = pages.filter((p) => p.date && p.date >= since && (!a.type || p.type === a.type));
+  const future = dated.filter((p) => p.date > today);
+  const items = (a.include_future ? dated : dated.filter((p) => p.date <= today)).sort((x, y) => y.date.localeCompare(x.date)).slice(0, a.limit ?? 30);
+  const tail = !a.include_future && future.length ? `
+${future.length} roadmap ${future.length === 1 ? "feature" : "features"} scheduled after today: pass include_future: true` : "";
+  if (!items.length) return `Nothing dated on or after ${since}${a.include_future ? "" : ` up to today (${today})`}.${tail}`;
+  return `${items.length} items since ${since}, newest first:
+${items.map((p) => line(p)).join("\n")}${tail}`;
+}
+async function toolBlogFootprint(a) {
+  await loadIndex();
+  const items = pages.filter((p) => p.source === a.source).sort((x, y) => (y.date ?? "").localeCompare(x.date ?? ""));
+  if (!items.length) return `No posts or videos from source "${a.source}" yet. Source ids are listed in ${REPO}/blob/main/sources.yaml.`;
+  const systems = /* @__PURE__ */ new Map();
+  for (const p of items) if (p.system) systems.set(p.system, (systems.get(p.system) ?? 0) + 1);
+  return `${a.source}: ${items.length} items, ${items.at(-1).date ?? "?"} to ${items[0].date ?? "?"}. Systems: ${[...systems].sort((x, y) => y[1] - x[1]).map(([s, n]) => `${s} ${n}`).join(", ")}.
+${items.slice(0, 20).map((p) => line(p)).join("\n")}`;
+}
+function toolFeedback(a) {
+  const title = `Feedback on ${a.path}`;
+  const body = `Page: ${url(a.path)}
+
+${a.message}
+
+(sent from the bc-observatory MCP server ${VERSION})`;
+  return `Open this link to file the issue (no sign-in through the agent): ${REPO}/issues/new?title=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}&labels=feedback`;
+}
+var VIEW = { section: z.string().optional(), offset: z.number().int().min(0).max(1e5).optional(), limit: z.number().int().min(1).max(5e3).optional() };
+function createServer() {
+  const server = new McpServer({ name: "bc-observatory", version: VERSION }, {
+    instructions: "BC Observatory: an agent-first knowledge base of Microsoft Dynamics 365 Business Central (Learn hubs, AL objects from the code for BC28-30, localizations, roadmap features, videos, community posts, code changes: merged pull requests of Microsoft's Business Central repositories, BCApps joined to the AL objects they changed, under changes/, and AL Language extension releases (the marketplace changelog, under releases/)). Every page carries a trust tier (official = Microsoft, community = everyone else) and a review state: say which tier a claim comes from. Never invent AL object ids or version numbers: look them up with get_object. Start with search(), read pages with cat(path), browse with ls(path)."
+  });
+  server.registerTool(
+    "search",
+    {
+      title: "Search the knowledge base",
+      description: "Search every page, and the fields, published events, global procedures and enum values of AL objects, ranked like the site's search. Takes names ('Sales Header'), references ('t36', 'cu 80', 'table 11300 BE'), bare ids ('36') and symbol prefixes ('event: OnAfterPost', 'field: Posting Date', 'proc: CopyToTempLines'); a symbol hit's path ends in its anchor (#event-<Name>, #field-<id>, #proc-<Name>, #value-<ordinal>); cat(path) reads that member alone. Hybrid by default: exact matches stay on top and the rest is fused with a meaning ranking; each hit says [keyword], [meaning] or [both]; mode 'keyword' or 'semantic' for one list. Filters: type (topic, app, feature, object, localization, video, post, change, source, digest, release), tier (official, community), system (finance, sales, ... or an alias such as 'g/l'), country ('BE'), app ('Subscription Billing'), object_type ('table'), kind (page, field, event, proc, value).",
+      inputSchema: { query: z.string(), type: z.string().optional(), tier: z.string().optional(), system: z.string().optional(), country: z.string().optional(), app: z.string().optional(), object_type: z.string().optional(), kind: z.enum(["page", "field", "event", "proc", "value"]).optional(), limit: z.number().int().min(1).max(50).optional(), mode: z.enum(["hybrid", "keyword", "semantic"]).optional() }
+    },
+    async (a) => text(await toolSearch(a))
+  );
+  server.registerTool(
+    "ls",
+    { title: "List pages", description: "Browse the page tree, e.g. ls('objects/table') or ls('localizations'); empty path lists the sections.", inputSchema: { path: z.string().optional() } },
+    async (a) => text(await toolLs(a))
+  );
+  server.registerTool(
+    "cat",
+    { title: "Read a page", description: `A page's markdown by its path from search or ls: frontmatter with evidence and links, then the body. A page over ${B} characters comes back compact with its section keys; section (or 'frontmatter'), offset and limit read one part. A symbol path ('objects/codeunit/80#event-OnAfterPostSalesDoc') returns that member's row.`, inputSchema: { path: z.string(), ...VIEW } },
+    async (a) => text(await toolCat(a))
+  );
+  server.registerTool("get_object", {
+    title: "Look up an AL object",
+    description: `An AL object of W1, a Microsoft first-party app or a country layer by type and id, reference, name or caption: ('table', '18'), ('table', 't36'), ('table', '36-be'), ('codeunit', 'Sales-Post'), ('page', 'Customers'), or with country 'BE'. Returns its page: fields, keys, events, procedures, calls, obsolete state, versions, countries, Learn pages; a W1 object wins over its country twins unless a country is given, and two candidates are listed with their paths. A page over ${B} characters comes back compact (frontmatter, the first 5 rows of each section, the section keys): pass section ('fields', 'events', 'procedures', 'calls', ...) with offset and limit to read one. To check that a field, event or procedure exists, search('event: <Name>') answers without the page.`,
+    inputSchema: { type: z.string(), idOrName: z.string(), country: z.string().length(2).optional(), ...VIEW }
+  }, async (a) => text(await toolGetObject(a)));
+  server.registerTool("diff_object", {
+    title: "What changed in an object",
+    description: "Member-level changes of a W1 object between two consecutive versions (fields, events, procedures, keys, properties, obsolete state).",
+    inputSchema: { type: z.string(), id: z.string(), from: z.string(), to: z.string() }
+  }, async (a) => text(await toolDiffObject(a)));
+  server.registerTool(
+    "localization",
+    { title: "A country localization", description: `What a country layer (BE, NL, DE, ...) adds to or changes in W1, with its Learn local functionality hub. Over ${B} characters it comes back compact; section, offset and limit read one section, as in cat.`, inputSchema: { country: z.string().length(2), ...VIEW } },
+    async (a) => text(await toolLocalization(a))
+  );
+  server.registerTool("whats_new", {
+    title: "What is new",
+    description: "Videos, posts, roadmap features, AL extension releases (type 'release') and merged pull requests of BCApps, AL-Go and BCQuality (type 'change') dated on or after a date (YYYY-MM-DD) up to today, newest first. A roadmap feature's date is its GA month: features after today are counted at the end and listed with include_future: true.",
+    inputSchema: { since: z.string(), type: z.string().optional(), limit: z.number().int().min(1).max(100).optional(), include_future: z.boolean().optional() }
+  }, async (a) => text(await toolWhatsNew(a)));
+  server.registerTool("blog_footprint", {
+    title: "A source's footprint",
+    description: "What a blog or channel (source id from sources.yaml, e.g. 'kauffmann-nl', 'yt-hougaard') covers: its posts or videos and the systems they touch.",
+    inputSchema: { source: z.string() }
+  }, async (a) => text(await toolBlogFootprint(a)));
+  server.registerTool("feedback", {
+    title: "Report a problem with a page",
+    description: "Returns a prefilled GitHub issue link for a page (wrong fact, missing evidence, broken link). Nothing is sent by the agent.",
+    inputSchema: { path: z.string(), message: z.string() }
+  }, async (a) => text(toolFeedback(a)));
+  return server;
+}
+function isMain() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
 }
 if (isMain()) {
-    await createServer().connect(new StdioServerTransport());
+  await createServer().connect(new StdioServerTransport());
 }
+export {
+  createServer,
+  fuse,
+  keepOf,
+  toolBlogFootprint,
+  toolCat,
+  toolDiffObject,
+  toolFeedback,
+  toolGetObject,
+  toolLocalization,
+  toolLs,
+  toolSearch,
+  toolWhatsNew
+};