@casys/mcp-erpnext 3.1.0-beta.7 → 3.1.0-beta.9

package/mcp-erpnext.mjs

@@ -1784,14 +1784,14 @@ var require_code3 = __commonJS({
     }
     exports.callValidateCode = callValidateCode;
     var newRegExp = (0, codegen_1._)`new RegExp`;
-    function usePattern({ gen, it: { opts } }, pattern) {
+    function usePattern({ gen, it: { opts } }, pattern2) {
       const u = opts.unicodeRegExp ? "u" : "";
       const { regExp } = opts.code;
-      const rx = regExp(pattern, u);
+      const rx = regExp(pattern2, u);
       return gen.scopeValue("pattern", {
         key: rx.toString(),
         ref: rx,
-        code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`
+        code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern2}, ${u})`
       });
     }
     exports.usePattern = usePattern;
@@ -6901,7 +6901,7 @@ var require_discriminator2 = __commonJS({
       error: error2,
       code(cxt) {
         const { gen, data, schema, parentSchema, it } = cxt;
-        const { oneOf } = parentSchema;
+        const { oneOf: oneOf2 } = parentSchema;
         if (!it.opts.discriminator) {
           throw new Error("discriminator: requires discriminator option");
         }
@@ -6910,7 +6910,7 @@ var require_discriminator2 = __commonJS({
           throw new Error("discriminator: requires propertyName");
         if (schema.mapping)
           throw new Error("discriminator: mapping is not supported");
-        if (!oneOf)
+        if (!oneOf2)
           throw new Error("discriminator: requires oneOf keyword");
         const valid = gen.let("valid", false);
         const tag2 = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
@@ -6938,8 +6938,8 @@ var require_discriminator2 = __commonJS({
           const oneOfMapping = {};
           const topRequired = hasRequired(parentSchema);
           let tagRequired = true;
-          for (let i = 0; i < oneOf.length; i++) {
-            let sch = oneOf[i];
+          for (let i = 0; i < oneOf2.length; i++) {
+            let sch = oneOf2[i];
             if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
               const ref = sch.$ref;
               sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
@@ -9021,9 +9021,9 @@ ${indent}`) + "'";
         return quotedString(value, ctx);
       }
       const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? "  " : "");
-      const literal2 = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.Scalar.BLOCK_FOLDED ? false : type === Scalar.Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, lineWidth, indent.length);
+      const literal3 = blockQuote === "literal" ? true : blockQuote === "folded" || type === Scalar.Scalar.BLOCK_FOLDED ? false : type === Scalar.Scalar.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, lineWidth, indent.length);
       if (!value)
-        return literal2 ? "|\n" : ">\n";
+        return literal3 ? "|\n" : ">\n";
       let chomp;
       let endStart;
       for (endStart = value.length; endStart > 0; --endStart) {
@@ -9072,7 +9072,7 @@ ${indent}`) + "'";
         if (onComment)
           onComment();
       }
-      if (!literal2) {
+      if (!literal3) {
         const foldedValue = value.replace(/\n+/g, "\n$&").replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${indent}`);
         let literalFallback = false;
         const foldOptions = getFoldOptions(ctx, true);
@@ -16815,8 +16815,8 @@ var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (ins
 var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
   $ZodCheck.init(inst, def);
   const escapedRegex = escapeRegex(def.includes);
-  const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position},}${escapedRegex}` : escapedRegex);
-  def.pattern = pattern;
+  const pattern2 = new RegExp(typeof def.position === "number" ? `^.{${def.position},}${escapedRegex}` : escapedRegex);
+  def.pattern = pattern2;
   inst._zod.check = (payload) => {
     if (payload.value.includes(def.includes, def.position))
       return;
@@ -16833,8 +16833,8 @@ var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst,
 });
 var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
   $ZodCheck.init(inst, def);
-  const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
-  def.pattern ?? (def.pattern = pattern);
+  const pattern2 = new RegExp(`^${escapeRegex(def.prefix)}.*`);
+  def.pattern ?? (def.pattern = pattern2);
   inst._zod.check = (payload) => {
     if (payload.value.startsWith(def.prefix))
       return;
@@ -16851,8 +16851,8 @@ var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (i
 });
 var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
   $ZodCheck.init(inst, def);
-  const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
-  def.pattern ?? (def.pattern = pattern);
+  const pattern2 = new RegExp(`.*${escapeRegex(def.suffix)}$`);
+  def.pattern ?? (def.pattern = pattern2);
   inst._zod.check = (payload) => {
     if (payload.value.endsWith(def.suffix))
       return;
@@ -18369,8 +18369,8 @@ var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
     return values ? /* @__PURE__ */ new Set([...values, void 0]) : void 0;
   });
   defineLazyInternal(inst, "pattern", (zod) => {
-    const pattern = zod.def.innerType._zod.pattern;
-    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
+    const pattern2 = zod.def.innerType._zod.pattern;
+    return pattern2 ? new RegExp(`^(${cleanRegex(pattern2.source)})?$`) : void 0;
   });
   inst._zod.parse = (payload, ctx) => {
     if (payload.value === void 0) {
@@ -18397,8 +18397,8 @@ var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
   defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin);
   defineLazyInternal(inst, "optout", (zod) => zod.def.innerType._zod.optout);
   defineLazyInternal(inst, "pattern", (zod) => {
-    const pattern = zod.def.innerType._zod.pattern;
-    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
+    const pattern2 = zod.def.innerType._zod.pattern;
+    return pattern2 ? new RegExp(`^(${cleanRegex(pattern2.source)}|null)$`) : void 0;
   });
   defineLazyInternal(inst, "values", (zod) => {
     return zod.def.innerType._zod.values ? /* @__PURE__ */ new Set([...zod.def.innerType._zod.values, null]) : void 0;
@@ -19492,12 +19492,12 @@ function _length(length, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _regex(pattern, params) {
+function _regex(pattern2, params) {
   return new $ZodCheckRegex({
     check: "string_format",
     format: "regex",
     ...normalizeParams(params),
-    pattern
+    pattern: pattern2
   });
 }
 // @__NO_SIDE_EFFECTS__
@@ -20183,9 +20183,9 @@ var addDivisor = (agg, value) => {
   if (!agg.multipleOf.includes(value))
     agg.multipleOf.push(value);
 };
-var addPattern = (agg, pattern) => {
+var addPattern = (agg, pattern2) => {
   agg.patterns ?? (agg.patterns = /* @__PURE__ */ new Set());
-  agg.patterns.add(pattern);
+  agg.patterns.add(pattern2);
 };
 var intersectMime = (agg, mime) => {
   agg.mime = agg.mime ? agg.mime.filter((m) => mime.includes(m)) : [...mime];
@@ -20250,8 +20250,8 @@ function aggregateChecks(schema) {
   }
   if (bag.mime)
     intersectMime(agg, bag.mime);
-  for (const pattern of bag.patterns ?? [])
-    addPattern(agg, pattern);
+  for (const pattern2 of bag.patterns ?? [])
+    addPattern(agg, pattern2);
   return agg;
 }
 var formatMap = {
@@ -20433,11 +20433,11 @@ var nanProcessor = (schema, ctx, json, params) => {
 };
 var templateLiteralProcessor = (schema, _ctx, json, _params) => {
   const _json = json;
-  const pattern = schema._zod.pattern;
-  if (!pattern)
+  const pattern2 = schema._zod.pattern;
+  if (!pattern2)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
-  _json.pattern = pattern.source;
+  _json.pattern = pattern2.source;
 };
 var fileProcessor = (schema, _ctx, json, _params) => {
   const _json = json;
@@ -20704,8 +20704,8 @@ function rewriteKeyNames(ctx) {
       bySchema.set(entry.schema, entry);
   }
   const rewrites = /* @__PURE__ */ new Map();
-  for (const record2 of pendingRecords.get(ctx) ?? []) {
-    const seen = ctx.seen.get(record2);
+  for (const record3 of pendingRecords.get(ctx) ?? []) {
+    const seen = ctx.seen.get(record3);
     const names = (seen?.def ?? seen?.schema)?.propertyNames;
     if (!names || names === true || rewrites.has(names))
       continue;
@@ -20735,8 +20735,8 @@ var recordProcessor = (schema, ctx, _json, params) => {
       path: [...params.path, "patternProperties", "*"]
     });
     json.patternProperties = {};
-    for (const pattern of patterns) {
-      assignProp(json.patternProperties, exactPattern(pattern).source, valueSchema);
+    for (const pattern2 of patterns) {
+      assignProp(json.patternProperties, exactPattern(pattern2).source, valueSchema);
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
@@ -26265,8 +26265,8 @@ function zodEmittedPattern(schema) {
   return typeof jsonSchema.pattern === "string" ? jsonSchema.pattern : void 0;
 }
 var DATETIME_FRACTION_DIGITS = /\\\.\\d\{(\d+)\}/;
-function datetimeReferenceSchemas(pattern) {
-  const fractionDigits = DATETIME_FRACTION_DIGITS.exec(pattern);
+function datetimeReferenceSchemas(pattern2) {
+  const fractionDigits = DATETIME_FRACTION_DIGITS.exec(pattern2);
   const precisions = [
     void 0,
     -1,
@@ -26279,7 +26279,7 @@ function datetimeReferenceSchemas(pattern) {
     precision
   }))));
 }
-function referencePatternsForFormat(format, pattern) {
+function referencePatternsForFormat(format, pattern2) {
   let referenceSchemas;
   switch (format) {
     case "email":
@@ -26292,14 +26292,14 @@ function referencePatternsForFormat(format, pattern) {
       referenceSchemas = [iso_exports.date()];
       break;
     case "date-time":
-      referenceSchemas = datetimeReferenceSchemas(pattern);
+      referenceSchemas = datetimeReferenceSchemas(pattern2);
       break;
   }
   return new Set(referenceSchemas.map((schema) => zodEmittedPattern(schema)).filter((emitted) => emitted !== void 0));
 }
-function isLibraryFormatPattern(format, pattern, vendor) {
+function isLibraryFormatPattern(format, pattern2, vendor) {
   if (vendor !== "zod") return true;
-  return referencePatternsForFormat(format, pattern).has(pattern);
+  return referencePatternsForFormat(format, pattern2).has(pattern2);
 }
 function promptArgumentsFromStandardSchema(schema) {
   const jsonSchema = standardSchemaToJsonSchema(schema, "input");
@@ -29237,14 +29237,14 @@ var require_code = /* @__PURE__ */ __commonJSMin(((exports) => {
   }
   exports.callValidateCode = callValidateCode;
   const newRegExp = (0, codegen_1._)`new RegExp`;
-  function usePattern({ gen, it: { opts } }, pattern) {
+  function usePattern({ gen, it: { opts } }, pattern2) {
     const u = opts.unicodeRegExp ? "u" : "";
     const { regExp } = opts.code;
-    const rx = regExp(pattern, u);
+    const rx = regExp(pattern2, u);
     return gen.scopeValue("pattern", {
       key: rx.toString(),
       ref: rx,
-      code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`
+      code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern2}, ${u})`
     });
   }
   exports.usePattern = usePattern;
@@ -32907,12 +32907,12 @@ var require_discriminator = /* @__PURE__ */ __commonJSMin(((exports) => {
     },
     code(cxt) {
       const { gen, data, schema, parentSchema, it } = cxt;
-      const { oneOf } = parentSchema;
+      const { oneOf: oneOf2 } = parentSchema;
       if (!it.opts.discriminator) throw new Error("discriminator: requires discriminator option");
       const tagName = schema.propertyName;
       if (typeof tagName != "string") throw new Error("discriminator: requires propertyName");
       if (schema.mapping) throw new Error("discriminator: mapping is not supported");
-      if (!oneOf) throw new Error("discriminator: requires oneOf keyword");
+      if (!oneOf2) throw new Error("discriminator: requires oneOf keyword");
       const valid = gen.let("valid", false);
       const tag2 = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
       gen.if((0, codegen_1._)`typeof ${tag2} == "string"`, () => validateMapping(), () => cxt.error(false, {
@@ -32950,8 +32950,8 @@ var require_discriminator = /* @__PURE__ */ __commonJSMin(((exports) => {
         const oneOfMapping = {};
         const topRequired = hasRequired(parentSchema);
         let tagRequired = true;
-        for (let i = 0; i < oneOf.length; i++) {
-          let sch = oneOf[i];
+        for (let i = 0; i < oneOf2.length; i++) {
+          let sch = oneOf2[i];
           if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
             const ref = sch.$ref;
             sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
@@ -39730,12 +39730,12 @@ var Node = class _Node {
     let node2 = this;
     for (let i = 0, len = tokens.length; i < len; i++) {
       const token = tokens[i];
-      const pattern = token.length === 1 ? token === "*" ? i === len - 1 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : null : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+      const pattern2 = token.length === 1 ? token === "*" ? i === len - 1 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : null : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
       let nextNode;
-      if (pattern) {
-        const name = pattern[1];
-        let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-        if (name && pattern[2]) {
+      if (pattern2) {
+        const name = pattern2[1];
+        let regexpStr = pattern2[2] || LABEL_REG_EXP_STR;
+        if (name && pattern2[2]) {
           if (regexpStr === ".*") {
             throw PATH_ERROR;
           }
@@ -40059,17 +40059,17 @@ var Node2 = class _Node2 {
     let i = 0;
     for (const p of parts) {
       const nextP = parts[++i];
-      const pattern = getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
-      const isParam = Array.isArray(pattern);
-      const key = isParam ? pattern[0] : pattern || p;
+      const pattern2 = getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
+      const isParam = Array.isArray(pattern2);
+      const key = isParam ? pattern2[0] : pattern2 || p;
       const child = curNode.#children[key] ||= new _Node2();
-      if (pattern && !child.#pattern) {
-        child.#pattern = pattern;
+      if (pattern2 && !child.#pattern) {
+        child.#pattern = pattern2;
         curNode.#patterns.push(child);
       }
       curNode = child;
       if (isParam) {
-        possibleKeys.add(pattern[1]);
+        possibleKeys.add(pattern2[1]);
       }
     }
     curNode.#methods.push({
@@ -40122,19 +40122,19 @@ var Node2 = class _Node2 {
           }
         }
         for (const child of node2.#patterns) {
-          const pattern = child.#pattern;
+          const pattern2 = child.#pattern;
           const params = node2.#params === emptyParams ? {} : { ...node2.#params };
-          if (typeof pattern === "string") {
-            if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+          if (typeof pattern2 === "string") {
+            if (pattern2 === "*" || part.startsWith(pattern2.slice(0, -1))) {
               this.#pushHandlerSets(handlerSets, child, method, node2.#params);
-              if (pattern === "*") {
+              if (pattern2 === "*") {
                 child.#params = params;
                 tempNodes.push(child);
               }
             }
             continue;
           }
-          const [, name, matcher] = pattern;
+          const [, name, matcher] = pattern2;
           if (!part && matcher === true) {
             continue;
           }
@@ -48158,6 +48158,7 @@ var CHART_META = viewer("chart-viewer");
 var KANBAN_META = viewer("kanban-viewer");
 var KPI_META = viewer("kpi-viewer");
 var FUNNEL_META = viewer("funnel-viewer");
+var BUY_EVIDENCE_META = viewer("buy-evidence-viewer");
 
 // src/runtime.ts
 var isDeno2 = typeof globalThis.Deno?.version?.deno === "string";
@@ -48387,6 +48388,24 @@ function decodeBase64File(contentBase64, maxBytes) {
   }
   return Uint8Array.from(binary, (character) => character.charCodeAt(0));
 }
+function normalizeFrappeSiteUrl(baseUrl) {
+  if (typeof baseUrl !== "string" || baseUrl.trim() === "") {
+    throw new Error(
+      "[FrappeClient] baseUrl is required to derive site identity"
+    );
+  }
+  let url2;
+  try {
+    url2 = new URL(baseUrl);
+  } catch {
+    throw new Error("[FrappeClient] baseUrl must be an absolute URL");
+  }
+  if (url2.protocol !== "http:" && url2.protocol !== "https:") {
+    throw new Error("[FrappeClient] baseUrl must be http or https");
+  }
+  const path = url2.pathname.replace(/\/+$/, "");
+  return `${url2.protocol}//${url2.host}${path}`;
+}
 var FrappeAPIError = class extends Error {
   /**
    * @param message - Human-readable error description
@@ -48473,6 +48492,17 @@ var FrappeClient = class {
     this.retryMethods = config2.retryMethods ?? DEFAULT_RETRY_METHODS;
     this.cache = config2.cache ?? new MemoryCache();
   }
+  /**
+   * Normalized site URL of this configured client: origin + site path, with
+   * credentials, query, and fragment stripped, and without a trailing slash.
+   *
+   * This is the preimage of the Buy capture `sourceInstance.siteId` SHA-256.
+   * It is not an ERP database UUID and must not be copied onto the wire when
+   * the opaque site identifier is sufficient.
+   */
+  normalizedSiteUrl() {
+    return normalizeFrappeSiteUrl(this.baseUrl);
+  }
   // ── Private HTTP helpers ────────────────────────────────────────────────────
   buildHeaders(includeJsonContentType = true) {
     const headers = {
@@ -49154,10 +49184,10 @@ function roundedTotalFallbackWarning(original, patched) {
 
 // src/tools/sales.ts
 function viewerDocument(value, doctype, name) {
-  const record2 = typeof value === "object" && value !== null ? value : {};
+  const record3 = typeof value === "object" && value !== null ? value : {};
   return {
-    ...record2,
-    ...typeof record2.name === "string" || !name ? {} : { name },
+    ...record3,
+    ...typeof record3.name === "string" || !name ? {} : { name },
     doctype
   };
 }
@@ -51665,8 +51695,8 @@ async function applyAssignment(doctype, name, assignment, ctx, failureContext) {
     throw new Error(`${failureContext}: ${reason}`, { cause: error2 });
   }
   const todos = Array.isArray(nativeResult) ? nativeResult.map((todo) => {
-    const record2 = todo;
-    return { owner: record2.owner, name: record2.name };
+    const record3 = todo;
+    return { owner: record3.owner, name: record3.name };
   }) : [];
   return { notify_user: true, assignees: assignment.assignees, todos };
 }
@@ -51683,8 +51713,8 @@ async function removeAssignment(doctype, name, assignee, ctx, failureContext) {
     throw new Error(`${failureContext}: ${reason}`, { cause: error2 });
   }
   const todos = Array.isArray(nativeResult) ? nativeResult.map((todo) => {
-    const record2 = todo;
-    return { owner: record2.owner, name: record2.name };
+    const record3 = todo;
+    return { owner: record3.owner, name: record3.name };
   }) : [];
   return { removed: assignee, remaining: todos };
 }
@@ -54973,11 +55003,11 @@ var setupTools = [
         filters.push(["enabled", "=", 1]);
       }
       if (input.search) {
-        const literal2 = input.search.replace(
+        const literal3 = input.search.replace(
           /[\\%_]/g,
           (match2) => `\\${match2}`
         );
-        filters.push(["full_name", "like", `%${literal2}%`]);
+        filters.push(["full_name", "like", `%${literal3}%`]);
       }
       const docs = await ctx.client.list("User", {
         fields: ["name", "full_name", "enabled"],
@@ -57437,6 +57467,1349 @@ var kanbanTools = [
   }
 ];
 
+// src/buy/identities.ts
+var BUY_SOURCE_CAPTURE_SCHEMA = "io.casys.mcp-erpnext.buy-source-capture/1.0";
+var BUY_RECORDED_RESULT_SCHEMA = "io.casys.mcp-erpnext.buy-recorded-result/1.0";
+var BUY_RECORDED_SESSION_SCHEMA = "io.casys.mcp-erpnext.buy-recorded-session/1.0";
+var BUY_EVIDENCE_VIEWER_URI = "ui://mcp-erpnext/buy-evidence-viewer";
+var BUY_VIEW_APP_MANIFEST_URI = "ui://mcp-erpnext/buy-evidence-manifest";
+var BUY_VIEW_APP_ID = "io.casys.mcp-erpnext.buy-evidence";
+var BUY_VIEW_APP_TITLE = "ERPNext Buy Evidence";
+var BUY_VIEW_APP_VERSION = "3.1.0-beta.9";
+var BUY_SOURCE_INSTANCE_KIND = "erpnext-site";
+var BUY_CAPTURE_DOCTYPE = [
+  "Item",
+  "BOM",
+  "Item Price",
+  "Supplier Quotation",
+  "Supplier",
+  "Price List",
+  "UOM",
+  "Currency Exchange"
+];
+var BUY_CAPTURE_MAX_DOCUMENTS = 32;
+var BUY_CAPTURE_MAX_CHILD_ROWS = 200;
+var BUY_CAPTURE_MAX_CANONICAL_BYTES = 262144;
+var BUY_CAPTURE_MAX_NAME_LENGTH = 140;
+var BUY_DOCTYPE_SOURCE_CATEGORY = {
+  Item: "item",
+  BOM: "bom",
+  "Item Price": "catalogue-price",
+  "Supplier Quotation": "supplier-quotation",
+  Supplier: "supplier",
+  "Price List": "price-list",
+  UOM: "uom",
+  "Currency Exchange": "currency-exchange"
+};
+var BUY_CONSISTENCY_KIND = "repeated-read";
+var BUY_CONSISTENCY_READS = 2;
+
+// src/buy/errors.ts
+var BuyCaptureError = class extends Error {
+  code;
+  retryable;
+  context;
+  recovery;
+  constructor(code, message2, options) {
+    super(message2);
+    this.name = "BuyCaptureError";
+    this.code = code;
+    this.retryable = options.retryable === true;
+    this.context = Object.freeze({ ...options.context ?? {} });
+    this.recovery = options.recovery;
+  }
+};
+
+// src/buy/json.ts
+var FINGERPRINT = /^sha256:[a-f0-9]{64}$/;
+var ISO_MILLISECONDS = /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}Z$/;
+var CALENDAR_DATE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
+var FRAPPE_DATETIME = /^[0-9]{4}-[0-9]{2}-[0-9]{2}[ T][0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?$/;
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "api_key",
+  "api_secret",
+  "authorization",
+  "baseUrl",
+  "command",
+  "commands",
+  "cookie",
+  "credentials",
+  "endpoint",
+  "password",
+  "source_path",
+  "sourcePath",
+  "stagedPath"
+]);
+function record2(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${name} must be an object.`);
+  }
+  return value;
+}
+function exactKeys(value, keys, name) {
+  const ownKeys = Reflect.ownKeys(value);
+  if (ownKeys.some((key) => typeof key !== "string")) {
+    throw new TypeError(`${name} contains missing or unsupported fields.`);
+  }
+  for (const key of ownKeys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !("value" in descriptor)) {
+      throw new TypeError(`${name} contains missing or unsupported fields.`);
+    }
+  }
+  const actual = ownKeys.toSorted();
+  const expected = [...keys].toSorted();
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    throw new TypeError(`${name} contains missing or unsupported fields.`);
+  }
+}
+function exactRecord(value, keys, name) {
+  const root = record2(value, name);
+  exactKeys(root, keys, name);
+  rejectForbiddenKeys(root, name);
+  return root;
+}
+function denseArray(value, name) {
+  if (!Array.isArray(value)) throw new TypeError(`${name} must be an array.`);
+  const allowed = /* @__PURE__ */ new Set(["length"]);
+  for (let index = 0; index < value.length; index += 1) {
+    allowed.add(String(index));
+  }
+  const ownKeys = Reflect.ownKeys(value);
+  if (ownKeys.length !== allowed.size || ownKeys.some((key) => typeof key !== "string" || !allowed.has(key))) {
+    throw new TypeError(`${name} must be a dense, unadorned array.`);
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor?.enumerable || !("value" in descriptor)) {
+      throw new TypeError(`${name} must be a dense, unadorned array.`);
+    }
+  }
+  return value;
+}
+function literal2(value, expected, name) {
+  if (value !== expected) throw new TypeError(`${name} must be ${expected}.`);
+  return expected;
+}
+function oneOf(value, allowed, name) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new TypeError(`${name} must be one of ${allowed.join(", ")}.`);
+  }
+  return value;
+}
+function nonEmpty(value, name) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError(`${name} must be a non-empty string.`);
+  }
+  if (value.trim() !== value) {
+    throw new TypeError(`${name} must not contain whitespace padding.`);
+  }
+  return value;
+}
+function pattern(value, expected, name) {
+  if (typeof value !== "string" || !expected.test(value)) {
+    throw new TypeError(`${name} has an invalid format.`);
+  }
+  return value;
+}
+function fingerprint(value, name) {
+  return pattern(value, FINGERPRINT, name);
+}
+function canonicalTimestamp(value, name) {
+  const timestamp = pattern(value, ISO_MILLISECONDS, name);
+  try {
+    if (new Date(timestamp).toISOString() !== timestamp) {
+      throw new TypeError(`${name} is not canonical UTC.`);
+    }
+  } catch {
+    throw new TypeError(`${name} is not canonical UTC.`);
+  }
+  return timestamp;
+}
+function calendarDate(value, name) {
+  const date4 = pattern(value, CALENDAR_DATE, name);
+  const parsed = /* @__PURE__ */ new Date(`${date4}T00:00:00.000Z`);
+  if (Number.isNaN(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== date4) {
+    throw new TypeError(`${name} is not a real calendar date.`);
+  }
+  return date4;
+}
+function frappeDatetime(value, name) {
+  const datetime3 = pattern(value, FRAPPE_DATETIME, name);
+  calendarDate(datetime3.slice(0, 10), name);
+  const [hour, minute, second] = datetime3.slice(11, 19).split(":").map(Number);
+  if (hour > 23 || minute > 59 || second > 59) {
+    throw new TypeError(`${name} is not a real Frappe datetime.`);
+  }
+  return datetime3;
+}
+function boundedArray(value, max, name) {
+  const items = denseArray(value, name);
+  if (items.length > max) {
+    throw new TypeError(`${name} exceeds the ${max}-entry bound.`);
+  }
+  return items;
+}
+function rejectForbiddenKeys(value, name) {
+  if (Array.isArray(value)) {
+    const items = denseArray(value, name);
+    for (let index = 0; index < items.length; index += 1) {
+      rejectForbiddenKeys(items[index], `${name}[${index}]`);
+    }
+    return;
+  }
+  if (typeof value !== "object" || value === null) return;
+  const root = record2(value, name);
+  for (const key of Object.keys(root)) {
+    if (FORBIDDEN_KEYS.has(key)) {
+      throw new TypeError(
+        `${name}.${key} is a private credential, path, or command field and must not appear in the Buy contract.`
+      );
+    }
+    rejectForbiddenKeys(root[key], `${name}.${key}`);
+  }
+}
+function canonicalJson2(value, name) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`${name} must contain only finite JSON numbers.`);
+    }
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    const items = denseArray(value, name);
+    return `[${items.map((item, index) => canonicalJson2(item, `${name}[${index}]`)).join(",")}]`;
+  }
+  const root = record2(value, name);
+  const prototype = Object.getPrototypeOf(root);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError(`${name} must contain only plain JSON objects.`);
+  }
+  const ownKeys = Reflect.ownKeys(root);
+  if (ownKeys.some((key) => typeof key !== "string")) {
+    throw new TypeError(`${name} must contain only string-keyed JSON objects.`);
+  }
+  const keys = ownKeys.toSorted();
+  const fields = keys.map((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(root, key);
+    if (!descriptor?.enumerable || !("value" in descriptor)) {
+      throw new TypeError(`${name}.${key} must be an enumerable JSON value.`);
+    }
+    if (descriptor.value === void 0) {
+      throw new TypeError(`${name}.${key} must not be undefined.`);
+    }
+    return `${JSON.stringify(key)}:${canonicalJson2(descriptor.value, `${name}.${key}`)}`;
+  });
+  return `{${fields.join(",")}}`;
+}
+function utf8ByteCount(text) {
+  return new TextEncoder().encode(text).byteLength;
+}
+async function sha256HexOfUtf8(text) {
+  const bytes = new TextEncoder().encode(text);
+  const digestBytes = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", bytes)
+  );
+  return Array.from(digestBytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256FingerprintOfUtf8(text) {
+  return `sha256:${await sha256HexOfUtf8(text)}`;
+}
+
+// src/buy/projection.ts
+var DECIMAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+var CURRENCY = /^[A-Z]{3}$/;
+var SENSITIVE_FIELDS = /* @__PURE__ */ new Set([
+  "api_key",
+  "api_secret",
+  "password",
+  "email_id",
+  "email",
+  "mobile_no",
+  "phone",
+  "cell_number"
+]);
+var ITEM_FIELDS = [
+  { key: "item_code", kind: "string", required: true },
+  { key: "item_name", kind: "string" },
+  { key: "item_group", kind: "string" },
+  { key: "stock_uom", kind: "string" },
+  { key: "is_purchase_item", kind: "boolean" },
+  { key: "is_stock_item", kind: "boolean" },
+  { key: "disabled", kind: "boolean" }
+];
+var BOM_FIELDS = [
+  { key: "item", kind: "string", required: true },
+  { key: "item_name", kind: "string" },
+  { key: "quantity", kind: "decimal", required: true },
+  { key: "uom", kind: "string", required: true },
+  { key: "is_active", kind: "boolean" },
+  { key: "is_default", kind: "boolean" },
+  { key: "company", kind: "string" },
+  { key: "currency", kind: "currency" },
+  { key: "with_operations", kind: "boolean" }
+];
+var BOM_ITEM_FIELDS = [
+  { key: "item_code", kind: "string", required: true },
+  { key: "item_name", kind: "string" },
+  { key: "qty", kind: "decimal", required: true },
+  { key: "uom", kind: "string", required: true },
+  { key: "rate", kind: "decimal" },
+  { key: "amount", kind: "decimal" },
+  { key: "sourced_by_supplier", kind: "boolean" }
+];
+var BOM_OPERATION_FIELDS = [
+  { key: "operation", kind: "string", required: true },
+  { key: "time_in_mins", kind: "decimal" },
+  { key: "hour_rate", kind: "decimal" }
+];
+var ITEM_PRICE_FIELDS = [
+  { key: "item_code", kind: "string", required: true },
+  { key: "item_name", kind: "string" },
+  { key: "price_list", kind: "string" },
+  { key: "price_list_rate", kind: "decimal", required: true },
+  { key: "currency", kind: "currency", required: true },
+  { key: "uom", kind: "string" },
+  { key: "min_qty", kind: "decimal" },
+  { key: "valid_from", kind: "date" },
+  { key: "valid_upto", kind: "date" },
+  { key: "supplier", kind: "string" },
+  { key: "buying", kind: "boolean" },
+  { key: "selling", kind: "boolean" }
+];
+var SUPPLIER_QUOTATION_FIELDS = [
+  { key: "supplier", kind: "string", required: true },
+  { key: "supplier_name", kind: "string" },
+  { key: "transaction_date", kind: "date", required: true },
+  { key: "valid_till", kind: "date" },
+  { key: "currency", kind: "currency", required: true },
+  { key: "conversion_rate", kind: "decimal" },
+  { key: "status", kind: "string" },
+  { key: "company", kind: "string" },
+  { key: "price_list", kind: "string" }
+];
+var SUPPLIER_QUOTATION_ITEM_FIELDS = [
+  { key: "item_code", kind: "string", required: true },
+  { key: "item_name", kind: "string" },
+  { key: "qty", kind: "decimal", required: true },
+  { key: "uom", kind: "string", required: true },
+  { key: "rate", kind: "decimal" },
+  { key: "amount", kind: "decimal" },
+  { key: "price_list_rate", kind: "decimal" },
+  { key: "discount_percentage", kind: "decimal" },
+  { key: "supplier_part_no", kind: "string" }
+];
+var SUPPLIER_FIELDS = [
+  { key: "supplier_name", kind: "string", required: true },
+  { key: "supplier_group", kind: "string" },
+  { key: "supplier_type", kind: "string" },
+  { key: "country", kind: "string" },
+  { key: "default_currency", kind: "currency" },
+  { key: "disabled", kind: "boolean" }
+];
+var PRICE_LIST_FIELDS = [
+  { key: "currency", kind: "currency", required: true },
+  { key: "enabled", kind: "boolean" },
+  { key: "buying", kind: "boolean" },
+  { key: "selling", kind: "boolean" },
+  { key: "price_not_uom_dependent", kind: "boolean" }
+];
+var UOM_FIELDS = [
+  { key: "uom_name", kind: "string" },
+  { key: "must_be_whole_number", kind: "boolean" }
+];
+var CURRENCY_EXCHANGE_FIELDS = [
+  { key: "from_currency", kind: "currency", required: true },
+  { key: "to_currency", kind: "currency", required: true },
+  { key: "exchange_rate", kind: "decimal", required: true },
+  { key: "date", kind: "date", required: true }
+];
+var BUY_DOCTYPE_CHILD_TABLES = {
+  BOM: [
+    { table: "items", fields: BOM_ITEM_FIELDS },
+    { table: "operations", fields: BOM_OPERATION_FIELDS }
+  ],
+  "Supplier Quotation": [
+    { table: "items", fields: SUPPLIER_QUOTATION_ITEM_FIELDS }
+  ]
+};
+var BUY_DOCTYPE_FIELD_SPECS = {
+  Item: ITEM_FIELDS,
+  BOM: BOM_FIELDS,
+  "Item Price": ITEM_PRICE_FIELDS,
+  "Supplier Quotation": SUPPLIER_QUOTATION_FIELDS,
+  Supplier: SUPPLIER_FIELDS,
+  "Price List": PRICE_LIST_FIELDS,
+  UOM: UOM_FIELDS,
+  "Currency Exchange": CURRENCY_EXCHANGE_FIELDS
+};
+function isBuyCaptureDoctype(value) {
+  return BUY_CAPTURE_DOCTYPE.includes(value);
+}
+async function projectBuyDocument(doctype, raw2) {
+  const name = requiredName(raw2.name, `${doctype}.name`);
+  const modified = requiredModified(raw2.modified, `${doctype}.modified`);
+  const fields = projectFields(
+    raw2,
+    BUY_DOCTYPE_FIELD_SPECS[doctype],
+    `${doctype}`
+  );
+  const children = projectChildren(doctype, raw2);
+  const docstatus = optionalDocstatus(raw2.docstatus, `${doctype}.docstatus`);
+  const status = optionalStatus(raw2.status, `${doctype}.status`);
+  const identity = {
+    doctype,
+    name,
+    modified,
+    ...docstatus !== void 0 ? { docstatus } : {},
+    ...status !== void 0 ? { status } : {},
+    sourceCategory: BUY_DOCTYPE_SOURCE_CATEGORY[doctype],
+    fields,
+    ...children !== void 0 ? { children } : {}
+  };
+  const fingerprint2 = await sha256FingerprintOfUtf8(
+    canonicalJson2(identity, `${doctype}:${name} projection`)
+  );
+  return { ...identity, fingerprint: fingerprint2 };
+}
+function projectChildren(doctype, raw2) {
+  const specs = BUY_DOCTYPE_CHILD_TABLES[doctype];
+  if (!specs) return void 0;
+  const tables = [];
+  for (const spec of specs) {
+    const value = raw2[spec.table];
+    if (value === void 0 || value === null) continue;
+    if (!Array.isArray(value)) {
+      throw new BuyCaptureError(
+        "BUY_CAPTURE_INVALID_PROJECTION",
+        `${doctype}.${spec.table} must be a child table array.`,
+        {
+          recovery: "Capture only closed child tables with exact row identities.",
+          context: { doctype, table: spec.table }
+        }
+      );
+    }
+    if (value.length > BUY_CAPTURE_MAX_CHILD_ROWS) {
+      throw new BuyCaptureError(
+        "BUY_CAPTURE_BOUNDS_EXCEEDED",
+        `${doctype}.${spec.table} exceeds the ${BUY_CAPTURE_MAX_CHILD_ROWS}-row bound.`,
+        {
+          recovery: "Narrow the capture to fewer child rows.",
+          context: {
+            doctype,
+            table: spec.table,
+            limit: BUY_CAPTURE_MAX_CHILD_ROWS,
+            actual: value.length
+          }
+        }
+      );
+    }
+    if (value.length === 0) continue;
+    const rows = value.map(
+      (row, index) => projectChildRow(
+        row,
+        spec.fields,
+        `${doctype}.${spec.table}[${index}]`
+      )
+    );
+    tables.push({ table: spec.table, rows });
+  }
+  return tables.length > 0 ? tables : void 0;
+}
+function projectChildRow(row, specs, path) {
+  if (typeof row !== "object" || row === null || Array.isArray(row)) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_PROJECTION",
+      `${path} must be a child row object.`,
+      {
+        recovery: "Child rows must keep their exact Frappe name identity.",
+        context: { path }
+      }
+    );
+  }
+  const record3 = row;
+  const name = requiredName(record3.name, `${path}.name`);
+  const idx = optionalIdx(record3.idx, `${path}.idx`);
+  return {
+    name,
+    ...idx !== void 0 ? { idx } : {},
+    fields: projectFields(record3, specs, path)
+  };
+}
+function projectFields(raw2, specs, path) {
+  for (const key of Object.keys(raw2)) {
+    if (SENSITIVE_FIELDS.has(key)) {
+      continue;
+    }
+  }
+  const fields = {};
+  for (const spec of specs) {
+    const value = projectField(raw2[spec.key], spec, `${path}.${spec.key}`);
+    if (value !== void 0) fields[spec.key] = value;
+  }
+  return fields;
+}
+function projectField(value, spec, path) {
+  if (value === void 0 || value === null || value === "") {
+    if (spec.required) {
+      throw new BuyCaptureError(
+        "BUY_CAPTURE_INVALID_PROJECTION",
+        `${path} is required on the closed commercial projection.`,
+        {
+          recovery: "The ERP document is missing a field later consumed as cost evidence.",
+          context: { path, field: spec.key }
+        }
+      );
+    }
+    return void 0;
+  }
+  switch (spec.kind) {
+    case "string":
+      return requiredString(value, path);
+    case "decimal":
+      return requiredDecimal(value, path);
+    case "boolean":
+      return requiredBoolean(value, path);
+    case "currency":
+      return requiredCurrency(value, path);
+    case "date":
+      return requiredDate(value, path);
+    case "integer":
+      return requiredInteger(value, path);
+  }
+}
+function requiredName(value, path) {
+  const name = requiredString(value, path);
+  if (name.length > BUY_CAPTURE_MAX_NAME_LENGTH) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_BOUNDS_EXCEEDED",
+      `${path} exceeds the ${BUY_CAPTURE_MAX_NAME_LENGTH}-character bound.`,
+      {
+        recovery: "Use the exact ERP document name; do not pass a description.",
+        context: {
+          path,
+          limit: BUY_CAPTURE_MAX_NAME_LENGTH,
+          actual: name.length
+        }
+      }
+    );
+  }
+  return name;
+}
+function requiredModified(value, path) {
+  try {
+    return frappeDatetime(value, path);
+  } catch {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_PROJECTION",
+      `${path} is not a Frappe datetime.`,
+      {
+        recovery: "Capture the document's exact modified timestamp.",
+        context: { path }
+      }
+    );
+  }
+}
+function requiredString(value, path) {
+  if (typeof value !== "string" || value.trim() === "" || value.trim() !== value) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_PROJECTION",
+      `${path} must be a non-empty unpadded string.`,
+      {
+        recovery: "Use the exact ERP string; do not invent a label.",
+        context: { path }
+      }
+    );
+  }
+  return value;
+}
+function requiredDecimal(value, path) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new BuyCaptureError(
+        "BUY_CAPTURE_INVALID_PROJECTION",
+        `${path} must be a finite decimal.`,
+        {
+          recovery: "Refuse non-finite commercial amounts rather than coerce them.",
+          context: { path }
+        }
+      );
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") {
+    if (!DECIMAL.test(value)) {
+      throw new BuyCaptureError(
+        "BUY_CAPTURE_INVALID_PROJECTION",
+        `${path} must be a canonical decimal string.`,
+        {
+          recovery: "Keep the ERP decimal; do not fill absence with zero.",
+          context: { path }
+        }
+      );
+    }
+    return value;
+  }
+  throw new BuyCaptureError(
+    "BUY_CAPTURE_INVALID_PROJECTION",
+    `${path} must be a decimal.`,
+    {
+      recovery: "Keep the ERP decimal; do not fill absence with zero.",
+      context: { path }
+    }
+  );
+}
+function requiredBoolean(value, path) {
+  if (value === true || value === 1) return true;
+  if (value === false || value === 0) return false;
+  throw new BuyCaptureError(
+    "BUY_CAPTURE_INVALID_PROJECTION",
+    `${path} must be a boolean or Frappe 0/1.`,
+    {
+      recovery: "Do not coerce missing flags to false.",
+      context: { path }
+    }
+  );
+}
+function requiredCurrency(value, path) {
+  const code = requiredString(value, path);
+  if (!CURRENCY.test(code)) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_PROJECTION",
+      `${path} must be a 3-letter currency code.`,
+      {
+        recovery: "Capture the document currency; do not guess a conversion.",
+        context: { path }
+      }
+    );
+  }
+  return code;
+}
+function requiredDate(value, path) {
+  try {
+    return calendarDate(value, path);
+  } catch {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_PROJECTION",
+      `${path} must be a real YYYY-MM-DD date.`,
+      {
+        recovery: "Keep the ERP calendar date; do not localize it.",
+        context: { path }
+      }
+    );
+  }
+}
+function requiredInteger(value, path) {
+  if (!Number.isSafeInteger(value)) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_PROJECTION",
+      `${path} must be a safe integer.`,
+      { recovery: "Keep the ERP integer identity.", context: { path } }
+    );
+  }
+  return value;
+}
+function optionalDocstatus(value, path) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (value !== 0 && value !== 1 && value !== 2) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_PROJECTION",
+      `${path} must be 0, 1, or 2.`,
+      { recovery: "Keep the ERP docstatus.", context: { path } }
+    );
+  }
+  return value;
+}
+function optionalStatus(value, path) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  return requiredString(value, path);
+}
+function optionalIdx(value, path) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  return requiredInteger(value, path);
+}
+function parseClosedWireFields(value, specs, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${path} must be an object.`);
+  }
+  const root = value;
+  const allowed = new Map(specs.map((spec) => [spec.key, spec]));
+  for (const key of Object.keys(root)) {
+    if (!allowed.has(key)) {
+      throw new TypeError(`${path}.${key} is not a closed commercial field.`);
+    }
+  }
+  const fields = {};
+  for (const spec of specs) {
+    const raw2 = root[spec.key];
+    if (raw2 === void 0 || raw2 === null || raw2 === "") {
+      if (spec.required) {
+        throw new TypeError(`${path}.${spec.key} is required.`);
+      }
+      continue;
+    }
+    fields[spec.key] = parseWireValue(raw2, spec, `${path}.${spec.key}`);
+  }
+  return fields;
+}
+function parseClosedWireChildren(doctype, value, path) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    throw new TypeError(`${path} must be an array.`);
+  }
+  const specs = BUY_DOCTYPE_CHILD_TABLES[doctype] ?? [];
+  if (specs.length === 0) {
+    throw new TypeError(`${path} is not admitted for ${doctype}.`);
+  }
+  if (value.length === 0) {
+    throw new TypeError(`${path} must be omitted when empty.`);
+  }
+  const known = new Map(specs.map((spec) => [spec.table, spec]));
+  const seenTables = /* @__PURE__ */ new Set();
+  return value.map((item, index) => {
+    const tablePath = `${path}[${index}]`;
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+      throw new TypeError(`${tablePath} must be an object.`);
+    }
+    const table2 = item;
+    const keys = Object.keys(table2).toSorted();
+    if (keys.length !== 2 || keys[0] !== "rows" || keys[1] !== "table") {
+      throw new TypeError(
+        `${tablePath} contains missing or unsupported fields.`
+      );
+    }
+    if (typeof table2.table !== "string" || !known.has(table2.table)) {
+      throw new TypeError(
+        `${tablePath}.table is not a closed child table for ${doctype}.`
+      );
+    }
+    if (seenTables.has(table2.table)) {
+      throw new TypeError(`${tablePath}.table duplicates ${table2.table}.`);
+    }
+    seenTables.add(table2.table);
+    const spec = known.get(table2.table);
+    if (!Array.isArray(table2.rows)) {
+      throw new TypeError(`${tablePath}.rows must be an array.`);
+    }
+    if (table2.rows.length > BUY_CAPTURE_MAX_CHILD_ROWS) {
+      throw new TypeError(
+        `${tablePath}.rows exceeds the ${BUY_CAPTURE_MAX_CHILD_ROWS}-row bound.`
+      );
+    }
+    const seenRows = /* @__PURE__ */ new Set();
+    const rows = table2.rows.map((row, rowIndex) => {
+      const rowPath = `${tablePath}.rows[${rowIndex}]`;
+      const parsed = parseClosedWireRow(row, spec.fields, rowPath);
+      if (seenRows.has(parsed.name)) {
+        throw new TypeError(`${rowPath} duplicates child row ${parsed.name}.`);
+      }
+      seenRows.add(parsed.name);
+      return parsed;
+    });
+    return { table: spec.table, rows };
+  });
+}
+function parseClosedWireRow(value, specs, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${path} must be an object.`);
+  }
+  const root = value;
+  const keys = Object.keys(root).toSorted();
+  const allowed = root.idx === void 0 ? ["fields", "name"] : ["fields", "idx", "name"];
+  if (keys.length !== allowed.length || keys.some((key, index) => key !== allowed[index])) {
+    throw new TypeError(`${path} contains missing or unsupported fields.`);
+  }
+  const name = requiredWireName(root.name, `${path}.name`);
+  return {
+    name,
+    ...root.idx === void 0 ? {} : {
+      idx: requiredWireIdx(root.idx, `${path}.idx`)
+    },
+    fields: parseClosedWireFields(root.fields, specs, `${path}.fields`)
+  };
+}
+function parseWireValue(value, spec, path) {
+  switch (spec.kind) {
+    case "string":
+      if (typeof value !== "string" || value.trim() === "" || value.trim() !== value) {
+        throw new TypeError(`${path} must be a non-empty unpadded string.`);
+      }
+      return value;
+    case "decimal":
+      if (typeof value !== "string" || !DECIMAL.test(value)) {
+        throw new TypeError(`${path} must be a canonical decimal string.`);
+      }
+      return value;
+    case "boolean":
+      if (value !== true && value !== false) {
+        throw new TypeError(`${path} must be a boolean.`);
+      }
+      return value;
+    case "currency":
+      if (typeof value !== "string" || !CURRENCY.test(value)) {
+        throw new TypeError(`${path} must be a 3-letter currency code.`);
+      }
+      return value;
+    case "date":
+      return calendarDate(value, path);
+    case "integer":
+      if (!Number.isSafeInteger(value)) {
+        throw new TypeError(`${path} must be a safe integer.`);
+      }
+      return value;
+  }
+}
+function requiredWireName(value, path) {
+  if (typeof value !== "string" || value.trim() === "" || value.trim() !== value) {
+    throw new TypeError(`${path} must be a non-empty unpadded string.`);
+  }
+  if (value.length > BUY_CAPTURE_MAX_NAME_LENGTH) {
+    throw new TypeError(
+      `${path} exceeds the ${BUY_CAPTURE_MAX_NAME_LENGTH}-character bound.`
+    );
+  }
+  return value;
+}
+function requiredWireIdx(value, path) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${path} must be a non-negative integer.`);
+  }
+  return value;
+}
+
+// src/buy/site.ts
+async function sourceInstanceFromClient(client) {
+  const normalized = client.normalizedSiteUrl();
+  return {
+    kind: BUY_SOURCE_INSTANCE_KIND,
+    siteId: await sha256FingerprintOfUtf8(normalized)
+  };
+}
+
+// src/buy/capture.ts
+var CALLER_AUTHORITY_KEYS = [
+  "sourceInstance",
+  "capturedAt",
+  "fingerprint",
+  "canonicalText",
+  "byteCount",
+  "endpoint",
+  "uri",
+  "credentials",
+  "baseUrl",
+  "siteId",
+  "attestedTimestamp",
+  "digest"
+];
+function parseBuyCaptureInput(value) {
+  const root = asRecord(value, "buy capture input");
+  for (const key of CALLER_AUTHORITY_KEYS) {
+    if (key in root) {
+      throw new BuyCaptureError(
+        "BUY_CAPTURE_CALLER_AUTHORITY_REJECTED",
+        `buy capture input must not include caller-supplied ${key}.`,
+        {
+          recovery: "Omit sourceInstance, capturedAt, fingerprints, endpoints, and credentials; the configured FrappeClient and server clock own those fields.",
+          context: { key }
+        }
+      );
+    }
+  }
+  const keys = Object.keys(root);
+  if (keys.length !== 1 || keys[0] !== "documents") {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_INPUT",
+      "buy capture input must contain only documents.",
+      {
+        recovery: "Pass a bounded list of exact {doctype, name, expectedModified?} references.",
+        context: { keys }
+      }
+    );
+  }
+  if (!Array.isArray(root.documents)) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_INPUT",
+      "buy capture input.documents must be an array.",
+      {
+        recovery: "Pass a dense list of exact document references."
+      }
+    );
+  }
+  if (root.documents.length === 0) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_INPUT",
+      "buy capture input.documents must not be empty.",
+      {
+        recovery: "Name the exact documents to capture."
+      }
+    );
+  }
+  if (root.documents.length > BUY_CAPTURE_MAX_DOCUMENTS) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_BOUNDS_EXCEEDED",
+      `buy capture input.documents exceeds the ${BUY_CAPTURE_MAX_DOCUMENTS}-document bound.`,
+      {
+        recovery: "Narrow the capture; silent pagination is not allowed.",
+        context: {
+          limit: BUY_CAPTURE_MAX_DOCUMENTS,
+          actual: root.documents.length
+        }
+      }
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const documents = root.documents.map(
+    (item, index) => parseDocumentRef(item, index, seen)
+  );
+  return { documents };
+}
+async function parseBuySourceCapture(value) {
+  const root = exactRecord(value, [
+    "schemaVersion",
+    "sourceInstance",
+    "capturedAt",
+    "documents",
+    "consistency"
+  ], "buy source capture");
+  literal2(
+    root.schemaVersion,
+    BUY_SOURCE_CAPTURE_SCHEMA,
+    "buy source capture.schemaVersion"
+  );
+  const source = exactRecord(
+    root.sourceInstance,
+    ["kind", "siteId"],
+    "buy source capture.sourceInstance"
+  );
+  literal2(
+    source.kind,
+    BUY_SOURCE_INSTANCE_KIND,
+    "buy source capture.sourceInstance.kind"
+  );
+  const documents = [];
+  const rawDocuments = boundedArray(
+    root.documents,
+    BUY_CAPTURE_MAX_DOCUMENTS,
+    "buy source capture.documents"
+  );
+  if (rawDocuments.length === 0) {
+    throw new TypeError("buy source capture.documents must not be empty.");
+  }
+  const seenDocuments = /* @__PURE__ */ new Set();
+  for (let index = 0; index < rawDocuments.length; index += 1) {
+    const parsed = await parseCapturedDocument(rawDocuments[index], index);
+    const id = `${parsed.doctype}:${parsed.name}`;
+    if (seenDocuments.has(id)) {
+      throw new TypeError(
+        `buy source capture.documents[${index}] duplicates ${id}.`
+      );
+    }
+    seenDocuments.add(id);
+    documents.push(parsed);
+  }
+  const consistency = exactRecord(
+    root.consistency,
+    ["kind", "reads", "consistent"],
+    "buy source capture.consistency"
+  );
+  literal2(
+    consistency.kind,
+    BUY_CONSISTENCY_KIND,
+    "buy source capture.consistency.kind"
+  );
+  if (consistency.reads !== BUY_CONSISTENCY_READS) {
+    throw new TypeError(
+      "buy source capture.consistency.reads must be 2."
+    );
+  }
+  if (consistency.consistent !== true) {
+    throw new TypeError(
+      "buy source capture.consistency.consistent must be true; inconsistent captures are not a usable payload."
+    );
+  }
+  return {
+    schemaVersion: BUY_SOURCE_CAPTURE_SCHEMA,
+    sourceInstance: {
+      kind: BUY_SOURCE_INSTANCE_KIND,
+      siteId: fingerprint(
+        source.siteId,
+        "buy source capture.sourceInstance.siteId"
+      )
+    },
+    capturedAt: canonicalTimestamp(
+      root.capturedAt,
+      "buy source capture.capturedAt"
+    ),
+    documents,
+    consistency: {
+      kind: BUY_CONSISTENCY_KIND,
+      reads: BUY_CONSISTENCY_READS,
+      consistent: true
+    }
+  };
+}
+async function sealBuySourceCapture(capture) {
+  const parsed = await parseBuySourceCapture(capture);
+  const canonicalText = canonicalJson2(parsed, "buy source capture");
+  const byteCount = utf8ByteCount(canonicalText);
+  if (byteCount > BUY_CAPTURE_MAX_CANONICAL_BYTES) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_BOUNDS_EXCEEDED",
+      `buy source capture exceeds the ${BUY_CAPTURE_MAX_CANONICAL_BYTES}-byte bound.`,
+      {
+        recovery: "Narrow the capture; silent pagination is not allowed.",
+        context: { limit: BUY_CAPTURE_MAX_CANONICAL_BYTES, actual: byteCount }
+      }
+    );
+  }
+  return {
+    schemaVersion: BUY_SOURCE_CAPTURE_SCHEMA,
+    capture: parsed,
+    canonicalText,
+    fingerprint: await sha256FingerprintOfUtf8(canonicalText),
+    byteCount
+  };
+}
+async function runBuyCapture(input, deps) {
+  const parsedInput = parseBuyCaptureInput(input);
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const capturedAt = canonicalTimestamp(
+    now().toISOString(),
+    "buy source capture.capturedAt"
+  );
+  const sourceInstance = await sourceInstanceFromClient(deps.client);
+  const first = await readAll(parsedInput.documents, deps.client);
+  const documents = await Promise.all(
+    first.map((row) => projectBuyDocument(row.doctype, row.doc))
+  );
+  for (let index = 0; index < parsedInput.documents.length; index += 1) {
+    const expected = parsedInput.documents[index].expectedModified;
+    if (expected !== void 0 && documents[index].modified !== expected) {
+      throw new BuyCaptureError(
+        "BUY_CAPTURE_EXPECTED_MODIFIED_MISMATCH",
+        `Document ${documents[index].doctype}:${documents[index].name} modified does not match expectedModified.`,
+        {
+          recovery: "Re-resolve the exact document revision before capturing.",
+          context: {
+            doctype: documents[index].doctype,
+            name: documents[index].name,
+            modified: documents[index].modified,
+            expectedModified: expected
+          }
+        }
+      );
+    }
+  }
+  const second = await readAll(parsedInput.documents, deps.client);
+  const reread = await Promise.all(
+    second.map((row) => projectBuyDocument(row.doctype, row.doc))
+  );
+  for (let index = 0; index < documents.length; index += 1) {
+    const a = documents[index];
+    const b = reread[index];
+    if (a.modified !== b.modified || a.fingerprint !== b.fingerprint) {
+      throw new BuyCaptureError(
+        "BUY_CAPTURE_INCONSISTENT",
+        `Document ${a.doctype}:${a.name} changed between the two skipCache reads.`,
+        {
+          retryable: true,
+          recovery: "Retry the capture. Repeated-read consistency failed; this is not a transactional snapshot.",
+          context: {
+            doctype: a.doctype,
+            name: a.name,
+            firstModified: a.modified,
+            secondModified: b.modified,
+            firstFingerprint: a.fingerprint,
+            secondFingerprint: b.fingerprint
+          }
+        }
+      );
+    }
+  }
+  return await sealBuySourceCapture({
+    schemaVersion: BUY_SOURCE_CAPTURE_SCHEMA,
+    sourceInstance,
+    capturedAt,
+    documents,
+    consistency: {
+      kind: BUY_CONSISTENCY_KIND,
+      reads: BUY_CONSISTENCY_READS,
+      consistent: true
+    }
+  });
+}
+async function readAll(refs, client) {
+  const docs = [];
+  for (const ref of refs) {
+    let doc;
+    try {
+      doc = await client.get(ref.doctype, ref.name, { skipCache: true });
+    } catch (error2) {
+      if (error2 instanceof FrappeAPIError && error2.status === 404) {
+        throw new BuyCaptureError(
+          "BUY_CAPTURE_MISSING_SOURCE",
+          `Document ${ref.doctype}:${ref.name} was not found.`,
+          {
+            recovery: "Capture only documents that currently exist on the configured site.",
+            context: { doctype: ref.doctype, name: ref.name }
+          }
+        );
+      }
+      throw error2;
+    }
+    assertExactReturnedIdentity(ref, doc);
+    docs.push({ doctype: ref.doctype, doc });
+  }
+  return docs;
+}
+function assertExactReturnedIdentity(ref, doc) {
+  if (doc.name !== ref.name) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_IDENTITY_MISMATCH",
+      `Requested ${ref.doctype}:${ref.name} but the client returned name ${String(doc.name)}.`,
+      {
+        recovery: "Refuse the response; do not relabel a different ERP document as the requested identity.",
+        context: {
+          requestedDoctype: ref.doctype,
+          requestedName: ref.name,
+          returnedName: doc.name
+        }
+      }
+    );
+  }
+  if (doc.doctype !== void 0 && doc.doctype !== null && doc.doctype !== "" && doc.doctype !== ref.doctype) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_IDENTITY_MISMATCH",
+      `Requested ${ref.doctype}:${ref.name} but the client returned doctype ${String(doc.doctype)}.`,
+      {
+        recovery: "Refuse the response; do not relabel a different ERP document as the requested identity.",
+        context: {
+          requestedDoctype: ref.doctype,
+          requestedName: ref.name,
+          returnedDoctype: doc.doctype
+        }
+      }
+    );
+  }
+}
+function parseDocumentRef(value, index, seen) {
+  const path = `buy capture input.documents[${index}]`;
+  const root = asRecord(value, path);
+  const keys = Object.keys(root).toSorted();
+  const allowed = root.expectedModified === void 0 ? ["doctype", "name"] : ["doctype", "expectedModified", "name"];
+  if (keys.length !== allowed.length || keys.some((key, keyIndex) => key !== allowed[keyIndex])) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_INPUT",
+      `${path} must contain only doctype, name, and optional expectedModified.`,
+      {
+        recovery: "Do not pass endpoints, sourceInstance, or extra ERP fields.",
+        context: { keys }
+      }
+    );
+  }
+  if (typeof root.doctype !== "string" || !isBuyCaptureDoctype(root.doctype)) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_UNSUPPORTED_DOCTYPE",
+      `${path}.doctype is not a closed Buy capture DocType.`,
+      {
+        recovery: `Use one of ${BUY_CAPTURE_DOCTYPE.join(", ")}. Generic doctypes cannot masquerade as a price.`,
+        context: { doctype: root.doctype }
+      }
+    );
+  }
+  if (typeof root.name !== "string" || root.name.trim() === "" || root.name.trim() !== root.name) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_INPUT",
+      `${path}.name must be the exact ERP document name.`,
+      { recovery: "Pass the exact document name, not a label." }
+    );
+  }
+  if (root.name.length > BUY_CAPTURE_MAX_NAME_LENGTH) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_BOUNDS_EXCEEDED",
+      `${path}.name exceeds the ${BUY_CAPTURE_MAX_NAME_LENGTH}-character bound.`,
+      {
+        recovery: "Use the exact ERP document name.",
+        context: {
+          limit: BUY_CAPTURE_MAX_NAME_LENGTH,
+          actual: root.name.length
+        }
+      }
+    );
+  }
+  const id = `${root.doctype}:${root.name}`;
+  if (seen.has(id)) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_INPUT",
+      `${path} duplicates ${id}.`,
+      { recovery: "Each exact document reference may appear once." }
+    );
+  }
+  seen.add(id);
+  const expectedModified = root.expectedModified === void 0 ? void 0 : parseExpectedModified(root.expectedModified, `${path}.expectedModified`);
+  return {
+    doctype: root.doctype,
+    name: root.name,
+    ...expectedModified !== void 0 ? { expectedModified } : {}
+  };
+}
+function parseExpectedModified(value, path) {
+  if (typeof value !== "string" || value.trim() === "" || value.trim() !== value) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_INPUT",
+      `${path} must be the exact Frappe modified timestamp.`,
+      { recovery: "Pass the document's modified value, not a caller digest." }
+    );
+  }
+  try {
+    frappeDatetime(value, path);
+  } catch {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_INPUT",
+      `${path} is not a Frappe datetime.`,
+      { recovery: "Pass the document's modified value." }
+    );
+  }
+  return value;
+}
+async function parseCapturedDocument(value, index) {
+  const path = `buy source capture.documents[${index}]`;
+  const root = record2(value, path);
+  const keys = Object.keys(root).toSorted();
+  const optional2 = /* @__PURE__ */ new Set(["docstatus", "status", "children"]);
+  const required2 = [
+    "doctype",
+    "fields",
+    "fingerprint",
+    "modified",
+    "name",
+    "sourceCategory"
+  ];
+  const actualRequired = keys.filter((key) => !optional2.has(key)).toSorted();
+  if (actualRequired.length !== required2.length || actualRequired.some((key, keyIndex) => key !== required2[keyIndex])) {
+    throw new TypeError(`${path} contains missing or unsupported fields.`);
+  }
+  const extra = keys.filter(
+    (key) => !required2.includes(key) && !optional2.has(key)
+  );
+  if (extra.length > 0) {
+    throw new TypeError(`${path} contains missing or unsupported fields.`);
+  }
+  const doctype = oneOf(
+    root.doctype,
+    BUY_CAPTURE_DOCTYPE,
+    `${path}.doctype`
+  );
+  const document = {
+    doctype,
+    name: nonEmpty(root.name, `${path}.name`),
+    modified: frappeDatetime(root.modified, `${path}.modified`),
+    ...root.docstatus === void 0 ? {} : {
+      docstatus: parseDocstatus(root.docstatus, `${path}.docstatus`)
+    },
+    ...root.status === void 0 ? {} : { status: nonEmpty(root.status, `${path}.status`) },
+    sourceCategory: nonEmpty(
+      root.sourceCategory,
+      `${path}.sourceCategory`
+    ),
+    fields: parseClosedWireFields(
+      root.fields,
+      BUY_DOCTYPE_FIELD_SPECS[doctype],
+      `${path}.fields`
+    ),
+    ...root.children === void 0 ? {} : {
+      children: parseClosedWireChildren(
+        doctype,
+        root.children,
+        `${path}.children`
+      )
+    },
+    fingerprint: fingerprint(root.fingerprint, `${path}.fingerprint`)
+  };
+  if (document.sourceCategory !== BUY_DOCTYPE_SOURCE_CATEGORY[doctype]) {
+    throw new TypeError(
+      `${path}.sourceCategory must match the closed DocType; a generic document cannot masquerade as a price.`
+    );
+  }
+  const { fingerprint: _ignored, ...identity } = document;
+  const expectedFingerprint = await sha256FingerprintOfUtf8(
+    canonicalJson2(identity, `${path} identity`)
+  );
+  if (document.fingerprint !== expectedFingerprint) {
+    throw new TypeError(
+      `${path}.fingerprint must be SHA-256 of the document projection without fingerprint.`
+    );
+  }
+  return document;
+}
+function parseDocstatus(value, path) {
+  if (value !== 0 && value !== 1 && value !== 2) {
+    throw new TypeError(`${path} must be 0, 1, or 2.`);
+  }
+  return value;
+}
+function asRecord(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new BuyCaptureError(
+      "BUY_CAPTURE_INVALID_INPUT",
+      `${name} must be an object.`,
+      { recovery: "Pass a JSON object with exact keys." }
+    );
+  }
+  return value;
+}
+
+// src/tools/buy.ts
+var buyTools = [
+  {
+    name: "erpnext_buy_capture",
+    annotations: { readOnlyHint: true },
+    description: "Read-only bounded capture of exact ERPNext commercial documents (Item, BOM, Item Price, Supplier Quotation, Supplier, Price List, UOM, Currency Exchange). Two skipCache reads must agree on modified and the closed projection fingerprint. Returns canonical JSON + SHA-256; does not store CAS, create BOM/RFQ/PO, compute a cost total, or qualify a live ERP. Not a registered purchase capability.",
+    category: "buy",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["documents"],
+      properties: {
+        documents: {
+          type: "array",
+          minItems: 1,
+          maxItems: BUY_CAPTURE_MAX_DOCUMENTS,
+          description: "Exact document references. Do not pass sourceInstance, URL, credentials, capturedAt, or a caller digest.",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["doctype", "name"],
+            properties: {
+              doctype: {
+                type: "string",
+                enum: [...BUY_CAPTURE_DOCTYPE],
+                description: "Closed Buy capture DocType"
+              },
+              name: {
+                type: "string",
+                minLength: 1,
+                maxLength: 140,
+                description: "Exact ERP document name"
+              },
+              expectedModified: {
+                type: "string",
+                description: "Optional exact Frappe modified timestamp to match"
+              }
+            }
+          }
+        }
+      }
+    },
+    handler: async (input, ctx) => {
+      return await runBuyCapture(input, { client: ctx.client });
+    }
+  }
+];
+
 // src/tools/mod.ts
 var toolsByCategory = {
   sales: salesTools,
@@ -57452,7 +58825,8 @@ var toolsByCategory = {
   operations: operationsTools,
   setup: setupTools,
   analytics: analyticsTools,
-  kanban: kanbanTools
+  kanban: kanbanTools,
+  buy: buyTools
 };
 var allTools = [
   ...salesTools,
@@ -57468,7 +58842,8 @@ var allTools = [
   ...operationsTools,
   ...setupTools,
   ...analyticsTools,
-  ...kanbanTools
+  ...kanbanTools,
+  ...buyTools
 ];
 function getToolsByCategory(category) {
   return toolsByCategory[category] ?? [];
@@ -58846,7 +60221,8 @@ var UI_VIEWERS = [
   "chart-viewer",
   "kpi-viewer",
   "funnel-viewer",
-  "kanban-viewer"
+  "kanban-viewer",
+  "buy-evidence-viewer"
 ];
 var VIEWER_RESOURCE_META = {
   ui: {
@@ -58860,6 +60236,110 @@ function withViewerResourceMeta(resource) {
   return { ...resource, _meta: VIEWER_RESOURCE_META };
 }
 
+// src/buy/manifest.ts
+var VIEW_APP_MANIFEST_SCHEMA = "io.casys.mcp.view-app-manifest/1.0";
+var VIEWER_SESSION_APPLY_ACTION = "viewer.session.apply";
+var BUY_VIEW_APP_MANIFEST = {
+  schemaVersion: VIEW_APP_MANIFEST_SCHEMA,
+  app: {
+    id: BUY_VIEW_APP_ID,
+    title: BUY_VIEW_APP_TITLE,
+    version: BUY_VIEW_APP_VERSION
+  },
+  resources: [{
+    uri: BUY_EVIDENCE_VIEWER_URI,
+    ownership: "whole-view",
+    resultSchemas: [BUY_RECORDED_RESULT_SCHEMA],
+    acceptedActions: [VIEWER_SESSION_APPLY_ACTION],
+    sessionSchemas: [BUY_RECORDED_SESSION_SCHEMA]
+  }]
+};
+var BUY_VIEW_APP_MANIFEST_JSON = `${JSON.stringify(BUY_VIEW_APP_MANIFEST)}
+`;
+function parseBuyViewAppManifest(value) {
+  const root = exactRecord(
+    value,
+    ["schemaVersion", "app", "resources"],
+    "Buy View App manifest"
+  );
+  literal2(
+    root.schemaVersion,
+    VIEW_APP_MANIFEST_SCHEMA,
+    "Buy View App manifest.schemaVersion"
+  );
+  const app = exactRecord(
+    root.app,
+    ["id", "title", "version"],
+    "Buy View App manifest.app"
+  );
+  literal2(app.id, BUY_VIEW_APP_ID, "Buy View App manifest.app.id");
+  literal2(app.title, BUY_VIEW_APP_TITLE, "Buy View App manifest.app.title");
+  literal2(
+    app.version,
+    BUY_VIEW_APP_VERSION,
+    "Buy View App manifest.app.version"
+  );
+  const resources = denseArray(
+    root.resources,
+    "Buy View App manifest.resources"
+  );
+  if (resources.length !== 1) {
+    throw new TypeError(
+      "Buy View App manifest.resources must contain exactly one whole view."
+    );
+  }
+  const resource = exactRecord(
+    resources[0],
+    [
+      "uri",
+      "ownership",
+      "resultSchemas",
+      "acceptedActions",
+      "sessionSchemas"
+    ],
+    "Buy View App manifest.resources[0]"
+  );
+  literal2(
+    resource.uri,
+    BUY_EVIDENCE_VIEWER_URI,
+    "Buy View App manifest.resources[0].uri"
+  );
+  literal2(
+    resource.ownership,
+    "whole-view",
+    "Buy View App manifest.resources[0].ownership"
+  );
+  const resultSchemas = denseArray(
+    resource.resultSchemas,
+    "Buy View App manifest.resources[0].resultSchemas"
+  );
+  if (resultSchemas.length !== 1 || resultSchemas[0] !== BUY_RECORDED_RESULT_SCHEMA) {
+    throw new TypeError(
+      "Buy View App manifest result schemas must be io.casys.mcp-erpnext.buy-recorded-result/1.0 exactly."
+    );
+  }
+  const acceptedActions = denseArray(
+    resource.acceptedActions,
+    "Buy View App manifest.resources[0].acceptedActions"
+  );
+  if (acceptedActions.length !== 1 || acceptedActions[0] !== VIEWER_SESSION_APPLY_ACTION) {
+    throw new TypeError(
+      "Buy View App manifest must accept viewer.session.apply exactly."
+    );
+  }
+  const sessionSchemas = denseArray(
+    resource.sessionSchemas,
+    "Buy View App manifest.resources[0].sessionSchemas"
+  );
+  if (sessionSchemas.length !== 1 || sessionSchemas[0] !== BUY_RECORDED_SESSION_SCHEMA) {
+    throw new TypeError(
+      "Buy View App manifest must bind buy-recorded-session/1.0 exactly."
+    );
+  }
+  return BUY_VIEW_APP_MANIFEST;
+}
+parseBuyViewAppManifest(BUY_VIEW_APP_MANIFEST);
+
 // src/ui/viewer-resource-paths.ts
 function fileUrlToPath2(url2) {
   const decodedPath = decodeURIComponent(url2.pathname);
@@ -59091,6 +60571,28 @@ function loadMrtrConfig() {
 
 // server.ts
 var DEFAULT_HTTP_PORT = 3012;
+function registerBuyViewAppManifest(server) {
+  const bytes = new TextEncoder().encode(BUY_VIEW_APP_MANIFEST_JSON);
+  server.registerResource(
+    {
+      uri: BUY_VIEW_APP_MANIFEST_URI,
+      name: "ERPNext Buy Evidence App manifest",
+      description: `Exact ${BUY_VIEW_APP_MANIFEST.app.id}@${BUY_VIEW_APP_MANIFEST.app.version} whole-view and recorded-session contract.`,
+      mimeType: "application/json",
+      size: bytes.byteLength
+    },
+    (requested) => {
+      if (requested.toString() !== BUY_VIEW_APP_MANIFEST_URI) {
+        throw new Error("Requested URI does not match the Buy App manifest.");
+      }
+      return {
+        uri: BUY_VIEW_APP_MANIFEST_URI,
+        mimeType: "application/json",
+        text: BUY_VIEW_APP_MANIFEST_JSON
+      };
+    }
+  );
+}
 async function main() {
   const args = getArgs3();
   if (args.includes("--inspect")) {
@@ -59120,7 +60622,7 @@ async function main() {
   );
   const server = new McpApp({
     name: "mcp-erpnext",
-    version: "3.1.0-beta.7",
+    version: "3.1.0-beta.9",
     transport: "stateless",
     cache: {
       ttlMs: 36e5,
@@ -59141,6 +60643,7 @@ async function main() {
   const mcpTools = toolsClient.toMCPFormat();
   const handlers = toolsClient.buildHandlersMap();
   server.registerTools(mcpTools, handlers);
+  registerBuyViewAppManifest(server);
   for (const viewerName of UI_VIEWERS) {
     const distPath = resolveViewerDistPath2(
       import.meta.url,