@diy-accounting-uk/diya-gl 1.2.58 → 1.2.60

package/dist/app/data/releases.json

@@ -1741,6 +1741,58 @@
           "scorecard": "101608 passed, 0 warnings, 0 failed"
         }
       }
+    },
+    {
+      "tag": "diya-gl-v1.2.58",
+      "date": "2026-10-25",
+      "formatVersion": "diya-gl/1",
+      "engineVersion": "1.2.58+ad393516",
+      "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": "a65ab09cf35c",
+          "scorecard": "101608 passed, 0 warnings, 0 failed"
+        }
+      }
+    },
+    {
+      "tag": "diya-gl-v1.2.59",
+      "date": "2026-10-27",
+      "formatVersion": "diya-gl/1",
+      "engineVersion": "1.2.59+9d3b814a",
+      "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": "a65ab09cf35c",
+          "scorecard": "101608 passed, 0 warnings, 0 failed"
+        }
+      }
     }
   ]
 }

package/dist/app/lib/diya-gl-interchange.js

@@ -46,7 +46,7 @@ import { canonicalBookToml, canonicalLinesJsonl, compareLines, orderedBookTopLev
 import { serializeReportDocument } from "./report-serializer.js";
 import { parseDiyaGlData } from "./diya-gl-loader.js";
 import { stampBook } from "./provenance.js";
-import { sniffIxbrl } from "./ixbrl-reader.js";
+import { sniffIxbrl, readIxbrlSet, checkSameReport, IxbrlError } from "./ixbrl-reader.js";
 import { mapIxbrlAccounts } from "./ixbrl-accounts.js";
 import { buildIxbrlSummaryBooks } from "./ixbrl-summary-book.js";
 import * as bst from "../products/bst.js";
@@ -190,6 +190,12 @@ async function zipKind(bytes) {
   const jsonEntries = entries.filter((name) => name.toLowerCase().endsWith(".json"));
   if (jsonEntries.length === 1 && entries.length === 1) return "json-zip";
 
+  const documents = entries.filter((name) => !name.toUpperCase().startsWith("META-INF/"));
+  if (documents.length > 0) {
+    const sniffed = await Promise.all(documents.map(async (name) => sniffIxbrl(await zip.file(name).async("uint8array"))));
+    if (sniffed.every(Boolean)) return "ixbrl-zip";
+  }
+
   return "unknown";
 }
 
@@ -200,7 +206,7 @@ async function zipKind(bytes) {
  * error messages only.
  * @param {Uint8Array} bytes
  * @param {string} [name] - a hint for messages, not for detection
- * @returns {Promise<"workbook"|"package-zip"|"package-set"|"diya-gl-zip"|"json-zip"|"json"|"ixbrl"|"xbrl"|"xls"|"unknown">}
+ * @returns {Promise<"workbook"|"package-zip"|"package-set"|"diya-gl-zip"|"json-zip"|"json"|"ixbrl"|"xbrl"|"ixbrl-zip"|"xls"|"unknown">}
  */
 export async function detectBookSource(bytes, name) {
   void name; // content decides the kind; the name is a hint for a caller's own error messages, never for detection
@@ -463,8 +469,8 @@ async function readJsonZipSource(bytes) {
 // An accounts file stands for two Company books, the file's own year and the
 // year before, each a summary with one line per tagged line. The comparative
 // pair, the accounts figures and the facts no figure uses ride beside them.
-async function readIxbrlSource(kind, bytes, deps) {
-  const accounts = mapIxbrlAccounts(bytes, deps.expect, { suiteConcepts: deps.suiteConcepts });
+async function readIxbrlSource(kind, source, deps) {
+  const accounts = mapIxbrlAccounts(source, deps.expect, { suiteConcepts: deps.suiteConcepts });
   const summary = await buildIxbrlSummaryBooks(accounts, { resources: deps.resources });
   const current = validated(kind, summary.book, summary.lines);
   const prior = validated(kind, summary.comparative.book, summary.comparative.lines);
@@ -478,6 +484,67 @@ async function readIxbrlSource(kind, bytes, deps) {
   };
 }
 
+// The directories of a Companies House package that hold the company's own
+// accounts, in the order they are looked for.
+const PACKAGE_ENTRY_DIRECTORIES = ["reports/english", "accounts", "subsidiary-accounts"];
+const PACKAGE_WELSH_DIRECTORY = "reports/welsh";
+
+const directoryOf = (entry) => entry.slice(0, Math.max(0, entry.lastIndexOf("/")));
+
+// A zip of iXBRL documents is one document set when its files sit together,
+// or a Companies House package when they sit in directories. A package is
+// read through its entry directory; a Welsh package is also compared with its
+// Welsh directory, as Companies House compares the two.
+async function readIxbrlZipSource(bytes) {
+  const zip = await JSZip.loadAsync(bytes);
+  const entries = Object.keys(zip.files)
+    .filter((name) => !zip.files[name].dir && !name.toUpperCase().startsWith("META-INF/"))
+    .sort();
+  const documentOf = async (entry) => ({ name: entry, bytes: await zip.file(entry).async("uint8array") });
+
+  const directories = new Map();
+  for (const entry of entries) {
+    const directory = directoryOf(entry);
+    directories.set(directory, [...(directories.get(directory) ?? []), entry]);
+  }
+  if (directories.size === 1 && directories.has("")) return readIxbrlSet(await Promise.all(entries.map(documentOf)));
+
+  for (const [directory, members] of directories) {
+    if (members.length > 1)
+      throw new IxbrlError(`The zip holds more than one accounts file in "${directory}/"; a package folder holds one.`);
+  }
+  const entryDirectory = PACKAGE_ENTRY_DIRECTORIES.find((directory) => directories.has(directory));
+  if (!entryDirectory) {
+    throw new IxbrlError(
+      directories.size === 1
+        ? "The zip holds accounts in a folder diya-gl does not recognise; drop the accounts file on its own."
+        : "The zip holds several folders and none is the company's own accounts; drop the accounts file on its own.",
+    );
+  }
+  const read = readIxbrlSet([await documentOf(directories.get(entryDirectory)[0])]);
+  if (entryDirectory === "reports/english" && directories.has(PACKAGE_WELSH_DIRECTORY)) {
+    const welsh = readIxbrlSet([await documentOf(directories.get(PACKAGE_WELSH_DIRECTORY)[0])]);
+    checkSameReport(read, welsh, "English", "Welsh");
+  }
+  return read;
+}
+
+/**
+ * Turn several files dropped together into D. Files that are all iXBRL
+ * documents are one document set. One file is read as readBookSource reads it.
+ * @param {Array<{name: string, bytes: Uint8Array}>} files
+ * @param {Object} [deps] - as readBookSource
+ * @returns {Promise<Object>} as readBookSource
+ */
+export async function readBookSources(files, deps = {}) {
+  if (files.length === 1) return readBookSource(files[0].bytes, files[0].name, deps);
+  const kinds = await Promise.all(files.map((file) => detectBookSource(file.bytes, file.name)));
+  if (kinds.every((kind) => kind === "ixbrl" || kind === "xbrl")) {
+    return readIxbrlSource("ixbrl", readIxbrlSet(files), deps);
+  }
+  throw new IxbrlError("Drop the accounts files on their own.");
+}
+
 /**
  * Turn a byte array into D: the book and its lines, whichever of the kinds
  * it sniffs as. The CLI's --file mode, the MCP server's extract_book
@@ -508,6 +575,8 @@ export async function readBookSource(bytes, name, deps = {}) {
     case "ixbrl":
     case "xbrl":
       return readIxbrlSource(kind, bytes, deps);
+    case "ixbrl-zip":
+      return readIxbrlSource(kind, await readIxbrlZipSource(bytes), deps);
     case "xls":
       throw new XlsBookSourceError(name);
     default:

package/dist/app/lib/ixbrl-accounts.js

@@ -41,6 +41,8 @@ export const FIXED_ASSET_ACCOUNTS = {
   motorVehicles: "0040",
 };
 
+const NATURE_NOTE = "micro-entity and Format 2 profit and loss";
+
 /**
  * The mapping, one row per concept and member the reader maps. `figure` is
  * the name the forms and builders use; `account` is where the summary book
@@ -89,6 +91,7 @@ export const MAPPING_TABLE = [
     note: "WithinOneYear; posts as a trade creditor, which the balance sheet shows within one year",
   },
   { concept: "AccruedLiabilitiesNotExpressedWithinCreditorsSubtotal", figure: "otherCreditors", account: "2100", note: "WithinOneYear" },
+  { concept: "TaxationSocialSecurityPayable", figure: "otherCreditors", account: "2100", note: "WithinOneYear" },
   {
     concept: "Creditors",
     dimension: MATURITY,
@@ -133,21 +136,77 @@ export const MAPPING_TABLE = [
     account: "1200",
     note: "a receipt coded K",
   },
+  {
+    concept: "InterestPayableSimilarChargesFinanceCosts",
+    figure: "interestPayable",
+    account: "5803",
+    note: "the ltd book's loan interest account",
+  },
   { concept: "TaxTaxCreditOnProfitOrLossOnOrdinaryActivities", figure: "tax", account: "-", note: "not posted; diya-gl works the tax" },
   { concept: "GrossProfitLoss", figure: "grossProfit", account: "-", note: "a check" },
   { concept: "OperatingProfitLoss", figure: "operatingProfit", account: "-", note: "a check" },
   { concept: "ProfitLossOnOrdinaryActivitiesBeforeTax", figure: "profitBeforeTax", account: "-", note: "a check" },
   { concept: "ProfitLoss", figure: "profit", account: "-", note: "a check" },
-  { concept: "OtherOperatingIncomeFormat2", figure: "otherOperatingIncome", account: "4003", note: "micro-entity profit and loss" },
-  { concept: "RawMaterialsConsumablesUsed", figure: "rawMaterialsConsumables", account: "5000", note: "micro-entity profit and loss" },
-  { concept: "StaffCostsEmployeeBenefitsExpense", figure: "staffCosts", account: "5101", note: "micro-entity profit and loss" },
+  { concept: "OtherOperatingIncomeFormat2", figure: "otherOperatingIncome", account: "4003", note: NATURE_NOTE },
+  {
+    concept: "OtherOperatingIncome",
+    figure: "otherOperatingIncome",
+    account: "4003",
+    note: `${NATURE_NOTE}; read when the Format 2 name is absent`,
+  },
+  {
+    concept: "IncreaseDecreaseInStocksInventoriesFinishedGoodsWorkInProgress",
+    figure: "changeInStocks",
+    account: "-",
+    note: "Format 2 profit and loss; not posted, the stock movement of the balance sheets already moves 1100 and 5000, and a difference is listed",
+  },
+  { concept: "OwnWorkCapitalised", figure: "ownWorkCapitalised", account: "4003", note: "Format 2 profit and loss" },
+  { concept: "RawMaterialsConsumablesUsed", figure: "rawMaterialsConsumables", account: "5000", note: NATURE_NOTE },
+  {
+    concept: "OtherExternalCharges",
+    figure: "otherExternalCharges",
+    account: "5001",
+    note: "Format 2 profit and loss; the sub-contractors account",
+  },
+  {
+    concept: "StaffCostsEmployeeBenefitsExpense",
+    figure: "staffCosts",
+    account: "5101",
+    note: `${NATURE_NOTE}; the sum of the three lines below when absent`,
+  },
+  { concept: "WagesSalaries", figure: "wagesSalaries", account: "5101", note: "part of staffCosts" },
+  { concept: "SocialSecurityCosts", figure: "socialSecurityCosts", account: "5101", note: "part of staffCosts" },
+  {
+    concept: "PensionOtherPost-employmentBenefitCostsOtherPensionCosts",
+    figure: "pensionCosts",
+    account: "5101",
+    note: "part of staffCosts",
+  },
   {
     concept: "DepreciationAmortisationImpairmentExpense",
     figure: "depreciation",
     account: "depreciationRate",
-    note: "micro-entity profit and loss",
+    note: NATURE_NOTE,
+  },
+  {
+    concept: "DepreciationAmortisationExpense",
+    figure: "depreciation",
+    account: "depreciationRate",
+    note: `${NATURE_NOTE}; read when the impairment name is absent`,
+  },
+  { concept: "OtherOperatingExpensesFormat2", figure: "otherOperatingExpenses", account: "5501", note: NATURE_NOTE },
+  {
+    concept: "OtherOperatingExpensesByNature",
+    figure: "otherOperatingExpenses",
+    account: "5501",
+    note: `${NATURE_NOTE}; read when the Format 2 name is absent`,
+  },
+  {
+    concept: "ProfitLossBeforeTax",
+    figure: "profitBeforeTax",
+    account: "-",
+    note: "a check; read when ProfitLossOnOrdinaryActivitiesBeforeTax is absent",
   },
-  { concept: "OtherOperatingExpensesFormat2", figure: "otherOperatingExpenses", account: "5501", note: "micro-entity profit and loss" },
   {
     concept: "GainLossOnDisposalsPropertyPlantEquipment",
     figure: "gainOnDisposal",
@@ -295,6 +354,7 @@ function balanceSheetAt(set, endDay, notes, label) {
     otherCreditors: sumDefined([
       set.maturity("OtherCreditors", endDay, ["WithinOneYear", null]),
       set.maturity("AccruedLiabilitiesNotExpressedWithinCreditorsSubtotal", endDay, ["WithinOneYear", null]),
+      set.maturity("TaxationSocialSecurityPayable", endDay, ["WithinOneYear", null]),
     ]),
     creditorsWithinOneYear: set.instant("Creditors", endDay, { [MATURITY]: "WithinOneYear" }),
     creditorsAfterOneYear: sumDefined([afterOneYear, provisions]),
@@ -308,22 +368,76 @@ function balanceSheetAt(set, endDay, notes, label) {
   });
 }
 
-function profitAndLossAt(set, endDay) {
+// The concepts that say which format the profit and loss account takes. Format 1 analyses costs by
+// function; Format 2 by nature. A Format 2 concept in a Format 1 file belongs to a note.
+const FORMAT_1_CONCEPTS = new Set([
+  "CostSales",
+  "GrossProfitLoss",
+  "DistributionCosts",
+  "AdministrativeExpenses",
+  "OtherOperatingIncomeFormat1",
+  "OtherOperatingExpensesFormat1",
+]);
+const FORMAT_2_CONCEPTS = new Set([
+  "IncreaseDecreaseInStocksInventoriesFinishedGoodsWorkInProgress",
+  "OwnWorkCapitalised",
+  "OtherOperatingIncomeFormat2",
+  "RawMaterialsConsumablesUsed",
+  "OtherExternalCharges",
+  "StaffCostsEmployeeBenefitsExpense",
+  "WagesSalaries",
+  "SocialSecurityCosts",
+  "PensionOtherPost-employmentBenefitCostsOtherPensionCosts",
+  "DepreciationAmortisationImpairmentExpense",
+  "DepreciationAmortisationExpense",
+  "OtherOperatingExpensesFormat2",
+  "OtherOperatingExpensesByNature",
+]);
+
+// 1 or 2: the format of the profit and loss account the facts ending on one of the days state.
+function profitAndLossFormat(set, endDays) {
+  for (const endDay of endDays) {
+    const names = set.facts.filter((fact) => fact.period.endDate === endDay).map((fact) => fact.localName);
+    if (names.some((name) => FORMAT_1_CONCEPTS.has(name))) return 1;
+    if (names.some((name) => FORMAT_2_CONCEPTS.has(name))) return 2;
+  }
+  return 1;
+}
+
+function profitAndLossAt(set, endDay, byNature) {
+  const staffCosts = byNature ? (set.duration("StaffCostsEmployeeBenefitsExpense", endDay) ?? undefined) : undefined;
+  const wagesSalaries = byNature ? set.duration("WagesSalaries", endDay) : undefined;
+  const socialSecurityCosts = byNature ? set.duration("SocialSecurityCosts", endDay) : undefined;
+  const pensionCosts = byNature ? set.duration("PensionOtherPost-employmentBenefitCostsOtherPensionCosts", endDay) : undefined;
+  const nature = byNature
+    ? {
+        changeInStocks: set.duration("IncreaseDecreaseInStocksInventoriesFinishedGoodsWorkInProgress", endDay),
+        ownWorkCapitalised: set.duration("OwnWorkCapitalised", endDay),
+        otherOperatingIncome: set.duration("OtherOperatingIncomeFormat2", endDay) ?? set.duration("OtherOperatingIncome", endDay),
+        rawMaterialsConsumables: set.duration("RawMaterialsConsumablesUsed", endDay),
+        otherExternalCharges: set.duration("OtherExternalCharges", endDay),
+        staffCosts: staffCosts ?? sumDefined([wagesSalaries, socialSecurityCosts, pensionCosts]),
+        wagesSalaries,
+        socialSecurityCosts,
+        pensionCosts,
+        depreciation:
+          set.duration("DepreciationAmortisationImpairmentExpense", endDay) ?? set.duration("DepreciationAmortisationExpense", endDay),
+        otherOperatingExpenses:
+          set.duration("OtherOperatingExpensesFormat2", endDay) ?? set.duration("OtherOperatingExpensesByNature", endDay),
+      }
+    : {};
   return pick({
+    ...nature,
     turnover: set.duration("TurnoverRevenue", endDay),
     costOfSales: set.duration("CostSales", endDay),
     grossProfit: set.duration("GrossProfitLoss", endDay),
     administrativeExpenses: set.duration("AdministrativeExpenses", endDay),
     operatingProfit: set.duration("OperatingProfitLoss", endDay),
     interestReceivable: set.duration("OtherInterestReceivableSimilarIncomeFinanceIncome", endDay),
-    profitBeforeTax: set.duration("ProfitLossOnOrdinaryActivitiesBeforeTax", endDay),
+    interestPayable: set.duration("InterestPayableSimilarChargesFinanceCosts", endDay),
+    profitBeforeTax: set.duration("ProfitLossOnOrdinaryActivitiesBeforeTax", endDay) ?? set.duration("ProfitLossBeforeTax", endDay),
     tax: set.duration("TaxTaxCreditOnProfitOrLossOnOrdinaryActivities", endDay),
     profit: set.duration("ProfitLoss", endDay) ?? set.duration("ProfitLossOnOrdinaryActivitiesAfterTax", endDay),
-    otherOperatingIncome: set.duration("OtherOperatingIncomeFormat2", endDay),
-    rawMaterialsConsumables: set.duration("RawMaterialsConsumablesUsed", endDay),
-    staffCosts: set.duration("StaffCostsEmployeeBenefitsExpense", endDay),
-    depreciation: set.duration("DepreciationAmortisationImpairmentExpense", endDay),
-    otherOperatingExpenses: set.duration("OtherOperatingExpensesFormat2", endDay),
     gainOnDisposal: set.duration("GainLossOnDisposalsPropertyPlantEquipment", endDay),
   });
 }
@@ -511,30 +625,49 @@ function checkProfitAndLoss(pl, label) {
   if (
     pl.profitBeforeTax !== undefined &&
     pl.operatingProfit !== undefined &&
-    !close(pl.operatingProfit + n(pl.interestReceivable), pl.profitBeforeTax)
+    !close(pl.operatingProfit + n(pl.interestReceivable) - n(pl.interestPayable), pl.profitBeforeTax)
   ) {
-    mismatch("profit before tax", pl.operatingProfit + n(pl.interestReceivable), pl.profitBeforeTax);
+    mismatch("profit before tax", pl.operatingProfit + n(pl.interestReceivable) - n(pl.interestPayable), pl.profitBeforeTax);
   }
   if (pl.profit !== undefined && pl.profitBeforeTax !== undefined && !close(pl.profitBeforeTax - n(pl.tax), pl.profit)) {
     mismatch("profit for the year", pl.profitBeforeTax - n(pl.tax), pl.profit);
   }
-  const micro = microProfitBeforeTax(pl);
-  if (micro !== undefined && pl.profit !== undefined && !close(micro - n(pl.tax), pl.profit)) {
-    mismatch("profit for the year", micro - n(pl.tax), pl.profit);
+  const byNature = natureProfitBeforeTax(pl);
+  if (byNature !== undefined && pl.operatingProfit !== undefined && !close(byNature, pl.operatingProfit)) {
+    mismatch("operating profit", byNature, pl.operatingProfit);
+  }
+  if (
+    byNature !== undefined &&
+    pl.profit !== undefined &&
+    !close(byNature + n(pl.interestReceivable) - n(pl.interestPayable) - n(pl.tax), pl.profit)
+  ) {
+    mismatch("profit for the year", byNature + n(pl.interestReceivable) - n(pl.interestPayable) - n(pl.tax), pl.profit);
   }
 }
 
-// The micro-entity P&L: turnover plus other income less the four expense lines.
-export function microProfitBeforeTax(pl) {
-  const hasMicroLine = ["otherOperatingIncome", "rawMaterialsConsumables", "staffCosts", "depreciation", "otherOperatingExpenses"].some(
-    (key) => pl[key] !== undefined,
-  );
-  if (!hasMicroLine || pl.turnover === undefined) return undefined;
+// The profit and loss account by nature (micro-entity lines and Format 2): turnover, the change in
+// stocks, own work capitalised and other income, less raw materials, external charges, staff costs,
+// depreciation and other expenses. Before interest, so a micro-entity's figure is its profit before tax.
+export function natureProfitBeforeTax(pl) {
+  const hasNatureLine = [
+    "changeInStocks",
+    "ownWorkCapitalised",
+    "otherOperatingIncome",
+    "rawMaterialsConsumables",
+    "otherExternalCharges",
+    "staffCosts",
+    "depreciation",
+    "otherOperatingExpenses",
+  ].some((key) => pl[key] !== undefined);
+  if (!hasNatureLine || pl.turnover === undefined) return undefined;
   const n = (value) => value ?? 0;
   return (
     pl.turnover +
+    n(pl.changeInStocks) +
+    n(pl.ownWorkCapitalised) +
     n(pl.otherOperatingIncome) -
     n(pl.rawMaterialsConsumables) -
+    n(pl.otherExternalCharges) -
     n(pl.staffCosts) -
     n(pl.depreciation) -
     n(pl.otherOperatingExpenses)
@@ -611,8 +744,11 @@ export function mapIxbrlAccounts(source, expect = {}, { suiteConcepts } = {}) {
   const notes = [];
   const currentYear = balanceSheetAt(set, period.end, notes, "Current year");
   const priorYear = priorEnd ? balanceSheetAt(set, priorEnd, notes, "Prior year") : {};
-  const currentPl = profitAndLossAt(set, period.end);
-  const priorPl = priorEnd ? profitAndLossAt(set, priorEnd) : {};
+  const profitAndLossFormatNumber = profitAndLossFormat(set, priorEnd ? [period.end, priorEnd] : [period.end]);
+  // A micro-entity file's lines read as the micro lines; a Format 2 small company file reads the same lines and more.
+  const byNature = regime === "micro" || profitAndLossFormatNumber === 2;
+  const currentPl = profitAndLossAt(set, period.end, byNature);
+  const priorPl = priorEnd ? profitAndLossAt(set, priorEnd, byNature) : {};
   const fixedAssetNote = priorEnd ? fixedAssetNoteAt(set, period.end, priorEnd) : null;
   // The note's totals and net book values restate what its classes and the balance sheet already say.
   for (const fact of set.facts) {
@@ -689,13 +825,15 @@ export function mapIxbrlAccounts(source, expect = {}, { suiteConcepts } = {}) {
   for (const fact of [shares, nominal]) if (fact) set.consumed.add(fact);
   const shareClassMember = (fact) => (fact && Object.keys(fact.dimensions).length === 1 ? local(Object.values(fact.dimensions)[0]) : null);
 
-  if (regime === "small" && hasProfitAndLoss && currentPl.costOfSales === undefined && currentPl.turnover === undefined) {
-    notes.push("This file's profit and loss account is Format 2, which the small company form does not take.");
-  }
-
   const principalActivity = textFact(set, "DescriptionPrincipalActivities") ?? null;
   const approvalDate = textFact(set, "DateAuthorisationFinancialStatementsForIssue") ?? null;
-  const definedBySuite = read.suite.date ? suiteConcepts?.(read.suite.date) : undefined;
+  const definedBySuite = read.suite.date && read.suite.family !== "UK-GAAP" ? suiteConcepts?.(read.suite.date) : undefined;
+  const sourceConcepts = {};
+  // A name stated both on its own and on a dimension (Equity) takes the UK GAAP name of the fact on its own.
+  const translated = set.facts.filter((fact) => fact.sourceConcept);
+  for (const fact of [...translated.filter((f) => Object.keys(f.dimensions).length === 0), ...translated]) {
+    sourceConcepts[fact.localName] ??= fact.sourceConcept;
+  }
   const unmapped = set.facts
     .filter((fact) => !set.consumed.has(fact) && fact.value !== "" && !isBoilerplate(fact))
     .map((fact) => ({
@@ -717,7 +855,7 @@ export function mapIxbrlAccounts(source, expect = {}, { suiteConcepts } = {}) {
     filleted,
     hasProfitAndLoss,
     balanceSheet: { currentYear, priorYear },
-    profitAndLoss: hasProfitAndLoss ? { currentYear: currentPl, priorYear: priorPl } : null,
+    profitAndLoss: hasProfitAndLoss ? { format: profitAndLossFormatNumber, currentYear: currentPl, priorYear: priorPl } : null,
     fixedAssetNote,
     averageEmployees: averageEmployees ?? null,
     principalActivity,
@@ -734,6 +872,7 @@ export function mapIxbrlAccounts(source, expect = {}, { suiteConcepts } = {}) {
         : null,
     firstAccounts: Boolean(expect.firstAccounts),
     notes,
+    sourceConcepts,
     unmapped,
   };
 }

package/dist/app/lib/ixbrl-reader.js

@@ -18,6 +18,7 @@
 // server run.
 
 import { DOMParser } from "@xmldom/xmldom";
+import { UK_GAAP_SUITE_DATE, translateUkGaapFacts } from "./ixbrl-uk-gaap.js";
 
 const NS_IX_11 = "http://www.xbrl.org/2013/inlineXBRL";
 const NS_IX_10 = "http://www.xbrl.org/2008/inlineXBRL";
@@ -41,7 +42,10 @@ const TRANSFORMATION_REGISTRIES = [
 
 const FRC_NAMESPACE = /^http:\/\/xbrl\.frc\.org\.uk\/(fr|cd|reports)\/(\d{4}-\d{2}-\d{2})\/(.+)$/;
 const FRC_ENTRY_POINT = /xbrl\.frc\.org\.uk\/([^/]+)\/(\d{4}-\d{2}-\d{2})\//;
-const OLD_UK_GAAP_NAMESPACE = /^http:\/\/www\.xbrl\.org\/uk\/(gaap|cd|fr)\b/;
+const OLD_UK_GAAP_NAMESPACE = /^http:\/\/www\.xbrl\.org\/uk\/(?:gaap|cd|fr|reports)\/[^/]+\/(\d{4}-\d{2}-\d{2})\b/;
+const OLD_UK_GAAP_ENTRY_POINT = /xbrl\.org\/uk\/(?:gaap|cd|fr|reports)\/[^/]+\/(\d{4}-\d{2}-\d{2})\//;
+
+const DROP_THE_SET = "Drop all the files of the set together, or the zip.";
 
 // What a customer sees when a file reads as something other than FRS 102 or
 // FRS 105 accounts.
@@ -361,7 +365,9 @@ function inlineParts(document) {
   const root = document.documentElement;
   const headers = descendants(root, (element) => isIx(element, "header"));
   const resources = headers.flatMap((header) => descendants(header, (element) => isIx(element, "resources")));
-  const schemaRefs = headers.flatMap((header) => descendants(header, (element) => is(element, NS_LINK, "schemaRef")));
+  const schemaRefs = headers.flatMap((header) =>
+    descendants(header, (element) => is(element, NS_LINK, "schemaRef") && !element.parentNode.getAttribute?.("target")),
+  );
   const hiddenElements = new Set(headers.flatMap((header) => descendants(header, (element) => isIx(element, "hidden"))));
   const factElements = descendants(root, (element) => isIx(element, "nonFraction") || isIx(element, "nonNumeric"));
   const continuations = new Map(
@@ -398,9 +404,7 @@ function nonNumericText(element, continuations) {
     seen.add(next);
     const continuation = continuations.get(next);
     if (!continuation) {
-      throw new IxbrlError(
-        "This file is one part of a document set: a fact continues in another file. diya-gl reads single-file documents.",
-      );
+      throw new IxbrlError(`This file is one part of a document set: a fact continues in another file. ${DROP_THE_SET}`);
     }
     text += textOf(continuation);
     next = continuation.getAttribute("continuedAt");
@@ -454,6 +458,7 @@ function suiteOf(namespaces, schemaRefs) {
       suite.date = match[2];
     } else if (/xbrl\.org\/uk\//.test(href)) {
       suite.family = "UK-GAAP";
+      suite.date ??= href.match(OLD_UK_GAAP_ENTRY_POINT)?.[1] ?? null;
     }
   }
   for (const namespace of namespaces) {
@@ -463,6 +468,7 @@ function suiteOf(namespaces, schemaRefs) {
       suite.modules.add(match[3]);
     } else if (OLD_UK_GAAP_NAMESPACE.test(namespace)) {
       suite.family = "UK-GAAP";
+      suite.date ??= namespace.match(OLD_UK_GAAP_NAMESPACE)[1];
     }
   }
   return suite;
@@ -473,111 +479,265 @@ const SUITE_LABELS = {
   "IFRS": "IFRS",
   "Charities": "Charities SORP",
   "UKSEF": "UK Single Electronic Format",
-  "UK-GAAP": "old UK GAAP",
 };
 
 function checkSuite(suite) {
+  if (suite.family === "UK-GAAP") {
+    if (suite.date !== UK_GAAP_SUITE_DATE) {
+      throw new IxbrlError(
+        `This file uses the UK GAAP taxonomy of ${suite.date ?? "an unstated date"}; the form reads the ${UK_GAAP_SUITE_DATE} suite.`,
+      );
+    }
+    return;
+  }
   if (suite.family && !READ_SUITES.includes(suite.family)) {
     const label = SUITE_LABELS[suite.family] ?? suite.family;
     throw new IxbrlError(`This file uses the ${label} taxonomy; the form takes FRS 102 and FRS 105 accounts.`);
   }
 }
 
-/**
- * Read an Inline XBRL document or an XBRL instance into facts.
- * @param {Uint8Array|string} input - the document
- * @returns {{kind: "ixbrl"|"xbrl", suite: {family: string|null, date: string|null, modules: string[]}, facts: Array<Object>, contexts: Object, units: Object}}
- * @throws {IxbrlError} when the document cannot be read, with a message a customer reads
- */
-export function readIxbrl(input) {
-  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
-  const kind = sniffIxbrl(bytes);
-  if (!kind) throw new IxbrlError("This file is not an Inline XBRL document or an XBRL instance.");
+const nameOf = (name) => (name ? `"${name}"` : "This file");
 
-  const document = parseDocument(decodeUtf8(bytes));
-  const parts = kind === "ixbrl" ? inlineParts(document) : instanceParts(document);
+function describeSuite(suite) {
+  return [suite.family, suite.date].filter(Boolean).join(" ");
+}
 
+function sameJson(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+function mergeResources(parsed) {
   const contexts = {};
   const units = {};
-  for (const resource of parts.resources) {
-    for (const child of elementChildren(resource)) {
-      if (is(child, NS_XBRLI, "context")) {
-        const context = readContext(child);
-        contexts[context.id] = context;
-      } else if (is(child, NS_XBRLI, "unit")) {
-        units[child.getAttribute("id")] = readUnit(child);
+  const identifiers = new Set();
+  for (const part of parsed) {
+    for (const resource of part.parts.resources) {
+      for (const child of elementChildren(resource)) {
+        if (is(child, NS_XBRLI, "context")) {
+          const context = readContext(child);
+          if (contexts[context.id] && !sameJson(contexts[context.id], context)) {
+            throw new IxbrlError(`The files define the context "${context.id}" differently.`);
+          }
+          contexts[context.id] = context;
+          identifiers.add(`${context.entity.scheme}|${context.entity.identifier}`);
+        } else if (is(child, NS_XBRLI, "unit")) {
+          const id = child.getAttribute("id");
+          const unit = readUnit(child);
+          if (units[id] !== undefined && units[id] !== unit) throw new IxbrlError(`The files define the unit "${id}" differently.`);
+          units[id] = unit;
+        }
       }
     }
   }
-  if (Object.keys(contexts).length === 0 && parts.factElements.length > 0) {
-    throw new IxbrlError("This file is one part of a document set: its contexts are in another file. diya-gl reads single-file documents.");
+  return { contexts, units, identifiers };
+}
+
+function checkSetAgrees(parsed, identifiers) {
+  if (identifiers.size > 1) {
+    const names = [...identifiers].map((id) => id.split("|")[1]);
+    throw new IxbrlError(`The files are for different companies (${names.join(" and ")}).`);
+  }
+  const suites = parsed
+    .map((part) => suiteOf(new Set(), part.parts.schemaRefs))
+    .filter((suite) => suite.family || suite.date)
+    .map(describeSuite);
+  if (new Set(suites).size > 1) {
+    throw new IxbrlError(`The files name different taxonomy suites (${[...new Set(suites)].join(" and ")}).`);
+  }
+}
+
+function readFactElement(element, part, shared) {
+  const { kind, parts } = part;
+  const { contexts, units, continuations } = shared;
+  const nameAttribute = kind === "ixbrl" ? element.getAttribute("name") : null;
+  if (kind === "ixbrl" && !nameAttribute) return null;
+  if (element.getAttributeNS(NS_XSI, "nil") === "true" || element.getAttribute("xsi:nil") === "true") return null;
+
+  const { namespace, localName } =
+    kind === "ixbrl"
+      ? resolveQName(element, nameAttribute, "a concept name")
+      : { namespace: element.namespaceURI, localName: element.localName };
+
+  const contextRef = element.getAttribute("contextRef");
+  const context = contexts[contextRef];
+  if (!context) throw new IxbrlError(`The fact ${localName} refers to the context "${contextRef}", which the file does not define.`);
+
+  const numeric = kind === "ixbrl" ? isIx(element, "nonFraction") : element.hasAttribute("unitRef");
+  let value;
+  let unit = null;
+  let decimals;
+  if (numeric) {
+    const unitRef = element.getAttribute("unitRef");
+    unit = units[unitRef];
+    if (unit === undefined) throw new IxbrlError(`The fact ${localName} refers to the unit "${unitRef}", which the file does not define.`);
+    if (unit !== "GBP" && unit !== "pure" && unit !== "shares" && !unit.startsWith("divide:")) {
+      throw new IxbrlError(`The fact ${localName} is stated in ${unit}; diya-gl reads pounds sterling (GBP), shares and pure numbers.`);
+    }
+    const decimalsText = element.getAttribute("decimals");
+    decimals = decimalsText === null ? undefined : decimalsText === "INF" ? Infinity : Number(decimalsText);
+    value = kind === "ixbrl" ? nonFractionValue(element) : Number(textOf(element).trim());
+  } else {
+    value = kind === "ixbrl" ? nonNumericValue(element, continuations) : textOf(element).trim();
+  }
+
+  return {
+    namespace,
+    localName,
+    contextRef,
+    entity: context.entity,
+    period: context.period,
+    dimensions: context.dimensions,
+    unit,
+    decimals,
+    value,
+    hidden: insideHidden(element, parts.hiddenElements),
+  };
+}
+
+/**
+ * Read one or more Inline XBRL documents, or one XBRL instance, into facts.
+ * Several documents are one Inline XBRL Document Set: their contexts, units
+ * and continuations merge, facts with no target attribute are read, and the
+ * duplicate rule runs across the whole set.
+ * @param {Array<{name: string, bytes: Uint8Array|string}>} documents
+ * @returns {{kind: "ixbrl"|"xbrl", suite: {family: string|null, date: string|null, modules: string[]}, facts: Array<Object>, contexts: Object, units: Object, leftOutTargets: string[]}}
+ * @throws {IxbrlError} when the set cannot be read, with a message a customer reads
+ */
+export function readIxbrlSet(documents) {
+  if (!Array.isArray(documents) || documents.length === 0) throw new IxbrlError("There is no file to read.");
+  const many = documents.length > 1;
+
+  const parsed = documents.map(({ name, bytes: input }) => {
+    const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+    const kind = sniffIxbrl(bytes);
+    if (!kind) throw new IxbrlError(`${nameOf(name)} is not an Inline XBRL document or an XBRL instance.`);
+    if (many && kind === "xbrl") throw new IxbrlError(`${nameOf(name)} is an XBRL instance; an instance is one file.`);
+    const document = parseDocument(decodeUtf8(bytes));
+    return { name, kind, parts: kind === "ixbrl" ? inlineParts(document) : instanceParts(document) };
+  });
+  const kind = parsed[0].kind;
+
+  const { contexts, units, identifiers } = mergeResources(parsed);
+  if (many) checkSetAgrees(parsed, identifiers);
+
+  const continuations = new Map();
+  for (const part of parsed) for (const [id, element] of part.parts.continuations) continuations.set(id, element);
+
+  if (Object.keys(contexts).length === 0 && parsed.some((part) => part.parts.factElements.length > 0)) {
+    throw new IxbrlError(`This file is one part of a document set: its contexts are in another file. ${DROP_THE_SET}`);
   }
 
   const facts = [];
   const seen = new Map();
   const factNamespaces = new Set();
-  for (const element of parts.factElements) {
-    const nameAttribute = kind === "ixbrl" ? element.getAttribute("name") : null;
-    if (kind === "ixbrl" && !nameAttribute) continue;
-    if (element.getAttributeNS(NS_XSI, "nil") === "true" || element.getAttribute("xsi:nil") === "true") continue;
-
-    const { namespace, localName } =
-      kind === "ixbrl"
-        ? resolveQName(element, nameAttribute, "a concept name")
-        : { namespace: element.namespaceURI, localName: element.localName };
-    factNamespaces.add(namespace);
-
-    const contextRef = element.getAttribute("contextRef");
-    const context = contexts[contextRef];
-    if (!context) throw new IxbrlError(`The fact ${localName} refers to the context "${contextRef}", which the file does not define.`);
-
-    const numeric = kind === "ixbrl" ? isIx(element, "nonFraction") : element.hasAttribute("unitRef");
-    let value;
-    let unit = null;
-    let decimals;
-    if (numeric) {
-      const unitRef = element.getAttribute("unitRef");
-      unit = units[unitRef];
-      if (unit === undefined)
-        throw new IxbrlError(`The fact ${localName} refers to the unit "${unitRef}", which the file does not define.`);
-      if (unit !== "GBP" && unit !== "pure" && unit !== "shares" && !unit.startsWith("divide:")) {
-        throw new IxbrlError(`The fact ${localName} is stated in ${unit}; diya-gl reads pounds sterling (GBP), shares and pure numbers.`);
+  const leftOut = new Set();
+  let defaultTargetElements = 0;
+  const shared = { contexts, units, continuations };
+  for (const part of parsed) {
+    for (const element of part.parts.factElements) {
+      const target = kind === "ixbrl" ? element.getAttribute("target") : null;
+      if (target) {
+        leftOut.add(target);
+        continue;
       }
-      const decimalsText = element.getAttribute("decimals");
-      decimals = decimalsText === null ? undefined : decimalsText === "INF" ? Infinity : Number(decimalsText);
-      value = kind === "ixbrl" ? nonFractionValue(element) : Number(textOf(element).trim());
-    } else {
-      value = kind === "ixbrl" ? nonNumericValue(element, parts.continuations) : textOf(element).trim();
-    }
-
-    const fact = {
-      namespace,
-      localName,
-      contextRef,
-      entity: context.entity,
-      period: context.period,
-      dimensions: context.dimensions,
-      unit,
-      decimals,
-      value,
-      hidden: insideHidden(element, parts.hiddenElements),
-    };
-
-    const key = `${namespace}#${localName}|${contextKey(context)}|${unit ?? ""}`;
-    if (seen.has(key)) {
-      const first = seen.get(key);
-      if (first.value !== value) {
-        throw new IxbrlError(`The file states ${localName} twice for the same period with different values (${first.value} and ${value}).`);
+      const fact = readFactElement(element, part, shared);
+      if (!fact) continue;
+      defaultTargetElements += 1;
+      factNamespaces.add(fact.namespace);
+
+      const context = contexts[fact.contextRef];
+      const key = `${fact.namespace}#${fact.localName}|${contextKey(context)}|${fact.unit ?? ""}`;
+      if (seen.has(key)) {
+        const first = seen.get(key);
+        if (first.value !== fact.value) {
+          throw new IxbrlError(
+            `${many ? "The files state" : "The file states"} ${fact.localName} twice for the same period with different values (${first.value} and ${fact.value}).`,
+          );
+        }
+        first.hidden = first.hidden && fact.hidden;
+        continue;
       }
-      first.hidden = first.hidden && fact.hidden;
-      continue;
+      seen.set(key, fact);
+      facts.push(fact);
     }
-    seen.set(key, fact);
-    facts.push(fact);
+  }
+  if (defaultTargetElements === 0 && leftOut.size > 0) {
+    throw new IxbrlError(`The set has no facts for the default target; its facts are for the targets ${[...leftOut].join(", ")}.`);
   }
 
-  const suite = suiteOf(factNamespaces, parts.schemaRefs);
+  const suite = suiteOf(
+    factNamespaces,
+    parsed.flatMap((part) => part.parts.schemaRefs),
+  );
   checkSuite(suite);
 
-  return { kind, suite: { family: suite.family, date: suite.date, modules: [...suite.modules] }, facts, contexts, units };
+  return {
+    kind,
+    suite: { family: suite.family, date: suite.date, modules: [...suite.modules] },
+    facts: suite.family === "UK-GAAP" ? translateUkGaapFacts(facts) : facts,
+    contexts,
+    units,
+    leftOutTargets: [...leftOut],
+  };
+}
+
+/**
+ * Read an Inline XBRL document or an XBRL instance into facts.
+ * @param {Uint8Array|string} input - the document
+ * @returns {{kind: "ixbrl"|"xbrl", suite: {family: string|null, date: string|null, modules: string[]}, facts: Array<Object>, contexts: Object, units: Object, leftOutTargets: string[]}}
+ * @throws {IxbrlError} when the document cannot be read, with a message a customer reads
+ */
+export function readIxbrl(input) {
+  return readIxbrlSet([{ name: "", bytes: input }]);
+}
+
+const DATE_TEXT = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * Whether two reads of one report state the same entity, periods, numbers and
+ * dates. A Welsh package holds the report in two languages and Companies House
+ * rejects it when they differ.
+ * @param {Object} first - a read from readIxbrlSet
+ * @param {Object} second - a read from readIxbrlSet
+ * @param {string} firstLabel - what to call the first in the refusal
+ * @param {string} secondLabel
+ * @throws {IxbrlError} naming the first concept that differs
+ */
+export function checkSameReport(first, second, firstLabel, secondLabel) {
+  const entities = (read) => [...new Set(Object.values(read.contexts).map((context) => context.entity.identifier))].sort().join(",");
+  if (entities(first) !== entities(second)) {
+    throw new IxbrlError(`The ${firstLabel} and ${secondLabel} accounts are for different companies.`);
+  }
+  const periods = (read) =>
+    [
+      ...new Set(
+        Object.values(read.contexts)
+          .filter((context) => !Object.keys(context.dimensions).length)
+          .map((context) => periodKey(context.period)),
+      ),
+    ]
+      .sort()
+      .join(",");
+  if (periods(first) !== periods(second)) {
+    throw new IxbrlError(`The ${firstLabel} and ${secondLabel} accounts are for different periods.`);
+  }
+  const figures = (read) =>
+    new Map(
+      read.facts
+        .filter((fact) => fact.unit !== null || (typeof fact.value === "string" && DATE_TEXT.test(fact.value)))
+        .map((fact) => [
+          `${fact.namespace}#${fact.localName}|${contextKey({ entity: fact.entity, period: fact.period, dimensions: fact.dimensions })}|${fact.unit ?? ""}`,
+          fact,
+        ]),
+    );
+  const a = figures(first);
+  const b = figures(second);
+  for (const [key, fact] of a) {
+    if (!b.has(key) || b.get(key).value !== fact.value) {
+      throw new IxbrlError(`The ${firstLabel} and ${secondLabel} accounts differ at ${fact.localName}.`);
+    }
+  }
+  for (const [key, fact] of b) {
+    if (!a.has(key)) throw new IxbrlError(`The ${firstLabel} and ${secondLabel} accounts differ at ${fact.localName}.`);
+  }
 }

package/dist/app/lib/ixbrl-summary-book.js

@@ -18,7 +18,7 @@ import { buildNewBook } from "./diya-gl-new-book.js";
 import { diyaGlToScenario } from "./diya-gl-loader.js";
 import { calculateFromDiyaGl } from "./diya-gl-calculator.js";
 import { buildOpeningBalance, toV2OpeningBalances } from "./scenario-extractor.js";
-import { FIXED_ASSET_ACCOUNTS, FIXED_ASSET_CLASSES, IxbrlError, microProfitBeforeTax } from "./ixbrl-accounts.js";
+import { FIXED_ASSET_ACCOUNTS, FIXED_ASSET_CLASSES, IxbrlError, natureProfitBeforeTax } from "./ixbrl-accounts.js";
 
 // The register's class name for each class the accounts note uses.
 const REGISTER_CLASS = {
@@ -284,8 +284,6 @@ class LineWriter {
   }
 }
 
-const referenceFor = (concept) => `IXBRL-${concept}`;
-
 // The opening journal: the balance sheet at the start of the year.
 function openingJournal(writer, date, opening, assetClasses) {
   const reference = "OB-001";
@@ -323,11 +321,14 @@ function profitAndLossLines(profitAndLoss, { stockMovement, depreciation, tagged
   };
   add("TurnoverRevenue", "sales", "4000", profitAndLoss.turnover, "Turnover");
   add("OtherOperatingIncomeFormat2", "sales", "4003", profitAndLoss.otherOperatingIncome, "Other operating income");
+  add("OwnWorkCapitalised", "sales", "4003", profitAndLoss.ownWorkCapitalised, "Own work capitalised");
   const costOfSales = profitAndLoss.costOfSales !== undefined ? profitAndLoss.costOfSales : profitAndLoss.rawMaterialsConsumables;
   const costConcept = profitAndLoss.costOfSales !== undefined ? "CostSales" : "RawMaterialsConsumablesUsed";
   if (costOfSales !== undefined || stockMovement !== 0)
     add(costConcept, "purchases", "5000", n(costOfSales) + stockMovement, "Cost of sales");
+  add("OtherExternalCharges", "purchases", "5001", profitAndLoss.otherExternalCharges, "Other external charges");
   add("StaffCostsEmployeeBenefitsExpense", "purchases", "5101", profitAndLoss.staffCosts, "Staff costs");
+  add("InterestPayableSimilarChargesFinanceCosts", "purchases", "5803", profitAndLoss.interestPayable, "Interest payable");
   if (profitAndLoss.administrativeExpenses !== undefined) {
     // The engine works the gain or loss on disposal from the sale, so it comes out of the expenses the file nets it into.
     add(
@@ -354,9 +355,10 @@ function profitAndLossLines(profitAndLoss, { stockMovement, depreciation, tagged
 
 function plProfitBeforeTax(profitAndLoss) {
   if (profitAndLoss.profitBeforeTax !== undefined) return profitAndLoss.profitBeforeTax;
-  const micro = microProfitBeforeTax(profitAndLoss);
-  if (micro !== undefined) return micro + n(profitAndLoss.interestReceivable);
-  if (profitAndLoss.operatingProfit !== undefined) return profitAndLoss.operatingProfit + n(profitAndLoss.interestReceivable);
+  const micro = natureProfitBeforeTax(profitAndLoss);
+  const netInterest = n(profitAndLoss.interestReceivable) - n(profitAndLoss.interestPayable);
+  if (micro !== undefined) return micro + netInterest;
+  if (profitAndLoss.operatingProfit !== undefined) return profitAndLoss.operatingProfit + netInterest;
   if (profitAndLoss.profit !== undefined) return profitAndLoss.profit + n(profitAndLoss.tax);
   return undefined;
 }
@@ -372,6 +374,7 @@ function bookShell(accounts, period, taxData, extras) {
   book.documentInfo.entriesComment = extras.comment;
   if (accounts.principalActivity) book.entityInformation.organizationDescription = accounts.principalActivity;
   if (number) book.entityInformation["diya-gl:companyNumber"] = number;
+  book.accounts.purchases["5001"] = { "accountMainDescription": "Sub contractors", "diya-gl:column": "P" };
   book.accounts.purchases["5101"] = { "accountMainDescription": "Employee wages (non-PAYE)", "diya-gl:column": "S" };
   book.accounts.purchases["5501"] = { "accountMainDescription": "General admin", "diya-gl:column": "AA" };
   book.accounts.sales["4006"] = { accountMainDescription: "Fixed asset sales" };
@@ -428,6 +431,7 @@ async function buildYear(accounts, which, deps) {
   const period = current ? accounts.period : accounts.priorPeriod;
   const closingSheet = sheetOf(accounts.balanceSheet[current ? "currentYear" : "priorYear"]);
   const profitAndLoss = accounts.profitAndLoss?.[current ? "currentYear" : "priorYear"] ?? null;
+  const referenceFor = (concept, statedConcept = concept) => `IXBRL-${accounts.sourceConcepts?.[statedConcept] ?? concept}`;
   const taxData = await loadTaxData(period, deps);
   const additionsRate = taxData.depreciation?.[ADDITIONS_RATE_KEY] ?? 0;
 
@@ -496,6 +500,11 @@ async function buildYear(accounts, which, deps) {
     };
   };
   let posted = postsFor(0);
+  if (current && profitAndLoss?.changeInStocks !== undefined && Math.abs(profitAndLoss.changeInStocks - stockMovement) > 1) {
+    differences.push(
+      `${label}: the file states a change in stocks of ${profitAndLoss.changeInStocks} and its balance sheets a stock movement of ${stockMovement}.`,
+    );
+  }
 
   const build = (flow) => {
     // The prior year's opening balance sheet: the closing one worked back.
@@ -513,7 +522,7 @@ async function buildYear(accounts, which, deps) {
       writer.invoice(
         "purchases",
         period.end,
-        referenceFor("PropertyPlantEquipmentAdditions"),
+        referenceFor("PropertyPlantEquipmentAdditions", "AdditionsOtherThanThroughBusinessCombinationsPropertyPlantEquipment"),
         "5900",
         additionsAmount,
         "Fixed asset additions",

package/dist/app/lib/ixbrl-uk-gaap.js

@@ -0,0 +1,202 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2006-2026 DIY Accounting Limited
+//
+// ixbrl-uk-gaap.js — the translation from the old UK GAAP taxonomy (the
+// 2009-09-01 suite: uk-gaap, uk-bus and uk-direp) to the FRS 102 names that
+// ixbrl-accounts.js reads. The reader applies it once, after it has found the
+// suite, so the mapping, the checks and the summary book read FRS 102 names
+// only. A translated fact keeps `sourceConcept`, the UK GAAP name it came
+// from. A UK GAAP name this table does not hold keeps its own name and its
+// own namespace, and the mapping lists it as unmapped.
+
+export const UK_GAAP_SUITE_DATE = "2009-09-01";
+
+const NS_UK_GAAP = `http://www.xbrl.org/uk/gaap/core/${UK_GAAP_SUITE_DATE}`;
+const NS_UK_BUS = `http://www.xbrl.org/uk/cd/business/${UK_GAAP_SUITE_DATE}`;
+const NS_UK_DIREP = `http://www.xbrl.org/uk/reports/direp/${UK_GAAP_SUITE_DATE}`;
+
+// The namespaces a translated fact, dimension and member take. The mapping
+// matches by local name, so these only say the name is an FRS 102 one.
+const FRS_NAMESPACE = {
+  "uk-gaap": "http://xbrl.frc.org.uk/fr/2022-01-01/core",
+  "uk-bus": "http://xbrl.frc.org.uk/cd/2022-01-01/business",
+  "uk-direp": "http://xbrl.frc.org.uk/reports/2022-01-01/direp",
+};
+
+const MODULE_OF_NAMESPACE = { [NS_UK_GAAP]: "uk-gaap", [NS_UK_BUS]: "uk-bus", [NS_UK_DIREP]: "uk-direp" };
+
+const MATURITY = "MaturitiesOrExpirationPeriodsDimension";
+const EQUITY_CLASS = "EquityClassesDimension";
+const WITHIN = "WithinOneYear";
+const AFTER = "AfterOneYear";
+
+const row = (module, concept, to = concept, dimension, member) => ({
+  module,
+  concept,
+  to,
+  ...(dimension ? { dimension, member } : {}),
+});
+const gaap = (concept, to, dimension, member) => row("uk-gaap", concept, to, dimension, member);
+const bus = (concept, to) => row("uk-bus", concept, to);
+
+/**
+ * One row per UK GAAP name: the FRS 102 local name, and the dimension and
+ * member the translated fact gains (replacing the fact's own value for that
+ * dimension). `OtherOperatingIncome` is the one row whose target depends on
+ * the file: `toWithGrossProfit` when the file states `CostSales` or
+ * `GrossProfitLoss`, `to` otherwise.
+ */
+export const UK_GAAP_TO_FRS_102 = [
+  gaap("FixedAssets"),
+  gaap("TangibleFixedAssets", "PropertyPlantEquipment"),
+  gaap("TangibleFixedAssetsCostOrValuation", "PropertyPlantEquipmentGrossCost"),
+  gaap("TangibleFixedAssetsAdditions", "AdditionsOtherThanThroughBusinessCombinationsPropertyPlantEquipment"),
+  gaap("TangibleFixedAssetsDisposals", "DisposalsPropertyPlantEquipment"),
+  gaap("TangibleFixedAssetsDepreciation", "AccumulatedDepreciationImpairmentPropertyPlantEquipment"),
+  gaap("TangibleFixedAssetsDepreciationChargedInPeriod", "IncreaseFromDepreciationChargeForYearPropertyPlantEquipment"),
+  gaap("TangibleFixedAssetsDepreciationDecreaseIncreaseOnDisposals", "DisposalsDecreaseInDepreciationImpairmentPropertyPlantEquipment"),
+  gaap("StocksInventory", "TotalInventories"),
+  gaap("Debtors"),
+  gaap("DebtorsDueWithinOneYear", "Debtors", MATURITY, WITHIN),
+  gaap("PrepaymentsAccruedIncomeNotExpressedWithinCurrentAssetSubtotal"),
+  gaap("CashBankInHand", "CashBankOnHand"),
+  gaap("CurrentAssets"),
+  gaap("NetCurrentAssetsLiabilities"),
+  gaap("TotalAssetsLessCurrentLiabilities"),
+  gaap("CreditorsDueWithinOneYear", "Creditors", MATURITY, WITHIN),
+  gaap("CreditorsDueAfterOneYear", "Creditors", MATURITY, AFTER),
+  gaap("TradeCreditors", "TradeCreditorsTradePayables", MATURITY, WITHIN),
+  gaap("TradeCreditorsWithinOneYear", "TradeCreditorsTradePayables", MATURITY, WITHIN),
+  gaap("CorporationTax", "CorporationTaxPayable"),
+  gaap("CorporationTaxDueWithinOneYear", "CorporationTaxPayable"),
+  gaap("OtherCreditors", "OtherCreditors", MATURITY, WITHIN),
+  gaap("OtherCreditorsDueWithinOneYear", "OtherCreditors", MATURITY, WITHIN),
+  gaap("TaxationSocialSecurityDueWithinOneYear", "TaxationSocialSecurityPayable", MATURITY, WITHIN),
+  gaap("AccrualsDeferredIncomeWithinOneYear", "AccruedLiabilitiesNotExpressedWithinCreditorsSubtotal", MATURITY, WITHIN),
+  gaap("ProvisionsForLiabilitiesCharges", "ProvisionsForLiabilitiesBalanceSheetSubtotal"),
+  gaap("NetAssetsLiabilitiesIncludingPensionAssetLiability", "NetAssetsLiabilities"),
+  gaap("CalledUpShareCapital", "Equity", EQUITY_CLASS, "ShareCapital"),
+  gaap("ProfitLossAccountReserve", "Equity", EQUITY_CLASS, "RetainedEarningsAccumulatedLosses"),
+  gaap("RevaluationReserve", "Equity", EQUITY_CLASS, "RevaluationReserve"),
+  gaap("ShareholderFunds", "Equity"),
+  gaap("TurnoverGrossOperatingRevenue", "TurnoverRevenue"),
+  gaap("CostSales"),
+  gaap("GrossProfitLoss"),
+  gaap("AdministrativeExpenses"),
+  gaap("OperatingProfitLoss"),
+  gaap("ProfitLossOnOrdinaryActivitiesBeforeTax"),
+  gaap("ProfitLossOnOrdinaryActivitiesAfterTax"),
+  gaap("OtherInterestReceivableSimilarIncome", "OtherInterestReceivableSimilarIncomeFinanceIncome"),
+  gaap("InterestPayableSimilarCharges", "InterestPayableSimilarChargesFinanceCosts"),
+  gaap("TaxOnProfitOrLossOnOrdinaryActivities", "TaxTaxCreditOnProfitOrLossOnOrdinaryActivities"),
+  gaap("ProfitLossForPeriod", "ProfitLoss"),
+  { ...gaap("OtherOperatingIncome", "OtherOperatingIncomeFormat2"), toWithGrossProfit: "OtherOperatingIncomeFormat1" },
+  gaap("RawMaterialsConsumables", "RawMaterialsConsumablesUsed"),
+  gaap("OtherExternalCharges"),
+  gaap("OwnWorkCapitalised"),
+  gaap("WagesSalaries"),
+  gaap("SocialSecurityCosts"),
+  gaap("IncreaseDecreaseInStocksFinishedGoodsWorkInProgress", "IncreaseDecreaseInStocksInventoriesFinishedGoodsWorkInProgress"),
+  gaap("StaffCosts", "StaffCostsEmployeeBenefitsExpense"),
+  gaap("DepreciationOtherAmountsWrittenOffTangibleIntangibleFixedAssets", "DepreciationAmortisationImpairmentExpense"),
+  gaap("OtherOperatingChargesFormat2", "OtherOperatingExpensesFormat2"),
+  gaap("AverageNumberEmployeesDuringPeriod"),
+  gaap("ParValueShare"),
+  gaap("ShareCapitalAllottedCalledUpPaid", "ShareCapital"),
+  gaap("TradeDebtors", "TradeDebtorsTradeReceivables"),
+  gaap("OtherDebtors"),
+  gaap("IntangibleFixedAssets", "IntangibleAssets"),
+  gaap("BankBorrowingsOverdrafts"),
+  bus("UKCompaniesHouseRegisteredNumber"),
+  bus("EntityCurrentLegalOrRegisteredName"),
+  bus("BalanceSheetDate"),
+  bus("StartDateForPeriodCoveredByReport"),
+  bus("EndDateForPeriodCoveredByReport"),
+  bus("DescriptionPrincipalActivities"),
+  bus("NameEntityOfficer"),
+  bus("EntityDormant", "EntityDormantTruefalse"),
+  gaap("NameDirectorSigningAccounts", "DirectorSigningFinancialStatements"),
+  gaap("DateApprovalAccounts", "DateAuthorisationFinancialStatementsForIssue"),
+  gaap("NumberSharesAllotted", "NumberSharesIssuedFullyPaid"),
+  gaap("NominalValueSharesIssued", "NominalValueAllottedShareCapital"),
+];
+
+// The old suite names some dimensions and members the FRS 102 suite names differently. Members not listed keep their name.
+export const UK_GAAP_DIMENSIONS_TO_FRS_102 = {
+  MaturitiesDimension: { to: MATURITY, members: {} },
+  TangibleFixedAssetClassesDimension: {
+    to: "PropertyPlantEquipmentClassesDimension",
+    members: { FixturesFittings: "FurnitureFittings" },
+  },
+};
+
+const ROWS = new Map(UK_GAAP_TO_FRS_102.map((entry) => [`${entry.module}:${entry.concept}`, entry]));
+
+const localOf = (key) => key.slice(key.indexOf("#") + 1);
+
+function translatedDimensions(dimensions, entry, module) {
+  const out = {};
+  for (const [dimensionKey, memberKey] of Object.entries(dimensions)) {
+    const renamed = UK_GAAP_DIMENSIONS_TO_FRS_102[localOf(dimensionKey)];
+    if (renamed && MODULE_OF_NAMESPACE[dimensionKey.slice(0, dimensionKey.indexOf("#"))]) {
+      const member = localOf(memberKey);
+      out[`${FRS_NAMESPACE["uk-gaap"]}#${renamed.to}`] = `${FRS_NAMESPACE["uk-gaap"]}#${renamed.members[member] ?? member}`;
+    } else {
+      out[dimensionKey] = memberKey;
+    }
+  }
+  if (entry.dimension) {
+    out[`${FRS_NAMESPACE[module]}#${entry.dimension}`] = `${FRS_NAMESPACE[module]}#${entry.member}`;
+  }
+  return out;
+}
+
+function factKey(fact) {
+  const dimensions = Object.entries(fact.dimensions)
+    .sort(([a], [b]) => (a < b ? -1 : 1))
+    .map(([dimension, member]) => `${dimension}=${member}`)
+    .join(",");
+  const period = fact.period.instant ?? `${fact.period.startDate}/${fact.period.endDate}`;
+  return `${fact.namespace}#${fact.localName}|${fact.entity.scheme}|${fact.entity.identifier}|${period}|${dimensions}|${fact.unit ?? ""}`;
+}
+
+/**
+ * Translate the UK GAAP facts of a read into FRS 102 names.
+ * Two UK GAAP names that translate to the same fact (a total and the same
+ * total restated within one year) give one fact when they agree; when they
+ * differ the first is translated and the second keeps its UK GAAP name.
+ * @param {Array<Object>} facts - facts from the reader
+ * @returns {Array<Object>} the facts, translated where the table holds the name
+ */
+export function translateUkGaapFacts(facts) {
+  const grossProfitStated = facts.some(
+    (fact) => fact.namespace === NS_UK_GAAP && (fact.localName === "CostSales" || fact.localName === "GrossProfitLoss"),
+  );
+  const out = [];
+  const taken = new Map();
+  for (const fact of facts) {
+    const module = MODULE_OF_NAMESPACE[fact.namespace];
+    const entry = module ? ROWS.get(`${module}:${fact.localName}`) : undefined;
+    if (!entry) {
+      out.push(fact);
+      continue;
+    }
+    const localName = grossProfitStated && entry.toWithGrossProfit ? entry.toWithGrossProfit : entry.to;
+    const translated = {
+      ...fact,
+      namespace: FRS_NAMESPACE[module],
+      localName,
+      dimensions: translatedDimensions(fact.dimensions, entry, module),
+      sourceConcept: fact.localName,
+    };
+    const key = factKey(translated);
+    const earlier = taken.get(key);
+    if (earlier === undefined) {
+      taken.set(key, translated);
+      out.push(translated);
+    } else if (earlier.value !== translated.value) {
+      out.push(fact);
+    }
+  }
+  return out;
+}

package/dist/app/lib/provenance-data.js

@@ -12,7 +12,7 @@
 
 export const PROVENANCE_DATA = {
   formatVersion: "diya-gl/1",
-  engineVersion: "1.2.58+ad393516",
+  engineVersion: "1.2.60+602620de",
   taxDataHash: "51bdff60e993",
   reconciledCommit: "54e8731a91279975e61b1a232fbb67fda89515f0",
   templates: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diy-accounting-uk/diya-gl",
-  "version": "1.2.58",
+  "version": "1.2.60",
   "type": "module",
   "description": "Recalculate, read and write DIYA-GL books from the command line",
   "license": "Apache-2.0",