@happyvertical/smrt-planner 0.0.2 → 0.1.1

package/dist/overviews/registry.js

@@ -10,21 +10,28 @@
  * never from option values: an option names a model or field, the loader looks
  * it up in the catalog and asks the `DataSource` for it.
  */
-import { createWidgetRegistry, registerCoreWidgets, registerRecipeWidgets, shortcutsFromNav, } from '@happyvertical/smrt-svelte/overview';
+import { composeShortcutsLoader, } from '@happyvertical/smrt-svelte/cookbook';
+import { createLineItemsLoader, createLineItemsWidget, createRelatedLoader, createRelatedWidget, createWidgetRegistry, lineItemColumns, parseColumnsOption, registerCoreWidgets, registerRecipeWidgets, relatedColumns, } from '@happyvertical/smrt-svelte/overview';
+import { currencyCodeField, deriveFieldRoles, } from '@happyvertical/smrt-svelte/screens';
 import { getModelByQualifiedName } from "../catalog/index.js";
-import { isMoneyField } from "../data/fakes.js";
-import { recordCount } from "../data/format.js";
-import { recordLabel } from "../data/labels.js";
+import { EPOCH, isMoneyField } from "../data/fakes.js";
+import { humanize, labelKey } from "../data/format.js";
+import { recordLabel, relationLabels } from "../data/labels.js";
+import { filteredListPath, modelPath, recordPath } from "../planner/routes.js";
 import { recipes } from "../recipes/index.js";
+import { isPlumbing } from "../recipes/plumbing.js";
 import { inScope } from "../recipes/scope.js";
+import { screenDefinition } from "../screens/definition.js";
+import { documentTotals, storedDocumentTotals, } from "../screens/totals.js";
 /** The registry every planner overview uses. */
 export const overviewRegistry = createWidgetRegistry();
