@mistriwork/engine 0.0.0 → 1.0.0-rc.9

package/dist/shared/servedApp.js

@@ -0,0 +1,45 @@
+export const PLACEMENTS = ['side', 'top'];
+/**
+ * The entries this reader may use, in the App's order. Its words are the
+ * entry's own, else a list's noun ("Ticket", its resource's singular) or the
+ * form's heading.
+ */
+export function newMenuEntries(served, views, reader, noun) {
+    return (served ?? []).flatMap((entry) => {
+        const view = views[entry.view];
+        if (!view || view.error)
+            return [];
+        /* Its mark and its group's heading, where it has them. */
+        const dress = {
+            ...(entry.icon === undefined ? {} : { icon: entry.icon }),
+            ...(entry.group === undefined ? {} : { group: entry.group }),
+        };
+        if (isServedForm(view)) {
+            if (!reader.grantedCommands?.includes(view.command.id))
+                return [];
+            return [{ view: entry.view, label: entry.label ?? view.label, ...dress }];
+        }
+        if (typeof view.table !== 'string' || !reader.canAdd(view.table))
+            return [];
+        return [{ view: entry.view, label: entry.label ?? noun(entry.view, view.table), table: view.table, ...dress }];
+    });
+}
+/** Whether a view is a command form: the one kind of view that runs a command. */
+export const isServedForm = (view) => Object.hasOwn(view, 'command');
+/** The view keys nav references, depth first: the menu's order. */
+export function navViewKeys(nav) {
+    return nav.flatMap((node) => ('group' in node ? navViewKeys(node.children) : 'view' in node ? [node.view] : []));
+}
+/**
+ * Every view key in the order rooms are listed: the menu's, then the views
+ * nav does not reference (a home nav does not list, and a list view only a
+ * dashboard embeds). Never the keys'
+ * own order — an object puts a key like "2024" before every other.
+ */
+export function viewOrder(app) {
+    const keys = navViewKeys(app.nav).filter((key) => Object.hasOwn(app.views, key));
+    return [...keys, ...Object.keys(app.views).filter((key) => !keys.includes(key))];
+}
+/** The assistant's own room, where its App gives it a page (`placement: 'page'`, appAssistant.ts): its word in
+ * nav, and its address, `/{app}/assistant` and `/{app}/assistant/{conversation}` for one conversation. */
+export const ASSISTANT_ROOM = 'assistant';

package/dist/shared/sessionLease.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The lease a session's requests carry once a tenant is chosen, as the
+ * client's session identity holds it (client sessionIdentity.ts): who it is
+ * for, and the platform realm's reserved id that its shape is checked
+ * against when it is adopted. Below the kit because the kit's session
+ * identity checks it; the tenancy that issues one, and the headers a
+ * request asserts it by, are the App framework's (tenantContext.ts, which
+ * says these again for its own readers).
+ */
+export interface TenantContextOwner {
+    readonly tabId: string;
+    readonly context: string;
+    readonly appId: string;
+    readonly accountId: string;
+    /** The selected tenant. In the platform realm it is the reserved
+        `@platform`, which no `?tenant=` selector can name. */
+    readonly tenantId: string;
+    /** Present only for a lease in the platform realm, which reads across
+        tenants, or for a support session's lease inside one dealer (its
+        `tenantId`), which may read that dealer's rows — every read ledgered —
+        and writes nothing; a tenant's lease carries no realm. */
+    readonly realm?: 'platform' | 'support';
+    /** The support session this lease is inside. Present only under
+        `realm: 'support'`, and only the id the caller opened the session with:
+        it names the row each ledgered read is recorded against. */
+    readonly supportId?: string;
+}
+export interface TenantContextReply extends TenantContextOwner {
+    readonly revision: number;
+    readonly expiresAt: number;
+}
+/** The platform realm's reserved context id. It fails every tenant selector,
+ * so only `?realm=platform` reaches it. */
+export declare const PLATFORM_TENANT_ID = "@platform";

package/dist/shared/sessionLease.js

@@ -0,0 +1,3 @@
+/** The platform realm's reserved context id. It fails every tenant selector,
+ * so only `?realm=platform` reaches it. */
+export const PLATFORM_TENANT_ID = '@platform';

