@diy-accounting-uk/diya-gl 1.2.64 → 1.2.66

package/dist/app/data/releases.json

@@ -1897,6 +1897,58 @@
           "scorecard": "101608 passed, 0 warnings, 0 failed"
         }
       }
+    },
+    {
+      "tag": "diya-gl-v1.2.64",
+      "date": "2026-10-29",
+      "formatVersion": "diya-gl/2",
+      "engineVersion": "1.2.64+abe8b184",
+      "taxDataHash": "51bdff60e993",
+      "reconciledCommit": "54e8731a91279975e61b1a232fbb67fda89515f0",
+      "templates": {
+        "bst": {
+          "hash": "0d003e10e00c",
+          "scorecard": "812 passed, 0 warnings, 0 failed"
+        },
+        "taxi": {
+          "hash": "1ff69654d64d",
+          "scorecard": "700 passed, 0 warnings, 0 failed"
+        },
+        "se": {
+          "hash": "064605ae76ed",
+          "scorecard": "8015 passed, 0 warnings, 0 failed"
+        },
+        "ltd": {
+          "hash": "b90d8b0f54a0",
+          "scorecard": "101608 passed, 0 warnings, 0 failed"
+        }
+      }
+    },
+    {
+      "tag": "diya-gl-v1.2.65",
+      "date": "2026-10-31",
+      "formatVersion": "diya-gl/2",
+      "engineVersion": "1.2.65+abe8b1846",
+      "taxDataHash": "51bdff60e993",
+      "reconciledCommit": "54e8731a91279975e61b1a232fbb67fda89515f0",
+      "templates": {
+        "bst": {
+          "hash": "0d003e10e00c",
+          "scorecard": "812 passed, 0 warnings, 0 failed"
+        },
+        "taxi": {
+          "hash": "1ff69654d64d",
+          "scorecard": "700 passed, 0 warnings, 0 failed"
+        },
+        "se": {
+          "hash": "064605ae76ed",
+          "scorecard": "8015 passed, 0 warnings, 0 failed"
+        },
+        "ltd": {
+          "hash": "b90d8b0f54a0",
+          "scorecard": "101608 passed, 0 warnings, 0 failed"
+        }
+      }
     }
   ]
 }

package/dist/app/lib/product-sheets/format.js

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2006-2026 DIY Accounting Limited
+
+import { canonicalForUnit } from "../canonical-report-value.js";
+
+export function fmt(v, unit = "money") {
+  if (v === null || v === undefined || v === "" || v === " ") return "—";
+  if (typeof v === "number") {
+    const canonical = Number(canonicalForUnit(v, unit));
+    // A nil that arrived by negation carries a sign bit and prints as "-0",
+    // which reads as a defect in a statement.
+    return (canonical === 0 ? 0 : canonical).toLocaleString("en-GB", { minimumFractionDigits: 0, maximumFractionDigits: 2 });
+  }
+  return String(v);
+}

