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

package/dist/shared/chartSeparation.d.ts

@@ -0,0 +1,11 @@
+export declare function linear(hex: string): [number, number, number];
+export declare function oklab([r, g, b]: readonly number[]): [number, number, number];
+/** The first reader two series are too alike for, how far apart they are to them and what they need; undefined when
+    every reader tells them apart. The one measure: the check says it, and a suggested chart is proved by it. */
+export declare function chartPairFailure(a: string, b: string): {
+    vision: string;
+    distance: number;
+    needs: number;
+} | undefined;
+/** Whether two series stay apart for every reader the chart check holds a palette to. */
+export declare function chartsApart(a: string, b: string): boolean;

package/dist/shared/chartSeparation.js

@@ -0,0 +1,58 @@
+/**
+ * Chart series apart for color-blind readers: the one measure `mistri check` holds an App's chart to
+ * (themeCheck.ts) and the built-in looks order their series by under each palette (lookPalettes.ts).
+ */
+/** Machado, Oliveira and Fernandes (2009) at full severity, in linear sRGB: the
+    two red-green deficiencies, about one man in twelve between them. Tritanopia
+    is rare enough (about 1 in 10,000) that it is not held against a palette. */
+const DEFICIENCIES = {
+    protanopia: [
+        [0.152286, 1.052583, -0.204868],
+        [0.114503, 0.786281, 0.099216],
+        [-0.003882, -0.048116, 1.051998],
+    ],
+    deuteranopia: [
+        [0.367322, 0.860646, -0.227968],
+        [0.280085, 0.672501, 0.047413],
+        [-0.01182, 0.04294, 0.968881],
+    ],
+};
+/** Adjacent series, in OKLab ΔE ×100: at least 8 under each deficiency, and 10 to normal vision. */
+const CHART_SEPARATION = { deficient: 8, normal: 10 };
+export function linear(hex) {
+    return [1, 3, 5].map((start) => {
+        const value = parseInt(hex.slice(start, start + 2), 16) / 255;
+        return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+    });
+}
+export function oklab([r, g, b]) {
+    const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b), m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b), s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+    return [
+        0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+        1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+        0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+    ];
+}
+function simulate(color, matrix) {
+    return matrix.map((row) => Math.min(1, Math.max(0, row[0] * color[0] + row[1] * color[1] + row[2] * color[2])));
+}
+/** OKLab distance ×100 between two hex colors, as seen with the deficiency named or with normal vision. */
+function chartDistance(a, b, deficiency) {
+    const see = (hex) => oklab(deficiency ? simulate(linear(hex), DEFICIENCIES[deficiency]) : linear(hex));
+    const x = see(a), y = see(b);
+    return 100 * Math.hypot(x[0] - y[0], x[1] - y[1], x[2] - y[2]);
+}
+/** The first reader two series are too alike for, how far apart they are to them and what they need; undefined when
+    every reader tells them apart. The one measure: the check says it, and a suggested chart is proved by it. */
+export function chartPairFailure(a, b) {
+    const tests = [
+        ['normal vision', chartDistance(a, b), CHART_SEPARATION.normal],
+        ...Object.keys(DEFICIENCIES).map((kind) => [kind, chartDistance(a, b, kind), CHART_SEPARATION.deficient]),
+    ];
+    const failed = tests.find(([, distance, needs]) => distance < needs);
+    return failed && { vision: failed[0], distance: failed[1], needs: failed[2] };
+}
+/** Whether two series stay apart for every reader the chart check holds a palette to. */
+export function chartsApart(a, b) {
+    return !chartPairFailure(a, b);
+}

package/dist/shared/clauses.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A query's trailing clauses, found by keyword: the client's chips take them
+ * off one at a time (client/clauses.js), and a list's question is built and
+ * read by them on both sides (listQuestion.ts).
+ *
+ * The split is by keyword, which the grammar makes safe: a query is a table,
+ * then conditions, then any of `show`, `sort`/`order by` and `limit` in that
+ * order. Only the trailing keywords are looked for, so a *value* containing
+ * the word "limit" cannot be mistaken for the clause — the boundary is found
+ * from the right, and only outside quotes.
+ */
+export { maskQuoted } from './maskQuoted.js';
+/** A query's parts: its table, its conditions and each trailing clause it has, keyword and all. */
+interface QueryParts {
+    table: string;
+    filter: string;
+    show?: string;
+    sort?: string;
+    limit?: string;
+}
+/** Break a query into its table, filter and trailing clauses. */
+export declare function splitQuery(text: unknown): QueryParts;

