@paprflare/tally 0.1.0

package/dist/index.cjs

@@ -0,0 +1,788 @@
+'use strict';
+
+var zod = require('zod');
+var fastXmlParser = require('fast-xml-parser');
+
+// src/types/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function tallyError(code, message, extra) {
+  return { code, message, ...extra };
+}
+function unwrap(result) {
+  if (result.ok) return result.value;
+  const err2 = result.error;
+  const e = new Error(`[${err2.code}] ${err2.message}`);
+  e.cause = err2.cause ?? err2;
+  throw e;
+}
+var gstinSchema = zod.z.string().regex(
+  /^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}Z[0-9A-Z]{1}$/,
+  "Invalid GSTIN format"
+).optional();
+var LedgerInputSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  /** Tally group name, e.g. "Sundry Debtors", "Sundry Creditors", "Bank Accounts" */
+  group: zod.z.string().min(1),
+  gstin: gstinSchema,
+  openingBalance: zod.z.number().optional(),
+  /** "Debit" | "Credit" — required by Tally when openingBalance is set */
+  openingBalanceType: zod.z.enum(["Debit", "Credit"]).optional(),
+  address: zod.z.array(zod.z.string()).optional(),
+  state: zod.z.string().optional(),
+  pincode: zod.z.string().optional(),
+  email: zod.z.string().email().optional(),
+  phone: zod.z.string().optional()
+});
+var LedgerSchema = zod.z.object({
+  name: zod.z.string(),
+  guid: zod.z.string(),
+  group: zod.z.string(),
+  gstin: zod.z.string().optional(),
+  /** Signed: positive = debit balance, negative = credit balance (normalized
+   * at the parser layer — Tally's raw XML encodes sign via a separate
+   * DR/CR-style attribute, never as a literal minus on the export). */
+  closingBalance: zod.z.number().optional(),
+  state: zod.z.string().optional()
+});
+var StockItemSchema = zod.z.object({
+  name: zod.z.string(),
+  guid: zod.z.string(),
+  unit: zod.z.string(),
+  closingQty: zod.z.number().optional(),
+  closingValue: zod.z.number().optional(),
+  /** HSN/SAC code, when GST is enabled in the company */
+  hsnCode: zod.z.string().optional(),
+  gstRate: zod.z.number().optional()
+});
+var StockItemInputSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  /** Tally stock group name, e.g. "Primary" */
+  group: zod.z.string().default("Primary"),
+  unit: zod.z.string().min(1),
+  hsnCode: zod.z.string().optional(),
+  gstRate: zod.z.number().optional(),
+  openingQty: zod.z.number().optional(),
+  openingRate: zod.z.number().optional()
+});
+var CompanySchema = zod.z.object({
+  name: zod.z.string(),
+  guid: zod.z.string(),
+  startingFrom: zod.z.string().optional(),
+  endingAt: zod.z.string().optional()
+});
+var OutstandingEntrySchema = zod.z.object({
+  ledgerName: zod.z.string(),
+  voucherNumber: zod.z.string(),
+  voucherDate: zod.z.coerce.date(),
+  dueDate: zod.z.coerce.date().optional(),
+  /** Positive = they owe you, negative = you owe them */
+  pendingAmount: zod.z.number(),
+  overdueDays: zod.z.number().optional()
+});
+var baseVoucherFields = {
+  date: zod.z.coerce.date(),
+  narration: zod.z.string().optional(),
+  /** Tally auto-numbers if omitted; only set this if you're syncing from an
+   * external system that owns numbering (e.g. an e-invoice generator). */
+  voucherNumber: zod.z.string().optional(),
+  reference: zod.z.string().optional()
+};
+var lineItemSchema = zod.z.object({
+  /** Must match an existing Tally stock item name exactly (case-sensitive) */
+  stockItem: zod.z.string().min(1),
+  quantity: zod.z.number().positive(),
+  rate: zod.z.number().nonnegative(),
+  /** Defaults to quantity * rate; pass explicitly to override rounding */
+  amount: zod.z.number().optional()
+});
+var taxLedgerSchema = zod.z.object({
+  /** e.g. "Output CGST", "Output SGST", "Output IGST" — must exist in Tally */
+  ledger: zod.z.string().min(1),
+  amount: zod.z.number()
+});
+var SalesVoucherInputSchema = zod.z.object({
+  voucherType: zod.z.literal("Sales"),
+  ...baseVoucherFields,
+  /** Sundry Debtor ledger name being billed */
+  party: zod.z.string().min(1),
+  items: zod.z.array(lineItemSchema).min(1),
+  /** Sales/revenue ledger to credit; defaults to "Sales" */
+  salesLedger: zod.z.string().default("Sales"),
+  taxes: zod.z.array(taxLedgerSchema).optional()
+});
+var PurchaseVoucherInputSchema = zod.z.object({
+  voucherType: zod.z.literal("Purchase"),
+  ...baseVoucherFields,
+  /** Sundry Creditor ledger name being paid */
+  party: zod.z.string().min(1),
+  items: zod.z.array(lineItemSchema).min(1),
+  purchaseLedger: zod.z.string().default("Purchase"),
+  taxes: zod.z.array(taxLedgerSchema).optional()
+});
+var PaymentVoucherInputSchema = zod.z.object({
+  voucherType: zod.z.literal("Payment"),
+  ...baseVoucherFields,
+  /** Ledger being debited — typically an expense or a creditor being paid off */
+  debitLedger: zod.z.string().min(1),
+  /** Bank or Cash ledger being credited */
+  creditLedger: zod.z.string().min(1),
+  amount: zod.z.number().positive()
+});
+var ReceiptVoucherInputSchema = zod.z.object({
+  voucherType: zod.z.literal("Receipt"),
+  ...baseVoucherFields,
+  /** Bank or Cash ledger being debited */
+  debitLedger: zod.z.string().min(1),
+  /** Ledger being credited — typically the debtor paying you */
+  creditLedger: zod.z.string().min(1),
+  amount: zod.z.number().positive()
+});
+var journalEntrySchema = zod.z.object({
+  ledger: zod.z.string().min(1),
+  type: zod.z.enum(["Debit", "Credit"]),
+  amount: zod.z.number().positive()
+});
+var JournalVoucherInputSchema = zod.z.object({
+  voucherType: zod.z.literal("Journal"),
+  ...baseVoucherFields,
+  entries: zod.z.array(journalEntrySchema).min(2)
+}).refine(
+  (v) => {
+    const debit = v.entries.filter((e) => e.type === "Debit").reduce((s, e) => s + e.amount, 0);
+    const credit = v.entries.filter((e) => e.type === "Credit").reduce((s, e) => s + e.amount, 0);
+    return Math.abs(debit - credit) < 5e-3;
+  },
+  { message: "Journal voucher debit and credit totals must balance" }
+);
+var VoucherInputSchema = zod.z.discriminatedUnion("voucherType", [
+  SalesVoucherInputSchema,
+  PurchaseVoucherInputSchema,
+  PaymentVoucherInputSchema,
+  ReceiptVoucherInputSchema
+  // Journal isn't included directly here because z.discriminatedUnion can't
+  // take a refined (ZodEffects) member — see VoucherInput union type below
+  // and validateVoucherInput() in client.ts, which validates Journal
+  // separately via JournalVoucherInputSchema.
+]);
+function assertNever(x) {
+  throw new Error(`Unhandled voucher type: ${JSON.stringify(x)}`);
+}
+
+// src/xml/envelope.ts
+var EMPTY_MARKER = "&#4;";
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatTallyDate(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}${m}${d}`;
+}
+function formatSignedAmount(amount, isDebit) {
+  const magnitude = Math.abs(amount).toFixed(2);
+  return isDebit ? magnitude : `-${magnitude}`;
+}
+function buildEnvelope(options, bodyXml) {
+  const staticVars = {
+    ...options.company ? { SVCURRENTCOMPANY: options.company } : {},
+    ...options.staticVariables ?? {}
+  };
+  const staticVarsXml = Object.entries(staticVars).map(([key, value]) => `<${key}>${escapeXml(value)}</${key}>`).join("");
+  const isImport = options.requestType === "Import Data";
+  const sectionTag = isImport ? "IMPORTDATA" : "EXPORTDATA";
+  return `<ENVELOPE><HEADER><TALLYREQUEST>${escapeXml(options.requestType)}</TALLYREQUEST></HEADER><BODY><${sectionTag}><REQUESTDESC><REPORTNAME>${escapeXml(options.id)}</REPORTNAME>` + (staticVarsXml ? `<STATICVARIABLES>${staticVarsXml}</STATICVARIABLES>` : "") + `</REQUESTDESC>` + (isImport && bodyXml ? `<REQUESTDATA>${bodyXml}</REQUESTDATA>` : "") + `</${sectionTag}></BODY></ENVELOPE>`;
+}
+
+// src/xml/builders/ledger.ts
+function buildCreateLedgerXml(input) {
+  const addressXml = (input.address ?? []).map((line) => `<ADDRESS>${escapeXml(line)}</ADDRESS>`).join("");
+  const openingBalanceXml = input.openingBalance != null ? `<OPENINGBALANCE>${input.openingBalanceType === "Credit" ? "-" : ""}${Math.abs(input.openingBalance).toFixed(2)}</OPENINGBALANCE>` : "";
+  return `<TALLYMESSAGE xmlns:UDF="TallyUDF"><LEDGER NAME="${escapeXml(input.name)}" ACTION="Create"><NAME>${escapeXml(input.name)}</NAME><PARENT>${escapeXml(input.group)}</PARENT>` + (input.gstin ? `<GSTIN>${escapeXml(input.gstin)}</GSTIN>` : "") + (input.state ? `<LEDSTATENAME>${escapeXml(input.state)}</LEDSTATENAME>` : "") + (input.pincode ? `<PINCODE>${escapeXml(input.pincode)}</PINCODE>` : "") + openingBalanceXml + addressXml + (input.email ? `<EMAIL>${escapeXml(input.email)}</EMAIL>` : "") + (input.phone ? `<LEDGERPHONE>${escapeXml(input.phone)}</LEDGERPHONE>` : "") + `</LEDGER></TALLYMESSAGE>`;
+}
+function buildCreateStockItemXml(input) {
+  const openingXml = input.openingQty != null ? `<OPENINGBALANCE>${input.openingQty} ${escapeXml(input.unit)}</OPENINGBALANCE>` + (input.openingRate != null ? `<OPENINGRATE>${input.openingRate.toFixed(2)}/${escapeXml(input.unit)}</OPENINGRATE><OPENINGVALUE>${(input.openingQty * input.openingRate).toFixed(2)}</OPENINGVALUE>` : "") : "";
+  return `<TALLYMESSAGE xmlns:UDF="TallyUDF"><STOCKITEM NAME="${escapeXml(input.name)}" ACTION="Create"><NAME>${escapeXml(input.name)}</NAME><PARENT>${escapeXml(input.group)}</PARENT><BASEUNITS>${escapeXml(input.unit)}</BASEUNITS>` + (input.hsnCode ? `<HSNCODE>${escapeXml(input.hsnCode)}</HSNCODE>` : "") + (input.gstRate != null ? `<GSTRATE>${input.gstRate}</GSTRATE>` : "") + openingXml + `</STOCKITEM></TALLYMESSAGE>`;
+}
+
+// src/xml/builders/voucher.ts
+function lineItemAmount(item) {
+  return item.amount ?? item.quantity * item.rate;
+}
+function buildInventoryEntryXml(item, isDebit) {
+  const qty = `${item.quantity}`;
+  return `<ALLINVENTORYENTRIES.LIST><STOCKITEMNAME>${escapeXml(item.stockItem)}</STOCKITEMNAME><ISDEEMEDPOSITIVE>${isDebit ? "Yes" : "No"}</ISDEEMEDPOSITIVE><RATE>${item.rate.toFixed(2)}</RATE><AMOUNT>${formatSignedAmount(lineItemAmount(item), isDebit)}</AMOUNT><ACTUALQTY>${qty}</ACTUALQTY><BILLEDQTY>${qty}</BILLEDQTY></ALLINVENTORYENTRIES.LIST>`;
+}
+function buildLedgerEntryXml(ledgerName, amount, isDebit) {
+  return `<ALLLEDGERENTRIES.LIST><LEDGERNAME>${escapeXml(ledgerName)}</LEDGERNAME><ISDEEMEDPOSITIVE>${isDebit ? "Yes" : "No"}</ISDEEMEDPOSITIVE><AMOUNT>${formatSignedAmount(amount, isDebit)}</AMOUNT></ALLLEDGERENTRIES.LIST>`;
+}
+function buildSalesXml(input) {
+  const itemsTotal = input.items.reduce(
+    (sum, item) => sum + lineItemAmount(item),
+    0
+  );
+  const taxTotal = (input.taxes ?? []).reduce((sum, t) => sum + t.amount, 0);
+  const partyTotal = itemsTotal + taxTotal;
+  const partyEntry = buildLedgerEntryXml(input.party, partyTotal, true);
+  const salesEntry = `<ALLLEDGERENTRIES.LIST><LEDGERNAME>${escapeXml(input.salesLedger)}</LEDGERNAME><ISDEEMEDPOSITIVE>No</ISDEEMEDPOSITIVE><AMOUNT>${formatSignedAmount(itemsTotal, false)}</AMOUNT>` + input.items.map((item) => buildInventoryEntryXml(item, false)).join("") + `</ALLLEDGERENTRIES.LIST>`;
+  const taxEntries = (input.taxes ?? []).map((t) => buildLedgerEntryXml(t.ledger, t.amount, false)).join("");
+  return buildVoucherEnvelope({
+    voucherTypeName: "Sales",
+    date: input.date,
+    narration: input.narration,
+    voucherNumber: input.voucherNumber,
+    reference: input.reference,
+    isInvoice: true,
+    partyName: input.party,
+    body: partyEntry + salesEntry + taxEntries
+  });
+}
+function buildPurchaseXml(input) {
+  const itemsTotal = input.items.reduce(
+    (sum, item) => sum + lineItemAmount(item),
+    0
+  );
+  const taxTotal = (input.taxes ?? []).reduce((sum, t) => sum + t.amount, 0);
+  const partyTotal = itemsTotal + taxTotal;
+  const partyEntry = buildLedgerEntryXml(input.party, partyTotal, false);
+  const purchaseEntry = `<ALLLEDGERENTRIES.LIST><LEDGERNAME>${escapeXml(input.purchaseLedger)}</LEDGERNAME><ISDEEMEDPOSITIVE>Yes</ISDEEMEDPOSITIVE><AMOUNT>${formatSignedAmount(itemsTotal, true)}</AMOUNT>` + input.items.map((item) => buildInventoryEntryXml(item, true)).join("") + `</ALLLEDGERENTRIES.LIST>`;
+  const taxEntries = (input.taxes ?? []).map((t) => buildLedgerEntryXml(t.ledger, t.amount, true)).join("");
+  return buildVoucherEnvelope({
+    voucherTypeName: "Purchase",
+    date: input.date,
+    narration: input.narration,
+    voucherNumber: input.voucherNumber,
+    reference: input.reference,
+    isInvoice: true,
+    partyName: input.party,
+    body: partyEntry + purchaseEntry + taxEntries
+  });
+}
+function buildPaymentXml(input) {
+  const body = buildLedgerEntryXml(input.debitLedger, input.amount, true) + buildLedgerEntryXml(input.creditLedger, input.amount, false);
+  return buildVoucherEnvelope({
+    voucherTypeName: "Payment",
+    date: input.date,
+    narration: input.narration,
+    voucherNumber: input.voucherNumber,
+    reference: input.reference,
+    isInvoice: false,
+    body
+  });
+}
+function buildReceiptXml(input) {
+  const body = buildLedgerEntryXml(input.debitLedger, input.amount, true) + buildLedgerEntryXml(input.creditLedger, input.amount, false);
+  return buildVoucherEnvelope({
+    voucherTypeName: "Receipt",
+    date: input.date,
+    narration: input.narration,
+    voucherNumber: input.voucherNumber,
+    reference: input.reference,
+    isInvoice: false,
+    body
+  });
+}
+function buildJournalXml(input) {
+  const body = input.entries.map((e) => buildLedgerEntryXml(e.ledger, e.amount, e.type === "Debit")).join("");
+  return buildVoucherEnvelope({
+    voucherTypeName: "Journal",
+    date: input.date,
+    narration: input.narration,
+    voucherNumber: input.voucherNumber,
+    reference: input.reference,
+    isInvoice: false,
+    body
+  });
+}
+function buildVoucherEnvelope(opts) {
+  return `<TALLYMESSAGE xmlns:UDF="TallyUDF"><VOUCHER VCHTYPE="${escapeXml(opts.voucherTypeName)}" ACTION="Create"` + (opts.isInvoice ? ` ISINVOICE="Yes"` : "") + `><DATE>${formatTallyDate(opts.date)}</DATE><VOUCHERTYPENAME>${escapeXml(opts.voucherTypeName)}</VOUCHERTYPENAME>` + (opts.voucherNumber ? `<VOUCHERNUMBER>${escapeXml(opts.voucherNumber)}</VOUCHERNUMBER>` : "") + (opts.partyName ? `<PARTYLEDGERNAME>${escapeXml(opts.partyName)}</PARTYLEDGERNAME>` : "") + (opts.reference ? `<REFERENCE>${escapeXml(opts.reference)}</REFERENCE>` : "") + (opts.narration ? `<NARRATION>${escapeXml(opts.narration)}</NARRATION>` : "") + opts.body + `</VOUCHER></TALLYMESSAGE>`;
+}
+function buildVoucherXml(input) {
+  switch (input.voucherType) {
+    case "Sales":
+      return buildSalesXml(input);
+    case "Purchase":
+      return buildPurchaseXml(input);
+    case "Payment":
+      return buildPaymentXml(input);
+    case "Receipt":
+      return buildReceiptXml(input);
+    case "Journal":
+      return buildJournalXml(input);
+    default:
+      return assertNever(input);
+  }
+}
+
+// src/xml/builders/collection.ts
+function buildGetCompaniesXml() {
+  return buildEnvelope({ requestType: "Export Data", id: "List of Companies" });
+}
+function buildGetLedgersXml(company) {
+  return buildEnvelope({
+    requestType: "Export Data",
+    id: "List of Ledgers",
+    company,
+    staticVariables: { SVEXPORTFORMAT: "$$SysName:XML" }
+  });
+}
+function buildGetStockItemsXml(company) {
+  return buildEnvelope({
+    requestType: "Export Data",
+    id: "List of Stock Items",
+    company,
+    staticVariables: { SVEXPORTFORMAT: "$$SysName:XML" }
+  });
+}
+function buildGetOutstandingXml(company) {
+  return buildEnvelope({
+    requestType: "Export Data",
+    id: "Bills Receivable",
+    // swap to "Bills Payable" for AP outstanding
+    company,
+    staticVariables: { SVEXPORTFORMAT: "$$SysName:XML" }
+  });
+}
+function buildPingXml() {
+  return buildGetCompaniesXml();
+}
+var parser = new fastXmlParser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  // Tally repeats sibling tags (LINEERROR, etc.) without warning when there's
+  // more than one — force these into arrays unconditionally so downstream
+  // code never has to special-case "string vs array of one".
+  isArray: (tagName) => ["LINEERROR", "TALLYMESSAGE"].includes(tagName)
+  // Tally emits &#4; as an empty-but-present marker on some master fields;
+  // fast-xml-parser decodes numeric entities by default, which turns it into
+  // an unprintable control character rather than throwing — we normalize it
+  // back to an empty string post-parse instead of fighting the entity
+  // decoder.
+});
+function parseImportResponse(rawXml) {
+  let parsed;
+  try {
+    parsed = parser.parse(rawXml);
+  } catch (cause) {
+    return err(
+      tallyError("PARSE_ERROR", "Could not parse Tally's response as XML", {
+        responseXml: rawXml,
+        cause
+      })
+    );
+  }
+  const body = parsed.ENVELOPE?.BODY;
+  const lineErrors = body?.LINEERROR;
+  if (lineErrors && lineErrors.length > 0) {
+    return err(
+      tallyError("TALLY_REJECTED", "Tally rejected the request", {
+        tallyMessage: lineErrors.join("; "),
+        responseXml: rawXml
+      })
+    );
+  }
+  const result = body?.DATA?.IMPORTRESULT;
+  const created = Number(result?.CREATED ?? 0);
+  const altered = Number(result?.ALTERED ?? 0);
+  const errors = Number(result?.ERRORS ?? 0);
+  if (errors > 0) {
+    return err(
+      tallyError(
+        "TALLY_REJECTED",
+        `Tally reported ${errors} error(s) during import`,
+        {
+          responseXml: rawXml
+        }
+      )
+    );
+  }
+  if (created === 0 && altered === 0) {
+    return err(
+      tallyError(
+        "PARSE_ERROR",
+        "Tally returned no CREATED/ALTERED count and no error \u2014 unexpected response shape",
+        {
+          responseXml: rawXml
+        }
+      )
+    );
+  }
+  return ok({
+    voucherNumber: String(result?.LASTVCHID ?? ""),
+    guid: String(result?.LASTMID ?? ""),
+    alteredOn: /* @__PURE__ */ new Date()
+  });
+}
+var COLLECTION_TAGS = ["LEDGER", "STOCKITEM", "COMPANY", "BILLOUTSTANDING"];
+var parser2 = new fastXmlParser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  isArray: (tagName) => COLLECTION_TAGS.includes(tagName)
+});
+function parseTallyNumber(raw) {
+  if (raw == null) return void 0;
+  const cleaned = String(raw).replace(/\s*(Cr|Dr)\s*$/i, "").replace(/,/g, "").trim();
+  const n = Number(cleaned);
+  return Number.isFinite(n) ? n : void 0;
+}
+function safeParse(rawXml, extract) {
+  try {
+    const parsed = parser2.parse(rawXml);
+    return ok(extract(parsed));
+  } catch (cause) {
+    return err(
+      tallyError("PARSE_ERROR", "Could not parse Tally's collection response", {
+        responseXml: rawXml,
+        cause
+      })
+    );
+  }
+}
+function findCollectionRoot(parsed) {
+  return parsed?.ENVELOPE?.BODY?.DATA?.COLLECTION ?? parsed?.ENVELOPE?.BODY?.DATA ?? {};
+}
+function parseLedgerCollection(rawXml) {
+  return safeParse(rawXml, (parsed) => {
+    const root = findCollectionRoot(parsed);
+    const ledgers = root.LEDGER ?? [];
+    return ledgers.map((l) => ({
+      name: String(l["@_NAME"] ?? l.NAME ?? ""),
+      guid: String(l.GUID ?? ""),
+      group: String(l.PARENT ?? ""),
+      gstin: l.GSTIN ? String(l.GSTIN) : void 0,
+      closingBalance: parseTallyNumber(l.CLOSINGBALANCE),
+      state: l.LEDSTATENAME ? String(l.LEDSTATENAME) : void 0
+    }));
+  });
+}
+function parseStockItemCollection(rawXml) {
+  return safeParse(rawXml, (parsed) => {
+    const root = findCollectionRoot(parsed);
+    const items = root.STOCKITEM ?? [];
+    return items.map((s) => ({
+      name: String(s["@_NAME"] ?? s.NAME ?? ""),
+      guid: String(s.GUID ?? ""),
+      unit: String(s.BASEUNITS ?? ""),
+      closingQty: parseTallyNumber(s.CLOSINGBALANCE),
+      closingValue: parseTallyNumber(s.CLOSINGVALUE),
+      hsnCode: s.HSNCODE ? String(s.HSNCODE) : void 0,
+      gstRate: parseTallyNumber(s.GSTRATE)
+    }));
+  });
+}
+function parseCompanyCollection(rawXml) {
+  return safeParse(rawXml, (parsed) => {
+    const root = findCollectionRoot(parsed);
+    const companies = root.COMPANY ?? [];
+    return companies.map((c) => ({
+      name: String(c["@_NAME"] ?? c.NAME ?? ""),
+      guid: String(c.GUID ?? ""),
+      startingFrom: c.STARTINGFROM ? String(c.STARTINGFROM) : void 0,
+      endingAt: c.ENDINGAT ? String(c.ENDINGAT) : void 0
+    }));
+  });
+}
+function parseOutstandingCollection(rawXml) {
+  return safeParse(rawXml, (parsed) => {
+    const root = findCollectionRoot(parsed);
+    const bills = root.BILLOUTSTANDING ?? [];
+    return bills.map((b) => ({
+      ledgerName: String(b.LEDGERNAME ?? ""),
+      voucherNumber: String(b.VOUCHERNUMBER ?? ""),
+      voucherDate: new Date(String(b.VOUCHERDATE ?? "")),
+      dueDate: b.DUEDATE ? new Date(String(b.DUEDATE)) : void 0,
+      pendingAmount: parseTallyNumber(b.PENDINGAMOUNT) ?? 0,
+      overdueDays: b.OVERDUEDAYS != null ? Number(b.OVERDUEDAYS) : void 0
+    }));
+  });
+}
+
+// src/tally/transport.ts
+var TallyTransport = class {
+  constructor(config) {
+    this.config = config;
+    this.retries = config.retries ?? 1;
+  }
+  config;
+  retries;
+  async send(requestXml) {
+    let lastError;
+    const protocol = this.config.https ? "https" : "http";
+    const url = `${protocol}://${this.config.host}:${this.config.port}/`;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "text/xml"
+          },
+          body: requestXml,
+          signal: AbortSignal.timeout(this.config.timeoutMs ?? 15e3)
+        });
+        const responseText = await response.text();
+        return ok(responseText);
+      } catch (cause) {
+        if (cause instanceof Error) {
+          if (cause.name === "TimeoutError" || cause.name === "AbortError") {
+            lastError = tallyError(
+              "TIMEOUT",
+              `Request to Tally timed out after ${this.config.timeoutMs ?? 15e3}ms`,
+              {
+                requestXml,
+                cause
+              }
+            );
+            continue;
+          }
+          if (cause instanceof TypeError) {
+            lastError = tallyError(
+              "NETWORK_ERROR",
+              `Could not reach Tally at ${this.config.host}:${this.config.port}`,
+              {
+                requestXml,
+                cause
+              }
+            );
+            continue;
+          }
+        }
+        lastError = tallyError(
+          "UNKNOWN",
+          "Unexpected error sending request to Tally",
+          {
+            requestXml,
+            cause
+          }
+        );
+        break;
+      }
+    }
+    return err(
+      lastError ?? tallyError("UNKNOWN", "Request failed with no captured error")
+    );
+  }
+};
+
+// src/tally/client.ts
+function validateVoucherInput(input) {
+  const schema = {
+    Sales: SalesVoucherInputSchema,
+    Purchase: PurchaseVoucherInputSchema,
+    Payment: PaymentVoucherInputSchema,
+    Receipt: ReceiptVoucherInputSchema,
+    Journal: JournalVoucherInputSchema
+  }[input.voucherType];
+  const parsed = schema.safeParse(input);
+  if (!parsed.success) {
+    return err(
+      tallyError(
+        "VALIDATION_ERROR",
+        `Invalid ${input.voucherType} voucher input`,
+        {
+          cause: parsed.error
+        }
+      )
+    );
+  }
+  return ok(parsed.data);
+}
+var Tally = class {
+  transport;
+  company;
+  constructor(config) {
+    this.transport = new TallyTransport(config);
+    this.company = config.company;
+  }
+  // ---- Connection -------------------------------------------------------
+  async ping() {
+    const result = await this.transport.send(buildPingXml());
+    if (!result.ok) return result;
+    if (!result.value.includes("<ENVELOPE>")) {
+      return err(
+        tallyError(
+          "PARSE_ERROR",
+          "Response did not look like a Tally ENVELOPE",
+          { responseXml: result.value }
+        )
+      );
+    }
+    return ok(true);
+  }
+  // ---- Reads --------------------------------------------------------------
+  async getCompanies() {
+    const res = await this.transport.send(buildGetCompaniesXml());
+    if (!res.ok) return res;
+    return parseCompanyCollection(res.value);
+  }
+  async getLedgers() {
+    const res = await this.transport.send(buildGetLedgersXml(this.company));
+    if (!res.ok) return res;
+    return parseLedgerCollection(res.value);
+  }
+  /** Alias matching the original product sketch's naming. */
+  async getCustomers() {
+    const res = await this.getLedgers();
+    if (!res.ok) return res;
+    return ok(res.value.filter((l) => l.group === "Sundry Debtors"));
+  }
+  async getStockItems() {
+    const res = await this.transport.send(buildGetStockItemsXml(this.company));
+    if (!res.ok) return res;
+    return parseStockItemCollection(res.value);
+  }
+  async getOutstanding() {
+    const res = await this.transport.send(buildGetOutstandingXml(this.company));
+    if (!res.ok) return res;
+    return parseOutstandingCollection(res.value);
+  }
+  // ---- Writes -------------------------------------------------------------
+  async createLedger(input) {
+    const parsed = LedgerInputSchema.safeParse(input);
+    if (!parsed.success) {
+      return err(
+        tallyError("VALIDATION_ERROR", "Invalid ledger input", {
+          cause: parsed.error
+        })
+      );
+    }
+    const xml = buildCreateLedgerXml(parsed.data);
+    const res = await this.transport.send(xml);
+    if (!res.ok) return res;
+    return parseImportResponse(res.value);
+  }
+  async createStockItem(input) {
+    const parsed = StockItemInputSchema.safeParse(input);
+    if (!parsed.success) {
+      return err(
+        tallyError("VALIDATION_ERROR", "Invalid stock item input", {
+          cause: parsed.error
+        })
+      );
+    }
+    const xml = buildCreateStockItemXml(parsed.data);
+    const res = await this.transport.send(xml);
+    if (!res.ok) return res;
+    return parseImportResponse(res.value);
+  }
+  async createVoucher(input) {
+    const validated = validateVoucherInput(input);
+    if (!validated.ok) return validated;
+    const xml = buildVoucherXml(validated.value);
+    const res = await this.transport.send(xml);
+    if (!res.ok) return res;
+    return parseImportResponse(res.value);
+  }
+  /**
+   * Convenience wrapper matching the original sketch's `createInvoice()`
+   * signature — expands into a full SalesVoucherInput (voucherType: "Sales")
+   * before going through the same validated path as createVoucher(). Kept
+   * separate from createVoucher() because "invoice" maps to a Sales voucher
+   * specifically, and spelling that out here means callers coming from
+   * other invoicing tools (Stripe, Zoho) don't need to know Tally's
+   * voucherType vocabulary at all.
+   */
+  async createInvoice(input) {
+    return this.createVoucher({
+      voucherType: "Sales",
+      date: input.date,
+      party: input.customer,
+      items: input.items,
+      salesLedger: input.salesLedger ?? "Sales",
+      taxes: input.taxes,
+      reference: input.reference,
+      narration: input.narration
+    });
+  }
+  // ---- AI agent integration ------------------------------------------------
+  /**
+   * Returns JSON-Schema-shaped tool definitions (derived from the same Zod
+   * schemas used for validation, so the agent-facing contract can never
+   * drift from what the SDK actually accepts) for OpenAI-style function
+   * calling, LangGraph, Mastra, or a hand-rolled MCP server. Each `handler`
+   * closes over `this`, so a caller can wire these straight into an agent
+   * framework's tool registry without writing adapter glue.
+   */
+  tools() {
+    return [
+      {
+        name: "getCustomers",
+        description: "List all Sundry Debtor ledgers (customers) in the active Tally company.",
+        parameters: zod.z.object({}),
+        handler: () => this.getCustomers()
+      },
+      {
+        name: "getOutstanding",
+        description: "Get outstanding (unpaid) receivable bills across all customers.",
+        parameters: zod.z.object({}),
+        handler: () => this.getOutstanding()
+      },
+      {
+        name: "createInvoice",
+        description: "Create a sales invoice for a customer with one or more line items.",
+        parameters: zod.z.object({
+          customer: zod.z.string(),
+          date: zod.z.coerce.date(),
+          items: zod.z.array(
+            zod.z.object({
+              stockItem: zod.z.string(),
+              quantity: zod.z.number(),
+              rate: zod.z.number()
+            })
+          )
+        }),
+        handler: (args) => this.createInvoice(args)
+      },
+      {
+        name: "createLedger",
+        description: "Create a new ledger account (e.g. a new customer or supplier) in Tally.",
+        parameters: LedgerInputSchema,
+        handler: (args) => this.createLedger(args)
+      }
+    ];
+  }
+};
+
+exports.CompanySchema = CompanySchema;
+exports.EMPTY_MARKER = EMPTY_MARKER;
+exports.JournalVoucherInputSchema = JournalVoucherInputSchema;
+exports.LedgerInputSchema = LedgerInputSchema;
+exports.LedgerSchema = LedgerSchema;
+exports.OutstandingEntrySchema = OutstandingEntrySchema;
+exports.PaymentVoucherInputSchema = PaymentVoucherInputSchema;
+exports.PurchaseVoucherInputSchema = PurchaseVoucherInputSchema;
+exports.ReceiptVoucherInputSchema = ReceiptVoucherInputSchema;
+exports.SalesVoucherInputSchema = SalesVoucherInputSchema;
+exports.StockItemInputSchema = StockItemInputSchema;
+exports.StockItemSchema = StockItemSchema;
+exports.Tally = Tally;
+exports.TallyTransport = TallyTransport;
+exports.VoucherInputSchema = VoucherInputSchema;
+exports.assertNever = assertNever;
+exports.buildCreateLedgerXml = buildCreateLedgerXml;
+exports.buildCreateStockItemXml = buildCreateStockItemXml;
+exports.buildEnvelope = buildEnvelope;
+exports.buildGetCompaniesXml = buildGetCompaniesXml;
+exports.buildGetLedgersXml = buildGetLedgersXml;
+exports.buildGetOutstandingXml = buildGetOutstandingXml;
+exports.buildGetStockItemsXml = buildGetStockItemsXml;
+exports.buildPingXml = buildPingXml;
+exports.buildVoucherXml = buildVoucherXml;
+exports.err = err;
+exports.escapeXml = escapeXml;
+exports.formatSignedAmount = formatSignedAmount;
+exports.formatTallyDate = formatTallyDate;
+exports.ok = ok;
+exports.parseCompanyCollection = parseCompanyCollection;
+exports.parseImportResponse = parseImportResponse;
+exports.parseLedgerCollection = parseLedgerCollection;
+exports.parseOutstandingCollection = parseOutstandingCollection;
+exports.parseStockItemCollection = parseStockItemCollection;
+exports.tallyError = tallyError;
+exports.unwrap = unwrap;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map