@diy-accounting-uk/diya-gl 1.2.13 → 1.2.15

package/dist/app/data/releases.json

@@ -571,6 +571,58 @@
           "scorecard": "101605 passed, 0 warnings, 0 failed"
         }
       }
+    },
+    {
+      "tag": "diya-gl-v1.2.13",
+      "date": "2026-09-14",
+      "formatVersion": "diya-gl/1",
+      "engineVersion": "1.2.13+f5b44cdf",
+      "taxDataHash": "4ecdbe985d22",
+      "reconciledCommit": "c910fdeefbe4f2f71ae9ec5f5d4a713783a1c0c7",
+      "templates": {
+        "bst": {
+          "hash": "0d003e10e00c",
+          "scorecard": "812 passed, 0 warnings, 0 failed"
+        },
+        "taxi": {
+          "hash": "1ff69654d64d",
+          "scorecard": "686 passed, 0 warnings, 0 failed"
+        },
+        "se": {
+          "hash": "15d3b753f7a4",
+          "scorecard": "7956 passed, 0 warnings, 0 failed"
+        },
+        "ltd": {
+          "hash": "caa14632083b",
+          "scorecard": "101605 passed, 0 warnings, 0 failed"
+        }
+      }
+    },
+    {
+      "tag": "diya-gl-v1.2.14",
+      "date": "2026-09-14",
+      "formatVersion": "diya-gl/1",
+      "engineVersion": "1.2.14+959e4a1d",
+      "taxDataHash": "4ecdbe985d22",
+      "reconciledCommit": "c910fdeefbe4f2f71ae9ec5f5d4a713783a1c0c7",
+      "templates": {
+        "bst": {
+          "hash": "0d003e10e00c",
+          "scorecard": "812 passed, 0 warnings, 0 failed"
+        },
+        "taxi": {
+          "hash": "1ff69654d64d",
+          "scorecard": "686 passed, 0 warnings, 0 failed"
+        },
+        "se": {
+          "hash": "94754ec2c44b",
+          "scorecard": "7962 passed, 0 warnings, 0 failed"
+        },
+        "ltd": {
+          "hash": "caa14632083b",
+          "scorecard": "101605 passed, 0 warnings, 0 failed"
+        }
+      }
     }
   ]
 }

package/dist/app/data/render-unrepresentable/se.json

@@ -462,5 +462,9 @@
   "section/journal-category-vat-netting/business-entertainment-memo-purchases-e/residue": "The journal-category-vat-netting report is a reconciliation table (categoryNettingLines, products/se.js) explaining how a gross journal figure nets into a statement cell; no page view is this table.",
   "section/journal-category-vat-netting/business-entertainment-memo-purchases-e/vat": "The journal-category-vat-netting report is a reconciliation table (categoryNettingLines, products/se.js) explaining how a gross journal figure nets into a statement cell; no page view is this table.",
   "section/accounting-profit-to-tax-profit-bridge/add-disallowable-expenses-added-back-box-46": "The page has no profit-bridge view; the bridge from accounting profit to tax profit is not printed anywhere on the books page.",
+  "cell/Fixedassets.xlsx!Schedule!M40": "The single asset pool car's own Schedule row (the third motor asset brought forward): its private use share, its P marker, its allowance and its written-down value. The Fixed assets view lists the brought-forward register by asset, without a cell key a row, and the AE1, AF1 and AG1 totals those rows sum into are on the same view under their own cell keys.",
+  "cell/Fixedassets.xlsx!Schedule!AD40": "The single asset pool car's own Schedule row (the third motor asset brought forward): its private use share, its P marker, its allowance and its written-down value. The Fixed assets view lists the brought-forward register by asset, without a cell key a row, and the AE1, AF1 and AG1 totals those rows sum into are on the same view under their own cell keys.",
+  "cell/Fixedassets.xlsx!Schedule!AE40": "The single asset pool car's own Schedule row (the third motor asset brought forward): its private use share, its P marker, its allowance and its written-down value. The Fixed assets view lists the brought-forward register by asset, without a cell key a row, and the AE1, AF1 and AG1 totals those rows sum into are on the same view under their own cell keys.",
+  "cell/Fixedassets.xlsx!Schedule!AG40": "The single asset pool car's own Schedule row (the third motor asset brought forward): its private use share, its P marker, its allowance and its written-down value. The Fixed assets view lists the brought-forward register by asset, without a cell key a row, and the AE1, AF1 and AG1 totals those rows sum into are on the same view under their own cell keys.",
   "section/accounting-profit-to-tax-profit-bridge/add-the-full-return-s-own-box-71-adjustment-for-change-of-accounting-practice": "The page has no profit-bridge view; the bridge from accounting profit to tax profit is not printed anywhere on the books page."
 }

package/dist/app/lib/anchors/se.js

