shutro-erp 0.2.0 → 0.3.0

package/dist/l10n_bd/module.js

@@ -0,0 +1,163 @@
+/**
+ * The data layer of the Bangladesh localization (RFC 0016 §5.3): the taxes under the VAT and Supplementary Duty Act
+ * 2012 (VAT at the standard and reduced rates, exempt and zero-rated, supplementary duty charged before VAT, advance
+ * tax on imports), and the tax identifiers of companies and contacts — the 13-digit BIN and the 12-digit TIN —
+ * checked when saved. The taxes are data (`noupdate`: the company's to change); their accounts are set for each
+ * company when the localization is installed.
+ */
+import { accountingShutro } from '../accounting/index.js';
+import { contactsShutro } from '../contacts/index.js';
+import { computeTaxes, taxRule } from '../product/index.js';
+import { orm } from '../server/orm.js';
+import { check, compute, defineModule, extendModel, f, record } from './.kosh/bindings.js';
+const BIN = /^\d{13}$/;
+const TIN = /^\d{12}$/;
+export const PartnerIdentifiers = extendModel('res.partner', {
+    fields: {
+        /** Business Identification Number (VAT registration, 13 digits): on the tax invoice (Mushak 6.3). */
+        bin: f.char({ size: 13, label: 'BIN' }),
+        /** Taxpayer Identification Number (income tax, 12 digits). */
+        tin: f.char({ size: 12, label: 'TIN' }),
+    },
+    constraints: {
+        binFormat: {
+            ...check('res.partner', ['bin'], (ps) => ps.filter((p) => p.bin !== null && !BIN.test(p.bin))),
+            message: 'A BIN has 13 digits.',
+        },
+        tinFormat: {
+            ...check('res.partner', ['tin'], (ps) => ps.filter((p) => p.tin !== null && !TIN.test(p.tin))),
+            message: 'A TIN has 12 digits.',
+        },
+    },
+});
+export const CompanyIdentifiers = extendModel('res.company', {
+    fields: {
+        bin: f.char({ size: 13, label: 'BIN' }),
+        tin: f.char({ size: 12, label: 'TIN' }),
+    },
+    constraints: {
+        companyBinFormat: {
+            ...check('res.company', ['bin'], (cs) => cs.filter((c) => c.bin !== null && !BIN.test(c.bin))),
+            message: 'A BIN has 13 digits.',
+        },
+        companyTinFormat: {
+            ...check('res.company', ['tin'], (cs) => cs.filter((c) => c.tin !== null && !TIN.test(c.tin))),
+            message: 'A TIN has 12 digits.',
+        },
+    },
+});
+/** What a tax is in the Mushak returns: the VAT's rate band, supplementary duty or advance tax. */
+export const MUSHAK_KINDS = {
+    standard: 'VAT, standard rate',
+    reduced: 'VAT, reduced rate',
+    zero: 'VAT, zero-rated',
+    exempt: 'VAT exempt',
+    sd: 'Supplementary duty',
+    at: 'Advance tax',
+};
+export const TaxMushak = extendModel('account.tax', {
+    fields: {
+        /** Where the tax goes in the Mushak 6.1, 6.2 and 9.1 (RFC 0016 §5.3); a tax without it is not reported. */
+        mushak: f.selection(MUSHAK_KINDS, { label: 'Mushak' }),
+    },
+});
+const TAX_DEPENDS = [
+    'lineKind',
+    'quantity',
+    'priceUnit',
+    'discount',
+    'taxes.rate',
+    'taxes.sequence',
+    'taxes.amountType',
+    'taxes.fixedAmount',
+    'taxes.affectsBase',
+    'taxes.priceIncluded',
+    'taxes.reverseCharge',
+    'taxes.mushak',
+];
+/** A product line's taxes, summed by Mushak kind (as Accounting computes them: after discount, in order). */
+export function mushakAmounts(l) {
+    if (l.lineKind !== 'product')
+        return null;
+    const taxes = [...l.taxes];
+    const quantity = l.quantity ?? orm.toDecimal(1);
+    const amount = quantity
+        .times(l.priceUnit ?? 0)
+        .times(orm.toDecimal(100).minus(l.discount ?? 0))
+        .div(100);
+    const result = computeTaxes(amount, quantity, taxes.map(taxRule));
+    const kindOf = new Map(taxes.map((t) => [t.id, t.mushak]));
+    let sd = orm.toDecimal(0);
+    let vat = orm.toDecimal(0);
+    for (const t of result.taxes) {
+        const kind = kindOf.get(t.tax);
+        if (kind === 'sd')
+            sd = sd.plus(t.amount);
+        else if (kind === 'standard' || kind === 'reduced' || kind === 'zero' || kind === 'exempt')
+            vat = vat.plus(t.amount);
+    }
+    return { sd, vat, total: result.total };
+}
+export const LineMushak = extendModel('account.move.line', {
+    fields: {
+        /** A product line's supplementary duty (Mushak 6.3 and the registers). */
+        sdAmount: f.monetary({
+            currency: 'currency',
+            store: true,
+            label: 'SD',
+            ...compute('account.move.line', 'sdAmount', [...TAX_DEPENDS], (lines) => {
+                for (const l of lines)
+                    l.sdAmount = mushakAmounts(l)?.sd ?? null;
+            }),
+        }),
+        /** A product line's VAT, on its price plus SD. */
+        vatAmount: f.monetary({
+            currency: 'currency',
+            store: true,
+            label: 'VAT',
+            ...compute('account.move.line', 'vatAmount', [...TAX_DEPENDS], (lines) => {
+                for (const l of lines)
+                    l.vatAmount = mushakAmounts(l)?.vat ?? null;
+            }),
+        }),
+        /** A product line's price with all its taxes. */
+        totalWithTaxes: f.monetary({
+            currency: 'currency',
+            store: true,
+            label: 'Total with taxes',
+            ...compute('account.move.line', 'totalWithTaxes', [...TAX_DEPENDS], (lines) => {
+                for (const l of lines)
+                    l.totalWithTaxes = mushakAmounts(l)?.total ?? null;
+            }),
+        }),
+    },
+});
+const tax = (id, name, use, rate, mushak, extra = {}) => record('account.tax', id, { name, use, rate, mushak, ...extra }, { noupdate: true });
+/** The ids the taxes keep from before 0.2.0, when Products shipped them (moved here by its migration). */
+export const TAXES = [
+    // VAT: the standard 15 % and the reduced rates.
+    tax('tax_sale_vat15', 'VAT 15%', 'sale', '0.15', 'standard'),
+    tax('tax_sale_vat10', 'VAT 10%', 'sale', '0.10', 'reduced'),
+    tax('tax_sale_vat7_5', 'VAT 7.5%', 'sale', '0.075', 'reduced'),
+    tax('tax_sale_vat5', 'VAT 5%', 'sale', '0.05', 'reduced'),
+    tax('tax_sale_exempt', 'VAT exempt', 'sale', '0', 'exempt'),
+    tax('tax_sale_zero', 'VAT 0% (exports)', 'sale', '0', 'zero'),
+    tax('tax_purchase_vat15', 'VAT 15% (purchases)', 'purchase', '0.15', 'standard'),
+    tax('tax_purchase_vat5', 'VAT 5% (purchases)', 'purchase', '0.05', 'reduced'),
+    tax('tax_purchase_exempt', 'VAT exempt (purchases)', 'purchase', '0', 'exempt'),
+    // Supplementary duty: before VAT, which is charged on the price plus SD.
+    tax('tax_sale_sd10', 'SD 10%', 'sale', '0.10', 'sd', { sequence: 1, affectsBase: true }),
+    tax('tax_sale_sd20', 'SD 20%', 'sale', '0.20', 'sd', { sequence: 1, affectsBase: true }),
+    tax('tax_sale_sd30', 'SD 30%', 'sale', '0.30', 'sd', { sequence: 1, affectsBase: true }),
+    tax('tax_sale_sd45', 'SD 45%', 'sale', '0.45', 'sd', { sequence: 1, affectsBase: true }),
+    // Advance tax on imports, recoverable against the VAT due.
+    tax('tax_purchase_at5', 'AT 5% (imports)', 'purchase', '0.05', 'at', { sequence: 20 }),
+];
+export const l10nBdShutro = defineModule({
+    name: 'l10n_bd',
+    version: '0.1.0',
+    depends: [accountingShutro, contactsShutro],
+    models: [],
+    extensions: [PartnerIdentifiers, CompanyIdentifiers, TaxMushak, LineMushak],
+    data: TAXES,
+});

