@mistriwork/engine 0.0.0 → 1.0.0-rc.9

package/dist/server/recordHistoryOperations.js

@@ -0,0 +1,43 @@
+import { TransactionOutcomeUnknown } from '../adapters/adapter.js';
+import { snapshotScopedData } from '../adapters/scoped/scopedReads.js';
+/** Owns completion/publication only. The supplied transaction and work retain
+ * their original authorization, record fences and image-capture contracts.
+ * No registry, fallback writer or way to upgrade a scoped capability exists. */
+export async function runRecordedTransaction(options) {
+    if (options.mode === 'preview') {
+        const transaction = options.transaction.bind(options), work = options.work.bind(options);
+        return { result: await transaction(work) };
+    }
+    const transaction = options.transaction.bind(options), work = options.work.bind(options);
+    const history = options.history;
+    const publish = history.publish.bind(history), quarantine = history.quarantine.bind(history);
+    const isRejection = options.isRejection.bind(options);
+    // Validate without accessors/prototypes, then retain the journal's ordinary
+    // data-object shape while detaching every nested value.
+    const uncertainty = structuredClone(snapshotScopedData(options.uncertainty));
+    let committed = false;
+    try {
+        const stored = await transaction(async (tx) => {
+            const prepared = await work(tx);
+            // Malformed evidence must fail inside the transaction, not after COMMIT.
+            // Detach before the writer's completion wait so retained callback objects
+            // cannot rewrite the history that will be published after commit.
+            return { result: prepared.result, entry: structuredClone(snapshotScopedData(prepared.entry)) };
+        });
+        committed = true;
+        const entry = publish(stored.entry);
+        return { result: stored.result, ...(entry.revertible ? { undoId: entry.id } : {}) };
+    }
+    catch (error) {
+        if (committed || error instanceof TransactionOutcomeUnknown || !isRejection(error)) {
+            try {
+                publish(uncertainty);
+            }
+            catch {
+                quarantine();
+            }
+            throw error instanceof TransactionOutcomeUnknown ? error : new TransactionOutcomeUnknown(error);
+        }
+        throw error;
+    }
+}

package/dist/server/recordWriteOperations.d.ts

