@agentshouse/mdruntime 0.1.0-c698c0ebd65bd → 0.1.0-c6dd3e87e3f5e

package/dist/compile.js

@@ -0,0 +1,786 @@
+import { ARRAY_INDEX, parse, pointerSegments } from '@agentshouse/mdmodel';
+import { binaryRecord } from './binary.js';
+import { documentKey, kindOf, pathOfKey, placedOf, roomOfKey } from './rows.js';
+import { byCodePoint, compared, cursorOf, FROM_START, MAXIMUM_WINDOW, } from './windows.js';
+const VISIBLE = (alias) => `${alias}.visible = 1 AND ${alias}.present = 1 AND ${alias}.queried = 1`;
+function fragment(sql, bind = []) {
+    return { sql, bind };
+}
+function joined(parts, separator) {
+    return {
+        sql: parts.map((part) => part.sql).join(separator),
+        bind: parts.flatMap((part) => part.bind),
+    };
+}
+function balanced(parts, separator) {
+    if (parts.length === 1)
+        return grouped(parts[0]);
+    const half = Math.ceil(parts.length / 2);
+    return grouped(joined([balanced(parts.slice(0, half), separator), balanced(parts.slice(half), separator)], separator));
+}
+function all(parts) {
+    return parts.length === 0 ? fragment('1') : balanced(parts, ' AND ');
+}
+function any(parts) {
+    return parts.length === 0 ? fragment('0') : balanced(parts, ' OR ');
+}
+function grouped(part) {
+    return { sql: `(${part.sql})`, bind: part.bind };
+}
+function list(values) {
+    return fragment(`(${values.map(() => '?').join(', ')})`, values);
+}
+function sqlValue(value) {
+    if (value === null)
+        return { kind: 'null', value: null };
+    if (typeof value === 'boolean')
+        return { kind: 'boolean', value: value ? 1 : 0 };
+    if (typeof value === 'number')
+        return { kind: 'number', value };
+    return { kind: 'string', value };
+}
+function same(alias, value) {
+    const held = sqlValue(value);
+    return held.kind === 'null'
+        ? fragment(`${alias}.kind = 'null'`)
+        : fragment(`${alias}.kind = ? AND ${alias}.value = ?`, [held.kind, held.value]);
+}
+const BOUNDS = { gt: '>', gte: '>=', lt: '<', lte: '<=' };
+function pointed(alias, field, reach) {
+    const { keys, places, glob } = placedOf(field, reach);
+    return fragment(`${alias}.keys = ? AND ${alias}.places ${glob ? 'GLOB' : '='} ?`, [keys, places]);
+}
+function heldValues(doc, field, alias, where) {
+    return joined([
+        fragment(`SELECT 1 FROM replica_values ${alias} WHERE ${alias}.doc = ${doc}.id AND `),
+        grouped(pointed(alias, field, 'value')),
+        fragment(' AND '),
+        grouped(where),
+    ], '');
+}
+function exists(part) {
+    return { sql: `EXISTS (${part.sql})`, bind: part.bind };
+}
+function itemOf(held, where) {
+    return exists(joined([
+        fragment(`SELECT 1 FROM replica_values i WHERE i.doc = ${held}.doc AND i.keys = ${held}.keys AND i.places = ${held}.places AND i.item >= 0 AND `),
+        grouped(where),
+    ], ''));
+}
+function matching(held, values) {
+    return any(values.map((value) => any([
+        same(held, value),
+        all([fragment(`${held}.kind = 'array'`), itemOf(held, same('i', value))]),
+    ])));
+}
+function tested(doc, field, test) {
+    const reached = exists(heldValues(doc, field, 'r', fragment('r.item = -1')));
+    if (test.op === 'exists')
+        return test.exists ? reached : fragment(`NOT ${reached.sql}`, reached.bind);
+    if (test.op === 'eq' || test.op === 'in') {
+        const values = test.op === 'eq' ? [test.value] : test.values;
+        return exists(heldValues(doc, field, 'v', any(values.map((value) => same('v', value)))));
+    }
+    if (test.op === 'ne' || test.op === 'nin') {
+        const values = test.op === 'ne' ? [test.value] : test.values;
+        const unmatched = matching('h', values);
+        return any([
+            fragment(`NOT ${reached.sql}`, reached.bind),
+            exists(heldValues(doc, field, 'h', all([fragment('h.item = -1'), fragment(`NOT (${unmatched.sql})`, unmatched.bind)]))),
+        ]);
+    }
+    if (test.op === 'range') {
+        return exists(heldValues(doc, field, 'v', all([
+            fragment('v.item = -1'),
+            ...test.bounds.map(([operator, bound]) => {
+                const held = sqlValue(bound);
+                return fragment(`v.kind = ? AND v.value ${BOUNDS[operator]} ?`, [
+                    held.kind,
+                    held.value,
+                ]);
+            }),
+        ])));
+    }
+    if (test.op === 'all') {
+        return exists(heldValues(doc, field, 'h', all([
+            fragment("h.item = -1 AND h.kind = 'array'"),
+            ...test.values.map((value) => itemOf('h', same('i', value))),
+        ])));
+    }
+    return exists(heldValues(doc, field, 'v', fragment("v.item = -1 AND v.kind = 'array' AND v.size = ?", [test.size])));
+}
+function conditioned(doc, condition) {
+    if ('every' in condition)
+        return all(condition.every.map((one) => conditioned(doc, one)));
+    if ('some' in condition)
+        return any(condition.some.map((one) => conditioned(doc, one)));
+    return tested(doc, condition.field, condition.test);
+}
+function located(bound, alias) {
+    if (bound.rooms.length === 0)
+        return fragment("''");
+    return fragment(`CASE ${alias}.key ${bound.rooms.map(() => 'WHEN ? THEN ?').join(' ')} END`, bound.rooms.flatMap(({ key, locator }) => [key, locator]));
+}
+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 ${list(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 unindexed(column) {
+    return `+${column}`;
+}
+function scoped(alias, scope, byPaths = false) {
+    const type = byPaths ? unindexed(`${alias}.type`) : `${alias}.type`;
+    return all([
+        ...(scope.types === null ? [] : [fragment(`${type} IN ${list(scope.types).sql}`, scope.types)]),
+        ...(scope.pathPrefix === null || scope.pathPrefix === ''
+            ? []
+            : [
+                fragment(`${alias}.path >= ? AND ${alias}.path < ?`, [
+                    `${scope.pathPrefix}/`,
+                    `${scope.pathPrefix}0`,
+                ]),
+            ]),
+        ...(scope.where === null ? [] : [conditioned(alias, scope.where)]),
+    ]);
+}
+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(pointed('l', plan.hop.field, 'link')),
+            fragment('AND'),
+            grouped(all([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(pointed('l', field, 'link')), fragment('AND')]),
+            grouped(all([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 ${list(keys).sql} AND ${VISIBLE('d')}`, keys),
+        ...(plan.paths === null ? [] : [fragment(`d.path IN ${list(plan.paths).sql}`, plan.paths)]),
+        ...(plan.folder === null ? [] : [fragment('d.folder = ?', [plan.folder])]),
+        reached(bound, 'd'),
+        scoped('d', plan.root, plan.paths !== null),
+        ...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,
+};
+function classOf(value, ordering) {
+    if (value === null || value === undefined) {
+        return { placement: ordering.nulls === 'first' ? 0 : 2, klass: 0, scalar: null };
+    }
+    if (typeof value === 'boolean')
+        return { placement: 1, klass: 1, scalar: value ? 1 : 0 };
+    if (typeof value === 'number')
+        return { placement: 1, klass: 1, scalar: value };
+    if (typeof value === 'string')
+        return { placement: 1, klass: 2, scalar: value };
+    return { placement: 1, klass: 3, scalar: JSON.stringify(value) };
+}
+function placement(term) {
+    const nulls = term.ordering.nulls === 'first' ? 0 : 2;
+    return fragment(`CASE WHEN ${term.kind.sql} IS NULL OR ${term.kind.sql} = 'null' THEN ${nulls} ELSE 1 END`, [...term.kind.bind, ...term.kind.bind]);
+}
+function klass(term) {
+    return fragment(`CASE ${term.kind.sql} WHEN 'boolean' THEN 1 WHEN 'number' THEN 1 WHEN 'string' THEN 2 WHEN 'array' THEN 3 ELSE 4 END`, term.kind.bind);
+}
+function classed(term, which) {
+    const kinds = which === 1 ? "('boolean', 'number')" : which === 2 ? "('string')" : "('array')";
+    return fragment(`(CASE WHEN ${term.kind.sql} IN ${kinds} THEN ${term.value.sql} END)`, [
+        ...term.kind.bind,
+        ...term.value.bind,
+    ]);
+}
+function collated(bound, term, which) {
+    if (which === 1)
+        return '';
+    const name = bound.collate(term.ordering, which === 3, term.total === true);
+    return name === null ? '' : ` COLLATE ${name}`;
+}
+function sorted(bound, term) {
+    const direction = term.ordering.direction === 'desc' ? 'DESC' : 'ASC';
+    return joined([
+        placement(term),
+        fragment(`${klass(term).sql} ${direction}`, klass(term).bind),
+        ...[1, 2, 3].map((which) => {
+            const value = classed(term, which);
+            return fragment(`${value.sql}${collated(bound, term, which)} ${direction}`, value.bind);
+        }),
+    ], ', ');
+}
+function beyond(bound, term, value) {
+    const held = classOf(value, term.ordering);
+    const place = placement(term);
+    if (held.placement !== 1) {
+        return {
+            beyond: fragment(`${place.sql} > ${held.placement}`, place.bind),
+            equal: fragment(`${place.sql} = ${held.placement}`, place.bind),
+        };
+    }
+    const after = term.ordering.direction === 'desc' ? '<' : '>';
+    const kind = klass(term);
+    const scalar = classed(term, held.klass);
+    const collation = collated(bound, term, held.klass);
+    return {
+        beyond: any([
+            fragment(`${place.sql} > 1`, place.bind),
+            all([
+                fragment(`${place.sql} = 1`, place.bind),
+                any([
+                    fragment(`${kind.sql} ${after} ${held.klass}`, kind.bind),
+                    all([
+                        fragment(`${kind.sql} = ${held.klass}`, kind.bind),
+                        fragment(`${scalar.sql} ${after} ?${collation}`, [...scalar.bind, held.scalar]),
+                    ]),
+                ]),
+            ]),
+        ]),
+        equal: all([
+            fragment(`${place.sql} = 1 AND ${kind.sql} = ${held.klass}`, [...place.bind, ...kind.bind]),
+            fragment(`${scalar.sql} = ?${collation}`, [...scalar.bind, held.scalar]),
+        ]),
+    };
+}
+function following(parts, tie) {
+    let condition = tie;
+    for (const part of [...parts].reverse()) {
+        condition = any([part.beyond, all([part.equal, condition])]);
+    }
+    return condition;
+}
+function keyTerm(bound, key, ordering, index) {
+    if (key.of === 'field') {
+        const alias = `o${index}`;
+        return {
+            term: { ordering, kind: fragment(`${alias}.kind`), value: fragment(`${alias}.value`) },
+            join: joined([
+                fragment(`LEFT JOIN replica_values ${alias} ON ${alias}.doc = d.id AND `),
+                grouped(pointed(alias, key.field, 'exact')),
+                fragment(` AND ${alias}.item = -1 AND ${alias}.kind NOT IN ('object', 'undefined')`),
+            ], ''),
+        };
+    }
+    const expression = key.of === 'room'
+        ? located(bound, 'd')
+        : key.of === 'path'
+            ? fragment('d.path')
+            : key.of === 'type'
+                ? fragment('d.type')
+                : 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 decodedKey(key, row, index) {
+    if (key.of === 'field') {
+        const kind = row[`k${index}`];
+        return kind === null || kind === undefined ? undefined : decoded(kind, row[`v${index}`]);
+    }
+    return row[`v${index}`] ?? 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 bodied(shape) {
+    return shape.sections !== null || shape.preamble || shape.markdown;
+}
+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 documentOf(shape, room, row, linked) {
+    const path = row.path;
+    const type = row.type;
+    const fileId = row.file_id ?? null;
+    const revision = row.revision ?? null;
+    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.fileId ? { fileId } : {}),
+            ...(shape.revision ? { revision } : {}),
+        };
+    }
+    const read = bodied(shape) ? parse(row.content, path) : null;
+    const body = read?.ok === true ? read.document : 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: row.change === null ? null : JSON.parse(row.change),
+            }
+            : {}),
+        ...(shape.fileId ? { fileId } : {}),
+        ...(shape.revision ? { revision } : {}),
+    };
+}
+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);
+    }
+    for (const [key, targets] of byKey) {
+        const reach = reached(bound, 's');
+        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(bound, key, orderingOf(options), index));
+    const filter = filtered(bound, plan);
+    const cursor = plan.after?.values ?? null;
+    const room = located(bound, 'd');
+    const tie = cursor === null
+        ? null
+        : (() => {
+            const key = cursor[shape.orderBy.length];
+            return any([
+                fragment(`${room.sql} > ?`, [...room.bind, roomOfKey(key)]),
+                fragment(`${room.sql} = ? AND d.path > ?`, [
+                    ...room.bind,
+                    roomOfKey(key),
+                    pathOfKey(key),
+                ]),
+            ]);
+        })();
+    const after = cursor === null || tie === null
+        ? null
+        : following(terms.map(({ term }, index) => beyond(bound, term, cursor[index])), tie);
+    const selected = joined([
+        fragment('SELECT d.id, d.key, d.path, d.type, d.binary, d.revision, d.fields, d.change, d.file_id'),
+        ...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(' 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 }) => sorted(bound, 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 linked = shape.backlinks ? backlinksOf(connection, bound, kept) : new Map();
+    const found = kept.map((row) => documentOf(shape, roomOf.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 ${list(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 ${list(read).sql}`, read)
+        .map((row) => [row.id, row.content]));
+    return kept.map((row) => ({ ...row, content: held.get(row.id) ?? null }));
+}
+function storedFolders(bound, plan) {
+    if (plan.paths !== null || plan.hop !== null || plan.backlinks !== 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)];
+    });
+    return all([
+        fragment(`f.key IN ${list(keys).sql} AND f.layer = 0 AND f.present = 1`, keys),
+        ...outside,
+        ...(prefix === null || prefix === ''
+            ? []
+            : [
+                fragment('(f.path = ? OR (f.path >= ? AND f.path < ?))', [
+                    prefix,
+                    `${prefix}/`,
+                    `${prefix}0`,
+                ]),
+            ]),
+        ...(plan.folder === null ? [] : [fragment('f.path = ?', [plan.folder])]),
+    ]);
+}
+function groups(connection, bound, plan, shape) {
+    const keyed = shape.groupBy.map((key, index) => {
+        const { term, join } = keyTerm(bound, key, GROUP_ORDER, index);
+        const kind = fragment(`COALESCE(${term.kind.sql}, 'null')`, term.kind.bind);
+        return { term: { ...term, kind }, join };
+    });
+    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(', 1 AS n FROM replica_entries d'),
+        ...keyed.flatMap(({ join }) => (join === null ? [] : [fragment(' '), join])),
+        fragment(' WHERE '),
+        filter,
+    ], '');
+    const folders = shape.groupBy.length === 1 && shape.groupBy[0].of === 'folder'
+        ? storedFolders(bound, plan)
+        : null;
+    const source = folders === null
+        ? inner
+        : joined([
+            inner,
+            fragment(" UNION ALL SELECT 'string' AS k0, f.path AS v0, 0 AS n FROM replica_folders f WHERE "),
+            folders,
+        ], '');
+    const columns = keyed.map((_, index) => `k${index}, v${index}`).join(', ');
+    const counted = {
+        ordering: { ...GROUP_ORDER },
+        kind: fragment("'number'"),
+        value: fragment('n'),
+    };
+    const outer = (index, ordering) => ({
+        ordering,
+        kind: fragment(`k${index}`),
+        value: fragment(`v${index}`),
+    });
+    const ordered = shape.orderBy.map(({ by, direction }) => by === 'count'
+        ? { ...counted, ordering: { ...GROUP_ORDER, direction } }
+        : outer(by, { ...GROUP_ORDER, direction }));
+    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 tieValues = cursor === null
+        ? null
+        : cursor[shape.orderBy.length].flatMap((value) => [
+            value,
+            kindOf(value ?? null),
+        ]);
+    const after = cursor === null || tieValues === null
+        ? null
+        : following(ordered.map((term, index) => beyond(bound, term, cursor[index])), following(ties.slice(0, -1).map((term, index) => beyond(bound, term, tieValues[index])), beyond(bound, ties.at(-1), tieValues.at(-1)).beyond));
+    const grouping = joined([fragment(`SELECT ${columns}, sum(n) AS n FROM (`), source, fragment(`) GROUP BY ${columns}`)], '');
+    const windowed = joined([
+        fragment('SELECT * FROM ('),
+        grouping,
+        fragment(')'),
+        ...(after === null ? [] : [fragment(' WHERE '), after]),
+        fragment(' ORDER BY '),
+        joined([...ordered, ...ties].map((term) => sorted(bound, 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) }));
+    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 }) => by === 'count' ? Number(last.n) : decoded(last[`k${by}`], last[`v${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 selected(connection, plan, rooms) {
+    return filtered(boundOf(connection, plan, rooms), plan);
+}
+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);
+}