@mistriwork/engine 0.0.0-stage → 1.0.0-rc.10

package/dist/shared/recordReads.js

@@ -0,0 +1,368 @@
+/**
+ * What a record page reads, as the requests its sections send.
+ *
+ * A record page used to reach its reader in three waves of requests — the
+ * root and the plan, then a request or two per section, then the history —
+ * and at 20 ms to the database each wave was a round of admissions and
+ * statements: a lender's loan finished at 0.9 s. The server now answers the
+ * whole page in one request (server/http/recordCompose.ts, and the tenant
+ * host's own): it plans the page, then asks each section's read on the
+ * section's behalf, through the same route and the same grants as the
+ * section's own request, and hands every answer back beside the plan. The
+ * client keeps them for the requests they answer (client/composedReads.ts),
+ * and a section that asks finds its answer waiting.
+ *
+ * So the one rule is that server and client build each request alike, and
+ * the builders live here, used by both: the sections' own modules call them
+ * for the request they send, and the server calls them to know what the
+ * sections will ask. A request built differently is only asked again — the
+ * section sends it, as it always did — so a drift costs a request, never a
+ * wrong answer.
+ *
+ * The record's own row is the one read that is not asked alike: every fields
+ * section, the header, the root probe and a custom section's record fields
+ * read the one row, each for its columns, and which of them ask together
+ * depends on what is drawn (a tab not yet opened asks nothing). The server
+ * reads every column any of them names, once, and each is answered with
+ * exactly its part (`rowPart`), as the client's own shared read already was
+ * (pageFieldsRead.ts).
+ */
+import { findTable, labelPath, primaryKey } from './schema.js';
+import { DEFAULT_HISTORY_LIMIT, kindReading } from './pageModel.js';
+import { assertNever } from './model.js';
+import { andQuery, quoteValue } from './query.js';
+import { tabMatches } from './addressParams.js';
+import { recordView, referenceProjection } from './referenceModel.js';
+import { tableAtPrefix } from './viewPaths.js';
+import { appTargetFields } from './appLinks.js';
+/** The route a record page is composed on. */
+export const RECORD_COMPOSE_PATH = '/api/pages/compose';
+/**
+ * A timeline stream's reads, as its section asks them (kit PageTimeline.tsx): its rows, where its author is a
+ * reference with the person's name beside it, read through the reference as a list column of it is; and where the
+ * stream has a far side, that side's rows. One rule for the section and the page's planned reads (`recordReads`),
+ * so a composed page's answer is the very read the section asks: a record page whose timeline was planned without
+ * the author's name asked it again, alone, once the page had drawn (a field report: a fifth round on a record).
+ */
+export function timelineReads(names, stream) {
+    if (stream.error || stream.empty || !stream.view)
+        return undefined;
+    const table = stream.from === undefined ? undefined : names.table(stream.from);
+    const reference = stream.by ? table?.columns.find((column) => column.name === stream.by)?.references : undefined;
+    const target = reference ? names.table(reference.table) : undefined;
+    const named = target && names.namePath(target);
+    const view = target && named && !primaryKey(target).includes(named)
+        ? { ...stream.view, columns: [...(stream.view.columns ?? []), { path: `${stream.by}.${named}` }] }
+        : stream.view;
+    const side = stream.side?.view && !stream.side.error && stream.key?.length ? stream.side.view : undefined;
+    return side ? { view, side } : { view };
+}
+/** Where a table's rows are named, as a view path. */
+const namePathOf = (names, table) => names.namePath ? names.namePath(table) : labelPath(names.schema, table, names.recordLabel(table.id));
+/**
+ * The fields a section shows when it names none. In the Workbench, every
+ * column: it is the database as it is. In an App, every column a reader
+ * reads — not a key the database handed out (a lone numeric or uuid primary
+ * key, which opened a lead on "ID 2") and not a row version, the same two
+ * the scaffold leaves out of the fields it writes (server/scaffold.ts).
+ */
+export function defaultFieldPaths(base, app) {
+    const keys = base.columns.filter((c) => c.primaryKey);
+    const surrogate = (c) => c.primaryKey && keys.length === 1 && (/^(id|uuid|guid)$/i.test(c.name) || /int|serial|number|numeric|uuid/i.test(c.type ?? ''));
+    const version = (c) => /^(version|lock_version|row_version|rowversion|revision)$/i.test(c.name);
+    const read = base.columns.filter((c) => !app || !(surrogate(c) || version(c))).map((c) => c.name);
+    return read.length ? read : base.columns.map((c) => c.name);
+}
+/** A fields section's columns: what it shows, the names of what it references, the record's name, and its workflow's field. */
+export function fieldsColumns(names, base, section) {
+    const paths = section.paths?.length ? [...section.paths] : defaultFieldPaths(base, names.app);
+    const namePath = namePathOf(names, base);
+    /* A headline also reads its second figure and every field its actions
+       fill a form from; they are fetched, not shown as facts. */
+    const extra = section.presentation === 'headline'
+        ? [
+            ...(section.subfigure ? [section.subfigure] : []),
+            ...(section.was ? [section.was] : []),
+            ...(section.actions ?? []).flatMap((action) => [
+                ...Object.values(action.prefill ?? {}),
+                ...(action.to ? appTargetFields(action.to) : []),
+            ]),
+        ].filter((path) => !paths.includes(path))
+        : [];
+    const projection = referenceProjection(names.schema, base, [...paths, ...new Set(extra)], section.names !== false && names.app, (table) => namePathOf(names, table));
+    const fetched = projection.fetched;
+    if (namePath && !fetched.includes(namePath))
+        fetched.push(namePath);
+    if (section.workflow && !fetched.includes(section.workflow.field))
+        fetched.push(section.workflow.field);
+    // A row-defined column's fields are the ones its record's `per` picks (definedFields.ts),
+    // through a reference too: `requested_item_id.answers` reads `requested_item_id.<per>`.
+    for (const path of paths) {
+        const through = names.defined ? definedThrough(names.schema, base.id, path, names.defined) : undefined;
+        const per = through?.binding.per;
+        const perPath = per === undefined ? undefined : through.prefix ? `${through.prefix}.${per}` : per;
+        if (perPath && !fetched.includes(perPath))
+            fetched.push(perPath);
+    }
+    return { fetched, labels: projection.labels };
+}
+/**
+ * The row-defined column a fields path ends on (`resources.<r>.defined`):
+ * the record's own (`specs`) or one through references
+ * (`requested_item_id.answers`), with the table it lives on, the hops before
+ * it, and its binding. Undefined for any other path. A record shows the
+ * column's fields wherever its path is shown, not only on its own page.
+ */
+export function definedThrough(schema, baseId, path, defined) {
+    const cut = path.lastIndexOf('.');
+    const prefix = cut === -1 ? '' : path.slice(0, cut), column = path.slice(cut + 1);
+    const table = tableAtPrefix(schema, baseId, prefix);
+    const bound = table ? defined(table.id) : undefined;
+    if (!table || !bound || !Object.hasOwn(bound, column))
+        return undefined;
+    return { table, column, prefix, binding: bound[column] };
+}
+/** A record header's columns: its status, its facts, the names of what they reference, and the record's name. */
+export function headerColumns(names, base, section) {
+    const projection = referenceProjection(names.schema, base, [...(section.status ? [section.status] : []), ...(section.paths ?? [])], names.app, (table) => namePathOf(names, table));
+    const fetched = projection.fetched;
+    const namePath = namePathOf(names, base);
+    if (namePath && !fetched.includes(namePath))
+        fetched.push(namePath);
+    return { fetched, labels: projection.labels };
+}
+/** The key as a filter on the record's own row, one equality per key column. */
+function keyFilter(base, key) {
+    return { groups: [primaryKey(base).map((column) => ({ path: column, op: '=', value: key[column] }))] };
+}
+/** A read of the record's own row, for columns: the probe (`root`), a fields section (`fields`), the header (`header`), a custom section's record (`<index>:record`). */
+export function rowBody(pageId, base, key, columns, part) {
+    return {
+        count: 'none',
+        view: {
+            id: `page:${pageId}:${part}`,
+            name: base.name,
+            base: base.id,
+            columns: columns.map((path) => ({ path })),
+            filter: keyFilter(base, key),
+            limit: 1,
+        },
+    };
+}
+/** The probe's columns: the key, and the record's name. */
+function probeColumns(names, base) {
+    const namePath = namePathOf(names, base);
+    return [...primaryKey(base), ...(namePath ? [namePath] : [])];
+}
+/** A related list's first request: its planned view at the reader's page size, with the names and keys a row needs. */
+export function listView(names, section, plan, rows) {
+    const table = names.table ? names.table(section.from ?? '') : findTable(names.schema, section.from ?? '');
+    const limit = section.limit ?? rows;
+    const view = plan.view && !section.limit ? { ...plan.view, limit } : plan.view;
+    const explicit = (target) => (names.recordLabel(target.id) === undefined ? undefined : namePathOf(names, target));
+    return view && table
+        ? recordView(names.schema, table, view, names.app, (target) => namePathOf(names, target), explicit)
+        : {
+            view: view,
+            labelColumns: {},
+            hidden: [],
+            keyColumns: [],
+            labelColumn: undefined,
+        };
+}
+/** A grouped list's page of groups, as `/api/breakdown` takes it: the request the page's compose asks and the list asks again. */
+export function groupsBody(groups, offset) {
+    return { def: groups, limit: groups.limit, offset };
+}
+/** A metric's measure: a count asked as a breakdown with no key, or the plan's own breakdown; none for a plain aggregate. */
+export function metricMeasure(plan) {
+    const counted = plan.counts && plan.view && !plan.breakdown
+        ? {
+            base: plan.view.base,
+            by: [],
+            measures: [{ fn: 'count', alias: 'value' }],
+            ...(plan.view.filter ? { filter: plan.view.filter } : {}),
+            limit: 1,
+        }
+        : undefined;
+    return plan.breakdown ?? counted;
+}
+/** Whether the record satisfies a `when`: one bounded query, key and condition composed the way every fold is. */
+export function whenBody(base, key, when) {
+    const keyText = primaryKey(base)
+        .map((c) => `${c} = ${quoteValue(String(key[c]))}`)
+        .join(' and ');
+    return { q: `${base.id} ${andQuery(keyText, when)}`, limit: 1, offset: 0, count: 'none' };
+}
+/** The first page of a record's history. */
+export function historyBody(base, key, limit) {
+    return { table: base.id, key, limit };
+}
+/**
+ * The sections a page draws when it opens on `tab`, as PageSections.tsx lays
+ * them out: a strip of named tabs draws the one asked for (the first, when
+ * none is) and every panel holding the record's own fields; a run of lists
+ * made into tabs draws the one asked for; everything else is drawn. The
+ * header is drawn in the head. What a closed tab would read is read when it
+ * is opened, as ever, and asked for nothing here.
+ */
+export function drawnSections(schema, page, tab, appPage) {
+    const drawn = new Set();
+    const shownAll = page.sections.map((section, index) => ({ section, index })).filter(({ section }) => !section.hidden);
+    const header = shownAll.find(({ section }) => section.kind === 'fields' && section.presentation === 'header');
+    if (header)
+        drawn.add(header.index);
+    const hasAside = page.sections.some((section) => section.region === 'aside' && !section.hidden);
+    const autoTabs = appPage ? page.listTabs === true : page.listTabs !== false;
+    const tabbed = (section) => section.kind === 'list' && section.presentation !== 'gallery' && (section.width === undefined || !appPage);
+    const lay = (items, listTabs, scoped) => {
+        for (let i = 0; i < items.length; i += 1) {
+            if (!(listTabs && autoTabs && tabbed(items[i].section))) {
+                drawn.add(items[i].index);
+                continue;
+            }
+            let end = i;
+            while (end + 1 < items.length && tabbed(items[end + 1].section))
+                end += 1;
+            const run = items.slice(i, end + 1);
+            if (run.length === 1)
+                drawn.add(run[0].index);
+            else {
+                const token = (item) => scoped
+                    ? `section:${item.index}`
+                    : (item.section.title ?? findTable(schema, item.section.from ?? '')?.name ?? item.section.from ?? '');
+                const asked = run.findIndex((item) => tabMatches(token(item), tab));
+                drawn.add(run[asked === -1 ? 0 : asked].index);
+            }
+            i = end;
+        }
+    };
+    for (const region of hasAside ? ['main', 'aside'] : [undefined]) {
+        const shown = shownAll.filter(({ section }) => !(section.kind === 'fields' && section.presentation === 'header') && (!region || (section.region ?? 'main') === region));
+        const scoped = region === 'aside';
+        const groups = [];
+        for (const item of shown) {
+            if (!item.section.tab)
+                continue;
+            const group = groups.find((g) => g.name === item.section.tab);
+            if (group)
+                group.items.push(item);
+            else
+                groups.push({ name: item.section.tab, items: [item] });
+        }
+        if (groups.length < 2) {
+            lay(shown, true, scoped);
+            continue;
+        }
+        const first = shown.findIndex((item) => item.section.tab);
+        lay(shown.slice(0, first), true, scoped);
+        const asked = groups.findIndex((group) => tabMatches(`tab:${group.name}`, tab));
+        groups.forEach((group, i) => {
+            if (i === (asked === -1 ? 0 : asked) || group.items.some(({ section }) => section.kind === 'fields'))
+                lay(group.items, false, scoped);
+        });
+        lay(shown.slice(first).filter((item) => !item.section.tab), true, scoped);
+    }
+    return drawn;
+}
+/**
+ * Every read a record page's sections will ask for when it opens on `tab`,
+ * given its plan: the record's row (every column any section drawn reads),
+ * and each other request as the section builds it. A hidden section, and
+ * one in a closed tab, reads nothing; a section behind a `when` is read
+ * too, and its condition asked, since the answer is only kept until it is
+ * asked for.
+ */
+export function recordPageReads(names, page, base, plans, key, options) {
+    const drawn = drawnSections(names.schema, page, options.tab, names.app);
+    /* Each reader of the row with its own columns, too: the one read of all of
+       them is refused whole where any column is, and then each is asked alone,
+       as the sections would have been. */
+    const parts = [{ part: 'root', columns: probeColumns(names, base) }];
+    const reads = [];
+    const planOf = (index) => plans.find((plan) => plan.index === index);
+    const view = (body) => reads.push({ path: '/api/view/run', body });
+    const breakdown = (def) => reads.push({ path: '/api/breakdown', body: { def } });
+    page.sections.forEach((section, index) => {
+        if (section.hidden || !drawn.has(index))
+            return;
+        if (section.when)
+            reads.push({ path: '/api/run', body: whenBody(base, key, section.when) });
+        const plan = planOf(index);
+        if (section.kind === 'fields') {
+            const header = section.presentation === 'header';
+            parts.push({
+                part: header ? 'header' : 'fields',
+                columns: (header ? headerColumns(names, base, section) : fieldsColumns(names, base, section)).fetched,
+            });
+            return;
+        }
+        if (section.kind === 'history') {
+            if (options.history)
+                reads.push({ path: '/api/record-history', body: historyBody(base, key, section.limit ?? DEFAULT_HISTORY_LIMIT) });
+            return;
+        }
+        /* A note reads nothing. Flow runs are fetched lazily by their section, behind the reader's own check
+           (server/recordFlows.ts), and a flow's diagram reads its steps when it is drawn, as the reader's rows
+           (PageFlowDiagram.tsx). */
+        if (kindReading(section.kind, 'none'))
+            return;
+        if (section.kind === 'custom' && section.record?.length)
+            parts.push({ part: `${index}:record`, columns: [...section.record] });
+        if (!plan || plan.error || plan.empty)
+            return;
+        switch (section.kind) {
+            case 'metric': {
+                const measure = metricMeasure(plan);
+                if (measure)
+                    breakdown(measure);
+                else if (plan.view)
+                    view({ view: plan.view });
+                return;
+            }
+            case 'breakdown':
+            case 'chart':
+                if (plan.breakdown)
+                    breakdown(plan.breakdown);
+                return;
+            case 'timeline':
+                for (const stream of plan.streams ?? []) {
+                    const asked = timelineReads({
+                        table: (id) => (names.table ? names.table(id) : findTable(names.schema, id)),
+                        namePath: (table) => namePathOf(names, table),
+                    }, stream);
+                    if (asked)
+                        view({ view: asked.view, offset: 0 });
+                    if (asked?.side)
+                        view({ view: asked.side, offset: 0 });
+                }
+                return;
+            case 'custom':
+                for (const read of Object.values(plan.reads ?? {}))
+                    if (!read.error && !read.empty && read.view)
+                        view({ view: read.view, offset: 0, count: 'none' });
+                for (const total of Object.values(plan.aggregates ?? {}))
+                    if (!total.error && !total.empty && total.breakdown)
+                        breakdown(total.breakdown);
+                return;
+            case 'list': {
+                /* A grouped list asks its groups first; each group's rows are asked of the keys that come back. */
+                if (section.group && plan.groups) {
+                    reads.push({ path: '/api/breakdown', body: groupsBody(plan.groups, 0) });
+                    if (plan.totals)
+                        breakdown(plan.totals);
+                    return;
+                }
+                const listed = listView(names, section, plan, options.rows).view;
+                if (listed)
+                    view({ view: listed, offset: 0 });
+                if (plan.totals)
+                    breakdown(plan.totals);
+                return;
+            }
+            default:
+                assertNever(section.kind, 'page section kind');
+        }
+    });
+    return { row: [...new Set(parts.flatMap((part) => part.columns))], parts, reads };
+}

