shutro-erp 0.3.4 → 0.3.6

package/dist/account_asset/board.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Depreciation boards (RFC 0024 §2.5), without a database: the planned month-end amounts of an asset from its value,
+ * salvage value, method and life. Exact in Decimals; the last line takes the rounding so the board ends at the
+ * salvage value.
+ *
+ * - **Straight line**: the depreciable amount over the life in months; with prorata the first month counts only the
+ *   days from the date of use, and one more month at the end takes the rest.
+ * - **Declining balance**: the annual rate on what remains, a twelfth a month — switching to straight line over the
+ *   months left as soon as that is more, so the asset reaches its salvage value at the end of its life.
+ * - **Units of production**: no plan ahead; each month's usage at the depreciable amount per unit (`unitsLine`).
+ */
+import { type Decimal } from '../server/orm.js';
+export interface BoardInput {
+    /** What remains to depreciate from, at `from` (the cost, or the book value after a revaluation). */
+    readonly bookValue: Decimal;
+    readonly salvage: Decimal;
+    readonly method: 'linear' | 'degressive' | 'units';
+    /** Months left in the asset's life from `from`. */
+    readonly months: number;
+    /** Declining balance: the yearly rate in percent. */
+    readonly rate: Decimal;
+    /** The date depreciation starts (`YYYY-MM-DD`): the date of use, or the day after the last posted month. */
+    readonly from: string;
+    /** The first month only from the date (`true`), or in full. */
+    readonly prorata: boolean;
+}
+export interface BoardLine {
+    /** The month's last day, `YYYY-MM-DD`. */
+    readonly date: string;
+    readonly amount: Decimal;
+    /** Depreciated so far on this board, this line included. */
+    readonly accumulated: Decimal;
+    /** The book value after this line. */
+    readonly remaining: Decimal;
+}
+/** The planned lines of a board. Units of production plans nothing ahead. */
+export declare function board(input: BoardInput): BoardLine[];
+/** Units of production: the month's depreciation for `units` used, never past the salvage value. */
+export declare function unitsLine(input: {
+    readonly cost: Decimal;
+    readonly salvage: Decimal;
+    readonly totalUnits: Decimal;
+    readonly units: Decimal;
+    readonly depreciated: Decimal;
+}): Decimal;
+/**
+ * A tax book (reducing balance at a yearly rate, a full year in the year of acquisition — as Bangladesh's Third
+ * Schedule reads; verify for the year): the written-down value at the start of each income year, its depreciation,
+ * and the value at its end, from the year of acquisition to `throughYear` (each year by its start, `YYYY`).
+ */
+export declare function taxBook(input: {
+    readonly cost: Decimal;
+    readonly rate: Decimal;
+    readonly acquiredYear: number;
+    readonly throughYear: number;
+}): {
+    year: number;
+    opening: Decimal;
+    depreciation: Decimal;
+    closing: Decimal;
+}[];

package/dist/account_asset/board.js

