@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/sections/entries.d.ts

@@ -0,0 +1,30 @@
+import type { CatalogModel } from '../catalog/types.ts';
+import { type RowScope } from '../recipes/scope.ts';
+import type { Recipe } from '../recipes/types.ts';
+/** What a navigation entry (a layout item id) points at in the app. */
+export interface SectionEntry {
+    /** The layout item id, `item:<package>:<Model>[:<key>]`. */
+    id: string;
+    model: CatalogModel;
+    /** In-app path of the entry's page, without the app query. */
+    path: string;
+    /** The entry's declared noun for New, if the recipe gave one. */
+    noun?: string;
+    /** The slice of rows the entry lists, if it is a filtered view. */
+    scope?: RowScope;
+}
+/**
+ * Every navigation entry the added recipes and features produce, by layout
+ * item id. Counting and New use it to turn a menu row back into a model; the
+ * scope is the same one the entry's own page lists, so a count matches it.
+ */
+export declare function entryIndex(added: readonly Recipe[], features: readonly string[]): Map<string, SectionEntry>;
+/**
+ * The Options and Help groups behind a set of entries: the group (or recipe)
+ * of each added recipe that has one of them in its nav, in recipe order. A
+ * section can hold several, e.g. Sales: Customers and Sales.
+ */
+export declare function optionGroups(entryIds: readonly string[], added: readonly Recipe[]): {
+    id: string;
+    label: string;
+}[];

package/dist/sections/entries.js

@@ -0,0 +1,57 @@
+import { getModel } from "../catalog/index.js";
+import { featureNavItems } from "../recipes/features.js";
+import { navItemId, navPath, recipeNav } from "../recipes/index.js";
+import { pageScope } from "../recipes/scope.js";
+import { sectionId } from "../recipes/sections.js";
+/**
+ * Every navigation entry the added recipes and features produce, by layout
+ * item id. Counting and New use it to turn a menu row back into a model; the
+ * scope is the same one the entry's own page lists, so a count matches it.
+ */
+export function entryIndex(added, features) {
+    const nav = added.flatMap((recipe) => recipeNav(recipe));
+    const index = new Map();
+    for (const entry of nav) {
+        const id = navItemId(entry.packageId, entry.model.name, entry.key);
+        if (index.has(id))
+            continue;
+        const scope = pageScope(entry.model.id, entry.key, nav);
+        index.set(id, {
+            id,
+            model: entry.model,
+            path: navPath(entry),
+            ...(entry.noun ? { noun: entry.noun } : {}),
+            ...(scope ? { scope } : {}),
+        });
+    }
+    for (const item of featureNavItems(features)) {
+        if (index.has(item.id))
+            continue;
+        const model = getModel(item.packageId, item.modelName);
+        if (!model)
+            continue;
+        index.set(item.id, {
+            id: item.id,
+            model,
+            path: navPath({ packageId: item.packageId, model }),
+        });
+    }
+    return index;
+}
+/**
+ * The Options and Help groups behind a set of entries: the group (or recipe)
+ * of each added recipe that has one of them in its nav, in recipe order. A
+ * section can hold several, e.g. Sales: Customers and Sales.
+ */
+export function optionGroups(entryIds, added) {
+    const wanted = new Set(entryIds);
+    const groups = [];
+    for (const recipe of added) {
+        const has = recipeNav(recipe).some((entry) => wanted.has(navItemId(entry.packageId, entry.model.name, entry.key)));
+        const id = sectionId(recipe);
+        if (has && !groups.some((group) => group.id === id)) {
+            groups.push({ id, label: recipe.group?.label ?? recipe.label });
+        }
+    }
+    return groups;
+}

package/dist/sections/info.d.ts

@@ -0,0 +1,16 @@
+/** The icon of a section the visitor made, or one the host knows nothing of. */
+export declare const DEFAULT_SECTION_ICON = "folder";
+/** What the app suggests for a navigation section: its icon and its blurb. */
+export interface SectionInfo {
+    icon?: string;
+    description?: string;
+}
+/**
+ * The suggested icon and description of a layout section id. A recipe's
+ * section carries both in the recipe data (the group summary stands in for a
+ * missing description); the More section is the app's own; a cookbook's custom
+ * sections have a description in the cookbook, and an icon in its layout.
+ */
+export declare function sectionInfo(id: string): SectionInfo;
+/** The title of a section page: its label once the layout has resolved, never the raw id. */
+export declare function sectionTitle(heading: string | null | undefined): string;

