@happyvertical/smrt-planner 0.0.1 → 0.1.0

package/dist/core/app.js

@@ -1,15 +1,119 @@
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { dirname, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { validateInferenceConfig } from "../inference/config.js";
+import { parseKitchenConfig } from "../kitchen/client.js";
 /**
- * Absolute path of the prerendered static planner app inside this package
- * (`app/`, built with the planner's relative base, so it works at `/` and at
- * any sub-path). Node only; kept out of `./core` so that entry stays free of
- * Node built-ins.
- *
- * Serve the files from here, and write your own `planner.config.json` next to
- * its `index.html` (copy the directory, or answer that one path yourself).
+ * Absolute path of the root-built prerendered planner app inside this package.
+ * Node only; kept out of `./core` so that entry stays free of Node built-ins.
+ * Serve it at `/`, or use `materializeApp` for a supported subpath artifact.
  */
 export const appDir = fileURLToPath(new URL('../../app/', import.meta.url));
-/** Absolute path of one file in the app, e.g. `appFile('planner.config.json')`. */
+/** Absolute path of one packaged app file, e.g. `appFile('index.html')`. */
 export function appFile(relativePath) {
     return fileURLToPath(new URL(relativePath, new URL('../../app/', import.meta.url)));
 }
+const sensitiveName = /^(?:api[-_]?key|key|token|authorization|secret|password)$/i;
+/** Validate and canonicalize a non-root app mount prefix. */
+export function normalizeAppBasePath(basePath) {
+    if (typeof basePath !== 'string' ||
+        !/^\/[A-Za-z0-9._~-]+(?:\/[A-Za-z0-9._~-]+)*$/.test(basePath) ||
+        basePath.split('/').some((segment) => segment === '.' || segment === '..')) {
+        throw new Error('basePath must start with /, contain URL-safe path segments, and have no trailing slash');
+    }
+    return basePath;
+}
+function assertCredentialFree(value, path = 'config') {
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => {
+            assertCredentialFree(entry, `${path}[${index}]`);
+        });
+        return;
+    }
+    for (const [name, entry] of Object.entries(value)) {
+        if (sensitiveName.test(name)) {
+            throw new Error(`${path}.${name} is a credential field and cannot be built into the app`);
+        }
+        assertCredentialFree(entry, `${path}.${name}`);
+    }
+}
+/** Validate config strictly enough for an immutable public artifact. */
+export function normalizePlannerAppConfig(config) {
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+        throw new Error('config must be an object');
+    }
+    const unknown = Object.keys(config).filter((name) => name !== 'inference' && name !== 'kitchen');
+    if (unknown.length)
+        throw new Error(`unknown app config field: ${unknown[0]}`);
+    assertCredentialFree(config);
+    const inference = validateInferenceConfig({
+        inference: config.inference,
+    });
+    if (inference.notice)
+        throw new Error(inference.notice);
+    let kitchen;
+    if (config.kitchen !== undefined) {
+        kitchen = parseKitchenConfig(config.kitchen);
+        if (!kitchen) {
+            throw new Error('kitchen.endpoint must be a usable http(s) URL');
+        }
+    }
+    return {
+        inference: inference.config,
+        ...(kitchen ? { kitchen } : {}),
+    };
+}
+function patchFallback(file, basePath) {
+    const source = readFileSync(file, 'utf8');
+    if (!source.includes('/_app/') || !/base:\s*""/.test(source)) {
+        throw new Error('packaged 404.html does not match the supported root fallback');
+    }
+    const patched = source
+        .replaceAll('/_app/', `${basePath}/_app/`)
+        .replace(/base:\s*""/, `base: ${JSON.stringify(basePath)}`);
+    if (patched.includes('"/_app/') || /base:\s*""/.test(patched)) {
+        throw new Error('could not make the fallback prefix-safe');
+    }
+    writeFileSync(file, patched);
+}
+/**
+ * Copy the published static app into a deterministic, prefix-safe deployment
+ * artifact. The copy is assembled beside `outDir` and renamed only after its
+ * fallback and config validate, so callers never receive a partial tree.
+ */
+export function materializeApp(options) {
+    const basePath = normalizeAppBasePath(options.basePath);
+    const config = normalizePlannerAppConfig(options.config);
+    const outDir = resolve(options.outDir);
+    const source = resolve(appDir);
+    const relation = relative(source, outDir);
+    if (!relation || (!relation.startsWith(`..${sep}`) && relation !== '..')) {
+        throw new Error('outDir must be outside the packaged app directory');
+    }
+    if (existsSync(outDir)) {
+        if (!statSync(outDir).isDirectory() || readdirSync(outDir).length > 0) {
+            throw new Error('outDir must be new or empty');
+        }
+    }
+    mkdirSync(dirname(outDir), { recursive: true });
+    const temporary = mkdtempSync(resolve(dirname(outDir), '.smrt-planner-'));
+    try {
+        cpSync(source, temporary, { recursive: true });
+        patchFallback(resolve(temporary, '404.html'), basePath);
+        writeFileSync(resolve(temporary, 'planner.config.json'), `${JSON.stringify(config, null, 2)}\n`);
+        if (existsSync(outDir))
+            rmdirSync(outDir);
+        renameSync(temporary, outDir);
+    }
+    catch (error) {
+        rmSync(temporary, { recursive: true, force: true });
+        throw error;
+    }
+    return {
+        outDir,
+        configFile: resolve(outDir, 'planner.config.json'),
+        fallbackFile: resolve(outDir, '404.html'),
+    };
+}