package/dist/l10n_bd/mushak.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The Mushak registers and the monthly return (RFC 0016 §5.3), from the posted documents of a month: the purchase
+ * register (Mushak 6.1) and the sales register (Mushak 6.2), a row per product line, and the summary of the
+ * monthly return (Mushak 9.1): supplies and purchases by VAT band with their SD and VAT, the adjustments (VAT
+ * deducted at source, advance tax) and the net tax. Filing stays on the NBR's online system: these prepare what is
+ * entered there. Amounts are in the company's currency (taka): a foreign-currency line converts at its document's
+ * rate, through its posted balance. Credit notes count negative. The stock columns of the registers wait for
+ * Inventory.
+ */
+import { orm } from '../server/orm.js';
+import type { Env } from './.kosh/bindings.js';
+type Decimal = ReturnType<typeof orm.toDecimal>;
+export type Side = 'sales' | 'purchases';
+/** A line's VAT band, from the Mushak kind of its VAT tax (`unclassified`: no VAT tax with a kind). */
+export type VatCategory = 'standard' | 'reduced' | 'zero' | 'exempt' | 'unclassified';
+export declare const VAT_CATEGORIES: readonly VatCategory[];
+export interface RegisterRow {
+    readonly date: string;
+    readonly number: string;
+    /** A credit note (its amounts are negative). */
+    readonly refund: boolean;
+    readonly partner: string;
+    readonly bin: string | null;
+    readonly description: string;
+    readonly quantity: Decimal;
+    readonly value: Decimal;
+    readonly sd: Decimal;
+    readonly vat: Decimal;
+    readonly total: Decimal;
+    readonly category: VatCategory;
+}
+export declare class MonthError extends Error {
+}
+/** The first and last day of `month` (`2026-10`). */
+export declare function monthRange(month: string): {
+    readonly from: string;
+    readonly to: string;
+};
+/** The register of `side` (Mushak 6.1 for purchases, 6.2 for sales) for `month`. */
+export declare function register(env: Env, side: Side, month: string): Promise<RegisterRow[]>;
+export interface Band {
+    readonly value: Decimal;
+    readonly sd: Decimal;
+    readonly vat: Decimal;
+}
+/** The summary of the monthly return (Mushak 9.1). */
+export interface Return91 {
+    readonly month: string;
+    /** Part 3: supplies, by VAT band. */
+    readonly supplies: Readonly<Record<VatCategory, Band>>;
+    /** Part 4: purchases, by VAT band. */
+    readonly purchases: Readonly<Record<VatCategory, Band>>;
+    /** Part 5: increasing adjustments — VAT we deducted at source from our suppliers. */
+    readonly vdsDeducted: Decimal;
+    /** Part 6: decreasing adjustments — VAT our customers deducted at source, advance tax paid on imports. */
+    readonly vdsByCustomers: Decimal;
+    readonly advanceTax: Decimal;
+    /** Part 7: the net tax. */
+    readonly outputVat: Decimal;
+    readonly inputVat: Decimal;
+    readonly sdPayable: Decimal;
+    /** Output VAT − input VAT + increasing − decreasing adjustments (negative: carried forward). */
+    readonly netVat: Decimal;
+}
+/** The monthly return's summary for `month`. */
+export declare function return91(env: Env, month: string): Promise<Return91>;
+export {};

