@classytic/labs 0.6.0 → 0.7.0

package/dist/domains/accounting/household-accounts/model.mjs

@@ -0,0 +1,1133 @@
+import { defineLabModel } from "../../../model/define.mjs";
+import { formatMoney, formatNumber } from "../../../model/money.mjs";
+import { isRefusal, refuse } from "../../../model/index.mjs";
+import { z } from "zod";
+import { HOUSEHOLD_ADJUSTMENT_KINDS, HOUSEHOLD_PLACES, householdReceiptsPayments, solveHouseholdBudget, solveHouseholdStatements } from "@classytic/stage/finance/accounting";
+
+//#region src/domains/accounting/household-accounts/model.ts
+/**
+* Household accounts: a family's (or a small venture's) money, three ways (NCTB SSC Accounting, ch12, "Family and
+* self-employment"; formats.md). The lesson picks the mode:
+*
+*   budget              the month's income lines and planned spending lines, each sorted under its head (food,
+*                       housing, savings...). Totals build as lines land; the budget shows a surplus or a deficit,
+*                       each head's share of the spending, and, when the lesson gives actuals, plan against actual.
+*   receipts-payments   the period's cash: opening cash, then each cash event placed on the receipts or the
+*                       payments side; the closing cash (Balance c/d) balances it.
+*   income-expenditure  the same cash events plus a few adjustments, placed into the income and expenditure statement
+*                       (only this period's income and expenses: an asset bought goes to the statement of financial
+*                       position, not to expenditure) and the family's statement of financial position; the surplus
+*                       or deficit is carried to the family fund and the position balances.
+*
+* Every figure is stage's (`solveHouseholdBudget`, `householdReceiptsPayments`, `solveHouseholdStatements`); this
+* model names lines, selects what the learner has placed so far, and words feedback. Every heading and sentence is a
+* prop, so a Bangla lesson passes its own; the lab's own buttons stay English.
+*/
+const HEADING = {
+	budget: "Family budget",
+	budgetIncome: "Income",
+	budgetExpense: "Spending",
+	incomeParticulars: "Source of income",
+	expenseParticulars: "Item of spending",
+	expected: "Expected",
+	planned: "Planned",
+	total: "Total",
+	share: "%",
+	totalIncome: "Total income",
+	totalSpending: "Total spending",
+	surplus: "Surplus",
+	deficit: "Deficit",
+	compare: "Plan and actual",
+	head: "Head",
+	plan: "Plan",
+	actual: "Actual",
+	over: "Over / under",
+	item: "Budget line",
+	receiptsPayments: "Receipts and payments account",
+	receipts: "Receipts",
+	payments: "Payments",
+	debit: "Dr",
+	credit: "Cr",
+	openingBalance: "Balance b/d (opening cash)",
+	closingBalance: "Balance c/d (closing cash)",
+	event: "Cash event",
+	incomeExpenditure: "Income and expenditure statement",
+	particulars: "Particulars",
+	income: "Income",
+	expenditure: "Expenditure",
+	totalExpenditure: "Total expenditure",
+	position: "Statement of financial position",
+	assets: "Assets",
+	liabilitiesAndFund: "Liabilities and family fund",
+	asset: "Asset",
+	liability: "Liability",
+	cash: "Cash in hand",
+	familyFund: "Family fund",
+	totalAssets: "Total assets",
+	totalLiabilitiesAndFund: "Total liabilities and family fund",
+	add: "Add:",
+	less: "Less:",
+	adjustment: "Adjustment",
+	/** The money columns' heading; left empty, the currency ("$", "Tk"). */
+	money: ""
+};
+const PHRASE = {
+	headQuestion: "Which head does it go under?",
+	sideQuestion: "Which side of the account?",
+	placeQuestion: "Where does it go?",
+	twice: "An adjustment goes in two places: place both.",
+	firstPlaced: "One is in. Where does the other one go?",
+	landed: "In:",
+	surplusMeans: "Income is more than spending: the family can save the rest.",
+	deficitMeans: "Spending is more than income: cut a head, or the family must borrow.",
+	evenMeans: "Income and spending are equal: the budget balances.",
+	overQuestion: "Which head went furthest over its plan?",
+	none: "None went over",
+	whyOver: "Read the over / under column: the biggest amount over the plan is the answer.",
+	overFound: "Plan against actual shows where the money really went.",
+	closingQuestion: "Where does the closing cash (Balance c/d) go?",
+	whyClosing: "Receipts are always the heavier side: write the closing cash on the payments side so both sides total the same.",
+	rpBalanced: "Both sides total the same.",
+	whyReceipt: "Money came in: the receipts side.",
+	whyPayment: "Money went out: the payments side.",
+	whyIncome: "Money the family earned this period: income.",
+	whyExpense: "Used up this period: an expense.",
+	whyAsset: "Bought or saved to keep: an asset in the statement of financial position, not expenditure.",
+	whyLoanReceived: "Borrowed money must be paid back: a liability, not income.",
+	whyLoanRepaid: "Paying back a loan makes the liability smaller; it is not an expense.",
+	whyOutstanding: "This period's expense, not yet paid: add it to the expense, and show it owed as a liability.",
+	whyPrepaid: "Paid now for the next period: take it off the expense, and show it as an asset.",
+	whyAccrued: "Earned this period, not yet received: add it to income, and show it as an asset.",
+	whyAdvance: "Received now for the next period: take it off income, and show it as a liability.",
+	outstanding: "outstanding",
+	outstandingLine: "{name} outstanding",
+	prepaid: "paid in advance",
+	prepaidLine: "{name} paid in advance",
+	accrued: "receivable",
+	accruedLine: "{name} receivable",
+	advance: "received in advance",
+	advanceLine: "{name} received in advance",
+	fundNote: "Family fund = opening assets − opening liabilities",
+	surplusLine: "Surplus",
+	deficitLine: "Deficit",
+	balances: "Total assets equal liabilities plus the family fund."
+};
+const DEFAULT_HEADS = [
+	{
+		id: "food",
+		name: "Food",
+		why: "What the family eats: the food head."
+	},
+	{
+		id: "housing",
+		name: "Housing",
+		why: "Keeping a roof over the family: the housing head."
+	},
+	{
+		id: "utilities",
+		name: "Utilities",
+		why: "Power, water, gas and the connection: the utilities head."
+	},
+	{
+		id: "education",
+		name: "Education",
+		why: "Learning costs: the education head."
+	},
+	{
+		id: "health",
+		name: "Health",
+		why: "Staying well: the health head."
+	},
+	{
+		id: "transport",
+		name: "Transport",
+		why: "Getting about: the transport head."
+	},
+	{
+		id: "savings",
+		name: "Savings",
+		why: "Put away for the future: the savings head. A budget plans savings like a cost."
+	}
+];
+const DEFAULT_ITEMS = [
+	{
+		id: "salary",
+		name: "Salary",
+		flow: "income",
+		amount: 3200
+	},
+	{
+		id: "tutoring",
+		name: "Weekend tutoring",
+		flow: "income",
+		amount: 400
+	},
+	{
+		id: "groceries",
+		name: "Groceries",
+		flow: "expense",
+		head: "food",
+		amount: 650
+	},
+	{
+		id: "rent",
+		name: "Flat rent",
+		flow: "expense",
+		head: "housing",
+		amount: 1100
+	},
+	{
+		id: "electricity",
+		name: "Electricity and gas",
+		flow: "expense",
+		head: "utilities",
+		amount: 180
+	},
+	{
+		id: "school",
+		name: "School fees",
+		flow: "expense",
+		head: "education",
+		amount: 300
+	},
+	{
+		id: "fresh",
+		name: "Fish, eggs and vegetables",
+		flow: "expense",
+		head: "food",
+		amount: 250
+	},
+	{
+		id: "internet",
+		name: "Internet and phone",
+		flow: "expense",
+		head: "utilities",
+		amount: 70
+	},
+	{
+		id: "medicine",
+		name: "Doctor and medicine",
+		flow: "expense",
+		head: "health",
+		amount: 120
+	},
+	{
+		id: "bus",
+		name: "Bus passes",
+		flow: "expense",
+		head: "transport",
+		amount: 150
+	},
+	{
+		id: "books",
+		name: "Books and stationery",
+		flow: "expense",
+		head: "education",
+		amount: 60
+	},
+	{
+		id: "deposit",
+		name: "Savings scheme deposit",
+		flow: "expense",
+		head: "savings",
+		amount: 400
+	}
+];
+const DEFAULT_EVENTS = [
+	{
+		id: "salary",
+		name: "Salary received",
+		side: "receipt",
+		amount: 3e4,
+		place: "income"
+	},
+	{
+		id: "tutoring",
+		name: "Tutoring fees received",
+		side: "receipt",
+		amount: 4800,
+		place: "income"
+	},
+	{
+		id: "rent",
+		name: "Flat rent paid",
+		side: "payment",
+		amount: 12e3,
+		place: "expense"
+	},
+	{
+		id: "food",
+		name: "Food bought",
+		side: "payment",
+		amount: 8400,
+		place: "expense"
+	},
+	{
+		id: "laptop",
+		name: "Laptop bought",
+		side: "payment",
+		amount: 1500,
+		place: "asset"
+	},
+	{
+		id: "utilities",
+		name: "Electricity, gas and water bills paid",
+		side: "payment",
+		amount: 2100,
+		place: "expense"
+	},
+	{
+		id: "school",
+		name: "School fees paid",
+		side: "payment",
+		amount: 3e3,
+		place: "expense"
+	},
+	{
+		id: "table",
+		name: "Dining table bought",
+		side: "payment",
+		amount: 800,
+		place: "asset",
+		of: "furniture"
+	},
+	{
+		id: "medical",
+		name: "Doctor and medicine",
+		side: "payment",
+		amount: 900,
+		place: "expense"
+	},
+	{
+		id: "deposit",
+		name: "Savings scheme deposit",
+		side: "payment",
+		amount: 2400,
+		place: "asset"
+	}
+];
+const DEFAULT_ADJUSTMENTS = [{
+	id: "utilities-due",
+	kind: "outstanding-expense",
+	event: "utilities",
+	amount: 300,
+	text: "The last electricity bill, $300, is still unpaid."
+}, {
+	id: "rent-ahead",
+	kind: "prepaid-expense",
+	event: "rent",
+	amount: 1e3,
+	text: "$1,000 of the rent paid is for January next year."
+}];
+const DEFAULT_OPENING_ASSETS = [{
+	id: "furniture",
+	name: "Furniture",
+	amount: 6e3
+}];
+const text = (max = 240) => z.string().trim().min(1).max(max);
+const id = z.string().trim().min(1).max(40).regex(/^[a-z0-9-]+$/, "ids are lower-case words joined by hyphens");
+const money = z.number().finite().positive().max(0xe8d4a51000);
+const partial = (keys) => z.object(Object.fromEntries(keys.map((k) => [k, text().optional()])));
+const headSchema = z.object({
+	id,
+	name: text(40),
+	why: text().optional()
+});
+const itemSchema = z.object({
+	id,
+	name: text(80),
+	flow: z.enum(["income", "expense"]),
+	head: id.optional(),
+	amount: money,
+	actual: z.number().finite().min(0).max(0xe8d4a51000).optional(),
+	why: text().optional()
+});
+const eventSchema = z.object({
+	id,
+	name: text(80),
+	side: z.enum(["receipt", "payment"]),
+	amount: money,
+	place: z.enum(HOUSEHOLD_PLACES).optional(),
+	of: id.optional(),
+	why: text().optional()
+});
+const adjustmentSchema = z.object({
+	id,
+	kind: z.enum(HOUSEHOLD_ADJUSTMENT_KINDS),
+	amount: money,
+	event: id.optional(),
+	name: text(80).optional(),
+	text: text().optional(),
+	why: text().optional()
+});
+const balanceSchema = z.object({
+	id,
+	name: text(80),
+	amount: money
+});
+const MODES = [
+	"budget",
+	"receipts-payments",
+	"income-expenditure"
+];
+const householdAccountsParamsSchema = z.object({
+	mode: z.enum(MODES).default("budget").describe("budget: sort budget lines under income and spending heads | receipts-payments: place cash events on the receipts or payments side | income-expenditure: place cash events and adjustments into the income and expenditure statement and the statement of financial position"),
+	household: text(80).default("The Hill family").describe("the family or venture, printed over each statement"),
+	period: text(80).optional().describe("the date line: a budget's month (\"Budget for March\"), or \"For the year ended 31 December 2025\" for the accounts"),
+	asAt: text(80).optional().describe("the date line of the statement of financial position, e.g. \"31 December 2025\""),
+	currency: z.string().min(1).max(6).default("$").describe("printed before amounts; Tk groups in lakhs"),
+	heads: z.array(headSchema).min(1).max(9).optional().describe("budget: the spending heads the learner sorts into, { id, name, why? } (why: the feedback for a line under it). Left out: food, housing, utilities, education, health, transport, savings"),
+	items: z.array(itemSchema).min(2).max(24).optional().describe("budget: the lines in the order the learner meets them, { id, name, flow: income | expense, head? (expense: a head id), amount (planned), actual? (on every line or none: adds plan against actual), why? }. Left out: a default month"),
+	openingCash: z.number().finite().min(0).max(0xe8d4a51000).default(1200).describe("receipts-payments and income-expenditure: cash in hand at the start (Balance b/d)"),
+	openingAssets: z.array(balanceSchema).max(8).optional().describe("income-expenditure: non-cash assets at the start, { id, name, amount } (house, furniture). With opening cash and opening liabilities they make the opening family fund. Left out with the default events: furniture 6,000; with authored events: none"),
+	openingLiabilities: z.array(balanceSchema).max(8).default([]).describe("income-expenditure: what the family owed at the start, { id, name, amount } (a home loan)"),
+	events: z.array(eventSchema).min(1).max(20).optional().describe("receipts-payments and income-expenditure: the cash events in order, { id, name, side: receipt | payment, amount, place?, of?, why? }. place (income-expenditure, required there): a receipt is income or liability (a loan received); a payment is expense, asset (bought, or a deposit) or liability (a loan repaid, with of). of: an opening asset this payment adds to, or the opening liability it repays. Left out: a default year"),
+	adjustments: z.array(adjustmentSchema).max(6).optional().describe("income-expenditure: { id, kind, amount, event?, name?, text?, why? }. kind: outstanding-expense (an expense still owed; event: the expense it adds to, or name for its own line) | prepaid-expense (event: the expense it comes off) | accrued-income (event or name) | income-in-advance (event: the income it comes off). text: the adjustment as the question words it. Left out with the default events: two; with authored events: none"),
+	headings: partial(Object.keys(HEADING)).default({}).describe("statement, column and total names as the book prints them: budget, budgetIncome, budgetExpense, incomeParticulars, expenseParticulars, expected, planned, total, share, totalIncome, totalSpending, surplus, deficit, compare, head, plan, actual, over, receiptsPayments, receipts, payments, openingBalance, closingBalance, incomeExpenditure, particulars, income, expenditure, totalExpenditure, position, assets, liabilitiesAndFund, asset, liability, cash, familyFund, totalAssets, totalLiabilitiesAndFund, add, less, item, event, adjustment, debit, credit, money (the money columns, e.g. টাকা; default the currency)"),
+	phrases: partial(Object.keys(PHRASE)).default({}).describe("questions, line names ({name} is the event) and feedback: headQuestion, sideQuestion, placeQuestion, twice, firstPlaced, landed, surplusMeans, deficitMeans, overQuestion, none, closingQuestion, whyClosing, whyReceipt, whyPayment, whyIncome, whyExpense, whyAsset, whyLoanReceived, whyLoanRepaid, whyOutstanding, whyPrepaid, whyAccrued, whyAdvance, outstandingLine, prepaidLine, accruedLine, advanceLine, outstanding, prepaid, accrued, advance, fundNote, surplusLine, deficitLine, balances, …")
+});
+const fill = (template, values) => template.replace(/\{(\w+)\}/g, (all, key) => values[key] ?? all);
+const ADJUSTMENT_WORDS = {
+	"outstanding-expense": [
+		"outstandingLine",
+		"outstanding",
+		"whyOutstanding"
+	],
+	"prepaid-expense": [
+		"prepaidLine",
+		"prepaid",
+		"whyPrepaid"
+	],
+	"accrued-income": [
+		"accruedLine",
+		"accrued",
+		"whyAccrued"
+	],
+	"income-in-advance": [
+		"advanceLine",
+		"advance",
+		"whyAdvance"
+	]
+};
+const PLACE_HEADING = {
+	income: "income",
+	expense: "expenditure",
+	asset: "asset",
+	liability: "liability"
+};
+function eventWhy(phrases, e, mode) {
+	if (e.why) return e.why;
+	if (mode === "receipts-payments") return e.side === "receipt" ? phrases.whyReceipt : phrases.whyPayment;
+	switch (e.place) {
+		case "income": return phrases.whyIncome;
+		case "expense": return phrases.whyExpense;
+		case "asset": return phrases.whyAsset;
+		default: return e.side === "receipt" ? phrases.whyLoanReceived : phrases.whyLoanRepaid;
+	}
+}
+/** The card in hand: the first with a place still open. */
+function current(s, st) {
+	return s.cards.find((c) => c.answers.some((a) => !st.placed.includes(`${c.id}:${a}`)));
+}
+/** Tap a place for the card in hand: a right one lands one of its open answers; a wrong one is marked. */
+function attempt(s, st, pick) {
+	const card = current(s, st);
+	if (!card) return st;
+	if (st.wrong && st.pick === pick) return st;
+	const hit = card.answers.find((a) => a === pick && !st.placed.includes(`${card.id}:${a}`));
+	if (hit) return {
+		...st,
+		placed: [...st.placed, `${card.id}:${hit}`],
+		pick: "",
+		wrong: false
+	};
+	return {
+		...st,
+		pick,
+		wrong: true,
+		misses: {
+			...st.misses,
+			[card.id]: (st.misses[card.id] ?? 0) + 1
+		}
+	};
+}
+const pct = (v) => `${formatNumber(v, { decimals: 0 })}%`;
+/** The budget's income and spending tables as far as the learner has sorted them. */
+function budgetTables(s, st) {
+	const placed = new Set(st.placed);
+	const last = st.placed.at(-1);
+	const h = s.headings;
+	const done = (i) => placed.has(`${i.id}:${i.flow === "income" ? "income" : i.head}`);
+	const keyOf = (i) => `${i.id}:${i.flow === "income" ? "income" : i.head}`;
+	const incomeItems = s.items.filter((i) => i.flow === "income");
+	const income = incomeItems.filter(done).map((i) => ({
+		key: i.id,
+		kind: "line",
+		label: i.name,
+		amount: i.amount,
+		col: 1,
+		less: false,
+		fresh: keyOf(i) === last
+	}));
+	const incomeDone = incomeItems.every(done);
+	if (incomeDone) income.push({
+		key: "income:total",
+		kind: "total",
+		label: h.totalIncome,
+		amount: s.budget.income,
+		col: 2,
+		less: false,
+		fresh: false
+	});
+	const spending = [];
+	const expenseItems = s.items.filter((i) => i.flow === "expense");
+	const allDone = s.items.every(done);
+	for (const head of s.heads) {
+		const lines = expenseItems.filter((i) => i.head === head.id);
+		const seen = lines.filter(done);
+		if (seen.length === 0) continue;
+		spending.push({
+			key: `${head.id}:heading`,
+			kind: "heading",
+			label: head.name,
+			col: 1,
+			less: false,
+			fresh: false
+		});
+		for (const i of seen) spending.push({
+			key: i.id,
+			kind: "line",
+			label: i.name,
+			amount: i.amount,
+			col: 1,
+			less: false,
+			fresh: keyOf(i) === last
+		});
+		if (seen.length === lines.length) {
+			const sum = s.budget.heads.find((x) => x.head === head.id);
+			spending.push({
+				key: `${head.id}:total`,
+				kind: "total",
+				label: "",
+				amount: sum.planned,
+				col: 2,
+				less: false,
+				fresh: false,
+				...allDone ? { share: pct(sum.share) } : {}
+			});
+		}
+	}
+	if (expenseItems.every(done)) spending.push({
+		key: "spending:total",
+		kind: "result",
+		label: h.totalSpending,
+		amount: s.budget.expense,
+		col: 2,
+		less: false,
+		fresh: false,
+		...allDone ? { share: pct(100) } : {}
+	});
+	return {
+		income,
+		spending,
+		incomeDone,
+		allDone
+	};
+}
+/** The receipts and payments account as far as the learner has placed it. */
+function rpSides(s, st) {
+	const placed = new Set(st.placed);
+	const last = st.placed.at(-1);
+	const h = s.headings;
+	const receipts = [{
+		key: "bd",
+		label: h.openingBalance,
+		amount: s.openingCash,
+		kind: "bd",
+		fresh: false
+	}];
+	const payments = [];
+	for (const e of s.events) {
+		const key = `${e.id}:${e.side}`;
+		if (!placed.has(key)) continue;
+		(e.side === "receipt" ? receipts : payments).push({
+			key: e.id,
+			label: e.name,
+			amount: e.amount,
+			kind: "line",
+			fresh: key === last
+		});
+	}
+	const balanced = st.closing === "payment" && current(s, st) === undefined;
+	if (balanced && s.book.carriedDown) payments.push({
+		key: "cd",
+		label: h.closingBalance,
+		amount: s.book.carriedDown.amount,
+		kind: "cd",
+		fresh: true
+	});
+	return {
+		receipts,
+		payments,
+		balanced,
+		total: balanced ? s.book.total : undefined
+	};
+}
+/** The income and expenditure statement and the statement of financial position as far as placed. */
+function ieStatements(s, st) {
+	const r = s.statements;
+	const h = s.headings;
+	const placed = new Set(st.placed);
+	const last = st.placed.at(-1);
+	const seen = (source, place) => s.given.has(source) || placed.has(`${source}:${place}`);
+	const fresh = (source, place) => `${source}:${place}` === last;
+	const linesOf = (lines, place, out) => {
+		let complete = true;
+		for (const line of lines) {
+			const entries = line.entries.filter((e) => seen(e.source, place));
+			if (entries.length < line.entries.length) complete = false;
+			if (entries.length === 0) continue;
+			const base = line.entries[0];
+			const baseSeen = seen(base.source, place);
+			const adj = s.adjustments[line.id];
+			const name = line.id === "cash" ? h.cash : adj ? place === "income" || place === "expense" ? adjustmentAbout(s, adj) : fill(s.phrases[ADJUSTMENT_WORDS[adj.kind][0]], { name: adjustmentAbout(s, adj) }) : s.names[line.id] ?? line.id;
+			out.push({
+				key: `${place}:${line.id}`,
+				kind: s.given.has(base.source) ? "given" : "line",
+				label: name,
+				...baseSeen ? { amount: base.amount } : {},
+				col: 1,
+				less: false,
+				fresh: baseSeen && fresh(base.source, place)
+			});
+			for (const e of line.entries.slice(1)) {
+				if (!seen(e.source, place)) continue;
+				const by = s.adjustments[e.source];
+				const label = by ? s.phrases[ADJUSTMENT_WORDS[by.kind][1]] : s.names[e.source] ?? e.source;
+				out.push({
+					key: `${place}:${line.id}/${e.source}`,
+					kind: "entry",
+					label: `${e.sign < 0 ? h.less : h.add} ${label}`,
+					amount: e.amount,
+					col: 1,
+					less: e.sign < 0,
+					fresh: fresh(e.source, place)
+				});
+			}
+			if (line.entries.length > 1 && entries.length === line.entries.length) out.push({
+				key: `${place}:${line.id}:net`,
+				kind: "net",
+				label: "",
+				amount: line.amount,
+				col: 1,
+				less: false,
+				fresh: false
+			});
+		}
+		return complete;
+	};
+	const income = [{
+		key: "income:heading",
+		kind: "heading",
+		label: h.income,
+		col: 1,
+		less: false,
+		fresh: false
+	}];
+	const incomeDone = linesOf(r.income.lines, "income", income);
+	if (incomeDone) income.push({
+		key: "income:total",
+		kind: "total",
+		label: h.totalIncome,
+		amount: r.income.total,
+		col: 2,
+		less: false,
+		fresh: false
+	});
+	income.push({
+		key: "expense:heading",
+		kind: "heading",
+		label: `${h.less} ${h.expenditure}`,
+		col: 1,
+		less: false,
+		fresh: false
+	});
+	const expenseDone = linesOf(r.expenditure.lines, "expense", income);
+	if (expenseDone) income.push({
+		key: "expense:total",
+		kind: "total",
+		label: h.totalExpenditure,
+		amount: r.expenditure.total,
+		col: 2,
+		less: true,
+		fresh: false
+	});
+	if (incomeDone && expenseDone) income.push({
+		key: "surplus",
+		kind: "result",
+		label: r.surplus < 0 ? h.deficit : h.surplus,
+		amount: Math.abs(r.surplus),
+		col: 2,
+		less: r.surplus < 0,
+		fresh: false
+	});
+	const position = [{
+		key: "assets:heading",
+		kind: "heading",
+		label: h.assets,
+		col: 1,
+		less: false,
+		fresh: false
+	}];
+	const assetsDone = linesOf(r.assets.lines, "asset", position);
+	if (assetsDone) position.push({
+		key: "assets:total",
+		kind: "result",
+		label: h.totalAssets,
+		amount: r.assets.total,
+		col: 2,
+		less: false,
+		fresh: false
+	});
+	position.push({
+		key: "liabilities:heading",
+		kind: "heading",
+		label: h.liabilitiesAndFund,
+		col: 1,
+		less: false,
+		fresh: false
+	});
+	const liabilitiesDone = linesOf(r.liabilities.lines, "liability", position);
+	position.push({
+		key: "fund",
+		kind: "given",
+		label: h.familyFund,
+		amount: Math.abs(r.openingFund),
+		col: 1,
+		less: r.openingFund < 0,
+		fresh: false,
+		note: s.fundWorking
+	});
+	if (st.carried) {
+		const p = s.phrases;
+		position.push({
+			key: "fund/surplus",
+			kind: "entry",
+			label: `${r.surplus < 0 ? h.less : h.add} ${r.surplus < 0 ? p.deficitLine : p.surplusLine}`,
+			amount: Math.abs(r.surplus),
+			col: 1,
+			less: r.surplus < 0,
+			fresh: true
+		});
+		position.push({
+			key: "fund:net",
+			kind: "net",
+			label: "",
+			amount: Math.abs(r.closingFund),
+			col: 1,
+			less: r.closingFund < 0,
+			fresh: false
+		});
+		position.push({
+			key: "liabilities:total",
+			kind: "result",
+			label: h.totalLiabilitiesAndFund,
+			amount: r.liabilitiesAndFund,
+			col: 2,
+			less: false,
+			fresh: false
+		});
+	}
+	return {
+		income,
+		position,
+		placedAll: incomeDone && expenseDone && assetsDone && liabilitiesDone
+	};
+}
+function adjustmentAbout(s, a) {
+	return a.event !== undefined ? s.names[a.event] ?? a.event : a.name ?? a.id;
+}
+const householdAccountsModel = defineLabModel({
+	id: "household-accounts",
+	params: householdAccountsParamsSchema,
+	resolve(p) {
+		const headings = {
+			...HEADING,
+			...p.headings
+		};
+		const phrases = {
+			...PHRASE,
+			...p.phrases
+		};
+		const m = (v) => formatMoney(v, { currency: p.currency });
+		const base = {
+			mode: p.mode,
+			household: p.household,
+			asAt: p.asAt ?? "31 December 2025",
+			currency: p.currency,
+			headings,
+			phrases,
+			openingCash: p.openingCash,
+			adjustments: {},
+			given: new Set(),
+			fundWorking: ""
+		};
+		if (p.mode === "budget") {
+			const heads = p.heads ?? DEFAULT_HEADS;
+			const items = p.items ?? DEFAULT_ITEMS.map((i) => itemSchema.parse(i));
+			const ids = new Set();
+			for (const x of [...heads, ...items]) {
+				if (ids.has(x.id)) return refuse("duplicate-id", `"${x.id}" is used twice among heads and items.`);
+				ids.add(x.id);
+			}
+			if (heads.some((x) => x.id === "income")) return refuse("reserved-id", "\"income\" is the income column; give the head another id.");
+			for (const i of items) {
+				if (i.flow === "expense" && !heads.some((x) => x.id === i.head)) return refuse("unknown-head", `"${i.id}": a spending line needs a head that is in \`heads\`.`);
+			}
+			if (!items.some((i) => i.flow === "income")) return refuse("needs-income", "A budget needs at least one income line.");
+			if (!items.some((i) => i.flow === "expense")) return refuse("needs-spending", "A budget needs at least one spending line.");
+			const budget = solveHouseholdBudget({ lines: items.map((i) => ({
+				id: i.id,
+				flow: i.flow,
+				...i.head !== undefined && i.flow === "expense" ? { head: i.head } : {},
+				planned: i.amount,
+				...i.actual !== undefined ? { actual: i.actual } : {}
+			})) });
+			if (isRefusal(budget)) return budget;
+			const used = heads.filter((x) => items.some((i) => i.head === x.id && i.flow === "expense"));
+			const cards = items.map((i) => {
+				const answer = i.flow === "income" ? "income" : i.head;
+				return {
+					id: i.id,
+					from: "item",
+					name: i.name,
+					text: i.name,
+					amount: i.amount,
+					answers: [answer],
+					why: i.why ?? (i.flow === "income" ? phrases.whyIncome : heads.find((x) => x.id === i.head).why ?? "")
+				};
+			});
+			const actuals = budget.value.actualIncome !== undefined;
+			return {
+				...base,
+				period: p.period ?? "Budget for March",
+				cards,
+				keys: cards.map((c) => `${c.id}:${c.answers[0]}`),
+				options: [{
+					value: "income",
+					label: headings.budgetIncome
+				}, ...heads.map((x) => ({
+					value: x.id,
+					label: x.name
+				}))],
+				names: Object.fromEntries([...heads, ...items].map((x) => [x.id, x.name])),
+				heads: used,
+				items,
+				budget: budget.value,
+				...actuals ? { overAnswer: budget.value.mostOver ?? "none" } : {},
+				events: []
+			};
+		}
+		const authored = p.events !== undefined;
+		const events = p.events ?? DEFAULT_EVENTS.map((e) => eventSchema.parse(e));
+		const period = p.period ?? "For the year ended 31 December 2025";
+		const eventIds = new Set();
+		for (const e of events) {
+			if (eventIds.has(e.id)) return refuse("duplicate-id", `"${e.id}" is used twice among the events.`);
+			eventIds.add(e.id);
+		}
+		if (p.mode === "receipts-payments") {
+			const book = householdReceiptsPayments({
+				openingCash: p.openingCash,
+				events
+			});
+			if (isRefusal(book)) return book;
+			const cards = events.map((e) => ({
+				id: e.id,
+				from: "event",
+				name: e.name,
+				text: e.name,
+				amount: e.amount,
+				answers: [e.side],
+				why: eventWhy(phrases, e, p.mode)
+			}));
+			return {
+				...base,
+				period,
+				cards,
+				keys: cards.map((c) => `${c.id}:${c.answers[0]}`),
+				options: [{
+					value: "receipt",
+					label: headings.receipts
+				}, {
+					value: "payment",
+					label: headings.payments
+				}],
+				names: Object.fromEntries(events.map((e) => [e.id, e.name])),
+				heads: [],
+				items: [],
+				events,
+				book: book.value
+			};
+		}
+		const openingAssets = p.openingAssets ?? (authored ? [] : DEFAULT_OPENING_ASSETS.map((a) => ({ ...a })));
+		const adjustments = p.adjustments ?? (authored ? [] : DEFAULT_ADJUSTMENTS.map((a) => adjustmentSchema.parse(a)));
+		for (const a of adjustments) {
+			if (a.event === undefined && !a.name && (a.kind === "outstanding-expense" || a.kind === "accrued-income")) return refuse("needs-name", `"${a.id}": an adjustment with no event needs a name, the line it opens.`);
+		}
+		const result = solveHouseholdStatements({
+			openingCash: p.openingCash,
+			openingAssets: openingAssets.map(({ id: i, amount }) => ({
+				id: i,
+				amount
+			})),
+			openingLiabilities: p.openingLiabilities.map(({ id: i, amount }) => ({
+				id: i,
+				amount
+			})),
+			events: events.map((e) => ({
+				id: e.id,
+				side: e.side,
+				amount: e.amount,
+				...e.place !== undefined ? { place: e.place } : {},
+				...e.of !== undefined ? { of: e.of } : {}
+			})),
+			adjustments: adjustments.map((a) => ({
+				id: a.id,
+				kind: a.kind,
+				amount: a.amount,
+				...a.event !== undefined ? { event: a.event } : {}
+			}))
+		});
+		if (isRefusal(result)) return result;
+		const r = result.value;
+		const names = Object.fromEntries([
+			...openingAssets,
+			...p.openingLiabilities,
+			...events
+		].map((x) => [x.id, x.name]));
+		const byAdjustment = Object.fromEntries(adjustments.map((a) => [a.id, a]));
+		const cards = [...events.map((e) => ({
+			id: e.id,
+			from: "event",
+			name: e.name,
+			text: e.name,
+			amount: e.amount,
+			answers: r.placements[e.id],
+			why: eventWhy(phrases, e, p.mode)
+		})), ...adjustments.map((a) => {
+			const [lineKey, , whyKey] = ADJUSTMENT_WORDS[a.kind];
+			const name = fill(phrases[lineKey], { name: adjustmentAbout({ names }, a) });
+			names[a.id] = name;
+			return {
+				id: a.id,
+				from: "adjustment",
+				name,
+				text: a.text ?? `${name}: ${m(a.amount)}`,
+				amount: a.amount,
+				answers: r.placements[a.id],
+				why: a.why ?? phrases[whyKey]
+			};
+		})];
+		const assetsWorking = [`${headings.cash} ${m(p.openingCash)}`, ...openingAssets.map((a) => `${a.name} ${m(a.amount)}`)].join(" + ");
+		const liabilitiesWorking = p.openingLiabilities.map((l) => ` − ${l.name} ${m(l.amount)}`).join("");
+		return {
+			...base,
+			period,
+			cards,
+			keys: cards.flatMap((c) => c.answers.map((a) => `${c.id}:${a}`)),
+			options: [
+				"income",
+				"expense",
+				"asset",
+				"liability"
+			].map((v) => ({
+				value: v,
+				label: headings[PLACE_HEADING[v]]
+			})),
+			names,
+			heads: [],
+			items: [],
+			events,
+			statements: r,
+			adjustments: byAdjustment,
+			given: new Set([
+				"cash",
+				...openingAssets.map((a) => a.id),
+				...p.openingLiabilities.map((l) => l.id)
+			]),
+			fundWorking: `${phrases.fundNote}: ${assetsWorking}${liabilitiesWorking} = ${formatMoney(r.openingFund, { currency: p.currency })}`
+		};
+	},
+	initial: () => ({
+		placed: [],
+		pick: "",
+		wrong: false,
+		misses: {},
+		overspent: "",
+		closing: "",
+		carried: false
+	}),
+	controls: (c) => ({
+		place: c.choice({
+			unset: true,
+			label: (s) => s.mode === "budget" ? s.phrases.headQuestion : s.mode === "receipts-payments" ? s.phrases.sideQuestion : s.phrases.placeQuestion,
+			when: (s, st) => current(s, st) !== undefined,
+			options: (s) => s.options,
+			get: (st) => st.pick,
+			set: (st, value, s) => attempt(s, st, value)
+		}),
+		overspent: c.choice({
+			unset: true,
+			label: (s) => s.phrases.overQuestion,
+			when: (s, st) => s.overAnswer !== undefined && current(s, st) === undefined,
+			options: (s) => [...s.heads.map((x) => ({
+				value: x.id,
+				label: x.name
+			})), {
+				value: "none",
+				label: s.phrases.none
+			}],
+			get: (st) => st.overspent,
+			set: (st, value) => ({
+				...st,
+				overspent: value
+			})
+		}),
+		closing: c.choice({
+			unset: true,
+			label: (s) => s.phrases.closingQuestion,
+			when: (s, st) => s.mode === "receipts-payments" && current(s, st) === undefined,
+			options: (s) => [{
+				value: "receipt",
+				label: s.headings.receipts
+			}, {
+				value: "payment",
+				label: s.headings.payments
+			}],
+			get: (st) => st.closing,
+			set: (st, value) => ({
+				...st,
+				closing: value
+			})
+		}),
+		carry: c.action({
+			label: "Carry the surplus to the family fund",
+			when: (s, st) => s.mode === "income-expenditure" && current(s, st) === undefined,
+			enabled: (_s, st) => !st.carried,
+			run: (s, st) => current(s, st) === undefined ? {
+				...st,
+				carried: true
+			} : st
+		})
+	}),
+	read(s, st) {
+		const card = current(s, st);
+		const open = card ? card.answers.filter((a) => !st.placed.includes(`${card.id}:${a}`)) : [];
+		const landedCount = card ? card.answers.length - open.length : 0;
+		const placed = card === undefined;
+		const lastKey = st.placed.at(-1);
+		const lastCard = lastKey ? s.cards.find((c) => c.answers.some((a) => `${c.id}:${a}` === lastKey)) : undefined;
+		const lastAnswer = lastKey?.slice((lastCard?.id.length ?? 0) + 1);
+		const label = (v) => s.options.find((o) => o.value === v)?.label ?? v;
+		const pickMark = card && st.wrong ? "wrong" : "pending";
+		let live;
+		let compare;
+		if (s.mode === "budget") {
+			const sorted = s.items.filter((i) => st.placed.includes(`${i.id}:${i.flow === "income" ? "income" : i.head}`));
+			const sums = solveHouseholdBudget({ lines: sorted.map((i) => ({
+				id: i.id,
+				flow: i.flow,
+				...i.flow === "expense" ? { head: i.head } : {},
+				planned: i.amount
+			})) });
+			live = isRefusal(sums) ? {
+				income: 0,
+				spending: 0
+			} : {
+				income: sums.value.income,
+				spending: sums.value.expense
+			};
+			if (s.overAnswer !== undefined) compare = s.budget.heads.map((x) => ({
+				head: x.head,
+				name: s.names[x.head] ?? x.head,
+				plan: x.planned,
+				actual: x.actual,
+				over: x.over
+			}));
+		}
+		const overMark = st.overspent === "" ? "pending" : st.overspent === s.overAnswer ? "right" : "wrong";
+		const closingMark = st.closing === "" ? "pending" : st.closing === "payment" ? "right" : "wrong";
+		const budget = s.mode === "budget" ? budgetTables(s, st) : undefined;
+		const rp = s.mode === "receipts-payments" ? rpSides(s, st) : undefined;
+		const ie = s.mode === "income-expenditure" ? ieStatements(s, st) : undefined;
+		const balanced = placed && st.carried && (s.statements?.balances ?? false);
+		const done = s.mode === "budget" ? placed && (s.overAnswer === undefined || overMark === "right") : s.mode === "receipts-payments" ? placed && closingMark === "right" : balanced;
+		const rightFirst = s.cards.filter((c) => (st.misses[c.id] ?? 0) === 0).length;
+		return {
+			card,
+			index: card ? s.cards.indexOf(card) : s.cards.length,
+			count: s.cards.length,
+			landedCount,
+			pickMark,
+			reason: card && st.wrong ? card.why : undefined,
+			landed: lastCard && lastAnswer !== undefined ? {
+				name: lastCard.name,
+				place: label(lastAnswer),
+				why: lastCard.why,
+				key: lastKey
+			} : undefined,
+			placedCount: st.placed.length,
+			total: s.keys.length,
+			placed,
+			live,
+			budget,
+			compare,
+			overMark,
+			rp,
+			closingMark,
+			ie,
+			carried: st.carried,
+			balanced,
+			done,
+			rightFirst
+		};
+	},
+	goals: {
+		placed: (r) => r.placed,
+		done: (r) => r.done
+	},
+	witness: (s) => ({
+		placed: [...s.keys],
+		pick: "",
+		wrong: false,
+		misses: {},
+		overspent: s.overAnswer ?? "",
+		closing: s.mode === "receipts-payments" ? "payment" : "",
+		carried: s.mode === "income-expenditure"
+	}),
+	describe: (s, st, r) => {
+		const m = (v) => formatMoney(v, { currency: s.currency });
+		const h = s.headings;
+		if (r.card) {
+			const where = `${r.index + 1} of ${r.count}.`;
+			const what = r.card.from === "adjustment" ? `${h.adjustment}: ${r.card.text} ${r.landedCount === 1 ? s.phrases.firstPlaced : s.phrases.twice}` : `${r.card.name}, ${m(r.card.amount)}.`;
+			return r.reason ? `${where} ${what} Not there: ${r.reason}` : `${where} ${what}`;
+		}
+		if (s.mode === "budget") {
+			const b = s.budget;
+			const result = b.surplus >= 0 ? `${h.surplus} ${m(b.surplus)}` : `${h.deficit} ${m(-b.surplus)}`;
+			return `${h.totalIncome} ${m(b.income)}; ${h.totalSpending} ${m(b.expense)}; ${result}.`;
+		}
+		if (s.mode === "receipts-payments") {
+			return r.done ? `${h.closingBalance} ${m(s.book.closing)}; ${h.receipts} ${m(s.book.total)} = ${h.payments} ${m(s.book.total)}.` : `Every event is placed. ${s.phrases.closingQuestion}`;
+		}
+		const x = s.statements;
+		const result = x.surplus >= 0 ? `${h.surplus} ${m(x.surplus)}` : `${h.deficit} ${m(-x.surplus)}`;
+		if (!st.carried) return `Everything is placed. ${result}. Carry it to the family fund.`;
+		return `${result}; ${h.familyFund} ${m(x.closingFund)}; ${h.totalAssets} ${m(x.assets.total)} = ${h.totalLiabilitiesAndFund} ${m(x.liabilitiesAndFund)}.`;
+	}
+});
+
+//#endregion
+export { householdAccountsModel, householdAccountsParamsSchema };