package/dist/shared/recordview.d.ts

@@ -0,0 +1,198 @@
+/**
+ * A record template: one row, with its references pulled in around it.
+ *
+ * The view composer as built answers "give me a table of X with columns from
+ * the things X points at" — one row per base record, joins flattened into
+ * columns. That is a useful shape and the wrong one for the question tablewalk
+ * actually exists to answer, which is "show me *this* work order, properly".
+ *
+ * That question wants a page: the work order's own fields, the customer's
+ * details inline because a work order without its customer's name is a
+ * riddle, and its parts and notes as tables underneath because there are
+ * several of each and a count is not enough.
+ *
+ * The difference from a list view is not cosmetic — it is what the thing is
+ * bound to. A list view is a *query*: it produces rows and you read them. A
+ * record template is bound to a **table**, not to a row, and applies to every
+ * row of it. Configure `work_order` once and every work order you ever walk
+ * to is laid out that way. That is what makes it worth configuring at all.
+ *
+ * Two consequences fall out, and both are why this shape earns its place:
+ *
+ *   - A has-many relationship is finally answerable. In a list view it either
+ *     multiplies rows or collapses to a count; here it is simply a table on
+ *     the page, which is what anyone asking for "the order and its lines"
+ *     meant in the first place.
+ *   - Views stop being a dead end. A list view is somewhere you look; a
+ *     record template is where a walk *arrives*, so views become part of the
+ *     navigation rather than a parallel product beside it.
+ */
+import { type ColumnMeta, type DatabaseSchema, type ForeignKey, type TableMeta } from './schema.js';
+/** A block of the base record's own fields, or of a to-one reference's. */
+interface FieldSection {
+    kind: 'fields';
+    /** Shown above the block. Absent means no heading. */
+    title?: string;
+    /**
+     * Paths, relative to the base. `reference` is the base's own column;
+     * `customer_id.name` is the customer's, pulled inline.
+     */
+    paths: string[];
+}
+/**
+ * A table of the rows that point at this record.
+ *
+ * Keyed by constraint name for the same reason aggregates are: a child can
+ * point at the same parent twice, and `work_order.parent_id` and
+ * `work_order.supersedes_id` are two different sections that would otherwise
+ * be indistinguishable.
+ */
+export interface ListSection {
+    kind: 'list';
+    title?: string;
+    /** Constraint name of the foreign key pointing back at this record. */
+    via: string;
+    /** Columns of the child table to show. Empty means a sensible default. */
+    columns: string[];
+    /** Rows to fetch per section. Bounded because a page is not a report. */
+    limit?: number;
+    orderBy?: {
+        column: string;
+        direction: 'asc' | 'desc';
+    }[];
+}
+type RecordSection = FieldSection | ListSection;
+interface RecordTemplate {
+    id: string;
+    name: string;
+    /** The table this template lays out. Not a row — every row of it. */
+    base: string;
+    sections: RecordSection[];
+    /** Used for every record of this table unless another is chosen. */
+    isDefault?: boolean;
+    connection?: string;
+    source?: 'config' | 'saved';
+}
+/** Rows to show in an embedded list before it needs its own page. */
+export declare const DEFAULT_LIST_LIMIT = 10;
+/**
+ * How a table's own columns divide into blocks.
+ *
+ * Derived from what the schema already says rather than from a stored layout:
+ * keys and the label column identify, foreign keys link, dates measure, and
+ * anything named like an audit column is bookkeeping. Ordering is by what
+ * gets looked at first, not by declaration order.
+ *
+ * Lives here rather than in the renderer because it *is* the default
+ * template. Having the derivation in one place and the stored layout in
+ * another is how the two start disagreeing about what a record looks like.
+ */
+export declare function groupOwnColumns(table: TableMeta): Array<[string | null, ColumnMeta[]]>;
+/**
+ * The template a table gets before anyone configures one.
+ *
+ * Derived rather than blank, because a blank record page is a worse starting
+ * point than the default layout the record view already produces, and because
+ * the fastest way to explain what a template *is* is to show someone one made
+ * of their own data.
+ *
+ * The rules are the ones the record view already uses, made explicit: the
+ * record's own fields first, then each to-one reference as its own labelled
+ * block, then each incoming relationship as a table.
+ */
+export declare function deriveTemplate(schema: DatabaseSchema, tableId: string): RecordTemplate | undefined;
+/**
+ * Every column of a child table worth showing, in declaration order.
+ *
+ * All of them, not a summary. A summary is the right shape for a reference
+ * pulled *into* a record — a customer's forty fields would bury the work order
+ * they are attached to — and the wrong shape for a table of children, which is
+ * the thing you opened the record to read. `work_order_part` summarised down
+ * to one column of quantities is a list of numbers with nothing to attach them
+ * to.
+ *
+ * The join columns are still dropped: every row here carries the same value
+ * for them, so a column of one repeated value is width spent on nothing. The
+ * key stays, because it is what distinguishes the rows.
+ *
+ * Anyone who wants fewer can say so in the layout builder, which is the right
+ * order for a default — start from everything and subtract, rather than start
+ * from a guess and hunt for what is missing.
+ */
+export declare function listColumns(table: TableMeta, exclude?: string[]): string[];
+/**
+ * A few columns that say what a row *is*.
+ *
+ * Keys and the columns forming the join are dropped: in a table of a work
+ * order's parts, every row has the same `work_order_id`, so a column of it is
+ * a column of one repeated value. What is left is what distinguishes the rows
+ * from each other, which is the only thing the section is there to show.
+ */
+export declare function summaryColumns(table: TableMeta, exclude?: string[], max?: number): string[];
+interface ResolvedList {
+    section: ListSection;
+    fk: ForeignKey;
+    child: TableMeta;
+    /** Column on the child that carries the parent's key, per key column. */
+    join: Array<{
+        childColumn: string;
+        parentColumn: string;
+    }>;
+}
+/**
+ * Match each list section to the foreign key it names.
+ *
+ * A section whose constraint has since been dropped is returned as an error
+ * rather than skipped: a template that quietly stops showing a table looks
+ * exactly like a record that has no rows in it.
+ */
+export declare function resolveLists(schema: DatabaseSchema, template: RecordTemplate): {
+    lists: ResolvedList[];
+    errors: string[];
+};
+/**
+ * Every path the base row itself has to supply.
+ *
+ * Collected across field sections so the record can be fetched in one query
+ * rather than one per section — a page with six reference blocks should not
+ * be six round trips.
+ */
+export declare function fieldPaths(template: RecordTemplate): string[];
+/** Whether a template still says anything, after resolution. */
+export declare function isEmpty(template: RecordTemplate): boolean;
+/**
+ * One layout as a config file writes it.
+ *
+ * `sections` is deliberately not `RecordSection[]`: a list section is keyed
+ * internally by constraint name (`via`), which is the right key — a child can
+ * point at a parent twice and the column alone would not say which — and the
+ * wrong thing to ask a person to type. So a config may say `via`, or say
+ * `from` and `whose` the way a page section does, and the naming is resolved
+ * against the schema when the layout is served.
+ *
+ * The authored words are the page section's — `whose`, `show`, `sort` — so
+ * one file speaks one language (docs/apps.md, "The respelling"). The parsed
+ * sections keep the internal field names (`path`, `paths`, `columns`,
+ * `orderBy`): the client and the server's resolver read those, and the
+ * respelling is of the surface a person types, not of the model.
+ */
+export interface ConfigLayout {
+    table: string;
+    connection?: string;
+    name?: string;
+    sections: Array<Record<string, unknown>>;
+}
+/**
+ * Read the `layouts` section of a tablewalk.json.
+ *
+ * Throws on anything malformed rather than skipping it, naming the entry and
+ * the fix — the same rule `parsePagesConfig` follows, for the same reason: a
+ * layout that silently did not appear is a bug report that starts "I
+ * definitely wrote it".
+ *
+ * Structure only. Whether `customer_id` is a real column, or `invoice` a real
+ * table, needs a schema this runs long before — those are answered when the
+ * layout is served, and reported on the layout itself.
+ */
+export declare function parseLayoutsConfig(raw: unknown, where: string): ConfigLayout[];
+export {};