package/dist/sections/info.js

@@ -0,0 +1,39 @@
+import { libraryCookbooks } from "../library/index.js";
+import { FEATURE_SECTION } from "../recipes/features.js";
+import { buildNavSections, recipes } from "../recipes/index.js";
+/** The icon of a section the visitor made, or one the host knows nothing of. */
+export const DEFAULT_SECTION_ICON = 'folder';
+const NAV_SECTIONS = new Map(buildNavSections(recipes).map((section) => [section.id, section]));
+/** `custom:` descriptions come with the cookbooks; ids are shared by name. */
+const CUSTOM_DESCRIPTIONS = new Map(libraryCookbooks.flatMap((cookbook) => Object.entries(cookbook.sectionDescriptions ?? {})));
+/**
+ * The suggested icon and description of a layout section id. A recipe's
+ * section carries both in the recipe data (the group summary stands in for a
+ * missing description); the More section is the app's own; a cookbook's custom
+ * sections have a description in the cookbook, and an icon in its layout.
+ */
+export function sectionInfo(id) {
+    if (id === `section:${FEATURE_SECTION.id}`) {
+        return {
+            icon: FEATURE_SECTION.icon,
+            description: FEATURE_SECTION.description,
+        };
+    }
+    if (id.startsWith('section:')) {
+        const section = NAV_SECTIONS.get(id.slice('section:'.length));
+        if (!section)
+            return {};
+        const summary = section.recipes.find((r) => r.group?.summary)?.group
+            ?.summary;
+        return {
+            icon: section.icon,
+            description: section.description ?? summary,
+        };
+    }
+    const description = CUSTOM_DESCRIPTIONS.get(id);
+    return description ? { description } : {};
+}
+/** The title of a section page: its label once the layout has resolved, never the raw id. */
+export function sectionTitle(heading) {
+    return heading?.trim() || 'Planner';
+}

package/dist/sections/path.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A section's page lives at `/s/<slug>/`. The slug is the layout id with its
+ * `kind:` prefix turned into `kind-` (`section:sales` -> `section-sales`,
+ * `custom:shop-2` -> `custom-shop-2`), so no path segment holds a colon. Only
+ * the first hyphen is the prefix; the kinds (`section`, `custom`, `package`)
+ * never contain one.
+ */
+export declare function sectionSlug(id: string): string;
+/** The layout id a slug names; the inverse of {@link sectionSlug}. */
+export declare function sectionIdFromSlug(slug: string): string;
+/** In-app path of a section's page, without the app query. */
+export declare function sectionPath(id: string): string;

package/dist/sections/path.js

@@ -0,0 +1,18 @@
+/**
+ * A section's page lives at `/s/<slug>/`. The slug is the layout id with its
+ * `kind:` prefix turned into `kind-` (`section:sales` -> `section-sales`,
+ * `custom:shop-2` -> `custom-shop-2`), so no path segment holds a colon. Only
+ * the first hyphen is the prefix; the kinds (`section`, `custom`, `package`)
+ * never contain one.
+ */
+export function sectionSlug(id) {
+    return id.replace(':', '-');
+}
+/** The layout id a slug names; the inverse of {@link sectionSlug}. */
+export function sectionIdFromSlug(slug) {
+    return slug.replace('-', ':');
+}
+/** In-app path of a section's page, without the app query. */
+export function sectionPath(id) {
+    return `/s/${sectionSlug(id)}/`;
+}

package/dist/settings/app-settings.d.ts