package/dist/app/lib/product-sheets/payslips.js

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2006-2026 DIY Accounting Limited
+
+import { toExcelSerial } from "../spreadsheet-runner.js";
+import { parseDate } from "../scenario-loader.js";
+import {
+  PAYE_DUE_DAY,
+  PAYE_SCHEDULE_FIRST_ROW,
+  PAYE_SCHEDULE_MONTH_TABS,
+  PAYSLIPS_EMPLOYEE_BASE_ROWS,
+  PAYSLIPS_EMPLOYEE_START_DATE_OFFSET,
+  PAYSLIPS_ENTRY_COLUMNS,
+  payeTaxMonthDates,
+  payslipsMonthEntryRows,
+  payslipsStartDate,
+  payslipsWagesPaidCell,
+} from "../payslips-layout.js";
+
+// Payslips.xlsx Jul (sheet5.xml) and Aug (sheet6.xml) shipped with 35 dead
+// #REF! cells: Jul!F11:F15 lost the weekly-block pay-date reference
+// (Employee!F$24/F$26 compared against E$9), Jul!T41 carried a stray
+// formula where every other month has a literal 0, and Aug!H11:M15 (K only
+// on rows 12-15) lost the previous month's row-41 brought-forward
+// reference. additionalReads never read either tab directly -- only the
+// Payment/Admin aggregates -- so none of it ever surfaced. Every fixture's
+// employees pay monthly, so the weekly-block gate (Employee!D$28 etc = "m")
+// and the carry-forward gate (Aug!T$9 = "Y") are never true: both blocks
+// always resolve to their blank/nil branch regardless of what the broken
+// formula pointed at, which is exactly why the #REF!s shipped unnoticed.
+export const PAYSLIPS_WEEKLY_ROWS = [11, 12, 13, 14, 15];
+export const PAYSLIPS_JUL_DEAD_CELLS = [...PAYSLIPS_WEEKLY_ROWS.map((row) => `F${row}`), "T41"];
+export const PAYSLIPS_AUG_BROUGHT_FORWARD_CELLS = PAYSLIPS_WEEKLY_ROWS.flatMap((row) => {
+  const cells = ["H", "I", "J", "L", "M"].map((col) => `${col}${row}`);
+  if (row >= 12) cells.push(`K${row}`);
+  return cells;
+});
+
+// The cells Payslips.xlsx cellWrites populates for a month's payroll, one
+// employee a row down the month's own monthly block, plus the wages-paid date
+// the block is dated from.
+export const payslipsMonthEntryCells = (monthIndex) => [
+  payslipsWagesPaidCell(monthIndex),
+  ...payslipsMonthEntryRows(monthIndex).flatMap((row) => Object.values(PAYSLIPS_ENTRY_COLUMNS).map((col) => `${col}${row}`)),
+];
+
+// The Employee sheet of Payslips.xlsx: the business details and up to five
+// employee blocks. payrollStart is the payroll year the package's calendar runs
+// on, payrollOpened the date the payroll record opened.
+export function writePayslipsEmployee(scenario, { payrollStart, payrollOpened, shiftDate }) {
+  // Employee blocks start at rows 13, 39, 65, 91, 117 (26-row intervals)
+  const EMP_BASE_ROWS = PAYSLIPS_EMPLOYEE_BASE_ROWS;
+  const emp = {};
+
+  // Business details in Payslips Employee sheet
+  const biz = scenario.business || {};
+  if (biz.name) emp.D5 = biz.name;
+  if (biz.address) emp.D6 = biz.address;
+  if (biz.town) emp.D7 = biz.town;
+  if (biz.postcode) emp.D9 = biz.postcode;
+
+  for (let i = 0; i < Math.min(scenario.employees.length, 5); i++) {
+    const e = scenario.employees[i];
+    const base = EMP_BASE_ROWS[i];
+    if (e.name) {
+      const parts = e.name.split(" ");
+      emp[`D${base + 2}`] = parts.slice(-1)[0]; // surname
+      emp[`D${base + 3}`] = parts.slice(0, -1).join(" "); // forename(s)
+    }
+    if (e.niNumber) emp[`M${base + 2}`] = e.niNumber;
+    // The date the employee joined, read against the payroll year this
+    // package's calendar runs on. Without it the employee's line on every
+    // month tab stays blank and the printed payslip prints no figures.
+    if (e.startDate && payrollStart) {
+      const joined = parseDate(e.startDate);
+      const onSheet = payslipsStartDate(joined, payrollOpened, shiftDate(joined), payrollStart);
+      emp[`D${base + PAYSLIPS_EMPLOYEE_START_DATE_OFFSET}`] = toExcelSerial(
+        onSheet.getUTCFullYear(),
+        onSheet.getUTCMonth() + 1,
+        onSheet.getUTCDate(),
+      );
+    }
+    emp[`D${base + 15}`] = e.payFrequency === "weekly" ? "W" : "M";
+    // The payroll number, not the scenario's own employee id. The printed
+    // payslip adds this cell to its block's start row to find the
+    // employee's line on the month tab, so a name in it takes the whole
+    // page's arithmetic with it.
+    emp[`D${base + 16}`] = i + 1;
+    emp[`D${base + 17}`] = e.isDirector ? "D" : e.niCategory || "A";
+  }
+  return emp;
+}
+
+// The PAYE remittance schedule: one row per tax month, each with the month it
+// ends and the day the payment falls due.
+export function checkPayeSchedule({ check, num }, paymentSchedule, payrollYearOpens) {
+  if (paymentSchedule && payrollYearOpens) {
+    const asSerial = (day) => toExcelSerial(day.getUTCFullYear(), day.getUTCMonth() + 1, day.getUTCDate());
+    PAYE_SCHEDULE_MONTH_TABS.forEach((tab, taxMonth) => {
+      const row = PAYE_SCHEDULE_FIRST_ROW + taxMonth;
+      const { ends, due } = payeTaxMonthDates(payrollYearOpens, taxMonth);
+      check(
+        `Payslips!Payment B${row} tax month ${taxMonth + 1} ends on the last day of ${tab}`,
+        num(paymentSchedule[`B${row}`]),
+        asSerial(ends),
+        0,
+      );
+      check(
+        `Payslips!Payment C${row} tax month ${taxMonth + 1} is due on the ${PAYE_DUE_DAY}th after it`,
+        num(paymentSchedule[`C${row}`]),
+        asSerial(due),
+        0,
+      );
+    });
+  }
+}