package/dist/l10n_bd/mushak.js

@@ -0,0 +1,139 @@
+/**
+ * The Mushak registers and the monthly return (RFC 0016 §5.3), from the posted documents of a month: the purchase
+ * register (Mushak 6.1) and the sales register (Mushak 6.2), a row per product line, and the summary of the
+ * monthly return (Mushak 9.1): supplies and purchases by VAT band with their SD and VAT, the adjustments (VAT
+ * deducted at source, advance tax) and the net tax. Filing stays on the NBR's online system: these prepare what is
+ * entered there. Amounts are in the company's currency (taka): a foreign-currency line converts at its document's
+ * rate, through its posted balance. Credit notes count negative. The stock columns of the registers wait for
+ * Inventory.
+ */
+import { orm } from '../server/orm.js';
+const ZERO = orm.toDecimal(0);
+export const VAT_CATEGORIES = [
+    'standard',
+    'reduced',
+    'zero',
+    'exempt',
+    'unclassified',
+];
+const KINDS = {
+    sales: { invoice: 'out_invoice', debit: 'out_debit', refund: 'out_refund' },
+    purchases: { invoice: 'in_invoice', debit: 'in_debit', refund: 'in_refund' },
+};
+export class MonthError extends Error {
+}
+/** The first and last day of `month` (`2026-10`). */
+export function monthRange(month) {
+    const match = /^(\d{4})-(0[1-9]|1[0-2])$/.exec(month);
+    if (match === null)
+        throw new MonthError('A month is written 2026-10.');
+    const [y, m] = [Number(match[1]), Number(match[2])];
+    const last = new Date(Date.UTC(y, m, 0)).getUTCDate();
+    return { from: `${month}-01`, to: `${month}-${String(last).padStart(2, '0')}` };
+}
+const round = (d) => d.toDecimalPlaces(2);
+/** The posted invoices and credit notes of `side` in `month`, with what the registers read. */
+async function documentsOf(env, side, month) {
+    const { from, to } = monthRange(month);
+    const kinds = KINDS[side];
+    const moves = await env.model('account.move').search({
+        where: {
+            kind: { in: [kinds.invoice, kinds.debit, kinds.refund] },
+            state: 'posted',
+            date: { gte: from, lte: to },
+        },
+        order: ['date asc', 'name asc'],
+    });
+    return moves.load({
+        partner: ['name', 'bin'],
+        invoiceLines: { taxes: ['mushak'] },
+        lines: { taxLineOf: ['mushak'] },
+    });
+}
+/** The register of `side` (Mushak 6.1 for purchases, 6.2 for sales) for `month`. */
+export async function register(env, side, month) {
+    const rows = [];
+    for (const move of await documentsOf(env, side, month)) {
+        const refund = move.kind === KINDS[side].refund;
+        const sign = refund ? -1 : 1;
+        for (const line of move.invoiceLines) {
+            if (line.lineKind !== 'product')
+                continue;
+            const subtotal = line.subtotal?.amount ?? ZERO;
+            // The value in taka is the posted balance (credit on sales, debit on purchases); taxes follow its rate.
+            const value = (line.balance?.amount ?? ZERO).abs();
+            const rate = subtotal.isZero() ? orm.toDecimal(1) : value.div(subtotal.abs());
+            const sd = round((line.sdAmount?.amount ?? ZERO).times(rate));
+            const vat = round((line.vatAmount?.amount ?? ZERO).times(rate));
+            const kinds = [...line.taxes].map((t) => t.mushak);
+            const category = VAT_CATEGORIES.find((c) => c !== 'unclassified' && kinds.includes(c)) ??
+                'unclassified';
+            rows.push({
+                date: String(move.date),
+                number: move.name ?? '',
+                refund,
+                partner: move.partner?.name ?? '',
+                bin: move.partner?.bin ?? null,
+                description: line.name ?? '',
+                quantity: (line.quantity ?? ZERO).times(sign),
+                value: value.times(sign),
+                sd: sd.times(sign),
+                vat: vat.times(sign),
+                total: value.plus(sd).plus(vat).times(sign),
+                category,
+            });
+        }
+    }
+    return rows;
+}
+function bands(rows) {
+    const out = Object.fromEntries(VAT_CATEGORIES.map((c) => [c, { value: ZERO, sd: ZERO, vat: ZERO }]));
+    for (const r of rows) {
+        const b = out[r.category];
+        out[r.category] = { value: b.value.plus(r.value), sd: b.sd.plus(r.sd), vat: b.vat.plus(r.vat) };
+    }
+    return out;
+}
+const sum = (bs, key) => VAT_CATEGORIES.reduce((s, c) => s.plus(bs[c][key]), ZERO);
+/** The monthly return's summary for `month`. */
+export async function return91(env, month) {
+    const { from, to } = monthRange(month);
+    const supplies = bands(await register(env, 'sales', month));
+    const purchases = bands(await register(env, 'purchases', month));
+    // Advance tax: the posted AT tax lines of the month's bills (net of credit notes).
+    let advanceTax = ZERO;
+    for (const move of await documentsOf(env, 'purchases', month))
+        for (const line of move.lines)
+            if (line.lineKind === 'tax' && line.taxLineOf?.mushak === 'at')
+                advanceTax = advanceTax.plus(line.balance?.amount ?? ZERO);
+    // VAT deducted at source: withholdings on the VAT of the month's posted payments, by direction.
+    let vdsDeducted = ZERO;
+    let vdsByCustomers = ZERO;
+    const payments = await env.model('account.payment').search({
+        where: { state: 'posted', date: { gte: from, lte: to } },
+    });
+    for (const p of await payments.load({ withholdings: { withholding: ['base', 'direction'] } }))
+        for (const w of p.withholdings) {
+            if (w.withholding.base !== 'tax')
+                continue;
+            const amount = w.amount?.amount ?? ZERO;
+            if (w.withholding.direction === 'vendor')
+                vdsDeducted = vdsDeducted.plus(amount);
+            else
+                vdsByCustomers = vdsByCustomers.plus(amount);
+        }
+    const outputVat = sum(supplies, 'vat');
+    const inputVat = sum(purchases, 'vat');
+    return {
+        month,
+        supplies,
+        purchases,
+        vdsDeducted,
+        vdsByCustomers,
+        advanceTax,
+        outputVat,
+        inputVat,
+        sdPayable: sum(supplies, 'sd'),
+        netVat: outputVat.minus(inputVat).plus(vdsDeducted).minus(vdsByCustomers).minus(advanceTax),
+    };
+}