package/dist/shared/shape.d.ts

@@ -0,0 +1,55 @@
+/**
+ * What is in this database, answered from the catalog alone.
+ *
+ * The first minute with an unfamiliar schema is spent on questions the
+ * structure already answers: where does this thing centre, what are the tables
+ * I will actually query, how deep does it go, and what is that lump over there
+ * connected to nothing. The diagram shows all of it at once, which is a
+ * different thing from saying it — a picture of sixty-six tables answers "what
+ * is in here" only for someone who already knows.
+ *
+ * This is the non-model version of the feature the backlog files under LLM
+ * assistance, and it is the honest first version: everything below is derived
+ * from foreign keys that were introspected on connect, so it costs no network,
+ * no key, and cannot be wrong about a table it hallucinated.
+ *
+ * Pure on purpose — no DOM, no state, no imports. It takes a schema and returns
+ * a description, which is what makes it testable without a browser.
+ */
+/**
+ * Describe a schema's shape.
+ *
+ * @param {{tables: Array, foreignKeys: Array}} schema
+ * @returns {{
+ *   counts: {tables: number, views: number, keys: number},
+ *   hubs: Array<{table: object, incoming: number, from: string[]}>,
+ *   leaves: object[],
+ *   joins: Array<{table: object, connects: string[]}>,
+ *   chain: object[],
+ *   islands: object[],
+ *   start: object | null,
+ * }}
+ */
+export declare function describeSchema(schema: {
+    tables: any[];
+    foreignKeys: any[];
+}): {
+    counts: {
+        tables: number;
+        views: number;
+        keys: number;
+    };
+    hubs: Array<{
+        table: object;
+        incoming: number;
+        from: string[];
+    }>;
+    leaves: object[];
+    joins: Array<{
+        table: object;
+        connects: string[];
+    }>;
+    chain: object[];
+    islands: object[];
+    start: object | null;
+};

package/dist/shared/shape.js

