@ketvietlab/ketsuite 0.1.2 → 0.1.5

package/dist/modules/sale/functions.js

@@ -1,33 +1,95 @@
-import { defineFn } from '@ketvietlab/ketjs';
+import { dateBucket, defineFn, deleteFrom, desc, eq, from, gte, ilike, inArray, localDayRange, lt, or, } from '@ketvietlab/ketjs';
+import { insertDraftMove, quoteTaxLine, quoteTaxLineForPosting } from '../account/functions.js';
+import { addDecimals, compareDecimals, minorText, moneyMinor, scaleOf, subtractDecimals, sumMoneyMinor, } from '../account/money.js';
 import { functions as pricingFunctions } from '../pricing/functions.js';
+import { sellableProduct } from '../product/sellable.js';
 import { functions as stockFunctions } from '../stock/functions.js';
+import { company, companyKey, ours } from './scope.js';
 export const SALE_STATES = ['draft', 'sent', 'sale', 'cancel'];
 export const SALE_INVOICE_STATUSES = ['upselling', 'invoiced', 'to invoice', 'no'];
 export const INVOICE_POLICIES = ['order', 'delivery'];
 const invalid = (field, message) => ({ ok: false, errors: [{ field, message }] });
+const externalOrder = (order) => order?.orderAuthority != null && order.orderAuthority !== 'local';
+const authorityRefusal = () => invalid('orderAuthority', 'this order is managed by an external system');
 const n = (value) => Number(value ?? 0);
-const money = (value) => Math.round((value + Number.EPSILON) * 100) / 100;
-const decimal = (value) => String(money(value));
+const quantityRound = (value) => Math.round((value + Number.EPSILON) * 100) / 100;
+const quantityText = (value) => String(quantityRound(value));
 const now = () => new Date().toISOString();
+const wildcard = (value) => String(value ?? '').replace(/[\\%_]/g, '\\$&');
 async function companyCurrency(ctx) {
-    if (!ctx.scope.company)
-        throw new Error('sale requires an active company');
-    const company = (await ctx.db.select('company.Company', { id: ctx.scope.company }))[0];
-    if (!company)
-        throw new Error(`company ${ctx.scope.company} does not exist`);
-    return String(company.currency);
+    const row = (await ctx.db.select('company.Company', { id: company(ctx) }))[0];
+    if (!row)
+        throw new Error(`company ${company(ctx)} does not exist`);
+    return String(row.currency);
 }
+/**
+ * The next order number for this company.
+ *
+ * The sequence row is keyed by the company because `id` is a tenant-wide primary
+ * key: keyed by the constant `'sale'`, the first company to raise an order owned
+ * the only row there could ever be, and every other company either read a row it
+ * could never write — the update pins the active company, so it matched nothing
+ * and span out blaming concurrency — or found none at all and dereferenced
+ * undefined. Numbers stay per-company, which the `(companyId, name)` index on
+ * Order already assumed.
+ */
 async function nextName(ctx) {
-    await ctx.db.insertIfAbsent('sale.Sequence', { id: 'sale', nextNumber: 1 });
-    for (let attempt = 0; attempt < 32; attempt += 1) {
-        const row = (await ctx.db.select('sale.Sequence', { id: 'sale' }))[0];
+    const id = companyKey(ctx, 'sale');
+    await ctx.db.insertIfAbsent('sale.Sequence', { id, nextNumber: 1 });
+    // Every order in the company funnels through this one row, so a bulk import
+    // running in parallel is a stampede by design. Losing the compare-and-set is
+    // normal there; what must not happen is giving up while the row is live —
+    // that turns a perfectly valid order into a spurious failure. Retries back
+    // off with jitter so the herd spreads out instead of colliding again.
+    for (let attempt = 0; attempt < 64; attempt += 1) {
+        const row = (await ours(ctx, 'sale.Sequence', { id }))[0];
+        if (!row)
+            throw new Error('sale sequence row disappeared while assigning a number');
         const current = n(row.nextNumber);
-        const changed = await ctx.db.compareAndSet('sale.Sequence', { id: 'sale' }, { nextNumber: row.nextNumber }, { nextNumber: current + 1 });
+        const changed = await ctx.db.compareAndSet('sale.Sequence', { id }, { nextNumber: row.nextNumber }, { nextNumber: current + 1 });
         if ('dryRun' in changed || changed.matched)
             return `S${String(current).padStart(5, '0')}`;
+        if (attempt >= 2)
+            await new Promise((resolve) => setTimeout(resolve, Math.min(100, 2 ** (attempt - 2)) * (0.5 + Math.random())));
     }
     throw new Error('sale sequence did not settle after concurrent updates');
 }
+/**
+ * When an invoice on this payment term falls due.
+ *
+ * `account` computes the same thing for the invoices it raises (its `dueDate`),
+ * walking the term's lines and taking the latest maturity. Sale used to write the
+ * invoice date into both date fields while still storing the term on the move,
+ * so a thirty-day term produced an invoice that was overdue on the day it was
+ * issued.
+ */
+async function paymentTermDue(ctx, paymentTermId, date) {
+    if (!paymentTermId)
+        return date.toISOString();
+    const lines = (await ctx.db.select('account.PaymentTermLine', { paymentId: paymentTermId })).sort((a, b) => n(a.sequence) - n(b.sequence));
+    let latest = new Date(date);
+    for (const line of lines) {
+        const due = new Date(date);
+        const days = n(line.nbDays);
+        if (line.delayType === 'days_after')
+            due.setUTCDate(due.getUTCDate() + days);
+        else if (line.delayType === 'days_after_end_of_month') {
+            due.setUTCMonth(due.getUTCMonth() + 1, 0);
+            due.setUTCDate(due.getUTCDate() + days);
+        }
+        else if (line.delayType === 'days_after_end_of_next_month') {
+            due.setUTCMonth(due.getUTCMonth() + 2, 0);
+            due.setUTCDate(due.getUTCDate() + days);
+        }
+        else {
+            due.setUTCDate(due.getUTCDate() + days);
+            due.setUTCMonth(due.getUTCMonth() + 1, Math.max(1, Math.min(31, n(line.daysNextMonth) || 1)));
+        }
+        if (due > latest)
+            latest = due;
+    }
+    return latest.toISOString();
+}
 async function contextOf(ctx, productId) {
     const product = (await ctx.db.select('product.Product', { id: productId }))[0];
     if (!product)
@@ -35,52 +97,68 @@ async function contextOf(ctx, productId) {
     const template = (await ctx.db.select('product.Template', { id: product.templateId }))[0];
     return template ? { product, template } : null;
 }
-function taxAmounts(tax, gross, quantity) {
-    if (!tax)
-        return { untaxed: money(gross), tax: 0, total: money(gross) };
-    if (tax.amountType === 'group')
-        throw new Error('group taxes are outside the supported Odoo 19 subset');
-    const amount = n(tax.amount), rate = amount / 100;
-    let untaxed = money(gross), taxAmount = 0;
-    if (tax.amountType === 'fixed') {
-        taxAmount = money(amount * quantity);
-        if (tax.priceInclude)
-            untaxed = money(gross - taxAmount);
-        return { untaxed, tax: taxAmount, total: tax.priceInclude ? money(gross) : money(gross + taxAmount) };
-    }
-    if (tax.amountType === 'division') {
-        if (tax.priceInclude) {
-            untaxed = money(gross * (1 - rate));
-            taxAmount = money(gross - untaxed);
-        }
-        else
-            taxAmount = money(gross / (1 - rate) - gross);
-    }
-    else if (tax.priceInclude) {
-        untaxed = money(gross / (1 + rate));
-        taxAmount = money(gross - untaxed);
-    }
-    else
-        taxAmount = money(gross * rate);
-    return { untaxed, tax: taxAmount, total: money(untaxed + taxAmount) };
-}
 async function recompute(ctx, orderId) {
-    let untaxed = 0, tax = 0;
-    for (const line of await ctx.db.select('sale.OrderLine', { orderId })) {
-        const held = line.taxId ? ((await ctx.db.select('account.Tax', { id: line.taxId }))[0] ?? null) : null;
-        const gross = money(n(line.productUomQty) * n(line.priceUnit) * (1 - n(line.discount) / 100));
-        const amounts = taxAmounts(held, gross, n(line.productUomQty));
-        untaxed = money(untaxed + amounts.untaxed);
-        tax = money(tax + amounts.tax);
-    }
-    await ctx.db.update('sale.Order', { id: orderId }, { amountUntaxed: decimal(untaxed), amountTax: decimal(tax), amountTotal: decimal(untaxed + tax) });
+    const order = (await ours(ctx, 'sale.Order', { id: orderId }))[0];
+    if (!order)
+        return;
+    const scale = scaleOf(order.currency);
+    const lines = await ours(ctx, 'sale.OrderLine', { orderId });
+    const amounts = await Promise.all(lines.map(async (line) => {
+        if (line.priceSubtotalIncl != null)
+            return { untaxed: line.priceSubtotal, total: line.priceSubtotalIncl };
+        // Rows written before Wave 1B have no stored inclusive total. Re-quote them through the same
+        // account boundary; explicit [] preserves a historically tax-free line instead of applying a
+        // product default that may have been configured later.
+        const quote = await quoteTaxLine(ctx, {
+            productId: line.productId,
+            taxIds: line.taxIds ?? (line.taxId ? [line.taxId] : []),
+            quantity: line.productUomQty,
+            priceUnit: line.priceUnit,
+            discount: line.discount,
+        });
+        if (quote.ok !== true)
+            return { untaxed: line.priceSubtotal, total: line.priceSubtotal };
+        return { untaxed: quote.amountUntaxed, total: quote.amountTotal };
+    }));
+    const untaxed = sumMoneyMinor(amounts.map((line) => line.untaxed), scale);
+    const total = sumMoneyMinor(amounts.map((line) => line.total), scale);
+    const tax = total - untaxed;
+    await ctx.db.update('sale.Order', { id: orderId }, {
+        amountUntaxed: minorText(untaxed, scale),
+        amountTax: minorText(tax, scale),
+        amountTotal: minorText(total, scale),
+        revision: n(order.revision) + 1,
+    });
+}
+/**
+ * The stock moves and invoice lines behind an order's lines.
+ *
+ * Both used to be found by reading the whole table and filtering in JS. A
+ * tenant that has imported a real order history holds hundreds of thousands of
+ * moves, so an order-detail page was reading the entire ledger to find the
+ * handful of rows that belong to one order. The `saleLineId` relation is
+ * auto-indexed, so these are index lookups now.
+ */
+async function movesOf(ctx, lineIds) {
+    if (!lineIds.length)
+        return [];
+    const M = ctx.table('stock.Move');
+    return ctx.db.all(from(M).where(inArray(M.saleLineId, lineIds)));
+}
+async function invoiceLinesOf(ctx, lineIds) {
+    if (!lineIds.length)
+        return [];
+    const L = ctx.table('account.MoveLine');
+    return ctx.db.all(from(L).where(inArray(L.saleLineId, lineIds)));
 }
 async function statusOf(ctx, orderId) {
-    const order = (await ctx.db.select('sale.Order', { id: orderId }))[0];
+    const order = (await ours(ctx, 'sale.Order', { id: orderId }))[0];
     if (order?.state !== 'sale')
         return 'no';
+    if (order.invoiceAuthority != null && order.invoiceAuthority !== 'local')
+        return 'no';
     let billable = 0, invoiced = 0, ordered = 0;
-    for (const line of await ctx.db.select('sale.OrderLine', { orderId })) {
+    for (const line of await ours(ctx, 'sale.OrderLine', { orderId })) {
         const context = await contextOf(ctx, line.productId);
         const policy = String(context?.template.invoicePolicy ?? 'order');
         ordered += n(line.productUomQty);
@@ -94,10 +172,32 @@ async function statusOf(ctx, orderId) {
 async function refreshStatus(ctx, orderId) {
     await ctx.db.update('sale.Order', { id: orderId }, { invoiceStatus: await statusOf(ctx, orderId) });
 }
+/**
+ * Append one durable lifecycle fact for an order.
+ *
+ * The deterministic id and unique domain key make this safe to call from both
+ * the mutation path and an idempotent replay. Downstream modules consume the
+ * ledger independently; Sale does not know which bridges are installed.
+ */
+async function recordOrderLifecycle(ctx, orderId, phase, occurredAt = now()) {
+    const order = (await ours(ctx, 'sale.Order', { id: orderId }))[0];
+    if (!order)
+        return;
+    await ctx.db.insertIfAbsent('sale.OrderLifecycleEvent', {
+        id: companyKey(ctx, 'sale-order-lifecycle', String(orderId), phase),
+        orderId,
+        phase,
+        orderRevision: order.revision ?? null,
+        occurredAt,
+        createdAt: now(),
+    });
+}
 const confirmEffects = [
     'read:sale.Order',
     'read:sale.OrderLine',
     'write:sale.Order',
+    'read:sale.OrderLifecycleEvent',
+    'write:sale.OrderLifecycleEvent',
     'read:product.Product',
     'read:product.Template',
     'read:uom.Unit',
@@ -107,15 +207,43 @@ const confirmEffects = [
     'write:stock.Picking',
     'write:stock.Move',
 ];
-async function confirm(ctx, id) {
-    const order = (await ctx.db.select('sale.Order', { id }))[0];
+/**
+ * A refusal thrown so the transaction it happened inside rolls back.
+ *
+ * `adapter.tx` commits on a normal return, so a soft error returned from inside
+ * one would commit the half-built delivery it is refusing over.
+ */
+class SaleRefused extends Error {
+    result;
+    constructor(result) {
+        super('refused');
+        this.result = result;
+    }
+}
+const claimRevision = async (ctx, order, expectedRevision) => {
+    const revision = n(order.revision);
+    if (expectedRevision !== undefined && revision !== n(expectedRevision))
+        return false;
+    const changed = await ctx.db.compareAndSet('sale.Order', { id: order.id }, { revision: order.revision ?? null }, { revision: revision + 1 });
+    return 'dryRun' in changed || changed.matched;
+};
+async function confirm(ctx, id, expectedRevision) {
+    const order = (await ours(ctx, 'sale.Order', { id }))[0];
     if (!order)
         return invalid('id', 'sales order does not exist');
-    if (order.state === 'sale')
+    if (externalOrder(order))
+        return authorityRefusal();
+    if (order.stockAuthority != null && !['local', 'external'].includes(String(order.stockAuthority)))
+        return invalid('stockAuthority', 'unknown stock authority');
+    if (expectedRevision !== undefined && n(order.revision) !== n(expectedRevision))
+        return invalid('expectedRevision', 'sales order changed');
+    if (order.state === 'sale') {
+        await recordOrderLifecycle(ctx, id, 'confirmed');
         return { ok: true, id, state: 'sale' };
+    }
     if (!['draft', 'sent'].includes(String(order.state)))
         return invalid('state', 'only a quotation can be confirmed');
-    const lines = await ctx.db.select('sale.OrderLine', { orderId: id });
+    const lines = await ours(ctx, 'sale.OrderLine', { orderId: id });
     if (!lines.length)
         return invalid('lines', 'a quotation needs at least one product line');
     const goods = [];
@@ -124,34 +252,55 @@ async function confirm(ctx, id) {
         if (context && context.template.type !== 'service')
             goods.push(line);
     }
+    // One transaction for the picking, its moves, their links and the state
+    // change. Unwrapped, a crash between `addMove` and the `saleLineId` update
+    // left a move with no link back to its line — and `cancelOrder`, which finds
+    // an order's moves by that link, could never cancel it: an orphan demanding
+    // stock forever, on an order still reading draft.
     let pickingId;
-    if (goods.length) {
-        pickingId = `${String(id)}:delivery`;
-        const created = (await stockFunctions.createPicking.handler(ctx, {
-            id: pickingId,
-            name: `Delivery ${String(order.name)}`,
-            pickingTypeId: `${String(order.warehouseId)}:outgoing`,
-            scheduledDate: order.dateOrder,
-        }));
-        if (created.ok !== true)
-            return created;
-        for (const line of goods) {
-            const moveId = `${String(line.id)}:delivery`;
-            const moved = (await stockFunctions.addMove.handler(ctx, {
-                id: moveId,
-                name: line.name,
-                pickingId,
-                productId: line.productId,
-                productUomId: line.productUomId,
-                productUomQty: line.productUomQty,
-                origin: order.name,
-            }));
-            if (moved.ok !== true)
-                return moved;
-            await ctx.db.update('stock.Move', { id: moveId }, { saleLineId: line.id });
-        }
+    try {
+        await ctx.tx(async (tx) => {
+            const current = (await ours(tx, 'sale.Order', { id }))[0];
+            if (!current || !(await claimRevision(tx, current, expectedRevision)))
+                throw new SaleRefused(invalid('expectedRevision', 'sales order changed'));
+            if (goods.length && current.stockAuthority !== 'external') {
+                pickingId = `${String(id)}:delivery`;
+                const created = (await stockFunctions.createPicking.handler(tx, {
+                    id: pickingId,
+                    name: `Delivery ${String(order.name)}`,
+                    pickingTypeId: `${String(order.warehouseId)}:outgoing`,
+                    scheduledDate: order.dateOrder,
+                }));
+                if (created.ok !== true)
+                    throw new SaleRefused(created);
+                for (const line of goods) {
+                    const moveId = `${String(line.id)}:delivery`;
+                    const moved = (await stockFunctions.addMove.handler(tx, {
+                        id: moveId,
+                        name: line.name,
+                        pickingId,
+                        productId: line.productId,
+                        productUomId: line.productUomId,
+                        productUomQty: line.productUomQty,
+                        origin: order.name,
+                    }));
+                    if (moved.ok !== true)
+                        throw new SaleRefused(moved);
+                    await tx.db.update('stock.Move', { id: moveId }, { saleLineId: line.id });
+                }
+            }
+            // The order keeps the date it was raised with. Stamping now() here wrote
+            // migration day onto every imported historical order the moment it was
+            // confirmed, and revenue-by-date was silently wrong from then on.
+            await tx.db.update('sale.Order', { id }, { state: 'sale' });
+            await recordOrderLifecycle(tx, id, 'confirmed');
+        });
+    }
+    catch (error) {
+        if (error instanceof SaleRefused)
+            return error.result;
+        throw error;
     }
-    await ctx.db.update('sale.Order', { id }, { state: 'sale', dateOrder: now() });
     await refreshStatus(ctx, id);
     return { ok: true, id, state: 'sale', ...(pickingId ? { pickingId } : {}) };
 }
@@ -178,13 +327,111 @@ export const functions = {
         },
     }),
     listOrders: defineFn({
-        input: { state: 'text?', partnerId: 'id?' },
+        input: {
+            state: 'text?',
+            states: 'json?',
+            partnerId: 'id?',
+            search: 'text?',
+            // A caller reporting on a window wants that window, not the history in
+            // front of it. Without these it had to page until the table ran out and
+            // discard the rest in memory, which is the cost this list was bounded to
+            // avoid in the first place.
+            dateFrom: 'datetime?',
+            dateTo: 'datetime?',
+            limit: 'int?',
+            offset: 'int?',
+        },
         effects: ['read:sale.Order'],
         agent: true,
-        handler: (ctx, args) => ctx.db.select('sale.Order', {
-            ...(args.state ? { state: args.state } : {}),
-            ...(args.partnerId ? { partnerId: args.partnerId } : {}),
-        }),
+        // Bounded and newest-first. Unbounded, a tenant with an imported order
+        // history handed the whole table to every caller — the quotations screen
+        // was loading six figures of rows to show a page.
+        handler: async (ctx, args) => {
+            const O = ctx.table('sale.Order');
+            const states = Array.isArray(args.states) ? args.states.map(String) : [];
+            const limit = Math.max(1, Math.min(Math.trunc(Number(args.limit) || 500), 2_000));
+            return ctx.db.all(from(O)
+                .where(eq(O.companyId, company(ctx)), ...(args.state ? [eq(O.state, String(args.state))] : []), ...(states.length ? [inArray(O.state, states)] : []), ...(args.partnerId ? [eq(O.partnerId, String(args.partnerId))] : []), ...(args.dateFrom ? [gte(O.dateOrder, String(args.dateFrom))] : []), ...(args.dateTo ? [lt(O.dateOrder, String(args.dateTo))] : []), ...(args.search
+                ? [
+                    or(ilike(O.name, `%${wildcard(args.search)}%`, true), ilike(O.clientOrderRef, `%${wildcard(args.search)}%`, true)),
+                ]
+                : []))
+                .orderBy(desc(O.dateOrder), desc(O.id))
+                .limit(limit)
+                .offset(Math.max(0, Math.trunc(Number(args.offset) || 0))));
+        },
+    }),
+    /**
+     * The dashboard's numbers, counted where the rows live.
+     *
+     * The dashboard used to load every order to count four subsets of them. At
+     * import scale that is six figures of rows materialised per view — and once
+     * the list is bounded, counting a page would simply be wrong.
+     */
+    countOrders: defineFn({
+        input: { timezone: 'text?' },
+        output: {
+            draft: 'int',
+            sent: 'int',
+            sale: 'int',
+            toInvoice: 'int',
+            draftToday: 'int',
+            sentTotal: 'decimal',
+            saleTotal: 'decimal',
+            toInvoiceTotal: 'decimal',
+            currency: 'text',
+        },
+        effects: ['read:sale.Order', 'read:company.Company'],
+        agent: true,
+        handler: async (ctx, args) => {
+            const O = ctx.table('sale.Order');
+            const mine = eq(O.companyId, company(ctx));
+            const currency = await companyCurrency(ctx);
+            // Amounts are summed for the company's own currency and no other. Every
+            // order takes that currency when it is raised, so in practice this is all
+            // of them; what it rules out is a company that changed currency later
+            // having its old đồng added to its new dollars and shown as one figure.
+            const priced = eq(O.currency, currency);
+            // "Today" is the reader's today. The timezone is the viewer's, so a
+            // quotation raised at nine in Ho Chi Minh City counts on the day it was
+            // raised rather than on the day it was in London.
+            const timezone = String(args.timezone ?? 'UTC');
+            const [dayStart, dayEnd] = localDayRange(dateBucket(now(), 'day', timezone) ?? '1970-01-01', timezone);
+            const scale = scaleOf(currency);
+            const countOf = (rows, key) => rows.find((row) => row.key[0] === key)?.count ?? 0;
+            const totalOf = (rows, key) => {
+                const amount = rows.find((row) => row.key[0] === key)?.aggregates.amount ?? '0';
+                return minorText(moneyMinor(String(amount), scale), scale);
+            };
+            // Grouped aggregates keep this response proportional to the number of
+            // states, not the number (or byte width) of imported orders. In
+            // particular, never materialise six figures of full Order rows in the
+            // application process just to add one decimal column.
+            const [stateGroups, invoiceGroups, stateTotals, invoiceTotals, draftToday] = await Promise.all([
+                ctx.db.group(from(O).where(mine).groupBy({ col: O.state })),
+                ctx.db.group(from(O).where(mine).groupBy({ col: O.invoiceStatus })),
+                ctx.db.group(from(O)
+                    .where(mine, priced)
+                    .groupBy({ col: O.state })
+                    .aggregate({ fn: 'sum', col: O.amountTotal, as: 'amount' })),
+                ctx.db.group(from(O)
+                    .where(mine, priced)
+                    .groupBy({ col: O.invoiceStatus })
+                    .aggregate({ fn: 'sum', col: O.amountTotal, as: 'amount' })),
+                ctx.db.count(from(O).where(mine, eq(O.state, 'draft'), gte(O.dateOrder, dayStart), lt(O.dateOrder, dayEnd))),
+            ]);
+            return {
+                draft: countOf(stateGroups, 'draft'),
+                sent: countOf(stateGroups, 'sent'),
+                sale: countOf(stateGroups, 'sale'),
+                toInvoice: countOf(invoiceGroups, 'to invoice'),
+                draftToday,
+                sentTotal: totalOf(stateTotals, 'sent'),
+                saleTotal: totalOf(stateTotals, 'sale'),
+                toInvoiceTotal: totalOf(invoiceTotals, 'to invoice'),
+                currency,
+            };
+        },
     }),
     getOrder: defineFn({
         input: { id: 'id' },
@@ -192,23 +439,31 @@ export const functions = {
             'read:sale.Order',
             'read:sale.OrderLine',
             'read:stock.Move',
+            'read:stock.Picking',
             'read:account.MoveLine',
             'read:account.Move',
         ],
         agent: true,
         handler: async (ctx, args) => {
-            const order = (await ctx.db.select('sale.Order', { id: args.id }))[0];
+            const order = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
             if (!order)
                 return null;
-            const lines = await ctx.db.select('sale.OrderLine', { orderId: args.id });
-            const moves = (await ctx.db.select('stock.Move')).filter((move) => lines.some((line) => line.id === move.saleLineId));
-            const invoiceLines = (await ctx.db.select('account.MoveLine')).filter((line) => lines.some((held) => held.id === line.saleLineId));
+            const lines = await ours(ctx, 'sale.OrderLine', { orderId: args.id });
+            const lineIds = lines.map((line) => String(line.id));
+            const moves = await movesOf(ctx, lineIds);
+            const pickingIds = [
+                ...new Set(moves.flatMap((move) => (move.pickingId ? [String(move.pickingId)] : []))),
+            ];
+            const invoiceLines = await invoiceLinesOf(ctx, lineIds);
             const ids = [...new Set(invoiceLines.map((line) => String(line.moveId)))];
+            const A = ctx.table('account.Move');
+            const P = ctx.table('stock.Picking');
             return {
                 ...order,
                 lines,
                 moves,
-                invoices: (await ctx.db.select('account.Move')).filter((move) => ids.includes(String(move.id))),
+                pickings: pickingIds.length ? await ctx.db.all(from(P).where(inArray(P.id, pickingIds))) : [],
+                invoices: ids.length ? await ctx.db.all(from(A).where(inArray(A.id, ids))) : [],
             };
         },
     }),
@@ -239,17 +494,22 @@ export const functions = {
         idempotent: true,
         agent: true,
         handler: async (ctx, args) => {
-            const existing = (await ctx.db.select('sale.Order', { id: args.id }))[0];
+            const existing = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
             if (existing)
                 return { ok: true, id: args.id, name: existing.name };
             if (!(await ctx.db.select('partner.Partner', { id: args.partnerId }))[0])
                 return invalid('partnerId', 'customer does not exist');
-            if (!(await ctx.db.select('stock.Warehouse', { id: args.warehouseId }))[0])
+            if (!(await ours(ctx, 'stock.Warehouse', { id: args.warehouseId }))[0])
                 return invalid('warehouseId', 'warehouse does not exist');
             if (args.pricelistId && !(await ctx.db.select('pricing.Pricelist', { id: args.pricelistId }))[0])
                 return invalid('pricelistId', 'pricelist does not exist');
             const name = await nextName(ctx), dateOrder = String(args.dateOrder ?? now());
-            await ctx.db.insert('sale.Order', {
+            // Two callers deciding on the same order at the same moment — a scheduled
+            // import and a webhook delivering the same external order — both pass the
+            // existence check above. The primary key settles it; the loser reads the
+            // winner's row and answers ok, which is what `idempotent` promises. The
+            // loser's sequence number is burned, which is the cheaper casualty.
+            const inserted = await ctx.db.insertIfAbsent('sale.Order', {
                 id: args.id,
                 name,
                 partnerId: args.partnerId,
@@ -267,7 +527,12 @@ export const functions = {
                 amountTax: '0',
                 amountTotal: '0',
                 notes: args.notes ?? null,
+                revision: 0,
             });
+            if (!('dryRun' in inserted) && !inserted.inserted) {
+                const winner = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
+                return { ok: true, id: args.id, name: winner?.name ?? name };
+            }
             return { ok: true, id: args.id, name };
         },
     }),
@@ -282,6 +547,8 @@ export const functions = {
             priceUnit: 'decimal?',
             discount: 'decimal?',
             taxId: 'id?',
+            taxIds: 'json?',
+            quoteRevision: 'text?',
             sequence: 'int?',
         },
         output: { ok: 'bool', id: 'id?', priceUnit: 'decimal?', errors: 'json?' },
@@ -292,24 +559,33 @@ export const functions = {
             'write:sale.Order',
             'read:product.Product',
             'read:product.Template',
+            'read:product.TemplateUom',
+            'read:product.ProductUom',
             'read:product.Category',
             'read:product.Cost',
             'read:uom.Unit',
             'read:pricing.Pricelist',
             'read:pricing.PricelistItem',
             'read:account.Tax',
+            'read:account.ProductTax',
+            'read:company.Company',
         ],
         idempotent: true,
         agent: true,
         handler: async (ctx, args) => {
-            const order = (await ctx.db.select('sale.Order', { id: args.orderId }))[0];
+            const order = (await ours(ctx, 'sale.Order', { id: args.orderId }))[0];
+            if (externalOrder(order))
+                return authorityRefusal();
             if (!order || !['draft', 'sent'].includes(String(order.state)) || order.locked)
                 return invalid('orderId', 'lines can only be added to an unlocked quotation');
-            if (!(n(args.productUomQty) > 0))
+            if (compareDecimals(args.productUomQty, '0') <= 0)
                 return invalid('productUomQty', 'ordered quantity must be positive');
-            const context = await contextOf(ctx, args.productId);
-            if (!context?.template.saleOk)
-                return invalid('productId', 'product is not sellable');
+            const sellable = await sellableProduct(ctx, args.productId, args.productUomId, {
+                allowMeasurementTreeUom: true,
+            });
+            if (!sellable.ok)
+                return invalid(sellable.field === 'uomId' ? 'productUomId' : sellable.field, sellable.message);
+            const context = sellable.value;
             let priceUnit = args.priceUnit;
             if (priceUnit === undefined && order.pricelistId) {
                 const priced = (await pricingFunctions.priceFor.handler(ctx, {
@@ -325,20 +601,23 @@ export const functions = {
             }
             priceUnit ??= context.template.listPrice;
             const discount = args.discount ?? '0';
-            if (n(priceUnit) < 0 || n(discount) < 0 || n(discount) > 100)
+            if (compareDecimals(priceUnit, '0') < 0 ||
+                compareDecimals(discount, '0') < 0 ||
+                compareDecimals(discount, '100') > 0)
                 return invalid('priceUnit', 'unit price and discount are invalid');
-            const tax = args.taxId ? (await ctx.db.select('account.Tax', { id: args.taxId }))[0] : null;
-            if (args.taxId && (!tax || !['sale', 'none'].includes(String(tax.typeTaxUse))))
-                return invalid('taxId', 'tax use does not match a sales order');
-            const gross = money(n(args.productUomQty) * n(priceUnit) * (1 - n(discount) / 100));
-            let subtotal;
-            try {
-                subtotal = taxAmounts(tax, gross, n(args.productUomQty)).untaxed;
-            }
-            catch (error) {
-                return invalid('taxId', error.message);
-            }
-            if (!(await ctx.db.select('sale.OrderLine', { id: args.id }))[0])
+            // Keep the established Sales contract: omitting tax means tax-free. POS resolves the product
+            // default explicitly through its own quote boundary before creating a line.
+            const taxIds = args.taxIds !== undefined ? args.taxIds : args.taxId ? [args.taxId] : [];
+            const quote = await quoteTaxLine(ctx, {
+                productId: args.productId,
+                taxIds,
+                quantity: args.productUomQty,
+                priceUnit,
+                discount,
+            });
+            if (quote.ok !== true)
+                return quote;
+            if (!(await ours(ctx, 'sale.OrderLine', { id: args.id }))[0])
                 await ctx.db.insert('sale.OrderLine', {
                     id: args.id,
                     orderId: args.orderId,
@@ -348,16 +627,190 @@ export const functions = {
                     productUomId: args.productUomId,
                     priceUnit: String(priceUnit),
                     discount: String(discount),
-                    taxId: args.taxId ?? null,
+                    taxId: quote.taxIds[0] ?? null,
+                    taxIds: quote.taxIds,
+                    taxEvidence: { currency: quote.currency, scale: quote.scale, taxes: quote.taxes },
+                    quoteRevision: args.quoteRevision ?? null,
                     qtyDelivered: '0',
                     qtyInvoiced: '0',
-                    priceSubtotal: decimal(subtotal),
+                    priceSubtotal: quote.amountUntaxed,
+                    priceSubtotalIncl: quote.amountTotal,
                     sequence: args.sequence ?? 10,
                 });
             await recompute(ctx, args.orderId);
             return { ok: true, id: args.id, priceUnit: String(priceUnit) };
         },
     }),
+    saveDraft: defineFn({
+        input: {
+            id: 'id',
+            partnerId: 'id',
+            warehouseId: 'id',
+            clientOrderRef: 'text?',
+            notes: 'text?',
+            lines: 'json',
+            create: 'bool?',
+            expectedRevision: 'int?',
+        },
+        output: { ok: 'bool', id: 'id?', revision: 'int?', errors: 'json?' },
+        effects: [
+            'read:sale.Sequence',
+            'write:sale.Sequence',
+            'read:sale.Order',
+            'write:sale.Order',
+            'read:sale.OrderLine',
+            'write:sale.OrderLine',
+            'read:partner.Partner',
+            'read:partner.Role',
+            'read:stock.Warehouse',
+            'read:product.Product',
+            'read:product.Template',
+            'read:product.TemplateUom',
+            'read:product.ProductUom',
+            'read:product.Category',
+            'read:product.Cost',
+            'read:uom.Unit',
+            'read:pricing.Pricelist',
+            'read:pricing.PricelistItem',
+            'read:account.PaymentTerm',
+            'read:account.Tax',
+            'read:account.ProductTax',
+            'read:company.Company',
+        ],
+        idempotent: true,
+        agent: true,
+        handler: async (ctx, args) => {
+            const lines = Array.isArray(args.lines) ? args.lines : [];
+            if (!args.create && args.expectedRevision === undefined)
+                return invalid('expectedRevision', 'sales order version is required');
+            if (!lines.length || lines.length > 100)
+                return invalid('lines', 'a draft needs 1 to 100 lines');
+            if (lines.some((line) => !line ||
+                typeof line !== 'object' ||
+                !line.id ||
+                !line.productId ||
+                !line.productUomId ||
+                !(n(line.productUomQty) > 0)))
+                return invalid('lines', 'every line needs a product, unit and positive quantity');
+            try {
+                await ctx.tx(async (tx) => {
+                    let order = (await ours(tx, 'sale.Order', { id: args.id }))[0];
+                    if (externalOrder(order))
+                        throw new SaleRefused(authorityRefusal());
+                    if (args.create && order)
+                        return;
+                    if (!order) {
+                        if (!args.create)
+                            throw new SaleRefused(invalid('id', 'sales order does not exist'));
+                        const created = (await functions.createOrder.handler(tx, {
+                            id: args.id,
+                            partnerId: args.partnerId,
+                            warehouseId: args.warehouseId,
+                            clientOrderRef: args.clientOrderRef,
+                            notes: args.notes,
+                        }));
+                        if (created.ok !== true)
+                            throw new SaleRefused(created);
+                        order = (await ours(tx, 'sale.Order', { id: args.id }))[0];
+                    }
+                    else {
+                        if (order.state !== 'draft' || order.locked)
+                            throw new SaleRefused(invalid('state', 'only an unlocked quotation can be updated'));
+                        if (!(await claimRevision(tx, order, args.expectedRevision)))
+                            throw new SaleRefused(invalid('expectedRevision', 'sales order changed'));
+                    }
+                    if (!order)
+                        throw new SaleRefused(invalid('id', 'sales order does not exist'));
+                    if (!(await tx.db.select('partner.Partner', { id: args.partnerId }))[0])
+                        throw new SaleRefused(invalid('partnerId', 'customer does not exist'));
+                    if (!(await tx.db.select('partner.Role', { partnerId: args.partnerId, role: 'customer' }))[0])
+                        throw new SaleRefused(invalid('partnerId', 'partner is not an active customer'));
+                    if (!(await ours(tx, 'stock.Warehouse', { id: args.warehouseId }))[0])
+                        throw new SaleRefused(invalid('warehouseId', 'warehouse does not exist'));
+                    await tx.db.update('sale.Order', { id: args.id }, {
+                        partnerId: args.partnerId,
+                        warehouseId: args.warehouseId,
+                        clientOrderRef: args.clientOrderRef ?? null,
+                        notes: args.notes ?? null,
+                    });
+                    const L = tx.table('sale.OrderLine');
+                    await tx.db.del(deleteFrom(L).where(eq(L.orderId, String(args.id))));
+                    for (const [index, line] of lines.entries()) {
+                        const added = (await functions.addLine.handler(tx, {
+                            id: line.id,
+                            orderId: args.id,
+                            productId: line.productId,
+                            productUomQty: line.productUomQty,
+                            productUomId: line.productUomId,
+                            sequence: (index + 1) * 10,
+                        }));
+                        if (added.ok !== true)
+                            throw new SaleRefused(added);
+                    }
+                });
+            }
+            catch (error) {
+                if (error instanceof SaleRefused)
+                    return error.result;
+                throw error;
+            }
+            const order = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
+            return { ok: true, id: args.id, revision: n(order?.revision) };
+        },
+    }),
+    removeLine: defineFn({
+        input: { id: 'id' },
+        output: { ok: 'bool', id: 'id?', orderId: 'id?', errors: 'json?' },
+        effects: [
+            'read:sale.Order',
+            'read:sale.OrderLine',
+            'write:sale.OrderLine',
+            'write:sale.Order',
+            'read:account.Tax',
+            'read:company.Company',
+        ],
+        idempotent: true,
+        agent: true,
+        // A line could be added and never taken back. A quotation with the wrong
+        // product on it had to be abandoned and raised again under a new number,
+        // because nothing in `sale` — function or route — could remove a line.
+        handler: async (ctx, args) => {
+            const line = (await ours(ctx, 'sale.OrderLine', { id: args.id }))[0];
+            if (!line)
+                return { ok: true, id: args.id };
+            const order = (await ours(ctx, 'sale.Order', { id: line.orderId }))[0];
+            if (externalOrder(order))
+                return authorityRefusal();
+            if (!order || !['draft', 'sent'].includes(String(order.state)) || order.locked)
+                return invalid('id', 'lines can only be removed from an unlocked quotation');
+            const L = ctx.table('sale.OrderLine');
+            await ctx.db.del(deleteFrom(L).where(eq(L.id, String(args.id))));
+            await recompute(ctx, line.orderId);
+            return { ok: true, id: args.id, orderId: line.orderId };
+        },
+    }),
+    resetOrder: defineFn({
+        input: { id: 'id' },
+        output: { ok: 'bool', id: 'id?', errors: 'json?' },
+        effects: ['read:sale.Order', 'write:sale.Order'],
+        idempotent: true,
+        agent: true,
+        // Cancelling was terminal: a cancelled order rendered no actions at all, so
+        // one mis-click spent an order number and stranded its lines forever. Only a
+        // cancelled order comes back, and it comes back as a draft — a confirmed
+        // order has deliveries behind it and must be cancelled first.
+        handler: async (ctx, args) => {
+            const order = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
+            if (!order)
+                return invalid('id', 'sales order does not exist');
+            if (order.state !== 'cancel')
+                return invalid('state', 'only a cancelled order can return to draft');
+            if (externalOrder(order))
+                return authorityRefusal();
+            await ctx.db.update('sale.Order', { id: args.id }, { state: 'draft', locked: false, revision: n(order.revision) + 1 });
+            return { ok: true, id: args.id };
+        },
+    }),
     sendQuotation: defineFn({
         input: { id: 'id' },
         output: { ok: 'bool', id: 'id?', errors: 'json?' },
@@ -365,20 +818,22 @@ export const functions = {
         idempotent: true,
         agent: true,
         handler: async (ctx, args) => {
-            const order = (await ctx.db.select('sale.Order', { id: args.id }))[0];
+            const order = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
             if (!order || !['draft', 'sent'].includes(String(order.state)))
                 return invalid('state', 'only a draft quotation can be sent');
-            await ctx.db.update('sale.Order', { id: args.id }, { state: 'sent' });
+            if (externalOrder(order))
+                return authorityRefusal();
+            await ctx.db.update('sale.Order', { id: args.id }, { state: 'sent', revision: n(order.revision) + 1 });
             return { ok: true, id: args.id };
         },
     }),
     confirmOrder: defineFn({
-        input: { id: 'id' },
+        input: { id: 'id', expectedRevision: 'int?' },
         output: { ok: 'bool', id: 'id?', state: 'text?', pickingId: 'id?', errors: 'json?' },
         effects: [...confirmEffects],
         idempotent: true,
         agent: true,
-        handler: (ctx, args) => confirm(ctx, args.id),
+        handler: (ctx, args) => confirm(ctx, args.id, args.expectedRevision),
     }),
     syncDeliveries: defineFn({
         input: { id: 'id' },
@@ -388,6 +843,8 @@ export const functions = {
             'read:sale.OrderLine',
             'write:sale.OrderLine',
             'write:sale.Order',
+            'read:sale.OrderLifecycleEvent',
+            'write:sale.OrderLifecycleEvent',
             'read:stock.Move',
             'read:product.Product',
             'read:product.Template',
@@ -395,13 +852,28 @@ export const functions = {
         idempotent: true,
         agent: true,
         handler: async (ctx, args) => {
-            if (!(await ctx.db.select('sale.Order', { id: args.id }))[0])
+            const held = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
+            if (!held)
                 return invalid('id', 'sales order does not exist');
-            for (const line of await ctx.db.select('sale.OrderLine', { orderId: args.id })) {
+            if (held.stockAuthority === 'external')
+                return { ok: true, id: args.id, invoiceStatus: await statusOf(ctx, args.id) };
+            if (held.stockAuthority != null && held.stockAuthority !== 'local')
+                return invalid('stockAuthority', 'unknown stock authority');
+            for (const line of await ours(ctx, 'sale.OrderLine', { orderId: args.id })) {
                 const moves = await ctx.db.select('stock.Move', { saleLineId: line.id, state: 'done' });
-                await ctx.db.update('sale.OrderLine', { id: line.id }, { qtyDelivered: decimal(moves.reduce((sum, move) => sum + n(move.quantity), 0)) });
+                await ctx.db.update('sale.OrderLine', { id: line.id }, { qtyDelivered: quantityText(moves.reduce((sum, move) => sum + n(move.quantity), 0)) });
             }
             await refreshStatus(ctx, args.id);
+            const order = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
+            if (order?.state === 'sale') {
+                const lines = await ours(ctx, 'sale.OrderLine', { orderId: args.id });
+                const required = lines.reduce((sum, line) => sum + n(line.productUomQty), 0);
+                const delivered = lines.reduce((sum, line) => sum + n(line.qtyDelivered), 0);
+                if (required > 0 && delivered + 0.000001 >= required)
+                    await recordOrderLifecycle(ctx, args.id, 'delivered');
+                else if (delivered > 0)
+                    await recordOrderLifecycle(ctx, args.id, 'shipped');
+            }
             return { ok: true, id: args.id, invoiceStatus: await statusOf(ctx, args.id) };
         },
     }),
@@ -426,6 +898,9 @@ export const functions = {
             'read:account.Journal',
             'read:account.Account',
             'read:account.Tax',
+            'read:account.ProductTax',
+            // paymentTermDue walks the term's lines to work out when this falls due.
+            'read:account.PaymentTermLine',
             'read:account.Move',
             'read:company.Company',
             'write:account.Move',
@@ -434,9 +909,11 @@ export const functions = {
         idempotent: true,
         agent: true,
         handler: async (ctx, args) => {
-            const order = (await ctx.db.select('sale.Order', { id: args.orderId }))[0];
+            const order = (await ours(ctx, 'sale.Order', { id: args.orderId }))[0];
             if (order?.state !== 'sale')
                 return invalid('orderId', 'only a confirmed sales order can be invoiced');
+            if (order.invoiceAuthority != null && order.invoiceAuthority !== 'local')
+                return invalid('invoiceAuthority', 'invoicing is disabled for this order');
             const existing = (await ctx.db.select('account.Move', { id: args.id }))[0];
             if (existing)
                 return { ok: true, id: args.id, amountTotal: existing.amountTotal };
@@ -448,117 +925,180 @@ export const functions = {
             if (receivable?.accountType !== 'asset_receivable')
                 return invalid('receivableAccountId', 'a receivable account is required');
             const billable = [];
-            for (const line of await ctx.db.select('sale.OrderLine', { orderId: args.orderId })) {
-                const context = await contextOf(ctx, line.productId), policy = String(context?.template.invoicePolicy ?? 'order');
-                const basis = policy === 'delivery' ? n(line.qtyDelivered) : n(line.productUomQty), quantity = money(basis - n(line.qtyInvoiced));
-                if (quantity <= 0)
-                    continue;
-                const gross = money(quantity * n(line.priceUnit) * (1 - n(line.discount) / 100)), tax = line.taxId ? ((await ctx.db.select('account.Tax', { id: line.taxId }))[0] ?? null) : null;
-                const amounts = taxAmounts(tax, gross, quantity);
-                if (amounts.tax &&
-                    (!args.taxAccountId || !(await ctx.db.select('account.Account', { id: args.taxAccountId }))[0]))
-                    return invalid('taxAccountId', 'a valid tax account is required');
-                billable.push({ line, quantity, subtotal: amounts.untaxed, tax, taxAmount: amounts.tax });
+            // A soft error raised once the transaction has started writing has to
+            // unwind it: `adapter.tx` commits on a normal return and rolls back only on
+            // a throw, so returning the error would leave a half-written invoice behind.
+            class Refused extends Error {
+                result;
+                constructor(result) {
+                    super('refused');
+                    this.result = result;
+                }
             }
-            if (!billable.length)
-                return invalid('lines', 'there is no ordered or delivered quantity left to invoice');
-            const untaxed = money(billable.reduce((sum, item) => sum + item.subtotal, 0)), tax = money(billable.reduce((sum, item) => sum + item.taxAmount, 0)), total = money(untaxed + tax), invoiceDate = String(args.invoiceDate ?? now());
-            await ctx.tx(async (tx) => {
-                await tx.db.insert('account.Move', {
-                    id: args.id,
-                    name: String(args.id),
-                    ref: order.name,
-                    date: invoiceDate,
-                    moveType: 'out_invoice',
-                    state: 'draft',
-                    journalId: args.journalId,
-                    partnerId: order.partnerId,
-                    invoiceDate,
-                    invoiceDateDue: invoiceDate,
-                    paymentTermId: order.paymentTermId,
-                    paymentState: 'not_paid',
-                    currency: order.currency,
-                    amountUntaxed: decimal(untaxed),
-                    amountTax: decimal(tax),
-                    amountTotal: decimal(total),
-                    postedAt: null,
-                });
-                let sequence = 10;
-                for (const item of billable) {
-                    const baseId = `${String(args.id)}:${String(item.line.id)}`;
-                    await tx.db.insert('account.MoveLine', {
-                        id: baseId,
-                        moveId: args.id,
-                        name: item.line.name,
-                        accountId: args.revenueAccountId,
-                        partnerId: order.partnerId,
-                        productId: item.line.productId,
-                        productUomId: item.line.productUomId,
-                        quantity: decimal(item.quantity),
-                        priceUnit: item.line.priceUnit,
-                        discount: item.line.discount,
-                        taxId: item.line.taxId,
-                        debit: '0',
-                        credit: decimal(item.subtotal),
-                        balance: decimal(-item.subtotal),
-                        dateMaturity: null,
-                        displayType: null,
-                        reconciled: false,
-                        amountResidual: '0',
-                        sequence,
-                        saleLineId: item.line.id,
+            const build = async (tx) => {
+                billable.length = 0;
+                for (const line of await ours(tx, 'sale.OrderLine', { orderId: args.orderId })) {
+                    const context = await contextOf(tx, line.productId), policy = String(context?.template.invoicePolicy ?? 'order');
+                    const basis = policy === 'delivery' ? line.qtyDelivered : line.productUomQty;
+                    const quantity = subtractDecimals(basis ?? '0', line.qtyInvoiced ?? '0');
+                    if (compareDecimals(quantity, '0') <= 0)
+                        continue;
+                    const quote = await quoteTaxLineForPosting(tx, {
+                        productId: line.productId,
+                        taxIds: line.taxIds ?? (line.taxId ? [line.taxId] : undefined),
+                        quantity,
+                        priceUnit: line.priceUnit,
+                        discount: line.discount,
+                        allowNegativePrice: line.lineKind === 'reward',
                     });
-                    sequence += 10;
-                    if (item.taxAmount)
-                        await tx.db.insert('account.MoveLine', {
-                            id: `${baseId}:tax`,
+                    if (quote.ok !== true)
+                        throw new Refused(quote);
+                    for (const share of quote.shares) {
+                        const accountId = (quote.shares.length === 1 ? args.taxAccountId : null) ?? share.accountId;
+                        if (!accountId || !(await tx.db.select('account.Account', { id: accountId }))[0])
+                            throw new Refused(invalid('taxAccountId', 'a valid tax account is required'));
+                    }
+                    billable.push({
+                        line,
+                        quantity,
+                        subtotal: quote.amountUntaxed,
+                        taxAmount: quote.amountTax,
+                        shares: quote.shares,
+                    });
+                }
+                if (!billable.length)
+                    throw new Refused(invalid('lines', 'there is no ordered or delivered quantity left to invoice'));
+            };
+            const invoiceDate = String(args.invoiceDate ?? now());
+            // The payment term decides when this is due; `account` computes it the same
+            // way for the invoices it raises itself. Writing the invoice date into both
+            // fields made every order-sourced invoice due on the day it was issued, so
+            // ageing showed it overdue from the start.
+            const due = await paymentTermDue(ctx, order.paymentTermId, new Date(invoiceDate));
+            const scale = scaleOf(order.currency);
+            let untaxed = 0n, tax = 0n, total = 0n;
+            try {
+                await ctx.tx(async (tx) => {
+                    await build(tx);
+                    untaxed = sumMoneyMinor(billable.map((item) => item.subtotal), scale);
+                    tax = sumMoneyMinor(billable.map((item) => item.taxAmount), scale);
+                    total = untaxed + tax;
+                    const zero = minorText(0n, scale);
+                    const move = {
+                        id: args.id,
+                        name: String(args.id),
+                        ref: order.name,
+                        date: invoiceDate,
+                        moveType: 'out_invoice',
+                        state: 'draft',
+                        journalId: args.journalId,
+                        partnerId: order.partnerId,
+                        invoiceDate,
+                        invoiceDateDue: due,
+                        paymentTermId: order.paymentTermId,
+                        paymentState: 'not_paid',
+                        currency: order.currency,
+                        amountUntaxed: minorText(untaxed, scale),
+                        amountTax: minorText(tax, scale),
+                        amountTotal: minorText(total, scale),
+                        postedAt: null,
+                        revision: 0,
+                    };
+                    const moveLines = [];
+                    let sequence = 10;
+                    for (const item of billable) {
+                        const baseId = `${String(args.id)}:${String(item.line.id)}`;
+                        const subtotalMinor = moneyMinor(item.subtotal, scale);
+                        const balance = -subtotalMinor;
+                        moveLines.push({
+                            id: baseId,
                             moveId: args.id,
-                            name: item.tax?.name ?? 'Tax',
-                            accountId: args.taxAccountId,
+                            name: item.line.name,
+                            accountId: args.revenueAccountId,
                             partnerId: order.partnerId,
-                            productId: null,
-                            productUomId: null,
-                            quantity: '1',
-                            priceUnit: decimal(item.taxAmount),
-                            discount: '0',
-                            taxId: null,
-                            debit: '0',
-                            credit: decimal(item.taxAmount),
-                            balance: decimal(-item.taxAmount),
+                            productId: item.line.productId,
+                            productUomId: item.line.productUomId,
+                            quantity: item.quantity,
+                            priceUnit: item.line.priceUnit,
+                            discount: item.line.discount,
+                            taxId: item.line.taxId,
+                            debit: minorText(balance > 0n ? balance : 0n, scale),
+                            credit: minorText(balance < 0n ? -balance : 0n, scale),
+                            balance: minorText(balance, scale),
                             dateMaturity: null,
                             displayType: null,
                             reconciled: false,
-                            amountResidual: '0',
-                            sequence: sequence++,
+                            amountResidual: zero,
+                            sequence,
                             saleLineId: item.line.id,
                         });
-                    await tx.db.update('sale.OrderLine', { id: item.line.id }, { qtyInvoiced: decimal(n(item.line.qtyInvoiced) + item.quantity) });
-                }
-                await tx.db.insert('account.MoveLine', {
-                    id: `${String(args.id)}:counterpart`,
-                    moveId: args.id,
-                    name: order.name,
-                    accountId: args.receivableAccountId,
-                    partnerId: order.partnerId,
-                    productId: null,
-                    productUomId: null,
-                    quantity: '1',
-                    priceUnit: decimal(total),
-                    discount: '0',
-                    taxId: null,
-                    debit: decimal(total),
-                    credit: '0',
-                    balance: decimal(total),
-                    dateMaturity: invoiceDate,
-                    displayType: null,
-                    reconciled: false,
-                    amountResidual: decimal(total),
-                    sequence: sequence + 10,
-                    saleLineId: null,
+                        sequence += 10;
+                        for (const share of item.shares) {
+                            const amountMinor = moneyMinor(share.amount, scale);
+                            const amount = minorText(amountMinor, scale);
+                            if (amountMinor === 0n)
+                                continue;
+                            const balance = -amountMinor;
+                            const accountId = (item.shares.length === 1 ? args.taxAccountId : null) ?? share.accountId;
+                            moveLines.push({
+                                id: `${baseId}:tax:${String(share.taxId)}`,
+                                moveId: args.id,
+                                name: share.name,
+                                accountId,
+                                partnerId: order.partnerId,
+                                productId: null,
+                                productUomId: null,
+                                quantity: '1',
+                                priceUnit: amount,
+                                discount: '0',
+                                taxId: share.taxId,
+                                debit: minorText(balance > 0n ? balance : 0n, scale),
+                                credit: minorText(balance < 0n ? -balance : 0n, scale),
+                                balance: minorText(balance, scale),
+                                dateMaturity: null,
+                                displayType: null,
+                                reconciled: false,
+                                amountResidual: zero,
+                                sequence: sequence++,
+                                saleLineId: item.line.id,
+                            });
+                        }
+                    }
+                    const totalText = minorText(total, scale);
+                    moveLines.push({
+                        id: `${String(args.id)}:counterpart`,
+                        moveId: args.id,
+                        name: order.name,
+                        accountId: args.receivableAccountId,
+                        partnerId: order.partnerId,
+                        productId: null,
+                        productUomId: null,
+                        quantity: '1',
+                        priceUnit: totalText,
+                        discount: '0',
+                        taxId: null,
+                        debit: totalText,
+                        credit: zero,
+                        balance: totalText,
+                        dateMaturity: due,
+                        displayType: null,
+                        reconciled: false,
+                        amountResidual: totalText,
+                        sequence: sequence + 10,
+                        saleLineId: null,
+                    });
+                    await insertDraftMove(tx, { move, lines: moveLines });
+                    for (const item of billable)
+                        await tx.db.update('sale.OrderLine', { id: item.line.id }, { qtyInvoiced: addDecimals(item.line.qtyInvoiced ?? '0', item.quantity) });
                 });
-            });
+            }
+            catch (error) {
+                if (error instanceof Refused)
+                    return error.result;
+                throw error;
+            }
             await refreshStatus(ctx, args.orderId);
-            return { ok: true, id: args.id, amountTotal: decimal(total) };
+            return { ok: true, id: args.id, amountTotal: minorText(total, scale) };
         },
     }),
     lockOrder: defineFn({
@@ -568,15 +1108,17 @@ export const functions = {
         idempotent: true,
         agent: true,
         handler: async (ctx, args) => {
-            const order = (await ctx.db.select('sale.Order', { id: args.id }))[0];
+            const order = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
             if (order?.state !== 'sale')
                 return invalid('state', 'only a sales order can be locked');
-            await ctx.db.update('sale.Order', { id: args.id }, { locked: args.locked });
+            if (externalOrder(order))
+                return authorityRefusal();
+            await ctx.db.update('sale.Order', { id: args.id }, { locked: args.locked, revision: n(order.revision) + 1 });
             return { ok: true, id: args.id };
         },
     }),
     cancelOrder: defineFn({
-        input: { id: 'id' },
+        input: { id: 'id', expectedRevision: 'int?' },
         output: { ok: 'bool', id: 'id?', errors: 'json?' },
         effects: [
             'read:sale.Order',
@@ -587,23 +1129,49 @@ export const functions = {
             'write:stock.Picking',
             'read:account.MoveLine',
             'write:sale.Order',
+            'read:sale.OrderLifecycleEvent',
+            'write:sale.OrderLifecycleEvent',
         ],
         idempotent: true,
         agent: true,
         handler: async (ctx, args) => {
-            const order = (await ctx.db.select('sale.Order', { id: args.id }))[0];
+            const order = (await ours(ctx, 'sale.Order', { id: args.id }))[0];
             if (!order)
                 return invalid('id', 'sales order does not exist');
-            const lines = await ctx.db.select('sale.OrderLine', { orderId: args.id }), moves = (await ctx.db.select('stock.Move')).filter((move) => lines.some((line) => line.id === move.saleLineId));
-            if (moves.some((move) => move.state === 'done'))
-                return invalid('state', 'a delivered order cannot be cancelled');
-            if ((await ctx.db.select('account.MoveLine')).some((line) => lines.some((held) => held.id === line.saleLineId)))
-                return invalid('state', 'an invoiced order cannot be cancelled');
-            for (const move of moves)
-                await ctx.db.update('stock.Move', { id: move.id }, { state: 'cancel' });
-            for (const pickingId of [...new Set(moves.map((move) => move.pickingId).filter(Boolean))])
-                await ctx.db.update('stock.Picking', { id: pickingId }, { state: 'cancel' });
-            await ctx.db.update('sale.Order', { id: args.id }, { state: 'cancel' });
+            if (args.expectedRevision !== undefined && n(order.revision) !== n(args.expectedRevision))
+                return invalid('expectedRevision', 'sales order changed');
+            if (externalOrder(order))
+                return authorityRefusal();
+            if (order.state === 'cancel')
+                return { ok: true, id: args.id };
+            try {
+                await ctx.tx(async (tx) => {
+                    const current = (await ours(tx, 'sale.Order', { id: args.id }))[0];
+                    if (!current || !(await claimRevision(tx, current, args.expectedRevision)))
+                        throw new SaleRefused(invalid('expectedRevision', 'sales order changed'));
+                    const lines = await ours(tx, 'sale.OrderLine', { orderId: args.id });
+                    const lineIds = lines.map((line) => String(line.id));
+                    const moves = await movesOf(tx, lineIds);
+                    if (moves.some((move) => move.state === 'done'))
+                        throw new SaleRefused(invalid('state', 'a delivered order cannot be cancelled'));
+                    if ((await invoiceLinesOf(tx, lineIds)).length)
+                        throw new SaleRefused(invalid('state', 'an invoiced order cannot be cancelled'));
+                    for (const move of moves)
+                        await tx.db.update('stock.Move', { id: move.id }, { state: 'cancel' });
+                    for (const pickingId of [...new Set(moves.map((move) => move.pickingId).filter(Boolean))])
+                        await tx.db.update('stock.Picking', { id: pickingId }, { state: 'cancel' });
+                    await tx.db.update('sale.Order', { id: args.id }, { state: 'cancel' });
+                    // A draft quotation has no fulfillment to cancel. Only an order that
+                    // had entered the sale state publishes a cancellation fact.
+                    if (current.state === 'sale')
+                        await recordOrderLifecycle(tx, args.id, 'cancelled');
+                });
+            }
+            catch (error) {
+                if (error instanceof SaleRefused)
+                    return error.result;
+                throw error;
+            }
             return { ok: true, id: args.id };
         },
     }),