package/dist/shared/clauses.js

@@ -0,0 +1,97 @@
+/**
+ * A query's trailing clauses, found by keyword: the client's chips take them
+ * off one at a time (client/clauses.js), and a list's question is built and
+ * read by them on both sides (listQuestion.ts).
+ *
+ * The split is by keyword, which the grammar makes safe: a query is a table,
+ * then conditions, then any of `show`, `sort`/`order by` and `limit` in that
+ * order. Only the trailing keywords are looked for, so a *value* containing
+ * the word "limit" cannot be mistaken for the clause — the boundary is found
+ * from the right, and only outside quotes.
+ */
+/** Trailing clause keywords, longest first so `order by` wins over `order`. */
+const TAIL = [
+    { key: 'limit', pattern: /\blimit\b/i },
+    { key: 'sort', pattern: /\b(?:sort|order\s+by)\b/i },
+    { key: 'show', pattern: /\bshow\b/i },
+];
+/**
+ * Positions of characters that are inside a quoted value.
+ *
+ * `status = "sort code"` contains the word `sort` and does not contain a sort
+ * clause. Scanning for quotes first is what keeps the two apart.
+ */
+function quotedSpans(text) {
+    const spans = [];
+    let quote = null;
+    let start = 0;
+    for (let i = 0; i < text.length; i += 1) {
+        const c = text[i];
+        if (quote) {
+            if (c === '\\') {
+                i += 1;
+                continue;
+            }
+            if (c === quote) {
+                spans.push([start, i]);
+                quote = null;
+            }
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+            start = i;
+        }
+    }
+    if (quote)
+        spans.push([start, text.length]);
+    return spans;
+}
+const inside = (spans, at) => spans.some(([a, b]) => at > a && at < b);
+/* The quote mask every scanner here reads through; the client imports it from this module. */
+export { maskQuoted } from './maskQuoted.js';
+/** Break a query into its table, filter and trailing clauses. */
+export function splitQuery(text) {
+    const query = String(text ?? '').trim();
+    const spans = quotedSpans(query);
+    const firstSpace = query.search(/\s/);
+    const table = firstSpace < 0 ? query : query.slice(0, firstSpace);
+    let rest = firstSpace < 0 ? '' : query.slice(firstSpace + 1);
+    const offset = firstSpace + 1;
+    const parts = { table, filter: '' };
+    /* Boundaries are found first, then sorted by *position* — not peeled off in
+       grammar order.
+  
+       Peeling assumed the clauses arrive in the order the grammar lists them. The
+       parser does not require that, and `customer limit 5 sort name` is a query
+       someone will type. Peeling `limit` first took everything from `limit` to
+       the end, so the sort clause was swallowed into it: the chip read "5 sort
+       name" and removing the limit removed the sort with it.
+  
+       The last occurrence of each keyword wins, because a clause word can appear
+       earlier as an unquoted value; quoted ones are excluded outright. */
+    const marks = [];
+    for (const { key, pattern } of TAIL) {
+        let at = -1;
+        let from = 0;
+        for (;;) {
+            const found = rest.slice(from).search(pattern);
+            if (found < 0)
+                break;
+            const absolute = from + found;
+            if (!inside(spans, offset + absolute))
+                at = absolute;
+            from = absolute + 1;
+        }
+        if (at >= 0)
+            marks.push({ key, at });
+    }
+    marks.sort((a, b) => a.at - b.at);
+    marks.forEach(({ key, at }, i) => {
+        const until = marks[i + 1]?.at ?? rest.length;
+        parts[key] = rest.slice(at, until).trim();
+    });
+    if (marks.length)
+        rest = rest.slice(0, marks[0].at);
+    parts.filter = rest.trim();
+    return parts;
+}

package/dist/shared/columnCaption.d.ts