@@ -0,0 +1,168 @@
+/**
+ * What is in this database, answered from the catalog alone.
+ *
+ * The first minute with an unfamiliar schema is spent on questions the
+ * structure already answers: where does this thing centre, what are the tables
+ * I will actually query, how deep does it go, and what is that lump over there
+ * connected to nothing. The diagram shows all of it at once, which is a
+ * different thing from saying it — a picture of sixty-six tables answers "what
+ * is in here" only for someone who already knows.
+ *
+ * This is the non-model version of the feature the backlog files under LLM
+ * assistance, and it is the honest first version: everything below is derived
+ * from foreign keys that were introspected on connect, so it costs no network,
+ * no key, and cannot be wrong about a table it hallucinated.
+ *
+ * Pure on purpose — no DOM, no state, no imports. It takes a schema and returns
+ * a description, which is what makes it testable without a browser.
+ */
+/** A table has to be pointed at by this many others before it is a hub. */
+const HUB_MINIMUM = 2;
+/** How much of a table has to be foreign keys before it is a join table. */
+const JOIN_RATIO = 0.6;
+/**
+ * Describe a schema's shape.
+ *
+ * @param {{tables: Array, foreignKeys: Array}} schema
+ * @returns {{
+ *   counts: {tables: number, views: number, keys: number},
+ *   hubs: Array<{table: object, incoming: number, from: string[]}>,
+ *   leaves: object[],
+ *   joins: Array<{table: object, connects: string[]}>,
+ *   chain: object[],
+ *   islands: object[],
+ *   start: object | null,
+ * }}
+ */
+export function describeSchema(schema) {
+    const tables = schema?.tables ?? [];
+    const keys = (schema?.foreignKeys ?? []).filter((fk) => fk.from.table !== fk.to.table);
+    const byId = new Map(tables.map((t) => [t.id, t]));
+    /* Counted as *distinct tables*, not constraints. `work_order` pointing at
+       `employee` three times — raised_by, assigned_to, approved_by — says one
+       thing about the shape, not three, and counting constraints would rank a
+       table by how many roles one neighbour plays in it. */
+    const incoming = new Map(tables.map((t) => [t.id, new Set()]));
+    const outgoing = new Map(tables.map((t) => [t.id, new Set()]));
+    for (const fk of keys) {
+        incoming.get(fk.to.table)?.add(fk.from.table);
+        outgoing.get(fk.from.table)?.add(fk.to.table);
+    }
+    const inCount = (t) => incoming.get(t.id)?.size ?? 0;
+    const outCount = (t) => outgoing.get(t.id)?.size ?? 0;
+    const real = tables.filter((t) => !t.isView);
+    const hubs = real
+        .filter((t) => inCount(t) >= HUB_MINIMUM)
+        .sort((a, b) => inCount(b) - inCount(a) || a.name.localeCompare(b.name))
+        .slice(0, 4)
+        .map((table) => ({
+        table,
+        incoming: inCount(table),
+        from: [...(incoming.get(table.id) ?? [])].map((id) => byId.get(id)?.name ?? id).sort(),
+    }));
+    /* Leaves point outwards and are pointed at by nothing, which is what a
+       transaction or an event table looks like: the thing that happened, hanging
+       off the things it happened to. They are usually what someone actually
+       wants to query, and they are the least visible in a diagram because they
+       sit at the edges. */
+    const leaves = real
+        .filter((t) => outCount(t) > 0 && inCount(t) === 0)
+        .sort((a, b) => outCount(b) - outCount(a) || a.name.localeCompare(b.name));
+    /* A join table is mostly foreign keys, points at two or more things, and —
+       the part that separates it from a lookup table — is pointed at by almost
+       nothing itself. A join table *connects* things; things do not connect to
+       it.
+    
+       Without that last clause `country` qualifies: three of its five columns are
+       references, to currency, language and region. But half the schema points at
+       `country`, which makes it a dimension everyone shares rather than a bridge
+       between two tables, and calling it a join table would mislead about the
+       one thing this list exists to say. */
+    const joins = real
+        .filter((t) => {
+        const fkColumns = t.columns.filter((c) => c.references).length;
+        return outCount(t) >= 2 && inCount(t) <= 1 && t.columns.length > 0 && fkColumns / t.columns.length >= JOIN_RATIO;
+    })
+        .map((table) => ({
+        table,
+        connects: [...(outgoing.get(table.id) ?? [])].map((id) => byId.get(id)?.name ?? id).sort(),
+    }));
+    return {
+        counts: {
+            tables: real.length,
+            views: tables.length - real.length,
+            keys: schema?.foreignKeys?.length ?? 0,
+        },
+        hubs,
+        leaves,
+        joins,
+        chain: longestChain(tables, outgoing)
+            .map((id) => byId.get(id))
+            .filter(Boolean),
+        islands: real.filter((t) => inCount(t) === 0 && outCount(t) === 0),
+        start: suggestStart(real, inCount, outCount),
+    };
+}
+/**
+ * The longest path of references, as the tables along it.
+ *
+ * The diagram computes the same *depth* to lay itself out, but a number is not
+ * the interesting part — "five levels deep" says less than "region → country →
+ * address → site → building → room", which is the shape of the domain written
+ * out. Recomputed here rather than shared because the diagram throws the path
+ * away and keeps only the count.
+ *
+ * A cycle is broken at the first table already on the path. A circular schema
+ * has no longest chain, and the alternative to stopping is not stopping.
+ */
+function longestChain(tables, outgoing) {
+    const best = new Map();
+    const walk = (id, seen) => {
+        if (seen.has(id))
+            return [];
+        if (best.has(id))
+            return best.get(id);
+        seen.add(id);
+        let longest = [];
+        for (const next of outgoing.get(id) ?? []) {
+            const path = walk(next, seen);
+            if (path.length > longest.length)
+                longest = path;
+        }
+        seen.delete(id);
+        const result = [id, ...longest];
+        /* Only memoised when the walk was not truncated by the cycle guard — a
+           path cut short by `seen` is an answer about this route, not about this
+           table, and caching it would poison every later route through it. */
+        if (!longest.some((t) => seen.has(t)))
+            best.set(id, result);
+        return result;
+    };
+    let chain = [];
+    for (const t of tables) {
+        const path = walk(t.id, new Set());
+        if (path.length > chain.length)
+            chain = path;
+    }
+    return chain.length > 1 ? chain : [];
+}
+/**
+ * Where to start reading.
+ *
+ * The table that connects to the most, with a readable name to recognise rows
+ * by. Both halves matter: a join table is highly connected and tells you
+ * nothing on its own, and a lookup table is readable and leads nowhere.
+ */
+function suggestStart(tables, inCount, outCount) {
+    const scored = tables
+        .filter((t) => t.columns.some((c) => !c.primaryKey && !c.references))
+        .map((t) => ({
+        table: t,
+        // Outgoing weighted higher: a table you can walk *from* opens more of the
+        // schema than one that is merely popular.
+        score: outCount(t) * 2 + inCount(t),
+    }))
+        .filter((s) => s.score > 0)
+        .sort((a, b) => b.score - a.score || a.table.name.localeCompare(b.table.name));
+    return scored[0]?.table ?? null;
+}