@@ -0,0 +1,86 @@
+/**
+ * Depreciation boards (RFC 0024 §2.5), without a database: the planned month-end amounts of an asset from its value,
+ * salvage value, method and life. Exact in Decimals; the last line takes the rounding so the board ends at the
+ * salvage value.
+ *
+ * - **Straight line**: the depreciable amount over the life in months; with prorata the first month counts only the
+ *   days from the date of use, and one more month at the end takes the rest.
+ * - **Declining balance**: the annual rate on what remains, a twelfth a month — switching to straight line over the
+ *   months left as soon as that is more, so the asset reaches its salvage value at the end of its life.
+ * - **Units of production**: no plan ahead; each month's usage at the depreciable amount per unit (`unitsLine`).
+ */
+import { orm } from '../server/orm.js';
+const ZERO = orm.toDecimal(0);
+const monthEnd = (y, m) => new Date(Date.UTC(y, m, 0)).toISOString().slice(0, 10);
+const money = (d) => d.toDecimalPlaces(2);
+/** The planned lines of a board. Units of production plans nothing ahead. */
+export function board(input) {
+    if (input.method === 'units' || input.months <= 0)
+        return [];
+    const [y0, m0, d0] = input.from.split('-').map(Number);
+    const daysInFirst = new Date(Date.UTC(y0, m0, 0)).getUTCDate();
+    const firstShare = input.prorata
+        ? orm.toDecimal(daysInFirst - d0 + 1).div(daysInFirst)
+        : orm.toDecimal(1);
+    const partial = input.prorata && d0 > 1;
+    const depreciable = input.bookValue.minus(input.salvage);
+    if (depreciable.lte(0))
+        return [];
+    const count = input.months + (partial ? 1 : 0);
+    const lines = [];
+    let accumulated = ZERO;
+    for (let i = 0; i < count; i += 1) {
+        const y = y0 + Math.floor((m0 - 1 + i) / 12);
+        const m = ((m0 - 1 + i) % 12) + 1;
+        const left = depreciable.minus(accumulated);
+        if (left.lte(0))
+            break;
+        let amount;
+        if (i === count - 1)
+            amount = left;
+        else if (input.method === 'linear') {
+            const monthly = depreciable.div(input.months);
+            amount = money(i === 0 ? monthly.times(firstShare) : monthly);
+        }
+        else {
+            const declining = input.bookValue.minus(accumulated).times(input.rate).div(1200);
+            const straight = left.div(count - i);
+            const base = declining.gt(straight) ? declining : straight;
+            amount = money(i === 0 ? base.times(firstShare) : base);
+        }
+        if (amount.gt(left))
+            amount = left;
+        accumulated = accumulated.plus(amount);
+        lines.push({
+            date: monthEnd(y, m),
+            amount,
+            accumulated,
+            remaining: input.bookValue.minus(accumulated),
+        });
+    }
+    return lines;
+}
+/** Units of production: the month's depreciation for `units` used, never past the salvage value. */
+export function unitsLine(input) {
+    if (input.totalUnits.lte(0))
+        return ZERO;
+    const depreciable = input.cost.minus(input.salvage);
+    const left = depreciable.minus(input.depreciated);
+    const amount = money(depreciable.div(input.totalUnits).times(input.units));
+    return amount.gt(left) ? (left.gt(0) ? left : ZERO) : amount;
+}
+/**
+ * A tax book (reducing balance at a yearly rate, a full year in the year of acquisition — as Bangladesh's Third
+ * Schedule reads; verify for the year): the written-down value at the start of each income year, its depreciation,
+ * and the value at its end, from the year of acquisition to `throughYear` (each year by its start, `YYYY`).
+ */
+export function taxBook(input) {
+    const out = [];
+    let wdv = input.cost;
+    for (let year = input.acquiredYear; year <= input.throughYear; year += 1) {
+        const depreciation = money(wdv.times(input.rate).div(100));
+        out.push({ year, opening: wdv, depreciation, closing: wdv.minus(depreciation) });
+        wdv = wdv.minus(depreciation);
+    }
+    return out;
+}