@@ -0,0 +1,44 @@
+import type { Cookbook } from '../cookbook/types.ts';
+import { type FieldPolicyRow } from '../recipes/policy.ts';
+/**
+ * App settings: the few defaults that belong to the visitor's app, not to a
+ * cookbook. They have no field of their own in the cookbook; they are the
+ * same app-scope `defaultValue` policy rows a cookbook writes, kept in one
+ * place so the Settings tab, the cookbook preview and the cookbooks agree on
+ * which fields each setting covers.
+ */
+export interface AppSettings {
+    /** ISO 4217 code. */
+    currency: string;
+    /** Default tax rate as a fraction (0.0825 is 8.25%). */
+    taxRate: number;
+    /** Default payment terms; empty means unset. */
+    paymentTerms: string;
+}
+export declare const DEFAULT_SETTINGS: Readonly<AppSettings>;
+/** Which model fields each setting is the default of (the single source). */
+export declare const SETTING_TARGETS: Readonly<Record<keyof AppSettings, readonly {
+    model: string;
+    field: string;
+}[]>>;
+/**
+ * A setting's row on a model no added recipe covers yet. Kept (by the store's
+ * pruning and the import check) so a recipe added later starts with the
+ * app's settings, and so removing every recipe never loses them.
+ */
+export declare function isSettingRow(row: FieldPolicyRow): boolean;
+/** The app's settings: the first stored row of each, else the defaults. */
+export declare function readSettings(cookbook: Pick<Cookbook, 'policies'>): AppSettings;
+/** Does the cookbook state a tax rate (a row), rather than leave the default? */
+export declare function hasTaxRateRow(cookbook: Pick<Cookbook, 'policies'>): boolean;
+/**
+ * A copy of the cookbook with the settings written as policy rows. A row is
+ * written for every model a setting covers (covered or not, so a recipe
+ * added later picks it up) and only where the value
+ * differs from what the model starts as; otherwise any row for it is removed,
+ * so an unset or default setting leaves no rows. Other keys on a row
+ * (visibility, label, ...) are kept.
+ */
+export declare function writeSettings(cookbook: Cookbook, settings: AppSettings): Cookbook;
+/** Starting values for a cookbook's editor: what it sets, else the defaults. */
+export declare function settingsOfCookbook(settings: Partial<AppSettings> | undefined): AppSettings;

package/dist/settings/app-settings.js