package/dist/shared/slug.d.ts

@@ -0,0 +1 @@
+export declare function slug(name: string, fallback: string): string;

package/dist/shared/slug.js

@@ -0,0 +1,12 @@
+/*
+ * The one rule for turning a display name into an id: lower case, each run of
+ * anything but letters and digits becomes one hyphen, and no hyphen at either
+ * end. Apps, pages, views and connections all derive a default id this way,
+ * each with its own word for a name that leaves nothing behind.
+ */
+export function slug(name, fallback) {
+    return (name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '') || fallback);
+}

package/dist/shared/sortText.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A sort written the way the query bar writes it — "due_on desc, name" —
+ * parsed to the structure a planner runs. One spelling for one question: a
+ * structured orderBy lived beside textual sort in tab queries, and remembering
+ * which surface wanted which was a tax on every author.
+ *
+ * A page section's `sort` (pageConfig.ts) and a record view's list section
+ * (recordview.ts) both read it here, so the two cannot drift into accepting
+ * different text. `example` is the surface's own sample, quoted in the error.
+ */
+export declare function parseSortText(raw: unknown, at: string, example: string): Array<{
+    column: string;
+    direction: 'asc' | 'desc';
+}> | undefined;

package/dist/shared/sortText.js

@@ -0,0 +1,26 @@
+/**
+ * A sort written the way the query bar writes it — "due_on desc, name" —
+ * parsed to the structure a planner runs. One spelling for one question: a
+ * structured orderBy lived beside textual sort in tab queries, and remembering
+ * which surface wanted which was a tax on every author.
+ *
+ * A page section's `sort` (pageConfig.ts) and a record view's list section
+ * (recordview.ts) both read it here, so the two cannot drift into accepting
+ * different text. `example` is the surface's own sample, quoted in the error.
+ */
+export function parseSortText(raw, at, example) {
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== 'string' || !raw.trim()) {
+        throw new Error(`${at} has a "sort" that is not query-bar text like "${example}".`);
+    }
+    return raw.split(',').map((part) => {
+        const words = part.trim().split(/\s+/);
+        const column = words[0] ?? '';
+        const direction = (words[1] ?? 'asc').toLowerCase();
+        if (!column || words.length > 2 || (direction !== 'asc' && direction !== 'desc')) {
+            throw new Error(`${at} has a "sort" it cannot read at "${part.trim()}". Write it like the query bar: "${example}".`);
+        }
+        return { column, direction: direction };
+    });
+}

package/dist/shared/sqlRelation.d.ts

@@ -0,0 +1,4 @@
+import type { SqlStyle } from './filter.js';
+import { type DatabaseSchema } from './schema.js';
+/** Physical relation rendering, kept separate from scoped relation lookup. */
+export declare function qualifiedTable(schema: DatabaseSchema, tableId: string, style: SqlStyle): string;

package/dist/shared/sqlRelation.js

