@agentshouse/mdruntime 0.1.0-ce41fec66d91b → 0.1.0-ce5b3c1e6ea87

package/dist/compile.js

@@ -1,127 +1,13 @@
-import { ARRAY_INDEX, parse, pointerSegments } from '@agentshouse/mdmodel';
+import { ARRAY_INDEX, bodied, byCodePoint, compared, cursorOf, heldKind, parse, pointerSegments, sql, } 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) {
+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 AND ${alias}.queried = 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}/`,
@@ -164,7 +50,7 @@ function reached(bound, alias) {
     }));
     return all([
         any([
-            ...(rooms.length === 0 ? [] : [fragment(`${alias}.key IN ${list(rooms).sql}`, rooms)]),
+            ...(rooms.length === 0 ? [] : [fragment(`${alias}.key IN ${listed(rooms).sql}`, rooms)]),
             ...(documents.length === 0
                 ? []
                 : [
@@ -174,40 +60,22 @@ function reached(bound, alias) {
         ...(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')),
+            grouped(sql.placed('l', plan.hop.field, 'link')),
             fragment('AND'),
-            grouped(all([scoped('m', plan.hop), reached(bound, 'm')])),
+            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(pointed('l', field, 'link')), fragment('AND')]),
-            grouped(all([scoped('s', plan.backlinks), reached(bound, 's')])),
+            ...(field === null ? [] : [grouped(sql.placed('l', field, 'link')), fragment('AND')]),
+            grouped(all([sql.scoped('s', plan.backlinks), reached(bound, 's')])),
         ], ' ')));
     }
     return parts;
@@ -215,11 +83,9 @@ function related(bound, plan) {
 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])]),
+        fragment(`d.key IN ${listed(keys).sql} AND ${VISIBLE('d')}`, keys),
         reached(bound, 'd'),
-        scoped('d', plan.root, plan.paths !== null),
+        sql.tests('d', plan),
         ...related(bound, plan),
     ]);
 }
@@ -250,108 +116,65 @@ const GROUP_TIES = {
     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;
+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(bound, key, ordering, index) {
+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`) },
+            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(pointed(alias, key.field, 'exact')),
+                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(bound, 'd')
+        ? located('d')
         : key.of === 'path'
             ? fragment('d.path')
             : key.of === 'type'
                 ? fragment('d.type')
-                : fragment('d.folder');
+                : key.of === 'subfolder'
+                    ? subfolderOf('d.folder', prefix)
+                    : fragment('d.folder');
     return {
         term: {
             ordering,
@@ -372,12 +195,20 @@ function decoded(kind, value) {
         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) {
-    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 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) {
@@ -428,9 +259,6 @@ function collating(connection) {
         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) {
@@ -499,8 +327,10 @@ function documentOf(shape, room, row, linked) {
                     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 read = bodied(shape) ? parse(row.content, path) : null;
@@ -523,13 +353,19 @@ function documentOf(shape, room, row, linked) {
         ...(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.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 ?? null } : {}),
     };
 }
 function backlinksOf(connection, bound, rows) {
@@ -555,10 +391,10 @@ function backlinksOf(connection, bound, rows) {
     return linked;
 }
 function documents(connection, bound, plan, shape, budget) {
-    const terms = shape.orderBy.map(({ key, options }, index) => keyTerm(bound, key, orderingOf(options), index));
+    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(bound, 'd');
+    const room = located('d');
     const tie = cursor === null
         ? null
         : (() => {
@@ -574,19 +410,20 @@ function documents(connection, bound, plan, shape, budget) {
         })();
     const after = cursor === null || tie === null
         ? null
-        : following(terms.map(({ term }, index) => beyond(bound, term, cursor[index])), tie);
+        : sql.following(terms.map(({ term }, index) => sql.beyond(bound.collate, 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'),
+        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 }) => sorted(bound, term)), room, fragment('d.path')], ', '),
+        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);
@@ -625,7 +462,7 @@ function withContent(connection, rows, budget) {
         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)
+        .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;
@@ -640,18 +477,22 @@ function withContent(connection, rows, budget) {
     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)
+        .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) {
-    if (plan.paths !== null || plan.hop !== null || plan.backlinks !== 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 prefix = plan.root.pathPrefix ?? '';
     const outside = (bound.reach?.areas ?? []).flatMap((area) => {
         const key = bound.keys.get(area.room);
         if (key === undefined)
@@ -659,63 +500,146 @@ function storedFolders(bound, plan) {
         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 ${list(keys).sql} AND f.layer = 0 AND f.present = 1`, keys),
+        fragment(`f.key IN ${listed(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`,
-                ]),
-            ]),
+        ...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(bound, key, GROUP_ORDER, 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 FROM replica_entries d'),
-        ...keyed.flatMap(({ join }) => (join === null ? [] : [fragment(' '), join])),
+        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 folders = shape.groupBy.length === 1 && shape.groupBy[0].of === 'folder'
-        ? storedFolders(bound, plan)
-        : null;
+    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, f.path AS v0, 0 AS n FROM replica_folders f WHERE "),
+            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 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,
+    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 ordered = shape.orderBy.map(({ by, direction }) => by === 'count'
-        ? { ...counted, ordering: { ...GROUP_ORDER, direction } }
-        : outer(by, { ...GROUP_ORDER, direction }));
+    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}`) },
@@ -725,34 +649,44 @@ function groups(connection, bound, plan, shape) {
         ? null
         : cursor[shape.orderBy.length].flatMap((value) => [
             value,
-            kindOf(value ?? null),
+            heldKind(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}`)], '');
+        : 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) => sorted(bound, term)), ', '),
+        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) }));
+    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 }) => by === 'count' ? Number(last.n) : decoded(last[`k${by}`], last[`v${by}`])),
-                keyOf(last),
-            ]);
+            : 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;
@@ -770,9 +704,6 @@ function boundOf(connection, plan, rooms) {
         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) {