@@ -0,0 +1,138 @@
+import { getModelByQualifiedName } from "../catalog/index.js";
+import { recipesById } from "../recipes/index.js";
+import { resolveFields } from "../recipes/policy.js";
+export const DEFAULT_SETTINGS = {
+    currency: 'USD',
+    taxRate: 0,
+    paymentTerms: '',
+};
+const C = '@happyvertical/smrt-commerce:';
+/** Which model fields each setting is the default of (the single source). */
+export const SETTING_TARGETS = {
+    currency: [
+        'Order',
+        'PurchaseOrder',
+        'WholesaleOrder',
+        'Estimate',
+        'Invoice',
+        'Agreement',
+    ].map((model) => ({ model: `${C}${model}`, field: 'currency' })),
+    taxRate: ['InvoiceLineItem', 'ContractLineItem'].map((model) => ({
+        model: `${C}${model}`,
+        field: 'taxRate',
+    })),
+    paymentTerms: [
+        ...['Order', 'WholesaleOrder', 'Estimate', 'Invoice', 'Agreement'].map((model) => ({ model: `${C}${model}`, field: 'terms' })),
+        { model: `${C}Customer`, field: 'paymentTerms' },
+    ],
+};
+/**
+ * A setting's row on a model no added recipe covers yet. Kept (by the store's
+ * pruning and the import check) so a recipe added later starts with the
+ * app's settings, and so removing every recipe never loses them.
+ */
+export function isSettingRow(row) {
+    return Object.values(SETTING_TARGETS).some((targets) => targets.some((t) => t.model === row.objectRef && t.field === row.fieldName));
+}
+const KEYS = Object.keys(SETTING_TARGETS);
+function rowValue(row) {
+    if (row?.defaultValue === undefined || row.defaultValue === null) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(row.defaultValue);
+    }
+    catch {
+        return undefined;
+    }
+}
+function findRow(policies, model, field) {
+    return policies.find((r) => r.scopeType === 'app' && r.objectRef === model && r.fieldName === field);
+}
+/** The app's settings: the first stored row of each, else the defaults. */
+export function readSettings(cookbook) {
+    const out = { ...DEFAULT_SETTINGS };
+    const first = (key, type) => {
+        for (const { model, field } of SETTING_TARGETS[key]) {
+            const value = rowValue(findRow(cookbook.policies, model, field));
+            if (typeof value === type)
+                return value;
+        }
+        return undefined;
+    };
+    const currency = first('currency', 'string');
+    const taxRate = first('taxRate', 'number');
+    const paymentTerms = first('paymentTerms', 'string');
+    if (typeof currency === 'string')
+        out.currency = currency;
+    if (typeof taxRate === 'number')
+        out.taxRate = taxRate;
+    if (typeof paymentTerms === 'string')
+        out.paymentTerms = paymentTerms;
+    return out;
+}
+/** Does the cookbook state a tax rate (a row), rather than leave the default? */
+export function hasTaxRateRow(cookbook) {
+    return SETTING_TARGETS.taxRate.some(({ model, field }) => typeof rowValue(findRow(cookbook.policies, model, field)) === 'number');
+}
+/** What a model's field starts as before any app-scope row (catalog + recipe hints). */
+function seedDefault(cookbook, modelId, field) {
+    const model = getModelByQualifiedName(modelId)?.model;
+    if (!model)
+        return undefined;
+    const hints = cookbook.recipes
+        .map((id) => recipesById.get(id)?.options?.[modelId])
+        .find(Boolean);
+    const entry = resolveFields(model, hints, []).find((r) => r.field.name === field);
+    return entry?.hasDefault ? entry.default : undefined;
+}
+const isUnset = (v) => v === undefined || v === null || v === '';
+/**
+ * A copy of the cookbook with the settings written as policy rows. A row is
+ * written for every model a setting covers (covered or not, so a recipe
+ * added later picks it up) and only where the value
+ * differs from what the model starts as; otherwise any row for it is removed,
+ * so an unset or default setting leaves no rows. Other keys on a row
+ * (visibility, label, ...) are kept.
+ */
+export function writeSettings(cookbook, settings) {
+    let policies = cookbook.policies.map((row) => ({ ...row }));
+    for (const key of KEYS) {
+        const raw = settings[key];
+        const value = key === 'paymentTerms'
+            ? String(raw).trim()
+            : key === 'currency'
+                ? String(raw).trim().toUpperCase()
+                : raw;
+        for (const { model, field } of SETTING_TARGETS[key]) {
+            const seed = seedDefault(cookbook, model, field);
+            const wanted = !isUnset(value) &&
+                !(isUnset(seed) ? false : seed === value) &&
+                !(isUnset(seed) && key === 'taxRate' && value === 0);
+            const existing = findRow(policies, model, field);
+            if (wanted) {
+                const encoded = JSON.stringify(value);
+                if (existing)
+                    existing.defaultValue = encoded;
+                else
+                    policies.push({
+                        objectRef: model,
+                        fieldName: field,
+                        scopeType: 'app',
+                        defaultValue: encoded,
+                    });
+            }
+            else if (existing) {
+                delete existing.defaultValue;
+                if (Object.keys(existing).length <= 3) {
+                    policies = policies.filter((r) => r !== existing);
+                }
+            }
+        }
+    }
+    return { ...cookbook, policies };
+}
+/** Starting values for a cookbook's editor: what it sets, else the defaults. */
+export function settingsOfCookbook(settings) {
+    return { ...DEFAULT_SETTINGS, ...settings };
+}

package/dist/settings/currencies.d.ts

@@ -0,0 +1,2 @@
+/** Circulating ISO 4217 currency codes (no funds, metals or retired codes). */
+export declare const CURRENCY_CODES: ReadonlySet<string>;

package/dist/settings/currencies.js

@@ -0,0 +1,8 @@
+/** Circulating ISO 4217 currency codes (no funds, metals or retired codes). */
+export const CURRENCY_CODES = new Set(('AED AFN ALL AMD ANG AOA ARS AUD AWG AZN BAM BBD BDT BGN BHD BIF BMD BND BOB BRL BSD BTN BWP BYN BZD ' +
+    'CAD CDF CHF CLP CNY COP CRC CUP CVE CZK DJF DKK DOP DZD EGP ERN ETB EUR FJD FKP GBP GEL GHS GIP GMD ' +
+    'GNF GTQ GYD HKD HNL HTG HUF IDR ILS INR IQD IRR ISK JMD JOD JPY KES KGS KHR KMF KPW KRW KWD KYD KZT ' +
+    'LAK LBP LKR LRD LSL LYD MAD MDL MGA MKD MMK MNT MOP MRU MUR MVR MWK MXN MYR MZN NAD NGN NIO NOK NPR ' +
+    'NZD OMR PAB PEN PGK PHP PKR PLN PYG QAR RON RSD RUB RWF SAR SBD SCR SDG SEK SGD SHP SLE SOS SRD SSP ' +
+    'STN SYP SZL THB TJS TMT TND TOP TRY TTD TWD TZS UAH UGX USD UYU UZS VES VND VUV WST XAF XCD XOF XPF ' +
+    'YER ZAR ZMW ZWG').split(' '));

