@formfeed/mcp 0.3.16 → 0.3.17

package/bin/formfeed-mcp.mjs

@@ -6257,9 +6257,9 @@ var require_parser2 = __commonJS({
               this.yytext = "";
               this.match = "";
             }
-            var rules = this._currentRules();
-            for (var i = 0; i < rules.length; i++) {
-              tempMatch = this._input.match(this.rules[rules[i]]);
+            var rules2 = this._currentRules();
+            for (var i = 0; i < rules2.length; i++) {
+              tempMatch = this._input.match(this.rules[rules2[i]]);
               if (tempMatch && (!match7 || tempMatch[0].length > match7[0].length)) {
                 match7 = tempMatch;
                 index = i;
@@ -6285,7 +6285,7 @@ var require_parser2 = __commonJS({
               this._more = false;
               this._input = this._input.slice(match7[0].length);
               this.matched += match7[0];
-              token = this.performAction.call(this, this.yy, this, rules[index], this.conditionStack[this.conditionStack.length - 1]);
+              token = this.performAction.call(this, this.yy, this, rules2[index], this.conditionStack[this.conditionStack.length - 1]);
               if (this.done && this._input) this.done = false;
               if (token) return token;
               else return;
@@ -16041,10 +16041,10 @@ var require_nunjucks = __commonJS({
               return typeof value === "function";
             }
             exports2.callable = callable;
-            function defined(value) {
+            function defined2(value) {
               return value !== void 0;
             }
-            exports2.defined = defined;
+            exports2.defined = defined2;
             function divisibleby(one, two) {
               return one % two === 0;
             }
@@ -70747,6 +70747,14 @@ function epcPayload(input) {
     ""
   ].join("\n");
 }
+var normaliseIban = (iban2) => iban2.replace(/\s/g, "").toUpperCase();
+function ibanChecksum(iban2) {
+  const rearranged = normaliseIban(iban2).slice(4) + normaliseIban(iban2).slice(0, 4);
+  const digits = [...rearranged].map((c) => c >= "A" && c <= "Z" ? String(c.charCodeAt(0) - 55) : c).join("");
+  let remainder = 0;
+  for (const digit of digits) remainder = (remainder * 10 + Number(digit)) % 97;
+  return remainder === 1;
+}
 
 // packages/engine/src/lib/codes/qr.ts
 var import_qrcode = __toESM(require_lib());
@@ -81793,6 +81801,49 @@ var paymentMeansCodes = list2(
   "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 74 75 76 77 78 91 92 93 94 95 96 97 98 ZZZ"
 );
 
+// packages/engine/src/lib/einvoice/decimal.ts
+function decimalText(value) {
+  if (typeof value === "string") {
+    const text5 = value.trim();
+    return /^-?\d+(\.\d+)?$/.test(text5) ? trimZeros(text5) : null;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  const text4 = value.toPrecision(15);
+  return /^-?\d+(\.\d+)?$/.test(text4) ? trimZeros(text4) : null;
+}
+function trimZeros(text4) {
+  const trimmed = text4.includes(".") ? text4.replace(/0+$/, "").replace(/\.$/, "") : text4;
+  return trimmed === "-0" ? "0" : trimmed;
+}
+function decimalPlaces(text4) {
+  const dot = text4.indexOf(".");
+  return dot === -1 ? 0 : text4.length - dot - 1;
+}
+function toUnits(text4, scale) {
+  const negative = text4.startsWith("-");
+  const [whole = "0", fraction = ""] = (negative ? text4.slice(1) : text4).split(
+    "."
+  );
+  const units = BigInt(whole + fraction.padEnd(scale, "0").slice(0, scale));
+  return negative ? -units : units;
+}
+function fromUnits(units, scale, places = scale) {
+  const negative = units < 0n;
+  const digits = (negative ? -units : units).toString().padStart(scale + 1, "0");
+  const whole = digits.slice(0, digits.length - scale);
+  const fraction = digits.slice(digits.length - scale).padEnd(places, "0");
+  const text4 = places > 0 ? `${whole}.${fraction.slice(0, places)}` : whole;
+  return negative && /[1-9]/.test(text4) ? `-${text4}` : text4;
+}
+function divideRounded(value, divisor) {
+  const negative = value < 0n !== divisor < 0n;
+  const a = value < 0n ? -value : value;
+  const b2 = divisor < 0n ? -divisor : divisor;
+  const quotient = (a * 2n + b2) / (b2 * 2n);
+  return negative ? -quotient : quotient;
+}
+var abs = (value) => value < 0n ? -value : value;
+
 // packages/engine/src/lib/einvoice/schema.ts
 import { z as z2 } from "zod";
 var numeric = z2.union([z2.number(), z2.string()]);
@@ -81965,6 +82016,1093 @@ var einvoiceOptionsSchema = z2.object({
   display_check: z2.enum(["warn", "strict"]).optional()
 }).strict();
 
+// packages/engine/src/lib/einvoice/check.ts
+var REQUIRED = {
+  number: ["BR-02", "BT-1"],
+  issue_date: ["BR-03", "BT-2"],
+  currency: ["BR-05", "BT-5"],
+  seller: ["BR-06", "BG-4"],
+  "seller.name": ["BR-06", "BT-27"],
+  "seller.address": ["BR-08", "BG-5"],
+  "seller.address.country": ["BR-09", "BT-40"],
+  buyer: ["BR-07", "BG-7"],
+  "buyer.name": ["BR-07", "BT-44"],
+  "buyer.address": ["BR-10", "BG-8"],
+  "buyer.address.country": ["BR-11", "BT-55"],
+  lines: ["BR-16", "BG-25"],
+  "lines[].id": ["BR-21", "BT-126"],
+  "lines[].quantity": ["BR-22", "BT-129"],
+  "lines[].net_amount": ["BR-24", "BT-131"],
+  "lines[].name": ["BR-25", "BT-153"],
+  "lines[].net_price": ["BR-26", "BT-146"],
+  "lines[].tax": ["BR-CO-04", "BT-151"],
+  "lines[].tax.category": ["BR-CO-04", "BT-151"],
+  tax: ["BR-CO-18", "BG-23"],
+  "tax.breakdown": ["BR-CO-18", "BG-23"],
+  "tax.breakdown[].basis": ["BR-45", "BT-116"],
+  "tax.breakdown[].amount": ["BR-46", "BT-117"],
+  "tax.breakdown[].category": ["BR-47", "BT-118"],
+  totals: ["BR-12", "BG-22"],
+  "totals.line_net": ["BR-12", "BT-106"],
+  "totals.tax_basis": ["BR-13", "BT-109"],
+  "totals.tax_total": ["BR-CO-14", "BT-110"],
+  "totals.grand": ["BR-14", "BT-112"],
+  "totals.due": ["BR-15", "BT-115"],
+  "allowances[].amount": ["BR-31", "BT-92"],
+  "allowances[].tax": ["BR-32", "BT-95"],
+  "allowances[].tax.category": ["BR-32", "BT-95"],
+  "charges[].amount": ["BR-36", "BT-99"],
+  "charges[].tax": ["BR-37", "BT-102"],
+  "charges[].tax.category": ["BR-37", "BT-102"],
+  "lines[].allowances[].amount": ["BR-41", "BT-136"],
+  "lines[].charges[].amount": ["BR-43", "BT-141"],
+  "delivery.address.country": ["BR-57", "BT-80"],
+  "preceding_invoices[].number": ["BR-55", "BT-25"]
+};
+var RULE_PREFIX = {
+  S: "BR-S",
+  Z: "BR-Z",
+  E: "BR-E",
+  AE: "BR-AE",
+  K: "BR-IC",
+  G: "BR-G",
+  O: "BR-O"
+};
+var UNIT_SUGGESTIONS = {
+  piece: "C62",
+  pieces: "C62",
+  pcs: "C62",
+  pc: "C62",
+  stk: "C62",
+  st\u00FCck: "C62",
+  unit: "C62",
+  units: "C62",
+  each: "C62",
+  hour: "HUR",
+  hours: "HUR",
+  h: "HUR",
+  std: "HUR",
+  stunde: "HUR",
+  stunden: "HUR",
+  day: "DAY",
+  days: "DAY",
+  tag: "DAY",
+  tage: "DAY",
+  month: "MON",
+  months: "MON",
+  monat: "MON",
+  year: "ANN",
+  min: "MIN",
+  minute: "MIN",
+  minutes: "MIN",
+  kg: "KGM",
+  g: "GRM",
+  t: "TNE",
+  l: "LTR",
+  litre: "LTR",
+  liter: "LTR",
+  m: "MTR",
+  km: "KMT",
+  m2: "MTK",
+  qm: "MTK",
+  m3: "MTQ",
+  kwh: "KWH",
+  flat: "LS",
+  pauschal: "LS"
+};
+var FRENCH_FRAMEWORKS = /* @__PURE__ */ new Set([
+  "B1",
+  "S1",
+  "M1",
+  "B2",
+  "S2",
+  "M2",
+  "S3",
+  "B4",
+  "S4",
+  "M4",
+  "S5",
+  "S6",
+  "B7",
+  "S7",
+  "B8",
+  "S8",
+  "M8"
+]);
+var FRENCH_OPERATION = { goods: "B1", services: "S1", mixed: "M1" };
+var FRENCH_NOTES = [
+  ["PMT", "the fixed compensation of \u20AC40 for recovery costs"],
+  ["PMD", "the penalties for late payment"],
+  ["AAB", "the discount for early payment, or that none is given"]
+];
+var CREDIT_TRANSFER = /* @__PURE__ */ new Set(["30", "58"]);
+function checkInvoice(data, options = {}) {
+  const problems = [];
+  const add2 = (code, path, message2, extra = {}) => {
+    problems.push({
+      code,
+      path,
+      ...extra.rule ? { rule: extra.rule } : {},
+      message: extra.rule ? `${message2} (${extra.rule})` : message2,
+      args: {
+        path,
+        ...extra.rule ? { rule: extra.rule } : {},
+        ...extra.args
+      }
+    });
+  };
+  const parsed = invoiceSchema.safeParse(data);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) {
+      const path = pathText(issue.path);
+      const required = REQUIRED[path.replace(/\[\d+\]/g, "[]")];
+      const absent = valueAt(data, issue.path) === void 0;
+      if (absent && required)
+        add2("missing", path, `_invoice.${path} is missing (${required[1]})`, {
+          rule: required[0],
+          args: { term: required[1] }
+        });
+      else if (absent) add2("missing", path, `_invoice.${path} is missing`);
+      else if (issue.code === "too_small" && path === "lines")
+        add2(
+          "missing",
+          path,
+          "_invoice.lines is empty: an invoice has at least one line (BG-25)",
+          {
+            rule: "BR-16",
+            args: { term: "BG-25" }
+          }
+        );
+      else if (issue.code === "too_small" && path === "tax.breakdown")
+        add2(
+          "missing",
+          path,
+          "_invoice.tax.breakdown is empty: an invoice has at least one VAT breakdown (BG-23)",
+          {
+            rule: "BR-CO-18",
+            args: { term: "BG-23" }
+          }
+        );
+      else
+        add2("invalid", path, `_invoice.${path}: ${issue.message}`, {
+          args: { detail: issue.message }
+        });
+    }
+    return { ok: false, invoice: null, problems };
+  }
+  const invoice = normalise(parsed.data, add2, options);
+  if (problems.length > 0) return { ok: false, invoice: null, problems };
+  rules(invoice, add2, options);
+  return problems.length > 0 ? { ok: false, invoice: null, problems } : { ok: true, invoice, problems: [] };
+}
+function pathText(path) {
+  let out = "";
+  for (const key of path)
+    out += typeof key === "number" ? `[${key}]` : out ? `.${String(key)}` : String(key);
+  return out;
+}
+function valueAt(data, path) {
+  let value = data;
+  for (const key of path) {
+    if (value === null || typeof value !== "object") return void 0;
+    value = value[key];
+  }
+  return value === null ? void 0 : value;
+}
+function normalise(input, add2, options) {
+  const amount = (value, path) => {
+    const text4 = decimalText(value);
+    if (text4 === null) {
+      add2("not_a_number", path, `_invoice.${path} is not a number`);
+      return "0";
+    }
+    if (decimalPlaces(text4) > 2) {
+      add2(
+        "decimals",
+        path,
+        `_invoice.${path} has more than 2 decimals; an amount of the invoice is exact to the cent`,
+        {
+          args: { max: 2, value: text4 }
+        }
+      );
+      return "0";
+    }
+    return text4;
+  };
+  const number = (value, path, max) => {
+    const text4 = decimalText(value);
+    if (text4 === null) {
+      add2("not_a_number", path, `_invoice.${path} is not a number`);
+      return "0";
+    }
+    if (decimalPlaces(text4) > max) {
+      add2("decimals", path, `_invoice.${path} has more than ${max} decimals`, {
+        args: { max, value: text4 }
+      });
+      return "0";
+    }
+    return text4;
+  };
+  const optionalAmount = (value, path) => value === void 0 ? void 0 : amount(value, path);
+  const date = (value, path) => {
+    if (value === void 0) return void 0;
+    const [year = 0, month = 0, day = 0] = value.split("-").map(Number);
+    const real = new Date(Date.UTC(year, month - 1, day));
+    if (real.getUTCFullYear() !== year || real.getUTCMonth() !== month - 1 || real.getUTCDate() !== day) {
+      add2("date", path, `_invoice.${path} is not a date of the calendar`, {
+        args: { value }
+      });
+    }
+    return value;
+  };
+  const code = (value, path, list3, name, rule2) => {
+    const upper = value.trim().toUpperCase();
+    if (!list3.has(upper))
+      add2(
+        "code_list",
+        path,
+        `_invoice.${path}: "${value}" is not a code of ${name}`,
+        {
+          rule: rule2,
+          args: { value, list: name }
+        }
+      );
+    return upper;
+  };
+  const period2 = (value, path, rule2) => {
+    if (!value || value.start === void 0 && value.end === void 0)
+      return void 0;
+    const start = date(value.start, `${path}.start`);
+    const end = date(value.end, `${path}.end`);
+    if (start && end && end < start)
+      add2("date_order", path, `_invoice.${path} ends before it starts`, {
+        rule: rule2
+      });
+    return { ...start ? { start } : {}, ...end ? { end } : {} };
+  };
+  const identifier3 = (value) => {
+    if (value === void 0) return void 0;
+    if (typeof value === "string") return { value };
+    return {
+      value: value.value,
+      ...value.scheme ? { scheme: value.scheme } : {}
+    };
+  };
+  const address2 = (value, path) => ({
+    ...defined({
+      street: value.street,
+      street2: value.street2,
+      street3: value.street3,
+      postcode: value.postcode,
+      city: value.city,
+      subdivision: value.subdivision
+    }),
+    country: code(
+      value.country,
+      `${path}.country`,
+      countryCodes,
+      "ISO 3166-1 (two letters, as in DE)",
+      "BR-CL-14"
+    )
+  });
+  const vatId = (value, path) => {
+    if (value === void 0) return void 0;
+    const id = value.replace(/\s/g, "").toUpperCase();
+    const prefix = id.slice(0, 2);
+    if (!(countryCodes.has(prefix) || prefix === "EL") || !/^[A-Z]{2}/.test(id))
+      add2(
+        "vat_id_prefix",
+        path,
+        `_invoice.${path} must start with the country code of the VAT ID, as in DE123456789`,
+        {
+          rule: "BR-CO-09",
+          args: { value }
+        }
+      );
+    return id;
+  };
+  const electronicAddress = (value, path, rule2) => {
+    const id = identifier3(value);
+    if (!id) return void 0;
+    const scheme = id.scheme?.trim().toUpperCase() ?? (/^[^@\s]+@[^@\s]+$/.test(id.value) ? "EM" : void 0);
+    if (!scheme) {
+      add2(
+        "scheme_required",
+        path,
+        `_invoice.${path} needs its scheme: write { "value": \u2026, "scheme": \u2026 } with a code of the EAS list, or an e-mail address`,
+        { rule: rule2 }
+      );
+      return void 0;
+    }
+    if (!electronicAddressSchemes.has(scheme))
+      add2(
+        "code_list",
+        `${path}.scheme`,
+        `_invoice.${path}.scheme: "${scheme}" is not a code of the EAS list (EM is an e-mail address)`,
+        {
+          rule: "BR-CL-25",
+          args: { value: scheme, list: "the EAS list" }
+        }
+      );
+    return { value: id.value, scheme };
+  };
+  const party2 = (value, path, addressRule) => {
+    const id = identifier3(value.id);
+    const registration = identifier3(value.legal_registration);
+    const electronic = electronicAddress(
+      value.electronic_address,
+      `${path}.electronic_address`,
+      addressRule
+    );
+    const vat = vatId(value.vat_id, `${path}.vat_id`);
+    return {
+      name: value.name,
+      ...defined({ trading_name: value.trading_name, vat_id: vat }),
+      ...id ? { id } : {},
+      ...registration ? { legal_registration: registration } : {},
+      address: address2(value.address, `${path}.address`),
+      ...value.contact && Object.values(value.contact).some((v2) => v2 !== void 0) ? { contact: defined(value.contact) } : {},
+      ...electronic ? { electronic_address: electronic } : {}
+    };
+  };
+  const tax = (value, path) => ({
+    category: value.category,
+    ...value.rate === void 0 || value.rate === null ? {} : { rate: number(value.rate, `${path}.rate`, 4) }
+  });
+  const allowance = (value, path) => ({
+    amount: amount(value.amount, `${path}.amount`),
+    ...defined({
+      reason: value.reason,
+      reason_code: value.reason_code?.trim().toUpperCase(),
+      base_amount: optionalAmount(value.base_amount, `${path}.base_amount`),
+      percent: value.percent === void 0 ? void 0 : number(value.percent, `${path}.percent`, 4)
+    })
+  });
+  const seller = party2(input.seller, "seller", "BR-62");
+  const buyer = party2(input.buyer, "buyer", "BR-63");
+  if (input.buyer.siren !== void 0) {
+    const siren = input.buyer.siren.replace(/\s/g, "");
+    if (buyer.legal_registration && buyer.legal_registration.value.replace(/\s/g, "") !== siren)
+      add2(
+        "siren_mismatch",
+        "buyer.siren",
+        "_invoice.buyer.siren and _invoice.buyer.legal_registration name different registrations; state one of them"
+      );
+    else
+      buyer.legal_registration = {
+        value: siren,
+        scheme: buyer.legal_registration?.scheme ?? "0002"
+      };
+  }
+  const notes = [
+    ...input.note ? [{ text: input.note }] : [],
+    ...(input.notes ?? []).map((note2) => ({
+      text: note2.text,
+      ...note2.subject_code ? { subject_code: note2.subject_code.trim().toUpperCase() } : {}
+    }))
+  ];
+  const delivery = input.delivery ? defined({
+    name: input.delivery.name,
+    date: date(input.delivery.date, "delivery.date"),
+    address: input.delivery.address ? address2(input.delivery.address, "delivery.address") : void 0
+  }) : void 0;
+  let businessProcess;
+  if (input.operation_code !== void 0)
+    businessProcess = input.operation_code.trim().toUpperCase();
+  else if (input.operation !== void 0)
+    businessProcess = FRENCH_OPERATION[input.operation];
+  const payment2 = input.payment ? defined({
+    means_code: input.payment.means_code === void 0 ? void 0 : code(
+      String(input.payment.means_code),
+      "payment.means_code",
+      paymentMeansCodes,
+      "UNTDID 4461 (58 is a SEPA credit transfer)",
+      "BR-CL-16"
+    ),
+    iban: iban(input.payment.iban, "payment.iban", add2),
+    bic: input.payment.bic?.replace(/\s/g, "").toUpperCase(),
+    account_name: input.payment.account_name,
+    reference: input.payment.reference,
+    terms: input.payment.terms,
+    due_date: date(input.payment.due_date, "payment.due_date"),
+    mandate_id: input.payment.mandate_id,
+    creditor_id: input.payment.creditor_id,
+    debited_iban: iban(
+      input.payment.debited_iban,
+      "payment.debited_iban",
+      add2
+    )
+  }) : void 0;
+  const rounding = optionalAmount(input.totals.rounding, "totals.rounding");
+  if (options.profile === "basic" && rounding !== void 0 && toUnits(rounding, 2) !== 0n)
+    add2(
+      "profile",
+      "totals.rounding",
+      "_invoice.totals.rounding cannot be carried by the profile basic, which has no rounding amount (BT-114); use en16931",
+      {
+        args: { profile: "basic", term: "BT-114" }
+      }
+    );
+  return {
+    number: input.number,
+    issue_date: date(input.issue_date, "issue_date") ?? input.issue_date,
+    type_code: code(
+      String(input.type_code),
+      "type_code",
+      documentTypeCodes,
+      "UNTDID 1001 (380 is an invoice, 381 a credit note)",
+      "BR-CL-01"
+    ),
+    currency: code(
+      input.currency,
+      "currency",
+      currencyCodes,
+      "ISO 4217 (three letters, as in EUR)",
+      "BR-CL-04"
+    ),
+    ...defined({
+      accounting_currency: input.accounting_currency === void 0 ? void 0 : code(
+        input.accounting_currency,
+        "accounting_currency",
+        currencyCodes,
+        "ISO 4217 (three letters, as in EUR)",
+        "BR-CL-05"
+      ),
+      buyer_reference: input.buyer_reference,
+      order_reference: input.order_reference,
+      contract_reference: input.contract_reference,
+      period: period2(input.period, "period", "BR-29"),
+      business_process: businessProcess
+    }),
+    notes,
+    preceding_invoices: (input.preceding_invoices ?? []).map(
+      (reference, i) => ({
+        number: reference.number,
+        ...defined({
+          issue_date: date(
+            reference.issue_date,
+            `preceding_invoices[${i}].issue_date`
+          )
+        })
+      })
+    ),
+    seller: {
+      ...seller,
+      ...defined({
+        tax_number: input.seller.tax_number,
+        legal_info: input.seller.legal_info,
+        vat_on_debits: input.seller.vat_on_debits
+      })
+    },
+    buyer,
+    ...delivery && Object.keys(delivery).length > 0 ? { delivery } : {},
+    lines: input.lines.map((line2, i) => {
+      const path = `lines[${i}]`;
+      const unit = line2.unit_code.trim();
+      const known = unitCodes.has(unit.toUpperCase()) || unitCodes.has(unit);
+      if (!known) {
+        const suggestion = UNIT_SUGGESTIONS[unit.toLowerCase()];
+        add2(
+          "code_list",
+          `${path}.unit_code`,
+          `_invoice.${path}.unit_code: "${unit}" is not a code of UN/ECE Recommendation 20${suggestion ? `; ${suggestion} is the code for it` : " (C62 is a piece, HUR an hour, DAY a day)"}`,
+          {
+            rule: "BR-CL-23",
+            args: {
+              value: unit,
+              list: "UN/ECE Recommendation 20",
+              ...suggestion ? { suggestion } : {}
+            }
+          }
+        );
+      }
+      const price = number(line2.net_price, `${path}.net_price`, 6);
+      if (price.startsWith("-"))
+        add2(
+          "negative",
+          `${path}.net_price`,
+          `_invoice.${path}.net_price must not be negative; a credit is a negative quantity`,
+          { rule: "BR-27" }
+        );
+      const standard = identifier3(line2.standard_item_id);
+      if (standard && !standard.scheme)
+        add2(
+          "scheme_required",
+          `${path}.standard_item_id`,
+          `_invoice.${path}.standard_item_id needs its scheme: write { "value": \u2026, "scheme": \u2026 }, 0160 for a GTIN`,
+          { rule: "BR-64" }
+        );
+      return {
+        id: String(line2.id),
+        name: line2.name,
+        quantity: number(line2.quantity, `${path}.quantity`, 6),
+        unit_code: unitCodes.has(unit) ? unit : unit.toUpperCase(),
+        net_price: price,
+        net_amount: amount(line2.net_amount, `${path}.net_amount`),
+        tax: tax(line2.tax, `${path}.tax`),
+        allowances: (line2.allowances ?? []).map(
+          (a, j2) => allowance(a, `${path}.allowances[${j2}]`)
+        ),
+        charges: (line2.charges ?? []).map(
+          (c, j2) => allowance(c, `${path}.charges[${j2}]`)
+        ),
+        ...defined({
+          description: line2.description,
+          price_base_quantity: line2.price_base_quantity === void 0 ? void 0 : number(
+            line2.price_base_quantity,
+            `${path}.price_base_quantity`,
+            6
+          ),
+          period: period2(line2.period, `${path}.period`, "BR-30"),
+          buyer_accounting_reference: line2.buyer_accounting_reference,
+          note: line2.note,
+          seller_item_id: line2.seller_item_id,
+          buyer_item_id: line2.buyer_item_id,
+          standard_item_id: standard,
+          order_line_reference: line2.order_line_reference
+        })
+      };
+    }),
+    allowances: (input.allowances ?? []).map((a, i) => ({
+      ...allowance(a, `allowances[${i}]`),
+      tax: tax(a.tax, `allowances[${i}].tax`)
+    })),
+    charges: (input.charges ?? []).map((c, i) => ({
+      ...allowance(c, `charges[${i}]`),
+      tax: tax(c.tax, `charges[${i}].tax`)
+    })),
+    breakdown: input.tax.breakdown.map((row, i) => ({
+      ...tax(row, `tax.breakdown[${i}]`),
+      basis: amount(row.basis, `tax.breakdown[${i}].basis`),
+      amount: amount(row.amount, `tax.breakdown[${i}].amount`),
+      ...defined({
+        exemption_reason: row.exemption_reason,
+        exemption_reason_code: row.exemption_reason_code?.trim()
+      })
+    })),
+    totals: {
+      line_net: amount(input.totals.line_net, "totals.line_net"),
+      tax_basis: amount(input.totals.tax_basis, "totals.tax_basis"),
+      tax_total: amount(input.totals.tax_total, "totals.tax_total"),
+      grand: amount(input.totals.grand, "totals.grand"),
+      due: amount(input.totals.due, "totals.due"),
+      ...defined({
+        allowances: optionalAmount(
+          input.totals.allowances,
+          "totals.allowances"
+        ),
+        charges: optionalAmount(input.totals.charges, "totals.charges"),
+        prepaid: optionalAmount(input.totals.prepaid, "totals.prepaid"),
+        tax_total_accounting: optionalAmount(
+          input.totals.tax_total_accounting,
+          "totals.tax_total_accounting"
+        ),
+        rounding
+      })
+    },
+    ...payment2 && Object.keys(payment2).length > 0 ? { payment: payment2 } : {}
+  };
+}
+function iban(value, path, add2) {
+  if (value === void 0) return void 0;
+  const normalised = normaliseIban(value);
+  if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{11,30}$/.test(normalised) || !ibanChecksum(normalised))
+    add2(
+      "iban",
+      path,
+      `_invoice.${path} is not a valid IBAN: its check digits do not match`
+    );
+  return normalised;
+}
+function defined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, v2]) => v2 !== void 0)
+  );
+}
+var cents = (text4) => text4 === void 0 ? 0n : toUnits(text4, 2);
+var money = (value) => fromUnits(value, 2);
+var rateKey = (tax) => `${tax.category}|${tax.rate ?? ""}`;
+function rules(invoice, add2, options) {
+  const { totals: totals2 } = invoice;
+  const sum = (path, stated, expected, rule2, formula) => {
+    if (stated !== expected)
+      add2(
+        "sum",
+        path,
+        `_invoice.${path} is ${money(stated)}, but ${formula} ${money(expected)}`,
+        {
+          rule: rule2,
+          args: { value: money(stated), expected: money(expected) }
+        }
+      );
+  };
+  const lineNet = invoice.lines.reduce(
+    (total, line2) => total + cents(line2.net_amount),
+    0n
+  );
+  const allowanceSum = invoice.allowances.reduce(
+    (total, a) => total + cents(a.amount),
+    0n
+  );
+  const chargeSum = invoice.charges.reduce(
+    (total, c) => total + cents(c.amount),
+    0n
+  );
+  const taxSum = invoice.breakdown.reduce(
+    (total, row) => total + cents(row.amount),
+    0n
+  );
+  sum(
+    "totals.line_net",
+    cents(totals2.line_net),
+    lineNet,
+    "BR-CO-10",
+    "the net amounts of the lines add up to"
+  );
+  sum(
+    "totals.allowances",
+    cents(totals2.allowances),
+    allowanceSum,
+    "BR-CO-11",
+    "the allowances of the document add up to"
+  );
+  sum(
+    "totals.charges",
+    cents(totals2.charges),
+    chargeSum,
+    "BR-CO-12",
+    "the charges of the document add up to"
+  );
+  sum(
+    "totals.tax_basis",
+    cents(totals2.tax_basis),
+    cents(totals2.line_net) - cents(totals2.allowances) + cents(totals2.charges),
+    "BR-CO-13",
+    "line_net less allowances plus charges is"
+  );
+  sum(
+    "totals.tax_total",
+    cents(totals2.tax_total),
+    taxSum,
+    "BR-CO-14",
+    "the VAT amounts of the breakdown add up to"
+  );
+  sum(
+    "totals.grand",
+    cents(totals2.grand),
+    cents(totals2.tax_basis) + cents(totals2.tax_total),
+    "BR-CO-15",
+    "tax_basis plus tax_total is"
+  );
+  sum(
+    "totals.due",
+    cents(totals2.due),
+    cents(totals2.grand) - cents(totals2.prepaid) + cents(totals2.rounding),
+    "BR-CO-16",
+    "grand less prepaid plus rounding is"
+  );
+  if (invoice.accounting_currency !== void 0 && totals2.tax_total_accounting === void 0)
+    add2(
+      "missing",
+      "totals.tax_total_accounting",
+      `_invoice.totals.tax_total_accounting is missing: with accounting_currency ${invoice.accounting_currency} the invoice states its VAT total in that currency (BT-111)`,
+      {
+        rule: "BR-53",
+        args: { term: "BT-111" }
+      }
+    );
+  if (invoice.accounting_currency === void 0 && totals2.tax_total_accounting !== void 0)
+    add2(
+      "missing",
+      "accounting_currency",
+      "_invoice.accounting_currency is missing: totals.tax_total_accounting needs the currency it is stated in (BT-6)",
+      {
+        rule: "BR-53",
+        args: { term: "BT-6" }
+      }
+    );
+  const used = /* @__PURE__ */ new Map();
+  const use = (tax, value, path) => {
+    const entry = used.get(rateKey(tax)) ?? {
+      tax,
+      basis: 0n,
+      items: 0,
+      first: path
+    };
+    entry.basis += value;
+    entry.items += 1;
+    used.set(rateKey(tax), entry);
+  };
+  invoice.lines.forEach(
+    (line2, i) => use(line2.tax, cents(line2.net_amount), `lines[${i}]`)
+  );
+  invoice.allowances.forEach(
+    (a, i) => use(a.tax, -cents(a.amount), `allowances[${i}]`)
+  );
+  invoice.charges.forEach(
+    (c, i) => use(c.tax, cents(c.amount), `charges[${i}]`)
+  );
+  const seen = /* @__PURE__ */ new Set();
+  invoice.breakdown.forEach((row, i) => {
+    const path = `tax.breakdown[${i}]`;
+    const prefix = RULE_PREFIX[row.category];
+    const shown = row.rate === void 0 ? row.category : `${row.category} at ${row.rate} %`;
+    if (seen.has(rateKey(row)))
+      add2(
+        "breakdown_duplicate",
+        path,
+        `_invoice.tax.breakdown lists category ${shown} twice; one entry per category and rate`,
+        {
+          args: { category: row.category, rate: row.rate ?? "" }
+        }
+      );
+    seen.add(rateKey(row));
+    const entry = used.get(rateKey(row));
+    const expected = entry?.basis ?? 0n;
+    if (cents(row.basis) !== expected)
+      add2(
+        "sum",
+        `${path}.basis`,
+        `_invoice.${path}.basis is ${money(cents(row.basis))}, but the lines, charges and allowances of category ${shown} come to ${money(expected)}`,
+        {
+          rule: `${prefix}-08`,
+          args: {
+            value: money(cents(row.basis)),
+            expected: money(expected),
+            category: row.category,
+            rate: row.rate ?? ""
+          }
+        }
+      );
+    if (row.rate !== void 0) {
+      const computed = divideRounded(
+        cents(row.basis) * toUnits(row.rate, 4),
+        1000000n
+      );
+      const items = BigInt(Math.max(1, entry?.items ?? 1));
+      const tolerance = (items + 1n) / 2n > 100n ? 100n : (items + 1n) / 2n;
+      if (abs(cents(row.amount) - computed) > tolerance)
+        add2(
+          "sum",
+          `${path}.amount`,
+          `_invoice.${path}.amount is ${money(cents(row.amount))}, but ${row.rate} % of ${money(cents(row.basis))} is ${money(computed)}`,
+          {
+            rule: "BR-CO-17",
+            args: {
+              value: money(cents(row.amount)),
+              expected: money(computed),
+              rate: row.rate,
+              basis: money(cents(row.basis))
+            }
+          }
+        );
+    }
+  });
+  for (const [key, entry] of used) {
+    if (seen.has(key)) continue;
+    const shown = entry.tax.rate === void 0 ? entry.tax.category : `${entry.tax.category} at ${entry.tax.rate} %`;
+    add2(
+      "breakdown_missing",
+      "tax.breakdown",
+      `_invoice.tax.breakdown has no entry for category ${shown}, which _invoice.${entry.first} falls under`,
+      {
+        rule: `${RULE_PREFIX[entry.tax.category]}-01`,
+        args: {
+          category: entry.tax.category,
+          rate: entry.tax.rate ?? "",
+          used: entry.first
+        }
+      }
+    );
+  }
+  const rate = (tax, path, at2) => {
+    const prefix = RULE_PREFIX[tax.category];
+    const number = at2 === "line" || at2 === "breakdown" ? "05" : at2 === "allowance" ? "06" : "07";
+    if (tax.category === "O") {
+      if (tax.rate !== void 0)
+        add2(
+          "rate_forbidden",
+          `${path}.rate`,
+          `_invoice.${path}.rate must be left out: category O is not subject to VAT and has no rate`,
+          { rule: `${prefix}-${number}` }
+        );
+      return;
+    }
+    if (tax.rate === void 0) {
+      add2(
+        "rate_required",
+        `${path}.rate`,
+        `_invoice.${path}.rate is missing: category ${tax.category} states its rate${tax.category === "S" ? "" : ", which is 0"}`,
+        {
+          rule: at2 === "breakdown" ? "BR-48" : `${prefix}-${number}`,
+          args: { category: tax.category }
+        }
+      );
+      return;
+    }
+    const value = toUnits(tax.rate, 4);
+    if (tax.category === "S" && value <= 0n)
+      add2(
+        "rate_positive",
+        `${path}.rate`,
+        `_invoice.${path}.rate is ${tax.rate}: category S is standard rated and needs a rate above 0; a rate of 0 is category Z or E`,
+        {
+          rule: `${prefix}-${number}`,
+          args: { rate: tax.rate }
+        }
+      );
+    if (tax.category !== "S" && value !== 0n)
+      add2(
+        "rate_zero",
+        `${path}.rate`,
+        `_invoice.${path}.rate is ${tax.rate}: category ${tax.category} carries a rate of 0`,
+        {
+          rule: `${prefix}-${number}`,
+          args: { rate: tax.rate, category: tax.category }
+        }
+      );
+  };
+  invoice.lines.forEach((line2, i) => rate(line2.tax, `lines[${i}].tax`, "line"));
+  invoice.allowances.forEach(
+    (a, i) => rate(a.tax, `allowances[${i}].tax`, "allowance")
+  );
+  invoice.charges.forEach((c, i) => rate(c.tax, `charges[${i}].tax`, "charge"));
+  const categories = new Set(
+    [...used.values()].map((entry) => entry.tax.category)
+  );
+  invoice.breakdown.forEach((row, i) => {
+    const path = `tax.breakdown[${i}]`;
+    const prefix = RULE_PREFIX[row.category];
+    rate(row, path, "breakdown");
+    categories.add(row.category);
+    const reason = row.exemption_reason !== void 0 || row.exemption_reason_code !== void 0;
+    if (row.category === "S" || row.category === "Z") {
+      if (reason)
+        add2(
+          "exemption_reason_forbidden",
+          `${path}.exemption_reason`,
+          `_invoice.${path} must not state an exemption reason: category ${row.category} is not an exemption`,
+          {
+            rule: `${prefix}-10`,
+            args: { category: row.category }
+          }
+        );
+    } else if (!reason) {
+      add2(
+        "exemption_reason_required",
+        `${path}.exemption_reason`,
+        `_invoice.${path}.exemption_reason is missing: category ${row.category} says why no VAT is charged, as text or as exemption_reason_code`,
+        {
+          rule: `${prefix}-10`,
+          args: { category: row.category }
+        }
+      );
+    }
+    if (row.category !== "S" && cents(row.amount) !== 0n)
+      add2(
+        "amount_zero",
+        `${path}.amount`,
+        `_invoice.${path}.amount is ${money(cents(row.amount))}: category ${row.category} carries no VAT, so the amount is 0`,
+        {
+          rule: `${prefix}-09`,
+          args: { value: money(cents(row.amount)), category: row.category }
+        }
+      );
+  });
+  const sellerTaxId = invoice.seller.vat_id !== void 0 || invoice.seller.tax_number !== void 0;
+  for (const category of categories) {
+    const prefix = RULE_PREFIX[category];
+    if (category === "O") {
+      if (invoice.seller.vat_id !== void 0)
+        add2(
+          "vat_id_forbidden",
+          "seller.vat_id",
+          "_invoice.seller.vat_id must be left out: an invoice of category O is not subject to VAT; the seller is named by tax_number or legal_registration",
+          { rule: "BR-O-02" }
+        );
+      if (invoice.buyer.vat_id !== void 0)
+        add2(
+          "vat_id_forbidden",
+          "buyer.vat_id",
+          "_invoice.buyer.vat_id must be left out: an invoice of category O is not subject to VAT",
+          { rule: "BR-O-02" }
+        );
+      if (categories.size > 1)
+        add2(
+          "only_category",
+          "tax.breakdown",
+          "_invoice mixes category O with others: an invoice that is not subject to VAT has that one category only",
+          { rule: "BR-O-11" }
+        );
+      continue;
+    }
+    if (category === "K" || category === "G") {
+      if (invoice.seller.vat_id === void 0)
+        add2(
+          "seller_tax_id_required",
+          "seller.vat_id",
+          `_invoice.seller.vat_id is missing: category ${category} names the seller's VAT ID`,
+          {
+            rule: `${prefix}-02`,
+            args: { category }
+          }
+        );
+    } else if (!sellerTaxId) {
+      add2(
+        "seller_tax_id_required",
+        "seller.vat_id",
+        `_invoice.seller.vat_id is missing: category ${category} names the seller's VAT ID, or tax_number where there is none`,
+        {
+          rule: `${prefix}-02`,
+          args: { category }
+        }
+      );
+    }
+    if (category === "AE" && invoice.buyer.vat_id === void 0 && invoice.buyer.legal_registration === void 0)
+      add2(
+        "buyer_tax_id_required",
+        "buyer.vat_id",
+        "_invoice.buyer.vat_id is missing: with reverse charge the buyer owes the VAT, so the invoice names the buyer's VAT ID or legal_registration",
+        {
+          rule: "BR-AE-02",
+          args: { category }
+        }
+      );
+    if (category === "K") {
+      if (invoice.buyer.vat_id === void 0)
+        add2(
+          "buyer_tax_id_required",
+          "buyer.vat_id",
+          "_invoice.buyer.vat_id is missing: an intra-community supply names the buyer's VAT ID",
+          {
+            rule: "BR-IC-02",
+            args: { category }
+          }
+        );
+      if (invoice.delivery?.date === void 0 && invoice.period === void 0)
+        add2(
+          "delivery_required",
+          "delivery.date",
+          "_invoice.delivery.date is missing: an intra-community supply states when it was delivered, or the invoicing period",
+          { rule: "BR-IC-11" }
+        );
+      if (invoice.delivery?.address === void 0)
+        add2(
+          "delivery_required",
+          "delivery.address.country",
+          "_invoice.delivery.address.country is missing: an intra-community supply states the country it was delivered to",
+          { rule: "BR-IC-12" }
+        );
+    }
+  }
+  if (invoice.seller.id === void 0 && invoice.seller.legal_registration === void 0 && invoice.seller.vat_id === void 0)
+    add2(
+      "seller_identifier_required",
+      "seller.vat_id",
+      "_invoice.seller needs an identifier the buyer can match: vat_id, legal_registration or id",
+      { rule: "BR-CO-26" }
+    );
+  const payment2 = invoice.payment;
+  const account = payment2?.iban !== void 0 || payment2?.bic !== void 0 || payment2?.account_name !== void 0;
+  if (payment2 && payment2.means_code === void 0 && (account || payment2.mandate_id !== void 0 || payment2.debited_iban !== void 0))
+    add2(
+      "means_code_required",
+      "payment.means_code",
+      "_invoice.payment.means_code is missing: payment details say how the invoice is paid, 58 for a SEPA credit transfer, 59 for a SEPA direct debit",
+      { rule: "BR-49" }
+    );
+  if (payment2?.means_code !== void 0 && CREDIT_TRANSFER.has(payment2.means_code) && payment2.iban === void 0)
+    add2(
+      "account_required",
+      "payment.iban",
+      `_invoice.payment.iban is missing: a payment by credit transfer (code ${payment2.means_code}) names the account`,
+      {
+        rule: "BR-61",
+        args: { means: payment2.means_code }
+      }
+    );
+  if (cents(totals2.due) > 0n && payment2?.due_date === void 0 && payment2?.terms === void 0)
+    add2(
+      "due_or_terms_required",
+      "payment.due_date",
+      "_invoice.payment.due_date is missing: an invoice with an amount due states when it is due, or its payment terms",
+      { rule: "BR-CO-25" }
+    );
+  if (invoice.seller.address.country === "FR" && invoice.buyer.address.country === "FR") {
+    if (options.profile === "basic")
+      add2(
+        "fr_profile",
+        "",
+        "_invoice is an invoice between French businesses, which France's e-invoicing reform does not accept in the profile basic (AFNOR XP Z12-012 takes EN 16931 and EXTENDED-CTC-FR); use en16931",
+        { args: { profile: "basic" } }
+      );
+    const digits = (id) => (id?.value ?? "").replace(/\s/g, "");
+    if (!/^\d{9}$/.test(digits(invoice.seller.legal_registration)))
+      add2(
+        "fr_seller_siren",
+        "seller.legal_registration",
+        "_invoice.seller.legal_registration is missing or not nine digits: an invoice between French businesses names the seller's SIREN (BT-30)",
+        { rule: "BR-FR-10" }
+      );
+    if (!/^\d{9}$/.test(digits(invoice.buyer.legal_registration)))
+      add2(
+        "fr_buyer_siren",
+        "buyer.siren",
+        "_invoice.buyer.siren is missing or not nine digits: an invoice between French businesses names the buyer's SIREN (BT-47)",
+        { rule: "BR-FR-11" }
+      );
+    if (invoice.business_process === void 0)
+      add2(
+        "fr_operation",
+        "operation",
+        "_invoice.operation is missing: an invoice between French businesses says whether it is for goods, services or mixed (BT-23)",
+        { rule: "BR-FR-08" }
+      );
+    else if (!FRENCH_FRAMEWORKS.has(invoice.business_process))
+      add2(
+        "code_list",
+        "operation_code",
+        `_invoice.operation_code: "${invoice.business_process}" is not a billing framework of the French specifications (B1, S1, M1 and their variants)`,
+        {
+          rule: "BR-FR-08",
+          args: {
+            value: invoice.business_process,
+            list: "the French billing frameworks"
+          }
+        }
+      );
+    if (invoice.seller.vat_on_debits === void 0)
+      add2(
+        "fr_vat_on_debits",
+        "seller.vat_on_debits",
+        "_invoice.seller.vat_on_debits is missing: an invoice between French businesses says whether the seller pays VAT on invoicing (true) or on payment (false)"
+      );
+    const subjects = new Set(invoice.notes.map((note2) => note2.subject_code));
+    for (const [code, what] of FRENCH_NOTES)
+      if (!subjects.has(code))
+        add2(
+          "fr_note",
+          "notes",
+          `_invoice.notes has no note with the subject_code ${code}: an invoice between French businesses states ${what} as a note (BT-21, BT-22)`,
+          { rule: "BR-FR-05", args: { subject_code: code } }
+        );
+    if (!invoice.seller.electronic_address)
+      add2(
+        "fr_electronic_address",
+        "seller.electronic_address",
+        "_invoice.seller.electronic_address is missing: an invoice between French businesses names the seller's electronic address (BT-34)",
+        { rule: "BR-FR-13", args: { term: "BT-34" } }
+      );
+    if (!invoice.buyer.electronic_address)
+      add2(
+        "fr_electronic_address",
+        "buyer.electronic_address",
+        "_invoice.buyer.electronic_address is missing: an invoice between French businesses names the buyer's electronic address (BT-49)",
+        { rule: "BR-FR-12", args: { term: "BT-49" } }
+      );
+  }
+}
+
 // packages/engine/src/lib/office/errors.ts
 var officeLimits = {
   /** Entries in one container. */
@@ -82703,7 +83841,7 @@ var encoder2 = new TextEncoder();
 // packages/mcp/src/lib/server.ts
 import { z as z3 } from "zod";
 var CONVERT_LIMIT_BYTES = 20 * 1024 * 1024;
-var SERVER_INFO = { name: "formfeed", version: "0.3.16" };
+var SERVER_INFO = { name: "formfeed", version: "0.3.17" };
 var READS = {
   readOnlyHint: true,
   destructiveHint: false,
@@ -82741,8 +83879,15 @@ var renderSummary = (r) => ({
   error: r.error,
   // the validator's verdict of a render whose template declares PDF/UA-1 (plan 21): whether the
   // file passed, and for each failed rule what to change and in which elements
-  ...r.accessibility ? { accessibility: r.accessibility } : {}
+  ...r.accessibility ? { accessibility: r.accessibility } : {},
+  // the report of an e-invoice (spec 17): valid, the findings, the XML's link, the hashes it checked
+  ...r.einvoice ? { einvoice: r.einvoice } : {}
 });
+var EINVOICE_PROBLEMS = /* @__PURE__ */ new Set([
+  "einvoice_data_invalid",
+  "einvoice_display_mismatch",
+  "pdfa_conversion_failed"
+]);
 function text3(data) {
   return {
     content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
@@ -82752,12 +83897,19 @@ function text3(data) {
 function failure(e) {
   const message2 = e instanceof FormfeedError ? `${e.code}: ${e.message}` : e instanceof Error ? e.message : String(e);
   const verdict = e instanceof FormfeedError && e.code === "pdfua_validation_failed" ? e.problem?.["accessibility"] : void 0;
+  const invoice = e instanceof FormfeedError && EINVOICE_PROBLEMS.has(e.code) ? Object.fromEntries(
+    ["errors", "einvoice"].filter((key) => e.problem?.[key] !== void 0).map((key) => [key, e.problem?.[key]])
+  ) : {};
+  const details = {
+    ...verdict ? { accessibility: verdict } : {},
+    ...invoice
+  };
   return {
     content: [
       {
         type: "text",
-        text: verdict ? `${message2}
-${JSON.stringify({ accessibility: verdict }, null, 2)}` : message2
+        text: Object.keys(details).length > 0 ? `${message2}
+${JSON.stringify(details, null, 2)}` : message2
       }
     ],
     isError: true
@@ -82775,7 +83927,7 @@ function createFormfeedServer(options) {
     ...options.fetch ? { fetch: options.fetch } : {}
   });
   const server = new McpServer(SERVER_INFO, {
-    instructions: "Formfeed renders PDFs and images from HTML templates, and fills Word and PowerPoint templates (as DOCX, PPTX or PDF). Start with list_templates, read the data shape with get_template_schema, check data with validate_template, then call render and hand the download_url to the user. convert_to_pdf turns office documents into PDFs. get_workspace says which workspace this server works in and what the period has left."
+    instructions: "Formfeed renders PDFs and images from HTML templates, and fills Word and PowerPoint templates (as DOCX, PPTX or PDF). Start with list_templates, read the data shape with get_template_schema, check data with validate_template, then call render and hand the download_url to the user. For an e-invoice (ZUGFeRD / Factur-X), put the invoice into data._invoice, check it with check_invoice, and call render with einvoice set; the template prints the same block. convert_to_pdf turns office documents into PDFs. get_workspace says which workspace this server works in and what the period has left."
   });
   server.registerTool(
     "list_templates",
@@ -82911,11 +84063,38 @@ function createFormfeedServer(options) {
       }
     }
   );
+  server.registerTool(
+    "check_invoice",
+    {
+      title: "Check an e-invoice",
+      description: "Checks the _invoice block of an e-invoice offline, as the API does before it renders one: the fields EN 16931 asks for, the totals to the cent, VAT categories and code lists, and France's rules for an invoice between two French businesses. Free, no units, nothing sent. Returns ok and problems, each with the field, the rule (BR-\u2026) where one applies and a message. Nothing is computed for you: change the values a problem names, check again, then call render with einvoice and the block as data._invoice. The validator that runs during the render holds the file to the full rule set and to PDF/A-3b as well.",
+      inputSchema: {
+        invoice: z3.record(z3.string(), z3.unknown()).describe(
+          "The _invoice block as it goes into data._invoice: number, issue_date, currency, seller, buyer, lines, tax.breakdown, totals and payment, as https://docs.formfeed.dev/templates/e-invoices#invoice-block describes"
+        ),
+        profile: z3.enum(["en16931", "basic"]).optional().describe(
+          "The profile the render will ask for; en16931 when left out. basic cannot carry a rounding amount and is refused between two French businesses"
+        )
+      },
+      annotations: READS
+    },
+    async ({ invoice, profile }) => {
+      const check = checkInvoice(invoice, { profile: profile ?? "en16931" });
+      return text3({
+        ok: check.ok,
+        problems: check.problems.map((problem) => ({
+          path: problem.path ? `_invoice.${problem.path}` : "_invoice",
+          ...problem.rule ? { rule: problem.rule } : {},
+          message: problem.message
+        }))
+      });
+    }
+  );
   server.registerTool(
     "render",
     {
       title: "Render a document",
-      description: "Creates a document by filling a stored template, or ad-hoc html, with data: a PDF or image, or DOCX, PPTX or PDF from Word and PowerPoint templates. Returns the render with status and download_url. Use it to make a document from data; to turn an existing office file into a PDF, use convert_to_pdf. Stored templates render their published version, so one whose published_version is null fails with template_not_found. Every call is a new render: a live key consumes units, a test key is free (watermarked on the Free plan). A render that fails returns status failed and an error with code and message; validate_template finds most causes beforehand. The link expires at expires_at; get_render issues a fresh one.",
+      description: "Creates a document by filling a stored template, or ad-hoc html, with data: a PDF or image, or DOCX, PPTX or PDF from Word and PowerPoint templates. Returns the render with status and download_url. Use it to make a document from data; to turn an existing office file into a PDF, use convert_to_pdf. Stored templates render their published version, so one whose published_version is null fails with template_not_found. Every call is a new render: a live key consumes units, a test key is free (watermarked on the Free plan). A render that fails returns status failed and an error with code and message; validate_template finds most causes beforehand. With einvoice the PDF becomes a ZUGFeRD / Factur-X e-invoice built from data._invoice (check the block with check_invoice first): the render then carries einvoice, the validator's report, and a refused invoice names the fields and rules to fix. The link expires at expires_at; get_render issues a fresh one.",
       inputSchema: {
         template: z3.string().optional().describe("Slug or tpl_ id of a stored template; pass this or html"),
         html: z3.string().optional().describe(
@@ -82936,6 +84115,25 @@ function createFormfeedServer(options) {
         locale: z3.string().optional().describe("BCP 47 tag for helpers and translations, e.g. de-DE"),
         wait: z3.boolean().default(true).describe(
           "Most renders are finished when the call returns; true also waits for one that continues in the background, false returns it as it is (queued or rendering) to check later with get_render"
+        ),
+        einvoice: z3.union([
+          z3.boolean(),
+          z3.object({
+            profile: z3.enum(["en16931", "basic"]).optional().describe(
+              "en16931 (default) carries the whole European standard; basic is the smallest full invoice and is refused between two French businesses"
+            ),
+            flavour: z3.enum(["factur-x", "zugferd"]).optional().describe(
+              "One specification under two names; the default factur-x and zugferd make the same file"
+            ),
+            xml: z3.enum(["embedded", "both"]).optional().describe(
+              "both also stores the XML as a file of its own, linked as einvoice.xml_url"
+            ),
+            display_check: z3.enum(["warn", "strict"]).optional().describe(
+              "What a value of the XML that the PDF does not show does: a warning in the report (default) or a failed render"
+            )
+          })
+        ]).optional().describe(
+          "Makes the PDF a ZUGFeRD / Factur-X e-invoice whose XML is built from data._invoice: true for the defaults, an object to choose, false to switch off what the template declares. PDF only; live renders from the Starter plan, test keys on Free make 20 marked ones a day"
         )
       },
       annotations: CREATES
@@ -82948,7 +84146,8 @@ function createFormfeedServer(options) {
       output,
       filename,
       locale,
-      wait
+      wait,
+      einvoice
     }) => {
       try {
         if (!template && !html)
@@ -82961,6 +84160,7 @@ function createFormfeedServer(options) {
           ...output ? { output } : {},
           ...filename ? { filename } : {},
           ...locale ? { locale } : {},
+          ...einvoice !== void 0 ? { post: { einvoice: einvoice === true ? {} : einvoice } } : {},
           meta: { source: "mcp" }
         });
         if (wait && render.status !== "succeeded" && render.status !== "failed")
@@ -83128,11 +84328,110 @@ function createFormfeedServer(options) {
 
 // packages/mcp/src/lib/web.ts
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+
+// packages/mcp/src/lib/server-card.ts
+import { SUPPORTED_PROTOCOL_VERSIONS } from "@modelcontextprotocol/sdk/types.js";
+var SERVER_CARD_TYPE = "application/mcp-server-card+json";
+var SERVER_CARD_SCHEMA = "https://static.modelcontextprotocol.io/schemas/v1/server-card.schema.json";
+function serverCard(origin, signIn) {
+  const endpoint = `${origin.replace(/\/$/, "")}/mcp`;
+  const supportedProtocolVersions = [...SUPPORTED_PROTOCOL_VERSIONS];
+  return {
+    $schema: SERVER_CARD_SCHEMA,
+    name: "io.github.formfeed-dev/formfeed",
+    version: SERVER_INFO.version,
+    description: "Render PDFs and images from templates, validate data and convert Office files to PDF.",
+    title: "Formfeed",
+    websiteUrl: "https://docs.formfeed.dev/integrations/mcp",
+    repository: {
+      url: "https://github.com/formfeed-dev/formfeed",
+      source: "github",
+      subfolder: "packages/mcp"
+    },
+    icons: [
+      { src: "https://formfeed.dev/favicon.svg", mimeType: "image/svg+xml" },
+      {
+        src: "https://formfeed.dev/brand/formfeed-512.png",
+        mimeType: "image/png",
+        sizes: ["512x512"]
+      }
+    ],
+    remotes: [
+      {
+        type: "streamable-http",
+        url: endpoint,
+        headers: [
+          signIn ? {
+            name: "Authorization",
+            description: "Bearer followed by a Formfeed API key (ff_test_\u2026 or ff_live_\u2026); without it the client signs in with your Formfeed account (OAuth) and you choose the workspace",
+            isRequired: false,
+            isSecret: true
+          } : {
+            name: "Authorization",
+            description: "Bearer followed by a Formfeed API key (ff_test_\u2026 or ff_live_\u2026)",
+            isRequired: true,
+            isSecret: true
+          }
+        ],
+        supportedProtocolVersions
+      },
+      ...signIn ? [
+        {
+          type: "streamable-http",
+          url: `${endpoint}/{workspace_id}`,
+          variables: {
+            workspace_id: {
+              description: "Workspace id from the Formfeed app, for a connection that should work in another workspace than the one chosen at sign-in (OAuth)",
+              isRequired: true
+            }
+          },
+          supportedProtocolVersions
+        }
+      ] : []
+    ]
+  };
+}
+var CORS = {
+  "access-control-allow-origin": "*",
+  "access-control-allow-methods": "GET, HEAD, OPTIONS",
+  "access-control-allow-headers": "Content-Type, If-None-Match",
+  "access-control-expose-headers": "ETag"
+};
+async function serverCardResponse(request, card) {
+  if (request.method === "OPTIONS")
+    return new Response(null, { status: 204, headers: CORS });
+  if (request.method !== "GET" && request.method !== "HEAD")
+    return new Response(null, {
+      status: 405,
+      headers: { ...CORS, allow: "GET, HEAD, OPTIONS" }
+    });
+  const body = JSON.stringify(card, null, 2);
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(body)
+  );
+  const etag = `"${[...new Uint8Array(digest).slice(0, 16)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}"`;
+  const headers = {
+    ...CORS,
+    "cache-control": "public, max-age=3600",
+    etag
+  };
+  const known = (request.headers.get("if-none-match") ?? "").split(",").map((tag) => tag.trim().replace(/^W\//, ""));
+  if (known.includes(etag) || known.includes("*"))
+    return new Response(null, { status: 304, headers });
+  return new Response(request.method === "HEAD" ? null : body, {
+    status: 200,
+    headers: { ...headers, "content-type": SERVER_CARD_TYPE }
+  });
+}
+
+// packages/mcp/src/lib/web.ts
 var WORKSPACE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var API_KEY = /^ff_(live|test)_/;
 var JWT = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
 var MCP_PATH = "/mcp";
 var RESOURCE_METADATA_PATH = "/.well-known/oauth-protected-resource";
+var SERVER_CARD_PATH = `${MCP_PATH}/server-card`;
 function resourceMetadata(origin, workspaceId, authorizationServer2) {
   return {
     resource: `${origin}${MCP_PATH}/${workspaceId}`,
@@ -83208,6 +84507,11 @@ function mcpFetchHandler(options = {}) {
         200
       );
     }
+    if (path === SERVER_CARD_PATH)
+      return serverCardResponse(
+        request,
+        serverCard(origin, Boolean(authorizationServer2))
+      );
     if (path !== MCP_PATH && !path.startsWith(`${MCP_PATH}/`))
       return new Response(null, { status: 404 });
     const workspaceId = path === MCP_PATH ? null : path.slice(MCP_PATH.length + 1);