@agentshouse/mdruntime 0.1.0-cd50a4607cb7d → 0.1.0-cd574a610e9c8

package/dist/compile.js

@@ -0,0 +1,723 @@
+import { ARRAY_INDEX, bodied, byCodePoint, compared, cursorOf, heldKind, parse, pointerSegments, sql, } from '@agentshouse/mdmodel';
+import { binaryRecord } from './binary.js';
+import { definitionsAt, UNTYPED } from './collection.js';
+import { documentKey, pathOfKey, roomOfKey } from './rows.js';
+import { FROM_START, MAXIMUM_WINDOW } from './windows.js';
+const { all, any, exists, fragment, grouped, joined, listed } = sql;
+export const VISIBLE = (alias) => `${alias}.visible = 1 AND ${alias}.present = 1`;
+function located(alias) {
+    return fragment(`(SELECT k.locator FROM replica_keys k WHERE k.key = ${alias}.key)`);
+}
+export function within(alias, path) {
+    return fragment(`(${alias}.path = ? OR (${alias}.path >= ? AND ${alias}.path < ?))`, [
+        path,
+        `${path}/`,
+        `${path}0`,
+    ]);
+}
+function ancestors(area) {
+    const depth = area.path.split('/').length;
+    return area.open.flatMap((open) => {
+        const segments = open.split('/');
+        return segments.slice(depth - 1, -1).map((_, at) => segments.slice(0, depth + at).join('/'));
+    });
+}
+function fenced(alias, key, area, folders) {
+    const opened = any([
+        ...area.open.map((open) => within(alias, open)),
+        ...(folders ? ancestors(area).map((path) => fragment(`${alias}.path = ?`, [path])) : []),
+    ]);
+    return all([
+        fragment(`${alias}.key = ?`, [key]),
+        within(alias, area.path),
+        fragment(`NOT ${grouped(opened).sql}`, opened.bind),
+    ]);
+}
+function reached(bound, alias) {
+    const reach = bound.reach;
+    if (reach === null)
+        return fragment('1');
+    const rooms = reach.rooms.flatMap((locator) => {
+        const key = bound.keys.get(locator);
+        return key === undefined ? [] : [key];
+    });
+    const documents = reach.documents.flatMap((held) => {
+        const key = bound.keys.get(roomOfKey(held));
+        return key === undefined ? [] : [[key, pathOfKey(held)]];
+    });
+    const outside = any(reach.areas.flatMap((area) => {
+        const key = bound.keys.get(area.room);
+        return key === undefined ? [] : [fenced(alias, key, area, false)];
+    }));
+    return all([
+        any([
+            ...(rooms.length === 0 ? [] : [fragment(`${alias}.key IN ${listed(rooms).sql}`, rooms)]),
+            ...(documents.length === 0
+                ? []
+                : [
+                    fragment(`EXISTS (SELECT 1 FROM json_each(?) j WHERE j.value ->> 0 = ${alias}.key AND j.value ->> 1 = ${alias}.path)`, [JSON.stringify(documents)]),
+                ]),
+        ]),
+        ...(reach.areas.length === 0 ? [] : [fragment(`NOT ${grouped(outside).sql}`, outside.bind)]),
+    ]);
+}
+function related(bound, plan) {
+    const parts = [];
+    if (plan.hop !== null) {
+        parts.push(exists(joined([
+            fragment(`SELECT 1 FROM replica_links l JOIN replica_entries m ON m.key = d.key AND m.path = l.target AND ${VISIBLE('m')} WHERE l.doc = d.id AND l.kind = 'field' AND`),
+            grouped(sql.placed('l', plan.hop.field, 'link')),
+            fragment('AND'),
+            grouped(all([sql.scoped('m', plan.hop), reached(bound, 'm')])),
+        ], ' ')));
+    }
+    if (plan.backlinks !== null) {
+        const field = plan.backlinks.field;
+        parts.push(exists(joined([
+            fragment(`SELECT 1 FROM replica_links l JOIN replica_entries s ON s.id = l.doc AND ${VISIBLE('s')} WHERE l.key = d.key AND l.target = d.path AND l.kind = 'field' AND`),
+            ...(field === null ? [] : [grouped(sql.placed('l', field, 'link')), fragment('AND')]),
+            grouped(all([sql.scoped('s', plan.backlinks), reached(bound, 's')])),
+        ], ' ')));
+    }
+    return parts;
+}
+function filtered(bound, plan) {
+    const keys = bound.rooms.map(({ key }) => key);
+    return all([
+        fragment(`d.key IN ${listed(keys).sql} AND ${VISIBLE('d')}`, keys),
+        reached(bound, 'd'),
+        sql.tests('d', plan),
+        ...related(bound, plan),
+    ]);
+}
+function orderingOf(options) {
+    const stringSort = options.stringSort ?? 'locale';
+    const collated = stringSort === 'locale';
+    return {
+        direction: options.direction,
+        nulls: options.nulls ?? 'first',
+        stringSort,
+        locale: collated ? options.locale : undefined,
+        localeOptions: collated
+            ? options.localeOptions
+            : undefined,
+    };
+}
+const GROUP_ORDER = {
+    direction: 'asc',
+    nulls: 'first',
+    stringSort: 'locale',
+    locale: undefined,
+    localeOptions: undefined,
+};
+const GROUP_TIES = {
+    direction: 'asc',
+    nulls: 'last',
+    stringSort: 'lexical',
+    locale: undefined,
+    localeOptions: undefined,
+};
+const GREATEST = { ...GROUP_ORDER, direction: 'desc', nulls: 'last' };
+const TIMES = {
+    created: { value: 'd.created', instant: 'd.created_instant' },
+    updated: { value: "(d.change ->> '$.time')", instant: 'd.changed_instant' },
+};
+function subfolderOf(column, prefix) {
+    const root = prefix ?? '';
+    const base = root === '' ? '' : `${root}/`;
+    const rest = `substr(${column}, length(?) + 1)`;
+    return fragment(`(CASE WHEN ${column} = ? THEN NULL WHEN instr(${rest}, '/') = 0 THEN ${column} ELSE ? || substr(${rest}, 1, instr(${rest}, '/') - 1) END)`, [root, base, base, base, base]);
+}
+function keyTerm(key, ordering, index, prefix) {
+    if (key.of === 'field') {
+        const alias = `o${index}`;
+        return {
+            term: {
+                ordering,
+                kind: fragment(`${alias}.kind`),
+                value: fragment(`${alias}.value`),
+                instant: fragment(`${alias}.instant`),
+            },
+            join: joined([
+                fragment(`LEFT JOIN replica_values ${alias} ON ${alias}.doc = d.id AND `),
+                grouped(sql.placed(alias, key.field, 'exact')),
+                fragment(` AND ${alias}.item = -1 AND ${alias}.kind NOT IN ('object', 'undefined')`),
+            ], ''),
+        };
+    }
+    if (key.of === 'size') {
+        return {
+            term: {
+                ordering,
+                kind: fragment("(CASE WHEN d.bytes IS NULL THEN 'null' ELSE 'number' END)"),
+                value: fragment('d.bytes'),
+            },
+            join: null,
+        };
+    }
+    if (key.of === 'created' || key.of === 'updated') {
+        const { value, instant } = TIMES[key.of];
+        return {
+            term: {
+                ordering,
+                kind: fragment(`(CASE WHEN ${value} IS NULL THEN 'null' ELSE 'string' END)`),
+                value: fragment(value),
+                instant: fragment(instant),
+            },
+            join: null,
+        };
+    }
+    const expression = key.of === 'room'
+        ? located('d')
+        : key.of === 'path'
+            ? fragment('d.path')
+            : key.of === 'type'
+                ? fragment('d.type')
+                : key.of === 'subfolder'
+                    ? subfolderOf('d.folder', prefix)
+                    : fragment('d.folder');
+    return {
+        term: {
+            ordering,
+            kind: fragment(`(CASE WHEN ${expression.sql} IS NULL THEN 'null' ELSE 'string' END)`, expression.bind),
+            value: expression,
+        },
+        join: null,
+    };
+}
+function decoded(kind, value) {
+    if (kind === 'string')
+        return value;
+    if (kind === 'number')
+        return typeof value === 'bigint' ? Number(value) : value;
+    if (kind === 'boolean')
+        return Number(value) === 1;
+    if (kind === 'array')
+        return JSON.parse(value);
+    return null;
+}
+function sortedOf(kind, value, instant) {
+    return sql.sortValue(kind, decoded(kind, value), instant);
+}
+function sortedValue(row, index) {
+    return sortedOf(row[`k${index}`], row[`v${index}`], row[`i${index}`]);
+}
+function decodedKey(key, row, index) {
+    const kind = row[`k${index}`];
+    if (key.of === 'field' && (kind === null || kind === undefined))
+        return undefined;
+    return sortedValue(row, index);
+}
+function instantOf(term) {
+    return term.instant ?? fragment('NULL');
+}
+const registered = new WeakMap();
+function hashed(text) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}
+function collating(connection) {
+    let held = registered.get(connection);
+    if (held === undefined) {
+        held = new Set();
+        registered.set(connection, held);
+    }
+    const names = held;
+    return (ordering, lists, total) => {
+        if (!lists && ordering.stringSort !== 'locale')
+            return null;
+        const inner = lists
+            ? {
+                ...ordering,
+                direction: 'asc',
+                nulls: ordering.direction === 'desc'
+                    ? ordering.nulls === 'first'
+                        ? 'last'
+                        : 'first'
+                    : ordering.nulls,
+            }
+            : ordering;
+        const spec = JSON.stringify([
+            lists,
+            total,
+            inner.nulls,
+            inner.stringSort,
+            inner.locale ?? null,
+            inner.localeOptions ?? null,
+        ]);
+        const name = `mdr_${lists ? 'l' : 's'}${hashed(spec)}`;
+        if (!names.has(name)) {
+            const collator = new Intl.Collator(inner.locale, inner.localeOptions);
+            connection.collate(name, lists
+                ? (left, right) => Math.sign(compared(JSON.parse(left), JSON.parse(right), inner)) || (total ? Math.sign(byCodePoint(left, right)) : 0)
+                : (left, right) => Math.sign(collator.compare(left, right)));
+            names.add(name);
+        }
+        return name;
+    };
+}
+function masked(pointers) {
+    const root = { whole: false, members: new Map() };
+    for (const pointer of pointers) {
+        let mask = root;
+        for (const token of pointerSegments(pointer)) {
+            const next = mask.members.get(token) ?? { whole: false, members: new Map() };
+            mask.members.set(token, next);
+            mask = next;
+        }
+        mask.whole = true;
+    }
+    return root;
+}
+function merged(left, right) {
+    if (left === undefined)
+        return right;
+    const members = new Map(left.members);
+    for (const [token, mask] of right.members)
+        members.set(token, merged(members.get(token), mask));
+    return { whole: left.whole || right.whole, members };
+}
+function cut(value, mask) {
+    if (mask.whole)
+        return value;
+    if (Array.isArray(value)) {
+        const each = {
+            whole: false,
+            members: new Map([...mask.members].filter(([token]) => !ARRAY_INDEX.test(token))),
+        };
+        const kept = [];
+        value.forEach((item, index) => {
+            const part = cut(item, merged(mask.members.get(String(index)), each));
+            if (part !== undefined)
+                kept[index] = part;
+        });
+        return kept.length === 0 ? undefined : kept;
+    }
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const kept = Object.entries(value).flatMap(([key, held]) => {
+        const member = mask.members.get(key);
+        const part = member === undefined ? undefined : cut(held, member);
+        return part === undefined ? [] : [[key, part]];
+    });
+    return kept.length === 0 ? undefined : Object.fromEntries(kept);
+}
+function sectionsOf(sections, names) {
+    if (names === 'all')
+        return sections;
+    return Object.fromEntries(names.flatMap((name) => (Object.hasOwn(sections, name) ? [[name, sections[name]]] : [])));
+}
+function freeParts(room, path, type, content) {
+    const definitions = room.composition === undefined ? undefined : definitionsAt(room.composition, path);
+    const definition = definitions?.(type === UNTYPED ? undefined : type);
+    if (definition === undefined && type !== UNTYPED)
+        return null;
+    const read = parse(content, path, definition);
+    return read.ok ? read.document : null;
+}
+function documentOf(shape, queried, row, linked) {
+    const room = queried.locator;
+    const path = row.path;
+    const type = row.type;
+    const fileId = row.file_id;
+    const revision = row.revision;
+    if (type === null) {
+        const binary = row.binary === null ? null : JSON.parse(row.binary);
+        const content = row.content ?? null;
+        return {
+            room,
+            path,
+            ...(binary === null
+                ? {}
+                : {
+                    binaryFile: binaryRecord(path, binary, revision ?? undefined),
+                }),
+            ...(shape.markdown && content !== null ? { markdown: content } : {}),
+            ...(shape.change ? { change: changeOf(row) } : {}),
+            ...(shape.fileId ? { fileId } : {}),
+            ...(shape.revision ? { revision } : {}),
+            ...heldFacts(shape, row),
+        };
+    }
+    const body = shape.sections !== null || shape.preamble
+        ? freeParts(queried, path, type, row.content)
+        : null;
+    const fields = JSON.parse(row.fields ?? '{}');
+    return {
+        room,
+        path,
+        type,
+        ...(shape.fields === null
+            ? {}
+            : {
+                fields: shape.fields === 'all'
+                    ? fields
+                    : (cut(fields, masked(shape.fields)) ?? {}),
+            }),
+        ...(shape.sections === null || body === null
+            ? {}
+            : { sections: sectionsOf(body.sections, shape.sections) }),
+        ...(shape.preamble && body !== null ? { preamble: body.preamble } : {}),
+        ...(shape.markdown ? { markdown: row.content } : {}),
+        ...(shape.backlinks ? { backlinks: linked.get(documentKey(room, path)) ?? [] } : {}),
+        ...(shape.change ? { change: changeOf(row) } : {}),
+        ...(shape.fileId ? { fileId } : {}),
+        ...(shape.revision ? { revision } : {}),
+        ...heldFacts(shape, row),
+    };
+}
+function changeOf(row) {
+    return row.change === null ? null : JSON.parse(row.change);
+}
+function heldFacts(shape, row) {
+    return {
+        ...(shape.size ? { size: row.bytes === null ? null : Number(row.bytes) } : {}),
+        ...(shape.created ? { created: row.created } : {}),
+    };
+}
+function backlinksOf(connection, bound, rows) {
+    const linked = new Map();
+    const byKey = new Map();
+    for (const row of rows) {
+        const key = Number(row.key);
+        const held = byKey.get(key) ?? [];
+        held.push(row.path);
+        byKey.set(key, held);
+    }
+    const reach = reached(bound, 's');
+    for (const [key, targets] of byKey) {
+        const room = bound.rooms.find((one) => one.key === key).locator;
+        const found = connection.rows(`SELECT target, path, type, field FROM (SELECT l.target, s.path, s.type, l.field, ROW_NUMBER() OVER (PARTITION BY l.target ORDER BY s.path, l.field) AS rank FROM (SELECT DISTINCT doc, target, field FROM replica_links WHERE key = ? AND kind = 'field' AND target IN (SELECT value FROM json_each(?))) l JOIN replica_entries s ON s.id = l.doc AND ${VISIBLE('s')} WHERE ${reach.sql}) WHERE rank <= ? ORDER BY target, path, field`, [key, JSON.stringify(targets), ...reach.bind, MAXIMUM_WINDOW]);
+        for (const row of found) {
+            const at = documentKey(room, row.target);
+            const held = linked.get(at) ?? [];
+            held.push({ path: row.path, type: row.type, field: row.field });
+            linked.set(at, held);
+        }
+    }
+    return linked;
+}
+function documents(connection, bound, plan, shape, budget) {
+    const terms = shape.orderBy.map(({ key, options }, index) => keyTerm(key, orderingOf(options), index, plan.root.pathPrefix));
+    const filter = filtered(bound, plan);
+    const cursor = plan.after?.values ?? null;
+    const room = located('d');
+    const after = cursor === null
+        ? null
+        : (() => {
+            const key = cursor[shape.orderBy.length];
+            return sql.following(terms.map(({ term }, index) => sql.beyond(bound.collate, term, cursor[index])), any([
+                fragment(`${room.sql} > ?`, [...room.bind, roomOfKey(key)]),
+                fragment(`${room.sql} = ? AND d.path > ?`, [
+                    ...room.bind,
+                    roomOfKey(key),
+                    pathOfKey(key),
+                ]),
+            ]));
+        })();
+    const selected = joined([
+        fragment('SELECT d.id, d.key, d.path, d.type, d.binary, d.revision, d.fields, d.change, d.file_id, d.bytes, d.created'),
+        ...terms.map(({ term }, index) => joined([
+            fragment(`, ${term.kind.sql} AS k${index}`, term.kind.bind),
+            fragment(`, ${term.value.sql} AS v${index}`, term.value.bind),
+            fragment(`, ${instantOf(term).sql} AS i${index}`, instantOf(term).bind),
+        ], '')),
+        fragment(' FROM replica_entries d'),
+        ...terms.flatMap(({ join }) => (join === null ? [] : [fragment(' '), join])),
+        fragment(' WHERE '),
+        after === null ? filter : all([filter, after]),
+        fragment(' ORDER BY '),
+        joined([...terms.map(({ term }) => sql.sorted(bound.collate, term)), room, fragment('d.path')], ', '),
+        ...(plan.limit === null ? [] : [fragment(' LIMIT ?', [plan.limit + 1])]),
+    ], '');
+    const rows = connection.rows(selected.sql, selected.bind);
+    const windowed = plan.limit === null ? rows : rows.slice(0, plan.limit);
+    const kept = bodied(shape) ? withContent(connection, windowed, budget) : windowed;
+    const cut = kept.length;
+    const roomOf = new Map(bound.rooms.map(({ key, locator }) => [key, locator]));
+    const queried = new Map(bound.rooms.map((one) => [one.key, one]));
+    const linked = shape.backlinks ? backlinksOf(connection, bound, kept) : new Map();
+    const found = kept.map((row) => documentOf(shape, queried.get(Number(row.key)), row, linked));
+    const last = kept.at(-1);
+    const cursorAt = (row) => cursorOf([
+        ...shape.orderBy.map(({ key }, index) => decodedKey(key, row, index)),
+        documentKey(roomOf.get(Number(row.key)), row.path),
+    ]);
+    const more = cut < windowed.length && last !== undefined ? cursorAt(last) : undefined;
+    const next = more !== undefined || plan.limit === null || rows.length <= plan.limit
+        ? undefined
+        : last === undefined
+            ? (plan.after?.text ?? FROM_START)
+            : cursorAt(last);
+    const total = plan.total
+        ? (() => {
+            const counted = joined([fragment('SELECT count(*) AS held FROM replica_entries d WHERE '), filter], '');
+            return Number(connection.rows(counted.sql, counted.bind)[0].held);
+        })()
+        : undefined;
+    return {
+        documents: found,
+        ...(next === undefined ? {} : { next }),
+        ...(more === undefined ? {} : { more }),
+        ...(total === undefined ? {} : { total }),
+    };
+}
+function withContent(connection, rows, budget) {
+    if (rows.length === 0)
+        return rows;
+    const ids = rows.map((row) => row.id);
+    const sizes = new Map(connection
+        .rows(`SELECT id, octet_length(content) AS size FROM replica_entries WHERE id IN ${listed(ids).sql}`, ids)
+        .map((row) => [row.id, Number(row.size ?? 0)]));
+    let cut = rows.length;
+    let spent = 0;
+    for (let at = 0; budget !== null && at < rows.length; at += 1) {
+        const size = sizes.get(rows[at].id) ?? 0;
+        if (at > 0 && spent + size > budget) {
+            cut = at;
+            break;
+        }
+        spent += size;
+    }
+    const kept = rows.slice(0, cut);
+    const read = kept.map((row) => row.id);
+    const held = new Map(connection
+        .rows(`SELECT id, content FROM replica_entries WHERE id IN ${listed(read).sql}`, read)
+        .map((row) => [row.id, row.content]));
+    return kept.map((row) => ({ ...row, content: held.get(row.id) ?? null }));
+}
+function storedFolders(bound, plan, subfolder) {
+    if (plan.paths !== null || plan.fileIds !== null)
+        return null;
+    if (plan.hop !== null || plan.backlinks !== null)
+        return null;
+    if (subfolder && plan.folder !== null)
+        return null;
+    const whole = bound.rooms.filter(({ locator }) => bound.reach === null || bound.reach.rooms.includes(locator));
+    if (whole.length === 0)
+        return null;
+    const keys = whole.map(({ key }) => key);
+    const prefix = plan.root.pathPrefix ?? '';
+    const outside = (bound.reach?.areas ?? []).flatMap((area) => {
+        const key = bound.keys.get(area.room);
+        if (key === undefined)
+            return [];
+        const fence = fenced('f', key, area, true);
+        return [fragment(`NOT ${grouped(fence).sql}`, fence.bind)];
+    });
+    const under = prefix === ''
+        ? subfolder
+            ? [fragment("f.path <> ''")]
+            : []
+        : [
+            subfolder
+                ? fragment('(f.path >= ? AND f.path < ?)', [`${prefix}/`, `${prefix}0`])
+                : within('f', prefix),
+        ];
+    return all([
+        fragment(`f.key IN ${listed(keys).sql} AND f.layer = 0 AND f.present = 1`, keys),
+        ...outside,
+        ...under,
+        ...(plan.outside ?? []).map((folder) => fragment(`NOT ${within('f', folder).sql}`, within('f', folder).bind)),
+        ...(plan.folder === null ? [] : [fragment('f.path = ?', [plan.folder])]),
+    ]);
+}
+const SIZES = [
+    'CASE WHEN d.binary IS NULL THEN 1 ELSE 0 END AS dn',
+    'CASE WHEN d.binary IS NULL THEN d.bytes ELSE 0 END AS ds',
+    'CASE WHEN d.binary IS NULL THEN 0 ELSE 1 END AS fn',
+    'CASE WHEN d.binary IS NULL THEN 0 ELSE d.bytes END AS fs',
+];
+const LATEST = "d.changed_instant || ' ' || (d.change ->> '$.time') AS u";
+function greatestTerm(ordering) {
+    return { ordering, kind: fragment('gk'), value: fragment('gv'), instant: fragment('gi') };
+}
+function latestOf(held) {
+    if (typeof held !== 'string')
+        return null;
+    return held.slice(held.indexOf(' ') + 1);
+}
+function groups(connection, bound, plan, shape) {
+    const prefix = plan.root.pathPrefix;
+    const keyed = shape.groupBy.map((key, index) => {
+        const { term, join } = keyTerm(key, GROUP_ORDER, index, prefix);
+        const kind = fragment(`COALESCE(${term.kind.sql}, 'null')`, term.kind.bind);
+        return { term: { ...term, kind }, join };
+    });
+    const ordering = shape.orderBy.map(({ by }) => by);
+    const sized = shape.size || ordering.includes('size');
+    const dated = shape.updated || ordering.includes('updated');
+    const greatest = shape.greatest === null
+        ? null
+        : keyTerm({ of: 'field', field: shape.greatest }, GREATEST, keyed.length, prefix);
+    const filter = filtered(bound, plan);
+    const inner = joined([
+        fragment('SELECT '),
+        joined(keyed.map(({ term }, index) => joined([
+            fragment(`${term.kind.sql} AS k${index}`, term.kind.bind),
+            fragment(`, ${term.value.sql} AS v${index}`, term.value.bind),
+            fragment(`, ${instantOf(term).sql} AS i${index}`, instantOf(term).bind),
+        ], '')), ', '),
+        fragment(['', '1 AS n', ...(sized ? SIZES : []), ...(dated ? [LATEST] : [])].join(', ')),
+        ...(greatest === null
+            ? []
+            : [
+                fragment(`, ${greatest.term.kind.sql} AS gk`, greatest.term.kind.bind),
+                fragment(`, ${greatest.term.value.sql} AS gv`, greatest.term.value.bind),
+                fragment(`, ${instantOf(greatest.term).sql} AS gi`, instantOf(greatest.term).bind),
+            ]),
+        fragment(' FROM replica_entries d'),
+        ...[...keyed, ...(greatest === null ? [] : [greatest])].flatMap(({ join }) => join === null ? [] : [fragment(' '), join]),
+        fragment(' WHERE '),
+        filter,
+    ], '');
+    const only = shape.groupBy.length === 1 ? shape.groupBy[0].of : null;
+    const subfolder = only === 'subfolder';
+    const folders = only === 'folder' || subfolder ? storedFolders(bound, plan, subfolder) : null;
+    const folderKey = subfolder ? subfolderOf('f.path', prefix) : fragment('f.path');
+    const zeros = [
+        ...(sized ? ['0', '0', '0', '0'] : []),
+        ...(dated ? ['NULL'] : []),
+        ...(greatest === null ? [] : ['NULL', 'NULL', 'NULL']),
+    ];
+    const source = folders === null
+        ? inner
+        : joined([
+            inner,
+            fragment(` UNION ALL SELECT 'string' AS k0, ${folderKey.sql} AS v0, NULL AS i0, 0 AS n${zeros.map((one) => `, ${one}`).join('')} FROM replica_folders f WHERE `, folderKey.bind),
+            folders,
+        ], '');
+    const held = keyed
+        .map((_, index) => `k${index}, i${index}, CASE WHEN i${index} IS NULL THEN v${index} END`)
+        .join(', ');
+    const ranked = greatest === null
+        ? source
+        : joined([
+            fragment(`SELECT *, ROW_NUMBER() OVER (PARTITION BY ${held} ORDER BY `),
+            sql.sorted(bound.collate, greatestTerm(GREATEST)),
+            fragment(', gv) AS gr FROM ('),
+            source,
+            fragment(')'),
+        ], '');
+    const columns = [
+        ...keyed.map((_, index) => `k${index}, min(v${index}) AS v${index}, i${index}`),
+        'sum(n) AS n',
+        ...(sized ? ['sum(dn) AS dn', 'sum(ds) AS ds', 'sum(fn) AS fn', 'sum(fs) AS fs'] : []),
+        ...(dated ? ['max(u) AS u'] : []),
+        ...(greatest === null
+            ? []
+            : ['gk', 'gv', 'gi'].map((column) => `min(CASE WHEN gr = 1 THEN ${column} END) AS ${column}`)),
+    ].join(', ');
+    const outer = (index, order) => ({
+        ordering: order,
+        kind: fragment(`k${index}`),
+        value: fragment(`v${index}`),
+    });
+    const termOf = (by, order) => {
+        if (by === 'count')
+            return { ordering: order, kind: fragment("'number'"), value: fragment('n') };
+        if (by === 'size') {
+            return { ordering: order, kind: fragment("'number'"), value: fragment('(ds + fs)') };
+        }
+        if (by === 'updated') {
+            return {
+                ordering: order,
+                kind: fragment("(CASE WHEN u IS NULL THEN 'null' ELSE 'string' END)"),
+                value: fragment("substr(u, instr(u, ' ') + 1)"),
+                instant: fragment("substr(u, 1, instr(u, ' ') - 1)"),
+            };
+        }
+        if (by === 'greatest')
+            return greatestTerm(order);
+        return { ...outer(by, order), instant: fragment(`i${by}`) };
+    };
+    const valueOf = (row, by) => {
+        if (by === 'count')
+            return Number(row.n);
+        if (by === 'size')
+            return Number(row.ds) + Number(row.fs);
+        if (by === 'updated') {
+            const text = latestOf(row.u);
+            return text === null ? null : sql.sortValue('string', text, row.u.split(' ')[0]);
+        }
+        if (by === 'greatest')
+            return sortedOf(row.gk, row.gv, row.gi);
+        return sortedValue(row, by);
+    };
+    const ordered = shape.orderBy.map(({ by, direction, nulls }) => termOf(by, { ...GROUP_ORDER, direction, nulls: nulls ?? GROUP_ORDER.nulls }));
+    const ties = keyed.flatMap((_, index) => [
+        { ...outer(index, GROUP_TIES), total: true },
+        { ordering: GROUP_TIES, kind: fragment("'string'"), value: fragment(`k${index}`) },
+    ]);
+    const cursor = plan.after?.values ?? null;
+    const after = cursor === null
+        ? null
+        : (() => {
+            const tieValues = cursor[shape.orderBy.length].flatMap((value) => [value, heldKind(value ?? null)]);
+            return sql.following(ordered.map((term, index) => sql.beyond(bound.collate, term, cursor[index])), sql.following(ties
+                .slice(0, -1)
+                .map((term, index) => sql.beyond(bound.collate, term, tieValues[index])), sql.beyond(bound.collate, ties.at(-1), tieValues.at(-1)).beyond));
+        })();
+    const grouping = joined([fragment(`SELECT ${columns} FROM (`), ranked, fragment(`) GROUP BY ${held}`)], '');
+    const windowed = joined([
+        fragment('SELECT * FROM ('),
+        grouping,
+        fragment(')'),
+        ...(after === null ? [] : [fragment(' WHERE '), after]),
+        fragment(' ORDER BY '),
+        joined([...ordered, ...ties].map((term) => sql.sorted(bound.collate, term)), ', '),
+        ...(plan.limit === null ? [] : [fragment(' LIMIT ?', [plan.limit + 1])]),
+    ], '');
+    const rows = connection.rows(windowed.sql, windowed.bind);
+    const kept = plan.limit === null ? rows : rows.slice(0, plan.limit);
+    const keyOf = (row) => keyed.map((_, index) => decoded(row[`k${index}`], row[`v${index}`]));
+    const found = kept.map((row) => ({
+        key: keyOf(row),
+        count: Number(row.n),
+        ...(shape.size
+            ? {
+                documents: { count: Number(row.dn), size: Number(row.ds) },
+                files: { count: Number(row.fn), size: Number(row.fs) },
+            }
+            : {}),
+        ...(shape.updated ? { updated: latestOf(row.u) } : {}),
+        ...(shape.greatest === null ? {} : { greatest: decoded(row.gk, row.gv) }),
+    }));
+    const last = kept.at(-1);
+    const next = plan.limit === null || rows.length <= plan.limit
+        ? undefined
+        : last === undefined
+            ? (plan.after?.text ?? FROM_START)
+            : cursorOf([...shape.orderBy.map(({ by }) => valueOf(last, by)), keyOf(last)]);
+    const total = plan.total
+        ? Number(connection.rows(joined([fragment('SELECT count(*) AS held FROM ('), grouping, fragment(')')], '').sql, grouping.bind)[0].held)
+        : undefined;
+    return {
+        groups: found,
+        ...(next === undefined ? {} : { next }),
+        ...(total === undefined ? {} : { total }),
+    };
+}
+function boundOf(connection, plan, rooms) {
+    return {
+        rooms: [...rooms].sort((left, right) => left.locator < right.locator ? -1 : left.locator > right.locator ? 1 : 0),
+        keys: new Map(rooms.map(({ locator, key }) => [locator, key])),
+        reach: plan.reach,
+        collate: collating(connection),
+    };
+}
+export function answerQuery(connection, plan, rooms, budget = null) {
+    const bound = boundOf(connection, plan, rooms);
+    if (rooms.length === 0) {
+        return plan.shape.kind === 'groups'
+            ? { groups: [], ...(plan.total ? { total: 0 } : {}) }
+            : { documents: [], ...(plan.total ? { total: 0 } : {}) };
+    }
+    return plan.shape.kind === 'groups'
+        ? groups(connection, bound, plan, plan.shape)
+        : documents(connection, bound, plan, plan.shape, budget);
+}