@@ -0,0 +1,16 @@
+import { type AppNoun } from './model.js';
+import { type DatabaseSchema } from './schema.js';
+/** The captions the App's resources give, by table id: `resources.<t>.labels`, column or label path → word; and what a record is called. */
+type Captions = Readonly<Record<string, {
+    labels?: Record<string, string>;
+    noun?: AppNoun;
+}>>;
+/**
+ * The one rule for what a column is called, on a screen and in anything the
+ * server words for a person (a record's history, an import's headers): the
+ * resource's own caption, else the one the schema implies. The server and the
+ * client both read it here, so the history says "Customer" where the screen does.
+ * `check` warns (`restated`) on a caption this returns without being told.
+ */
+export declare function columnCaption(resources: Captions, schema: DatabaseSchema | null, tableId: string, path: string, contextPath?: string): string;
+export {};

package/dist/shared/columnCaption.js

@@ -0,0 +1,90 @@
+/* What a column is called: the one naming rule the server (record history, imports, anything that names a column) and the client share. */
+import { humanName } from './model.js';
+import { headingOf, pluralOf, recordNoun } from './appNoun.js';
+import { hasFilterOf } from './listFilters.js';
+import { columnKind, findTable, labelColumn } from './schema.js';
+const midSentence = (word) => (/^[A-Z][a-z]/.test(word) ? word.charAt(0).toLowerCase() + word.slice(1) : word);
+/**
+ * A list's filter over the rows that point at its record (listFilters.ts),
+ * said by those rows: "Opportunity stage"; on a link table, the record its
+ * reference names ("Tag"); by one of their segments, "Has open opportunities".
+ */
+function hasCaption(resources, schema, tableId, has) {
+    const child = schema ? (findTable(schema, has.child) ?? schema.tables.find((table) => table.name === has.child)) : undefined;
+    const id = child?.id ?? has.child;
+    const noun = Object.hasOwn(resources, id) ? resources[id].noun : undefined;
+    const one = recordNoun(noun, child?.name ?? has.child);
+    if (child?.segments && Object.hasOwn(child.segments, has.asks)) {
+        return `Has ${midSentence(humanName(has.asks))} ${noun?.many ?? pluralOf(one)}`;
+    }
+    const caption = columnCaption(resources, schema, id, has.asks);
+    const reference = has.asks.includes('.') ? undefined : child?.columns.find((column) => column.name === has.asks)?.references;
+    if (reference && reference.table !== tableId)
+        return caption;
+    return `${headingOf(one)} ${midSentence(caption)}`;
+}
+/**
+ * The one rule for what a column is called, on a screen and in anything the
+ * server words for a person (a record's history, an import's headers): the
+ * resource's own caption, else the one the schema implies. The server and the
+ * client both read it here, so the history says "Customer" where the screen does.
+ * `check` warns (`restated`) on a caption this returns without being told.
+ */
+export function columnCaption(resources, schema, tableId, path, contextPath = '') {
+    const explicit = (table, column) => {
+        const labels = Object.hasOwn(resources, table) ? resources[table].labels : undefined;
+        if (!labels || !Object.hasOwn(labels, column))
+            return undefined;
+        return labels[column];
+    };
+    const named = explicit(tableId, path);
+    if (named)
+        return named;
+    const has = hasFilterOf(path);
+    if (has)
+        return hasCaption(resources, schema, tableId, has);
+    const tableAt = (parts) => {
+        let at = tableId;
+        for (const part of parts) {
+            const fk = schema?.foreignKeys.find((fk) => fk.from.table === at && fk.from.columns.length === 1 && fk.from.columns[0] === part);
+            if (!fk)
+                return undefined;
+            at = fk.to.table;
+        }
+        return at;
+    };
+    // A section already titled for a related record need not repeat that relationship on every field.
+    if (contextPath && path.startsWith(`${contextPath}.`)) {
+        const context = tableAt(contextPath.split('.'));
+        if (context)
+            return columnCaption(resources, schema, context, path.slice(contextPath.length + 1), '');
+    }
+    const parts = path.split('.');
+    const leaf = parts[parts.length - 1];
+    const owner = tableAt(parts.slice(0, -1));
+    const table = schema && owner ? findTable(schema, owner) : undefined;
+    if (parts.length > 1 && table && leaf === labelColumn(table)) {
+        return explicit(tableId, parts[0]) || humanName(parts[0].replace(/_(id|sku|code|key)$/, ''));
+    }
+    const inherited = owner && explicit(owner, leaf);
+    if (inherited)
+        return inherited;
+    const reference = table?.columns.find((col) => col.name === leaf)?.references;
+    if (reference && schema && owner) {
+        const target = findTable(schema, reference.table);
+        const naming = target && labelColumn(target);
+        const single = schema.foreignKeys.some((fk) => fk.from.table === owner && fk.from.columns.length === 1 && fk.from.columns[0] === leaf && fk.to.table === reference.table);
+        const projected = naming && single && explicit(owner, `${leaf}.${naming}`);
+        if (projected)
+            return projected;
+    }
+    if (reference)
+        return humanName(leaf.replace(/_id$/, ''));
+    // A moment is said by what happened: `ready_at` is "Ready", `due_on` "Due". The suffix is how SQL
+    // spells the type, not a word a person reads; a number or a flag named so keeps it.
+    const column = table?.columns.find((col) => col.name === leaf);
+    const kind = column && !column.flag ? columnKind(column.type ?? '') : undefined;
+    if ((kind === 'date' || kind === 'text') && /._(at|on)$/.test(leaf))
+        return humanName(leaf.replace(/_(at|on)$/, ''));
+    return humanName(leaf);
+}