@@ -0,0 +1,8 @@
+import { findTable } from './schema.js';
+/** Physical relation rendering, kept separate from scoped relation lookup. */
+export function qualifiedTable(schema, tableId, style) {
+    const table = findTable(schema, tableId);
+    if (!table)
+        return style.quote(tableId);
+    return table.schema ? `${style.quote(table.schema)}.${style.quote(table.name)}` : style.quote(table.name);
+}

package/dist/shared/sqlsaved.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Saved SQL statements, as a config file section.
+ *
+ * The same idea as the `views` section beside it, for the same reason: a
+ * statement you retype every morning is a statement that should have a name,
+ * and a *team's* statements belong in a file they can commit rather than in
+ * one person's browser. `tablewalk.json` is already the place a repository says
+ * "these are the databases this project talks to"; this lets it also say "and
+ * these are the questions people ask of them".
+ *
+ * The stored form is the text, never anything compiled. It stays readable in
+ * the editor, it survives the schema changing underneath it — at worst as a
+ * visible error you can fix rather than a silently wrong answer — and it can be
+ * reviewed in a pull request by someone who knows SQL and nothing about
+ * tablewalk.
+ */
+export interface SavedQuery {
+    name: string;
+    sql: string;
+    /** Optional prose, for a statement whose purpose is not obvious from it. */
+    description?: string;
+    /**
+     * Connection id or name this belongs to. Absent means every connection —
+     * which is right for a statement about a schema several databases share, and
+     * wrong for one about a table only production has, so it is worth setting.
+     */
+    connection?: string;
+    /** Where it came from, so the interface can say what it can be edited. */
+    source?: 'config' | 'saved';
+}
+/**
+ * Read the `queries` section of a config file.
+ *
+ * Errors name the file, the position *and* the statement's name where there is
+ * one, because a config file is something a person wrote by hand and "queries
+ * is not an array" sends them to search a file they may not have written.
+ *
+ * A duplicate name is refused rather than resolved. Two statements called
+ * "Daily totals" that do different things is a worse outcome than a startup
+ * error, and silently keeping the last one is the worst of the three.
+ */
+export declare function parseQueriesConfig(raw: unknown, where: string): SavedQuery[];
+/** The saved statements that apply to one connection, by id or by name. */
+export declare function queriesFor(all: SavedQuery[], connectionId: string, connectionName?: string): SavedQuery[];

package/dist/shared/sqlsaved.js

@@ -0,0 +1,63 @@
+/**
+ * Saved SQL statements, as a config file section.
+ *
+ * The same idea as the `views` section beside it, for the same reason: a
+ * statement you retype every morning is a statement that should have a name,
+ * and a *team's* statements belong in a file they can commit rather than in
+ * one person's browser. `tablewalk.json` is already the place a repository says
+ * "these are the databases this project talks to"; this lets it also say "and
+ * these are the questions people ask of them".
+ *
+ * The stored form is the text, never anything compiled. It stays readable in
+ * the editor, it survives the schema changing underneath it — at worst as a
+ * visible error you can fix rather than a silently wrong answer — and it can be
+ * reviewed in a pull request by someone who knows SQL and nothing about
+ * tablewalk.
+ */
+/**
+ * Read the `queries` section of a config file.
+ *
+ * Errors name the file, the position *and* the statement's name where there is
+ * one, because a config file is something a person wrote by hand and "queries
+ * is not an array" sends them to search a file they may not have written.
+ *
+ * A duplicate name is refused rather than resolved. Two statements called
+ * "Daily totals" that do different things is a worse outcome than a startup
+ * error, and silently keeping the last one is the worst of the three.
+ */
+export function parseQueriesConfig(raw, where) {
+    const queries = raw?.queries;
+    if (queries === undefined)
+        return [];
+    if (!Array.isArray(queries))
+        throw new Error(`${where}: "queries" must be an array.`);
+    const seen = new Set();
+    return queries.map((entry, i) => {
+        const at = `${where}: query ${i + 1}`;
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            throw new Error(`${at} is not an object.`);
+        }
+        const q = entry;
+        if (typeof q.name !== 'string' || !q.name.trim())
+            throw new Error(`${at} has no "name".`);
+        const name = q.name.trim();
+        if (seen.has(name)) {
+            throw new Error(`${where}: two queries are called "${name}". Names have to be distinct.`);
+        }
+        seen.add(name);
+        if (typeof q.sql !== 'string' || !q.sql.trim()) {
+            throw new Error(`${at} ("${name}") has no "sql".`);
+        }
+        return {
+            name,
+            sql: q.sql.trim(),
+            description: typeof q.description === 'string' && q.description.trim() ? q.description.trim() : undefined,
+            connection: typeof q.connection === 'string' && q.connection.trim() ? q.connection.trim() : undefined,
+            source: 'config',
+        };
+    });
+}
+/** The saved statements that apply to one connection, by id or by name. */
+export function queriesFor(all, connectionId, connectionName) {
+    return all.filter((q) => !q.connection || q.connection === connectionId || q.connection === connectionName);
+}