@@ -31,6 +31,8 @@ import {
   ANNUAL_ADJUSTMENT_CELLS,
   GOODS_FOR_OWN_USE_CELL,
   SPECIAL_RATE_POOL_MARKER_COLUMN,
+  SINGLE_ASSET_POOL_MARKER_COLUMN,
+  PRIVATE_USE_COLUMN,
   SALESINVOICE_VAT_REG_CELL,
   SALESINVOICE_TELEPHONE_CELL,
   SALESINVOICE_PRODUCT_DETAILS_COLUMNS,
@@ -355,14 +357,25 @@ function isPayslipsInputCell(sheet, cellRef) {
   return isPayslipsMonthInputCell(sheet, cellRef);
 }
 
-// Schedule: an opening asset's description/cost/acc-dep/tax-wdv (C, E, F, O)
-// and its special rate pool marker (AB) on its existing-asset row, or an
+// Schedule: an opening asset's description/cost/acc-dep/tax-wdv (C, E, F, O),
+// its private use share (M), its special rate pool marker (AB) and its single
+// asset pool marker (AD) on its existing-asset row, or an
 // in-year disposal's date/proceeds (U, V) on that same row; a new purchase's
 // date/supplier/cost (B, C, E) on a New Plant & Machinery row. See
 // app/products/se.js's cellWrites() Schedule writer.
 const EXISTING_SCHEDULE_ROWS = new Set([...EXISTING_ASSET_ROWS.motor, ...EXISTING_ASSET_ROWS.computer]);
 const NEW_SCHEDULE_ROWS = new Set(NEW_PLANT_ROWS);
-const EXISTING_SCHEDULE_COLUMNS = ["C", "E", "F", "O", "U", "V", SPECIAL_RATE_POOL_MARKER_COLUMN];
+const EXISTING_SCHEDULE_COLUMNS = [
+  "C",
+  "E",
+  "F",
+  PRIVATE_USE_COLUMN,
+  "O",
+  "U",
+  "V",
+  SPECIAL_RATE_POOL_MARKER_COLUMN,
+  SINGLE_ASSET_POOL_MARKER_COLUMN,
+];
 const NEW_SCHEDULE_COLUMNS = ["B", "C", "E"];
 const HP_ROWS = new Set(HP_AGREEMENT_ROWS);
 const HP_COLUMNS = ["B", "C", "D", "E", "F", "G", "H", "L"];

package/dist/app/lib/calculators/se-derivations.js

@@ -479,7 +479,6 @@ const BOOK_STATED_ANNUAL_BOXES = [
 // year -- annualFieldsUnavailableForYear() below is what keeps a year that
 // no longer accepts a field from warning about it as if it still did.
 const NO_SOURCE_ANNUAL_BOXES = [
-  { box: "51", pick: 1 }, // allowances.capitalAllowanceSingleAssetPool (shared with box 50)
   { box: "53.1", pick: 0 }, // allowances.enhancedStructuredBuildingAllowance
   { box: "55", pick: 1 }, // allowances.businessPremisesRenovationAllowance (shared with enhancedCapitalAllowance)
   { box: "59", pick: 1 }, // adjustments.balancingChargeBpra (shared with balancingChargeOther)
@@ -541,9 +540,19 @@ export function buildSelfEmploymentAnnualSubmission(book, lines, taxData, option
   const root = {};
   const cellNumber = (cell) => (typeof seFull[cell] === "number" ? seFull[cell] : 0);
   setPath(root, primaryField(boxes, "49"), round2(seFull.D139));
-  setPath(root, primaryField(boxes, "50"), round2(seFull.D144));
+  // The printed boxes 50 and 51 hold every writing down allowance by rate,
+  // single asset pools included; the API files the single asset pools
+  // (Schedule AE and AF, the rows marked P) under their own field and the
+  // pooled balance under each rate's field.
+  const schedule = rawResults["Fixedassets.xlsx!Schedule"];
+  const singleAssetMain = typeof schedule?.AE1 === "number" ? schedule.AE1 : 0;
+  const singleAssetSpecial = typeof schedule?.AF1 === "number" ? schedule.AF1 : 0;
+  setPath(root, primaryField(boxes, "50"), round2(seFull.D144 - singleAssetMain));
   // Box 51 is the schedule's special rate pool (column AC, the rows marked S).
-  setPath(root, primaryField(boxes, "51"), round2(seFull.D147));
+  setPath(root, primaryField(boxes, "51"), round2(seFull.D147 - singleAssetSpecial));
+  if (singleAssetMain + singleAssetSpecial !== 0) {
+    setPath(root, fieldsOf(boxEntry(boxes, "50"))[1], round2(singleAssetMain + singleAssetSpecial));
+  }
   // HMRC's mapping files box 54 and box 55 under one field: the small pools
   // write-off the sheet computes at O144 and the charge-point figure the book
   // states at O139 both reach it.

package/dist/app/lib/calculators/se.js

@@ -440,9 +440,24 @@ function payrollMonths(payroll) {
  * That is what the sheet reports for a disposal with no tax value entered, so
  * it is what this reports too.
  */
-function scheduleRow({ cost, accDep = 0, taxWdv, depRate, aiaRate, wdaRate, specialRate = 0, pool, disposal }) {
+function scheduleRow({
+  cost,
+  accDep = 0,
+  taxWdv,
+  depRate,
+  aiaRate,
+  wdaRate,
+  specialRate = 0,
+  pool,
+  singleAssetPool = false,
+  privateUse = 0,
+  disposal,
+}) {
   const written = cost > 0;
   const isNewAsset = aiaRate !== undefined;
+  // The car rows multiply the allowances by (1-M), the business share; M is
+  // nil on every other row, so the factor is 1 there.
+  const businessShare = 1 - privateUse;
   const row = { E: cost, F: accDep, H: depRate };
   // A New asset block has no opening net book value column at all, so the row
   // shows nothing there and the depreciation charge below is not capped.
@@ -459,8 +474,8 @@ function scheduleRow({ cost, accDep = 0, taxWdv, depRate, aiaRate, wdaRate, spec
     row.O = taxWdv === undefined ? SHEET_BLANK : taxWdv;
     row.Q = SHEET_BLANK;
     const claimsWritingDown = typeof row.O === "number" && row.O > 0;
-    row.R = claimsWritingDown && !specialPool ? row.O * wdaRate : SHEET_BLANK;
-    row.AC = claimsWritingDown && specialPool ? row.O * specialRate : SHEET_BLANK;
+    row.R = claimsWritingDown && !specialPool ? row.O * wdaRate * businessShare : SHEET_BLANK;
+    row.AC = claimsWritingDown && specialPool ? row.O * specialRate * businessShare : SHEET_BLANK;
     row.S = claimsWritingDown ? row.O - sheetNumber(row.R) - sheetNumber(row.AC) : SHEET_BLANK;
   } else {
     row.O = SHEET_BLANK;
@@ -470,6 +485,16 @@ function scheduleRow({ cost, accDep = 0, taxWdv, depRate, aiaRate, wdaRate, spec
     row.AC = SHEET_BLANK;
     row.S = written ? cost - sheetNumber(row.Q) : SHEET_BLANK;
   }
+  // Column AD marks a row "P" for a single asset pool: AE and AF repeat its
+  // allowance by rate and AG its written-down value, so the small pools
+  // test can leave the row out. The row's own R, AC and S do not change.
+  row.AE = singleAssetPool && !specialPool ? sheetNumber(row.R) : SHEET_BLANK;
+  row.AF = singleAssetPool && specialPool ? sheetNumber(row.AC) : SHEET_BLANK;
+  row.AG = singleAssetPool ? sheetNumber(row.S) : SHEET_BLANK;
+  // AH and AI split the pooled written-down value by rate pool, single asset
+  // pool rows left out, so the small pools test can run on each pool alone.
+  row.AH = !singleAssetPool && !specialPool ? sheetNumber(row.S) : SHEET_BLANK;
+  row.AI = !singleAssetPool && specialPool ? sheetNumber(row.S) : SHEET_BLANK;
 
   row.V = disposal ? disposal.proceeds : SHEET_BLANK;
   row.W = disposal ? cost : SHEET_BLANK;
@@ -481,8 +506,8 @@ function scheduleRow({ cost, accDep = 0, taxWdv, depRate, aiaRate, wdaRate, spec
     row.Y = SHEET_ERROR;
     row.Z = SHEET_BLANK;
   } else {
-    row.Y = disposal.proceeds < row.S ? row.S - disposal.proceeds : SHEET_BLANK;
-    row.Z = disposal.proceeds > row.S ? disposal.proceeds - row.S : SHEET_BLANK;
+    row.Y = disposal.proceeds < row.S ? (row.S - disposal.proceeds) * businessShare : SHEET_BLANK;
+    row.Z = disposal.proceeds > row.S ? (disposal.proceeds - row.S) * businessShare : SHEET_BLANK;
   }
   return row;
 }
@@ -500,7 +525,29 @@ function carry(inputs, compute) {
   return inputs.some((value) => value === SHEET_ERROR) ? SHEET_ERROR : compute();
 }
 
-const SCHEDULE_TOTAL_COLUMNS = ["E", "F", "G", "I", "J", "K", "O", "Q", "R", "S", "V", "W", "X", "Y", "Z", "AC"];
+const SCHEDULE_TOTAL_COLUMNS = [
+  "E",
+  "F",
+  "G",
+  "I",
+  "J",
+  "K",
+  "O",
+  "Q",
+  "R",
+  "S",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z",
+  "AC",
+  "AE",
+  "AF",
+  "AG",
+  "AH",
+  "AI",
+];
 
 function scheduleTotals(rows) {
   const totals = {};
@@ -546,21 +593,34 @@ function buildSchedule(scenario, taxData, rate) {
   });
 
   const existingRows = [];
+  // The motor rows' own single asset pool cells, keyed by cell reference:
+  // the private use share the writer puts in M, the marker in AD, and the
+  // row's AE and AG, so a reconciliation that reads the marked row finds
+  // the same figures here.
+  const motorRowCells = {};
   for (const [category, block] of Object.entries(EXISTING_ASSET_BLOCKS)) {
-    for (const asset of assetsByCategory[category].slice(0, block.rows.length)) {
-      existingRows.push(
-        scheduleRow({
-          cost: asset.cost,
-          accDep: asset.acc_dep || 0,
-          taxWdv: asset.tax_wdv,
-          depRate: depreciation[block.rateKey] ?? 0,
-          wdaRate,
-          specialRate,
-          pool: asset.pool,
-          disposal: disposalByAsset.get(asset),
-        }),
-      );
-    }
+    assetsByCategory[category].slice(0, block.rows.length).forEach((asset, index) => {
+      const row = scheduleRow({
+        cost: asset.cost,
+        accDep: asset.acc_dep || 0,
+        taxWdv: asset.tax_wdv,
+        depRate: depreciation[block.rateKey] ?? 0,
+        wdaRate,
+        specialRate,
+        pool: asset.pool,
+        singleAssetPool: asset.single_asset_pool === true,
+        privateUse: category === "motor" ? asset.private_use || 0 : 0,
+        disposal: disposalByAsset.get(asset),
+      });
+      existingRows.push(row);
+      if (category === "motor") {
+        const rowNumber = block.rows[index];
+        motorRowCells[`M${rowNumber}`] = asset.private_use || 0;
+        motorRowCells[`AD${rowNumber}`] = asset.single_asset_pool ? "P" : SHEET_BLANK;
+        motorRowCells[`AE${rowNumber}`] = row.AE;
+        motorRowCells[`AG${rowNumber}`] = row.AG;
+      }
+    });
   }
 
   const newRows = capitalPurchases
@@ -569,7 +629,7 @@ function buildSchedule(scenario, taxData, rate) {
 
   const existing = scheduleTotals(existingRows);
   const additions = scheduleTotals(newRows);
-  return { existing, additions, totals: addScheduleTotals(existing, additions) };
+  return { existing, additions, totals: addScheduleTotals(existing, additions), motorRowCells };
 }
 
 // ── Hire purchase ──────────────────────────────────────────────────────────
@@ -960,7 +1020,7 @@ export function calculateSeCells(book, lines, taxData, scenario = {}) {
   const boxes32to45Total = sheetSum(Object.values(seFullDisallowable)) + pl.B34;
 
   // ── The fixed asset workbook ──
-  const scheduleCells = { E57: schedule.existing.E, E110: schedule.additions.E, AC4: admin.G6 };
+  const scheduleCells = { E57: schedule.existing.E, E110: schedule.additions.E, AC4: admin.G6, ...schedule.motorRowCells };
   for (const column of SCHEDULE_TOTAL_COLUMNS) scheduleCells[`${column}1`] = schedule.totals[column];
   const faReconciliation = {
     E11: schedule.additions.E,
@@ -1023,7 +1083,21 @@ export function calculateSeCells(book, lines, taxData, scenario = {}) {
   const scheduleQ = schedule.totals.Q;
   const scheduleR = schedule.totals.R;
   const scheduleAC = schedule.totals.AC;
-  const scheduleS = schedule.totals.S;
+  // The small pools write-off runs per rate pool over the pooled balance
+  // before this year's allowance, the single asset pool rows (AE, AF) left
+  // out: the main pool's is R1-AE1+AH1 and the special rate pool's
+  // AC1-AF1+AI1, and each pool under £1,000 writes off its own written-down
+  // value. The sheet reads
+  // IF((R1-AE1+AH1)<1000,AH1,0)+IF((AC1-AF1+AI1)<1000,AI1,0) on
+  // SE Full!O144 and SE Short!D85.
+  const scheduleAE = schedule.totals.AE;
+  const scheduleAF = schedule.totals.AF;
+  const scheduleAH = schedule.totals.AH;
+  const scheduleAI = schedule.totals.AI;
+  const smallPoolsWriteOff = carry(
+    [scheduleR, scheduleAC, scheduleAE, scheduleAF, scheduleAH, scheduleAI],
+    () => (scheduleR - scheduleAE + scheduleAH < 1000 ? scheduleAH : 0) + (scheduleAC - scheduleAF + scheduleAI < 1000 ? scheduleAI : 0),
+  );
   const scheduleY = schedule.totals.Y;
   const scheduleZ = schedule.totals.Z;
 
@@ -1073,7 +1147,7 @@ export function calculateSeCells(book, lines, taxData, scenario = {}) {
   seShort.O80 = carry([scheduleR, scheduleY, scheduleAC], () =>
     scheduleR + scheduleY + scheduleAC > 0 ? scheduleR + scheduleY + scheduleAC : 0,
   );
-  seShort.D85 = carry([scheduleR, scheduleS], () => (scheduleR + scheduleS < 1000 ? scheduleS : 0));
+  seShort.D85 = smallPoolsWriteOff;
   seShort.O85 = carry([scheduleZ], () => (scheduleZ > 0 ? scheduleZ : 0));
   seShort.D94 = goodsForOwnUse;
   const shortAllowances = [seShort.D71, seShort.O85, seShort.D94, seShort.O71, seShort.D80, seShort.D85, seShort.O80];
@@ -1155,7 +1229,7 @@ export function calculateSeCells(book, lines, taxData, scenario = {}) {
   seFull.D210 = stated(annualAdjustments.accountingAdjustment);
   // Box 50 carries the whole writing down allowance the schedule claims.
   seFull.D144 = carry([scheduleR], () => scheduleR);
-  seFull.O144 = carry([scheduleR, scheduleS], () => (scheduleR + scheduleS < 1000 ? scheduleS : 0));
+  seFull.O144 = smallPoolsWriteOff;
   seFull.O149 = scheduleY;
   seFull.O154 = carry([seFull.D139, seFull.D144, seFull.O144, seFull.O149], () =>
     sheetSum([seFull.D139, seFull.D144, seFull.D147, seFull.D152, seFull.D156, seFull.D160, seFull.O139, seFull.O144, seFull.O149]),

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

@@ -563,6 +563,30 @@ export function diyaGlToScenario(book, lines, product) {
         const opening = { category, description: asset.description, cost: asset.cost, acc_dep: asset.accumulatedDepreciation };
         if (asset.taxWrittenDownValue !== undefined) opening.tax_wdv = asset.taxWrittenDownValue;
         if (asset.capitalAllowancePool === "special") opening.pool = "special";
+        // A single asset pool is a fact the book states, never one the loader
+        // infers: private use puts an asset in its own pool (CAA 2001 s.206),
+        // so a private use share without the marker is a contradiction. The
+        // Schedule applies the private use share on the motor rows only, and
+        // the Company Schedule has neither column.
+        if (asset.singleAssetPool || asset.privateUseProportion > 0) {
+          if (product !== "se") {
+            throw new Error(
+              `Fixed asset ${asset.assetID} states a single asset pool or private use, which the Company Schedule has no column for`,
+            );
+          }
+          if (category !== "motor") {
+            throw new Error(
+              `Fixed asset ${asset.assetID} states a single asset pool or private use on class "${asset.class}", which the Schedule applies to motor vehicles only`,
+            );
+          }
+          if (!asset.singleAssetPool) {
+            throw new Error(
+              `Fixed asset ${asset.assetID} states privateUseProportion without singleAssetPool; a privately used asset is its own pool`,
+            );
+          }
+          opening.single_asset_pool = true;
+          if (asset.privateUseProportion > 0) opening.private_use = asset.privateUseProportion;
+        }
         return opening;
       });
     if (openingFixedAssets.length > 0) scenario.opening_fixed_assets = openingFixedAssets;

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

@@ -12,9 +12,9 @@
 
 export const PROVENANCE_DATA = {
   formatVersion: "diya-gl/1",
-  engineVersion: "1.2.13+f5b44cdf",
+  engineVersion: "1.2.15+27b706de",
   taxDataHash: "4ecdbe985d22",
-  reconciledCommit: "c910fdeefbe4f2f71ae9ec5f5d4a713783a1c0c7",
+  reconciledCommit: "54e8731a91279975e61b1a232fbb67fda89515f0",
   templates: {
     bst: {
       hash: "0d003e10e00c",
@@ -25,8 +25,8 @@ export const PROVENANCE_DATA = {
       scorecard: "686 passed, 0 warnings, 0 failed",
     },
     se: {
-      hash: "15d3b753f7a4",
-      scorecard: "7956 passed, 0 warnings, 0 failed",
+      hash: "3c88a8ba129b",
+      scorecard: "7966 passed, 0 warnings, 0 failed",
     },
     ltd: {
       hash: "caa14632083b",

package/dist/app/lib/scenario-extractor.js

@@ -1282,6 +1282,15 @@ export function formatScenarioToml(metadata, grouped, expected) {
         parts.push("# The special rate (6%) pool, SA103F box 51; the Schedule marks the row S in column AB.");
         parts.push(`pool = "special"`);
       }
+      if (asset.single_asset_pool) {
+        parts.push("# A single asset pool (private use or a short-life asset election): the Schedule marks the row P in");
+        parts.push("# column AD, and the API files its allowance as capitalAllowanceSingleAssetPool.");
+        parts.push("single_asset_pool = true");
+      }
+      if (asset.private_use !== undefined) {
+        parts.push("# The share of use that is private, which reduces the allowances (Schedule column M on the car rows).");
+        parts.push(`private_use = ${asset.private_use}`);
+      }
       parts.push("");
     }
   }

package/dist/app/lib/xlsx-exporter.js

@@ -1167,6 +1167,11 @@ const SCHEDULE_DISPOSAL_COLUMNS = { disposedDate: "U", disposalProceeds: "V" };
 // Column AB, "S" on a row whose tax written-down value sits in the special
 // rate pool (the Self Employed Schedule's AC column, SA103F box 51).
 const SCHEDULE_SPECIAL_RATE_POOL_MARKER = { column: "AB", value: "S" };
+// The single asset pool marker beside it, and the private use share the car
+// rows carry in column M. The Company Schedule has neither column, so its
+// register never sets either field.
+const SCHEDULE_SINGLE_ASSET_POOL_MARKER = { column: "AD", value: "P" };
+const SCHEDULE_PRIVATE_USE_COLUMN = "M";
 
 // The single-file products keep one Fixed Assets sheet inside the workbook
 // and their writers fill only its in-year addition block: BST the Plant &
@@ -1262,6 +1267,13 @@ async function fixedAssetRegisterFrom(set, product) {
       if (textAt(xml, `${SCHEDULE_SPECIAL_RATE_POOL_MARKER.column}${row}`, sharedStrings) === SCHEDULE_SPECIAL_RATE_POOL_MARKER.value) {
         asset.capitalAllowancePool = "special";
       }
+      if (textAt(xml, `${SCHEDULE_SINGLE_ASSET_POOL_MARKER.column}${row}`, sharedStrings) === SCHEDULE_SINGLE_ASSET_POOL_MARKER.value) {
+        asset.singleAssetPool = true;
+      }
+      if (assetClass === "motorVehicles") {
+        const privateUse = numberAt(xml, `${SCHEDULE_PRIVATE_USE_COLUMN}${row}`, sharedStrings);
+        if (privateUse > 0) asset.privateUseProportion = privateUse;
+      }
       assign(asset, "description", textAt(xml, `${SCHEDULE_ASSET_COLUMNS.description}${row}`, sharedStrings));
       assign(asset, "accumulatedDepreciation", numberAt(xml, `${SCHEDULE_ASSET_COLUMNS.accumulatedDepreciation}${row}`, sharedStrings));
       assign(asset, "taxWrittenDownValue", numberAt(xml, `${SCHEDULE_ASSET_COLUMNS.taxWrittenDownValue}${row}`, sharedStrings));

package/dist/app/products/se.js

@@ -277,6 +277,17 @@ export const NEW_PLANT_ROWS = [67, 68, 69, 70, 71];
 // AB38="S" and AC$4, S38 = IF(O38>0,O38-N(R38)-N(AC38)," "), AC1 = AC57+AC110.
 export const SPECIAL_RATE_POOL_MARKER_COLUMN = "AB";
 export const SPECIAL_RATE_POOL_MARKER = "S";
+// Column AD on an asset row: "P" keeps the row's tax written-down value in a
+// single asset pool. R, AC and S stay as they are; AE and AF repeat the
+// row's writing down allowance by rate and AG its written-down value, so the
+// small pools test on SE Full!O144 can leave the marked rows out. Column M
+// on the car rows (38 to 48, 91 to 101) is the private use share the R, AC,
+// Y and Z formulas multiply by (1-M). Verified against the template:
+// AE38 = IF(AND(AD38="P",AB38<>"S"),N(R38)," "), AF38 the same with AB38="S"
+// and N(AC38), AG38 = IF(AD38="P",N(S38)," "), AE1 = AE57+AE110.
+export const SINGLE_ASSET_POOL_MARKER_COLUMN = "AD";
+export const SINGLE_ASSET_POOL_MARKER = "P";
+export const PRIVATE_USE_COLUMN = "M";
 
 // Hire purchase agreements (Fixedassets.xlsx HPfinance sheet). Only two
 // rows are available for scenario agreements before the sheet's own
@@ -670,7 +681,7 @@ function composeWrites(scenario, targetStartYear) {
         skips.push(skipped("openingFixedAsset", assetEntry, why));
         continue;
       }
-      // Written left-to-right (C, then E, then F). setCellValue/setCellString
+      // Written left-to-right (C, E, F, M, O, AB, AD). setCellValue/setCellString
       // in spreadsheet-runner.js replaces a matched cell together with every
       // self-closing sibling up to the row's next already-closed cell -- an
       // earlier write onto a later (rightward) column silently deletes any
@@ -682,6 +693,9 @@ function composeWrites(scenario, targetStartYear) {
       if (asset.description) fa[`C${row}`] = asset.description;
       fa[`E${row}`] = asset.cost;
       if (asset.acc_dep) fa[`F${row}`] = asset.acc_dep;
+      // The private use share reads on the car rows alone; the loader has
+      // already refused it on any other class.
+      if (asset.private_use !== undefined && asset.category === "motor") fa[`${PRIVATE_USE_COLUMN}${row}`] = asset.private_use;
       // Column O is the written down TAX value brought forward, the figure
       // the capital allowance columns work from. The schedule computes a
       // disposal's balancing allowance as that value less the sale proceeds,
@@ -689,6 +703,7 @@ function composeWrites(scenario, targetStartYear) {
       // allowance block, and every figure downstream of it, in error.
       if (asset.tax_wdv) fa[`O${row}`] = asset.tax_wdv;
       if (asset.pool === "special") fa[`${SPECIAL_RATE_POOL_MARKER_COLUMN}${row}`] = SPECIAL_RATE_POOL_MARKER;
+      if (asset.single_asset_pool) fa[`${SINGLE_ASSET_POOL_MARKER_COLUMN}${row}`] = SINGLE_ASSET_POOL_MARKER;
       existingAssetRowsUsed[asset.category].push(row);
     }
   }
@@ -1262,7 +1277,40 @@ export function multiFileOptions() {
         // E57 and E110 are the schedule's own existing-asset and new-asset
         // cost subtotals; row 1 adds the two. Reading both lets the report
         // state the year's asset movement rather than one closing total.
-        Schedule: ["E1", "F1", "G1", "I1", "J1", "K1", "Q1", "R1", "S1", "V1", "W1", "X1", "Y1", "Z1", "AC1", "AC4", "E57", "E110"],
+        // AE1, AF1 and AG1 are the single asset pool totals; AH1 and AI1 the
+        // pooled written-down value by rate pool, which the small pools test
+        // now runs over per pool; M40, AD40, AE40 and AG40 are the fixture's
+        // marked car row (van 38, estate car 39, hatchback 40), read so its
+        // marker and private use share are proved on the row itself.
+        Schedule: [
+          "E1",
+          "F1",
+          "G1",
+          "I1",
+          "J1",
+          "K1",
+          "Q1",
+          "R1",
+          "S1",
+          "V1",
+          "W1",
+          "X1",
+          "Y1",
+          "Z1",
+          "AC1",
+          "AC4",
+          "AE1",
+          "AF1",
+          "AG1",
+          "AH1",
+          "AI1",
+          "E57",
+          "E110",
+          "M40",
+          "AD40",
+          "AE40",
+          "AG40",
+        ],
         FAreconciliation: ["E11", "E13", "E15", "K11", "K13", "K15"],
         // E2 is the long-term-creditors total for the "New Hire Purchase
         // Agreements" block (SUM(E8:E14)); I/J/K on rows 8 and 10 are the
@@ -1653,6 +1701,17 @@ const FIXED_ASSET_CELL_LABELS = {
     X1: "Accumulated depreciation on the assets sold in the year",
     Y1: "Balancing allowance on the disposals",
     Z1: "Balancing charge on the disposals",
+    AC1: "Total special rate writing down allowance claimed (the rows marked S in column AB)",
+    AC4: "Special rate writing down allowance rate, read from Admin",
+    AE1: "Single asset pool writing down allowance at the main rate (the rows marked P in column AD)",
+    AF1: "Single asset pool writing down allowance at the special rate (the rows marked P and S)",
+    AG1: "Single asset pool tax written down value carried forward",
+    AH1: "Main pool tax written down value carried forward, single asset pool rows left out",
+    AI1: "Special rate pool tax written down value carried forward (the rows marked S), single asset pool rows left out",
+    M40: "Private use share of the third motor vehicle brought forward",
+    AD40: "Single asset pool marker on the third motor vehicle brought forward (P)",
+    AE40: "Single asset pool main rate allowance on the third motor vehicle brought forward",
+    AG40: "Single asset pool tax written down value on the third motor vehicle brought forward",
     E57: "Cost of the assets owned at the start of the year",
     E110: "Cost of the assets bought during the year",
   },
@@ -1861,6 +1920,61 @@ export function profitBridge(results) {
   return buildProfitBridge(rows, `${TAX_SHEET}!E5`, num(tax.E5));
 }
 
+// ── The Schedule's capital allowance pools, from the fixture ───────────────
+
+// The opening tax written-down values that claim a writing down allowance in
+// one rate pool, each reduced to its business share: a privately used car
+// claims on (1 - M), which the Schedule applies on the car rows.
+function openingPoolAllowance(expected, pool) {
+  return (expected.opening_fixed_assets || [])
+    .filter((asset) => (asset.pool === "special") === (pool === "special"))
+    .reduce((total, asset) => total + (asset.tax_wdv || 0) * (1 - (asset.private_use || 0)), 0);
+}
+
+// The small pools write-off the way SE Full!O144 and SE Short!D85 state it:
+// IF((R1-AE1+AH1)<1000,AH1,0)+IF((AC1-AF1+AI1)<1000,AI1,0). Each rate pool
+// takes the £1,000 test on its own balance before this year's allowance, the
+// single asset pool rows left out, and writes off its own written-down value
+// when it passes.
+function smallPoolsWriteOff(schedule) {
+  const num = (v) => (typeof v === "number" ? v : 0);
+  const mainBalance = num(schedule.R1) - num(schedule.AE1) + num(schedule.AH1);
+  const specialBalance = num(schedule.AC1) - num(schedule.AF1) + num(schedule.AI1);
+  return (mainBalance < 1000 ? num(schedule.AH1) : 0) + (specialBalance < 1000 ? num(schedule.AI1) : 0);
+}
+
+// The same figures from the fixture's own assets, pool by pool. A pooled
+// opening asset puts its whole tax written-down value into its pool's test
+// (allowance plus written-down value is the value brought forward) and its
+// written-down balance after this year's allowance into the write-off; a
+// single asset pool row puts nothing into either; an asset bought in the
+// year puts its cost less the annual investment allowance into the main
+// pool's both.
+function fixtureSmallPools(expected, taxData, rate) {
+  const wda = taxData.capital_allowances.writing_down_allowance;
+  const specialWda = taxData.capital_allowances.writing_down_allowance_special || 0;
+  const aia = taxData.capital_allowances.annual_investment_allowance ?? 0;
+  const pools = { main: { balance: 0, writtenDown: 0 }, special: { balance: 0, writtenDown: 0 } };
+  for (const asset of expected.opening_fixed_assets || []) {
+    if (asset.single_asset_pool || !(asset.tax_wdv > 0)) continue;
+    const pool = asset.pool === "special" ? pools.special : pools.main;
+    const share = 1 - (asset.private_use || 0);
+    const allowance = asset.tax_wdv * (asset.pool === "special" ? specialWda : wda) * share;
+    pool.balance += asset.tax_wdv;
+    pool.writtenDown += asset.tax_wdv - allowance;
+  }
+  for (const transactions of Object.values(expected.purchases || {})) {
+    for (const tx of transactions) {
+      if (tx.code !== "fa") continue;
+      const cost = netOfVat(tx.amount, rate);
+      pools.main.balance += cost - cost * aia;
+      pools.main.writtenDown += cost - cost * aia;
+    }
+  }
+  const writeOff = (pool) => (pool.balance < 1000 ? pool.writtenDown : 0);
+  return { ...pools, writeOff: writeOff(pools.main) + writeOff(pools.special) };
+}
+
 // ── Journal category VAT netting ───────────────────────────────────────────
 
 // A journal row takes its own VAT off its own gross and rounds nothing
@@ -2543,10 +2657,13 @@ export function checkCompliance(results, expected, taxData, calculateExpectedTax
       check("SA103F box 49 annual investment allowance (D139) = Schedule Q1", num(seFull.D139), Math.max(0, num(returnSchedule.Q1)));
       check("SA103F box 50 capital allowances at 18% (D144) = Schedule R1", num(seFull.D144), num(returnSchedule.R1));
       check("SA103F box 51 capital allowances at 6% (D147) = Schedule AC1", num(seFull.D147), num(returnSchedule.AC1));
+      // The small pools write-off runs per rate pool over the pooled balance
+      // alone, the single asset pool rows (AE1, AF1) left out:
+      // O144 = IF((R1-AE1+AH1)<1000,AH1,0)+IF((AC1-AF1+AI1)<1000,AI1,0).
       check(
-        "SA103F box 55 100% and other enhanced capital allowances (O144) = Schedule S1 while the small pool balance is under £1,000",
+        "SA103F box 55 100% and other enhanced capital allowances (O144) = each pool's Schedule written-down value (AH1, AI1) while that pool's balance is under £1,000",
         num(seFull.O144),
-        num(returnSchedule.R1) + num(returnSchedule.S1) < 1000 ? num(returnSchedule.S1) : 0,
+        smallPoolsWriteOff(returnSchedule),
       );
       check("SA103F box 56 allowances on sale or cessation (O149) = Schedule Y1", num(seFull.O149), num(returnSchedule.Y1));
       check("SA103F box 59 balancing charge (O160) = Schedule Z1", num(seFull.O160), num(returnSchedule.Z1));
@@ -2561,20 +2678,27 @@ export function checkCompliance(results, expected, taxData, calculateExpectedTax
     // Each pool against the scenario's own assets: the main pool's boxes 50
     // and the special rate pool's box 51, each at its own year's rate, so an
     // asset marked for one pool that lands in the other moves both boxes.
+    // A privately used car claims its allowance on the business share alone
+    // (Schedule column M), single asset pool or not, so the anchor carries
+    // that factor row by row.
     if (taxData?.capital_allowances && expected.opening_fixed_assets) {
-      const poolTaxWdv = (pool) =>
-        expected.opening_fixed_assets
-          .filter((asset) => (asset.pool === "special") === (pool === "special"))
-          .reduce((total, asset) => total + (asset.tax_wdv || 0), 0);
       check(
-        "SA103F box 50 capital allowances at 18% (D144) = the scenario's opening tax written-down values at the year's writing down rate",
+        "SA103F box 50 capital allowances at 18% (D144) = the scenario's opening tax written-down values at the year's writing down rate, less private use",
         num(seFull.D144),
-        poolTaxWdv("main") * taxData.capital_allowances.writing_down_allowance,
+        openingPoolAllowance(expected, "main") * taxData.capital_allowances.writing_down_allowance,
       );
       check(
-        "SA103F box 51 capital allowances at 6% (D147) = the scenario's special rate pool tax written-down values at the year's special rate",
+        "SA103F box 51 capital allowances at 6% (D147) = the scenario's special rate pool tax written-down values at the year's special rate, less private use",
         num(seFull.D147),
-        poolTaxWdv("special") * (taxData.capital_allowances.writing_down_allowance_special || 0),
+        openingPoolAllowance(expected, "special") * (taxData.capital_allowances.writing_down_allowance_special || 0),
+      );
+      // The same rule the sheet applies, run over the fixture's own pools:
+      // a sheet whose R1, AC1, AE1, AF1, AH1 and AI1 agree with each other
+      // but not with the assets fails here.
+      check(
+        "SA103F box 55 100% and other enhanced capital allowances (O144) = the small pools write-off computed per pool from the scenario's own pooled assets",
+        num(seFull.O144),
+        fixtureSmallPools(expected, taxData, rate).writeOff,
       );
     }
 
@@ -2843,14 +2967,83 @@ export function checkCompliance(results, expected, taxData, calculateExpectedTax
         taxData.capital_allowances.writing_down_allowance_special || 0,
         0.0001,
       );
-      const specialPoolWdv = expected.opening_fixed_assets
-        .filter((asset) => asset.pool === "special")
-        .reduce((t, asset) => t + (asset.tax_wdv || 0), 0);
       check(
-        "Fixed assets: Schedule special rate pool allowance (AC1) = the scenario's special rate assets at the year's special rate",
+        "Fixed assets: Schedule special rate pool allowance (AC1) = the scenario's special rate assets at the year's special rate, less private use",
         sched.AC1 || 0,
-        specialPoolWdv * (taxData.capital_allowances.writing_down_allowance_special || 0),
+        openingPoolAllowance(expected, "special") * (taxData.capital_allowances.writing_down_allowance_special || 0),
+      );
+
+      // The pooled written-down values by rate pool (AH, AI), and each
+      // pool's balance before this year's allowance, which is what the small
+      // pools test runs over: the main pool's from the van and the year's
+      // additions, the special rate pool's from the estate car's 9,000
+      // alone, so a pool that counted the other's balance, or a single asset
+      // pool's, moves here.
+      const pools = fixtureSmallPools(expected, taxData, rate);
+      check(
+        "Fixed assets: Schedule main pool written down value (AH1) = the scenario's pooled main rate assets' tax written-down values less this year's allowance, plus additions less their annual investment allowance",
+        sched.AH1 || 0,
+        pools.main.writtenDown,
+      );
+      check(
+        "Fixed assets: Schedule special rate pool written down value (AI1) = the scenario's pooled special rate assets' tax written-down values less this year's allowance",
+        sched.AI1 || 0,
+        pools.special.writtenDown,
+      );
+      check(
+        "Fixed assets: main pool balance before this year's allowance (R1 - AE1 + AH1) = the scenario's pooled main rate assets' tax written-down values plus additions less their annual investment allowance",
+        num(sched.R1) - num(sched.AE1) + num(sched.AH1),
+        pools.main.balance,
       );
+      check(
+        "Fixed assets: special rate pool balance before this year's allowance (AC1 - AF1 + AI1) = the scenario's pooled special rate assets' tax written-down values",
+        num(sched.AC1) - num(sched.AF1) + num(sched.AI1),
+        pools.special.balance,
+      );
+
+      // The single asset pools (column AD marked P): each marked asset's
+      // allowance at its own rate on its business share, and its written-down
+      // value less that allowance, anchored on the fixture's assets.
+      const wda = taxData.capital_allowances.writing_down_allowance;
+      const specialWda = taxData.capital_allowances.writing_down_allowance_special || 0;
+      const singleAssets = expected.opening_fixed_assets.filter((asset) => asset.single_asset_pool);
+      const singleAllowance = (asset) =>
+        (asset.tax_wdv || 0) * (asset.pool === "special" ? specialWda : wda) * (1 - (asset.private_use || 0));
+      check(
+        "Fixed assets: Schedule single asset pool main rate allowance (AE1) = the scenario's single asset pool main rate assets at the year's rate, less private use",
+        sched.AE1 || 0,
+        singleAssets.filter((asset) => asset.pool !== "special").reduce((t, asset) => t + singleAllowance(asset), 0),
+      );
+      check(
+        "Fixed assets: Schedule single asset pool special rate allowance (AF1) = the scenario's single asset pool special rate assets at the year's special rate, less private use",
+        sched.AF1 || 0,
+        singleAssets.filter((asset) => asset.pool === "special").reduce((t, asset) => t + singleAllowance(asset), 0),
+      );
+      check(
+        "Fixed assets: Schedule single asset pool written down value (AG1) = the scenario's single asset pool assets' tax written-down values less this year's allowance",
+        sched.AG1 || 0,
+        singleAssets.reduce((t, asset) => t + (asset.tax_wdv || 0) - singleAllowance(asset), 0),
+      );
+      // The marker and the private use share on the row itself, for each
+      // motor asset the fixture declares, in the order the writer fills the
+      // block.
+      expected.opening_fixed_assets
+        .filter((asset) => asset.category === "motor")
+        .forEach((asset, index) => {
+          const row = EXISTING_ASSET_ROWS.motor[index];
+          if (row === undefined || !(`AD${row}` in sched)) return;
+          checkText(
+            `Fixed assets: Schedule single asset pool marker (AD${row}) = ${asset.single_asset_pool ? "P" : "blank"} for the scenario's motor asset ${index + 1}`,
+            typeof sched[`AD${row}`] === "string" ? sched[`AD${row}`].trim() : "",
+            asset.single_asset_pool ? SINGLE_ASSET_POOL_MARKER : "",
+          );
+          check(
+            `Fixed assets: Schedule private use share (M${row}) = the scenario's motor asset ${index + 1} private use`,
+            num(sched[`M${row}`]),
+            asset.private_use || 0,
+            0.0001,
+          );
+        });
     }
 
     // 3. P&L depreciation and disposal lines carry the Schedule's own

package/dist/web/spreadsheets.diyaccounting.co.uk/public/schema/diya-gl-book-v2.schema.json

@@ -483,6 +483,17 @@
             "default": "main",
             "description": "Which writing down pool the asset's tax written-down value sits in. special is the 6% pool (cars with higher CO2 emissions, integral features, long-life assets), SA103F box 51; the Self Employed Schedule marks the row S in column AB and claims the allowance in column AC. Absent means the main pool, box 50."
           },
+          "singleAssetPool": {
+            "type": "boolean",
+            "default": false,
+            "description": "The asset's tax written-down value is its own pool: an asset with private use (CAA 2001 s.206) or under a short-life asset election (ss.83-86). Its writing down allowance still prints in SA103F box 50 or 51 by rate, but the API files it as capitalAllowanceSingleAssetPool and the small pools allowance never applies to it. The Self Employed Schedule marks the row P in column AD and carries the allowance and the written-down value in columns AE to AG. Self Employed only."
+          },
+          "privateUseProportion": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 1,
+            "description": "The share of the asset's use that is not business use, which reduces its writing down and balancing allowances (the Self Employed Schedule's column M on the car rows). An asset with private use is a single asset pool, so singleAssetPool must be true whenever this is above nil. Self Employed motor vehicles only."
+          },
           "description": {
             "type": "string"
           },

package/package.json

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