package/dist/l10n_bd/routes.d.ts

@@ -0,0 +1,3 @@
+import { type ModuleContext } from '../server/index.js';
+export type MushakForm = '6.1' | '6.2' | '9.1';
+export declare function registerMushakRoutes(context: ModuleContext): void;

package/dist/l10n_bd/routes.js

@@ -0,0 +1,205 @@
+/**
+ * The Mushak registers and return over HTTP (RFC 0016 §5.3): `GET /api/v1/l10n_bd/mushak/:form?month=2026-10` for
+ * 6.1 (purchases), 6.2 (sales) and 9.1 (the monthly return's summary), as JSON for the screen, or with
+ * `format=xlsx` / `format=pdf` as a file. As the user: reading needs the documents' read right, a file their export
+ * right, and every file is in the audit log.
+ */
+import { moneyFormat, renderPdf, workbook } from '../reporting/index.js';
+import { audit, HttpProblem } from '../server/index.js';
+import { MonthError, monthRange, register, return91, VAT_CATEGORIES, } from './mushak.js';
+const TITLES = {
+    '6.1': 'Purchase register',
+    '6.2': 'Sales register',
+    '9.1': 'Monthly return (summary)',
+};
+const BANDS = {
+    standard: 'Standard rate (15 %)',
+    reduced: 'Reduced rates',
+    zero: 'Zero-rated',
+    exempt: 'Exempt',
+    unclassified: 'Without a Mushak VAT kind',
+};
+const money = (d) => d.toFixed(2);
+/** The JSON of a register row. */
+const rowJson = (r) => ({
+    ...r,
+    quantity: r.quantity.toString(),
+    value: money(r.value),
+    sd: money(r.sd),
+    vat: money(r.vat),
+    total: money(r.total),
+});
+const bandJson = (b) => ({ value: money(b.value), sd: money(b.sd), vat: money(b.vat) });
+const bandsJson = (bs) => Object.fromEntries(VAT_CATEGORIES.map((c) => [c, bandJson(bs[c])]));
+const returnJson = (r) => ({
+    month: r.month,
+    supplies: bandsJson(r.supplies),
+    purchases: bandsJson(r.purchases),
+    vdsDeducted: money(r.vdsDeducted),
+    vdsByCustomers: money(r.vdsByCustomers),
+    advanceTax: money(r.advanceTax),
+    outputVat: money(r.outputVat),
+    inputVat: money(r.inputVat),
+    sdPayable: money(r.sdPayable),
+    netVat: money(r.netVat),
+});
+/** The form as a table: a header row, then rows of text and amounts. */
+function table(form, data) {
+    if (form !== '9.1') {
+        const partner = form === '6.2' ? 'Customer' : 'Supplier';
+        return [
+            [
+                'No.',
+                'Date',
+                'Invoice or note',
+                partner,
+                'BIN',
+                'Description',
+                'Quantity',
+                'Value',
+                'SD',
+                'VAT',
+                'Total',
+                'VAT band',
+            ],
+            ...data.map((r, i) => [
+                String(i + 1),
+                r.date,
+                r.number,
+                r.partner,
+                r.bin ?? '',
+                r.description,
+                r.quantity.toString(),
+                r.value,
+                r.sd,
+                r.vat,
+                r.total,
+                BANDS[r.category],
+            ]),
+        ];
+    }
+    const r = data;
+    const bandRows = (bs) => VAT_CATEGORIES.map((c) => [BANDS[c], bs[c].value, bs[c].sd, bs[c].vat]);
+    return [
+        ['', 'Value', 'SD', 'VAT'],
+        ['Part 3 — supplies (output tax)', '', '', ''],
+        ...bandRows(r.supplies),
+        ['Part 4 — purchases (input tax)', '', '', ''],
+        ...bandRows(r.purchases),
+        ['Part 5 — increasing adjustments', '', '', ''],
+        ['VAT deducted at source from suppliers', '', '', r.vdsDeducted],
+        ['Part 6 — decreasing adjustments', '', '', ''],
+        ['VAT deducted at source by customers', '', '', r.vdsByCustomers],
+        ['Advance tax paid on imports', '', '', r.advanceTax],
+        ['Part 7 — net tax', '', '', ''],
+        ['Output VAT', '', '', r.outputVat],
+        ['Input VAT', '', '', r.inputVat],
+        ['Supplementary duty payable', '', r.sdPayable, ''],
+        ['Net VAT payable (negative: carried forward)', '', '', r.netVat],
+    ];
+}
+const isDecimal = (v) => typeof v !== 'string';
+function sheet(form, month, rows, currency) {
+    const format = moneyFormat(currency);
+    return {
+        name: `Mushak ${form} ${month}`,
+        rows: rows.map((row, i) => row.map((v) => {
+            if (isDecimal(v))
+                return { decimal: v.toFixed(2), format };
+            // 9.1's part headings (a text in the first column only) are bold.
+            if (i > 0 && form === '9.1' && v.startsWith('Part '))
+                return { text: v, bold: true };
+            return v;
+        })),
+        widths: form === '9.1' ? [48, 16, 16, 16] : [6, 12, 18, 28, 16, 32, 10, 14, 12, 12, 14, 22],
+    };
+}
+const esc = (s) => s.replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[c]);
+function html(form, month, company, rows, locale) {
+    const number = new Intl.NumberFormat(locale, {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    });
+    const cell = (v, tag) => isDecimal(v)
+        ? `<${tag} class="n">${number.format(Number(v.toFixed(2)))}</${tag}>`
+        : `<${tag}>${esc(v)}</${tag}>`;
+    const [head, ...body] = rows;
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Mushak ${form} ${month}</title><style>
+body { font: 9pt system-ui, sans-serif; color: #111; }
+h1 { font-size: 14pt; margin: 0 0 2mm; } p { margin: 0 0 4mm; }
+table { width: 100%; border-collapse: collapse; }
+th, td { border-bottom: 1px solid #ccc; padding: 1.2mm 1.5mm; text-align: start; vertical-align: top; }
+th { background: #f2f2f2; } .n { text-align: end; white-space: nowrap; }
+</style></head><body><h1>Mushak ${form} — ${TITLES[form]}</h1><p>${esc(company.name)}${company.bin === null ? '' : ` · BIN ${esc(company.bin)}`} · ${month}</p><table><thead><tr>${(head ?? []).map((v) => cell(v, 'th')).join('')}</tr></thead><tbody>${body
+        .map((r) => `<tr>${r.map((v) => cell(v, 'td')).join('')}</tr>`)
+        .join('')}</tbody></table></body></html>`;
+}
+export function registerMushakRoutes(context) {
+    context.app.get('/api/v1/l10n_bd/mushak/:form', async (request, reply) => {
+        const form = request.params.form;
+        if (form !== '6.1' && form !== '6.2' && form !== '9.1')
+            throw new HttpProblem(404, 'unknown-form', 'Unknown form', 'The forms are 6.1, 6.2 and 9.1.');
+        const query = request.query;
+        const month = typeof query.month === 'string' ? query.month : '';
+        const format = query.format === 'xlsx' || query.format === 'pdf' ? query.format : 'json';
+        try {
+            monthRange(month);
+        }
+        catch (error) {
+            if (error instanceof MonthError)
+                throw new HttpProblem(400, 'invalid-month', 'Invalid month', error.message);
+            throw error;
+        }
+        const out = await request.env(async (raw) => {
+            const env = raw;
+            env.access.check('account.move', format === 'json' ? 'read' : 'export');
+            const data = form === '9.1'
+                ? await return91(env, month)
+                : await register(env, form === '6.2' ? 'sales' : 'purchases', month);
+            if (format === 'json')
+                return {
+                    json: form === '9.1'
+                        ? returnJson(data)
+                        : { rows: data.map(rowJson) },
+                };
+            await audit(raw, {
+                kind: 'data.export',
+                summary: `Exported Mushak ${form} for ${month} as ${format}.`,
+                targetModel: 'account.move',
+                details: { form, month },
+                ip: request.ip,
+            });
+            const [company] = await env
+                .model('res.company')
+                .search({ where: { id: env.companyRef }, limit: 1 })
+                .then((c) => c.load({ currency: ['name'] }));
+            return {
+                rows: table(form, data),
+                company: {
+                    name: company?.name ?? '',
+                    bin: company?.bin ?? null,
+                    currency: company?.currency.name ?? 'BDT',
+                    locale: company?.numberGrouping === 'lakh' ? 'en-IN' : 'en-US',
+                },
+            };
+            // A file is an export: its audit event is written.
+        }, { write: format !== 'json' });
+        if ('json' in out)
+            return out.json;
+        const filename = `mushak-${form}-${month}.${format}`;
+        const content = format === 'xlsx'
+            ? workbook([sheet(form, month, out.rows, out.company.currency)])
+            : await renderPdf(html(form, month, out.company, out.rows, out.company.locale), {
+                paper: 'A4',
+                orientation: form === '9.1' ? 'portrait' : 'landscape',
+                blocks: [],
+            });
+        await reply
+            .type(format === 'xlsx'
+            ? 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            : 'application/pdf')
+            .header('content-disposition', `attachment; filename="${filename}"`)
+            .send(content);
+        return reply;
+    });
+}

package/dist/l10n_bd/web/MushakPage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Accounting › Reporting › Mushak returns (RFC 0016 §5.3): the sales register (6.2), the purchase register (6.1) and
+ * the monthly return's summary (9.1) of a month, as the server computes them, with their XLSX and PDF files.
+ */
+import { type PageProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function MushakPage({ api }: PageProps): ReactElement;

package/dist/l10n_bd/web/MushakPage.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Accounting › Reporting › Mushak returns (RFC 0016 §5.3): the sales register (6.2), the purchase register (6.1) and
+ * the monthly return's summary (9.1) of a month, as the server computes them, with their XLSX and PDF files.
+ */
+import { ApiError, Button, Input, Label, useKosh } from '../../ui/index.js';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { useId, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const FORMS = ['6.2', '6.1', '9.1'];
+const BANDS = ['standard', 'reduced', 'zero', 'exempt', 'unclassified'];
+function saveFile(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    a.click();
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+}
+const cell = 'px-2 py-1';
+const amount = `${cell} text-end tabular-nums`;
+export function MushakPage({ api }) {
+    const { t } = useTranslation('l10n_bd');
+    const { format } = useKosh();
+    const id = useId();
+    const [form, setForm] = useState('6.2');
+    const [month, setMonth] = useState(new Date().toISOString().slice(0, 7));
+    const path = `/api/v1/l10n_bd/mushak/${form}?month=${month}`;
+    const data = useQuery({
+        queryKey: ['l10n_bd', 'mushak', form, month],
+        queryFn: () => api.call('GET', path),
+        enabled: /^\d{4}-\d{2}$/.test(month),
+    });
+    const download = useMutation({
+        mutationFn: async (kind) => {
+            const { blob, filename } = await api.download(`${path}&format=${kind}`, undefined, 'GET');
+            saveFile(blob, filename);
+        },
+    });
+    const error = data.error ?? download.error;
+    return (_jsxs("div", { className: "grid gap-4 p-4", children: [_jsx("h1", { className: "text-xl font-semibold", children: t('mushak.title') }), _jsxs("div", { className: "flex flex-wrap items-end gap-2", children: [_jsxs("fieldset", { className: "flex flex-wrap gap-1", children: [_jsx("legend", { className: "sr-only", children: t('mushak.form') }), FORMS.map((f) => (_jsx(Button, { variant: form === f ? 'primary' : 'secondary', "aria-pressed": form === f, onClick: () => setForm(f), children: t(`mushak.forms.${f.replace('.', '_')}`) }, f)))] }), _jsxs("div", { className: "grid gap-1", children: [_jsx(Label, { htmlFor: `${id}-month`, children: t('mushak.month') }), _jsx(Input, { id: `${id}-month`, type: "month", value: month, onChange: (e) => setMonth(e.target.value) })] }), _jsx(Button, { variant: "secondary", disabled: download.isPending, onClick: () => download.mutate('xlsx'), children: t('mushak.xlsx') }), _jsx(Button, { variant: "secondary", disabled: download.isPending, onClick: () => download.mutate('pdf'), children: t('mushak.pdf') })] }), _jsx("p", { className: "text-sm text-muted-foreground", children: t('mushak.hint') }), error === null ? null : (_jsx("p", { role: "alert", className: "text-sm text-danger", children: error instanceof ApiError ? error.message : String(error) })), data.data === undefined ? null : 'rows' in data.data ? (_jsx(Register, { rows: data.data.rows, purchases: form === '6.1' })) : (_jsx(Summary, { data: data.data }))] }));
+    function Register({ rows, purchases, }) {
+        if (rows.length === 0)
+            return _jsx("p", { className: "text-sm text-muted-foreground", children: t('mushak.empty') });
+        return (_jsx("div", { className: "overflow-x-auto", children: _jsxs("table", { className: "w-full text-sm", children: [_jsx("thead", { className: "bg-muted", children: _jsxs("tr", { children: [_jsx("th", { className: `${cell} text-start`, children: t('mushak.date') }), _jsx("th", { className: `${cell} text-start`, children: t('mushak.number') }), _jsx("th", { className: `${cell} text-start`, children: t(purchases ? 'mushak.supplier' : 'mushak.customer') }), _jsx("th", { className: `${cell} text-start`, children: t('mushak.bin') }), _jsx("th", { className: `${cell} text-start`, children: t('mushak.description') }), _jsx("th", { className: `${cell} text-end`, children: t('mushak.value') }), _jsx("th", { className: `${cell} text-end`, children: t('mushak.sd') }), _jsx("th", { className: `${cell} text-end`, children: t('mushak.vat') }), _jsx("th", { className: `${cell} text-end`, children: t('mushak.total') }), _jsx("th", { className: `${cell} text-start`, children: t('mushak.band') })] }) }), _jsx("tbody", { children: rows.map((r, i) => (_jsxs("tr", { className: "border-b", children: [_jsx("td", { className: cell, children: format.date(r.date) }), _jsxs("td", { className: cell, children: [r.number, r.refund ? ` (${t('mushak.creditNote')})` : ''] }), _jsx("td", { className: cell, children: r.partner }), _jsx("td", { className: `${cell} tabular-nums`, children: r.bin ?? '' }), _jsx("td", { className: cell, children: r.description }), _jsx("td", { className: amount, children: format.decimal(r.value, 2) }), _jsx("td", { className: amount, children: format.decimal(r.sd, 2) }), _jsx("td", { className: amount, children: format.decimal(r.vat, 2) }), _jsx("td", { className: amount, children: format.decimal(r.total, 2) }), _jsx("td", { className: cell, children: t(`mushak.bands.${r.category}`) })] }, i))) })] }) }));
+    }
+    function Summary({ data }) {
+        const heading = (key) => (_jsx("tr", { className: "bg-muted font-semibold", children: _jsx("th", { colSpan: 4, scope: "colgroup", className: `${cell} text-start`, children: t(key) }) }));
+        const bands = (rows) => BANDS.map((b) => (_jsxs("tr", { className: "border-b", children: [_jsx("th", { scope: "row", className: `${cell} text-start font-normal`, children: t(`mushak.bands.${b}`) }), _jsx("td", { className: amount, children: format.decimal(rows[b].value, 2) }), _jsx("td", { className: amount, children: format.decimal(rows[b].sd, 2) }), _jsx("td", { className: amount, children: format.decimal(rows[b].vat, 2) })] }, b)));
+        const line = (key, value, column = 'vat') => (_jsxs("tr", { className: "border-b", children: [_jsx("th", { scope: "row", className: `${cell} text-start font-normal`, children: t(key) }), _jsx("td", { className: amount }), _jsx("td", { className: amount, children: column === 'sd' ? format.decimal(value, 2) : '' }), _jsx("td", { className: amount, children: column === 'vat' ? format.decimal(value, 2) : '' })] }));
+        return (_jsxs("table", { className: "w-full max-w-3xl text-sm", children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { className: `${cell} text-start`, children: _jsx("span", { className: "sr-only", children: t('mushak.form') }) }), _jsx("th", { className: `${cell} text-end`, children: t('mushak.value') }), _jsx("th", { className: `${cell} text-end`, children: t('mushak.sd') }), _jsx("th", { className: `${cell} text-end`, children: t('mushak.vat') })] }) }), _jsxs("tbody", { children: [heading('mushak.r91.supplies'), bands(data.supplies), heading('mushak.r91.purchases'), bands(data.purchases), heading('mushak.r91.increasing'), line('mushak.r91.vdsDeducted', data.vdsDeducted), heading('mushak.r91.decreasing'), line('mushak.r91.vdsByCustomers', data.vdsByCustomers), line('mushak.r91.advanceTax', data.advanceTax), heading('mushak.r91.net'), line('mushak.r91.outputVat', data.outputVat), line('mushak.r91.inputVat', data.inputVat), line('mushak.r91.sdPayable', data.sdPayable, 'sd')] }), _jsx("tfoot", { className: "font-semibold", children: _jsxs("tr", { children: [_jsx("th", { scope: "row", className: `${cell} text-start`, children: t('mushak.r91.netVat') }), _jsx("td", { className: amount }), _jsx("td", { className: amount }), _jsx("td", { className: amount, children: format.decimal(data.netVat, 2) })] }) })] }));
+    }
+}

package/dist/l10n_bd/web/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/l10n_bd`: the Mushak returns page (the sales and purchase registers and the
+ * monthly return).
+ */
+import { type Registry } from '../../ui/index.js';
+import type { i18n } from 'i18next';
+import { messages } from './messages.js';
+export { MushakPage } from './MushakPage.js';
+/** Registers the page (and the messages in `i18n`, when given). */
+export declare function registerL10nBdWeb(registry: Registry, i18n?: i18n): Registry;
+/** The messages, named as the starter project's back-office imports them (`<app>Messages`). */
+export { messages as l10n_bdMessages };