@@ -0,0 +1,111 @@
+import { Refusal, type Adapter, type DeleteRequest, type DeleteResult, type InsertRequest, type InsertResult, type UpdateRequest, type UpdateResult, type WriteTransaction } from '../adapters/adapter.js';
+import { recordWrite } from './journal.js';
+import { type DatabaseSchema, type ForeignKey } from '../shared/schema.js';
+interface RecordWriteOptions {
+    adapter: Adapter;
+    connection: string;
+    /** Owns logical/physical mapping and verified account attribution for every entry. */
+    record?: typeof recordWrite;
+    /** Verified history ownership, paired with the exact physical connection.
+     * Used to fail closed if publishing even an uncertainty barrier fails. */
+    historyOwner?: {
+        principal?: string;
+        app?: string;
+    };
+    completeInverse?: boolean;
+    by?: string;
+    /** False where an App writes: it has no Undo, so nothing is journaled (unrecorded). */
+    journal?: boolean;
+}
+type Recorded<Result> = {
+    result: Result;
+    undoId?: number;
+};
+/** What else a deletion may change: see recordedDelete. */
+interface Dependents {
+    references?: readonly ForeignKey[];
+    unseen?: boolean;
+}
+/** One row of a new record's lines as a save sends it: the values the reader set. */
+export interface LineRow {
+    values: Record<string, string | number | boolean | null>;
+}
+/**
+ * One collection of a record's lines, judged by the route (formLinesWrite.ts):
+ * the child table, the reference that joins a row to the record and the
+ * record's column it holds, the column the rows' places
+ * fill, and every row, in order.
+ */
+export interface LineCollection {
+    table: string;
+    whose: string;
+    refers: string;
+    order?: string;
+    rows: readonly LineRow[];
+    /** Filled as the lines are written: the key of every row inserted, for the search index to follow once the transaction commits. */
+    written?: Record<string, string | number>[];
+}
+/**
+ * A record's lines, written in its transaction once the record is: each row
+ * the insert the reader could make of it alone, so the
+ * App's adapter judges every one (grants, validation, transitions) and a
+ * refusal of any rolls back the record with them. A refused row's fields
+ * cross as `table[i].field`, so the form marks the line, not the record.
+ */
+/**
+ * A refusal that names the fields it turned down — the App framework's
+ * validation (app/appValidationDenied.ts) — said again by a line with each
+ * field at the line's place, so the form marks the line, not the record.
+ */
+export interface FieldRefusal extends Refusal {
+    readonly fields: readonly string[];
+    renamed(rename: (field: string) => string): Refusal;
+}
+/**
+ * What writes a record's lines: the transaction itself where its adapter
+ * judges every row, or, under a row policy or a tenant lease, that writer's
+ * own facade — its transitions, its stamps, its deletion policy — so a line
+ * is held to exactly what the same row would be held to alone.
+ */
+export type LineWriter = Pick<WriteTransaction, 'query' | 'insert' | 'lockRecord'> & {
+    update(request: UpdateRequest): Promise<unknown>;
+    remove(request: DeleteRequest): Promise<unknown>;
+};
+export declare function writeLines(tx: LineWriter, lines: readonly LineCollection[], record: Readonly<Record<string, unknown>> | undefined): Promise<void>;
+export declare function recordedUpdate(options: RecordWriteOptions, input: UpdateRequest): Promise<Recorded<UpdateResult>>;
+export declare function recordedInsert(options: RecordWriteOptions, input: InsertRequest, 
+/** Rows that go with the new one, in its transaction, made from it: a record's tag links (tagLists.ts). */
+alongside?: (result: InsertResult) => readonly InsertRequest[], 
+/** The new record's lines (`form.lines`), inserted in its transaction and joined to it (formLinesWrite.ts). */
+lines?: readonly LineCollection[]): Promise<Recorded<InsertResult>>;
+/**
+ * Many new rows of one table in one transaction, recorded as one entry: an
+ * import. Undo removes every row it added or none, as a single insert's
+ * does, and only when each row's whole stored image could be captured; one
+ * that could not makes the entry a barrier that says why.
+ */
+export declare function recordedImport(options: RecordWriteOptions, inputs: readonly InsertRequest[], checkpoint?: () => void): Promise<Recorded<InsertResult[]>>;
+/**
+ * Captures this row only. A database-owned cascade (or `set null`) is not a
+ * graph Undo: putting the parent back would leave its children gone or
+ * emptied, which is half an undo. So when one of `dependents.references` —
+ * the incoming references whose rule changes the rows behind them, named as
+ * this writer names them — has a row pointing at this one, read on the same
+ * writer before the delete, the entry is a barrier that says why, and the
+ * deletion is undone whole or not at all. `dependents.unseen` says such a
+ * reference exists from a table this writer cannot read (one an App does not
+ * declare): it cannot be counted here, so it is a barrier whatever it holds.
+ */
+export declare function recordedDelete(options: RecordWriteOptions, input: DeleteRequest, dependents?: Dependents): Promise<Recorded<DeleteResult>>;
+/** The incoming references a deletion of `table` would change rows through:
+ * every rule but a refusal, an unreported one included. */
+export declare function changingReferences(schema: DatabaseSchema, table: string): ForeignKey[];
+/**
+ * A deletion's dependents read off the database's own catalog, never an
+ * App's reduced one: a cascade into a table the App does not declare still
+ * happens. `physical` is the connection's catalog and `table` its name there;
+ * `writerName` gives the name the writer reads a physical table by, or
+ * undefined when it cannot read it — which makes the reference unseen.
+ */
+export declare function deletionDependents(physical: DatabaseSchema, table: string, writerName: (physicalTable: string) => string | undefined): Dependents;
+export {};

