@happyvertical/smrt-planner 0.0.2 → 0.1.1

package/dist/settings/app-settings.js

@@ -1,13 +1,22 @@
 import { getModelByQualifiedName } from "../catalog/index.js";
 import { recipesById } from "../recipes/index.js";
 import { resolveFields } from "../recipes/policy.js";
+export const TAX_ROUNDINGS = ['line', 'document'];
 export const DEFAULT_SETTINGS = {
     currency: 'USD',
     taxRate: 0,
     paymentTerms: '',
+    pricesIncludeTax: false,
+    taxRounding: 'line',
 };
 const C = '@happyvertical/smrt-commerce:';
-/** Which model fields each setting is the default of (the single source). */
+/**
+ * Which model fields each setting is the default of (the single source). The
+ * money settings name the same fields as smrt-core's
+ * `COMMERCE_SETTING_TARGETS`: `pricesIncludeTax` is Invoice and Contract
+ * `lineAmountType` (`'inclusive'` / `'exclusive'`), `taxRounding` their
+ * `taxRoundingScope`.
+ */
 export const SETTING_TARGETS = {
     currency: [
         'Order',
@@ -16,15 +25,31 @@ export const SETTING_TARGETS = {
         'Estimate',
         'Invoice',
         'Agreement',
+        'Lease',
     ].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' })),
+        ...[
+            'Order',
+            'WholesaleOrder',
+            'Estimate',
+            'Invoice',
+            'Agreement',
+            'Lease',
+        ].map((model) => ({ model: `${C}${model}`, field: 'terms' })),
         { model: `${C}Customer`, field: 'paymentTerms' },
     ],
+    pricesIncludeTax: ['Invoice', 'Contract'].map((model) => ({
+        model: `${C}${model}`,
+        field: 'lineAmountType',
+    })),
+    taxRounding: ['Invoice', 'Contract'].map((model) => ({
+        model: `${C}${model}`,
+        field: 'taxRoundingScope',
+    })),
 };
 /**
  * A setting's row on a model no added recipe covers yet. Kept (by the store's
@@ -63,12 +88,20 @@ export function readSettings(cookbook) {
     const currency = first('currency', 'string');
     const taxRate = first('taxRate', 'number');
     const paymentTerms = first('paymentTerms', 'string');
+    const lineAmountType = first('pricesIncludeTax', 'string');
+    const taxRounding = first('taxRounding', 'string');
     if (typeof currency === 'string')
         out.currency = currency;
     if (typeof taxRate === 'number')
         out.taxRate = taxRate;
     if (typeof paymentTerms === 'string')
         out.paymentTerms = paymentTerms;
+    if (lineAmountType === 'inclusive' || lineAmountType === 'exclusive') {
+        out.pricesIncludeTax = lineAmountType === 'inclusive';
+    }
+    if (taxRounding === 'line' || taxRounding === 'document') {
+        out.taxRounding = taxRounding;
+    }
     return out;
 }
 /** Does the cookbook state a tax rate (a row), rather than leave the default? */