package/dist/core/prompt.js

@@ -16,7 +16,7 @@ function indexOf(catalog) {
 }
 /** The snapshot's theme as the setting the prompt describes. */
 function themeOf(snapshot) {
-    const { preset, primary, colorScheme } = snapshot.theme;
+    const { preset, primary, colorScheme, borderRadius, density, contrast } = snapshot.theme;
     const theme = {};
     if (preset)
         theme.preset = preset;
@@ -25,6 +25,13 @@ function themeOf(snapshot) {
     if (colorScheme && colorScheme !== 'system') {
         theme.colorScheme = colorScheme;
     }
+    if (borderRadius) {
+        theme.borderRadius = borderRadius;
+    }
+    if (density)
+        theme.density = density;
+    if (contrast)
+        theme.contrast = contrast;
     return Object.keys(theme).length ? theme : undefined;
 }
 /** `rename_item(id, label)`: required inputs bare, optional ones with `?`. */
@@ -80,6 +87,8 @@ export function buildHostPrompt(input) {
             currency: snapshot.settings.currency,
             taxRate: Number((snapshot.settings.taxRate / 100).toFixed(6)),
             paymentTerms: snapshot.settings.paymentTerms,
+            pricesIncludeTax: snapshot.settings.pricesIncludeTax,
+            taxRounding: snapshot.settings.taxRounding,
         }, matchText(indexOf(catalog), message), { current: themeOf(snapshot) }),
         ...commandSection(snapshot),
     ].join('\n');

package/dist/core/reply.d.ts

@@ -18,12 +18,17 @@ export interface HostReply {
         currency?: string;
         taxRate?: number;
         paymentTerms?: string;
+        pricesIncludeTax?: boolean;
+        taxRounding?: 'line' | 'document';
     };