package/dist/shared/commandFieldPath.d.ts

@@ -0,0 +1,2 @@
+/** A refusal's field path: `name`, `group.name` or `rows[1].name`, as deep as groups nest. */
+export declare const COMMAND_FIELD_PATH: RegExp;

package/dist/shared/commandFieldPath.js

@@ -0,0 +1,7 @@
+/*
+ * The one spelling of a refusal's field path. It sits below the command
+ * runtime because the canonical JSON walk (adapters/commands/canonicalJson.ts),
+ * which the stores share, names a refused member by it too.
+ */
+/** A refusal's field path: `name`, `group.name` or `rows[1].name`, as deep as groups nest. */
+export const COMMAND_FIELD_PATH = /^[A-Za-z_][A-Za-z0-9_]{0,127}(?:\[\d{1,3}\])?(?:\.[A-Za-z_][A-Za-z0-9_]{0,127}(?:\[\d{1,3}\])?){0,2}$/;

package/dist/shared/commandWire.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What a command request and a date field carry, below the commands that use them: the most keys one request may
+ * name, one record's key as text, a served input's fields depth first, and an ISO calendar date. The kit's selection, composed reads and date picker read
+ * them as the App framework's commands do (command.ts re-exports them), so the cap and the key's spelling are one rule
+ * on both sides without the kit reaching into the command rules.
+ */
+import type { AppCommandField } from '../../schema/model.js';
+/**
+ * A selection larger than one loaded page is a filter, not a selection. The
+ * most records a queue selects, and the most keys one multi-target command
+ * request may name: one constant, so the client cap and the server cap agree.
+ */
+export declare const BULK_LIMIT = 200;
+/**
+ * One record's identity: its columns sorted, each value as text. `{ id: 1 }`
+ * and `{ id: "1" }` name the same row, so a target list may not carry both,
+ * and the client and the server match a refusal's key to a record by it.
+ */
+export declare function commandKeyText(key: unknown): string;
+/** An ISO calendar date, `YYYY-MM-DD`, that exists. */
+export declare function isIsoDate(value: unknown): value is string;
+/** Every field of a declaration, depth first, with the group path it sits under. */
+export declare function commandFieldsDeep(fields: readonly AppCommandField[], within?: string): Generator<{
+    field: AppCommandField;
+    path: string;
+}>;

package/dist/shared/commandWire.js