package/dist/shared/stitchedPaths.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Where a path crosses a stitched reference: a declared reference to a table
+ * in another source, on another connection (ForeignKey.stitched), which is
+ * read in a second step and never joined. Shared by the reader that stitches
+ * (appStitchedReads.ts) and the load-time check of an App's own lists, so an
+ * authored filter or sort through one is refused when the App starts, in the
+ * words a request through one is refused with.
+ */
+import type { DatabaseSchema, ForeignKey } from './schema.js';
+import { type ViewCondition, type ViewOrder } from './viewPaths.js';
+/** A stitched hop a path takes: the prefix as the path wrote it, the edge, and whether it is past the first step. */
+export interface StitchedHop {
+    prefix: string;
+    edge: ForeignKey;
+    deep: boolean;
+}
+/** The first stitched hop a path takes from `base`, or none. */
+export declare function stitchedHop(schema: DatabaseSchema, base: string, path: string): StitchedHop | undefined;
+/** Why a list cannot filter or sort by a path on the far side of a stitched reference. */
+export declare function stitchedFarProblem(hop: StitchedHop, path: string, what: string): string;
+/** The first condition or sort of a list that is across a stitched reference, said as a problem. */
+export declare function stitchedListProblem(schema: DatabaseSchema, base: string, parsed: {
+    filter?: {
+        groups: ViewCondition[][];
+    };
+    orderBy?: ViewOrder[];
+}): string | undefined;

package/dist/shared/stitchedPaths.js

@@ -0,0 +1,38 @@
+import { hopsFrom } from './viewPaths.js';
+/** The first stitched hop a path takes from `base`, or none. */
+export function stitchedHop(schema, base, path) {
+    const segments = path.split('.').map((segment) => segment.trim());
+    let table = base;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const matches = hopsFrom(schema, table).filter((hop) => hop.name === segments[i] || hop.fk.name === segments[i]);
+        if (matches.length !== 1)
+            return undefined;
+        const { fk } = matches[0];
+        if (fk.stitched)
+            return { prefix: segments.slice(0, i + 1).join('.'), edge: fk, deep: i > 0 };
+        table = fk.to.table;
+    }
+    return undefined;
+}
+/** Why a list cannot filter or sort by a path on the far side of a stitched reference. */
+export function stitchedFarProblem(hop, path, what) {
+    const target = hop.edge.to.table;
+    return (`"${path}" is on ${target}, in another source on another connection, so a list of ${hop.edge.from.table} cannot ${what} by it: ` +
+        `each database filters and sorts what it holds. Show it, or ${what} on ${target}'s own list.`);
+}
+/** The first condition or sort of a list that is across a stitched reference, said as a problem. */
+export function stitchedListProblem(schema, base, parsed) {
+    for (const condition of parsed.filter?.groups.flat() ?? []) {
+        for (const path of [condition.path, ...(condition.other ? [condition.other] : [])]) {
+            const hop = stitchedHop(schema, base, path);
+            if (hop)
+                return stitchedFarProblem(hop, path, 'filter');
+        }
+    }
+    for (const order of parsed.orderBy ?? []) {
+        const hop = order.alias ? undefined : stitchedHop(schema, base, order.path);
+        if (hop)
+            return stitchedFarProblem(hop, order.path, 'sort');
+    }
+    return undefined;
+}

package/dist/shared/structuredFilter.d.ts