@@ -103,7 +136,11 @@ export function writeSettings(cookbook, settings) {
             ? String(raw).trim()
             : key === 'currency'
                 ? String(raw).trim().toUpperCase()
-                : raw;
+                : key === 'pricesIncludeTax'
+                    ? raw
+                        ? 'inclusive'
+                        : 'exclusive'
+                    : raw;
         for (const { model, field } of SETTING_TARGETS[key]) {
             const seed = seedDefault(cookbook, model, field);
             const wanted = !isUnset(value) &&

package/dist/smrt-version.d.ts

@@ -0,0 +1,2 @@
+/** The released smrt line the planner is built against (the `smrt` CLI version its commands name). */
+export declare const SMRT_VERSION = "0.57.0";

package/dist/smrt-version.js

@@ -0,0 +1,4 @@
+// Generated by scripts/write-smrt-version.ts from the installed
+// @happyvertical/smrt-core; do not edit. `pnpm version:smrt` refreshes it.
+/** The released smrt line the planner is built against (the `smrt` CLI version its commands name). */
+export const SMRT_VERSION = '0.57.0';

package/dist/styles/planner-forms.css

@@ -0,0 +1,53 @@
+/* Planner app-level treatment for generated record forms. */
+.planner-form {
+  box-sizing: border-box;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: var(--smrt-spacing-4);
+  inline-size: 100%;
+  max-inline-size: 58rem;
+  min-inline-size: 0;
+  margin-block: var(--smrt-spacing-2) var(--smrt-spacing-6);
+}
+
+.planner-form > h3 {
+  grid-column: 1 / -1;
+  padding-block-end: var(--smrt-spacing-3);
+  border-block-end: var(--smrt-hairline);
+  font: var(--smrt-typography-title-large-font);
+  letter-spacing: var(--smrt-typography-title-large-tracking);
+}
+
+.planner-form > .field,
+.planner-form > .derived {
+  min-inline-size: 0;
+}
+
+.planner-form > .field[data-renderer='textarea'],
+.planner-form > .field[data-renderer='address'],
+.planner-form > .field[data-renderer='json'],
+.planner-form > .grid,
+.planner-form > .totals,
+.planner-form > .error,
+.planner-form > .actions {
+  grid-column: 1 / -1;
+}
+
+.planner-form > .actions {
+  flex-wrap: wrap;
+  align-items: center;
+  padding-block-start: var(--smrt-spacing-4);
+  border-block-start: var(--smrt-hairline);
+}
+
+.planner-form :is(input, select, textarea):focus-visible {
+  outline: var(--smrt-focus-ring-width) solid var(--smrt-focus-ring-color);
+  outline-offset: var(--smrt-focus-ring-offset);
+}
+
+@media (min-width: 46rem) {
+  .planner-form {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    column-gap: var(--smrt-spacing-6);
+  }
+}

package/dist/styles/planner-lists.css

@@ -0,0 +1,43 @@
+/* Planner app-level treatment for generated record tables. */
+.planner-list {
+  width: 100%;
+  border-collapse: separate;
+  border-spacing: 0;
+  font-size: 0.875rem;
+}
+
+.planner-list th {
+  background: var(--smrt-surface-sunken);
+  color: var(--smrt-color-on-surface-variant);
+  font-weight: var(--smrt-typography-weight-semibold);
+}
+
+.planner-list tbody tr:hover {
+  background: color-mix(in srgb, currentColor calc(var(--smrt-state-hover) * 100%), transparent);
+}
+
+.planner-list .sort-button {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--smrt-spacing-2);
+  padding: var(--smrt-spacing-1) 0;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  font-weight: inherit;
+  white-space: nowrap;
+  cursor: pointer;
+}
+
+.planner-list .sort-button:focus-visible {
+  outline: var(--smrt-focus-ring-width) solid var(--smrt-focus-ring-color);
+  outline-offset: var(--smrt-focus-ring-offset);
+}
+
+.planner-list .sort-icon {
+  color: var(--smrt-color-primary);
+  font-size: 1rem;
+  line-height: 1;
+}

package/dist/theme/css-highlight.d.ts

@@ -0,0 +1,6 @@
+export interface CssToken {
+    text: string;
+    kind: 'plain' | 'comment' | 'selector' | 'property' | 'value' | 'punctuation';
+}
+/** Small CSS lexer for the Planner editor. Text is rendered by Svelte, never as HTML. */
+export declare function highlightCss(source: string): CssToken[];

package/dist/theme/css-highlight.js

@@ -0,0 +1,34 @@
+/** Small CSS lexer for the Planner editor. Text is rendered by Svelte, never as HTML. */
+export function highlightCss(source) {
+    const result = [];
+    const pattern = /(\/\*[\s\S]*?\*\/|\/\*[\s\S]*$|"(?:\\.|[^"\\])*"?|'(?:\\.|[^'\\])*'?|[{}:;]|[^{}:;'"/]+|\/)/g;
+    let inBlock = false;
+    let afterColon = false;
+    for (const match of source.matchAll(pattern)) {
+        const text = match[0];
+        let kind = 'plain';
+        if (text.startsWith('/*'))
+            kind = 'comment';
+        else if (/^[{}:;]$/.test(text)) {
+            kind = 'punctuation';
+            if (text === '{') {
+                inBlock = true;
+                afterColon = false;
+            }
+            if (text === '}') {
+                inBlock = false;
+                afterColon = false;
+            }
+            if (text === ':')
+                afterColon = true;
+            if (text === ';')
+                afterColon = false;
+        }
+        else if (inBlock)
+            kind = afterColon ? 'value' : 'property';
+        else
+            kind = 'selector';
+        result.push({ text, kind });
+    }
+    return result;
+}