package/dist/theme/runtime.d.ts

@@ -0,0 +1,14 @@
+import { type ColorSchemeSetting, type ThemeSetting } from './theme.ts';
+/** What `ThemeProvider` is told: a preset id (built-in or registered) and a scheme. */
+export interface ResolvedTheme {
+    preset: string;
+    colorScheme: ColorSchemeSetting;
+}
+/** The brand theme's id: unique per colour and font, since a registered id never changes. */
+export declare function brandThemeId(primary: string, fontFamily?: string): string;
+/**
+ * The preset id and scheme a theme means, registering its brand theme through
+ * `createThemeFromColor` first. Registered ids are never reused for another
+ * colour, because `ThemeProvider` looks a theme up once per preset id.
+ */
+export declare function resolveTheme(theme: ThemeSetting | undefined): ResolvedTheme;

package/dist/theme/runtime.js

@@ -0,0 +1,27 @@
+import { createThemeFromColor, registerTheme, } from '@happyvertical/smrt-ui/themes';
+import { DEFAULT_COLOR_SCHEME, DEFAULT_PRESET, THEME_FONTS, } from "./theme.js";
+const registered = new Set();
+/** The brand theme's id: unique per colour and font, since a registered id never changes. */
+export function brandThemeId(primary, fontFamily) {
+    return `planner-brand-${primary.slice(1)}${fontFamily ? `-${fontFamily.toLowerCase().replace(/[^a-z0-9]/g, '')}` : ''}`;
+}
+/**
+ * The preset id and scheme a theme means, registering its brand theme through
+ * `createThemeFromColor` first. Registered ids are never reused for another
+ * colour, because `ThemeProvider` looks a theme up once per preset id.
+ */
+export function resolveTheme(theme) {
+    const colorScheme = theme?.colorScheme ?? DEFAULT_COLOR_SCHEME;
+    const custom = theme?.custom;
+    if (!custom)
+        return { preset: theme?.preset ?? DEFAULT_PRESET, colorScheme };
+    const id = brandThemeId(custom.primary, custom.fontFamily);
+    if (!registered.has(id)) {
+        const font = custom.fontFamily ? THEME_FONTS[custom.fontFamily] : undefined;
+        registerTheme(createThemeFromColor(custom.primary, id, 'Brand colour', {
+            ...(font ? { fontFamily: font } : {}),
+        }));
+        registered.add(id);
+    }
+    return { preset: id, colorScheme };
+}