@@ -0,0 +1,41 @@
+/**
+ * What a command request and a date field carry, below the commands that use them: the most keys one request may
+ * name, one record's key as text, a served input's fields depth first, and an ISO calendar date. The kit's selection, composed reads and date picker read
+ * them as the App framework's commands do (command.ts re-exports them), so the cap and the key's spelling are one rule
+ * on both sides without the kit reaching into the command rules.
+ */
+/**
+ * A selection larger than one loaded page is a filter, not a selection. The
+ * most records a queue selects, and the most keys one multi-target command
+ * request may name: one constant, so the client cap and the server cap agree.
+ */
+export const BULK_LIMIT = 200;
+/**
+ * One record's identity: its columns sorted, each value as text. `{ id: 1 }`
+ * and `{ id: "1" }` name the same row, so a target list may not carry both,
+ * and the client and the server match a refusal's key to a record by it.
+ */
+export function commandKeyText(key) {
+    if (!key || typeof key !== 'object' || Array.isArray(key))
+        return '';
+    const record = key;
+    return JSON.stringify(Object.keys(record)
+        .sort()
+        .map((column) => [column, String(record[column])]));
+}
+/** An ISO calendar date, `YYYY-MM-DD`, that exists. */
+export function isIsoDate(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const date = new Date(`${value}T00:00:00Z`);
+    return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+/** Every field of a declaration, depth first, with the group path it sits under. */
+export function* commandFieldsDeep(fields, within = '') {
+    for (const item of fields) {
+        const path = within ? `${within}.${item.name}` : item.name;
+        yield { field: item, path };
+        if (item.type === 'group')
+            yield* commandFieldsDeep(item.fields, path);
+    }
+}

package/dist/shared/computed.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Computed columns: a resource's virtual columns, each a typed expression over
+ * its own columns — `computed: { is_overdue: computed.boolean('due_on < today
+ * and not completed'), days_open: computed.number('today - opened_on') }`.
+ *
+ * A computed column is served like a rollup (rollups.ts): never a column of
+ * the table, so no insert, no update, no form and no single-table read ever
+ * names it; it lives beside the columns (`TableMeta.computed`), where the path
+ * resolver finds it by name, and the view compiler writes its expression into
+ * the statement wherever a path names it — a list's `show`, a sort, a tab's or
+ * an action's condition, a record page's fields, a dashboard's measure, an
+ * export. So it sorts, filters, tones and exports like a column, on every
+ * engine, with nothing for the browser to work out.
+ *
+ * Its words are the query language's: columns (and paths through a reference,
+ * as a record label's template reads them, `account_id.close_date`), numbers,
+ * quoted text, `true`/`false`, `today` and `now`, `me` (the signed-in
+ * account's email, as a fixed action's `set` writes it), comparisons,
+ * `and`/`or`/`not`, `in (…)`, `is empty`, arithmetic, and dates: a date minus a date is
+ * days, a date plus a number is that many days later, and a unit says others
+ * (`ends_on + term months`, `now - 30 minutes`). Five functions: `coalesce(a, b, …)`
+ * the first that has a value, `round(x)` and `round(x, 2)`, `abs(x)`, and
+ * `min(a, b, …)` and `max(a, b, …)` of numbers or dates, which have no value
+ * where one of theirs has none, as arithmetic has (`max(owed - paid, 0)`).
+ * That covers a due flag, an age, a renewal day, a balance.
+ * Anything heavier is a database view or a generated column, which the
+ * catalog reads as a column already.
+ *
+ * The constants are folded when the catalog is served (withComputed), each
+ * request's: `today` is the App's day in its time zone, `now` the instant,
+ * `me` this reader. A reader is served a computed column only where every
+ * column it reads is served to them, so a value never says what its inputs
+ * would not (appComputed.ts).
+ */
+import type { SqlStyle } from './filter.js';
+import type { ColumnMeta, DatabaseSchema } from './schema.js';
+export declare const COMPUTED_TYPES: readonly ['boolean', 'number', 'date'];
+export type ComputedType = (typeof COMPUTED_TYPES)[number];
+/** A span a date moves by: `3 days`, `term months`. */
+export type ComputedUnit = ComputedSpan['unit'];
+export type ComputedNode = {
+    k: 'path';
+    path: string;
+} | {
+    k: 'number';
+    value: number;
+} | {
+    k: 'text';
+    value: string;
+} | {
+    k: 'bool';
+    value: boolean;
+} | {
+    k: 'today';
+} | {
+    k: 'now';
+} | {
+    k: 'me';
+} | {
+    k: 'date';
+    value: string;
+} | {
+    k: 'instant';
+    value: string;
+} | {
+    k: 'nobody';
+} | {
+    k: 'not';
+    of: ComputedNode;
+} | {
+    k: 'neg';
+    of: ComputedNode;
+} | {
+    k: 'empty';
+    of: ComputedNode;
+    negate: boolean;
+} | ComputedSpan | {
+    k: 'call';
+    fn: ComputedFunction;
+    args: ComputedNode[];
+} | {
+    k: 'op';
+    op: ComputedOp;
+    left: ComputedNode;
+    right: ComputedNode;
+};
+/** The functions an expression may call (computedParse.ts COMPUTED_FUNCTIONS): each written alike on every engine and worked out alike in JavaScript. */
+export type ComputedFunction = 'coalesce' | 'round' | 'min' | 'max' | 'abs';
+interface ComputedSpan {
+    k: 'span';
+    of: ComputedNode;
+    unit: 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+}
+export type ComputedOp = '+' | '-' | '*' | '/' | '=' | '!=' | '<' | '<=' | '>' | '>=' | 'and' | 'or';
+/** A computed column as a catalog serves it and a view carries it: no request ever supplies one. */
+export interface ComputedColumn {
+    type: ComputedType;
+    expr: ComputedNode;
+    /** The paths it reads, from its own table: what a reader must be served for it to be. */
+    reads: string[];
+}
+/** A computed column a view names, keyed by its path in `ViewDef.expressions`, with the prefix of the record it is on. */
+export interface ComputedPath extends ComputedColumn {
+    on: string;
+}
+/** What a computed column is to anything that reads columns: typed, never written, never a key. */
+export declare function computedColumnMeta(name: string, computed: Pick<ComputedColumn, 'type'>): ColumnMeta;
+/**
+ * The catalog with each table's computed columns among its columns, typed and never written (`computed` by table id):
+ * what a rule judged of a stored row reads one through (a validation, a form's value from a referenced record), where
+ * the figure is worked out once the row is read rather than by the statement that reads it.
+ */
+export declare function withComputedColumns(schema: DatabaseSchema, computed: ReadonlyMap<string, Readonly<Record<string, Pick<ComputedColumn, 'type'>>>>): DatabaseSchema;
+export declare class ComputedError extends Error {
+    readonly at: number;
+    constructor(message: string, at: number);
+}
+/** Every path an expression reads, once each, in order. */
+export declare function computedReads(node: ComputedNode): string[];
+export type ValueKind = 'number' | 'date' | 'text' | 'boolean' | 'span' | 'null';
+/**
+ * What an expression is, or why it is none: each column's kind from the
+ * catalog (`kindOf`), a date minus a date a number of days, a date plus a
+ * number or a span a date. Said in the author's words, with the character
+ * the mistake stands at where a word locates it.
+ */
+export declare function computedKind(node: ComputedNode, kindOf: (path: string) => ValueKind | undefined): ValueKind;
+/** A statement that writes `now` was compiled where no request says the instant: a missing wrapper, not a bad definition,
+ * so a caller that turns compile errors into "not shown" lets this one through rather than keep the answer it would give. */
+export declare class StatementInstantMissing extends Error {
+}
+/** Who says the instant a statement is written at (an ISO string), or undefined where nobody does. */
+export declare function readStatementInstantFrom(read: () => string | undefined): void;
+/** The expression with its constants as this request's values: the App's day, the instant, the reader. `keepNow`
+ * leaves the instant as written, for the statement to write as its request's (statementInstant, above). */
+export declare function foldConstants(node: ComputedNode, values: {
+    today: string;
+    now: string;
+    me: string | null;
+}, keepNow?: boolean): ComputedNode;
+/**
+ * The expression as SQL on one engine. `column` writes a path the way the
+ * view writes every other (qualified against its joins); `kindOf` is the
+ * same reading of the catalog that typed it, which says where a yes-or-no
+ * column is an integer (SQLite, a PostgreSQL 0/1 flag).
+ */
+export declare function compileComputed(computed: Pick<ComputedColumn, 'type' | 'expr'>, style: SqlStyle, column: (path: string) => string, kindOf: (path: string) => {
+    kind: ValueKind;
+    native?: boolean;
+} | undefined): string;
+/** What an expression comes to: a figure, a yes-or-no, text, a calendar day or an instant; null for no value. */
+export type ComputedValue = number | boolean | string | null | {
+    day: string;
+} | {
+    instant: Date;
+};
+/** Whether an expression says the instant (`now`), so it comes to a moment rather than a day. */
+export declare function readsNow(node: ComputedNode): boolean;
+/** Whether an expression says the reader (`me`), so it comes to a different value for each. */
+export declare function readsMe(node: ComputedNode): boolean;
+export {};