package/dist/server/recordWriteOperations.js

@@ -0,0 +1,329 @@
+import { Refusal, WriteConflict, } from '../adapters/adapter.js';
+import { snapshotScopedData } from '../adapters/scoped/scopedReads.js';
+import { inRecordLane } from '../adapters/writeLanes.js';
+import { withWriteAhead } from '../adapters/writeAhead.js';
+import { isPoolBusy } from '../adapters/poolMetrics.js';
+import { writeFailureOutcome } from './constraints.js';
+import { journalFieldsMatch, journalImageMatches, quarantineHistory, recordWrite, summarise, } from './journal.js';
+import { runRecordedTransaction } from './recordHistoryOperations.js';
+import { referencesTo } from '../shared/schema.js';
+import { carryServerRequest } from './serverRequests.js';
+function barrier(kind, table, reason, unknown = false) {
+    const entry = {
+        kind,
+        summary: reason,
+        reason,
+        revertible: false,
+        ...(unknown ? { undoState: 'unknown' } : { blocksUndo: true }),
+        // Keep the logical resource for source attribution, but no record values.
+        steps: [{ table }],
+    };
+    return entry;
+}
+async function recorded(options, kind, table, run) {
+    const { adapter: writer, record = recordWrite, connection, by } = options;
+    const historyOwner = options.historyOwner ? { ...options.historyOwner } : undefined;
+    if (!writer.transaction)
+        throw new Refusal('Recorded writes require a supported transaction writer.');
+    return runRecordedTransaction({
+        mode: 'write',
+        transaction: writer.transaction.bind(writer),
+        work: run,
+        history: {
+            publish: (entry) => record(connection, { ...entry, ...(by ? { by } : {}) }),
+            quarantine: () => quarantineHistory(connection, historyOwner),
+        },
+        uncertainty: {
+            ...barrier(kind, table, 'Write outcome or history unconfirmed. Refresh and reconcile before further editing.', true),
+            revertible: false,
+            undoState: 'unknown',
+        },
+        // A refused checkout: no writer was leased, or the transaction rolled back (a failed rollback is an unknown outcome, which isPoolBusy does not claim).
+        isRejection: (error) => error instanceof Refusal || error instanceof WriteConflict || isPoolBusy(error) || writeFailureOutcome(error) === 'rejected',
+    });
+}
+/**
+ * An App's write. An App has no Undo, so it keeps no journal entry and
+ * captures no images for one; what it keeps is the transaction and the row
+ * lock the journal's capture ran in. Inside them the App's adapter judges
+ * transitions on the locked row and validates the stored row after the
+ * write, and a refusal there rolls the write back — the reasons a single
+ * statement would not do. The lane (writeLanes.ts) keeps saves of one
+ * record in the order they arrived, now that saves of different records
+ * run side by side.
+ */
+async function unrecorded(options, request, run) {
+    const writer = options.adapter;
+    if (!writer.transaction)
+        throw new Refusal('Writes require a supported transaction writer.');
+    const work = () => writer.transaction(run);
+    return { result: await (request.key ? inRecordLane(request.table, request.key, work) : work()) };
+}
+async function original(tx, request, columns) {
+    // Merely using the writer handle is not enough under READ COMMITTED: another
+    // transaction could change the row between SELECT and mutation. The adapter
+    // owns the dialect-specific row lock (or SQLite's existing writer fence).
+    if (!tx.lockRecord)
+        throw new Refusal('Recorded writes require a transaction record-lock capability.');
+    await tx.lockRecord({ table: request.table, key: request.key });
+    return rowAt(tx, request, columns);
+}
+async function rowAt(tx, request, columns) {
+    const result = await tx.query({
+        table: request.table,
+        ...(columns ? { columns } : {}),
+        filter: { groups: [Object.entries(request.key).map(([column, value]) => ({ column, op: '=', value }))] },
+        limit: 2,
+        offset: 0,
+    });
+    return result.rows.length === 1 ? { ...snapshotScopedData(result.rows[0]) } : undefined;
+}
+const isFieldRefusal = (error) => error instanceof Refusal && typeof error.renamed === 'function';
+export async function writeLines(tx, lines, record) {
+    for (const line of lines) {
+        /* A transaction tried again writes them again: only the last attempt's keys stand. */
+        const written = (line.written = []);
+        const bound = record?.[line.refers];
+        if (typeof bound !== 'string' && typeof bound !== 'number')
+            throw new Refusal("The record's key was not read back, so its lines cannot be joined to it.");
+        const marked = async (i, work) => {
+            try {
+                return await work();
+            }
+            catch (error) {
+                if (!isFieldRefusal(error))
+                    throw error;
+                /* The table's own name, unqualified: a field crosses as one segment and a column (fieldErrors.ts). */
+                throw error.renamed((name) => `${line.table.slice(line.table.lastIndexOf('.') + 1)}[${i}].${name}`);
+            }
+        };
+        const placed = (row, i) => ({ ...row.values, ...(line.order ? { [line.order]: i + 1 } : {}) });
+        for (const [i, row] of line.rows.entries()) {
+            const made = await marked(i, () => tx.insert(snapshotScopedData({ table: line.table, values: { ...placed(row, i), [line.whose]: bound } })));
+            written.push(made.key);
+        }
+    }
+}
+export async function recordedUpdate(options, input) {
+    const request = snapshotScopedData(input);
+    if (!Object.keys(request.values).length)
+        throw new Refusal('Nothing to set.');
+    if (options.journal === false)
+        // The record it locks, reads and writes, told to the transaction so its lock and row go behind the BEGIN (writeAhead.ts).
+        return withWriteAhead({ targets: [{ table: request.table, key: request.key }], writes: true, locks: true }, () => unrecorded(options, request, async (tx) => {
+            // The row the App judges is the row the write replaces: a plain read would not hold it.
+            if (!tx.lockRecord)
+                throw new Refusal('Writes require a transaction record-lock capability.');
+            await tx.lockRecord({ table: request.table, key: request.key });
+            return tx.update(request);
+        }));
+    return recorded(options, 'update', request.table, async (tx) => {
+        // PK fields identify the predicate; they need not be readable projections.
+        const before = await original(tx, request, Object.keys(request.values));
+        const losslessBefore = Boolean(before && (await journalFieldsMatch(tx, request.table, request.key, before)));
+        const result = await tx.update(request);
+        const touched = Object.keys(result.applied);
+        // Store the database image, not its write-intent DTO (booleans, defaults
+        // and AFTER triggers can have a different stored representation).
+        const after = result.affected === 1 && touched.length ? await rowAt(tx, request, touched) : undefined;
+        if (!losslessBefore ||
+            !before ||
+            !after ||
+            !touched.length ||
+            touched.some((column) => !Object.hasOwn(before, column)) ||
+            !(await journalFieldsMatch(tx, request.table, request.key, after))) {
+            return { result, entry: barrier('update', request.table, 'The updated record has no complete original for Undo.') };
+        }
+        const steps = [
+            {
+                table: request.table,
+                key: { ...request.key },
+                before: Object.fromEntries(touched.map((column) => [column, before[column]])),
+                after,
+                exactFields: true,
+            },
+        ];
+        return { result, entry: { kind: 'update', summary: summarise('update', steps), revertible: true, steps } };
+    });
+}
+export async function recordedInsert(options, input, 
+/** Rows that go with the new one, in its transaction, made from it: a record's tag links (tagLists.ts). */
+alongside, 
+/** The new record's lines (`form.lines`), inserted in its transaction and joined to it (formLinesWrite.ts). */
+lines) {
+    // An upload's file columns are the server's to write (serverRequests.ts): the copy keeps the mark.
+    const request = carryServerRequest(input, snapshotScopedData(input));
+    const completeInverse = options.completeInverse !== false;
+    if (lines?.length && options.journal !== false)
+        throw new Refusal("A record's lines are saved with it in an App.");
+    const withRows = async (tx, result) => {
+        for (const row of alongside?.(result) ?? [])
+            await tx.insert(snapshotScopedData(row));
+        if (lines?.length)
+            await writeLines(tx, lines, { ...result.row, ...result.key });
+        return result;
+    };
+    if (options.journal === false)
+        return unrecorded(options, request, async (tx) => withRows(tx, await tx.insert(request)));
+    return recorded(options, 'insert', request.table, async (tx) => {
+        const result = await withRows(tx, await tx.insert(request));
+        /* An Undo of the record alone would leave its tags' link rows pointing at nothing. */
+        if (alongside && alongside(result).length) {
+            return {
+                result,
+                entry: barrier('insert', request.table, 'This creation added rows beside the record, which one Undo does not take back.'),
+            };
+        }
+        if (!tx.lockRecord ||
+            !completeInverse ||
+            !Object.keys(result.key ?? {}).length ||
+            !result.row ||
+            !Object.keys(result.row).length ||
+            !(await journalImageMatches(tx, request.table, result.row))) {
+            return {
+                result,
+                entry: barrier('insert', request.table, 'This creation has no complete identifiable inverse under the current permissions.'),
+            };
+        }
+        const steps = [
+            { table: request.table, key: { ...result.key }, after: { ...snapshotScopedData(result.row) }, wholeRow: true },
+        ];
+        return { result, entry: { kind: 'insert', summary: summarise('insert', steps), revertible: true, steps } };
+    });
+}
+/**
+ * Many new rows of one table in one transaction, recorded as one entry: an
+ * import. Undo removes every row it added or none, as a single insert's
+ * does, and only when each row's whole stored image could be captured; one
+ * that could not makes the entry a barrier that says why.
+ */
+export async function recordedImport(options, inputs, checkpoint = () => { }) {
+    const requests = inputs.map((input) => snapshotScopedData(input));
+    const table = requests[0]?.table;
+    if (!table || requests.some((request) => request.table !== table))
+        throw new Refusal('An import writes rows of one table.');
+    if (options.journal === false)
+        return unrecorded(options, { table }, async (tx) => {
+            const results = [];
+            for (const request of requests) {
+                checkpoint();
+                results.push(await tx.insert(request));
+            }
+            checkpoint();
+            return results;
+        });
+    let complete = options.completeInverse !== false;
+    return recorded(options, 'insert', table, async (tx) => {
+        const results = [];
+        const steps = [];
+        for (const request of requests) {
+            checkpoint();
+            const result = await tx.insert(request);
+            results.push(result);
+            if (complete &&
+                (!tx.lockRecord ||
+                    !Object.keys(result.key ?? {}).length ||
+                    !result.row ||
+                    !Object.keys(result.row).length ||
+                    !(await journalImageMatches(tx, table, result.row))))
+                complete = false;
+            if (complete)
+                steps.push({ table, key: { ...result.key }, after: { ...snapshotScopedData(result.row) }, wholeRow: true });
+        }
+        checkpoint();
+        if (!complete)
+            return {
+                result: results,
+                entry: barrier('insert', table, 'This import has no complete identifiable inverse under the current permissions.'),
+            };
+        return { result: results, entry: { kind: 'insert', summary: summarise('insert', steps), revertible: true, steps } };
+    });
+}
+/**
+ * Captures this row only. A database-owned cascade (or `set null`) is not a
+ * graph Undo: putting the parent back would leave its children gone or
+ * emptied, which is half an undo. So when one of `dependents.references` —
+ * the incoming references whose rule changes the rows behind them, named as
+ * this writer names them — has a row pointing at this one, read on the same
+ * writer before the delete, the entry is a barrier that says why, and the
+ * deletion is undone whole or not at all. `dependents.unseen` says such a
+ * reference exists from a table this writer cannot read (one an App does not
+ * declare): it cannot be counted here, so it is a barrier whatever it holds.
+ */
+export async function recordedDelete(options, input, dependents = {}) {
+    const request = snapshotScopedData(input);
+    const completeInverse = options.completeInverse !== false;
+    if (options.journal === false)
+        return unrecorded(options, request, (tx) => tx.remove(request));
+    return recorded(options, 'delete', request.table, async (tx) => {
+        const before = await original(tx, request);
+        const complete = completeInverse && Boolean(before && (await journalImageMatches(tx, request.table, before)));
+        const touches = complete && (dependents.unseen === true || (await touchesDependents(tx, request.key, dependents.references ?? [])));
+        const result = await tx.remove(request);
+        if (touches) {
+            return { result, entry: barrier('delete', request.table, 'Rows elsewhere depended on it, so this deletion cannot be undone.') };
+        }
+        if (!complete || result.affected !== 1 || !before || !Object.keys(before).length) {
+            return { result, entry: barrier('delete', request.table, 'The deleted record has no complete original for Undo.') };
+        }
+        /* The key as the row stored it, not as the request spelled it: an
+           address says `1` as text, and a restore is checked against the stored
+           row, whose integer 1 is not the string '1'. */
+        const key = Object.fromEntries(Object.entries(request.key).map(([column, value]) => [column, Object.hasOwn(before, column) ? before[column] : value]));
+        const steps = [{ table: request.table, key, before, wholeRow: true }];
+        return { result, entry: { kind: 'delete', summary: summarise('delete', steps), revertible: true, steps } };
+    });
+}
+/** Whether a row behind one of these references points at `key`. A count that
+ * cannot be taken is read as yes: an Undo that might be partial is not offered. */
+async function touchesDependents(tx, key, dependents) {
+    for (const fk of dependents) {
+        const conditions = fk.to.columns.map((column, i) => ({
+            column: fk.from.columns[i] ?? fk.from.columns[0],
+            op: '=',
+            value: key[column],
+        }));
+        if (conditions.some((condition) => condition.value === undefined || condition.value === null))
+            return true;
+        try {
+            const found = await tx.query({
+                table: fk.from.table,
+                columns: fk.from.columns,
+                filter: { groups: [conditions] },
+                limit: 1,
+                offset: 0,
+            });
+            if (found.rows.length)
+                return true;
+        }
+        catch {
+            return true;
+        }
+    }
+    return false;
+}
+/** The incoming references a deletion of `table` would change rows through:
+ * every rule but a refusal, an unreported one included. */
+export function changingReferences(schema, table) {
+    return referencesTo(schema, table).filter((fk) => !fk.declared && fk.onDelete !== 'restrict' && fk.onDelete !== 'no action');
+}
+/**
+ * A deletion's dependents read off the database's own catalog, never an
+ * App's reduced one: a cascade into a table the App does not declare still
+ * happens. `physical` is the connection's catalog and `table` its name there;
+ * `writerName` gives the name the writer reads a physical table by, or
+ * undefined when it cannot read it — which makes the reference unseen.
+ */
+export function deletionDependents(physical, table, writerName) {
+    const references = [];
+    // A table the catalog does not know cannot be shown to have no dependents.
+    let unseen = !physical.tables.some((item) => item.id === table);
+    for (const fk of changingReferences(physical, table)) {
+        const name = writerName(fk.from.table);
+        if (name === undefined)
+            unseen = true;
+        else
+            references.push({ ...fk, from: { ...fk.from, table: name } });
+    }
+    return { references, unseen };
+}