package/dist/app/lib/product-sheets/salesinvoice.js

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2006-2026 DIY Accounting Limited
+
+// ── Sales invoice sample line (Salesinvoice.xlsx) ───────────────────────────
+// The customer-facing invoice template has no external link into the rest of
+// the book, so its own VAT rate is proved directly: the generator now writes
+// the tax year's standard rate into Product Details!D2:D99 (generator.js),
+// and this checks one sample invoice line, anchored to the fixture's own
+// first sale, computes the right net, VAT and gross from it. Row 2 of
+// Product Details already ships the template's own placeholder product code
+// (A2 = 1001); this only sets its selling price. Business Details!B11 is the
+// VAT registration number the invoice template itself gates its per-row VAT
+// lookup on (verified against the XML: Invoice Template!N38 reads
+// 'Product Details'!D:D only when O8, which reads 'Business Details'!B11, is
+// not blank) -- an unregistered business is left untouched, the same as the
+// template's own guidance for it. The invoice also carries a carriage charge
+// (Invoice Database!E, the "Carriage Charge" column), which the template
+// taxes separately from the product lines in Invoice Template!P62. That term
+// used to read a literal 0.2; it now reads 'Product Details'!$D$2, the same
+// cell every row of D2:D99 carries the tax year's rate into, so carriage is
+// taxed at the written rate like every other line.
+export const SALESINVOICE_VAT_REG_CELL = "B11";
+// The same sheet's "Telephone" box, the entry cell beside its A8 label.
+export const SALESINVOICE_TELEPHONE_CELL = "B8";
+export const SALESINVOICE_SAMPLE_PRODUCT_CODE = 1001;
+export const SALESINVOICE_SAMPLE_PRODUCT_ROW = 2;
+export const SALESINVOICE_SAMPLE_CARRIAGE_CHARGE = 37.5;
+export const SALESINVOICE_PRODUCT_DETAILS_COLUMNS = { code: "A", price: "C", vatRate: "D" };
+export const SALESINVOICE_INVOICE_DATABASE_COLUMNS = {
+  activate: "A",
+  invoiceNumber: "B",
+  carriage: "E",
+  productCode1: "F",
+  quantity1: "G",
+};
+export const SALESINVOICE_INVOICE_TEMPLATE_CELLS = { netTotal: "P58", carriageNet: "P60", vatTotal: "P62", grossTotal: "P64" };
+export const SALESINVOICE_LINE1_CELLS = { productCode: "C38", unitPrice: "J38", quantity: "L38", lineNet: "P38", lineVat: "V38" };
+
+// The Salesinvoice.xlsx writes for a scenario: the telephone number, and one
+// sample invoice line for a VAT-registered business.
+export function writeSalesinvoice(scenario, rate) {
+  // Anchored to the fixture's own first sale so the customer-facing invoice
+  // total and VAT can be checked against a real figure (see checkSalesinvoice).
+  const salesinvoiceWrites = {};
+  // The invoice's own letterhead carries the business telephone number,
+  // which no other sheet in these workbooks has a box for.
+  if (scenario.business?.phone) salesinvoiceWrites["Business Details"] = { [SALESINVOICE_TELEPHONE_CELL]: scenario.business.phone };
+  const firstInvoiceSale = Object.values(scenario.sales || {}).flat()[0];
+  if (rate > 0 && scenario.business?.vat_number && firstInvoiceSale) {
+    salesinvoiceWrites["Business Details"] = {
+      ...salesinvoiceWrites["Business Details"],
+      [SALESINVOICE_VAT_REG_CELL]: scenario.business.vat_number,
+    };
+    salesinvoiceWrites["Invoice Database"] = {
+      [`${SALESINVOICE_INVOICE_DATABASE_COLUMNS.activate}2`]: 1,
+      [`${SALESINVOICE_INVOICE_DATABASE_COLUMNS.invoiceNumber}2`]: 1,
+      [`${SALESINVOICE_INVOICE_DATABASE_COLUMNS.carriage}2`]: SALESINVOICE_SAMPLE_CARRIAGE_CHARGE,
+      [`${SALESINVOICE_INVOICE_DATABASE_COLUMNS.productCode1}2`]: SALESINVOICE_SAMPLE_PRODUCT_CODE,
+      [`${SALESINVOICE_INVOICE_DATABASE_COLUMNS.quantity1}2`]: 1,
+    };
+    salesinvoiceWrites["Product Details"] = {
+      [`${SALESINVOICE_PRODUCT_DETAILS_COLUMNS.price}${SALESINVOICE_SAMPLE_PRODUCT_ROW}`]: firstInvoiceSale.amount,
+    };
+  }
+  return salesinvoiceWrites;
+}
+
+// The customer-facing invoice against the tax year's own VAT rate.
+export function checkSalesinvoice({ check, num }, results, expected, taxData, rate) {
+  // Salesinvoice.xlsx carries no external link to the rest of the book, so a
+  // wrong figure here never reaches the accounts -- it reaches the
+  // customer's customer. The generator writes the tax year's standard rate
+  // into Product Details!D2:D99 (generator.js); this checks the rate landed
+  // and that the one sample invoice line, plus the invoice's carriage
+  // charge, both compute their VAT correctly from it, hand-computed from the
+  // fixture's own first sale and the sample carriage charge.
+  const invoiceProductDetails = results["Salesinvoice.xlsx!Product Details"];
+  const invoiceTemplate = results["Salesinvoice.xlsx!Invoice Template"];
+  if (invoiceProductDetails && invoiceTemplate && taxData) {
+    const standardRatePercent = Math.round(taxData.vat.standard_rate * 100);
+    check(
+      "Salesinvoice Product Details: VAT Rate = the tax year's standard rate",
+      num(invoiceProductDetails[`${SALESINVOICE_PRODUCT_DETAILS_COLUMNS.vatRate}${SALESINVOICE_SAMPLE_PRODUCT_ROW}`]),
+      standardRatePercent,
+      0,
+    );
+
+    // cellWrites only puts the sample invoice line and carriage charge on the
+    // sheet for a VAT-registered business (rate > 0 and a VAT number) --
+    // otherwise Salesinvoice.xlsx keeps its blank template state, and these
+    // five figures would have nothing to compare against.
+    const firstInvoiceSale = Object.values(expected.sales || {}).flat()[0];
+    if (rate > 0 && expected.business?.vat_number && firstInvoiceSale) {
+      const expectedNet = firstInvoiceSale.amount;
+      const expectedLineVat = (expectedNet * standardRatePercent) / 100;
+      const expectedCarriageVat = (SALESINVOICE_SAMPLE_CARRIAGE_CHARGE * standardRatePercent) / 100;
+      const expectedVatTotal = expectedLineVat + expectedCarriageVat;
+      check(
+        "Salesinvoice: line VAT = price x quantity x the tax year's standard rate",
+        num(invoiceTemplate[SALESINVOICE_LINE1_CELLS.lineVat]),
+        expectedLineVat,
+        0.01,
+      );
+      check(
+        "Salesinvoice: net total = the invoice's one line",
+        num(invoiceTemplate[SALESINVOICE_INVOICE_TEMPLATE_CELLS.netTotal]),
+        expectedNet,
+        0.01,
+      );
+      check(
+        "Salesinvoice: carriage charge lands on the invoice",
+        num(invoiceTemplate[SALESINVOICE_INVOICE_TEMPLATE_CELLS.carriageNet]),
+        SALESINVOICE_SAMPLE_CARRIAGE_CHARGE,
+        0.01,
+      );
+      check(
+        "Salesinvoice: VAT total = line VAT plus carriage VAT at the tax year's standard rate",
+        num(invoiceTemplate[SALESINVOICE_INVOICE_TEMPLATE_CELLS.vatTotal]),
+        expectedVatTotal,
+        0.01,
+      );
+      check(
+        "Salesinvoice: amount payable = net plus carriage plus VAT",
+        num(invoiceTemplate[SALESINVOICE_INVOICE_TEMPLATE_CELLS.grossTotal]),
+        expectedNet + SALESINVOICE_SAMPLE_CARRIAGE_CHARGE + expectedVatTotal,
+        0.01,
+      );
+    }
+  }
+}

package/dist/app/lib/product-sheets/serial-dates.js

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2006-2026 DIY Accounting Limited
+
+// The date an Excel serial stands for.
+export function excelSerialToUtcDate(serial) {
+  const epoch = Date.UTC(1899, 11, 30);
+  return new Date(epoch + Math.round(serial) * 24 * 60 * 60 * 1000);
+}
+
+export function formatSerialDate(serial) {
+  return excelSerialToUtcDate(serial).toLocaleDateString("en-GB", { timeZone: "UTC", day: "numeric", month: "long", year: "numeric" });
+}
+
+// The " (period ending d Month yyyy)" a VAT return line carries, or nothing
+// at all when the form has no date on it.
+export function periodEnding(serial) {
+  return serial ? ` (period ending ${formatSerialDate(serial)})` : "";
+}