package/dist/theme/theme.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The app's look, kept in the app document (smrt#3604): a built-in smrt-ui
+ * preset, a light/dark/system choice and optionally a brand colour that
+ * `createThemeFromColor` expands into a full theme. Tokens only, never CSS.
+ * Absent means the default (the `smrt` preset, following the system scheme).
+ */
+export type ColorSchemeSetting = 'light' | 'dark' | 'system';
+export interface CustomTheme {
+    /** `#rrggbb`, lowercase. */
+    primary: string;
+    /** A key of `THEME_FONTS`. */
+    fontFamily?: string;
+}
+export interface ThemeSetting {
+    /** A built-in smrt-ui preset; the default when absent. */
+    preset?: string;
+    colorScheme?: ColorSchemeSetting;
+    /** A brand colour theme; wins over `preset` while present. */
+    custom?: CustomTheme;
+}
+/** smrt-ui's built-in presets (its Node-safe `themes/presets` subpath). */
+export declare const THEME_PRESETS: readonly string[];
+export declare const DEFAULT_PRESET = "smrt";
+export declare const DEFAULT_COLOR_SCHEME: ColorSchemeSetting;
+export declare const COLOR_SCHEMES: readonly ColorSchemeSetting[];
+/** The fonts a theme may name, each with its CSS stack. A fixed list, never free text. */
+export declare const THEME_FONTS: Readonly<Record<string, string>>;
+/** `#rgb` or `#rrggbb` (with or without `#`) as lowercase `#rrggbb`; else null. */
+export declare function normalizeHex(value: unknown): string | null;
+export type ThemeParse = {
+    ok: true;
+    theme: ThemeSetting | undefined;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Check a `theme` value from a file. Strict: a bad preset, colour, font or
+ * scheme is an error, not silently dropped. An empty object reads as absent.
+ */
+export declare function parseTheme(value: unknown): ThemeParse;
+/** Same theme? Absent and `{}` are the same (the default). */
+export declare function themeEquals(a: ThemeSetting | undefined, b: ThemeSetting | undefined): boolean;
+/** Drop defaults so an unchanged theme stays absent from the document. */
+export declare function compactTheme(theme: ThemeSetting | undefined): ThemeSetting | undefined;
+/** A short phrase for the chat and the Settings tab, e.g. "Glass, dark". */
+export declare function describeTheme(theme: ThemeSetting | undefined): string;

package/dist/theme/theme.js

@@ -0,0 +1,122 @@
+import { availablePresets } from '@happyvertical/smrt-ui/themes/presets';
+/** smrt-ui's built-in presets (its Node-safe `themes/presets` subpath). */
+export const THEME_PRESETS = availablePresets;
+export const DEFAULT_PRESET = 'smrt';
+export const DEFAULT_COLOR_SCHEME = 'system';
+export const COLOR_SCHEMES = [
+    'light',
+    'dark',
+    'system',
+];
+/** The fonts a theme may name, each with its CSS stack. A fixed list, never free text. */
+export const THEME_FONTS = {
+    'system-ui': 'system-ui, -apple-system, "Segoe UI", sans-serif',
+    Inter: 'Inter, system-ui, sans-serif',
+    Georgia: 'Georgia, "Times New Roman", serif',
+    'ui-rounded': 'ui-rounded, "SF Pro Rounded", system-ui, sans-serif',
+    'ui-monospace': 'ui-monospace, "SF Mono", Menlo, monospace',
+};
+const HEX = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+/** `#rgb` or `#rrggbb` (with or without `#`) as lowercase `#rrggbb`; else null. */
+export function normalizeHex(value) {
+    if (typeof value !== 'string')
+        return null;
+    const match = HEX.exec(value.trim());
+    if (!match)
+        return null;
+    let digits = match[1].toLowerCase();
+    if (digits.length === 3) {
+        digits = [...digits].map((d) => d + d).join('');
+    }
+    return `#${digits}`;
+}
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * Check a `theme` value from a file. Strict: a bad preset, colour, font or
+ * scheme is an error, not silently dropped. An empty object reads as absent.
+ */
+export function parseTheme(value) {
+    if (value === undefined)
+        return { ok: true, theme: undefined };
+    if (!isObject(value)) {
+        return { ok: false, error: 'The cookbook "theme" must be an object.' };
+    }
+    const theme = {};
+    if (value.preset !== undefined) {
+        if (typeof value.preset !== 'string' ||
+            !THEME_PRESETS.includes(value.preset)) {
+            return {
+                ok: false,
+                error: `The theme preset must be one of ${THEME_PRESETS.join(', ')}.`,
+            };
+        }
+        theme.preset = value.preset;
+    }
+    if (value.colorScheme !== undefined) {
+        if (!COLOR_SCHEMES.includes(value.colorScheme)) {
+            return {
+                ok: false,
+                error: 'The theme colorScheme must be light, dark or system.',
+            };
+        }
+        theme.colorScheme = value.colorScheme;
+    }
+    if (value.custom !== undefined) {
+        if (!isObject(value.custom)) {
+            return { ok: false, error: 'The theme "custom" must be an object.' };
+        }
+        const primary = normalizeHex(value.custom.primary);
+        if (!primary) {
+            return {
+                ok: false,
+                error: 'The theme custom primary must be a hex colour like #c2410c.',
+            };
+        }
+        const custom = { primary };
+        if (value.custom.fontFamily !== undefined) {
+            const font = value.custom.fontFamily;
+            if (typeof font !== 'string' || !Object.hasOwn(THEME_FONTS, font)) {
+                return {
+                    ok: false,
+                    error: `The theme font must be one of ${Object.keys(THEME_FONTS).join(', ')}.`,
+                };
+            }
+            custom.fontFamily = font;
+        }
+        theme.custom = custom;
+    }
+    return { ok: true, theme: Object.keys(theme).length ? theme : undefined };
+}
+/** Same theme? Absent and `{}` are the same (the default). */
+export function themeEquals(a, b) {
+    return JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+}
+function canonical(theme) {
+    return {
+        preset: theme?.preset ?? DEFAULT_PRESET,
+        colorScheme: theme?.colorScheme ?? DEFAULT_COLOR_SCHEME,
+        primary: theme?.custom?.primary ?? null,
+        font: theme?.custom ? (theme.custom.fontFamily ?? null) : null,
+    };
+}
+/** Drop defaults so an unchanged theme stays absent from the document. */
+export function compactTheme(theme) {
+    if (!theme)
+        return undefined;
+    const out = {};
+    if (theme.preset)
+        out.preset = theme.preset;
+    if (theme.colorScheme)
+        out.colorScheme = theme.colorScheme;
+    if (theme.custom)
+        out.custom = { ...theme.custom };
+    return Object.keys(out).length ? out : undefined;
+}
+/** A short phrase for the chat and the Settings tab, e.g. "Glass, dark". */
+export function describeTheme(theme) {
+    const scheme = theme?.colorScheme ?? DEFAULT_COLOR_SCHEME;
+    const base = theme?.custom
+        ? `brand colour ${theme.custom.primary}`
+        : (theme?.preset ?? DEFAULT_PRESET);
+    return scheme === 'system' ? base : `${base}, ${scheme}`;
+}

package/dist/upstream/CustomerSelect.svelte

@@ -0,0 +1,60 @@
+<!--
+  STAND-IN for `CustomerSelect` of `@happyvertical/smrt-commerce/svelte`
+  (happyvertical/smrt#3602). Presentation-only: data comes from the caller's
+  `search(query)` and `resolve(id)`, which return the commerce party DTO
+  (`CustomerDisplayData`, whose `profile.name` is the label). Shows the
+  profile name plus status and type, with an optional "New customer" action.
+  Registered in `selects.ts` as the selector for
+  `@happyvertical/smrt-commerce:Customer`. When #3602 ships, import the
+  published component and delete this file.
+-->
+<script lang="ts">
+import { RelationInput } from '@happyvertical/smrt-svelte/forms';
+import { customerOption } from './partySelect.js';
+import type { CustomerDisplayData } from './partyTypes.js';
+
+interface CustomerSelectProps {
+  value?: string;
+  name: string;
+  label?: string;
+  required?: boolean;
+  disabled?: boolean;
+  error?: string;
+  search: (query: string) => Promise<CustomerDisplayData[]>;
+  resolve: (id: string) => Promise<CustomerDisplayData | null>;
+  onCreate?: () => void;
+  createLabel?: string;
+  onchange?: (id: string) => void;
+}
+
+let {
+  value = $bindable(''),
+  name,
+  label = 'Customer',
+  required = false,
+  disabled = false,
+  error,
+  search,
+  resolve,
+  onCreate,
+  createLabel = 'New customer',
+  onchange,
+}: CustomerSelectProps = $props();
+</script>
+
+<RelationInput
+  bind:value
+  {name}
+  {label}
+  {required}
+  {disabled}
+  {error}
+  {onCreate}
+  {createLabel}
+  {onchange}
+  search={async (query) => (await search(query)).map(customerOption)}
+  resolve={async (id) => {
+    const found = await resolve(id);
+    return found ? { id: found.id, label: found.profile.name } : null;
+  }}
+/>

package/dist/upstream/CustomerSelect.svelte.d.ts

@@ -0,0 +1,17 @@
+import type { CustomerDisplayData } from './partyTypes.ts';
+interface CustomerSelectProps {
+    value?: string;
+    name: string;
+    label?: string;
+    required?: boolean;
+    disabled?: boolean;
+    error?: string;
+    search: (query: string) => Promise<CustomerDisplayData[]>;
+    resolve: (id: string) => Promise<CustomerDisplayData | null>;
+    onCreate?: () => void;
+    createLabel?: string;
+    onchange?: (id: string) => void;
+}
+declare const CustomerSelect: import("svelte").Component<CustomerSelectProps, {}, "value">;
+type CustomerSelect = ReturnType<typeof CustomerSelect>;
+export default CustomerSelect;