package/dist/theme/custom-css.svelte.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Custom CSS from a cookbook is untrusted: a cookbook can be imported, shared,
+ * or written by a host agent. Before it reaches the page it is parsed by the
+ * browser, stripped of external loads, and re-serialized inside an `@scope`
+ * rooted at this Planner's own app shell, so it can neither style the host
+ * page nor fetch anything. It applies only once the visitor approves that
+ * exact text.
+ */
+/** The shell class authors write; a leading one is read as this Planner's shell. */
+export declare const SHELL_CLASS = "smrt-admin-shell";
+/** Marks the one shell element a Planner's custom CSS is scoped to. */
+export declare const SCOPE_ATTRIBUTE = "data-smrt-planner-scope";
+/** `?styles=off` turns custom CSS off, whatever it hides. */
+export declare const STYLES_OFF_PARAM = "styles";
+/**
+ * The browser's own reading of `css`, without external loads, scoped to the
+ * element `scope` selects. Serialized rules are balanced, so nothing can close
+ * the scope. Empty outside a browser or when nothing survives.
+ */
+export declare function containCustomCss(css: string, scope: string): string;
+/**
+ * The selector for the app shell around `element`, marking that one shell so
+ * custom CSS cannot reach another shell on the page (a host's own AppShell or
+ * a second Planner). Null when `element` is not inside a shell.
+ */
+export declare function shellScopeOf(element: Element | null): string | null;
+/** SHA-256 of the UTF-8 text, hex. Synchronous so approval checks stay reactive. */
+export declare function sha256(text: string): string;
+/** Remember the visitor's approval of exactly this CSS. */
+export declare function approveCustomCss(css: string): void;
+/** Approved on this page or remembered on this device; reactive to approvals. */
+export declare function customCssApproved(css: string): boolean;
+/** `?styles=off` in the address bar. */
+export declare function customCssDisabled(search: string): boolean;

package/dist/theme/custom-css.svelte.js

