@formfeed/mcp 0.3.16 → 0.3.18

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;
@@ -7573,7 +7573,7 @@ var require_base64 = __commonJS({
 var require_base64_vlq = __commonJS({
   "node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64-vlq.js"(exports) {
     "use strict";
-    var base64 = require_base64();
+    var base642 = require_base64();
     var VLQ_BASE_SHIFT = 5;
     var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
     var VLQ_BASE_MASK = VLQ_BASE - 1;
@@ -7596,7 +7596,7 @@ var require_base64_vlq = __commonJS({
         if (vlq > 0) {
           digit |= VLQ_CONTINUATION_BIT;
         }
-        encoded += base64.encode(digit);
+        encoded += base642.encode(digit);
       } while (vlq > 0);
       return encoded;
     };
@@ -7609,7 +7609,7 @@ var require_base64_vlq = __commonJS({
         if (aIndex >= strLen) {
           throw new Error("Expected more digits in base 64 VLQ value.");
         }
-        digit = base64.decode(aStr.charCodeAt(aIndex++));
+        digit = base642.decode(aStr.charCodeAt(aIndex++));
         if (digit === -1) {
           throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
         }
@@ -14656,7 +14656,7 @@ var require_nunjucks = __commonJS({
                 });
                 return result;
               };
-              _proto.fetch = function fetch(url, cb) {
+              _proto.fetch = function fetch2(url, cb) {
                 if (typeof window === "undefined") {
                   throw new Error("WebLoader can only by used in a browser");
                 }
@@ -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());
@@ -70849,11 +70857,11 @@ var codeHelpers = [
     aliases: ["epc_qr", "girocode"],
     doc: {
       signature: "epcQr({ name, iban, bic?, amount?, reference?, text? }, { size })",
-      description: "SEPA credit transfer QR code (EPC069-12 / GiroCode) that banking apps scan to prefill a payment. Give the image an `alt`, and print the bank details as text as well: the code is a picture.",
+      description: "SEPA credit transfer QR code (EPC069-12 / GiroCode) that banking apps scan to prefill a payment. Put an invoice number into `text` (the remittance line); `reference` is only for a structured creditor reference (RF\u2026). Give the image an `alt`, and print the bank details as text as well: the code is a picture.",
       examples: {
-        jinja2: '<img src="{{ epcQr({ name: company.name, iban: company.iban, amount: invoice.total, reference: invoice.number }) }}" alt="QR code to pay invoice {{ invoice.number }}">',
-        liquid: '<img src="{{ company.iban | epcQr: name: company.name, amount: invoice.total, reference: invoice.number }}" alt="QR code to pay invoice {{ invoice.number }}">',
-        handlebars: '<img src="{{epcQr name=company.name iban=company.iban amount=invoice.total reference=invoice.number}}" alt="QR code to pay invoice {{invoice.number}}">'
+        jinja2: '<img src="{{ epcQr({ name: company.name, iban: company.iban, amount: invoice.total, text: invoice.number }) }}" alt="QR code to pay invoice {{ invoice.number }}">',
+        liquid: '<img src="{{ company.iban | epcQr: name: company.name, amount: invoice.total, text: invoice.number }}" alt="QR code to pay invoice {{ invoice.number }}">',
+        handlebars: '<img src="{{epcQr name=company.name iban=company.iban amount=invoice.total text=invoice.number}}" alt="QR code to pay invoice {{invoice.number}}">'
       },
       category: "code"
     },
@@ -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,44 @@ 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 NO_KEY = "This tool needs a Formfeed API key. Set FORMFEED_API_KEY to a key from https://app.formfeed.dev/keys (a test key, ff_test_\u2026, renders for free), or connect to https://mcp.formfeed.dev/mcp and sign in. Without a key, validate_template (with html and engine) and check_invoice work.";
+var NO_KEY_INSTRUCTION = "No API key is set, so only validate_template with html and engine, and check_invoice, work here; every other tool answers with how to get a key.";
+var IMAGE_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  webp: "image/webp"
+};
+var IMAGE_LIMIT_BYTES = 2 * 1024 * 1024;
+async function readCapped(res, limit) {
+  if (!res.body) return null;
+  const reader = res.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.length;
+    if (size > limit) {
+      await reader.cancel();
+      return null;
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+function base64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768)
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(binary);
+}
+var SERVER_INFO = { name: "formfeed", version: "0.3.18" };
 var READS = {
   readOnlyHint: true,
   destructiveHint: false,
@@ -82718,6 +83893,37 @@ var CREATES = {
 var engineSchema = z3.enum(["jinja2", "liquid", "handlebars"]);
 var outputSchema = z3.enum(outputFormats);
 var kindSchema = z3.enum(["pdf", "image", "docx", "pptx"]);
+var renderOutput = {
+  id: z3.string().describe("rnd_ id of the render"),
+  status: z3.enum(["queued", "rendering", "succeeded", "failed"]),
+  download_url: z3.string().nullable().describe("Signed link to the file; null until the render succeeded"),
+  expires_at: z3.string().nullable().describe("When download_url stops working; get_render issues a fresh one"),
+  page_count: z3.number().nullable(),
+  units: z3.number().describe("Units the render counted"),
+  environment: z3.enum(["live", "test"]),
+  template: z3.object({
+    id: z3.string(),
+    slug: z3.string(),
+    version: z3.number(),
+    channel: z3.string().nullable().optional(),
+    canary: z3.boolean().optional()
+  }).nullable().describe(
+    "The template and version rendered; null for html and conversions"
+  ),
+  error: z3.object({ code: z3.string().optional(), message: z3.string().optional() }).nullable().describe("Why a failed render failed"),
+  accessibility: z3.record(z3.string(), z3.unknown()).optional().describe("The PDF/UA-1 verdict, when the template declares it"),
+  einvoice: z3.record(z3.string(), z3.unknown()).optional().describe("The e-invoice report, when the render made one")
+};
+var diagnosticOutput = z3.object({
+  severity: z3.enum(["error", "warning", "info"]),
+  code: z3.string(),
+  message: z3.string(),
+  path: z3.string().optional().describe("Where in the data, for data errors"),
+  line: z3.number().optional(),
+  column: z3.number().optional(),
+  part: z3.string().optional().describe("Word and PowerPoint templates: the file part of the tag"),
+  paragraph: z3.number().optional()
+});
 var templateSummary = (t) => ({
   id: t.id,
   slug: t.slug,
@@ -82741,8 +83947,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,19 +83965,26 @@ 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
   };
 }
 function createFormfeedServer(options) {
-  const client = new Formfeed({
+  const client = options.apiKey ? new Formfeed({
     apiKey: options.apiKey,
     headers: {
       "user-agent": `formfeed-mcp/${SERVER_INFO.version}`,
@@ -82773,15 +83993,39 @@ function createFormfeedServer(options) {
     ...options.region ? { region: options.region } : {},
     ...options.baseUrl ? { baseUrl: options.baseUrl } : {},
     ...options.fetch ? { fetch: options.fetch } : {}
-  });
+  }) : null;
+  const api = () => {
+    if (!client) throw new Error(NO_KEY);
+    return client;
+  };
+  const fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
   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: (client ? "" : `${NO_KEY_INSTRUCTION} `) + "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. An image render also returns the picture itself, so look at it before handing it on. 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."
   });
+  const picture = async (render) => {
+    const mimeType = IMAGE_TYPES[render.output];
+    if (render.status !== "succeeded" || !mimeType || !render.download_url)
+      return [];
+    try {
+      const res = await fetchImpl(render.download_url);
+      const bytes = res.ok ? await readCapped(res, IMAGE_LIMIT_BYTES) : null;
+      return bytes ? [{ type: "image", data: base64(bytes), mimeType }] : [];
+    } catch {
+      return [];
+    }
+  };
+  const renderResult = async (render) => {
+    const result = text3(renderSummary(render));
+    return {
+      ...result,
+      content: [...result.content, ...await picture(render)]
+    };
+  };
   server.registerTool(
     "list_templates",
     {
       title: "List templates",
-      description: "Lists the templates of the workspace the API key belongs to, most recently changed first: id, slug, name, kind (pdf, image, docx for Word, pptx for PowerPoint), engine, tags and published_version. Call it first to find the slug that get_template_schema, validate_template and render take; skip it when the user already named the template. Returns every match in one answer, without archived templates, and an empty list when nothing matches. A template whose published_version is null has never been published, so render cannot use it yet. Read-only and free.",
+      description: "Lists the templates of the workspace this server works in (the one chosen at sign-in, or the API key's), most recently changed first: id, slug, name, kind (pdf, image, docx for Word, pptx for PowerPoint), engine, tags and published_version. Call it first to find the slug that get_template_schema, validate_template and render take; skip it when the user already named the template. Returns every match in one answer, without archived templates, and an empty list when nothing matches. A template whose published_version is null has never been published, so render cannot use it yet. Read-only and free.",
       inputSchema: {
         kind: kindSchema.optional().describe("Only templates that produce this kind of document"),
         engine: engineSchema.optional().describe("Only templates written in this template language"),
@@ -82792,11 +84036,26 @@ function createFormfeedServer(options) {
           "Text to find in the name or slug, case-insensitive (e.g. invoice)"
         )
       },
+      outputSchema: {
+        templates: z3.array(
+          z3.object({
+            id: z3.string().describe("tpl_ id"),
+            slug: z3.string(),
+            name: z3.string(),
+            kind: z3.string().describe("pdf, image, docx (Word) or pptx (PowerPoint)"),
+            engine: z3.string().describe("jinja2, liquid or handlebars"),
+            description: z3.string().nullable(),
+            tags: z3.array(z3.string()),
+            published_version: z3.number().nullable().describe("null: never published, so render cannot use it yet"),
+            updated_at: z3.string()
+          })
+        )
+      },
       annotations: READS
     },
     async (args2) => {
       try {
-        const templates = await client.templates.all(args2);
+        const templates = await api().templates.all(args2);
         return text3({ templates: templates.map(templateSummary) });
       } catch (e) {
         return failure(e);
@@ -82813,13 +84072,22 @@ function createFormfeedServer(options) {
           "Slug (e.g. invoice) or tpl_ id, as list_templates returns them"
         )
       },
+      outputSchema: {
+        template: z3.string(),
+        version: z3.number().describe("The version the schema comes from"),
+        status: z3.string().describe("published, or draft when nothing is published yet"),
+        schema: z3.record(z3.string(), z3.unknown()).describe(
+          "JSON Schema of data; inferred from sample_data when none is stored"
+        ),
+        sample_data: z3.record(z3.string(), z3.unknown())
+      },
       annotations: READS
     },
     async ({ template }) => {
       try {
-        const version = await client.templates.versions.get(template, "published").catch(async (e) => {
+        const version = await api().templates.versions.get(template, "published").catch(async (e) => {
           if (e.status === 404)
-            return client.templates.versions.get(template, "latest");
+            return api().templates.versions.get(template, "latest");
           throw e;
         });
         const schema = version.data_schema ?? inferSchema(version.sample_data ?? {});
@@ -82850,12 +84118,17 @@ function createFormfeedServer(options) {
           "The data the document will be rendered with, shaped as get_template_schema describes. Left out, a stored template is checked with its sample data"
         )
       },
+      outputSchema: {
+        ok: z3.boolean().describe("false when a diagnostic is an error"),
+        template: z3.object({ id: z3.string(), slug: z3.string(), version: z3.number() }).optional().describe("The stored version checked; absent for html"),
+        diagnostics: z3.array(diagnosticOutput)
+      },
       annotations: READS
     },
     async ({ template, html, engine, data }) => {
       try {
         if (template) {
-          const check = (version) => client.templates.validate(template, {
+          const check = (version) => api().templates.validate(template, {
             version,
             ...data ? { data } : {}
           });
@@ -82911,11 +84184,48 @@ 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"
+        )
+      },
+      outputSchema: {
+        ok: z3.boolean(),
+        problems: z3.array(
+          z3.object({
+            path: z3.string().describe("The field, e.g. _invoice.seller.vat_id"),
+            rule: z3.string().optional().describe("The EN 16931 rule, e.g. BR-03"),
+            message: z3.string()
+          })
+        )
+      },
+      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; for an image (png, jpg or webp) up to 2 MB the result also carries the picture itself, so look at what you made before handing it on (a PDF comes as its link). 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 or a signed-in agent 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,8 +84246,28 @@ 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"
         )
       },
+      outputSchema: renderOutput,
       annotations: CREATES
     },
     async ({
@@ -82948,12 +84278,13 @@ function createFormfeedServer(options) {
       output,
       filename,
       locale,
-      wait
+      wait,
+      einvoice
     }) => {
       try {
         if (!template && !html)
           return failure(new Error("Pass template or html"));
-        let render = await client.renders.create({
+        let render = await api().renders.create({
           ...template ? { template } : {},
           ...html ? { html } : {},
           ...engine ? { engine } : {},
@@ -82961,11 +84292,12 @@ 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")
-          render = await client.renders.waitFor(render.id);
-        return text3(renderSummary(render));
+          render = await api().renders.waitFor(render.id);
+        return await renderResult(render);
       } catch (e) {
         return failure(e);
       }
@@ -83000,6 +84332,7 @@ function createFormfeedServer(options) {
         single_page_sheets: z3.boolean().optional().describe("Each spreadsheet sheet on one page"),
         filename: z3.string().optional().describe("Name of the PDF behind download_url, e.g. report.pdf")
       },
+      outputSchema: renderOutput,
       annotations: CREATES
     },
     async (args2) => {
@@ -83032,7 +84365,7 @@ function createFormfeedServer(options) {
         };
         let render;
         if (render_id) {
-          render = await client.pdf.convert(render_id, convert);
+          render = await api().pdf.convert(render_id, convert);
         } else {
           let data;
           let name;
@@ -83063,7 +84396,7 @@ function createFormfeedServer(options) {
               );
             name = file_name;
           }
-          render = await client.pdf.convert(
+          render = await api().pdf.convert(
             { file: { data, name } },
             {
               ...convert,
@@ -83072,8 +84405,8 @@ function createFormfeedServer(options) {
           );
         }
         if (render.status !== "succeeded" && render.status !== "failed")
-          render = await client.renders.waitFor(render.id);
-        return text3(renderSummary(render));
+          render = await api().renders.waitFor(render.id);
+        return await renderResult(render);
       } catch (e) {
         return failure(e);
       }
@@ -83083,17 +84416,18 @@ function createFormfeedServer(options) {
     "get_render",
     {
       title: "Get a render",
-      description: "Returns the current state of a render: status (queued, rendering, succeeded or failed), download_url with expires_at, page_count, units and error. Use it to follow a render started with wait false, or to get a fresh link once the old one has expired; render and convert_to_pdf already return this for the render they just made. Read-only and free; an unknown id returns an error.",
+      description: "Returns the current state of a render: status (queued, rendering, succeeded or failed), download_url with expires_at, page_count, units and error, and the picture of a finished image render up to 2 MB. Use it to follow a render started with wait false, or to get a fresh link once the old one has expired; render and convert_to_pdf already return this for the render they just made. Read-only and free; an unknown id returns an error.",
       inputSchema: {
         id: z3.string().describe(
           "rnd_ id of the render, as render or convert_to_pdf returned it"
         )
       },
+      outputSchema: renderOutput,
       annotations: READS
     },
     async ({ id }) => {
       try {
-        return text3(renderSummary(await client.renders.get(id)));
+        return await renderResult(await api().renders.get(id));
       } catch (e) {
         return failure(e);
       }
@@ -83105,11 +84439,36 @@ function createFormfeedServer(options) {
       title: "Which workspace this server works in",
       description: "Returns the workspace and organisation this server acts in, the plan, the environment (live or test) and the units of the current period: included, used and the balance of prepaid units. Call it when the user asks where a document will land or how many renders are left, or when list_templates returns nothing you expected. A signed-in agent works in the workspace chosen when it was connected, which the person changes in Formfeed under Account \u2192 Connected agents; an API key works in the workspace it was made for. Read-only and free.",
       inputSchema: {},
+      outputSchema: {
+        workspace: z3.object({
+          id: z3.string(),
+          slug: z3.string(),
+          name: z3.string(),
+          region: z3.string().describe("eu, us or apac")
+        }),
+        organization: z3.object({
+          id: z3.string(),
+          slug: z3.string(),
+          name: z3.string()
+        }),
+        plan: z3.object({
+          id: z3.string(),
+          name: z3.string(),
+          monthly_units: z3.number().nullable().optional().describe("Units included a month; null where the plan sets none")
+        }),
+        environment: z3.enum(["live", "test"]).optional().describe("live renders count units; test renders are free"),
+        period: z3.object({ start: z3.string(), end: z3.string() }).describe("The current billing period"),
+        units: z3.object({
+          included: z3.number().nullable().optional(),
+          used: z3.number(),
+          overage_balance: z3.number().optional().describe("Prepaid units left beyond the included ones")
+        })
+      },
       annotations: READS
     },
     async () => {
       try {
-        const { workspace, organization, plan, environment, period: period2, units } = await client.account.get();
+        const { workspace, organization, plan, environment, period: period2, units } = await api().account.get();
         return text3({
           workspace,
           organization,
@@ -83128,11 +84487,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 +84666,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);
@@ -83366,7 +84829,7 @@ var authorizationServer = flag("--auth-server") ?? process.env["FORMFEED_AUTH_SE
 var publicOrigin = flag("--public-origin") ?? process.env["FORMFEED_PUBLIC_ORIGIN"];
 if (args.includes("--help") || args.includes("-h")) {
   process.stdout.write(
-    "formfeed-mcp: Model Context Protocol server for Formfeed\n\n  formfeed-mcp              stdio; needs FORMFEED_API_KEY\n  formfeed-mcp --http       Streamable HTTP on --port (8790) and --host (127.0.0.1); the key comes from Authorization: Bearer\n                            --auth-server <issuer> (or FORMFEED_AUTH_SERVER) also takes OAuth access tokens on /mcp and /mcp/<workspace id>;\n                            --public-origin <url> (or FORMFEED_PUBLIC_ORIGIN) is the origin clients see behind a proxy\n"
+    "formfeed-mcp: Model Context Protocol server for Formfeed\n\n  formfeed-mcp              stdio; FORMFEED_API_KEY, without it the offline checks only\n  formfeed-mcp --http       Streamable HTTP on --port (8790) and --host (127.0.0.1); the key comes from Authorization: Bearer\n                            --auth-server <issuer> (or FORMFEED_AUTH_SERVER) also takes OAuth access tokens on /mcp and /mcp/<workspace id>;\n                            --public-origin <url> (or FORMFEED_PUBLIC_ORIGIN) is the origin clients see behind a proxy\n"
   );
 } else if (args.includes("--http")) {
   startHttp({
@@ -83379,17 +84842,16 @@ if (args.includes("--help") || args.includes("-h")) {
   }).then((h) => process.stderr.write(`formfeed-mcp listening on ${h.url}
 `));
 } else {
-  const apiKey = process.env["FORMFEED_API_KEY"];
-  if (!apiKey) {
-    process.stderr.write("FORMFEED_API_KEY is required for the stdio server\n");
-    process.exitCode = 3;
-  } else {
-    startStdio({ apiKey, baseUrl, region }).catch((e) => {
-      process.stderr.write(`${e instanceof Error ? e.message : String(e)}
+  const apiKey = process.env["FORMFEED_API_KEY"] || void 0;
+  if (!apiKey)
+    process.stderr.write(
+      "FORMFEED_API_KEY is not set: only validate_template (with html) and check_invoice work\n"
+    );
+  startStdio({ apiKey, baseUrl, region }).catch((e) => {
+    process.stderr.write(`${e instanceof Error ? e.message : String(e)}
 `);
-      process.exitCode = 1;
-    });
-  }
+    process.exitCode = 1;
+  });
 }
 /*! Bundled license information: