@mistriwork/engine 0.0.0 → 1.0.0-rc.10

package/dist/server/http/firstPaint.js

@@ -0,0 +1,262 @@
+/**
+ * A first page with its data in it (shared/firstPaint.ts says why).
+ *
+ * When the shell is served for an address, the server asks itself what the
+ * page will ask first — who is here, the runtime, the App, its schema, its
+ * pages and saved views, then the first room's own reads — and writes each
+ * answer into the page, in a `<script type="application/json">` block the
+ * client reads instead of fetching. Nothing here decides what anyone may
+ * read: every answer is the reply of the route a fetch would reach, asked
+ * through the whole dispatcher (`Loop`, handler.ts) with the page request's
+ * own headers — its cookie, its proxy identity, its host — so the gate, the
+ * App's grants, a row policy and a public visitor's grant all apply exactly
+ * as they would to the fetch. A read that route refuses, fails, or answers
+ * with anything but JSON is left out, and the client asks it itself and is
+ * told in its own words.
+ *
+ * Nothing is read from the request but its address: the path and the query
+ * parameters say which room; the headers only ride along to the routes, as
+ * a fetch's would. An answer that sets a cookie (a public form's claim) is
+ * never carried — a cookie is the client's to receive from its own request
+ * — nor one whose reply says something only its headers can
+ * (`x-mistri-search`).
+ *
+ * The block is bounded (MOST): answers are written in the order the page
+ * needs them, and one that would take the page past the bound is left for
+ * the client to ask. A page that carries any answer is one person's: it is
+ * sent `private` and never stored by a shared cache (clientHttp.ts).
+ */
+import { Readable } from 'node:stream';
+import { itemKey, readKey } from '../../shared/firstPaint.js';
+import { BREAKDOWN_BATCH } from '../resourceReadHttp.js';
+import { COUNT_EACH_MAX } from '../../shared/reads.js';
+/** The most JSON a page carries, in bytes before compression: a wide catalog's schema is a third of it. */
+const MOST = 1024 * 1024;
+/**
+ * How long a page waits for its answers, in ms. The page's head and scripts
+ * are already on their way (clientHttp.ts streams it), so this is only how
+ * long the block holds the end of the page: a read that takes longer is left
+ * for the client to ask, and a slow room costs its own read, never the page.
+ */
+let BUDGET = 1500;
+/** For tests on a busy machine: how long a page waits for its answers. */
+export function setFirstPaintBudget(ms) {
+    BUDGET = ms;
+}
+/* A page request's headers that describe the navigation rather than who is
+   asking: a fetch from the page carries its own. */
+const NAVIGATION = new Set([
+    'if-none-match',
+    'if-modified-since',
+    'if-match',
+    'if-unmodified-since',
+    'if-range',
+    'range',
+    'accept',
+    'accept-encoding',
+    'content-type',
+    'content-length',
+    'transfer-encoding',
+    'origin',
+    'referer',
+    'upgrade-insecure-requests',
+    'purpose',
+    'sec-purpose',
+    'cache-control',
+    'pragma',
+    'expect',
+    'x-mistri-account',
+]);
+/**
+ * The request a fetch from this page would make: the page's own headers —
+ * its cookie, its proxy identity, its host — for the page's own origin, as
+ * `fetch` sends them (same-origin, JSON), and the body, if any. Enough of
+ * IncomingMessage for the gate, the auth store and the body reader.
+ */
+export function loopbackRequest(page, method, target, body) {
+    const payload = body === undefined ? undefined : Buffer.from(JSON.stringify(body), 'utf8');
+    const headers = {};
+    for (const [name, value] of Object.entries(page.headers)) {
+        if (value !== undefined && !NAVIGATION.has(name) && !name.startsWith('sec-fetch-'))
+            headers[name] = value;
+    }
+    Object.assign(headers, { 'sec-fetch-site': 'same-origin', 'sec-fetch-mode': 'cors', 'sec-fetch-dest': 'empty' }, payload ? { 'content-type': 'application/json', 'content-length': String(payload.length) } : {});
+    const stream = Readable.from(payload ? [payload] : []);
+    const socket = page.socket;
+    return Object.assign(stream, {
+        method,
+        url: target,
+        headers,
+        httpVersion: page.httpVersion,
+        httpVersionMajor: page.httpVersionMajor,
+        httpVersionMinor: page.httpVersionMinor,
+        complete: true,
+        aborted: false,
+        socket: {
+            remoteAddress: socket?.remoteAddress,
+            remotePort: socket?.remotePort,
+            remoteFamily: socket?.remoteFamily,
+            localAddress: socket?.localAddress,
+            localPort: socket?.localPort,
+            encrypted: socket?.encrypted,
+        },
+    });
+}
+/** The answers a page carries, in the order it needs them. */
+class Carried {
+    reads = [];
+    items = [];
+    read(method, target, body, answer) {
+        if (!answer)
+            return undefined;
+        if (!ok(answer))
+            return undefined;
+        // A placed form owns a fresh operation token. Never inline it even if a
+        // caller accidentally marks the response as carriable.
+        if (answer.body && typeof answer.body === 'object' && Object.hasOwn(answer.body, 'placement'))
+            return undefined;
+        if (answer.carriable)
+            this.reads.push([readKey(method, target, body), { body: answer.body, ...(answer.account ? { account: answer.account } : {}) }]);
+        return answer.body;
+    }
+    item(kind, owner, item, body, account) {
+        if (body && typeof body === 'object' && Object.hasOwn(body, 'placement'))
+            return;
+        this.items.push([itemKey(kind, owner, item), { body, ...(account ? { account } : {}) }]);
+    }
+    /**
+     * The block's JSON, within the bound: whatever would pass it is left for the
+     * client to ask. Each answer is serialized once, and the block is joined from
+     * those pieces: it used to be serialized to be measured and again to be sent,
+     * which was the most expensive thing a page load did on a busy server.
+     */
+    json(most) {
+        let size = 32;
+        const take = (entries) => {
+            const kept = new Map();
+            for (const [key, value] of entries) {
+                const name = JSON.stringify(key);
+                const body = JSON.stringify(value);
+                const cost = Buffer.byteLength(escapeData(name)) + Buffer.byteLength(escapeData(body)) + 2;
+                if (size + cost > most)
+                    continue;
+                kept.set(name, body);
+                size += cost;
+            }
+            return kept;
+        };
+        const reads = take(this.reads);
+        const items = take(this.items);
+        if (!reads.size && !items.size)
+            return undefined;
+        const object = (kept) => `{${[...kept].map(([name, body]) => `${name}:${body}`).join(',')}}`;
+        return `{"reads":${object(reads)},"items":${object(items)}}`;
+    }
+}
+/** A reply the client would take as an answer: a success, in JSON, that says no error. */
+function ok(answer) {
+    if (answer.status < 200 || answer.status >= 300 || answer.body === null || typeof answer.body !== 'object')
+        return false;
+    return !('error' in answer.body);
+}
+/* The most items each batch route takes at once (resourceReadHttp.ts BREAKDOWN_BATCH, shared/reads.ts COUNT_EACH_MAX). */
+const BATCH_MOST = { '/api/breakdowns': BREAKDOWN_BATCH, '/api/counts': COUNT_EACH_MAX };
+const chunks = (items, size) => {
+    const out = [];
+    for (let at = 0; at < items.length; at += size)
+        out.push(items.slice(at, at + size));
+    return out;
+};
+/**
+ * The answers for the page at `path` (its inside form, shared/mount.ts)
+ * with `search`: what boot.js asks, in its order, and then what the first
+ * room asks (`rooms`, an App's: firstPaintRooms.ts). Each round's requests
+ * are asked together.
+ */
+export async function firstPaint({ path, search, loop: asked, most = MOST, budget = BUDGET, rooms, }) {
+    const carried = new Carried();
+    /* Past the budget every answer still out is none: the client asks it. */
+    const controller = new AbortController();
+    const deadline = performance.now() + Math.max(0, budget);
+    let timer;
+    const late = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            controller.abort();
+            resolve(undefined);
+        }, Math.max(0, budget));
+    });
+    const loop = (method, target, body) => {
+        // A completed earlier stage must not launch more work after the deadline.
+        if (controller.signal.aborted || performance.now() >= deadline)
+            return Promise.resolve(undefined);
+        const answer = asked(method, target, body, controller.signal).then((value) => (performance.now() < deadline ? value : undefined), () => undefined);
+        return Promise.race([answer, late]);
+    };
+    try {
+        return await answered(carried, path, search, loop, most, rooms);
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+    }
+}
+async function answered(carried, path, search, loop, most, rooms) {
+    const ask = async (method, target, body) => carried.read(method, target, body, await loop(method, target, body));
+    const done = () => ({ json: carried.json(most) });
+    /* A page that is all its own reads is asked for before who-am-I (boot.js). */
+    const alone = rooms?.alone(path);
+    if (alone) {
+        for (const read of alone)
+            await ask(read.method, read.target, read.body);
+        return done();
+    }
+    const first = path.split('/').filter(Boolean)[0];
+    let requested = null;
+    try {
+        requested = first ? decodeURIComponent(first) : null;
+    }
+    catch {
+        return done();
+    }
+    const [me, runtime] = (await Promise.all([
+        ask('GET', requested ? `/api/whoami?${new URLSearchParams({ app: requested })}` : '/api/whoami'),
+        ask('GET', '/api/runtime'),
+    ]));
+    if (!me || !runtime || !rooms)
+        return done();
+    const room = await rooms.room({ path, search, requested, me, runtime, ask });
+    if (!room)
+        return done();
+    const { app: selected, plan } = room;
+    await Promise.all([
+        ...plan.reads.map((read) => ask(read.method, read.target, read.body)),
+        ...plan.batches.flatMap((batch) => chunks(batch.items, BATCH_MOST[batch.path]).map(async (items) => {
+            const answer = await loop('POST', batch.path, { ...batch.body, items: items.map((item) => item.sent), app: selected });
+            // Individual batch items have no response headers for the client to check.
+            // Keep them only when the batch belongs to the identity boot established.
+            const account = typeof me.accountId === 'string' ? me.accountId : undefined;
+            const results = answer && ok(answer) && answer.carriable && answer.account === account
+                ? answer.body.results
+                : undefined;
+            if (!Array.isArray(results) || results.length !== items.length)
+                return;
+            items.forEach((item, index) => {
+                const body = batch.unwrap ? batch.unwrap(results[index]) : results[index];
+                if (body !== undefined)
+                    carried.item(item.kind ?? batch.kind, selected, item.key, body, answer?.account);
+            });
+        })),
+    ]);
+    return done();
+}
+/**
+ * The data block, as the page carries it: JSON with every `<`, `>` and `&`
+ * written as its escape, and the two line separators JavaScript once took
+ * for line ends, so no value — a row's text is anybody's — can close the
+ * script element, open a comment inside it, or be read as markup.
+ */
+export function firstPaintBlock(id, json) {
+    return `<script type="application/json" id="${id}">${escapeData(json)}</script>`;
+}
+/** Count the same escaped UTF-8 bytes that will be sent, including hostile text. */
+const escapeData = (json) => json.replace(/[<>&\u2028\u2029]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);

package/dist/server/http/httpOperationRoutes.d.ts

@@ -0,0 +1,11 @@
+import type { PostContext } from './context.js';
+/** Why this request cannot try an API, or undefined when it can. */
+export declare function operationRefusal(request: {
+    appConfigured: boolean;
+    dialect: string;
+    rowsKept: boolean;
+}): {
+    status: number;
+    error: string;
+} | undefined;
+export declare function httpOperationRoutes(post: PostContext): Promise<boolean>;

package/dist/server/http/httpOperationRoutes.js

@@ -0,0 +1,50 @@
+import { send } from './reply.js';
+const DESCRIBE = '/api/http/operations';
+const TRY = '/api/http/operation';
+/** Why this request cannot try an API, or undefined when it can. */
+export function operationRefusal(request) {
+    if (request.appConfigured)
+        return { status: 403, error: 'Trying an API is part of the database browser; an application does not offer it.' };
+    if (request.dialect !== 'http')
+        return { status: 400, error: 'This connection is a database, not an API, so it has no operations to try.' };
+    if (request.rowsKept)
+        return {
+            status: 403,
+            error: 'This connection keeps its rows in ("rows": false), and an API\'s answer is rows, so it is not tried here.',
+        };
+    return undefined;
+}
+const isParams = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) && Object.values(value).every((each) => typeof each === 'string');
+export async function httpOperationRoutes(post) {
+    const { res, path, body, adapter, schema, registry, connection, appConfigured } = post;
+    if (path !== DESCRIBE && path !== TRY)
+        return false;
+    const refused = operationRefusal({ appConfigured, dialect: schema.dialect, rowsKept: registry.configOf(connection)?.rows === false });
+    if (refused) {
+        send(res, refused.status, { error: refused.error });
+        return true;
+    }
+    const api = adapter;
+    if (typeof api.operations !== 'function' || typeof api.operation !== 'function') {
+        send(res, 501, { error: 'This connection cannot describe its API operations in this build.' });
+        return true;
+    }
+    const resource = String(body.resource ?? '');
+    // Refusals (an unknown resource, an undeclared parameter) and API failures throw, and server.ts maps them.
+    if (path === DESCRIBE) {
+        send(res, 200, api.operations.call(adapter, resource));
+        return true;
+    }
+    const kind = body.operation;
+    if (kind !== 'list' && kind !== 'item') {
+        send(res, 400, { error: 'An operation is "list" or "item".' });
+        return true;
+    }
+    const params = body.params ?? {};
+    if (!isParams(params)) {
+        send(res, 400, { error: "An operation's parameters are names and text values." });
+        return true;
+    }
+    send(res, 200, await api.operation.call(adapter, resource, kind, params));
+    return true;
+}

package/dist/server/http/pageReads.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The GET routes both products serve that shape a page rather than read its
+ * rows: what could point at a table, its suggested page, the stored record
+ * layouts and saved pages, and a list's saved filters.
+ *
+ * What a product decides of them is `PageReadHooks`: the page a table opens
+ * on when nobody wrote one (an App's record anatomy, the database browser's
+ * counts and lists), and whether the App signs people in, whose filters are
+ * then each account's own.
+ */
+import { type PageDef } from '../../shared/page.js';
+import { type DatabaseSchema } from '../../shared/schema.js';
+import type { RequestContext, ResolvedSource } from './context.js';
+export interface PageReadHooks {
+    /** A table's page when nobody wrote one. */
+    suggested(source: ResolvedSource, schema: DatabaseSchema, table: string): PageDef | null;
+    /** Whether the App this source belongs to signs people in. */
+    signsIn(ctx: RequestContext, source: ResolvedSource): boolean;
+}
+export declare function pageReadRoutes(ctx: RequestContext, source: ResolvedSource, hooks: PageReadHooks): Promise<boolean>;

package/dist/server/http/pageReads.js

@@ -0,0 +1,205 @@
+/**
+ * The GET routes both products serve that shape a page rather than read its
+ * rows: what could point at a table, its suggested page, the stored record
+ * layouts and saved pages, and a list's saved filters.
+ *
+ * What a product decides of them is `PageReadHooks`: the page a table opens
+ * on when nobody wrote one (an App's record anatomy, the database browser's
+ * counts and lists), and whether the App signs people in, whose filters are
+ * then each account's own.
+ */
+import { defaultColumns, metricColumns, relationsTo, resolvePath } from '../../shared/page.js';
+import { filtersPath, filtersSection, layoutsFor, pagesPath } from '../layouts.js';
+import { referencesFrom, referencesTo, findTable, tableNamed } from '../../shared/schema.js';
+import { send } from './reply.js';
+export async function pageReadRoutes(ctx, source, hooks) {
+    const { res, url, path, configLayouts, identity, policyContext } = ctx;
+    const { schema, access, connectionId, publicScope } = source;
+    /**
+     * The page for a table nobody has written one for.
+     *
+     * Asked for by table rather than shipped with the list, because it is
+     * derived from the schema and the client has the schema — but the rule that
+     * derives it lives in shared/page.ts, and a second copy in the browser is
+     * the drift this codebase has paid for repeatedly.
+     */
+    /**
+     * What a page about this table could show.
+     *
+     * The path is the one field nobody guesses when writing a page by hand, so
+     * the builder does not ask for it — it asks the schema what points here and
+     * offers the answers with their paths already written. Computed on the
+     * server because the rules that resolve a path live in shared/page.ts, and
+     * a second copy of them in the browser is the drift this codebase has paid
+     * for in every feature that tried it.
+     */
+    if (path === '/api/pages/relations') {
+        const table = String(url.searchParams.get('table') ?? '');
+        if (!findTable(schema, table)) {
+            send(res, 404, { error: `Unknown table "${table}"` });
+            return true;
+        }
+        const relations = relationsTo(schema, table);
+        const describe = (r) => ({
+            ...r,
+            /* Numeric columns, for what a `sum` could be about. */
+            columns: metricColumns(schema, r.from),
+            defaults: defaultColumns(findTable(schema, r.from), r.path, resolvePath(schema, r.from, r.path).path),
+            all: findTable(schema, r.from).columns.map((c) => c.name),
+        });
+        /* What points at each record this table points at, one reference out.
+    
+           This is how a work-order page offers "tickets at its site": the site is
+           not the root, but the root names it, and the schema knows what points
+           at a site. Direct relations only — the two-hop tail on a foreign
+           record is a menu nobody has asked for yet. */
+        const references = referencesFrom(schema, table)
+            .filter((fk) => fk.to.table !== table && findTable(schema, fk.to.table))
+            .map((fk) => {
+            const target = findTable(schema, fk.to.table);
+            return {
+                of: fk.from.columns.length === 1 ? fk.from.columns[0] : fk.name,
+                target: target.id,
+                targetName: target.name,
+                via: fk.from.columns.join(', '),
+                relations: relationsTo(schema, target.id, 1).map(describe),
+            };
+        })
+            .filter((ref) => ref.relations.length);
+        send(res, 200, {
+            ...publicScope,
+            references,
+            relations: relations.map((r) => ({
+                ...r,
+                /* Numeric columns, for what a `sum` could be about. */
+                columns: metricColumns(schema, r.from),
+                /* And what a list of this relation shows when nobody has said —
+                   computed here, with the resolved path, because the rule that drops
+                   the constant column is the same one the planner uses. A builder
+                   that guessed at it would be a copy, and the copy would be the one
+                   that forgot composite keys. */
+                defaults: defaultColumns(findTable(schema, r.from), r.path, resolvePath(schema, r.from, r.path).path),
+                /* Every column, so the picker can offer the ones the default leaves
+                   out without a second request. */
+                all: findTable(schema, r.from).columns.map((c) => c.name),
+            })),
+        });
+        return true;
+    }
+    if (path === '/api/pages/suggested') {
+        const table = String(url.searchParams.get('table') ?? '');
+        /* Two different failures, and they had one message between them: a table
+           this connection does not have was reported as a table without a primary
+           key, which sends the reader looking for a key on something that is not
+           there. */
+        if (!findTable(schema, table)) {
+            send(res, 404, { error: `Unknown table "${table}"` });
+            return true;
+        }
+        /* An App's resource with no page of its own opens on the record anatomy
+           (pageAnatomy.ts), dressed in the App's words; the Workbench keeps its
+           page of counts and lists, the database as it is. */
+        const suggested = hooks.suggested(source, schema, table);
+        if (!suggested) {
+            send(res, 404, {
+                error: `No page can be built for "${table}" — it needs a primary key to identify a record by.`,
+            });
+            return true;
+        }
+        send(res, 200, { ...publicScope, page: suggested });
+        return true;
+    }
+    /**
+     * Every stored record layout for this connection.
+     *
+     * Sent as a set rather than one at a time: the client needs to know which
+     * tables have a layout to render the "Layout" affordance honestly, and a
+     * request per table would be one round trip per row you walk to.
+     */
+    if (path === '/api/layouts') {
+        if (access) {
+            send(res, 200, { ...publicScope, layouts: {} });
+            return true;
+        }
+        const saved = await layoutsFor(connectionId);
+        /* Config layouts fill in for tables nobody has laid out here, and never
+           over one somebody has. A committed layout is the default a team starts
+           from; the copy in this browser is what its reader chose afterwards, and
+           silently replacing that would make the config file feel like it was
+           fighting them. */
+        const merged = { ...saved };
+        for (const layout of configLayouts) {
+            if (layout.connection && layout.connection !== connectionId)
+                continue;
+            const table = tableNamed(schema, layout.table);
+            if (!table)
+                continue;
+            if (merged[table.id])
+                continue;
+            merged[table.id] = resolveConfigLayout(schema, table.id, layout);
+        }
+        send(res, 200, { ...publicScope, layouts: merged });
+        return true;
+    }
+    /** Every page saved for this connection, from the same kind of file. */
+    if (path === '/api/pages/saved') {
+        send(res, 200, { ...publicScope, pages: access ? {} : await layoutsFor(connectionId, pagesPath()) });
+        return true;
+    }
+    /**
+     * The saved list filters — an App list's saved views, list → [{name, query}]
+     * — and whose they are (`store`): the list the connection shares, the
+     * signed-in account's own, or none where nothing may be kept.
+     */
+    if (path === '/api/filters') {
+        const account = typeof identity.id === 'string' ? identity.id : undefined;
+        const section = filtersSection(connectionId, { signIn: hooks.signsIn(ctx, source), account, rowPolicy: Boolean(policyContext) });
+        const store = section === null ? 'none' : section === connectionId ? 'shared' : 'account';
+        send(res, 200, { ...publicScope, store, filters: section === null ? {} : await layoutsFor(section, filtersPath()) });
+        return true;
+    }
+    return false;
+}
+/**
+ * A config layout, with its list sections keyed the way the client expects.
+ *
+ * A list is stored against the constraint name of the foreign key pointing
+ * back at the record — the right key, because a child can point at a parent
+ * twice and the column alone would not say which — and the wrong thing to ask
+ * anyone to type into a file. So a config may name the pair instead
+ * (`"from": "invoice", "whose": "customer_id"`, parsed to the internal
+ * `path`) and it is turned into the constraint here, where there is a schema
+ * to turn it with.
+ *
+ * A pair that names no real relationship keeps its section and gains an
+ * `error`, rather than disappearing: the same choice `/api/views` makes for a
+ * view that will not compile. A layout that silently lost a list is a layout
+ * nobody can debug.
+ */
+function resolveConfigLayout(schema, tableId, layout) {
+    const incoming = referencesTo(schema, tableId);
+    const sections = layout.sections.map((section) => {
+        if (section.kind !== 'list' || section.via)
+            return section;
+        const from = String(section.from ?? '');
+        const column = String(section.path ?? '');
+        const child = tableNamed(schema, from);
+        const match = child && incoming.find((fk) => fk.from.table === child.id && fk.from.columns.some((c) => c.toLowerCase() === column.toLowerCase()));
+        const { from: _from, path: _path, ...rest } = section;
+        if (!match) {
+            return {
+                ...rest,
+                via: '',
+                error: `No foreign key from ${from}.${column} back to ${tableId}` + `${child ? '' : ` — and no table called "${from}"`}.`,
+            };
+        }
+        return { ...rest, via: match.name };
+    });
+    return {
+        id: `config-${layout.table}`,
+        name: layout.name ?? 'From config',
+        base: tableId,
+        sections,
+        source: 'config',
+    };
+}

package/dist/server/http/pageRoutes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The POST routes both products serve that plan or keep rather than change
+ * data: a page's section plans, a record's incoming references, and a list's
+ * saved filters.
+ *
+ * What an App decides of them is `PageRules` (mistri: http/appAuthoring.ts):
+ * whether its reader's fields reach a page, the record a row policy admits,
+ * whether it signs people in (whose filters are each account's own), and its
+ * failures said by code. The database browser plans what its connection
+ * reads, and says a failure in the database's words.
+ */
+import type { Adapter } from '../../adapters/adapter.js';
+import { type PageDef } from '../../shared/page.js';
+import { type DatabaseSchema } from '../../shared/schema.js';
+import type { PostContext } from './context.js';
+/** An App's rules for the page routes. Absent, the database browser's. */
+interface PageRules {
+    /** Whether the App this request names signs people in: its saved filters are then each account's own. */
+    signsIn(post: PostContext): boolean;
+    /** Whether a reader whose grant names fields reads every field `page` shows (appFieldProjection.ts). */
+    readsPage(schema: DatabaseSchema, page: PageDef): boolean;
+    /** The record a row policy admits, or a refusal (appPolicyHttp.ts). */
+    requireRecord(adapter: Adapter, schema: DatabaseSchema, table: string, key: Record<string, string | number>): Promise<unknown>;
+    /** The record's own row, read as a row policy admits it, with the columns asked. */
+    readRecord(adapter: Adapter, schema: DatabaseSchema, table: string, key: Record<string, string | number>, columns: string[]): Promise<Record<string, unknown>>;
+    /** A failure said by code, never in a driver's words (appErrors.ts). */
+    said(error: unknown): {
+        message: string;
+        code: string;
+    };
+}
+/** What a product decides of the page routes. */
+export interface PageHooks {
+    /** A table's suggested page (`suggested:<table>`): the App's anatomy of it, or the schema's. */
+    suggested(post: PostContext, table: string): PageDef | null;
+    readonly rules?: PageRules;
+}
+export declare function pageRoutes(post: PostContext, hooks: PageHooks): Promise<boolean>;
+export {};