@@ -0,0 +1,246 @@
+/**
+ * Custom CSS from a cookbook is untrusted: a cookbook can be imported, shared,
+ * or written by a host agent. Before it reaches the page it is parsed by the
+ * browser, stripped of external loads, and re-serialized inside an `@scope`
+ * rooted at this Planner's own app shell, so it can neither style the host
+ * page nor fetch anything. It applies only once the visitor approves that
+ * exact text.
+ */
+/** The shell class authors write; a leading one is read as this Planner's shell. */
+export const SHELL_CLASS = 'smrt-admin-shell';
+/** Marks the one shell element a Planner's custom CSS is scoped to. */
+export const SCOPE_ATTRIBUTE = 'data-smrt-planner-scope';
+/** `?styles=off` turns custom CSS off, whatever it hides. */
+export const STYLES_OFF_PARAM = 'styles';
+const APPROVED_KEY = 'smrt-planner-approved-css-v2';
+const LEGACY_APPROVED_KEY = 'smrt-planner-approved-css';
+const MAX_APPROVED = 20;
+/** Value functions that load something: allowed only as literal `data:` URLs. */
+const LOADS = /\b(?:url|image-set|image|cross-fade|element|src)\s*\(/gi;
+/**
+ * Whether a rule's whole declaration text is safe. The text is checked as
+ * written out, shorthands and `var()` fallbacks included, because the browser
+ * keeps a `var()` value (and a custom property) as raw author text: any escape
+ * is refused, and every load must be a literal `url("data:...")`.
+ */
+function safeDeclarations(text) {
+    if (text.includes('\\'))
+        return false;
+    for (const match of text.matchAll(LOADS)) {
+        if (!/^url/i.test(match[0]))
+            return false;
+        const rest = text.slice((match.index ?? 0) + match[0].length).trimStart();
+        if (!/^(["']?)data:/i.test(rest))
+            return false;
+    }
+    return true;
+}
+/** Split a selector list on its top-level commas. */
+function selectorList(text) {
+    const out = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === '(' || c === '[')
+            depth++;
+        else if (c === ')' || c === ']')
+            depth--;
+        else if (c === ',' && depth === 0) {
+            out.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    out.push(text.slice(start).trim());
+    return out;
+}
+const LEADING_SHELL = new RegExp(`^\\.${SHELL_CLASS}(?![\\w-])`);
+/**
+ * Inside `@scope`, a selector without `:scope` is read as a descendant of the
+ * root, so `.smrt-admin-shell a` would never match. A leading shell selector
+ * becomes `:scope`; the scope limit still keeps every match inside the shell.
+ */
+function shellToScope(rule) {
+    const next = selectorList(rule.selectorText)
+        .map((selector) => selector.replace(LEADING_SHELL, ':scope'))
+        .join(', ');
+    if (next !== rule.selectorText)
+        rule.selectorText = next;
+}
+/** Rule types that stay inside the scope; every other at-rule is global. */
+const KEPT = [
+    'CSSStyleRule',
+    'CSSMediaRule',
+    'CSSSupportsRule',
+    'CSSContainerRule',
+    'CSSNestedDeclarations',
+];
+const kept = (rule) => KEPT.some((name) => name in globalThis &&
+    rule instanceof
+        globalThis[name]);
+/**
+ * Keep only scoped style rules, at every depth: `@import`, `@font-face`,
+ * `@keyframes`, `@property`, `@layer` and the like register global names that
+ * `@scope` does not confine. A rule whose declarations could load anything is
+ * dropped whole.
+ */
+function strip(list, remove, nestedInStyle = false) {
+    for (let i = list.length - 1; i >= 0; i--) {
+        const rule = list[i];
+        const style = rule.style;
+        if (!kept(rule) || (style && !safeDeclarations(style.cssText))) {
+            remove(i);
+            continue;
+        }
+        const isStyle = 'selectorText' in rule;
+        if (isStyle && !nestedInStyle)
+            shellToScope(rule);
+        const group = rule;
+        if (group.cssRules && group.deleteRule) {
+            const owner = group;
+            strip(owner.cssRules, (at) => owner.deleteRule(at), nestedInStyle || isStyle);
+        }
+    }
+}
+/**
+ * The browser's own reading of `css`, without external loads, scoped to the
+ * element `scope` selects. Serialized rules are balanced, so nothing can close
+ * the scope. Empty outside a browser or when nothing survives.
+ */
+export function containCustomCss(css, scope) {
+    if (!css.trim() || typeof CSSStyleSheet === 'undefined')
+        return '';
+    const sheet = new CSSStyleSheet();
+    try {
+        sheet.replaceSync(css);
+    }
+    catch {
+        return '';
+    }
+    strip(sheet.cssRules, (at) => sheet.deleteRule(at));
+    const rules = Array.from(sheet.cssRules, (rule) => rule.cssText);
+    return rules.length ? `@scope (${scope}) {\n${rules.join('\n')}\n}` : '';
+}
+let nextScope = 0;
+/**
+ * The selector for the app shell around `element`, marking that one shell so
+ * custom CSS cannot reach another shell on the page (a host's own AppShell or
+ * a second Planner). Null when `element` is not inside a shell.
+ */
+export function shellScopeOf(element) {
+    const shell = element?.closest(`.${SHELL_CLASS}`);
+    if (!shell)
+        return null;
+    let id = shell.getAttribute(SCOPE_ATTRIBUTE);
+    if (!id) {
+        id = `p${++nextScope}`;
+        shell.setAttribute(SCOPE_ATTRIBUTE, id);
+    }
+    return `[${SCOPE_ATTRIBUTE}="${id}"]`;
+}
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/** SHA-256 of the UTF-8 text, hex. Synchronous so approval checks stay reactive. */
+export function sha256(text) {
+    const data = new TextEncoder().encode(text);
+    const bits = data.length * 8;
+    const padded = new Uint8Array(((data.length + 9 + 63) >> 6) << 6);
+    padded.set(data);
+    padded[data.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(bits / 2 ** 32));
+    view.setUint32(padded.length - 4, bits >>> 0);
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+        0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(offset + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, k] = h;
+        for (let i = 0; i < 64; i++) {
+            const t1 = (k +
+                (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) +
+                ((e & f) ^ (~e & g)) +
+                K[i] +
+                w[i]) >>>
+                0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) +
+                ((a & b) ^ (a & c) ^ (b & c))) >>>
+                0;
+            k = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] += a;
+        h[1] += b;
+        h[2] += c;
+        h[3] += d;
+        h[4] += e;
+        h[5] += f;
+        h[6] += g;
+        h[7] += k;
+    }
+    return Array.from(h, (x) => x.toString(16).padStart(8, '0')).join('');
+}
+function readApproved() {
+    try {
+        localStorage.removeItem(LEGACY_APPROVED_KEY);
+        const value = JSON.parse(localStorage.getItem(APPROVED_KEY) ?? '[]');
+        return Array.isArray(value)
+            ? value.filter((v) => typeof v === 'string' && /^[0-9a-f]{64}$/.test(v))
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+const approvedThisPage = new Set();
+// Bumped on each approval so readers re-run.
+const approvals = $state({ version: 0 });
+/** Remember the visitor's approval of exactly this CSS. */
+export function approveCustomCss(css) {
+    const id = sha256(css);
+    approvedThisPage.add(id);
+    const next = [id, ...readApproved().filter((v) => v !== id)].slice(0, MAX_APPROVED);
+    try {
+        localStorage.setItem(APPROVED_KEY, JSON.stringify(next));
+    }
+    catch {
+        // Without storage the approval lasts for this page only.
+    }
+    approvals.version++;
+}
+/** Approved on this page or remembered on this device; reactive to approvals. */
+export function customCssApproved(css) {
+    void approvals.version;
+    const id = sha256(css);
+    return approvedThisPage.has(id) || readApproved().includes(id);
+}
+/** `?styles=off` in the address bar. */
+export function customCssDisabled(search) {
+    return new URLSearchParams(search).get(STYLES_OFF_PARAM) === 'off';
+}

package/dist/theme/runtime.js

@@ -1,4 +1,4 @@
-import { createThemeFromColor, registerTheme, } from '@happyvertical/smrt-ui/themes';
+import { createThemeFromColor, getTheme, 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. */
@@ -13,11 +13,31 @@ export function brandThemeId(primary, fontFamily) {
 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);
+    const fontFamily = theme?.fontFamily ?? custom?.fontFamily;
+    const font = fontFamily ? THEME_FONTS[fontFamily] : undefined;
+    if (!custom) {
+        const basePreset = theme?.preset ?? DEFAULT_PRESET;
+        if (!font)
+            return { preset: basePreset, colorScheme };
+        const id = `planner-preset-${basePreset}-${fontFamily?.toLowerCase().replace(/[^a-z0-9]/g, '')}`;
+        if (!registered.has(id)) {
+            const base = getTheme(basePreset);
+            const typography = Object.fromEntries(Object.entries(base.typography).map(([key, token]) => [
+                key,
+                { ...token, fontFamily: 'var(--smrt-font-family)' },
+            ]));
+            registerTheme({
+                ...base,
+                id: id,
+                fontFamily: font,
+                typography,
+            });
+            registered.add(id);
+        }
+        return { preset: id, colorScheme };
+    }
+    const id = brandThemeId(custom.primary, fontFamily);
     if (!registered.has(id)) {
-        const font = custom.fontFamily ? THEME_FONTS[custom.fontFamily] : undefined;
         registerTheme(createThemeFromColor(custom.primary, id, 'Brand colour', {
             ...(font ? { fontFamily: font } : {}),
         }));

package/dist/theme/theme.d.ts

@@ -1,8 +1,11 @@
 /**
  * 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).
+ * `createThemeFromColor` expands into a full theme (it replaces the preset;
+ * smrt-ui's `primaryColor`, which only tints a preset, is never used), plus
+ * corner radius, density and contrast. Custom CSS is saved
+ * with the cookbook and applied live by the Planner.
+ * Absent means the default (the `glass` preset, following the system scheme).
  */
 export type ColorSchemeSetting = 'light' | 'dark' | 'system';
 export interface CustomTheme {
@@ -11,18 +14,38 @@ export interface CustomTheme {
     /** A key of `THEME_FONTS`. */
     fontFamily?: string;
 }
+/** Corner radius scale (`ThemeProvider` `borderRadius`); `md` is the preset's own. */
+export type BorderRadiusSetting = 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+/** Control size: comfortable, or larger touch targets. */
+export type DensitySetting = 'comfortable' | 'touch';
+/** `auto` follows the device's contrast preference. */
+export type ContrastSetting = 'auto' | 'standard' | 'more';
 export interface ThemeSetting {
     /** A built-in smrt-ui preset; the default when absent. */
     preset?: string;
     colorScheme?: ColorSchemeSetting;
+    /** Corner radius; absent keeps the preset's own. */
+    borderRadius?: BorderRadiusSetting;
+    /** Control density; absent is comfortable. */
+    density?: DensitySetting;
+    /** Contrast; absent follows the device. */
+    contrast?: ContrastSetting;
+    /** A font override that preserves the selected preset's palette. */
+    fontFamily?: string;
     /** A brand colour theme; wins over `preset` while present. */
     custom?: CustomTheme;
+    /** User-authored CSS carried with the cookbook and applied at runtime. */
+    customCss?: string;
 }
 /** 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_PRESET = "glass";
 export declare const DEFAULT_COLOR_SCHEME: ColorSchemeSetting;
 export declare const COLOR_SCHEMES: readonly ColorSchemeSetting[];
+/** The cookbook's `theme.borderRadius` values (smrt-core's cookbook schema). */
+export declare const BORDER_RADII: readonly BorderRadiusSetting[];
+export declare const DENSITIES: readonly DensitySetting[];
+export declare const CONTRASTS: readonly ContrastSetting[];
 /** 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. */