package/dist/account_asset/books.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Fixed assets in the books (RFC 0024 §2.5): the board planned on confirmation and after a revaluation, the lines due
+ * posted once each (Depreciation expense against Accumulated depreciation, in the category's journal, with the
+ * asset's cost centre), units of production from each month's usage, disposal or sale with its gain or loss,
+ * revaluation and impairment, draft assets from posted bills, and the tax book beside the accounting book.
+ */
+import { type Decimal, type Id } from '../server/orm.js';
+import type { Env } from './.kosh/bindings.js';
+/** A date-only value as `YYYY-MM-DD` (PostgreSQL dates read as local midnights). */
+export declare function isoDate(v: unknown): string;
+/** Plans (again) the boards of the assets: what is not posted yet is replaced, from what remains. */
+export declare function planBoard(env: Env, ids: readonly number[]): Promise<void>;
+/** Posts every running asset's lines due on or before `upTo` (units of production: from the usage); returns how many. */
+export declare function postDue(env: Env, upTo: string, only?: readonly number[]): Promise<number>;
+/** Disposes of (or sells) an asset on `date`: depreciation up to then, the asset out, the gain or loss booked. */
+export declare function dispose(env: Env, id: number, input: {
+    readonly date: string;
+    readonly proceeds: Decimal;
+    readonly account: number | null;
+}): Promise<Id<'account.move'>>;
+/** Revalues an asset to `value` on `date` (an impairment when lower); the rest of its board planned again. */
+export declare function revalue(env: Env, id: number, input: {
+    readonly date: string;
+    readonly value: Decimal;
+}): Promise<Id<'account.move'>>;
+/** A posted bill's lines on an asset category's asset account become draft assets, once each. */
+export declare function assetsFromBill(env: Env, moveId: number): Promise<number>;
+export interface TaxBookRow {
+    readonly asset: number;
+    readonly name: string;
+    readonly category: string;
+    readonly rate: string;
+    readonly opening: string;
+    readonly taxDepreciation: string;
+    readonly closing: string;
+    readonly bookDepreciation: string;
+    readonly bookValue: string;
+    /** The book value less the tax value at the year's end: the temporary difference for deferred tax. */
+    readonly difference: string;
+}
+/** The tax book of the fiscal year starting in `year` beside the accounting book, asset by asset. */
+export declare function taxBookOf(env: Env, year: number): Promise<TaxBookRow[]>;

package/dist/account_asset/books.js

@@ -0,0 +1,398 @@
+/**
+ * Fixed assets in the books (RFC 0024 §2.5): the board planned on confirmation and after a revaluation, the lines due
+ * posted once each (Depreciation expense against Accumulated depreciation, in the category's journal, with the
+ * asset's cost centre), units of production from each month's usage, disposal or sale with its gain or loss,
+ * revaluation and impairment, draft assets from posted bills, and the tax book beside the accounting book.
+ */
+import { orm } from '../server/orm.js';
+import { board, taxBook, unitsLine } from './board.js';
+const ZERO = orm.toDecimal(0);
+/** A date-only value as `YYYY-MM-DD` (PostgreSQL dates read as local midnights). */
+export function isoDate(v) {
+    if (!(v instanceof Date))
+        return String(v ?? '').slice(0, 10);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${v.getFullYear()}-${pad(v.getMonth() + 1)}-${pad(v.getDate())}`;
+}
+const nextDay = (date) => new Date(Date.parse(`${date}T00:00:00Z`) + 86_400_000).toISOString().slice(0, 10);
+async function post(env, company, journal, date, ref, lines) {
+    const [c] = await env.model('res.company').browse([company]).load({});
+    const made = await env.model('account.move').create([
+        {
+            kind: 'entry',
+            journal,
+            company,
+            currency: c?.currency.id,
+            date,
+            ref,
+            lines: {
+                create: lines
+                    .filter((l) => !l.debit.isZero() || !l.credit.isZero())
+                    .map((l) => ({
+                    account: l.account,
+                    name: l.name,
+                    analytic: l.analytic ?? null,
+                    debit: l.debit.toDecimalPlaces(2).toString(),
+                    credit: l.credit.toDecimalPlaces(2).toString(),
+                })),
+            },
+        },
+    ]);
+    await env.withGrants({ grants: ['account.post'], reason: `asset ${ref}` }, (e) => e.model('account.move').browse(made.ids).post());
+    return made.ids[0];
+}
+/** An account of the company by code, made when missing. */
+async function accountByCode(env, company, spec) {
+    return ((await env.model('account.account').search({ where: { company, code: spec.code }, limit: 1 })).ids[0] ??
+        (await env.model('account.account').create([{ ...spec, company }]))
+            .ids[0]);
+}
+/** Plans (again) the boards of the assets: what is not posted yet is replaced, from what remains. */
+export async function planBoard(env, ids) {
+    for (const a of await env
+        .model('account.asset')
+        .browse(ids)
+        .load({ lines: true })) {
+        const planned = [...a.lines].filter((l) => !l.posted).map((l) => l.id);
+        if (planned.length > 0)
+            await env.model('account.asset.line').browse(planned).unlink();
+        const posted = [...a.lines]
+            .filter((l) => l.posted)
+            .sort((x, y) => isoDate(x.date).localeCompare(isoDate(y.date)));
+        const months = posted.filter((l) => l.kind === 'depreciation').length;
+        const revalued = posted
+            .filter((l) => l.kind === 'revaluation')
+            .reduce((s, l) => s.plus(l.amount), ZERO);
+        const lowered = posted
+            .filter((l) => l.kind === 'depreciation' || l.kind === 'impairment')
+            .reduce((s, l) => s.plus(l.amount), ZERO);
+        const last = posted.filter((l) => l.kind === 'depreciation').at(-1);
+        const lines = board({
+            bookValue: a.value.plus(revalued).minus(lowered),
+            salvage: a.salvage,
+            method: a.method,
+            months: a.lifeMonths - months,
+            rate: a.rate ?? ZERO,
+            from: last === undefined ? isoDate(a.dateInUse) : nextDay(isoDate(last.date)),
+            prorata: last === undefined && a.prorata,
+        });
+        if (lines.length > 0)
+            await env.model('account.asset.line').create(lines.map((l) => ({
+                asset: a.id,
+                date: l.date,
+                kind: 'depreciation',
+                amount: l.amount.toString(),
+            })));
+    }
+    await env.flush();
+}
+/** Posts every running asset's lines due on or before `upTo` (units of production: from the usage); returns how many. */
+export async function postDue(env, upTo, only) {
+    let count = 0;
+    const assets = await (await env.model('account.asset').search({
+        where: { state: 'running', ...(only === undefined ? {} : { id: { in: only } }) },
+    })).load({ category: true, lines: true, usage: true });
+    for (const a of assets) {
+        // Units of production: a line for each month's usage not depreciated yet.
+        if (a.method === 'units') {
+            let depreciated = [...a.lines]
+                .filter((l) => l.kind === 'depreciation')
+                .reduce((s, l) => s.plus(l.amount), ZERO);
+            for (const u of [...a.usage].filter((u) => u.line === null && isoDate(u.date) <= upTo)) {
+                const amount = unitsLine({
+                    cost: a.value,
+                    salvage: a.salvage,
+                    totalUnits: a.totalUnits ?? ZERO,
+                    units: u.units,
+                    depreciated,
+                });
+                if (amount.lte(0))
+                    continue;
+                const made = await env.model('account.asset.line').create([
+                    {
+                        asset: a.id,
+                        date: isoDate(u.date),
+                        kind: 'depreciation',
+                        amount: amount.toString(),
+                    },
+                ]);
+                await env
+                    .model('account.asset.usage')
+                    .browse([u.id])
+                    .write({ line: made.ids[0] });
+                depreciated = depreciated.plus(amount);
+            }
+            await env.flush();
+        }
+        const due = [
+            ...(await (await env.model('account.asset.line').search({
+                where: { asset: a.id, kind: 'depreciation', posted: false, date: { lte: upTo } },
+                order: ['date asc'],
+            })).load(['date', 'amount'])),
+        ];
+        for (const l of due) {
+            const move = await post(env, a.company.id, a.category.journal.id, isoDate(l.date), `${a.name} depreciation`, [
+                {
+                    account: a.category.expenseAccount.id,
+                    debit: l.amount,
+                    credit: ZERO,
+                    name: a.name,
+                    analytic: a.analytic?.id ?? null,
+                },
+                {
+                    account: a.category.accumulatedAccount.id,
+                    debit: ZERO,
+                    credit: l.amount,
+                    name: a.name,
+                },
+            ]);
+            await env
+                .model('account.asset.line')
+                .browse([l.id])
+                .write({ posted: true, move });
+            count += 1;
+        }
+        await env.flush();
+        // Fully depreciated: nothing left above the salvage value and nothing planned.
+        const [now] = await env.model('account.asset').browse([a.id]).load({ lines: true });
+        if (now !== undefined &&
+            a.method !== 'units' &&
+            [...now.lines].every((l) => l.posted) &&
+            (now.bookValue ?? ZERO).lte(now.salvage))
+            await env.model('account.asset').browse([a.id]).close();
+    }
+    await env.flush();
+    return count;
+}
+/** Disposes of (or sells) an asset on `date`: depreciation up to then, the asset out, the gain or loss booked. */
+export async function dispose(env, id, input) {
+    await postDue(env, input.date, [id]);
+    const [a] = await env
+        .model('account.asset')
+        .browse([id])
+        .load({ category: true, lines: true });
+    if (a === undefined || a.state !== 'running')
+        throw new orm.ValidationError('account.asset', ['state'], 'Only a running asset is disposed of.', 'Confirm the asset first.');
+    if (input.proceeds.gt(0) && input.account === null)
+        throw new orm.ValidationError('account.asset', ['proceeds'], 'Say where the sale’s proceeds go.', 'Choose the receivable or bank account of the sale.');
+    const revalued = [...a.lines]
+        .filter((l) => l.posted && l.kind === 'revaluation')
+        .reduce((s, l) => s.plus(l.amount), ZERO);
+    const cost = a.value.plus(revalued);
+    const depreciated = a.depreciated ?? ZERO;
+    const book = cost.minus(depreciated);
+    const result = input.proceeds.minus(book);
+    const gain = a.category.gainAccount?.id ??
+        (await accountByCode(env, a.company.id, {
+            code: '4900',
+            name: 'Other income',
+            type: 'income_other',
+        }));
+    const loss = a.category.lossAccount?.id ?? a.category.expenseAccount.id;
+    const lines = [
+        {
+            account: a.category.accumulatedAccount.id,
+            debit: depreciated,
+            credit: ZERO,
+            name: `${a.name} disposed`,
+        },
+        { account: a.category.assetAccount.id, debit: ZERO, credit: cost, name: `${a.name} disposed` },
+    ];
+    if (input.proceeds.gt(0) && input.account !== null)
+        lines.push({
+            account: input.account,
+            debit: input.proceeds,
+            credit: ZERO,
+            name: `${a.name} sold`,
+        });
+    if (result.gt(0))
+        lines.push({ account: gain, debit: ZERO, credit: result, name: `${a.name} gain on disposal` });
+    if (result.lt(0))
+        lines.push({
+            account: loss,
+            debit: result.neg(),
+            credit: ZERO,
+            name: `${a.name} loss on disposal`,
+        });
+    const move = await post(env, a.company.id, a.category.journal.id, input.date, `${a.name} disposal`, lines);
+    const planned = [...a.lines].filter((l) => !l.posted).map((l) => l.id);
+    if (planned.length > 0)
+        await env.model('account.asset.line').browse(planned).unlink();
+    await env.model('account.asset.line').create([
+        {
+            asset: a.id,
+            date: input.date,
+            kind: 'disposal',
+            amount: book.toString(),
+            posted: true,
+            move,
+        },
+    ]);
+    await env
+        .model('account.asset')
+        .browse([a.id])
+        .write({ disposedOn: input.date, proceeds: input.proceeds.toString() });
+    await env.flush();
+    await env.model('account.asset').browse([a.id]).dispose();
+    await env.flush();
+    await env.emit('account.asset.disposed', { id: a.id, proceeds: input.proceeds.toString() });
+    return move;
+}
+/** Revalues an asset to `value` on `date` (an impairment when lower); the rest of its board planned again. */
+export async function revalue(env, id, input) {
+    await postDue(env, input.date, [id]);
+    const [a] = await env
+        .model('account.asset')
+        .browse([id])
+        .load({ category: true });
+    if (a === undefined || a.state !== 'running')
+        throw new orm.ValidationError('account.asset', ['state'], 'Only a running asset is revalued.', 'Confirm the asset first.');
+    const diff = input.value.minus(a.bookValue ?? ZERO);
+    if (diff.isZero())
+        throw new orm.ValidationError('account.asset', ['value'], 'That is its book value already.', 'Give the new value.');
+    let move;
+    if (diff.lt(0)) {
+        const loss = a.category.lossAccount?.id ?? a.category.expenseAccount.id;
+        move = await post(env, a.company.id, a.category.journal.id, input.date, `${a.name} impairment`, [
+            {
+                account: loss,
+                debit: diff.neg(),
+                credit: ZERO,
+                name: `${a.name} impairment`,
+                analytic: a.analytic?.id ?? null,
+            },
+            {
+                account: a.category.accumulatedAccount.id,
+                debit: ZERO,
+                credit: diff.neg(),
+                name: `${a.name} impairment`,
+            },
+        ]);
+    }
+    else {
+        const surplus = await accountByCode(env, a.company.id, {
+            code: '3150',
+            name: 'Revaluation surplus',
+            type: 'equity',
+        });
+        move = await post(env, a.company.id, a.category.journal.id, input.date, `${a.name} revaluation`, [
+            {
+                account: a.category.assetAccount.id,
+                debit: diff,
+                credit: ZERO,
+                name: `${a.name} revaluation`,
+            },
+            { account: surplus, debit: ZERO, credit: diff, name: `${a.name} revaluation` },
+        ]);
+    }
+    await env.model('account.asset.line').create([
+        {
+            asset: a.id,
+            date: input.date,
+            kind: diff.lt(0) ? 'impairment' : 'revaluation',
+            amount: diff.abs().toString(),
+            posted: true,
+            move,
+        },
+    ]);
+    await env.flush();
+    await planBoard(env, [a.id]);
+    return move;
+}
+/** A posted bill's lines on an asset category's asset account become draft assets, once each. */
+export async function assetsFromBill(env, moveId) {
+    const [bill] = await env
+        .model('account.move')
+        .browse([moveId])
+        .load({ lines: true, partner: true });
+    if (bill === undefined || bill.kind !== 'in_invoice' || bill.state !== 'posted')
+        return 0;
+    const categories = [
+        ...(await (await env.model('account.asset.category').search({ where: { company: bill.company.id } })).load({
+            assetAccount: true,
+        })),
+    ];
+    let made = 0;
+    for (const l of bill.lines) {
+        const category = categories.find((c) => c.assetAccount.id === l.account?.id);
+        if (category === undefined || l.debit.amount.lte(0))
+            continue;
+        if ((await env.model('account.asset').search({ where: { billLine: l.id }, limit: 1 })).length > 0)
+            continue;
+        await env.model('account.asset').create([
+            {
+                name: l.name ?? `${bill.name} line`,
+                category: category.id,
+                partner: bill.partner?.id ?? null,
+                bill: bill.id,
+                billLine: l.id,
+                analytic: l.analytic?.id ?? null,
+                company: bill.company.id,
+                value: l.debit.amount.toString(),
+                dateAcquired: isoDate(bill.date),
+                dateInUse: isoDate(bill.date),
+                method: category.method,
+                lifeMonths: category.lifeMonths,
+                rate: category.rate?.toString() ?? null,
+                prorata: category.prorata,
+            },
+        ]);
+        made += 1;
+    }
+    await env.flush();
+    return made;
+}
+/** The first day of the company's fiscal year that contains `date`. */
+function fiscalYearOf(date, startMonth) {
+    const [y, m] = date.split('-').map(Number);
+    return m >= startMonth ? y : y - 1;
+}
+/** The tax book of the fiscal year starting in `year` beside the accounting book, asset by asset. */
+export async function taxBookOf(env, year) {
+    const [company] = await env
+        .model('res.company')
+        .browse([env.companyId])
+        .load(['fiscalYearStart']);
+    const start = Number(company?.fiscalYearStart ?? 1);
+    const from = `${year}-${String(start).padStart(2, '0')}-01`;
+    const to = new Date(Date.UTC(year + 1, start - 1, 0)).toISOString().slice(0, 10);
+    const rows = [];
+    for (const a of await (await env
+        .model('account.asset')
+        .search({ where: { state: { ne: 'draft' }, dateAcquired: { lte: to } } })).load({ category: true, lines: true })) {
+        if (a.disposedOn !== null && isoDate(a.disposedOn) < from)
+            continue;
+        const rate = a.category.taxRate ?? ZERO;
+        const years = taxBook({
+            cost: a.value,
+            rate,
+            acquiredYear: fiscalYearOf(isoDate(a.dateAcquired), start),
+            throughYear: year,
+        });
+        const row = years.at(-1);
+        if (row === undefined)
+            continue;
+        const inYear = [...a.lines].filter((l) => l.kind === 'depreciation' && isoDate(l.date) >= from && isoDate(l.date) <= to);
+        const upTo = [...a.lines].filter((l) => isoDate(l.date) <= to);
+        const lowered = upTo
+            .filter((l) => l.kind === 'depreciation' || l.kind === 'impairment')
+            .reduce((s, l) => s.plus(l.amount), ZERO);
+        const raised = upTo
+            .filter((l) => l.kind === 'revaluation')
+            .reduce((s, l) => s.plus(l.amount), ZERO);
+        const book = a.value.plus(raised).minus(lowered);
+        rows.push({
+            asset: a.id,
+            name: a.name,
+            category: a.category.name,
+            rate: rate.toString(),
+            opening: row.opening.toFixed(2),
+            taxDepreciation: row.depreciation.toFixed(2),
+            closing: row.closing.toFixed(2),
+            bookDepreciation: inYear.reduce((s, l) => s.plus(l.amount), ZERO).toFixed(2),
+            bookValue: book.toFixed(2),
+            difference: book.minus(row.closing).toFixed(2),
+        });
+    }
+    return rows;
+}

package/dist/account_asset/demo.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Fixed assets' demo data (RFC 0008 §5.8): three categories — office equipment, computers, vehicles — with the tax
+ * book's rates (Bangladesh's Third Schedule as last known: verify), a set of laptops bought fourteen months ago and
+ * a delivery van on declining balance, both confirmed with their months so far posted.
+ */
+import type { DemoContext } from '../modules-sdk/index.js';
+export declare function assetDemo(ctx: DemoContext): Promise<string>;

package/dist/account_asset/demo.js

@@ -0,0 +1,72 @@
+import { postDue } from './books.js';
+const DINA = { login: 'dina', name: 'Dina Rahman', groups: ['account.manager'] };
+export async function assetDemo(ctx) {
+    return ctx.as(DINA, async (raw) => {
+        const env = raw;
+        const byCode = async (code) => (await env.model('account.account').search({ where: { code }, limit: 1 })).ids[0];
+        const [asset, accumulated, expense] = [
+            await byCode('1500'),
+            await byCode('1590'),
+            await byCode('6600'),
+        ];
+        const journal = (await env.model('account.journal').search({ where: { type: 'general' }, limit: 1 })).ids[0];
+        if (asset === undefined ||
+            accumulated === undefined ||
+            expense === undefined ||
+            journal === undefined)
+            return 'Fixed assets: no chart of accounts, nothing made.';
+        const accounts = {
+            assetAccount: asset,
+            accumulatedAccount: accumulated,
+            expenseAccount: expense,
+            journal,
+        };
+        const made = await env.model('account.asset.category').create([
+            { name: 'Office equipment', ...accounts, method: 'linear', lifeMonths: 60, taxRate: '10' },
+            { name: 'Computers', ...accounts, method: 'linear', lifeMonths: 36, taxRate: '30' },
+            {
+                name: 'Vehicles',
+                ...accounts,
+                method: 'degressive',
+                lifeMonths: 60,
+                rate: '30',
+                taxRate: '20',
+            },
+        ]);
+        const [, computers, vehicles] = made.ids;
+        const assets = await env.model('account.asset').create([
+            {
+                name: 'Laptops for the sales team (5)',
+                code: 'FA-0001',
+                category: computers,
+                value: '450000',
+                salvage: '0',
+                dateAcquired: ctx.date(-425),
+                dateInUse: ctx.date(-420),
+                method: 'linear',
+                lifeMonths: 36,
+            },
+            {
+                name: 'Delivery van',
+                code: 'FA-0002',
+                category: vehicles,
+                value: '3200000',
+                salvage: '400000',
+                dateAcquired: ctx.date(-200),
+                dateInUse: ctx.date(-200),
+                method: 'degressive',
+                rate: '30',
+                lifeMonths: 60,
+            },
+        ]);
+        await env.flush();
+        await env.model('account.asset').browse(assets.ids).confirm();
+        await env.flush();
+        const posted = await env.asSuperuser({ reason: 'demo depreciation' }, async (su) => {
+            const n = await postDue(su, ctx.date(0));
+            await su.flush();
+            return n;
+        });
+        return `Fixed assets: 3 categories, 2 assets, ${posted} months of depreciation posted.`;
+    });
+}

package/dist/account_asset/index.d.ts

@@ -0,0 +1,9 @@
+import { defineModule } from '../modules-sdk/index.js';
+import { type ModuleContext } from '../server/index.js';
+import { type Worker } from '../server/orm.js';
+export { board, taxBook, unitsLine } from './board.js';
+export { assetsFromBill, dispose, planBoard, postDue, revalue, type TaxBookRow, taxBookOf, } from './books.js';
+export { Asset, AssetCategory, AssetLine, AssetUsage, accountAssetShutro } from './module.js';
+/** The subscriber that makes draft assets of posted bills; tests `drain()` it, the server starts it. */
+export declare function assetWorker(context: Pick<ModuleContext, 'shutro'>): Worker;
+export declare const accountAsset: ReturnType<typeof defineModule>;