@happyvertical/smrt-planner 0.0.1 → 0.1.0

package/dist/data/planner-source.js

@@ -1,17 +1,54 @@
 import { catalog } from "../catalog/index.js";
-import { browserStorage } from "../cookbook/storage.js";
+import { browserStorage, STORAGE_KEY } from "../cookbook/storage.js";
+import { followSettings } from "../cookbook/store.svelte.js";
+import { parseCookbookText } from "../cookbook/validate.js";
 import { catalogModels } from "../forms/shared.js";
 import { PROFILE_TYPE, stockSamples, VARIANT } from "../forms/stock.js";
+import { ASSET, PRODUCT_ASSET } from "../products/media.js";
 import { recipes } from "../recipes/index.js";
 import { childLinks } from "../recipes/plumbing.js";
 import { recipeState } from "../recipes/state.svelte.js";
+import { DEFAULT_SAMPLE_TAX_RATE, fakeId } from "./fakes.js";
+import { defaultTaxCode, sampleTaxCodes, sampleTaxComponents, } from "./money.js";
+import { getSamplePricing, getSampleTaxRate } from "./packs.js";
 import { createMemoryDataSource } from "./source.js";
+const C = '@happyvertical/smrt-commerce:';
+const TAX_CODE = `${C}TaxCode`;
+const TAX_COMPONENT = `${C}TaxComponent`;
+const TAX_SETTINGS = `${C}TaxSettings`;
+const DOCUMENT_TAX = `${C}DocumentTax`;
+const MONEY_MIGRATION = `${C}MoneyMigrationDocument`;
+/** The sample tenant's tax codes for the app's current settings. */
+function currentTaxCodes() {
+    const rate = getSampleTaxRate() ?? DEFAULT_SAMPLE_TAX_RATE;
+    return { codes: sampleTaxCodes(rate), fallback: defaultTaxCode(rate) };
+}
+/**
+ * A page opened straight at a record reads sample rows before the layout
+ * hydrates the saved cookbook (its `afterNavigate`), so the rows would be
+ * priced by defaults rather than the app's money settings. Read the saved
+ * cookbook's settings first; only reads, the store's hydrate does the rest.
+ */
+function primeSampleSettings(storage) {
+    try {
+        const raw = storage?.getItem(STORAGE_KEY);
+        if (!raw)
+            return;
+        const parsed = parseCookbookText(raw, { dropUnknownRecipes: true });
+        if (parsed.ok)
+            followSettings(parsed.cookbook);
+    }
+    catch {
+        // Unreadable or unavailable: the store's hydrate reports it.
+    }
+}
 /**
  * The planner's sample-data source: seeded in-memory fakes whose added, edited
  * and deleted rows survive a reload (Reset clears them). The seam for live
  * objects: swap this for a collection-backed `DataSource`.
  */
 export function createPlannerDataSource() {
+    primeSampleSettings(browserStorage());
     return createMemoryDataSource({
         storage: browserStorage(),
         // Fields the views hide still carry their policy default, e.g. the
@@ -20,8 +57,91 @@ export function createPlannerDataSource() {
         // Variants only make sense under a product a form creates, so they start
         // empty, as do Profile types: a form adds the one it needs. Locations, SKUs
         // and stock are sampled together (one SKU per product).
-        empty: [VARIANT, PROFILE_TYPE],
-        samples: stockSamples(catalogModels),
+        // A document's tax snapshot is kept on its lines (`taxComponentsJson`),
+        // so `DocumentTax` holds no rows of its own; the planner's tenant is on
+        // the money model from the start and never migrates.
+        empty: [VARIANT, PROFILE_TYPE, DOCUMENT_TAX, MONEY_MIGRATION],
+        samples: {
+            // The tax codes sample documents resolve against: the seeded ones,
+            // the app default and smrt-commerce's example pack (`data/money.ts`).
+            [TAX_CODE]: {
+                from: [],
+                make: () => currentTaxCodes().codes.map((code) => ({
+                    id: code.id,
+                    code: code.code,
+                    name: code.name,
+                    kind: code.kind,
+                    appliesTo: code.appliesTo,
+                    active: code.active,
+                    componentsJson: JSON.stringify(code.components.map((part) => ({
+                        taxComponentId: part.id,
+                        compound: false,
+                    }))),
+                })),
+            },
+            [TAX_COMPONENT]: {
+                from: [],
+                make: () => sampleTaxComponents(currentTaxCodes().codes).map((part) => ({
+                    id: part.id,
+                    name: part.name,
+                    percent: part.percent,
+                    liabilityAccountId: null,
+                    recoverable: part.recoverable,
+                    active: true,
+                })),
+            },
+            [TAX_SETTINGS]: {
+                from: [],
+                make: () => {
+                    const { fallback } = currentTaxCodes();
+                    const pricing = getSamplePricing();
+                    return [
+                        {
+                            id: fakeId(`${TAX_SETTINGS}:sample`),
+                            defaultSalesTaxCodeId: fallback.id,
+                            defaultPurchaseTaxCodeId: fallback.id,
+                            defaultLineAmountType: pricing.pricesIncludeTax
+                                ? 'inclusive'
+                                : 'exclusive',
+                            taxRoundingScope: pricing.taxRounding,
+                            moneyModel: 'v2',
+                        },
+                    ];
+                },
+            },
+            ...stockSamples(catalogModels),
+            [ASSET]: {
+                from: [catalogModels('@happyvertical/smrt-products:Product')],
+                make: ([products]) => (products ?? []).map((product, i) => ({
+                    id: fakeId(`${ASSET}:sample:${product.id}`),
+                    name: `${String(product.name ?? 'Product')} image`,
+                    sourceUri: `data:image/svg+xml,${encodeURIComponent(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 240 240"><rect width="240" height="240" fill="hsl(${(i * 47) % 360} 40% 82%)"/><circle cx="120" cy="94" r="46" fill="hsl(${(i * 47 + 30) % 360} 35% 58%)"/><path d="M44 214c20-55 132-55 152 0" fill="hsl(${(i * 47 + 10) % 360} 30% 46%)"/><text x="120" y="224" text-anchor="middle" font-family="sans-serif" font-size="14" fill="white">${String(product.name ?? '').replace(/[<&>]/g, '')}</text></svg>`)}`,
+                    mimeType: 'image/svg+xml',
+                    description: `Sample image for ${String(product.name ?? 'this product')}.`,
+                    sourceType: 'browser-demo',
+                })),
+            },
+            [PRODUCT_ASSET]: {
+                from: [
+                    catalogModels('@happyvertical/smrt-products:Product'),
+                    catalogModels(ASSET),
+                ],
+                make: ([products, assets]) => (products ?? []).flatMap((product, i) => {
+                    const asset = assets?.[i];
+                    return asset
+                        ? [
+                            {
+                                id: fakeId(`${PRODUCT_ASSET}:sample:${product.id}`),
+                                productId: product.id,
+                                assetId: asset.id,
+                                relationship: 'gallery',
+                                sortOrder: 0,
+                            },
+                        ]
+                        : [];
+                }),
+            },
+        },
         // Every sample parent comes with line items: the same parent-to-children
         // lookup the record view uses, so what it shows is what was seeded.
         children: {

package/dist/data/source.d.ts

@@ -45,6 +45,11 @@ export type RecordWrite = {
 };
 export interface DataSource {
     list(model: CatalogModel): Promise<ModelRecord[]>;
+    /**
+     * The rows whose `field` equals `value` (compared as strings): a record's
+     * related rows, by the foreign key that points at it.
+     */
+    listWhere(model: CatalogModel, field: string, value: string): Promise<ModelRecord[]>;
     get(model: CatalogModel, id: string): Promise<ModelRecord | undefined>;
     create(model: CatalogModel, values: Record<string, unknown>): Promise<ModelRecord>;
     update(model: CatalogModel, id: string, values: Record<string, unknown>): Promise<ModelRecord | undefined>;
@@ -63,8 +68,14 @@ export interface DataSource {
      */
     onReset?(listener: () => void): () => void;
 }
-/** Prefix of the localStorage keys rows are kept under, one per model. */
-export declare const DATA_STORAGE_PREFIX = "smrt-planner:data:v3:";
+/**
+ * Prefix of the localStorage keys rows are kept under, one per model. v6:
+ * documents are on smrt-commerce's money model (a line's `amount` is its net
+ * after discount, or its gross when prices include tax, with tax stored
+ * apart; `derived.ts`). Rows kept under an older prefix are left behind for
+ * fresh samples, never migrated.
+ */
+export declare const DATA_STORAGE_PREFIX = "smrt-planner:data:v6:";
 /** Remove every stored row. Never throws. */
 export declare function clearStoredData(storage: Storage | null | undefined): void;
 export interface MemoryDataSourceOptions {

package/dist/data/source.js

@@ -1,14 +1,33 @@
-import { fakeChildrenOf, syncTotals } from "./children.js";
-import { allocationInvoiceField, allocationPaymentField, isAllocationModel, isLineModel, PAID_PAYMENT_STATUS, settleInvoice, settleLine, tracksPayments, withTotals, } from "./derived.js";
-import { EPOCH, fakeId, fakeRecords, sampleRowCount, } from "./fakes.js";
+import { fakeChildrenOf, seedMismatch, settleSample, withCarried, } from "./children.js";
+import { allocationInvoiceField, allocationPaymentField, documentLineAmountType, documentRoundingScope, isAllocationModel, isLineModel, PAID_PAYMENT_STATUS, settleInvoice, settleWithLines, tracksPayments, } from "./derived.js";
+import { DEFAULT_SAMPLE_ROWS, DEFAULT_SAMPLE_TAX_RATE, EPOCH, fakeId, fakeRecords, sampleRowCount, } from "./fakes.js";
+import { defaultTaxCode, MoneyValidationError, moneyCurrency, sampleTaxCodes, settleDocument, } from "./money.js";
+import { getSamplePricing, getSampleTaxRate } from "./packs.js";
 import { fakeAllocations } from "./payments.js";
 export function isRecordRef(value) {
     return (typeof value === 'object' &&
         value !== null &&
         typeof value.ref === 'string');
 }
-/** Prefix of the localStorage keys rows are kept under, one per model. */
-export const DATA_STORAGE_PREFIX = 'smrt-planner:data:v3:';
+/**
+ * Prefix of the localStorage keys rows are kept under, one per model. v6:
+ * documents are on smrt-commerce's money model (a line's `amount` is its net
+ * after discount, or its gross when prices include tax, with tax stored
+ * apart; `derived.ts`). Rows kept under an older prefix are left behind for
+ * fresh samples, never migrated.
+ */
+export const DATA_STORAGE_PREFIX = 'smrt-planner:data:v6:';
+const TAX_CODE_MODEL = '@happyvertical/smrt-commerce:TaxCode';
+const TAX_COMPONENT_MODEL = '@happyvertical/smrt-commerce:TaxComponent';
+const TAX_CODE_KINDS = ['taxable', 'zero-rated', 'exempt', 'out-of-scope'];
+/** Has a document left `draft`, freezing the codes its lines were taxed with? */
+function isIssuedRow(model, row) {
+    const status = model.fields.find((f) => f.name === 'status');
+    return (Boolean(status?.enum?.includes('draft')) &&
+        typeof row.status === 'string' &&
+        row.status !== '' &&
+        row.status !== 'draft');
+}
 const CREATED_KEY = `${DATA_STORAGE_PREFIX}_created`;
 /** Remove every stored row. Never throws. */
 export function clearStoredData(storage) {
@@ -31,7 +50,7 @@ export function clearStoredData(storage) {
 /** Deterministic seeded fakes held in memory, lazily per model. */
 export function createMemoryDataSource(options = {}) {
     const seed = options.seed ?? 1;
-    const rows = options.rowsPerModel ?? 8;
+    const rows = options.rowsPerModel ?? DEFAULT_SAMPLE_ROWS;
     const empty = new Set(options.empty ?? []);
     const tables = new Map();
     const resetListeners = new Set();
@@ -177,7 +196,7 @@ export function createMemoryDataSource(options = {}) {
         // A child's rows come from its parents, never from random fakes.
         const made = empty.has(model.id) || owned.length || allocation
             ? []
-            : fakeRecords(model, sampleRowCount(model.id, rows), seed);
+            : fakeRecords(model, sampleRowCount(model.id, rows), seed, rows);
         // Registered before the other side is built so each finds this table.
         tables.set(model.id, made);
         for (const link of linksOf(model.id))
@@ -196,15 +215,136 @@ export function createMemoryDataSource(options = {}) {
         }
         if (!empty.has(model.id)) {
             for (const { parent, fk } of owned) {
-                for (const row of table(parent)) {
-                    const items = fakeChildrenOf(model, fk, row, seed);
-                    made.push(...items);
-                    syncTotals(row, parent, items);
-                }
+                // A child row takes the values a hidden field carries in this app
+                // (a line's discount the recipe options leave at 0), as one created
+                // through the form would, before its parent's totals are summed.
+                const carried = options.defaults?.(model) ?? {};
+                table(parent).forEach((row, index) => {
+                    const items = fakeChildrenOf(model, fk, row, seed, rows).map((item) => withCarried(item, carried));
+                    if (!isLineModel(model)) {
+                        made.push(...items);
+                        return;
+                    }
+                    made.push(...settleSample(row, parent, items, moneyContext(parent, row)));
+                    seedMismatch(row, parent, index);
+                });
             }
         }
         return made;
     };
+    const modelById = new Map((options.children?.models ?? []).map((m) => [m.id, m]));
+    /**
+     * The sample tenant's tax codes as its tables hold them: the seeded set for
+     * the app's rate, with any `TaxCode` row (and the `TaxComponent` rows it
+     * names) replacing or adding to it, so a code the visitor added or edited
+     * is the one a line resolves.
+     */
+    const tenantTaxCodes = (rate) => {
+        const base = sampleTaxCodes(rate);
+        // Through `table`, so rows saved in an earlier visit count even when
+        // nothing has opened the tax tables yet.
+        const codeModel = modelById.get(TAX_CODE_MODEL);
+        const componentModel = modelById.get(TAX_COMPONENT_MODEL);
+        const rows = codeModel ? table(codeModel) : [];
+        if (!rows.length)
+            return base;
+        const parts = new Map(base.flatMap((c) => c.components.map((p) => [p.id, p])));
+        for (const row of componentModel ? table(componentModel) : []) {
+            parts.set(row.id, {
+                id: row.id,
+                key: row.id,
+                name: String(row.name ?? ''),
+                percent: String(row.percent ?? '0'),
+                recoverable: row.recoverable === true,
+            });
+        }
+        const fromRows = rows.map((row) => {
+            let listed = [];
+            try {
+                listed = JSON.parse(String(row.componentsJson ?? '[]'));
+            }
+            catch {
+                listed = [];
+            }
+            const components = (Array.isArray(listed) ? listed : []).flatMap((entry) => {
+                const found = entry && typeof entry === 'object'
+                    ? parts.get(String(entry.taxComponentId))
+                    : undefined;
+                return found ? [found] : [];
+            });
+            const kind = TAX_CODE_KINDS.includes(String(row.kind))
+                ? row.kind
+                : 'taxable';
+            const appliesTo = ['sales', 'purchases', 'both'].includes(String(row.appliesTo))
+                ? row.appliesTo
+                : 'both';
+            return {
+                id: row.id,
+                code: String(row.code ?? ''),
+                name: String(row.name ?? ''),
+                kind,
+                appliesTo,
+                active: row.active !== false,
+                components,
+            };
+        });
+        const byId = new Map(fromRows.map((c) => [c.id, c]));
+        // A table seeded with the tenant's codes is the whole truth: a code the
+        // visitor deleted stays deleted, except the default for the app's current
+        // rate, which smrt's activation creates (or reuses) whenever the rate is
+        // set, so a rate changed after the table was seeded still has its code.
+        // A table that never held them (a source without tax samples) only adds
+        // to the seeded set.
+        if (base.some((c) => byId.has(c.id))) {
+            const fallback = defaultTaxCode(rate);
+            const seeded = base
+                .filter((c) => byId.has(c.id) || c.id === fallback.id)
+                .map((c) => byId.get(c.id) ?? c);
+            return [
+                ...seeded,
+                ...fromRows.filter((c) => !base.some((b) => b.id === c.id)),
+            ];
+        }
+        return [...base, ...fromRows];
+    };
+    /**
+     * How a document's money is settled: its own pricing mode and rounding,
+     * else the app's; the sample tenant's tax codes, the app default for its
+     * tax rate; and what its customer and products say about tax.
+     */
+    const moneyContext = (parent, row) => {
+        const pricing = getSamplePricing();
+        const rate = getSampleTaxRate() ?? DEFAULT_SAMPLE_TAX_RATE;
+        const codes = tenantTaxCodes(rate);
+        const customerField = parent.fields.find((f) => f.name === 'customerId' && f.related);
+        const customerModel = customerField?.related
+            ? modelById.get(customerField.related)
+            : undefined;
+        const customer = customerModel
+            ? table(customerModel).find((c) => c.id === row.customerId)
+            : undefined;
+        const products = (productId) => {
+            for (const [id, rows] of tables) {
+                if (!id.endsWith(':Product'))
+                    continue;
+                const found = rows.find((p) => p.id === productId);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        };
+        const codeOf = (value) => typeof value === 'string' && value ? value : null;
+        return {
+            lineAmountType: documentLineAmountType(row, pricing.pricesIncludeTax ? 'inclusive' : 'exclusive'),
+            roundingScope: documentRoundingScope(row, pricing.taxRounding),
+            currency: moneyCurrency(row.currency, moneyCurrency(pricing.currency)),
+            codes,
+            appDefaultCodeId: defaultTaxCode(rate).id,
+            customerTaxExempt: customer?.taxExempt === true,
+            partyCodeId: codeOf(customer?.defaultTaxCodeId),
+            productCodeOf: (productId) => codeOf(products(productId)?.defaultSalesTaxCodeId),
+        };
+    };
     /** Save the model and the tables it is built together with. */
     const persist = (model) => {
         if (!storage)
@@ -234,37 +374,75 @@ export function createMemoryDataSource(options = {}) {
             // Quota or private mode: the rows stay in memory for this visit.
         }
     };
-    /** A parent's line items, by its id. */
-    const lineLink = (parent) => linksOf(parent.id).find((l) => isLineModel(l.model));
-    /** Recompute a parent's totals from its lines (they are never typed in). */
-    const resync = (parent, parentId) => {
+    /**
+     * A document's line items: a line model that belongs to it through its own
+     * key (an Invoice's lines by `invoiceId`), never a model the lines merely
+     * point at (a Product or a TaxCode is not the document they are settled in).
+     */
+    const lineLink = (parent) => linksOf(parent.id).find((l) => isLineModel(l.model) &&
+        ownersOf(l.model.id).some((o) => o.parent.id === parent.id && o.fk === l.fk));
+    /**
+     * Settle a parent with its lines (they are never typed in): the lines'
+     * money and the parent's totals, written back to both tables. Whether the
+     * parent was there to settle.
+     */
+    const resync = (parent, parentId, lineWrite = false) => {
         const link = lineLink(parent);
         if (!link)
-            return;
+            return false;
         const list = table(parent);
         const index = list.findIndex((r) => r.id === parentId);
         if (index < 0)
-            return;
-        const lines = table(link.model).filter((r) => r[link.fk] === parentId);
-        list[index] = withTotals(parent, list[index], lines);
+            return false;
+        const lineRows = table(link.model);
+        const lines = lineRows.filter((r) => r[link.fk] === parentId);
+        const row = list[index];
+        // An issued document's money is frozen, as smrt's money model freezes it
+        // when a document leaves draft: its own edits keep the stored figures,
+        // and a change to its lines is refused.
+        if (isIssuedRow(parent, row)) {
+            if (lineWrite) {
+                throw new MoneyValidationError('FROZEN_DOCUMENT', `This ${parent.name.toLowerCase()} has been issued, so its lines can no longer change.`);
+            }
+            return true;
+        }
+        const settled = settleWithLines(parent, row, lines, moneyContext(parent, row));
+        list[index] = settled.row;
+        for (const line of settled.lines) {
+            const at = lineRows.findIndex((r) => r.id === line.id);
+            if (at >= 0)
+                lineRows[at] = line;
+        }
+        return true;
     };
-    /** Settle a written row, then the parents whose totals depend on it. */
+    /**
+     * Settle a written row, then the parents whose totals depend on it. Throws
+     * smrt's `MoneyValidationError` for money the model refuses.
+     */
     const settle = (model, record) => {
         let settled = record;
-        if (isLineModel(model)) {
-            settled = settleLine(record);
-            const list = table(model);
-            const index = list.findIndex((r) => r.id === record.id);
-            if (index >= 0)
-                list[index] = settled;
-        }
         if (lineLink(model)) {
             resync(model, record.id);
             settled = table(model).find((r) => r.id === record.id) ?? settled;
         }
-        for (const { parent, fk } of ownersOf(model.id)) {
-            if (isLineModel(model))
-                resync(parent, record[fk]);
+        if (isLineModel(model)) {
+            const owned = ownersOf(model.id).some(({ parent, fk }) => resync(parent, record[fk], true));
+            const list = table(model);
+            const index = list.findIndex((r) => r.id === record.id);
+            if (!owned && index >= 0) {
+                // A line with no document settles on its own, on the app's terms.
+                const pricing = getSamplePricing();
+                const rate = getSampleTaxRate() ?? DEFAULT_SAMPLE_TAX_RATE;
+                const alone = settleDocument([record], {
+                    lineAmountType: pricing.pricesIncludeTax ? 'inclusive' : 'exclusive',
+                    roundingScope: pricing.taxRounding,
+                    currency: moneyCurrency(pricing.currency),
+                    codes: tenantTaxCodes(rate),
+                    appDefaultCodeId: defaultTaxCode(rate).id,
+                }).lines[0];
+                list[index] = alone;
+            }
+            settled = table(model).find((r) => r.id === record.id) ?? settled;
         }
         // What an invoice has paid follows its allocations and their payments.
         if (tracksPayments(model)) {
@@ -286,6 +464,22 @@ export function createMemoryDataSource(options = {}) {
         }
         return settled;
     };
+    /** Copies of the tables a write to `model` may settle, to undo a refusal. */
+    const snapshotFamily = (model) => {
+        const family = [
+            model,
+            ...linksOf(model.id).map((l) => l.model),
+            ...ownersOf(model.id).map((o) => o.parent),
+        ];
+        return new Map(family.map((m) => [m.id, table(m).map((r) => ({ ...r }))]));
+    };
+    const restore = (snapshot) => {
+        for (const [id, rows] of snapshot) {
+            const list = tables.get(id);
+            if (list)
+                list.splice(0, list.length, ...rows);
+        }
+    };
     const present = (model, record) => ({
         ...record,
         ...(options.defaults?.(model) ?? {}),
@@ -296,6 +490,11 @@ export function createMemoryDataSource(options = {}) {
         async list(model) {
             return table(model).map((r) => present(model, r));
         },
+        async listWhere(model, field, value) {
+            return table(model)
+                .filter((r) => String(r[field] ?? '') === value)
+                .map((r) => present(model, r));
+        },
         async get(model, id) {
             const found = table(model).find((r) => r.id === id);
             return found ? present(model, found) : undefined;
@@ -306,8 +505,17 @@ export function createMemoryDataSource(options = {}) {
                 ...values,
                 id: nextId(model),
             };
+            const snapshot = snapshotFamily(model);
             table(model).push(record);
-            const settled = settle(model, record);
+            let settled;
+            try {
+                settled = settle(model, record);
+            }
+            catch (error) {
+                restore(snapshot);
+                created--;
+                throw error;
+            }
             persist(model);
             return { ...settled };
         },
@@ -316,9 +524,26 @@ export function createMemoryDataSource(options = {}) {
             const index = list.findIndex((r) => r.id === id);
             if (index < 0)
                 return undefined;
-            const next = { ...list[index], ...values, id };
+            const snapshot = snapshotFamily(model);
+            const previous = list[index];
+            const next = { ...previous, ...values, id };
             list[index] = next;
-            const settled = settle(model, next);
+            let settled;
+            try {
+                settled = settle(model, next);
+                // A line moved to another document leaves its old one: that one
+                // settles without it (refused when it has been issued).
+                if (isLineModel(model)) {
+                    for (const { parent, fk } of ownersOf(model.id)) {
+                        if (previous[fk] !== next[fk])
+                            resync(parent, previous[fk], true);
+                    }
+                }
+            }
+            catch (error) {
+                restore(snapshot);
+                throw error;
+            }
             persist(model);
             return { ...settled };
         },
@@ -327,13 +552,22 @@ export function createMemoryDataSource(options = {}) {
             const index = list.findIndex((r) => r.id === id);
             if (index < 0)
                 return false;
+            const snapshot = snapshotFamily(model);
             const [gone] = list.splice(index, 1);
-            const spec = allocationSpecOf(model);
-            if (spec && gone)
-                resettleInvoice(spec.invoice, gone[spec.invoiceFk]);
-            for (const { parent, fk } of ownersOf(model.id)) {
-                if (isLineModel(model) && gone)
-                    resync(parent, gone[fk]);
+            try {
+                const spec = allocationSpecOf(model);
+                if (spec && gone)
+                    resettleInvoice(spec.invoice, gone[spec.invoiceFk]);
+                for (const { parent, fk } of ownersOf(model.id)) {
+                    if (isLineModel(model) && gone)
+                        resync(parent, gone[fk], true);
+                }
+            }
+            catch (error) {
+                // The document refused (issued, or a sibling's code was switched
+                // off): the line stays, as it was.
+                restore(snapshot);
+                throw error;
             }
             persist(model);
             return true;

package/dist/features/palette.d.ts

@@ -28,6 +28,8 @@ export interface PlannerPaletteOptions {
     add: (id: string) => void;
     /** In-app path of a Planner tab, with the app query. */
     href: (tab: string) => string;
+    /** The group label of the planner's tabs; defaults to "Planner". */
+    title?: string;
 }
 /**
  * The planner's own providers: its tabs, and "Add <feature>" for every recipe

package/dist/features/palette.js

@@ -19,7 +19,7 @@ export function plannerProviders(options) {
     return [
         {
             id: 'planner-tabs',
-            label: 'Planner',
+            label: options.title ?? 'Planner',
             order: 20,
             items: () => PLANNER_TAB_COMMANDS.map((tab) => ({
                 id: tab.id,

package/dist/forms/stock.d.ts

@@ -25,4 +25,4 @@ export declare function stockSamples(models: ModelLookup): NonNullable<MemoryDat
  */
 export declare function stockByProduct(skus: readonly ModelRecord[], levels: readonly ModelRecord[]): Map<string, number>;
 /** Deletes for a product and everything the forms saved under it. */
-export declare function planProductDelete(productId: string, skus: readonly ModelRecord[], models: ModelLookup): RecordWrite[];
+export declare function planProductDelete(productId: string, skus: readonly ModelRecord[], models: ModelLookup, productAssets?: readonly ModelRecord[]): RecordWrite[];

package/dist/forms/stock.js

@@ -1,5 +1,6 @@
 import { fakeId, hashString } from "../data/fakes.js";
 import { getSamplePack } from "../data/packs.js";
+import { planProductImageDelete } from "../products/media.js";
 export const PRODUCT = '@happyvertical/smrt-products:Product';
 export const VARIANT = '@happyvertical/smrt-products:ProductVariant';
 export const SKU = '@happyvertical/smrt-products:Sku';
@@ -92,8 +93,9 @@ export function stockByProduct(skus, levels) {
     return totals;
 }
 /** Deletes for a product and everything the forms saved under it. */
-export function planProductDelete(productId, skus, models) {
+export function planProductDelete(productId, skus, models, productAssets = []) {
     return [
+        ...planProductImageDelete(productId, productAssets),
         ...skus.flatMap((sku) => [
             { op: 'delete', model: models(STOCK_LEVEL), match: { skuId: sku.id } },
             { op: 'delete', model: models(SKU), id: sku.id },

package/dist/index.d.ts

@@ -1,17 +1,22 @@
 /**
- * smrt planner as a package: mount the `Planner` component in a host layout,
+ * smrt planner as a package: mount `Planner` for the full app shell, or
+ * `PlannerControls` inside a host-owned shell,
  * drive it with the typed command set (`./commands` has no UI in it), and read
  * its plan as a compact snapshot.
  *
  * @module
  */
-export { type ByoPresetDefinition, type ConfigResult, type InferenceConfig, type InferenceMode, loadInferenceConfig, parseInferenceConfig, } from './inference/config.ts';
+export { type ByoPresetDefinition, type ConfigResult, type CredentialPersistence, type InferenceConfig, type InferenceMode, loadInferenceConfig, parseInferenceConfig, } from './inference/config.ts';
 export { createHostChat, type HostChatOptions, type HostRequest, } from './inference/host.ts';
 export { createOpenAIChat, testConnection } from './inference/openai.ts';
 export { type KitchenConfig, type KitchenEndpoint, type KitchenOutcome, type KitchenResult, parseKitchenConfig, sendToKitchen, } from './kitchen/client.ts';
 export { KITCHEN_FRAGMENT_KEY, type KitchenFragment, readKitchenFragment, } from './kitchen/fragment.ts';
 export { createPlannerAssistant, type PlannerAssistant, type PlannerChatInference, type PlannerConfigInference, type PlannerInference, } from './planner/assistant.ts';
 export * from './planner/commands/index.ts';
+export { default as HostPlanner } from './planner/host/HostPlanner.svelte';
+export { type CallKitchenTool, createHostSession, type HostPlan, type HostSession, } from './planner/host/session.svelte.ts';
 export { plannerController } from './planner/instance.ts';
 export { default as Planner } from './planner/Planner.svelte';
-export type { PlannerHandle, PlannerProps } from './planner/types.ts';
+export { default as PlannerControls } from './planner/PlannerControls.svelte';
+export { PLANNER_SHELL_EDGE_TOGGLES, PLANNER_SHELL_PANEL_DEFAULTS, plannerShellProps, } from './planner/shell.ts';
+export type { PlannerBackLink, PlannerHandle, PlannerProps, } from './planner/types.ts';