package/dist/server/resourceReadHttp.d.ts

@@ -0,0 +1,81 @@
+import { type Adapter, type SqlStyle } from '../adapters/adapter.js';
+import { type DatabaseSchema } from '../shared/schema.js';
+import { type QueryPerson } from '../shared/query.js';
+import { type ViewDef } from '../shared/view.js';
+/** A dashboard is at most a few dozen sections; a batch past this is not one. */
+export declare const BREAKDOWN_BATCH = 48;
+/** The furthest a list is paged by offset over HTTP: past it the rows skipped cost more than the page. */
+export declare const MAX_PAGE_OFFSET = 10000;
+/**
+ * What an App's reads are beside the database browser's, given by the App
+ * framework (app/appReads.ts) wherever an App is read: absent, a read is the
+ * browser's, which shows its SQL and its compiled columns and says a failure
+ * in the engine's own words.
+ */
+export interface AppReads {
+    /** The adapter with every read of a union answered by its branches (app/unionReads.ts). */
+    reader(adapter: Adapter, schema: DatabaseSchema): Adapter;
+    /** A reply as an App is told it: rendering and mutation state, never compiler output (app/appResponses.ts). */
+    reply(body: Record<string, unknown>): Record<string, unknown>;
+    /** A structured read's failure as an App says it (app/appErrors.ts): never a driver's message. */
+    error(err: unknown): unknown;
+    /**
+     * Who `me` is in `texts`, with the memberships they read, through this
+     * request's reader (app/appMe.ts), or nothing where no text compares with
+     * the person.
+     */
+    person(me: () => Promise<QueryPerson | null>, texts: readonly unknown[], schema: DatabaseSchema, adapter: Adapter): Promise<{
+        me?: QueryPerson | null;
+    }>;
+}
+interface ResourceReadHttpOptions {
+    /** An App's reads (AppReads), or none: the database browser's. */
+    app: AppReads | undefined;
+    now: () => Date;
+    /**
+     * Who `me` is in this request's text, read from the verified session and
+     * asked only when the text says `me` (appMe.ts). Absent — the database
+     * browser, a tenant App — `me` is the word it is.
+     */
+    me?: () => Promise<QueryPerson | null>;
+    /**
+     * The ISO weekday an App's weeks start on (its `ui.locale`, weekStart.ts),
+     * set on every breakdown in place of whatever the request said. Absent —
+     * the database browser — a request may say its own, and Monday is the default.
+     */
+    weekStart?: number;
+    /**
+     * The most rows `/api/run` answers for a table, where its reader may not
+     * export it (dataRoutes.ts, by the product's `exports.may`); undefined is no
+     * bound past the ceiling. A list's own read of 100,000 rows was an export
+     * by another name.
+     */
+    rowsMost?: (table: string) => number | undefined;
+}
+interface ResourceReadHttpReply {
+    status: number;
+    body: unknown;
+}
+/**
+ * Parse and shape the five resource-read routes using an already-authorized
+ * adapter. This owns no source acquisition, response stream or HTTP error class:
+ * escaping service validation errors retain their identity for the host to map.
+ */
+export declare function dispatchResourceReadHttp(path: string, body: Record<string, unknown>, adapter: Adapter, schema: DatabaseSchema, options: ResourceReadHttpOptions): Promise<ResourceReadHttpReply | undefined>;
+/**
+ * Which dialect writes the SQL shown in the explain panel.
+ *
+ * The adapter picks its own style when it runs the statement; this is the
+ * copy the user reads, and it has to agree with what actually ran or the
+ * panel is teaching the wrong thing.
+ */
+export declare function styleFor(schema: DatabaseSchema): SqlStyle;
+/**
+ * Coerce a JSON body into a `ViewDef`.
+ *
+ * Shape only. Whether the paths mean anything is `compileView`'s job, and it
+ * refuses what it cannot resolve — so this does not need to know the schema,
+ * and there is no second, weaker validator to disagree with the first.
+ */
+export declare function normaliseView(raw: unknown): ViewDef;
+export {};