shutro-erp 0.3.5 → 0.3.7

package/dist/production/module.js

@@ -0,0 +1,1333 @@
+/**
+ * The data layer of Production (RFC 0021): bills of materials with versions and effective dates, work centres with
+ * their hours and cost, and production orders that say what is required, available and short before they start and
+ * what they will cost. Orders move stock only through Stockroom: Confirm reserves the components in a consumption
+ * transfer (stock → Production), Produce validates it and the output transfer (Production → stock).
+ */
+import { contactsShutro } from '../contacts/index.js';
+import { messagingShutro } from '../messaging/index.js';
+import { approvalGuard, permissionsShutro, requestApprovals } from '../permissions/index.js';
+import { productShutro } from '../product/index.js';
+import { emitting } from '../server/index.js';
+import { orm } from '../server/orm.js';
+import { defaultLocations, inProductUnit, stockShutro } from '../stock/index.js';
+import { check, compute, defineModel, defineModule, extendModel, f, onchange, records, } from './.kosh/bindings.js';
+import { BOM_KINDS, bomsNeedApproval, CompanyProduction, ineligible, ProductionBomCost, ProductionBomEligibility, ProductionBomSpec, ProductionProductSpec, ProductionShift, ProductionSpecParameter, } from './depth.js';
+import { ProductionPlan, ProductionPlanLine, ProductionPlanMaterial } from './plan.js';
+import { followOrders, ProductionSchedule, ProductionScheduleComponent } from './schedule.js';
+const READ = ['read'];
+const ALL = ['read', 'write', 'create', 'unlink'];
+const zero = orm.toDecimal(0);
+const money = (d) => d.toDecimalPlaces(2);
+/** A date as `YYYY-MM-DD` (date-only values from PostgreSQL are local midnights: their local parts). */
+const iso = (v) => {
+    if (!(v instanceof Date))
+        return String(v ?? '');
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${v.getFullYear()}-${pad(v.getMonth() + 1)}-${pad(v.getDate())}`;
+};
+/** The bill of `product` valid on `date`: the latest that starts on or before it and has not ended. */
+export async function validBom(env, product, date) {
+    const bills = await (await env.model('production.bom').search({ where: { product } })).load([
+        'validFrom',
+        'validTo',
+        'state',
+        'company',
+    ]);
+    // Active bills; drafts too when the company needs no approval (RFC 0031 §3.2).
+    const needs = new Map();
+    const usable = async (b) => {
+        if (b.state === 'active')
+            return true;
+        if (b.state !== 'draft')
+            return false;
+        let need = needs.get(b.company.id);
+        if (need === undefined) {
+            need = await bomsNeedApproval(env, b.company.id);
+            needs.set(b.company.id, need);
+        }
+        return !need;
+    };
+    const candidates = [];
+    for (const b of bills)
+        if (await usable(b))
+            candidates.push(b);
+    const valid = candidates
+        .filter((b) => (b.validFrom === null || iso(b.validFrom) <= date) &&
+        (b.validTo === null || iso(b.validTo) >= date))
+        .sort((a, b) => iso(b.validFrom).localeCompare(iso(a.validFrom)) || b.id - a.id);
+    return valid[0]?.id ?? null;
+}
+export const ProductionWorkcenter = defineModel('production.workcenter', {
+    label: 'Work centre',
+    recName: 'name',
+    order: ['name asc'],
+    archivable: true,
+    companyScoped: { required: true },
+    access: { 'production.user': READ, 'production.manager': [...ALL, 'export', 'import'] },
+    fields: {
+        name: f.char({ required: true }),
+        code: f.char(),
+        /** Hours it works a day (its capacity). */
+        hoursPerDay: f.decimal({ scale: 2, required: true, default: '8', label: 'Hours a day' }),
+        /** Labour and overhead per hour of work. */
+        costPerHour: f.decimal({ scale: 2, required: true, default: '0', label: 'Cost per hour' }),
+        batchMin: f.decimal({ scale: 4, label: 'Minimum batch', help: 'The smallest batch it runs.' }),
+        batchMax: f.decimal({
+            scale: 4,
+            label: 'Maximum batch',
+            help: 'The largest batch it runs at once.',
+        }),
+        oeeTarget: f.decimal({
+            scale: 2,
+            default: '85',
+            label: 'OEE target (%)',
+            help: 'The overall equipment effectiveness aimed at: availability × performance × quality.',
+        }),
+        setupMinutes: f.decimal({
+            scale: 2,
+            default: '0',
+            label: 'Setup (minutes)',
+            help: 'Before each batch.',
+        }),
+        cleanupMinutes: f.decimal({
+            scale: 2,
+            default: '0',
+            label: 'Cleanup (minutes)',
+            help: 'After each batch.',
+        }),
+        alternatives: f.many2many('production.workcenter', {
+            relation: 'production_wc_alternative',
+            label: 'Alternative work centres',
+            help: 'Where the same operation may run when this centre is full.',
+        }),
+        note: f.text(),
+    },
+    sqlConstraints: {
+        positive: {
+            check: orm.sql `hours_per_day > 0 AND cost_per_hour >= 0`,
+            message: 'A work centre works some hours a day, at a cost that is not negative.',
+        },
+    },
+});
+export const ProductionBom = defineModel('production.bom', {
+    label: 'Bill of materials',
+    recName: 'label',
+    order: ['product asc', 'validFrom desc', 'id desc'],
+    archivable: true,
+    companyScoped: { required: true },
+    tracking: ['quantity', 'validFrom', 'validTo', 'kind', 'state'],
+    access: { 'production.user': READ, 'production.manager': [...ALL, 'export', 'import'] },
+    fields: {
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        /** How many of the product one bill makes, in the product's unit. */
+        quantity: f.decimal({ scale: 4, required: true, default: '1', label: 'Makes' }),
+        kind: f.selection(BOM_KINDS, {
+            required: true,
+            default: 'standard',
+            help: 'Standard: components in quantities. Formula: components as shares of the batch (ratios adding up to 100 %), scaled to any quantity. Packaging: a pack of the product made.',
+        }),
+        packSize: f.decimal({
+            scale: 4,
+            label: 'Pack size',
+            help: 'For a packaging bill: how much of the product one pack holds, in the product’s unit.',
+        }),
+        expectedLoss: f.decimal({
+            scale: 2,
+            default: '0',
+            label: 'Expected loss (%)',
+            help: 'What is lost making or packing a batch, as a share of it.',
+        }),
+        tolerance: f.decimal({
+            scale: 2,
+            default: '0',
+            label: 'Tolerance (±%)',
+            help: 'How far the quantity made may stray from the batch before it is questioned.',
+        }),
+        version: f.char({ required: true, default: 'v1' }),
+        /** From when this version is used (empty: always). */
+        validFrom: f.date({ label: 'Valid from' }),
+        validTo: f.date({ label: 'Valid until' }),
+        lines: f.one2many('production.bom.line', 'bom', { label: 'Components' }),
+        operations: f.one2many('production.bom.operation', 'bom'),
+        byproducts: f.one2many('production.bom.byproduct', 'bom', { label: 'By-products' }),
+        specs: f.one2many('production.bom.spec', 'bom', { label: 'Specifications' }),
+        costs: f.one2many('production.bom.cost', 'bom', { label: 'Costing history' }),
+        unitCost: f.decimal({
+            scale: 4,
+            store: true,
+            label: 'Unit cost',
+            help: 'The components (gross of their losses) at their cost and the operations at their work centres’ rates, per unit made.',
+            ...compute('production.bom', 'unitCost', [
+                'quantity',
+                'lines.grossQuantity',
+                'lines.quantity',
+                'lines.uom',
+                'lines.product.standardPrice',
+                'lines.product.uom',
+                'operations.minutes',
+                'operations.workcenter.costPerHour',
+            ], (bills) => {
+                for (const b of bills) {
+                    let total = zero;
+                    for (const l of b.lines) {
+                        const qty = inProductUnit(l.grossQuantity ?? l.quantity, (l.uom ?? null), (l.product.uom ?? null));
+                        total = total.plus(qty.times(l.product.standardPrice ?? zero));
+                    }
+                    for (const op of b.operations)
+                        total = total.plus(op.minutes.div(60).times(op.workcenter.costPerHour));
+                    b.unitCost = b.quantity.gt(0) ? total.div(b.quantity).toDecimalPlaces(4) : zero;
+                }
+            }),
+        }),
+        state: f.state({
+            states: { draft: 'Draft', review: 'Under review', active: 'Active', inactive: 'Inactive' },
+            initial: 'draft',
+            help: 'Drafted, submitted for review, approved into active (the version used), set inactive when superseded; a revision copies it to the next version. A company that needs no approval uses drafts as well.',
+            transitions: {
+                submit: {
+                    from: ['draft'],
+                    to: 'review',
+                    guard: records('production.bom', async (bills) => {
+                        const out = [];
+                        for (const b of await bills.load({ lines: true, specs: true })) {
+                            const lines = [...b.lines];
+                            const ratios = lines.reduce((s, l) => s.plus(l.ratio ?? zero), zero);
+                            if (lines.length === 0 ||
+                                (b.kind === 'formula' && !ratios.eq(100)) ||
+                                [...b.specs].some((s) => s.within === false))
+                                out.push(b.id);
+                        }
+                        return out;
+                    }),
+                    message: 'A bill under review has components, formula ratios adding up to 100 % and every specification within range.',
+                    after: records('production.bom', async (bills) => {
+                        await requestApprovals(bills);
+                        for (const b of await bills.load({}))
+                            await bills.env.emit('production.bom.submitted', { id: b.id });
+                    }),
+                },
+                approve: {
+                    from: ['review'],
+                    to: 'active',
+                    guard: records('production.bom', (bills) => approvalGuard(bills)),
+                    message: 'Waiting for approvals.',
+                    after: records('production.bom', async (bills) => {
+                        const env = bills.env;
+                        for (const b of await bills.load({})) {
+                            await env.asSuperuser({ reason: 'bill costing history' }, (su) => su.model('production.bom.cost').create([
+                                {
+                                    bom: b.id,
+                                    date: env.today(),
+                                    unitCost: b.unitCost ?? zero,
+                                    note: 'Activated',
+                                },
+                            ]));
+                            await env.emit('production.bom.activated', { id: b.id });
+                        }
+                    }),
+                },
+                reject: { from: ['review'], to: 'draft' },
+                deactivate: { from: ['active'], to: 'inactive' },
+                reactivate: { from: ['inactive'], to: 'active' },
+                /** A copy as the next version, in draft, to change and submit; the cost of this version kept. */
+                revise: {
+                    from: ['active'],
+                    to: 'active',
+                    after: records('production.bom', async (bills) => {
+                        const env = bills.env;
+                        for (const id of bills.ids)
+                            await reviseBom(env, id);
+                    }),
+                },
+            },
+            extensible: true,
+        }),
+        note: f.text(),
+        label: f.char({
+            store: true,
+            label: 'Bill of materials',
+            ...compute('production.bom', 'label', ['product.name', 'version'], (bills) => {
+                for (const b of bills)
+                    b.label = `${b.product.name} ${b.version}`;
+            }),
+        }),
+    },
+    sqlConstraints: {
+        positive: { check: orm.sql `quantity > 0`, message: 'A bill makes a positive quantity.' },
+        packaging: {
+            check: orm.sql `kind <> 'packaging' OR (pack_size IS NOT NULL AND pack_size > 0)`,
+            message: 'A packaging bill has a pack size.',
+        },
+        shares: {
+            check: orm.sql `expected_loss >= 0 AND expected_loss < 100 AND tolerance >= 0 AND tolerance <= 100`,
+            message: 'Loss and tolerance are percentages.',
+        },
+        period: {
+            check: orm.sql `valid_from IS NULL OR valid_to IS NULL OR valid_to >= valid_from`,
+            message: 'A bill ends on or after it starts.',
+        },
+    },
+});
+/** The next version's name: v1 → v2, 2026-A → 2026-A-2. */
+function nextVersion(version) {
+    const m = /^(.*?)(\d+)$/.exec(version);
+    return m === null ? `${version}-2` : `${m[1]}${Number(m[2]) + 1}`;
+}
+/** A copy of a bill as its next version, in draft: lines, operations, by-products and specifications. */
+export async function reviseBom(env, id) {
+    const [b] = await env
+        .model('production.bom')
+        .browse([id])
+        .load({ lines: true, operations: true, byproducts: true, specs: true, company: true });
+    if (b === undefined)
+        return null;
+    const made = await env.model('production.bom').create([
+        {
+            product: b.product.id,
+            company: b.company.id,
+            quantity: b.quantity,
+            kind: b.kind,
+            packSize: b.packSize,
+            expectedLoss: b.expectedLoss,
+            tolerance: b.tolerance,
+            version: nextVersion(b.version),
+            note: b.note,
+            lines: {
+                create: [...b.lines].map((l) => ({
+                    product: l.product.id,
+                    quantity: l.quantity,
+                    uom: l.uom?.id ?? null,
+                    ratio: l.ratio,
+                    loss: l.loss,
+                })),
+            },
+            operations: {
+                create: [...b.operations].map((o) => ({
+                    name: o.name,
+                    workcenter: o.workcenter.id,
+                    minutes: o.minutes,
+                })),
+            },
+            byproducts: {
+                create: [...b.byproducts].map((x) => ({
+                    product: x.product.id,
+                    quantity: x.quantity,
+                    uom: x.uom?.id ?? null,
+                    costShare: x.costShare,
+                })),
+            },
+            specs: {
+                create: [...b.specs].map((x) => ({
+                    parameter: x.parameter.id,
+                    minimum: x.minimum,
+                    maximum: x.maximum,
+                })),
+            },
+        },
+    ]);
+    await env.emit('production.bom.revised', { id: b.id });
+    return made.ids[0] ?? null;
+}
+export const ProductionBomLine = defineModel('production.bom.line', {
+    label: 'Component',
+    order: ['id asc'],
+    access: { 'production.user': READ, 'production.manager': ALL },
+    fields: {
+        bom: f.many2one('production.bom', { required: true, ondelete: 'cascade' }),
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        quantity: f.decimal({ scale: 4, required: true, default: '1' }),
+        uom: f.many2one('uom.uom', { label: 'Unit' }),
+        ratio: f.decimal({
+            scale: 2,
+            label: 'Ratio (%)',
+            help: 'For a formula: the component’s share of the batch; the ratios add up to 100 %.',
+        }),
+        loss: f.decimal({
+            scale: 2,
+            default: '0',
+            label: 'Loss (%)',
+            help: 'What is lost of this component in making (spillage, moisture): the gross quantity covers it.',
+        }),
+        netQuantity: f.decimal({
+            scale: 4,
+            store: true,
+            label: 'Net quantity',
+            help: 'What goes into the product: the quantity, or the ratio of the batch for a formula.',
+            ...compute('production.bom.line', 'netQuantity', ['quantity', 'ratio', 'bom.kind', 'bom.quantity'], (lines) => {
+                for (const l of lines)
+                    l.netQuantity =
+                        l.bom.kind === 'formula' && l.ratio !== null
+                            ? l.bom.quantity.times(l.ratio).div(100).toDecimalPlaces(4)
+                            : l.quantity;
+            }),
+        }),
+        grossQuantity: f.decimal({
+            scale: 4,
+            store: true,
+            label: 'Gross quantity',
+            help: 'The net quantity plus the loss: what the order consumes.',
+            ...compute('production.bom.line', 'grossQuantity', ['netQuantity', 'loss'], (lines) => {
+                for (const l of lines)
+                    l.grossQuantity = (l.netQuantity ?? l.quantity)
+                        .times(orm.toDecimal(100).plus(l.loss ?? zero))
+                        .div(100)
+                        .toDecimalPlaces(4);
+            }),
+        }),
+    },
+    onchange: {
+        product: onchange('production.bom.line', async (d) => {
+            const p = await d.record('product');
+            if (p?.uom)
+                d.set('uom', p.uom.id);
+        }),
+    },
+    sqlConstraints: {
+        positive: {
+            check: orm.sql `quantity > 0`,
+            message: 'A component is needed in a positive quantity.',
+        },
+        shares: {
+            check: orm.sql `(ratio IS NULL OR (ratio >= 0 AND ratio <= 100)) AND loss >= 0 AND loss < 100`,
+            message: 'Ratios and losses are percentages.',
+        },
+    },
+    constraints: {
+        // The company's eligibility rules for the bill's kind (RFC 0031 §3.2): refused lines say why.
+        eligible: {
+            ...check('production.bom.line', ['product', 'bom'], async (lines) => {
+                const env = lines.env;
+                const failing = [];
+                for (const l of await lines.load({ bom: { company: true }, product: true })) {
+                    const why = await ineligible(env, l.bom.company.id, l.bom.kind, l.product.id);
+                    if (why !== null) {
+                        failing.push(l.id);
+                        throw new orm.ValidationError('production.bom.line', ['product'], why, 'Choose an allowed component, or change the eligibility rules (Production › Configuration).');
+                    }
+                }
+                return failing;
+            }),
+            message: 'This product is not an allowed component of the bill’s kind.',
+        },
+        notItself: {
+            ...check('production.bom.line', ['product', 'bom'], async (lines) => (await lines.load({ bom: true }))
+                .filter((l) => l.bom.product.id === l.product.id)
+                .map((l) => l.id)),
+            message: 'A product is not a component of itself.',
+        },
+    },
+});
+/** What else one bill makes (sawdust, offcuts), and the share of the order's cost it carries. */
+export const ProductionBomByproduct = defineModel('production.bom.byproduct', {
+    label: 'By-product',
+    order: ['id asc'],
+    access: { 'production.user': READ, 'production.manager': ALL },
+    fields: {
+        bom: f.many2one('production.bom', { required: true, ondelete: 'cascade' }),
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        quantity: f.decimal({ scale: 4, required: true, default: '1' }),
+        uom: f.many2one('uom.uom', { label: 'Unit' }),
+        /** Percent of the order's cost (the main product carries the rest). */
+        costShare: f.decimal({
+            scale: 2,
+            required: true,
+            default: '0',
+            label: 'Share of the cost (%)',
+        }),
+    },
+    sqlConstraints: {
+        positive: {
+            check: orm.sql `quantity > 0 AND cost_share >= 0 AND cost_share < 100`,
+            message: 'A by-product is made in a positive quantity, with a share of the cost under 100 %.',
+        },
+    },
+    constraints: {
+        sharesUnderAll: {
+            ...check('production.bom.byproduct', ['costShare', 'bom', 'product'], async (lines) => {
+                const failing = [];
+                for (const l of await lines.load({ bom: { byproducts: true } })) {
+                    const total = [...l.bom.byproducts].reduce((s, b) => s.plus(b.costShare), zero);
+                    if (total.gte(100) || l.product.id === l.bom.product.id)
+                        failing.push(l.id);
+                }
+                return failing;
+            }),
+            message: 'By-products are other products than the one made, and their shares of the cost stay under 100 %.',
+        },
+    },
+});
+export const ProductionBomOperation = defineModel('production.bom.operation', {
+    label: 'Operation',
+    order: ['id asc'],
+    access: { 'production.user': READ, 'production.manager': ALL },
+    fields: {
+        bom: f.many2one('production.bom', { required: true, ondelete: 'cascade' }),
+        name: f.char({ required: true }),
+        workcenter: f.many2one('production.workcenter', { required: true, ondelete: 'restrict' }),
+        /** Minutes for what one bill makes. */
+        minutes: f.decimal({ scale: 2, required: true, default: '0' }),
+    },
+});
+export const ProductionOrderComponent = defineModel('production.order.component', {
+    label: 'Component need',
+    order: ['id asc'],
+    access: { 'production.user': READ, 'production.manager': READ },
+    fields: {
+        production: f.many2one('production.order', { required: true, ondelete: 'cascade' }),
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        /** In the product's unit. */
+        required: f.decimal({ scale: 4, required: true, default: '0' }),
+        /** Available in the warehouse when the order was last checked. */
+        available: f.decimal({ scale: 4, required: true, default: '0' }),
+        short: f.decimal({
+            scale: 4,
+            store: true,
+            label: 'Short',
+            help: 'How much more is needed than the warehouse had available when the order was last checked.',
+            ...compute('production.order.component', 'short', ['required', 'available'], (lines) => {
+                for (const l of lines) {
+                    const missing = l.required.minus(l.available);
+                    l.short = missing.gt(0) ? missing : zero;
+                }
+            }),
+        }),
+        cost: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Cost',
+            help: 'The quantity needed at the component’s cost.',
+            ...compute('production.order.component', 'cost', ['required', 'product.standardPrice'], (lines) => {
+                for (const l of lines)
+                    l.cost = money(l.required.times(l.product.standardPrice));
+            }),
+        }),
+    },
+});
+/**
+ * A bill's component needs for `quantity` of its product (in the components' own units, gross of losses) with what
+ * is available — on hand and not reserved — in the warehouse now.
+ */
+export async function componentNeeds(env, bom, quantity, warehouse, company) {
+    const [bill] = await env
+        .model('production.bom')
+        .browse([bom])
+        .load({ lines: { product: { uom: true }, uom: true } });
+    if (bill === undefined || bill.quantity.lte(0))
+        return [];
+    const factor = quantity.div(bill.quantity);
+    const needs = new Map();
+    for (const l of bill.lines) {
+        const inUnit = inProductUnit((l.grossQuantity ?? l.quantity).times(factor), l.uom ?? null, l.product.uom ?? null);
+        needs.set(l.product.id, (needs.get(l.product.id) ?? zero).plus(inUnit));
+    }
+    const places = await defaultLocations(env, 'internal', warehouse, company);
+    const out = [];
+    for (const [product, required] of needs) {
+        let available = zero;
+        if (places.source !== null) {
+            const quants = await (await env.model('stock.quant').search({
+                where: {
+                    product: orm.asId(product, 'product.product'),
+                    location: { childOf: places.source },
+                },
+            })).load(['quantity', 'reserved']);
+            available = [...quants].reduce((s, q) => s.plus(q.quantity).minus(q.reserved ?? zero), zero);
+        }
+        out.push({
+            product,
+            required: required.toDecimalPlaces(4),
+            available: available.gt(0) ? available.toDecimalPlaces(4) : zero,
+        });
+    }
+    return out;
+}
+/**
+ * Lists the orders' component needs from their bills (in the product's unit, for the quantity ordered) with what is
+ * available in their warehouse now; as the system (component lines are not edited by hand).
+ */
+async function explode(ids, env) {
+    await env.asSuperuser({ reason: 'production components' }, async (su) => {
+        const orders = await su.model('production.order').browse(ids).load({ components: true });
+        for (const o of orders) {
+            if (o.components.length > 0)
+                await o.components.unlink();
+            if (o.bom === null)
+                continue;
+            for (const n of await componentNeeds(su, o.bom.id, o.quantity, o.warehouse?.id ?? null, o.company.id))
+                await su.model('production.order.component').create([
+                    {
+                        production: o.id,
+                        product: orm.asId(n.product, 'product.product'),
+                        required: n.required,
+                        available: n.available,
+                    },
+                ]);
+        }
+    });
+}
+/** When a work centre's day starts (local time). */
+export const DAY_STARTS_AT = 8;
+/**
+ * Forward schedule of `minutes` of work at a centre working `hoursPerDay` from `DAY_STARTS_AT`, from `from`: what does
+ * not fit in a day continues the next day. Returns the start and the end.
+ */
+export function schedule(from, minutes, hoursPerDay) {
+    const dayStart = (d) => new Date(d.getFullYear(), d.getMonth(), d.getDate(), DAY_STARTS_AT);
+    const dayEnd = (d) => new Date(dayStart(d).getTime() + hoursPerDay * 3_600_000);
+    let at = new Date(Math.max(from.getTime(), dayStart(from).getTime()));
+    if (at >= dayEnd(at))
+        at = dayStart(new Date(at.getTime() + 86_400_000));
+    const start = at;
+    let left = minutes * 60_000;
+    for (;;) {
+        const room = dayEnd(at).getTime() - at.getTime();
+        if (left <= room)
+            return { start, stop: new Date(at.getTime() + left) };
+        left -= room;
+        at = dayStart(new Date(dayStart(at).getTime() + 86_400_000));
+    }
+}
+/**
+ * A step of a production order at a work centre: planned from the bill's operation (its minutes for the quantity
+ * ordered), scheduled after what the centre already has, then started and finished with the minutes it took.
+ */
+export const ProductionWorkorder = defineModel('production.workorder', {
+    label: 'Work order',
+    tracking: ['state', 'plannedStart', 'workcenter'],
+    recName: 'name',
+    order: ['plannedStart asc', 'id asc'],
+    companyScoped: { required: true },
+    access: {
+        'production.user': ['read', 'write'],
+        'production.manager': [...ALL, 'export'],
+    },
+    fields: {
+        production: f.many2one('production.order', { required: true, ondelete: 'cascade' }),
+        name: f.char({ required: true, label: 'Operation' }),
+        workcenter: f.many2one('production.workcenter', { required: true, ondelete: 'restrict' }),
+        plannedMinutes: f.decimal({ scale: 2, required: true, default: '0', label: 'Planned minutes' }),
+        plannedStart: f.datetime({ label: 'Planned start' }),
+        plannedStop: f.datetime({ label: 'Planned end' }),
+        startedAt: f.datetime({ label: 'Started' }),
+        finishedAt: f.datetime({ label: 'Finished' }),
+        /** The minutes it took (from start to finish). */
+        actualMinutes: f.decimal({ scale: 2, label: 'Minutes taken' }),
+        state: f.state({
+            states: { ready: 'Ready', progress: 'In progress', done: 'Done', cancel: 'Cancelled' },
+            initial: 'ready',
+            help: 'Started and finished at the work centre; the minutes between them are recorded.',
+            transitions: {
+                start: {
+                    from: ['ready'],
+                    to: 'progress',
+                    after: records('production.workorder', async (orders) => {
+                        await orders.write({ startedAt: new Date() });
+                    }),
+                },
+                finish: {
+                    from: ['progress'],
+                    to: 'done',
+                    after: records('production.workorder', async (orders) => {
+                        const now = new Date();
+                        for (const w of await orders.load({})) {
+                            const began = w.startedAt instanceof Date ? w.startedAt : now;
+                            await w.write({
+                                finishedAt: now,
+                                // Whole milliseconds, then minutes (Shutro takes no fractional JS numbers).
+                                actualMinutes: orm
+                                    .toDecimal(now.getTime() - began.getTime())
+                                    .div(60_000)
+                                    .toDecimalPlaces(2),
+                            });
+                        }
+                    }),
+                },
+                /** Done with its order (Produce), however far it got. */
+                close: { from: ['ready', 'progress'], to: 'done' },
+                cancel: { from: ['ready', 'progress'], to: 'cancel' },
+            },
+        }),
+    },
+});
+/**
+ * Makes the orders' work orders from their bills' operations and schedules them forward, step after step, each at
+ * its work centre after what the centre already has planned (from the order's date).
+ */
+async function planWork(ids, env) {
+    await env.asSuperuser({ reason: 'production schedule' }, async (su) => {
+        const orders = await su
+            .model('production.order')
+            .browse(ids)
+            .load({ bom: { operations: { workcenter: true } } });
+        for (const o of orders) {
+            if (o.bom === null)
+                continue;
+            const factor = o.quantity.div(o.bom.quantity);
+            // The order's day, local (a date is read as text or as a local midnight).
+            const day = new Date(`${iso(o.date)}T00:00:00`);
+            let after = new Date(day.getFullYear(), day.getMonth(), day.getDate(), DAY_STARTS_AT);
+            for (const op of o.bom.operations) {
+                const minutes = op.minutes.times(factor).toDecimalPlaces(2);
+                // The centre is free after the last step it has that is not done or cancelled.
+                const busy = await (await su.model('production.workorder').search({
+                    where: { workcenter: op.workcenter.id, state: { in: ['ready', 'progress'] } },
+                    order: ['plannedStop desc'],
+                    limit: 1,
+                })).load(['plannedStop']);
+                const free = [...busy][0]?.plannedStop;
+                const from = free instanceof Date && free > after ? free : after;
+                const { start, stop } = schedule(from, Number(minutes), Number(op.workcenter.hoursPerDay));
+                await su.model('production.workorder').create([
+                    {
+                        production: o.id,
+                        company: o.company.id,
+                        name: op.name,
+                        workcenter: op.workcenter.id,
+                        plannedMinutes: minutes,
+                        plannedStart: start,
+                        plannedStop: stop,
+                    },
+                ]);
+                after = stop;
+            }
+        }
+    });
+}
+/** The places of an order: its warehouse's stock, and the Production location. */
+/** A date-only value as `YYYY-MM-DD`. */
+function dayOf(v) {
+    if (!(v instanceof Date))
+        return String(v ?? '').slice(0, 10);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${v.getFullYear()}-${pad(v.getMonth() + 1)}-${pad(v.getDate())}`;
+}
+async function placesOf(env, warehouse, company) {
+    const stock = (await defaultLocations(env, 'internal', warehouse, company)).source;
+    const production = (await env.model('stock.location').search({ where: { usage: 'production' }, limit: 1 })).ids[0];
+    if (stock === null || production === undefined)
+        throw new orm.ValidationError('production.order', ['warehouse'], 'There is no stock location or Production location to work from.', 'Check the warehouse in Stockroom › Configuration.');
+    return { stock, production };
+}
+export const ProductionOrder = defineModel('production.order', {
+    label: 'Production order',
+    recName: 'name',
+    order: ['date desc', 'id desc'],
+    companyScoped: { required: true },
+    tracking: ['state', 'quantity', 'bom'],
+    access: {
+        'production.user': ['read', 'write', 'create'],
+        'production.manager': [...ALL, 'export', 'import'],
+    },
+    fields: {
+        name: f.char({
+            required: true,
+            readonly: true,
+            sequence: { code: 'production.order', dateField: 'date' },
+            label: 'Reference',
+        }),
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        quantity: f.decimal({ scale: 4, required: true, default: '1' }),
+        bom: f.many2one('production.bom', { ondelete: 'restrict', label: 'Bill of materials' }),
+        plan: f.many2one('production.plan', { ondelete: 'set null', label: 'Production plan' }),
+        schedule: f.many2one('production.schedule', { ondelete: 'set null', label: 'Batch' }),
+        stage: f.selection({ make: 'Make', pack: 'Pack' }, {
+            required: true,
+            default: 'make',
+            help: 'Make: the product from its components. Pack: packs of a made product, taken from its lot.',
+        }),
+        batch: f.char({
+            label: 'Batch number',
+            help: 'The lot the batch is produced into, for a tracked product.',
+        }),
+        sourceOrder: f.many2one('production.order', {
+            ondelete: 'set null',
+            label: 'Source order',
+            help: 'The make order a pack order packs.',
+        }),
+        sourceLot: f.many2one('stock.lot', {
+            ondelete: 'set null',
+            label: 'Source lot',
+            help: 'The lot a pack order takes its bulk from: the make order’s, once produced.',
+        }),
+        lot: f.many2one('stock.lot', { ondelete: 'set null', label: 'Produced lot' }),
+        producedQty: f.decimal({
+            scale: 4,
+            label: 'Produced',
+            help: 'What came out, set before producing; the quantity ordered when empty.',
+        }),
+        consumedQty: f.decimal({
+            scale: 4,
+            store: true,
+            label: 'Consumed',
+            help: 'For a pack order the bulk it packs; else the components in the product’s own unit (a formula’s shares).',
+            ...compute('production.order', 'consumedQty', [
+                'stage',
+                'components.required',
+                'components.product.uom',
+                'product.uom',
+                'sourceOrder.product',
+            ], (orders) => {
+                for (const o of orders) {
+                    const lines = [...o.components];
+                    if (o.stage === 'pack') {
+                        const bulk = lines.find((c) => c.product.id === (o.sourceOrder?.product.id ?? -1));
+                        o.consumedQty = bulk?.required ?? zero;
+                        continue;
+                    }
+                    const unit = o.product.uom?.id ?? null;
+                    o.consumedQty = lines
+                        .filter((c) => (c.product.uom?.id ?? null) === unit)
+                        .reduce((s, c) => s.plus(c.required), zero);
+                }
+            }),
+        }),
+        lossQty: f.decimal({
+            scale: 4,
+            store: true,
+            label: 'Process loss',
+            help: 'Consumed less produced (packs × the pack size for a pack order), once done; negative: a gain.',
+            ...compute('production.order', 'lossQty', ['state', 'stage', 'consumedQty', 'producedQty', 'quantity', 'bom.packSize'], (orders) => {
+                for (const o of orders) {
+                    if (o.state !== 'done') {
+                        o.lossQty = zero;
+                        continue;
+                    }
+                    const out = o.producedQty ?? o.quantity;
+                    const bulk = o.stage === 'pack' ? out.times(o.bom?.packSize ?? orm.toDecimal(1)) : out;
+                    o.lossQty = (o.consumedQty ?? zero).minus(bulk);
+                }
+            }),
+        }),
+        lossPercent: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Loss %',
+            help: 'The process loss as a share of what was consumed.',
+            ...compute('production.order', 'lossPercent', ['lossQty', 'consumedQty'], (orders) => {
+                for (const o of orders) {
+                    const c = o.consumedQty ?? zero;
+                    o.lossPercent = c.gt(0) ? (o.lossQty ?? zero).div(c).times(100).toDecimalPlaces(2) : zero;
+                }
+            }),
+        }),
+        yieldStatus: f.selection({ pending: 'Pending', within: 'Within tolerance', beyond: 'Beyond tolerance' }, {
+            store: true,
+            label: 'Yield',
+            help: 'Once done: the loss against the bill’s expected loss, within its tolerance or beyond it.',
+            ...compute('production.order', 'yieldStatus', ['state', 'lossPercent', 'consumedQty', 'bom.expectedLoss', 'bom.tolerance'], (orders) => {
+                for (const o of orders) {
+                    if (o.state !== 'done' || (o.consumedQty ?? zero).lte(0)) {
+                        o.yieldStatus = 'pending';
+                        continue;
+                    }
+                    const diff = (o.lossPercent ?? zero).minus(o.bom?.expectedLoss ?? zero);
+                    const gap = diff.lt(0) ? zero.minus(diff) : diff;
+                    o.yieldStatus = gap.lte(o.bom?.tolerance ?? zero) ? 'within' : 'beyond';
+                }
+            }),
+        }),
+        actualStart: f.datetime({ label: 'Started' }),
+        actualEnd: f.datetime({ label: 'Finished' }),
+        operator: f.many2one('res.users', { ondelete: 'set null' }),
+        shift: f.many2one('production.shift', { ondelete: 'set null' }),
+        manufacturingDate: f.date({ label: 'Manufactured on' }),
+        expiryDate: f.date({
+            label: 'Expires on',
+            help: 'From the product’s shelf life, on the batch’s lot.',
+        }),
+        date: f.date({ required: true, default: (env) => env.today(), label: 'Planned for' }),
+        warehouse: f.many2one('stock.warehouse', { ondelete: 'restrict' }),
+        components: f.one2many('production.order.component', 'production'),
+        /** Scrap recorded on the order, with its reasons (Stockroom's scrap). */
+        scraps: f.one2many('stock.scrap', 'production'),
+        workorders: f.one2many('production.workorder', 'production', { label: 'Work orders' }),
+        consumption: f.many2one('stock.picking', {
+            ondelete: 'set null',
+            label: 'Components transfer',
+        }),
+        output: f.many2one('stock.picking', { ondelete: 'set null', label: 'Output transfer' }),
+        /** The components at their cost. */
+        materialCost: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Materials',
+            help: 'The components needed at their cost.',
+            ...compute('production.order', 'materialCost', ['components.cost'], (orders) => {
+                for (const o of orders)
+                    o.materialCost = [...o.components].reduce((s, c) => s.plus(c.cost ?? zero), zero);
+            }),
+        }),
+        /** The operations at their work centres' cost per hour. */
+        operationCost: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Operations',
+            help: 'The operations’ minutes for the quantity ordered at their work centres’ cost per hour.',
+            ...compute('production.order', 'operationCost', [
+                'quantity',
+                'bom.quantity',
+                'bom.operations.minutes',
+                'bom.operations.workcenter.costPerHour',
+            ], (orders) => {
+                for (const o of orders) {
+                    if (o.bom === null) {
+                        o.operationCost = zero;
+                        continue;
+                    }
+                    const factor = o.quantity.div(o.bom.quantity);
+                    o.operationCost = money([...o.bom.operations].reduce((s, op) => s.plus(op.minutes.times(factor).div(60).times(op.workcenter.costPerHour)), zero));
+                }
+            }),
+        }),
+        totalCost: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Total cost',
+            help: 'The materials and the operations together.',
+            ...compute('production.order', 'totalCost', ['materialCost', 'operationCost'], (orders) => {
+                for (const o of orders)
+                    o.totalCost = (o.materialCost ?? zero).plus(o.operationCost ?? zero);
+            }),
+        }),
+        unitCost: f.decimal({
+            scale: 4,
+            store: true,
+            label: 'Unit cost',
+            help: 'The total cost divided by the quantity made.',
+            ...compute('production.order', 'unitCost', ['totalCost', 'quantity'], (orders) => {
+                for (const o of orders)
+                    o.unitCost = o.quantity.gt(0)
+                        ? (o.totalCost ?? zero).div(o.quantity).toDecimalPlaces(4)
+                        : zero;
+            }),
+        }),
+        /** The one chip: Draft, Waiting (components short), Ready, Done, Cancelled. */
+        status: f.selection({
+            draft: 'Draft',
+            waiting: 'Waiting',
+            ready: 'Ready',
+            progress: 'In progress',
+            done: 'Done',
+            cancelled: 'Cancelled',
+        }, {
+            store: true,
+            label: 'Status',
+            help: 'A confirmed order is ready once all its components are reserved, otherwise it is waiting.',
+            ...compute('production.order', 'status', ['state', 'consumption.availability'], (orders) => {
+                for (const o of orders)
+                    o.status =
+                        o.state === 'confirmed'
+                            ? o.consumption?.availability === 'full'
+                                ? 'ready'
+                                : 'waiting'
+                            : o.state === 'cancel'
+                                ? 'cancelled'
+                                : o.state;
+            }),
+        }),
+        note: f.text(),
+        state: f.state({
+            states: {
+                draft: 'Draft',
+                confirmed: 'Confirmed',
+                progress: 'In progress',
+                done: 'Done',
+                cancel: 'Cancelled',
+            },
+            initial: 'draft',
+            help: 'Confirmed, the components are reserved and the work orders scheduled; done, the product is made.',
+            transitions: {
+                /** Lists the components with what is available and short, and the cost, before anything starts. */
+                check: {
+                    from: ['draft', 'confirmed'],
+                    to: 'draft',
+                    guard: records('production.order', async (orders) => (await orders.load({})).filter((o) => o.state !== 'draft')),
+                    message: 'A confirmed order is checked with Check availability.',
+                    after: records('production.order', async (orders) => {
+                        await explode(orders.ids, orders.env);
+                    }),
+                },
+                confirm: emitting('production.order.confirmed', {
+                    from: ['draft'],
+                    to: 'confirmed',
+                    guard: records('production.order', async (orders) => {
+                        const env = orders.env;
+                        const out = [];
+                        for (const o of await orders.load({ bom: true, company: true })) {
+                            if (o.bom === null || o.bom.state === 'inactive' || o.bom.state === 'review') {
+                                out.push(o.id);
+                                continue;
+                            }
+                            if (o.bom.state === 'draft' && (await bomsNeedApproval(env, o.company.id)))
+                                out.push(o.id);
+                        }
+                        return out;
+                    }),
+                    message: 'Choose a bill of materials that may be used: an active one (or a draft, when bills need no approval).',
+                    // The components, their transfer to Production (reserved), and the work orders, scheduled.
+                    after: records('production.order', async (orders) => {
+                        await explode(orders.ids, orders.env);
+                        await planWork(orders.ids, orders.env);
+                        const env = orders.env;
+                        for (const o of await env
+                            .model('production.order')
+                            .browse(orders.ids)
+                            .load({ components: true, sourceOrder: true })) {
+                            // Nothing to consume (labour only): no components transfer.
+                            if (o.components.length === 0)
+                                continue;
+                            // A pack order takes its bulk from the make order's lot.
+                            const bulkProduct = o.sourceOrder?.product.id ?? null;
+                            const { stock, production } = await placesOf(env, o.warehouse?.id ?? null, o.company.id);
+                            const made = await env.model('stock.picking').create([
+                                {
+                                    kind: 'production',
+                                    company: o.company.id,
+                                    warehouse: o.warehouse?.id ?? null,
+                                    source: stock,
+                                    destination: production,
+                                    origin: o.name,
+                                    scheduledDate: o.date,
+                                    moves: {
+                                        create: [...o.components].map((c) => ({
+                                            product: c.product.id,
+                                            quantity: c.required,
+                                            restrictLot: o.sourceLot !== null && c.product.id === bulkProduct
+                                                ? o.sourceLot.id
+                                                : null,
+                                        })),
+                                    },
+                                },
+                            ]);
+                            await made.confirm();
+                            await env
+                                .model('production.order')
+                                .browse([o.id])
+                                .write({ consumption: made.ids[0] ?? null });
+                        }
+                    }),
+                }),
+                /** "Check availability": reserve the components that came in since. */
+                reserve: {
+                    from: ['confirmed'],
+                    to: 'confirmed',
+                    after: records('production.order', async (orders) => {
+                        const env = orders.env;
+                        for (const o of await env.model('production.order').browse(orders.ids).load({}))
+                            if (o.consumption !== null)
+                                await env.model('stock.picking').browse([o.consumption.id]).reserve();
+                    }),
+                },
+                /** Work begins: the actual start; the batch in progress. */
+                start: {
+                    from: ['confirmed'],
+                    to: 'progress',
+                    after: records('production.order', async (orders) => {
+                        const env = orders.env;
+                        await env
+                            .model('production.order')
+                            .browse(orders.ids)
+                            .write({ actualStart: env.now() });
+                        await env.flush();
+                        for (const o of await orders.load({}))
+                            if (o.schedule !== null)
+                                await followOrders(env, o.schedule.id);
+                    }),
+                },
+                produce: emitting('production.order.done', {
+                    from: ['confirmed', 'progress'],
+                    to: 'done',
+                    guard: records('production.order', async (orders) => (await orders.load({ consumption: true })).filter((o) => o.consumption !== null && o.consumption.availability !== 'full')),
+                    message: 'Components are short: check availability, or wait for them to come in.',
+                    before: records('production.order', async (orders) => {
+                        const env = orders.env;
+                        // What is left of the work is done with the order.
+                        const open = await env.model('production.workorder').search({
+                            where: { production: { in: [...orders.ids] }, state: { in: ['ready', 'progress'] } },
+                        });
+                        if (open.length > 0)
+                            await open.close();
+                        for (const o of await env
+                            .model('production.order')
+                            .browse(orders.ids)
+                            .load({ product: true })) {
+                            if (o.consumption !== null)
+                                await env.model('stock.picking').browse([o.consumption.id]).validate();
+                            const { stock, production } = await placesOf(env, o.warehouse?.id ?? null, o.company.id);
+                            const [bill] = o.bom === null
+                                ? []
+                                : await env.model('production.bom').browse([o.bom.id]).load({ byproducts: true });
+                            const produced = o.producedQty ?? o.quantity;
+                            const factor = bill === undefined ? zero : produced.div(bill.quantity);
+                            // A tracked product is produced into the batch's lot (the order's reference without a batch).
+                            const tracking = o.product.tracking ?? 'none';
+                            const tracked = tracking !== 'none';
+                            const lotName = o.batch ?? o.name;
+                            const made = await env.model('stock.picking').create([
+                                {
+                                    kind: 'production',
+                                    company: o.company.id,
+                                    warehouse: o.warehouse?.id ?? null,
+                                    source: production,
+                                    destination: stock,
+                                    origin: o.name,
+                                    moves: {
+                                        create: [
+                                            { product: o.product.id, quantity: produced },
+                                            ...[...(bill?.byproducts ?? [])].map((b) => ({
+                                                product: b.product.id,
+                                                quantity: b.quantity.times(factor).toDecimalPlaces(4),
+                                                uom: b.uom?.id ?? null,
+                                            })),
+                                        ],
+                                    },
+                                    ...(tracked
+                                        ? {
+                                            lotLines: {
+                                                create: [{ product: o.product.id, lotName, quantity: produced }],
+                                            },
+                                        }
+                                        : {}),
+                                },
+                            ]);
+                            // Linked before it is validated: what values it (production_account) finds its order.
+                            await env
+                                .model('production.order')
+                                .browse([o.id])
+                                .write({ output: made.ids[0] ?? null });
+                            await made.confirm();
+                            await made.validate();
+                            // The batch's lot with its expiry from the product's shelf life; the dates; the end of the work.
+                            const today = dayOf(env.today());
+                            let lot = null;
+                            let expiryDate = null;
+                            if (tracked) {
+                                lot =
+                                    (await env
+                                        .model('stock.lot')
+                                        .search({ where: { product: o.product.id, name: lotName }, limit: 1 })).ids[0] ?? null;
+                                const days = o.product.shelfLifeDays ?? 0;
+                                if (lot !== null && days > 0) {
+                                    const expiry = new Date(`${today}T00:00:00Z`);
+                                    expiry.setUTCDate(expiry.getUTCDate() + days);
+                                    expiryDate = expiry.toISOString().slice(0, 10);
+                                    await env.model('stock.lot').browse([lot]).write({ expiryDate });
+                                }
+                            }
+                            await env.model('production.order').browse([o.id]).write({
+                                lot,
+                                producedQty: produced,
+                                manufacturingDate: today,
+                                expiryDate,
+                                actualEnd: env.now(),
+                            });
+                            await env.flush();
+                            // The pack orders waiting for this batch: confirmed now, their bulk taken from its lot.
+                            const packs = await env
+                                .model('production.order')
+                                .search({ where: { sourceOrder: o.id, state: 'draft' } });
+                            if (packs.length > 0) {
+                                await env.model('production.order').browse(packs.ids).write({ sourceLot: lot });
+                                await env.flush();
+                                await packs.confirm();
+                                await env.flush();
+                            }
+                        }
+                    }),
+                    after: records('production.order', async (orders) => {
+                        const env = orders.env;
+                        for (const o of await orders.load({}))
+                            if (o.schedule !== null)
+                                await followOrders(env, o.schedule.id);
+                    }),
+                }),
+                cancel: {
+                    from: ['draft', 'confirmed', 'progress'],
+                    to: 'cancel',
+                    after: records('production.order', async (orders) => {
+                        const env = orders.env;
+                        const open = await env.model('production.workorder').search({
+                            where: { production: { in: [...orders.ids] }, state: { in: ['ready', 'progress'] } },
+                        });
+                        for (const w of await open.load({}))
+                            await w.cancel();
+                        for (const o of await env
+                            .model('production.order')
+                            .browse(orders.ids)
+                            .load({ consumption: true }))
+                            if (o.consumption !== null &&
+                                o.consumption.state !== 'done' &&
+                                o.consumption.state !== 'cancel')
+                                await env.model('stock.picking').browse([o.consumption.id]).cancel();
+                    }),
+                },
+                redraft: { from: ['cancel'], to: 'draft' },
+            },
+        }),
+    },
+    onchange: {
+        // The bill valid on the order's date, and the company's first warehouse.
+        product: onchange('production.order', async (d, env) => {
+            const product = d.get('product');
+            if (product === null || product === undefined)
+                return;
+            d.set('bom', await validBom(env, product, String(d.get('date') ?? env.today())));
+            if ((d.get('warehouse') ?? null) === null)
+                d.set('warehouse', (await defaultLocations(env, 'internal')).warehouse);
+        }),
+        date: onchange('production.order', async (d, env) => {
+            const product = d.get('product');
+            if (product === null || product === undefined)
+                return;
+            d.set('bom', await validBom(env, product, String(d.get('date') ?? env.today())));
+        }),
+    },
+    sqlConstraints: {
+        positive: { check: orm.sql `quantity > 0`, message: 'An order makes a positive quantity.' },
+    },
+    constraints: {
+        billOfTheProduct: {
+            ...check('production.order', ['bom', 'product'], async (orders) => (await orders.load({ bom: true }))
+                .filter((o) => o.bom !== null && o.bom.product.id !== o.product.id)
+                .map((o) => o.id)),
+            message: 'The bill of materials is for another product.',
+        },
+    },
+});
+/** Scrap recorded on a production order (a broken component, a faulty unit made), with its reason. */
+/** Production's product fields: the shelf life of what is made, the retail price printed on its label. */
+export const ProductProduction = extendModel('product.product', {
+    fields: {
+        shelfLifeDays: f.integer({
+            label: 'Shelf life (days)',
+            help: 'A produced lot expires this many days after its manufacturing date; empty: no expiry.',
+        }),
+        retailPrice: f.decimal({
+            scale: 2,
+            label: 'Maximum retail price',
+            help: 'Printed on the batch label (MRP).',
+        }),
+    },
+});
+export const ScrapProduction = extendModel('stock.scrap', {
+    fields: {
+        production: f.many2one('production.order', { ondelete: 'set null', label: 'Production order' }),
+    },
+});
+/**
+ * Reorder rules that make (RFC 0024 §2.6): production orders not produced yet are on order; ordering makes one
+ * production order per rule with the bill valid on its date, confirmed (its components reserved, its work planned).
+ */
+export const ReorderMake = extendModel('stock.reorder', {
+    overrides: {
+        pending: async function (next) {
+            const out = await next();
+            const rules = this;
+            const env = rules.env;
+            for (const r of await rules.load({})) {
+                const main = (await defaultLocations(env, 'internal', null, r.company.id))
+                    .warehouse;
+                const orders = await (await env.model('production.order').search({
+                    where: {
+                        product: r.product.id,
+                        company: r.company.id,
+                        state: { in: ['draft', 'confirmed'] },
+                    },
+                })).load({});
+                const found = out.get(r.id) ?? [];
+                for (const o of orders)
+                    if ((o.warehouse?.id ?? main) === r.warehouse.id)
+                        found.push({ quantity: o.quantity.toString(), document: o.name });
+                out.set(r.id, found);
+            }
+            return out;
+        },
+        procure: async function (next, quantities) {
+            const out = await next(quantities);
+            const rules = this;
+            const env = rules.env;
+            for (const r of await rules.load({ product: true })) {
+                const qty = quantities.get(r.id);
+                if (r.method !== 'make' || qty === undefined)
+                    continue;
+                const date = new Date(`${env.today()}T00:00:00Z`);
+                date.setUTCDate(date.getUTCDate() + r.leadDays);
+                const when = date.toISOString().slice(0, 10);
+                const bom = await validBom(env, r.product.id, when);
+                if (bom === null)
+                    throw new orm.ValidationError('stock.reorder', ['method'], `${r.product.name} has no bill of materials valid on ${when}.`, 'Add one in Production › Bills of materials, or replenish it another way.');
+                const made = await env.model('production.order').create([
+                    {
+                        product: r.product.id,
+                        quantity: qty,
+                        bom,
+                        date: when,
+                        warehouse: r.warehouse.id,
+                        company: r.company.id,
+                        note: 'Replenishment',
+                    },
+                ]);
+                await made.confirm();
+                const [order] = await made.load({});
+                out.set(r.id, order?.name ?? '');
+            }
+            return out;
+        },
+    },
+});
+export const productionShutro = defineModule({
+    name: 'production',
+    version: '0.3.0',
+    depends: [productShutro, stockShutro, contactsShutro, messagingShutro, permissionsShutro],
+    groups: [
+        orm.defineGroup({ code: 'production.user', label: 'Production user', implies: ['stock.user'] }),
+        orm.defineGroup({
+            code: 'production.manager',
+            label: 'Production manager',
+            implies: ['production.user'],
+        }),
+    ],
+    sequences: [
+        orm.defineSequence({
+            code: 'production.order',
+            prefix: 'MO/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+        orm.defineSequence({
+            code: 'production.plan',
+            prefix: 'PLAN/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+        orm.defineSequence({
+            code: 'production.schedule',
+            prefix: 'BATCH/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+    ],
+    models: [
+        ProductionWorkcenter,
+        ProductionBom,
+        ProductionBomLine,
+        ProductionBomByproduct,
+        ProductionBomOperation,
+        ProductionOrder,
+        ProductionOrderComponent,
+        ProductionWorkorder,
+        ProductionSpecParameter,
+        ProductionProductSpec,
+        ProductionBomSpec,
+        ProductionBomCost,
+        ProductionBomEligibility,
+        ProductionShift,
+        ProductionPlan,
+        ProductionPlanLine,
+        ProductionPlanMaterial,
+        ProductionSchedule,
+        ProductionScheduleComponent,
+    ],
+    extensions: [ScrapProduction, ReorderMake, CompanyProduction, ProductProduction],
+});