-    /** Theme tokens: a preset or `#rrggbb`, and light or dark. */
+    /** Theme tokens: a preset or `#rrggbb`, light or dark, corner radius, density and contrast. */
     theme?: {
         preset?: string;
         primary?: string;
         colorScheme?: string;
+        borderRadius?: string;
+        density?: string;
+        contrast?: string;
     };
     /** Up to 8 planner commands, run in order by the planner. */
     commands?: {

package/dist/data/children.d.ts

@@ -1,5 +1,6 @@
 import type { CatalogModel } from '../catalog/types.ts';
 import { type ModelRecord } from './fakes.ts';
+import { type MoneyContext } from './money.ts';
 /** A child model and the field holding its parent's id (see `childLinks`). */
 export interface ChildOf {
     model: CatalogModel;
@@ -9,12 +10,55 @@ export interface ChildOf {
  * Sample child rows for one parent record: one to four (journals, an even
  * number of balanced entries), each pointing at the parent through `fk`. Ids
  * and values are seeded from the parent's id, so the same parent always gets
- * the same children. A line item's `amount` is `quantity * unitPrice` so it
- * reads right next to the parent's totals.
+ * the same children. A line's money (`amount`, `taxAmount`, its tax code's
+ * snapshot) is settled with its document's other lines (`settleSample`).
  */
-export declare function fakeChildrenOf(child: CatalogModel, fk: string, parent: ModelRecord, seed: number): ModelRecord[];
+export declare function fakeChildrenOf(child: CatalogModel, fk: string, parent: ModelRecord, seed: number, rows?: number): ModelRecord[];
+/** Does a sample document give a discount (about one in three, by its id)? */
+export declare function discounted(parent: {
+    id: string;
+}): boolean;
 /**
- * Bring a parent's totals in line with the line items just generated for it
- * (see `withTotals`).
+ * Does a sample line carry its own tax code (`taxMode: 'override'`), about one
+ * line in seven by its document and position, never a document's first line?
  */
-export declare function syncTotals(parent: ModelRecord, parentModel: CatalogModel, items: readonly ModelRecord[]): void;
+export declare function overridesTax(parent: {
+    id: string;
+}, index: number): boolean;
+/**
+ * The code an overriding sample line chooses, by line: in an app whose
+ * currency an example-pack code names, that code half the time (BC GST + PST
+ * for CAD, so its components show apart); otherwise exempt or zero-rated.
+ */
+export declare function overrideTaxCode(parent: {
+    id: string;
+}, index: number, currency?: string): import("./money.ts").SampleTaxCode | undefined;
+/**
+ * A sample line once the app's hidden fields' values are applied (`carried`):
+ * where the app hides the line's `discount`, an amount discount could not be
+ * seen or entered, so the line takes its tenth off as a percentage instead,
+ * and where it hides `discountRate` too, the line has no discount.
+ */
+export declare function withCarried(item: ModelRecord, carried: Readonly<Record<string, unknown>>): ModelRecord;
+/**
+ * The sample documents whose stored totals deliberately disagree with their
+ * lines, so the record page's mismatch flag has something to show: the third
+ * Order and the third Invoice (row index 2), drafts whose subtotal and total
+ * were left stale by an edit made elsewhere. Only a draft's totals are read
+ * against its lines (an issued document shows its frozen figures as they
+ * are), so these two are drafts. Their own fields stay authoritative; the
+ * page only flags the difference. Editing a line recomputes the totals and
+ * clears it.
+ */
+export declare const MISMATCH_MODELS: readonly string[];
+export declare const MISMATCH_ROW = 2;
+/** What the stale total is off by, in minor units. */
+export declare const MISMATCH_AMOUNT = 2500;
+/** Leave one document's total stale (see {@link MISMATCH_MODELS}). */
+export declare function seedMismatch(parent: ModelRecord, parentModel: CatalogModel, index: number): void;
+/**
+ * Settle the line items just generated for a parent with it (see
+ * `settleWithLines`): the parent's totals are set in place and the settled
+ * lines returned.
+ */
+export declare function settleSample(parent: ModelRecord, parentModel: CatalogModel, items: readonly ModelRecord[], context: MoneyContext): ModelRecord[];

package/dist/data/children.js

@@ -1,16 +1,17 @@
-import { isLineModel, settleLine, withTotals } from "./derived.js";
-import { createRandom, fakeId, fakeRecord, hashString, packLine, } from "./fakes.js";
-import { getSamplePack } from "./packs.js";
+import { isLineModel, lineAmount, settleWithLines } from "./derived.js";
+import { createRandom, fakeId, fakeRecord, hashString, packLine, relatedIndex, } from "./fakes.js";
+import { examplePackCodeFor, SEEDED_TAX_CODES, } from "./money.js";
+import { getSamplePack, getSamplePricing } from "./packs.js";
 const MAX_CHILDREN = 4;
 const hasField = (model, name) => model.fields.some((f) => f.name === name);
 /**
  * Sample child rows for one parent record: one to four (journals, an even
  * number of balanced entries), each pointing at the parent through `fk`. Ids
  * and values are seeded from the parent's id, so the same parent always gets
- * the same children. A line item's `amount` is `quantity * unitPrice` so it
- * reads right next to the parent's totals.
+ * the same children. A line's money (`amount`, `taxAmount`, its tax code's
+ * snapshot) is settled with its document's other lines (`settleSample`).
  */
-export function fakeChildrenOf(child, fk, parent, seed) {
+export function fakeChildrenOf(child, fk, parent, seed, rows) {
     const random = createRandom(hashString(`${seed}:${child.id}:${parent.id}`));
     const ledger = hasField(child, 'debit') && hasField(child, 'credit');
     const count = ledger
@@ -21,7 +22,7 @@ export function fakeChildrenOf(child, fk, parent, seed) {
     return Array.from({ length: count }, (_, i) => {
         const index = hashString(`${parent.id}:${i}`) % 997;
         const record = {
-            ...fakeRecord(child, index, seed),
+            ...fakeRecord(child, index, seed, rows),
             id: fakeId(`${child.id}:${parent.id}:${i}`),
             [fk]: parent.id,
         };
@@ -32,7 +33,11 @@ export function fakeChildrenOf(child, fk, parent, seed) {
             const productField = child.fields.find((f) => f.related?.endsWith(':Product') && f.name in record);
             const pack = getSamplePack();
             const { products } = pack;
-            const item = products[(index % 5) % products.length];
+            // The same row the line's `productId` was pointed at (`relatedIndex`).
+            const item = productField
+                ? products[relatedIndex(productField, { modelId: child.id, index, rows }) %
+                    products.length]
+                : products[index % products.length];
             const described = packLine(index);
             if (described) {
                 // Labour and fabrication are not products: no product to point at.
@@ -57,9 +62,8 @@ export function fakeChildrenOf(child, fk, parent, seed) {
             const quantity = low + Math.floor(random() * (high - low + 1));
             if (hasField(child, 'quantity'))
                 record.quantity = quantity;
-            if (hasField(child, 'discount'))
-                record.discount = 0;
-            record.amount = settleLine(record).amount;
+            Object.assign(record, sampleLineMoney(child, parent, i, quantity, Number(record.unitPrice ?? 0)));
+            record.amount = lineAmount(record);
         }
         if (ledger) {
             const debit = i % 2 === 0;
@@ -69,12 +73,138 @@ export function fakeChildrenOf(child, fk, parent, seed) {
         return record;
     });
 }
+/** Does a sample document give a discount (about one in three, by its id)? */
+export function discounted(parent) {
+    return hashString(`discount:${parent.id}`) % 3 === 0;
+}
+/** A tenth off the line's price, in whole currency units. */
+function lineDiscount(quantity, unitPrice) {
+    return Math.round((quantity * unitPrice) / 1000) * 100;
+}
+/**
+ * Does a sample line carry its own tax code (`taxMode: 'override'`), about one
+ * line in seven by its document and position, never a document's first line?
+ */
+export function overridesTax(parent, index) {
+    return (index > 0 && hashString(`tax-override:${parent.id}:${index}`) % 7 === 0);
+}
 /**
- * Bring a parent's totals in line with the line items just generated for it
- * (see `withTotals`).
+ * The code an overriding sample line chooses, by line: in an app whose
+ * currency an example-pack code names, that code half the time (BC GST + PST
+ * for CAD, so its components show apart); otherwise exempt or zero-rated.
  */
-export function syncTotals(parent, parentModel, items) {
-    if (!items.length || !items.every((r) => 'unitPrice' in r))
+export function overrideTaxCode(parent, index, currency = getSamplePricing().currency) {
+    const draw = hashString(`tax-override-kind:${parent.id}:${index}`) % 4;
+    const pack = examplePackCodeFor(currency);
+    if (pack && draw < 2)
+        return pack;
+    const kind = draw % 2 === 0 ? 'exempt' : 'zero-rated';
+    return SEEDED_TAX_CODES.find((c) => c.kind === kind);
+}
+/**
+ * The money inputs of a sample line, for the fields the line has: a
+ * discounted document's first line takes a tenth off, as a percentage
+ * (`discountType: 'percent'`, `discountRate: '10'`) or a whole-unit amount
+ * (`'amount'`, `discount` in minor units), alternating by document; a few
+ * lines carry a tax code of their own (`overrideTaxCode`); every other line
+ * inherits its code. What the line then comes to is the document's to settle.
+ */
+function sampleLineMoney(child, parent, index, quantity, unitPrice) {
+    const money = {};
+    const discount = index === 0 && discounted(parent);
+    const percent = hashString(`discount-kind:${parent.id}`) % 2 === 0;
+    if (hasField(child, 'discountType')) {
+        money.discountType = discount ? (percent ? 'percent' : 'amount') : 'none';
+    }
+    if (hasField(child, 'discountRate')) {
+        money.discountRate = discount && percent ? '10' : null;
+    }
+    if (hasField(child, 'discount')) {
+        money.discount =
+            discount && !(percent && hasField(child, 'discountType'))
+                ? lineDiscount(quantity, unitPrice)
+                : 0;
+    }
+    // A line with a `discount` but no `discountType` field cannot say which
+    // kind it is: an amount is the only one the model can read from it.
+    if (!hasField(child, 'discountType') && money.discount) {
+        money.discountType = 'amount';
+    }
+    const override = overridesTax(parent, index)
+        ? overrideTaxCode(parent, index)
+        : undefined;
+    if (hasField(child, 'taxMode')) {
+        money.taxMode = override ? 'override' : 'inherit';
+    }
+    if (hasField(child, 'taxCodeId'))
+        money.taxCodeId = override?.id ?? null;
+    return money;
+}
+/**
+ * A sample line once the app's hidden fields' values are applied (`carried`):
+ * where the app hides the line's `discount`, an amount discount could not be
+ * seen or entered, so the line takes its tenth off as a percentage instead,
+ * and where it hides `discountRate` too, the line has no discount.
+ */
+export function withCarried(item, carried) {
+    const next = { ...item, ...carried };
+    if ('discount' in carried &&
+        !('discountType' in carried) &&
+        next.discountType === 'amount') {
+        next.discountType = 'percent';
+        next.discountRate = '10';
+        next.discount = 0;
+    }
+    // Neither kind can be seen: no discount at all.
+    if ('discountRate' in carried && next.discountType === 'percent') {
+        next.discountType = 'none';
+        next.discountRate = null;
+        next.discount = 0;
+    }
+    return next;
+}
+/**
+ * The sample documents whose stored totals deliberately disagree with their
+ * lines, so the record page's mismatch flag has something to show: the third
+ * Order and the third Invoice (row index 2), drafts whose subtotal and total
+ * were left stale by an edit made elsewhere. Only a draft's totals are read
+ * against its lines (an issued document shows its frozen figures as they
+ * are), so these two are drafts. Their own fields stay authoritative; the
+ * page only flags the difference. Editing a line recomputes the totals and
+ * clears it.
+ */
+export const MISMATCH_MODELS = [
+    '@happyvertical/smrt-commerce:Order',
+    '@happyvertical/smrt-commerce:Invoice',
+];
+export const MISMATCH_ROW = 2;
+/** What the stale total is off by, in minor units. */
+export const MISMATCH_AMOUNT = 2500;
+/** Leave one document's total stale (see {@link MISMATCH_MODELS}). */
+export function seedMismatch(parent, parentModel, index) {
+    if (index !== MISMATCH_ROW ||
+        !MISMATCH_MODELS.includes(parentModel.id) ||
+        typeof parent.subtotal !== 'number' ||
+        typeof parent.totalAmount !== 'number') {
         return;
-    Object.assign(parent, withTotals(parentModel, parent, items));
+    }
+    if (parentModel.fields.some((f) => f.name === 'status' && f.enum?.includes('draft'))) {
+        parent.status = 'draft';
+    }
+    // Stale but self-consistent: subtotal and total moved together.
+    parent.subtotal += MISMATCH_AMOUNT;
+    parent.totalAmount += MISMATCH_AMOUNT;
+}
+/**
+ * Settle the line items just generated for a parent with it (see
+ * `settleWithLines`): the parent's totals are set in place and the settled
+ * lines returned.
+ */
+export function settleSample(parent, parentModel, items, context) {
+    if (!items.length || !items.every((r) => 'unitPrice' in r)) {
+        return [...items];
+    }
+    const settled = settleWithLines(parentModel, parent, items, context);
+    Object.assign(parent, settled.row);
+    return settled.lines;
 }

package/dist/data/derived.d.ts

@@ -1,37 +1,45 @@
 /**
- * Amounts the commerce models derive rather than take as input, mirrored from
- * `ContractLineItem` / `InvoiceLineItem` / `Invoice` in smrt-commerce:
+ * Amounts a document's lines derive rather than take as input, on
+ * smrt-commerce's money model (released in 0.56.1; `money.ts` holds the
+ * mapping to the package's own calculator):
  *
- *   line subtotal = round(quantity * unitPrice) - discount   (minor units)
- *   line tax      = round(line subtotal * taxRate)           (taxRate is a fraction)
- *   line amount   = line subtotal + line tax
+ *   line amount   = quantity x unitPrice - discount
+ *                   (prices without tax: the line's net; with tax: its gross)
+ *   line tax      = from the line's resolved tax code, per component
+ *   subtotal      = sum of the lines' net
+ *   taxAmount     = sum of the lines' tax
+ *   totalAmount   = subtotal + taxAmount
+ *   discountTotal = sum of the lines' discounts, informational: already
+ *                   inside the line amounts, never subtracted again
  *
- * and a parent with line items takes `subtotal`, `taxAmount` and `totalAmount`
- * from the sum of its lines, ignoring what a form sent.
+ * A parent with line items takes these from its lines, ignoring what a form
+ * sent. See AGENTS.md.
  */
 import type { CatalogModel } from '../catalog/types.ts';
+import { type LineAmountType, type MoneyContext, type SettledDocument, type TaxRoundingScope } from './money.ts';
+export { lineAmount } from './money.ts';
 type Row = Readonly<Record<string, unknown>>;
 /** A line item: it prices a quantity of something. */
 export declare function isLineModel(model: CatalogModel): boolean;
-export interface LineAmounts {
-    subtotal: number;
-    tax: number;
-    amount: number;
-}
-export declare function lineAmounts(line: Row): LineAmounts;
-/** The line with its `amount` brought in line with its other fields. */
-export declare function settleLine<T extends Row>(line: T): T & {
-    amount: number;
-};
-export interface ParentTotals {
-    subtotal: number;
-    taxAmount: number;
-    totalAmount: number;
-}
-export declare function totalsOf(lines: readonly Row[]): ParentTotals;
+/** The totals a document's summary shows: subtotal, tax, total. */
 export declare const TOTAL_FIELDS: readonly ["subtotal", "taxAmount", "totalAmount"];
-/** `row` with the model's total fields set from `lines`. */
-export declare function withTotals<T extends Record<string, unknown>>(model: CatalogModel, row: T, lines: readonly Row[]): T;
+/** Every header field its lines decide, `discountTotal` included. */
+export declare const DOCUMENT_MONEY_FIELDS: readonly ["subtotal", "taxAmount", "totalAmount", "discountTotal"];
+/** The fields of a line its document's calculation writes. */
+export declare const LINE_MONEY_FIELDS: readonly ["amount", "taxAmount", "taxRate", "taxCodeCode", "taxCodeName"];
+/** The document's own pricing mode, else `fallback` (the app's). */
+export declare function documentLineAmountType(row: Row, fallback: LineAmountType): LineAmountType;
+/** The document's own rounding scope, else `fallback` (the app's). */
+export declare function documentRoundingScope(row: Row, fallback: TaxRoundingScope): TaxRoundingScope;
+/**
+ * `row` and its `lines` settled together: the lines' derived fields, and the
+ * model's header money fields (`subtotal`, `discountTotal`, `taxAmount`,
+ * `totalAmount`, where the model has them).
+ */
+export declare function settleWithLines<T extends Record<string, unknown>, L extends Row>(model: CatalogModel, row: T, lines: readonly L[], context: MoneyContext): {
+    row: T;
+    lines: SettledDocument<L>['lines'];
+};
 /** A record that tracks what has been paid against it (an Invoice). */
 export declare function tracksPayments(model: CatalogModel): boolean;
 /** The field of a payment allocation that points at its payment. */
@@ -59,9 +67,10 @@ export declare function settleInvoice(invoice: Row, counted: readonly {
     at: string;
 }[], now: number): Settlement;
 /**
- * The fields a form shows but does not let anyone type: a line's `amount`, a
- * parent's totals when it has line items, and what an invoice has paid (and
- * when) when it has payment allocations.
+ * The fields a form shows but does not let anyone type: a line's money (its
+ * amount, tax and the tax code's snapshot), a parent's totals when it has line
+ * items, and what an invoice has paid (and when) when it has payment
+ * allocations.
  */
 export declare function derivedFieldNames(model: CatalogModel, hasLineChildren: boolean, hasPaymentChildren?: boolean): ReadonlySet<string>;
 /** Does the field of a line item point at a product? */
@@ -76,4 +85,3 @@ export declare function isProductField(field: {
  * editable. A product with no name or price fills nothing.
  */
 export declare function productPrefill(line: CatalogModel, product: Row | undefined): Record<string, unknown>;
-export {};

package/dist/data/derived.js

@@ -1,3 +1,5 @@
+import { settleDocument, } from "./money.js";
+export { lineAmount } from "./money.js";
 const num = (value) => {
     const n = Number(value ?? 0);
     return Number.isFinite(n) ? n : 0;
@@ -7,35 +9,47 @@ const has = (model, name) => model.fields.some((f) => f.name === name);
 export function isLineModel(model) {
     return ['quantity', 'unitPrice', 'amount'].every((n) => has(model, n));
 }
-export function lineAmounts(line) {
-    const subtotal = Math.round(num(line.quantity) * num(line.unitPrice)) - num(line.discount);
-    const tax = Math.round(subtotal * num(line.taxRate));
-    return { subtotal, tax, amount: subtotal + tax };
-}
-/** The line with its `amount` brought in line with its other fields. */
-export function settleLine(line) {
-    return { ...line, amount: lineAmounts(line).amount };
+/** The totals a document's summary shows: subtotal, tax, total. */
+export const TOTAL_FIELDS = ['subtotal', 'taxAmount', 'totalAmount'];
+/** Every header field its lines decide, `discountTotal` included. */
+export const DOCUMENT_MONEY_FIELDS = [
+    ...TOTAL_FIELDS,
+    'discountTotal',
+];
+/** The fields of a line its document's calculation writes. */
+export const LINE_MONEY_FIELDS = [
+    'amount',
+    'taxAmount',
+    'taxRate',
+    'taxCodeCode',
+    'taxCodeName',
+];
+const LINE_AMOUNT_TYPES = ['exclusive', 'inclusive', 'none'];
+/** The document's own pricing mode, else `fallback` (the app's). */
+export function documentLineAmountType(row, fallback) {
+    const value = row.lineAmountType;
+    return typeof value === 'string' && LINE_AMOUNT_TYPES.includes(value)
+        ? value
+        : fallback;
 }
-export function totalsOf(lines) {
-    let subtotal = 0;
-    let taxAmount = 0;
-    for (const line of lines) {
-        const parts = lineAmounts(line);
-        subtotal += parts.subtotal;
-        taxAmount += parts.tax;
-    }
-    return { subtotal, taxAmount, totalAmount: subtotal + taxAmount };
+/** The document's own rounding scope, else `fallback` (the app's). */
+export function documentRoundingScope(row, fallback) {
+    const value = row.taxRoundingScope;
+    return value === 'line' || value === 'document' ? value : fallback;
 }
-export const TOTAL_FIELDS = ['subtotal', 'taxAmount', 'totalAmount'];
-/** `row` with the model's total fields set from `lines`. */
-export function withTotals(model, row, lines) {
-    const totals = totalsOf(lines);
+/**
+ * `row` and its `lines` settled together: the lines' derived fields, and the
+ * model's header money fields (`subtotal`, `discountTotal`, `taxAmount`,
+ * `totalAmount`, where the model has them).
+ */
+export function settleWithLines(model, row, lines, context) {
+    const settled = settleDocument(lines, context);
     const next = { ...row };
-    for (const name of TOTAL_FIELDS) {
+    for (const name of DOCUMENT_MONEY_FIELDS) {
         if (has(model, name))
-            next[name] = totals[name];
+            next[name] = settled[name];
     }
-    return next;
+    return { row: next, lines: settled.lines };
 }
 /** A record that tracks what has been paid against it (an Invoice). */
 export function tracksPayments(model) {
@@ -91,18 +105,23 @@ export function settleInvoice(invoice, counted, now) {
     };
 }
 /**
- * The fields a form shows but does not let anyone type: a line's `amount`, a
- * parent's totals when it has line items, and what an invoice has paid (and
- * when) when it has payment allocations.
+ * The fields a form shows but does not let anyone type: a line's money (its
+ * amount, tax and the tax code's snapshot), a parent's totals when it has line
+ * items, and what an invoice has paid (and when) when it has payment
+ * allocations.
  */
 export function derivedFieldNames(model, hasLineChildren, hasPaymentChildren = false) {
     const names = new Set();
-    if (isLineModel(model))
-        names.add('amount');
+    if (isLineModel(model)) {
+        for (const name of LINE_MONEY_FIELDS)
+            if (has(model, name))
+                names.add(name);
+    }
     if (hasLineChildren) {
-        for (const name of TOTAL_FIELDS)
+        for (const name of DOCUMENT_MONEY_FIELDS) {
             if (has(model, name))
                 names.add(name);
+        }
     }
     if (hasPaymentChildren && tracksPayments(model)) {
         for (const name of ['amountPaid', 'paidDate']) {