@@ -0,0 +1,22 @@
+import type { Op } from './filter.js';
+export type StructuredScalar = string | number | boolean | null;
+/** A validated condition, shared by execution and transport. Parsing may build
+ * broader draft types; execution must validate them before claiming this shape. */
+type StructuredCondition<Field extends 'column' | 'path'> = Record<Field, string> & ({
+    op: 'isNull' | 'isNotNull';
+    value?: StructuredScalar;
+} | {
+    op: 'in';
+    value: StructuredScalar[];
+} | {
+    op: Exclude<Op, 'isNull' | 'isNotNull' | 'in'>;
+    value: StructuredScalar;
+} | (Field extends 'path' ? {
+    op: '=' | '!=' | '>' | '>=' | '<' | '<=';
+    other: string;
+    value?: undefined;
+} : never));
+export interface StructuredFilter<Field extends 'column' | 'path' = 'column'> {
+    groups: Array<Array<StructuredCondition<Field>>>;
+}
+export {};

package/dist/shared/structuredFilter.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/subtitlePath.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The path a shown column's second line reads, or undefined for none. A
+ * rule's `subtitle` names a column of the table the value was read from, so
+ * `employee_id.name` shown on a timesheet reads `employee_id.title` — the
+ * employee's title, never the timesheet's own column of that name. Its own
+ * module: the cell draws it (client valueModel.ts) and a list's question
+ * fetches it (listQuestion.ts), and a public page's cells carry nothing else.
+ */
+export declare function subtitlePath(rule: {
+    subtitle?: string;
+} | null | undefined, column: string): string | undefined;
+/**
+ * The path a shown column's lead icon reads its tone from, or undefined for
+ * none: like a second line, a column of the table the value was read from.
+ */
+export declare function leadTonePath(rule: {
+    icon?: {
+        toneOf?: string;
+    };
+} | null | undefined, column: string): string | undefined;

package/dist/shared/subtitlePath.js

@@ -0,0 +1,24 @@
+/**
+ * The path a shown column's second line reads, or undefined for none. A
+ * rule's `subtitle` names a column of the table the value was read from, so
+ * `employee_id.name` shown on a timesheet reads `employee_id.title` — the
+ * employee's title, never the timesheet's own column of that name. Its own
+ * module: the cell draws it (client valueModel.ts) and a list's question
+ * fetches it (listQuestion.ts), and a public page's cells carry nothing else.
+ */
+export function subtitlePath(rule, column) {
+    if (!rule?.subtitle)
+        return undefined;
+    const hop = column.lastIndexOf('.');
+    return hop < 0 ? rule.subtitle : `${column.slice(0, hop + 1)}${rule.subtitle}`;
+}
+/**
+ * The path a shown column's lead icon reads its tone from, or undefined for
+ * none: like a second line, a column of the table the value was read from.
+ */
+export function leadTonePath(rule, column) {
+    if (!rule?.icon?.toneOf)
+        return undefined;
+    const hop = column.lastIndexOf('.');
+    return hop < 0 ? rule.icon.toneOf : `${column.slice(0, hop + 1)}${rule.icon.toneOf}`;
+}

package/dist/shared/suggest.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Levenshtein distance, capped: names more than three characters apart in
+ * length score 99 without the table being built. Only ever used to suggest
+ * a near miss, where anything that far off is no suggestion at all.
+ */
+export declare function distance(a: string, b: string): number;
+/** The candidate closest to `name` ignoring case, if one is within three edits. */
+export declare function nearest(name: string, candidates: readonly string[]): string | undefined;
+/**
+ * The refusal of a key its place does not take, after the place:
+ * `has no "lable". Did you mean "label"? It takes: …`, the caller ending the
+ * sentence. A key some other place takes (`homes`) is told where it belongs
+ * instead: it is spelled right and put in the wrong place. A key here one
+ * slip away still wins, since a typo is the likelier mistake.
+ */
+export declare function unknownKey(key: string, takes: readonly string[], homes?: readonly string[]): string;
+/** A short list for an error message; long lists help nobody. */
+export declare function shortList(items: readonly string[]): string;