-function capabilities(ctx) {
-    const { source, sections, entries, href } = ctx;
-    if (!source || !sections || !entries || !href) {
+/** What every data widget reads: the sample source and the app's links. */
+function dataCapabilities(ctx) {
+    const { source, href } = ctx;
+    if (!source || !href) {
         throw new Error('the planner widget context is missing');
     }
-    return { source, sections, entries, href };
+    return { source, href };
 }
 function modelOf(qualified) {
     const found = typeof qualified === 'string'
@@ -34,14 +41,49 @@ function modelOf(qualified) {
         throw new Error(`unknown model ${String(qualified)}`);
     return {
         model: found.model,
-        path: `/m/${found.pkg.id}/${found.model.name}/`,
+        packageId: found.pkg.id,
+        path: modelPath(found.pkg.id, found.model.name),
     };
 }
-/** The sample data has no named filters yet: naming one is an error tile. */
-function refuseFilter(filter) {
-    if (typeof filter === 'string' && filter !== '') {
+const REF_TYPES = new Set(['foreignKey', 'crossPackageRef']);
+/**
+ * The one named filter the sample data knows: `parent`, with `field` (a
+ * metric's `parentField`, when its `field` is the one measured) the
+ * reference field on the widget's model that points at the record the
+ * overview is rendered on (`ctx.record`, a detail overview). Any other
+ * name is an error tile, as is `parent` outside a record view.
+ */
+function parentFilter(options, ctx, model) {
+    const filter = options.filter;
+    if (typeof filter !== 'string' || filter === '')
+        return undefined;
+    if (filter !== 'parent')
         throw new Error(`unknown filter ${filter}`);
+    const { record } = ctx;
+    if (!record?.id)
+        throw new Error('the parent filter needs a record');
+    // A metric measuring `field` names the reference as `parentField`.
+    const named = typeof options.parentField === 'string' && options.parentField
+        ? options.parentField
+        : options.field;
+    const field = typeof named === 'string' ? named : '';
+    const target = model.fields.find((f) => f.name === field);
+    if (!target || !REF_TYPES.has(target.type)) {
+        throw new Error(`${model.name} has no reference field ${field}`);
     }
+    return { field, id: record.id };
+}
+/** The widget's rows: the model's, or those pointing at the record. */
+async function rowsOf(source, model, parent) {
+    return parent
+        ? source.listWhere(model, parent.field, parent.id)
+        : source.list(model);
+}
+/** Where the widget's list link goes: the list, narrowed to the record's rows. */
+function listHref(href, found, parent) {
+    return href(parent
+        ? filteredListPath(found.packageId, found.model.name, parent.field, parent.id)
+        : found.path);
 }
 const numeric = (value) => typeof value === 'number' && Number.isFinite(value);
 /**
@@ -49,16 +91,18 @@ const numeric = (value) => typeof value === 'number' && Number.isFinite(value);
  * over the model's sample rows. Money fields stay integer minor units.
  */
 async function loadMetric(options, ctx) {
-    const { source, href } = capabilities(ctx);
-    const { model, path } = modelOf(options.model);
-    refuseFilter(options.filter);
-    const rows = await source.list(model);
+    const { source, href } = dataCapabilities(ctx);
+    const found = modelOf(options.model);
+    const { model } = found;
+    const parent = parentFilter(options, ctx, model);
+    const rows = await rowsOf(source, model, parent);
+    const link = listHref(href, found, parent);
     const measure = typeof options.measure === 'string' ? options.measure : '';
     if (measure === 'count' || measure === '') {
         return {
             value: rows.length,
             format: 'integer',
-            href: href(path),
+            href: link,
         };
     }
     const field = model.fields.find((f) => f.name === options.field);
@@ -86,7 +130,7 @@ async function loadMetric(options, ctx) {
         value: money ? Math.round(value) : value,
         format: money ? 'money' : field.type === 'integer' ? 'integer' : 'decimal',
         ...(money ? { currency: 'USD' } : {}),
-        href: href(path),
+        href: link,
     };
 }
 function compare(a, b) {
@@ -94,79 +138,445 @@ function compare(a, b) {
         return a - b;
     return String(a ?? '').localeCompare(String(b ?? ''));
 }
-/** `records`: the first `limit` sample rows, optionally sorted by a field. */
+/** Framework timestamps the catalog and the samples do not carry. */
+const SYSTEM_DATES = new Set(['createdAt', 'updatedAt']);
+/** How a table cell renders, by the first of the field's roles a table draws. */
+const CELL_ROLES = [
+    'identifier',
+    'status',
+    'date',
+    'money',
+    'quantity',
+    'party',
+    'title',
+];
+function cellRole(roles = []) {
+    return CELL_ROLES.find((role) => roles.includes(role));
+}
+/**
+ * The columns a `records` table shows: the `columns` option's field names
+ * when given (unknown names are an error tile), else the framework's
+ * `relatedColumns` by role (identifier, status, lead date, a party, the
+ * amount: five, as `screenRelations` asks), leaving out the field pointing
+ * at the page's record.
+ */
+function recordColumns(model, roles, option, parentField) {
+    const definition = screenDefinition(model);
+    const exclude = parentField ? [parentField] : [];
+    const keys = parseColumnsOption(option);
+    if (keys.length === 0) {
+        return relatedColumns(definition, roles, { exclude, max: 5 });
+    }
+    // The framework's own column for a key where it has one (a line's unit
+    // price is not summed), else one by the field's roles.
+    const known = [
+        ...lineItemColumns(definition, roles, { exclude }),
+        ...relatedColumns(definition, roles, { exclude, max: keys.length + 8 }),
+    ];
+    return keys.map((key) => {
+        const field = model.fields.find((f) => f.name === key);
+        if (!field)
+            throw new Error(`${model.name} has no field ${key}`);
+        const framework = known.find((column) => column.key === key);
+        if (framework)
+            return framework;
+        const role = cellRole(roles[key]);
+        return {
+            key,
+            label: REF_TYPES.has(field.type)
+                ? humanize(key.replace(/Id$/, ''))
+                : humanize(key),
+            ...(role ? { role } : {}),
+        };
+    });
+}
+/** The roles a table footer sums. */
+const SUMMED = new Set([
+    'money',
+    'quantity',
+]);
+/**
+ * Footer sums over EVERY matching row, not only the page shown: the money
+ * (integer minor units) and quantity columns, never one marked
+ * `summarize: false` (a unit price).
+ */
+export function recordSummaries(columns, rows) {
+    const out = {};
+    for (const column of columns) {
+        if (!(column.summarize ?? SUMMED.has(column.role)))
+            continue;
+        out[column.key] = rows.reduce((total, row) => {
+            const value = row[column.key];
+            return numeric(value) ? total + value : total;
+        }, 0);
+    }
+    return out;
+}
+/** The one currency of the rows' currency field, else USD. */
+function currencyOf(model, rows) {
+    const field = currencyCodeField(screenDefinition(model));
+    const codes = new Set(rows
+        .map((row) => (field ? row[field] : undefined))
+        .filter((v) => typeof v === 'string' && v !== ''));
+    return codes.size === 1 ? ([...codes][0] ?? 'USD') : 'USD';
+}
+/**
+ * `records`: the first `limit` sample rows, optionally sorted by a field;
+ * each row links to its record page and carries `cells` for the table's
+ * columns (raw: money in integer minor units, dates as ISO strings, a
+ * reference as its record's label). `summaries` sum the money and quantity
+ * columns over every matching row and `total` counts them, so a footer
+ * under a page of five orders still totals all of them. A sort by a
+ * framework timestamp the samples do not carry (`createdAt`, the record
+ * view's default) falls back to the model's lead date, so "newest" still
+ * means newest.
+ */
 async function loadRecords(options, ctx) {
-    const { source, href } = capabilities(ctx);
-    const { model, path } = modelOf(options.model);
-    refuseFilter(options.filter);
-    let rows = await source.list(model);
+    const { source, href } = dataCapabilities(ctx);
+    const found = modelOf(options.model);
+    const { model } = found;
+    const parent = parentFilter(options, ctx, model);
+    let rows = await rowsOf(source, model, parent);
     if (typeof options.sort === 'string' && options.sort) {
-        const sort = options.sort;
-        if (!model.fields.some((f) => f.name === sort)) {
-            throw new Error(`${model.name} has no field ${sort}`);
+        const named = model.fields.find((f) => f.name === options.sort);
+        if (!named && !SYSTEM_DATES.has(options.sort)) {
+            throw new Error(`${model.name} has no field ${options.sort}`);
+        }
+        const carried = rows.some((row) => row[options.sort] !== undefined);
+        const sort = carried ? options.sort : leadDateField(model)?.name;
+        if (sort) {
+            const sign = options.direction === 'asc' ? 1 : -1;
+            rows = [...rows].sort((a, b) => sign * compare(a[sort], b[sort]));
         }
-        const sign = options.direction === 'asc' ? 1 : -1;
-        rows = [...rows].sort((a, b) => sign * compare(a[sort], b[sort]));
     }
+    const roles = deriveFieldRoles(screenDefinition(model));
+    const columns = recordColumns(model, roles, options.columns, parent?.field);
     const limit = numeric(options.limit) ? options.limit : 5;
     const shown = rows.slice(0, limit);
+    const refFields = model.fields.filter((f) => REF_TYPES.has(f.type) && columns.some((c) => c.key === f.name));
+    const labels = await relationLabels(source, refFields, shown);
+    const cellsOf = (row) => Object.fromEntries(columns.map((column) => {
+        const value = row[column.key];
+        const ref = refFields.find((f) => f.name === column.key);
+        if (ref?.related && typeof value === 'string' && value) {
+            return [column.key, labels.get(labelKey(ref.related, value)) ?? ''];
+        }
+        return [column.key, value ?? null];
+    }));
+    const summaries = recordSummaries(columns, rows);
+    // A line item, link row or the like lives inside its parent: no page of
+    // its own to link a row or "View all" to.
+    const linked = !isPlumbing(model);
     return {
         rows: await Promise.all(shown.map(async (row) => ({
             id: String(row.id),
-            title: await recordLabel(source, model, row),
+            // On a record's page the parent is the page: leave its name out.
+            title: await recordLabel(source, model, row, 0, parent?.field),
+            ...(linked
+                ? {
+                    href: href(recordPath(found.packageId, model.name, String(row.id))),
+                }
+                : {}),
+            cells: cellsOf(row),
         }))),
-        ...(rows.length > shown.length ? { total: rows.length } : {}),
-        href: href(path),
+        total: rows.length,
+        ...(linked ? { href: listHref(href, found, parent) } : {}),
+        columns,
+        currency: currencyOf(model, rows),
+        ...(Object.keys(summaries).length ? { summaries } : {}),
     };
 }
+/** The chart's `period` option: how far back from the sample clock it looks. */
+const PERIOD_DAYS = {
+    '7d': 7,
+    '30d': 30,
+    '90d': 90,
+    '12m': 365,
+    all: null,
+};
+const DAY = 24 * 60 * 60 * 1000;
+/** The bucket a period's date axis uses; coarser as the window widens. */
+function bucketOf(period) {
+    if (period === '7d' || period === '30d')
+        return 'day';
+    if (period === '90d')
+        return 'week';
+    return 'month';
+}
+/** The start of `date`'s bucket, as a UTC timestamp. */
+function bucketStart(ms, bucket) {
+    const date = new Date(ms);
+    if (bucket === 'month') {
+        return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1);
+    }
+    const day = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+    // ISO weeks start on Monday.
+    return bucket === 'week' ? day - ((date.getUTCDay() + 6) % 7) * DAY : day;
+}
+function nextBucket(ms, bucket) {
+    if (bucket === 'month') {
+        const date = new Date(ms);
+        return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1);
+    }
+    return ms + (bucket === 'week' ? 7 : 1) * DAY;
+}
+/** A deterministic, locale-free axis label: `2025-11` or `2025-11-03`. */
+function bucketLabel(ms, bucket) {
+    const iso = new Date(ms).toISOString();
+    return bucket === 'month' ? iso.slice(0, 7) : iso.slice(0, 10);
+}
+const isDateField = (field) => field.type === 'datetime' && !field.system;
+/** The model's lead date, for the period window: `issueDate`-like names first. */
+function leadDateField(model) {
+    const dated = model.fields.filter(isDateField);
+    return (dated.find((f) => /^(issue|order|start|created)/i.test(f.name)) ?? dated[0]);
+}
+function dateOf(value) {
+    if (typeof value !== 'string' && typeof value !== 'number')
+        return undefined;
+    const ms = new Date(value).getTime();
+    return Number.isFinite(ms) ? ms : undefined;
+}
 /**
- * `shortcuts`: the section's menu entries as cards, as the shell resolves them
- * (renames, hides, moves), each with its record count. `section` names another
- * section by its id without the `section:` / `custom:` prefix; absent, the
- * overview's own section.
+ * `chart`: one measure of the model's sample rows grouped by a field. This is
+ * the IN-BROWSER STAND-IN for a runtime report: a generated app's chart
+ * loader hands these same options to the runtime report compiler and renders
+ * what it returns; the planner groups the seeded rows itself so the widget
+ * can be tried before a server exists.
+ *
+ * `groupBy` names a field: a date field is bucketed (days for `7d`/`30d`,
+ * weeks for `90d`, months for `12m`/`all`) with empty buckets kept so a line
+ * stays continuous; any other field groups by value, largest first. Absent,
+ * the model's lead date field is used. `period` is a window back from the
+ * sample clock (`EPOCH`, the fixed "now" of the seeded data) over the
+ * grouped date field, else the lead date field; a model with no date field
+ * ignores it. `measure` is `count`, or `sum` / `avg` of a numeric `field`;
+ * money stays integer minor units. The widget's `style` (bar, line, table,
+ * pie or stat) is rendered by the widget itself from these points: `stat`
+ * headlines the last point against the one before, which on a date axis is
+ * the latest bucket.
  */
-async function loadShortcuts(options, ctx) {
-    const { source, sections, entries } = capabilities(ctx);
-    const named = typeof options.section === 'string' ? options.section : '';
-    const sectionId = named
-        ? sections.find((s) => s.id === `section:${named}` || s.id === `custom:${named}`)?.id
-        : ctx.overviewId;
-    if (!sectionId)
-        throw new Error(`unknown section ${named}`);
-    const data = shortcutsFromNav(sections, sectionId);
-    const items = await Promise.all(data.items.map(async (item) => {
-        const entry = entries.get(item.id);
+async function loadChart(options, ctx) {
+    const { source, href } = dataCapabilities(ctx);
+    const found = modelOf(options.model);
+    const { model } = found;
+    const parent = parentFilter(options, ctx, model);
+    const groupName = typeof options.groupBy === 'string' ? options.groupBy : '';
+    const groupField = groupName
+        ? model.fields.find((f) => f.name === groupName)
+        : leadDateField(model);
+    if (!groupField) {
+        throw new Error(groupName
+            ? `${model.name} has no field ${groupName}`
+            : `${model.name} has no date field to chart; choose a group-by field`);
+    }
+    const measure = typeof options.measure === 'string' ? options.measure : '';
+    let valueField;
+    if (measure && measure !== 'count') {
+        if (measure !== 'sum' && measure !== 'avg') {
+            throw new Error(`unknown measure ${measure}`);
+        }
+        valueField = model.fields.find((f) => f.name === options.field);
+        if (!valueField ||
+            (valueField.type !== 'integer' && valueField.type !== 'decimal')) {
+            throw new Error(`${measure} needs a numeric field of ${model.name}`);
+        }
+    }
+    const period = typeof options.period === 'string' ? options.period : '30d';
+    if (!Object.hasOwn(PERIOD_DAYS, period)) {
+        throw new Error(`unknown period ${period}`);
+    }
+    const days = PERIOD_DAYS[period];
+    const byDate = isDateField(groupField);
+    const windowField = byDate ? groupField : leadDateField(model);
+    const since = days !== null && windowField
+        ? EPOCH - days * DAY
+        : Number.NEGATIVE_INFINITY;
+    let rows = await rowsOf(source, model, parent);
+    if (windowField && since !== Number.NEGATIVE_INFINITY) {
+        rows = rows.filter((row) => {
+            const at = dateOf(row[windowField.name]);
+            return at !== undefined && at >= since && at <= EPOCH;
+        });
+    }
+    // Group: each bucket keeps the count and the sum, so `avg` is sum / count.
+    const groups = new Map();
+    const add = (label, key, row) => {
+        const group = groups.get(label) ?? { key, sum: 0, n: 0 };
+        if (valueField) {
+            const value = row[valueField.name];
+            if (!numeric(value))
+                return;
+            group.sum += value;
+        }
+        group.n += 1;
+        groups.set(label, group);
+    };
+    const bucket = bucketOf(period);
+    if (byDate) {
+        // Every bucket of the window, in order, empty ones included.
+        const start = since !== Number.NEGATIVE_INFINITY
+            ? since
+            : Math.min(...rows.map((row) => dateOf(row[groupField.name]) ?? EPOCH), EPOCH);
+        for (let at = bucketStart(start, bucket); at <= EPOCH; at = nextBucket(at, bucket)) {
+            groups.set(bucketLabel(at, bucket), { key: at, sum: 0, n: 0 });
+        }
+        for (const row of rows) {
+            const at = dateOf(row[groupField.name]);
+            if (at === undefined)
+                continue;
+            const startOfBucket = bucketStart(at, bucket);
+            add(bucketLabel(startOfBucket, bucket), startOfBucket, row);
+        }
+    }
+    else {
+        for (const row of rows) {
+            const value = row[groupField.name];
+            const label = value === null || value === undefined || value === ''
+                ? '(none)'
+                : String(value);
+            add(label, label, row);
+        }
+    }
+    const money = valueField ? isMoneyField(valueField) : false;
+    const measureOf = (group) => {
+        if (!valueField)
+            return group.n;
+        const value = measure === 'avg' && group.n ? group.sum / group.n : group.sum;
+        return money ? Math.round(value) : value;
+    };
+    let points = [...groups.entries()].map(([label, group]) => ({
+        label,
+        value: measureOf(group),
+        key: group.key,
+    }));
+    points = byDate
+        ? points.sort((a, b) => Number(a.key) - Number(b.key))
+        : points.sort((a, b) => b.value - a.value || a.label.localeCompare(b.label));
+    return {
+        points: points.map(({ label, value }) => ({ label, value })),
+        format: !valueField
+            ? 'integer'
+            : money
+                ? 'money'
+                : valueField.type === 'integer'
+                    ? 'integer'
+                    : 'decimal',
+        ...(money ? { currency: 'USD' } : {}),
+        href: listHref(href, found, parent),
+    };
+}
+/**
+ * The shortcuts' record counts: a `CookbookShortcutsLoader` that gives each of
+ * the shell's default entries (the section's menu as resolved: renames, hides,
+ * moves) its count of sample rows, in the entry's own scope. The framework
+ * composes it with its entries (`composeShortcutsLoader`): under the mounted
+ * `Planner`'s `CookbookApp` as `loaders.shortcuts`, on the static app's
+ * section pages through {@link overviewRegistry}. An entry the index does not
+ * know (no model) keeps no count.
+ */
+export const loadShortcutCounts = async (ctx, defaults) => {
+    const { source, entryIndex } = ctx;
+    if (!source || !entryIndex) {
+        throw new Error('the planner widget context is missing');
+    }
+    return Promise.all(defaults.map(async (item) => {
+        const entry = entryIndex.get(item.id ?? '');
         if (!entry)
             return item;
         const rows = await source.list(entry.model);
-        const count = recordCount(rows.filter((row) => inScope(entry.scope, row)).length);
         return {
             ...item,
-            // The count first: a long description is clipped.
-            description: item.description
-                ? `${count} · ${item.description}`
-                : count,
+            count: rows.filter((row) => inScope(entry.scope, row)).length,
         };
     }));
-    return { items };
-}
-registerCoreWidgets(overviewRegistry, {
+};
+/**
+ * The data loaders over the sample source and the shortcuts' counts, for the
+ * mounted `Planner`'s `CookbookApp`, whose registry composes `shortcuts` with
+ * the shell's entries.
+ */
+export const plannerLoaders = {
     metric: loadMetric,
     records: loadRecords,
-    shortcuts: loadShortcuts,
+    chart: loadChart,
+    shortcuts: loadShortcutCounts,
+};
+registerCoreWidgets(overviewRegistry, {
+    ...plannerLoaders,
+    shortcuts: composeShortcutsLoader(loadShortcutCounts),
 });
+/**
+ * The record page's own widgets (smrt#3718), registered once on the shared
+ * registry so a cookbook's stored record overview validates like a
+ * section's. The framework builds them from one record view's relations;
+ * the planner hands those over in the load context (`relations`,
+ * `viewAllHref`), and every tab or line list is one call of
+ * {@link loadRecords} with the parent filter.
+ */
+function recordWidgetOptions(ctx) {
+    const { relations, viewAllHref } = ctx;
+    if (!relations)
+        throw new Error('the record page context is missing');
+    return { relations, records: loadRecords, viewAllHref };
+}
+/**
+ * The page's record, read fresh at load time, for the line-items totals
+ * block: an issued document's frozen money (`storedDocumentTotals`, shown as
+ * stored with a row per tax component), else a draft's own totals by role
+ * (`documentTotals`, read against its lines); and its currency code.
+ */
+async function recordFigures(ctx, relations) {
+    const { source } = dataCapabilities(ctx);
+    const ref = ctx.record;
+    if (!ref?.id)
+        throw new Error('line items need a record');
+    const { model } = modelOf(ref.model);
+    const record = await source.get(model, ref.id);
+    if (!record)
+        return {};
+    const items = relations.find((r) => r.kind === 'items');
+    const lineModel = items
+        ? getModelByQualifiedName(items.model)?.model
+        : undefined;
+    const lines = items && lineModel
+        ? await source.listWhere(lineModel, items.field, ref.id)
+        : [];
+    const storedTotals = storedDocumentTotals(model, record, lines);
+    const totals = storedTotals ? undefined : documentTotals(model, record);
+    const code = currencyCodeField(screenDefinition(model));
+    const currency = code ? record[code] : undefined;
+    return {
+        ...(storedTotals ? { storedTotals } : {}),
+        ...(totals ? { totals } : {}),
+        ...(typeof currency === 'string' && currency ? { currency } : {}),
+    };
+}
+overviewRegistry.register(createRelatedWidget((options, ctx) => createRelatedLoader(recordWidgetOptions(ctx))(options, ctx)));
+overviewRegistry.register(createLineItemsWidget(async (options, ctx) => {
+    const base = recordWidgetOptions(ctx);
+    const { totals, storedTotals, currency } = await recordFigures(ctx, base.relations);
+    return createLineItemsLoader({
+        ...base,
+        totals: () => totals,
+        storedTotals: () => storedTotals,
+        currency: () => currency,
+    })(options, ctx);
+}));
 /** The core widget types a section overview offers. */
 export const CORE_WIDGET_TYPES = [
     'shortcuts',
     'metric',
     'records',
+    'chart',
     'note',
 ];
 /**
  * How a recipe widget's `'<specifier>#<Export>'` becomes a module: a static map
- * of dynamic imports, one entry per package that ships widgets. No published
- * recipe declares a `widget` surface yet, so it is empty and every lookup is
- * `undefined` (the widget then renders as unavailable).
+ * of dynamic imports, one entry per package that ships widgets. The only
+ * published widget surface (smrt-reports' `runtime-report-chart`) needs a
+ * server, so the map is empty and every lookup is `undefined` (the widget then
+ * renders as unavailable).
  */
 const RECIPE_WIDGET_MODULES = {};
 export const resolveRecipeExport = async (specifier, exportName) => {

package/dist/overviews/validate.js

@@ -7,7 +7,7 @@
  * rendered or loaded, and only the canonical override is kept.
  */
 import { checkOverviewOverride, parseOverviewOverride, } from '@happyvertical/smrt-svelte/overview';
-import { isOverviewId, sectionOverview } from "./definitions.js";
+import { isOverviewId, overviewDefinition } from "./definitions.js";
 import { overviewRegistry } from "./registry.js";
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 function describe(id, issue) {
@@ -39,7 +39,7 @@ function without(override, ids) {
  * checked again, so one bad widget does not cost the visitor the others.
  */
 export function checkStoredOverride(id, raw) {
-    const definition = sectionOverview(id);
+    const definition = overviewDefinition(id);
     if (!definition) {
         return {
             override: null,