@agentshouse/mdmodel 0.1.0-ccf1367190878 → 0.1.0-cdbd463e01dc2

package/dist/query/match.js

@@ -0,0 +1,121 @@
+import { byCodePoint, instantKey } from '../kinds.js';
+import { dirname } from '../paths.js';
+import { invalid, } from './language.js';
+import { indexed, placedOf } from './rows.js';
+const BOUNDS = { gt: '>', gte: '>=', lt: '<', lte: '<=' };
+function globbed(pattern) {
+    let source = '';
+    for (let at = 0; at < pattern.length; at += 1) {
+        const char = pattern[at];
+        if (char === '*')
+            source += '.*';
+        else if (char === '[') {
+            const end = pattern.indexOf(']', at);
+            source += pattern.slice(at, end + 1);
+            at = end;
+        }
+        else
+            source += char.replace(/[.\\^$+?()|{}/]/gu, '\\$&');
+    }
+    return new RegExp(`^${source}$`, 'u');
+}
+function reached(values, field) {
+    const { keys, places, glob } = placedOf(field, 'value');
+    const matched = glob ? globbed(places) : null;
+    return values.filter((row) => row.keys === keys && (matched === null ? row.places === places : matched.test(row.places)));
+}
+function holds(sign, operator) {
+    if (operator === '=')
+        return sign === 0;
+    if (operator === '>')
+        return sign > 0;
+    if (operator === '>=')
+        return sign >= 0;
+    if (operator === '<')
+        return sign < 0;
+    return sign <= 0;
+}
+function compares(row, operator, value) {
+    if (typeof value !== 'string') {
+        if (row.kind !== typeof value)
+            return false;
+        const right = typeof value === 'boolean' ? Number(value) : value;
+        return holds(Math.sign(row.value - right), operator);
+    }
+    if (row.instant !== null) {
+        const key = instantKey(value);
+        return key !== null && holds(byCodePoint(row.instant, key), operator);
+    }
+    return row.kind === 'string' && holds(byCodePoint(row.value, value), operator);
+}
+function same(row, value) {
+    return value === null ? row.kind === 'null' : compares(row, '=', value);
+}
+function itemsOf(values, held) {
+    return values.filter((row) => row.keys === held.keys && row.places === held.places && row.item >= 0);
+}
+function matching(values, held, wanted) {
+    return wanted.some((value) => same(held, value) ||
+        (held.kind === 'array' && itemsOf(values, held).some((item) => same(item, value))));
+}
+function tested(values, field, test) {
+    const rows = reached(values, field);
+    const present = rows.some((row) => row.item === -1);
+    if (test.op === 'exists')
+        return test.exists === present;
+    if (test.op === 'eq' || test.op === 'in') {
+        const wanted = test.op === 'eq' ? [test.value] : test.values;
+        return rows.some((row) => wanted.some((value) => same(row, value)));
+    }
+    if (test.op === 'ne' || test.op === 'nin') {
+        const wanted = test.op === 'ne' ? [test.value] : test.values;
+        return !present || rows.some((row) => row.item === -1 && !matching(values, row, wanted));
+    }
+    if (test.op === 'range') {
+        return rows.some((row) => row.item === -1 &&
+            test.bounds.every(([operator, bound]) => compares(row, BOUNDS[operator], bound)));
+    }
+    if (test.op === 'prefix') {
+        return rows.some((row) => row.kind === 'string' && row.value.startsWith(test.prefix));
+    }
+    if (test.op === 'all') {
+        return rows.some((row) => row.item === -1 &&
+            row.kind === 'array' &&
+            test.values.every((value) => itemsOf(values, row).some((item) => same(item, value))));
+    }
+    return rows.some((row) => row.item === -1 && row.kind === 'array' && row.size === test.size);
+}
+function conditioned(values, condition) {
+    if ('every' in condition)
+        return condition.every.every((one) => conditioned(values, one));
+    if ('some' in condition)
+        return condition.some.some((one) => conditioned(values, one));
+    return tested(values, condition.field, condition.test);
+}
+function scoped(candidate, values, scope) {
+    return ((scope.types === null || (candidate.type !== null && scope.types.includes(candidate.type))) &&
+        (scope.pathPrefix === null ||
+            scope.pathPrefix === '' ||
+            candidate.path.startsWith(`${scope.pathPrefix}/`)) &&
+        (scope.where === null || conditioned(values, scope.where)));
+}
+export function heldAt(candidate, field) {
+    return reached(indexed(candidate.path, candidate.fields, candidate.definition).values, field);
+}
+export function matches(plan, candidate) {
+    if (plan.rooms !== null)
+        invalid('rooms', 'names Rooms, which one Document does not choose');
+    if (plan.hop !== null)
+        invalid('hop', 'tests other Documents, which one Document cannot answer');
+    if (plan.backlinks !== null) {
+        invalid('backlinks', 'tests other Documents, which one Document cannot answer');
+    }
+    const values = indexed(candidate.path, candidate.fields, candidate.definition).values;
+    return ((plan.paths === null || plan.paths.includes(candidate.path)) &&
+        (plan.fileIds === null ||
+            (candidate.fileId !== null && plan.fileIds.includes(candidate.fileId))) &&
+        (plan.folder === null || dirname(candidate.path) === plan.folder) &&
+        scoped(candidate, values, plan.root) &&
+        (plan.text === null ||
+            (candidate.text !== null && candidate.text.toLowerCase().includes(plan.text.toLowerCase()))));
+}

package/dist/query/rows.d.ts

@@ -0,0 +1,32 @@
+import { type Definition } from '../definition.js';
+export type HeldKind = 'string' | 'number' | 'boolean' | 'null' | 'array' | 'object' | 'undefined';
+export type HeldValue = {
+    readonly keys: string;
+    readonly places: string;
+    readonly item: number;
+    readonly kind: HeldKind;
+    readonly value: string | number | null;
+    readonly size: number | null;
+    readonly instant: string | null;
+};
+export type HeldLink = {
+    readonly kind: 'field';
+    readonly keys: string;
+    readonly places: string;
+    readonly target: string;
+    readonly field: string;
+};
+export type Indexed = {
+    readonly values: readonly HeldValue[];
+    readonly links: readonly HeldLink[];
+};
+export type Reach = 'exact' | 'value' | 'link';
+export type Placed = {
+    readonly keys: string;
+    readonly places: string;
+    readonly glob: boolean;
+};
+export declare function placedOf(pointer: string, reach: Reach): Placed;
+export declare function heldKind(value: unknown): HeldKind;
+export declare function indexed(path: string, fields: Readonly<Record<string, unknown>>, definition: Pick<Definition, 'frontmatter'> | undefined): Indexed;
+//# sourceMappingURL=rows.d.ts.map

package/dist/query/rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rows.d.ts","sourceRoot":"","sources":["../../src/query/rows.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,UAAU,EAEhB,MAAM,kBAAkB,CAAC;AAI1B,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEnG,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAE/C,MAAM,MAAM,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAahG,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAuB9D;AA4BD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAMjD;AAoGD,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,GAAG,SAAS,GACtD,OAAO,CAcT"}

package/dist/query/rows.js

@@ -0,0 +1,161 @@
+import { ARRAY_INDEX, escapePointer, itemFacts, memberFacts, } from '../definition.js';
+import { instantKey, kindOf } from '../kinds.js';
+import { target } from '../paths.js';
+export function placedOf(pointer, reach) {
+    const [first = '', ...rest] = pointer.split('/').slice(1);
+    const keys = [first];
+    const gaps = [[]];
+    for (const segment of rest) {
+        if (ARRAY_INDEX.test(segment)) {
+            gaps.at(-1).push(segment);
+            continue;
+        }
+        keys.push(segment);
+        gaps.push([]);
+    }
+    const places = gaps
+        .map((gap, at) => {
+        const open = at < gaps.length - 1 ? reach !== 'exact' : reach === 'link';
+        return `/${gap.map((number) => `[.:]${number}`).join('')}.${open ? '*' : ''}`;
+    })
+        .join('');
+    return {
+        keys: keys.map((key) => `/${key}`).join(''),
+        places,
+        glob: /[[*]/u.test(places),
+    };
+}
+function placesOf({ done, head, tail }) {
+    return `${done}/${head}${tail}.`;
+}
+function throughOf(keys, places) {
+    const gaps = places.split('/').slice(1);
+    return keys
+        .split('/')
+        .slice(1)
+        .map((key, at) => `/${key}${gaps[at].replace(/\.\d*/gu, '').replaceAll(':', '/')}`)
+        .join('');
+}
+function plainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function referred(facts, value) {
+    return typeof value === 'string' && facts?.reference !== undefined;
+}
+function resolved(reading, facts, value) {
+    if (!referred(facts, value))
+        return value;
+    return target(reading.path, value) ?? undefined;
+}
+export function heldKind(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (typeof value === 'object')
+        return 'object';
+    return typeof value;
+}
+function scalarOf(value) {
+    if (typeof value === 'string' || typeof value === 'number')
+        return value;
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (Array.isArray(value))
+        return JSON.stringify(value);
+    return null;
+}
+function instantOf(facts, value) {
+    return facts !== undefined && kindOf(facts) === 'date-time' ? instantKey(value) : null;
+}
+function held(reading, at, places, value, items) {
+    reading.values.push({
+        keys: at.keys,
+        places,
+        item: -1,
+        kind: heldKind(value),
+        value: scalarOf(value),
+        size: Array.isArray(value) ? value.length : null,
+        instant: instantOf(at.facts, value),
+    });
+    if (!Array.isArray(value))
+        return;
+    value.forEach((item, index) => {
+        const itemKind = heldKind(item);
+        reading.values.push({
+            keys: at.keys,
+            places,
+            item: index,
+            kind: itemKind,
+            value: itemKind === 'array' ? null : scalarOf(item),
+            size: null,
+            instant: instantOf(items[index], item),
+        });
+    });
+}
+function itemsOf(facts, node) {
+    return node.map((_, index) => (facts === undefined ? undefined : itemFacts(facts, index)));
+}
+function record(reading, node, at) {
+    const items = Array.isArray(node) ? itemsOf(at.facts, node) : [];
+    const value = Array.isArray(node)
+        ? node.map((item, index) => resolved(reading, items[index], item))
+        : resolved(reading, at.facts, node);
+    const places = placesOf(at);
+    held(reading, at, places, value, items);
+    if (typeof value !== 'string' || !referred(at.facts, node))
+        return;
+    reading.links.push({
+        kind: 'field',
+        keys: at.keys,
+        places,
+        target: value,
+        field: throughOf(at.keys, places),
+    });
+}
+function walk(reading, node, at) {
+    record(reading, node, at);
+    if (Array.isArray(node)) {
+        const items = itemsOf(at.facts, node);
+        node.forEach((item, index) => walk(reading, item, {
+            ...at,
+            tail: `${at.tail}.${index}`,
+            exact: `${at.exact}/${index}`,
+            facts: items[index],
+        }));
+        return;
+    }
+    if (!plainObject(node))
+        return;
+    for (const [key, value] of Object.entries(node)) {
+        const segment = escapePointer(key);
+        const exact = `${at.exact}/${segment}`;
+        const facts = at.facts === undefined ? undefined : memberFacts(at.facts, key);
+        walk(reading, value, ARRAY_INDEX.test(segment)
+            ? {
+                ...at,
+                head: `${at.head}${at.tail.replaceAll('.', ':')}:${segment}`,
+                tail: '',
+                exact,
+                facts,
+            }
+            : { keys: `${at.keys}/${segment}`, done: placesOf(at), head: '', tail: '', exact, facts });
+    }
+}
+export function indexed(path, fields, definition) {
+    const reading = { path, values: [], links: [] };
+    for (const [name, value] of Object.entries(fields)) {
+        const segment = escapePointer(name);
+        walk(reading, value, {
+            keys: `/${segment}`,
+            done: '',
+            head: '',
+            tail: '',
+            exact: `/${segment}`,
+            facts: definition === undefined ? undefined : memberFacts(definition.frontmatter, name),
+        });
+    }
+    return { values: reading.values, links: reading.links };
+}

package/dist/query/sql.d.ts

@@ -0,0 +1,39 @@
+import { type Ordering } from '../kinds.js';
+import type { QueryPlan, Scope } from './language.js';
+import { type HeldValue, type Reach } from './rows.js';
+export type SqlValue = string | number | bigint | Uint8Array | null;
+export type Fragment = {
+    readonly sql: string;
+    readonly bind: readonly SqlValue[];
+};
+export type Collate = (ordering: Ordering, lists: boolean, total: boolean) => string | null;
+export type Term = {
+    readonly ordering: Ordering;
+    readonly kind: Fragment;
+    readonly value: Fragment;
+    readonly instant?: Fragment;
+    readonly total?: boolean;
+};
+export type Following = {
+    readonly beyond: Fragment;
+    readonly equal: Fragment;
+};
+export declare const VALUE_TABLE = "CREATE TABLE replica_values (doc INTEGER NOT NULL, keys TEXT NOT NULL, places TEXT NOT NULL, item INTEGER NOT NULL, kind TEXT NOT NULL, value, size INTEGER, instant TEXT, PRIMARY KEY (doc, keys, places, item)) WITHOUT ROWID";
+export declare const HOLDS_PHRASE = "holds_phrase";
+export declare function holdsPhrase(_context: number, text: unknown, phrase: unknown): number;
+export declare function fragment(sql: string, bind?: readonly SqlValue[]): Fragment;
+export declare function joined(parts: readonly Fragment[], separator: string): Fragment;
+export declare function all(parts: readonly Fragment[]): Fragment;
+export declare function any(parts: readonly Fragment[]): Fragment;
+export declare function grouped(part: Fragment): Fragment;
+export declare function listed(values: readonly SqlValue[]): Fragment;
+export declare function exists(part: Fragment): Fragment;
+export declare function insertedValues(doc: number, values: readonly HeldValue[]): Fragment;
+export declare function placed(alias: string, field: string, reach: Reach): Fragment;
+export declare function scoped(alias: string, scope: Scope, byPaths?: boolean): Fragment;
+export declare function tests(alias: string, plan: QueryPlan): Fragment;
+export declare function sortValue(kind: SqlValue | undefined, value: unknown, instant: SqlValue | undefined): unknown;
+export declare function sorted(collate: Collate, term: Term): Fragment;
+export declare function beyond(collate: Collate, term: Term, value: unknown): Following;
+export declare function following(parts: readonly Following[], tie: Fragment): Fragment;
+//# sourceMappingURL=sql.d.ts.map

package/dist/query/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../src/query/sql.ts"],"names":[],"mappings":"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"}

package/dist/query/sql.js

@@ -0,0 +1,279 @@
+import { instantKey } from '../kinds.js';
+import { placedOf } from './rows.js';
+export const VALUE_TABLE = 'CREATE TABLE replica_values (doc INTEGER NOT NULL, keys TEXT NOT NULL, places TEXT NOT NULL, item INTEGER NOT NULL, kind TEXT NOT NULL, value, size INTEGER, instant TEXT, PRIMARY KEY (doc, keys, places, item)) WITHOUT ROWID';
+export const HOLDS_PHRASE = 'holds_phrase';
+const BOUNDS = { gt: '>', gte: '>=', lt: '<', lte: '<=' };
+const NUMBERS = 1;
+const INSTANTS = 2;
+const TEXTS = 3;
+const LISTS = 4;
+export function holdsPhrase(_context, text, phrase) {
+    return typeof text === 'string' &&
+        typeof phrase === 'string' &&
+        text.toLowerCase().includes(phrase)
+        ? 1
+        : 0;
+}
+export function fragment(sql, bind = []) {
+    return { sql, bind };
+}
+export 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));
+}
+export function all(parts) {
+    return parts.length === 0 ? fragment('1') : balanced(parts, ' AND ');
+}
+export function any(parts) {
+    return parts.length === 0 ? fragment('0') : balanced(parts, ' OR ');
+}
+export function grouped(part) {
+    return { sql: `(${part.sql})`, bind: part.bind };
+}
+export function listed(values) {
+    return fragment(`(${values.map(() => '?').join(', ')})`, values);
+}
+export function exists(part) {
+    return { sql: `EXISTS (${part.sql})`, bind: part.bind };
+}
+function not(part) {
+    return { sql: `NOT ${part.sql}`, bind: part.bind };
+}
+function scalarText(value) {
+    if (value === Infinity)
+        return 'Infinity';
+    if (value === -Infinity)
+        return '-Infinity';
+    return JSON.stringify(value);
+}
+export function insertedValues(doc, values) {
+    const rows = values.map((value) => `[${JSON.stringify(value.keys)},${JSON.stringify(value.places)},${value.item},${JSON.stringify(value.kind)},${scalarText(value.value)},${JSON.stringify(value.size)},${JSON.stringify(value.instant)}]`);
+    return fragment('INSERT INTO replica_values (doc, keys, places, item, kind, value, size, instant) SELECT ?, value ->> 0, value ->> 1, value ->> 2, value ->> 3, value ->> 4, value ->> 5, value ->> 6 FROM json_each(?)', [doc, `[${rows.join(',')}]`]);
+}
+export function placed(alias, field, reach) {
+    const { keys, places, glob } = placedOf(field, reach);
+    return fragment(`${alias}.keys = ? AND ${alias}.places ${glob ? 'GLOB' : '='} ?`, [keys, places]);
+}
+function plainText(alias, operator, text) {
+    return fragment(`${alias}.instant IS NULL AND ${alias}.kind = 'string' AND ${alias}.value ${operator} ?`, [text]);
+}
+function compares(alias, operator, value) {
+    if (typeof value !== 'string') {
+        return fragment(`${alias}.kind = ? AND ${alias}.value ${operator} ?`, [
+            typeof value,
+            typeof value === 'boolean' ? (value ? 1 : 0) : value,
+        ]);
+    }
+    const key = instantKey(value);
+    if (key === null)
+        return plainText(alias, operator, value);
+    return any([
+        fragment(`${alias}.instant IS NOT NULL AND ${alias}.instant ${operator} ?`, [key]),
+        plainText(alias, operator, value),
+    ]);
+}
+function same(alias, value) {
+    return value === null ? fragment(`${alias}.kind = 'null'`) : compares(alias, '=', value);
+}
+function heldValues(doc, field, alias, where) {
+    return joined([
+        fragment(`SELECT 1 FROM replica_values ${alias} WHERE ${alias}.doc = ${doc}.id AND `),
+        grouped(placed(alias, field, 'value')),
+        fragment(' AND '),
+        grouped(where),
+    ], '');
+}
+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 : not(reached);
+    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;
+        return any([
+            not(reached),
+            exists(heldValues(doc, field, 'h', all([fragment('h.item = -1'), not(grouped(matching('h', values)))]))),
+        ]);
+    }
+    if (test.op === 'range') {
+        return exists(heldValues(doc, field, 'v', all([
+            fragment('v.item = -1'),
+            ...test.bounds.map(([operator, bound]) => compares('v', BOUNDS[operator], bound)),
+        ])));
+    }
+    if (test.op === 'prefix') {
+        return exists(heldValues(doc, field, 'v', fragment("v.kind = 'string' AND substr(v.value, 1, length(?)) = ?", [
+            test.prefix,
+            test.prefix,
+        ])));
+    }
+    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);
+}
+export function scoped(alias, scope, byPaths = false) {
+    const type = byPaths ? `+${alias}.type` : `${alias}.type`;
+    return all([
+        ...(scope.types === null
+            ? []
+            : [fragment(`${type} IN ${listed(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)]),
+    ]);
+}
+export function tests(alias, plan) {
+    return all([
+        ...(plan.paths === null
+            ? []
+            : [fragment(`${alias}.path IN ${listed(plan.paths).sql}`, plan.paths)]),
+        ...(plan.fileIds === null
+            ? []
+            : [fragment(`${alias}.file_id IN ${listed(plan.fileIds).sql}`, plan.fileIds)]),
+        ...(plan.folder === null ? [] : [fragment(`${alias}.folder = ?`, [plan.folder])]),
+        scoped(alias, plan.root, plan.paths !== null),
+        ...(plan.text === null
+            ? []
+            : [fragment(`${HOLDS_PHRASE}(${alias}.content, ?)`, [plan.text.toLowerCase()])]),
+    ]);
+}
+function instantMark(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    const { instant } = value;
+    return typeof instant === 'string' && Object.keys(value).length === 1 ? instant : null;
+}
+export function sortValue(kind, value, instant) {
+    return typeof instant === 'string' && kind === 'string' ? { instant } : value;
+}
+function classOf(value, ordering) {
+    if (value === null || value === undefined) {
+        return { placement: ordering.nulls === 'first' ? 0 : 2, klass: 0, scalar: null };
+    }
+    const mark = instantMark(value);
+    if (mark !== null)
+        return { placement: 1, klass: INSTANTS, scalar: mark };
+    if (typeof value === 'boolean')
+        return { placement: 1, klass: NUMBERS, scalar: value ? 1 : 0 };
+    if (typeof value === 'number')
+        return { placement: 1, klass: NUMBERS, scalar: value };
+    if (typeof value === 'string')
+        return { placement: 1, klass: TEXTS, scalar: value };
+    return { placement: 1, klass: LISTS, 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) {
+    const kinds = fragment(`CASE ${term.kind.sql} WHEN 'boolean' THEN ${NUMBERS} WHEN 'number' THEN ${NUMBERS} WHEN 'string' THEN ${TEXTS} WHEN 'array' THEN ${LISTS} ELSE 5 END`, term.kind.bind);
+    if (term.instant === undefined)
+        return kinds;
+    return fragment(`CASE WHEN ${term.instant.sql} IS NOT NULL THEN ${INSTANTS} ELSE ${kinds.sql} END`, [...term.instant.bind, ...kinds.bind]);
+}
+function classed(term, which) {
+    if (which === INSTANTS)
+        return term.instant ?? fragment('NULL');
+    const kinds = which === NUMBERS ? "('boolean', 'number')" : which === TEXTS ? "('string')" : "('array')";
+    const plain = which === TEXTS && term.instant !== undefined
+        ? fragment(` AND ${term.instant.sql} IS NULL`, term.instant.bind)
+        : fragment('');
+    return fragment(`(CASE WHEN ${term.kind.sql} IN ${kinds}${plain.sql} THEN ${term.value.sql} END)`, [...term.kind.bind, ...plain.bind, ...term.value.bind]);
+}
+function collated(collate, term, which) {
+    if (which === NUMBERS || which === INSTANTS)
+        return '';
+    const name = collate(term.ordering, which === LISTS, term.total === true);
+    return name === null ? '' : ` COLLATE ${name}`;
+}
+export function sorted(collate, term) {
+    const direction = term.ordering.direction === 'desc' ? 'DESC' : 'ASC';
+    return joined([
+        placement(term),
+        fragment(`${klass(term).sql} ${direction}`, klass(term).bind),
+        ...[NUMBERS, INSTANTS, TEXTS, LISTS].map((which) => {
+            const value = classed(term, which);
+            return fragment(`${value.sql}${collated(collate, term, which)} ${direction}`, value.bind);
+        }),
+    ], ', ');
+}
+export function beyond(collate, 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(collate, 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]),
+        ]),
+    };
+}
+export function following(parts, tie) {
+    let condition = tie;
+    for (const part of [...parts].reverse()) {
+        condition = any([part.beyond, all([part.equal, condition])]);
+    }
+    return condition;
+}

package/dist/references.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../src/references.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EAEhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAwBzD,wBAAgB,UAAU,CACxB,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,EACrC,UAAU,EAAE,UAAU,GACrB,SAAS,SAAS,EAAE,CAItB"}
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../src/references.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EAEhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AA8BzD,wBAAgB,UAAU,CACxB,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,EACrC,UAAU,EAAE,UAAU,GACrB,SAAS,SAAS,EAAE,CAItB"}

package/dist/references.js

@@ -5,7 +5,12 @@ function collect(value, facts, pointer, found) {
         return;
     if (typeof value === 'string') {
         if (facts.reference !== undefined)
-            found.push({ pointer, value, to: facts.reference });
+            found.push({
+                pointer,
+                value,
+                to: facts.reference,
+                ...(facts.crossRoom === true ? { crossRoom: true } : {}),
+            });
         return;
     }
     if (Array.isArray(value)) {

package/dist/reserved.d.ts

@@ -0,0 +1,5 @@
+export declare const ROOM_DESCRIPTION = "ROOM.md";
+export declare const RESERVED_NAMES: readonly string[];
+export declare function isReservedName(name: string): boolean;
+export declare function isDocumentPath(path: string): boolean;
+//# sourceMappingURL=reserved.d.ts.map

package/dist/reserved.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reserved.d.ts","sourceRoot":"","sources":["../src/reserved.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAE1C,eAAO,MAAM,cAAc,EAAE,SAAS,MAAM,EAO3C,CAAC;AAQF,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGpD"}