@agentshouse/mdmodel 0.1.0-cabd61587647f → 0.1.0-caefdbe3e3d42

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,UAAU,GAAG,SAAS,GACjC,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"}

package/dist/reserved.js

@@ -0,0 +1,20 @@
+export const ROOM_DESCRIPTION = 'ROOM.md';
+export const RESERVED_NAMES = [
+    ROOM_DESCRIPTION,
+    'capture',
+    'settings',
+    'rooms',
+    'agents',
+    'house',
+];
+function folded(name) {
+    return name.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+const FOLDED_RESERVED_NAMES = new Set(RESERVED_NAMES.map(folded));
+export function isReservedName(name) {
+    return FOLDED_RESERVED_NAMES.has(folded(name));
+}
+export function isDocumentPath(path) {
+    const first = path.split('/', 1)[0];
+    return first !== '' && !isReservedName(first);
+}

package/dist/schema.d.ts

@@ -4,5 +4,6 @@ export type SchemaRefusal = {
     readonly location: string;
 };
 export declare function frontmatterRefusal(definition: Definition, fields: Readonly<Record<string, unknown>>): SchemaRefusal | undefined;
+export declare function conditionedSections(definition: Definition, fields: Readonly<Record<string, unknown>>): readonly string[];
 export declare function fitsItem(definition: Definition, section: string, text: string): boolean;
 //# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAA4B,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAS5E,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AA2KjF,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,aAAa,GAAG,SAAS,CAG3B;AAED,wBAAgB,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMvF"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAA4B,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA0B5E,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AA6NjF,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,aAAa,GAAG,SAAS,CAI3B;AAYD,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,SAAS,MAAM,EAAE,CAGnB;AAED,wBAAgB,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMvF"}

package/dist/schema.js

@@ -1,6 +1,7 @@
 import { Validator } from '@cfworker/json-schema';
 import { escapePointer, refTarget } from './definition.js';
 import { MEMBER_FIELD, RECEIVED_FIELD, SITE_FIELD, TYPE_FIELD } from './fields.js';
+import { withLinearRegExp } from './pattern.js';
 import { interpretPlain, isRecord } from './yaml.js';
 const STANDING_MAPS = ['properties', 'patternProperties'];
 const STANDING = [
@@ -95,10 +96,49 @@ function closed(node, inPlace, defs, always = false) {
 function copied(value) {
     return JSON.parse(JSON.stringify(value));
 }
+function asks(asked) {
+    return asked.sections.length > 0 || asked.conditions.length > 0;
+}
+function branchOf(node, defs, closedDefs) {
+    if (!isRecord(node))
+        return { schema: node, asked: { sections: [], conditions: [] } };
+    const { sections, ...rest } = node;
+    const read = unconditioned(rest, defs, closedDefs);
+    const required = Object.entries(isRecord(sections) ? sections : {}).flatMap(([name, spec]) => isRecord(spec) && spec.required === true ? [name] : []);
+    return { schema: read.schema, asked: { sections: required, conditions: read.conditions } };
+}
+function unconditioned(node, defs, closedDefs) {
+    if (!isRecord(node))
+        return { schema: node, conditions: [] };
+    const schema = { ...node };
+    const conditions = [];
+    if (Array.isArray(node.allOf))
+        schema.allOf = node.allOf.map((entry) => {
+            const read = unconditioned(entry, defs, closedDefs);
+            conditions.push(...read.conditions);
+            return read.schema;
+        });
+    if (node.if === undefined)
+        return { schema, conditions };
+    const met = branchOf(node.then, defs, closedDefs);
+    const unmet = branchOf(node.else, defs, closedDefs);
+    if (node.then !== undefined)
+        schema.then = met.schema;
+    if (node.else !== undefined)
+        schema.else = unmet.schema;
+    if (!asks(met.asked) && !asks(unmet.asked))
+        return { schema, conditions };
+    const test = new Validator(isRecord(node.if)
+        ? { ...closed(node.if, true, defs), $defs: closedDefs }
+        : node.if === true, '2020-12', false);
+    return { schema, conditions: [...conditions, { test, met: met.asked, unmet: unmet.asked }] };
+}
 function compile(definition) {
     const defs = copied(definition.shape.defs);
-    const { sections, member_document: _mark, ...root } = copied(definition.shape.schema);
+    const { sections, member_document: _mark, ...written } = copied(definition.shape.schema);
     const closedDefs = mapped(defs, (held) => closed(held, true, defs));
+    const read = unconditioned(written, defs, closedDefs);
+    const root = read.schema;
     const declared = isRecord(root.properties) ? root.properties : {};
     const properties = {
         [TYPE_FIELD]: true,
@@ -114,7 +154,7 @@ function compile(definition) {
             continue;
         lists.set(name, new Validator({ ...closed(spec.items, false, defs), $defs: closedDefs }, '2020-12', false));
     }
-    return { frontmatter, sections: lists };
+    return { frontmatter, sections: lists, conditions: read.conditions };
 }
 function compiledOf(definition) {
     const held = compiled.get(definition);
@@ -150,14 +190,25 @@ function refusalOf(errors) {
     return { rule: 'schema', location: '' };
 }
 export function frontmatterRefusal(definition, fields) {
-    const result = compiledOf(definition).frontmatter.validate(fields);
+    const { frontmatter } = compiledOf(definition);
+    const result = withLinearRegExp(() => frontmatter.validate(fields));
     return result.valid ? undefined : refusalOf(result.errors);
 }
+function askedOf(conditions, fields) {
+    return conditions.flatMap((condition) => {
+        const asked = condition.test.validate(fields).valid ? condition.met : condition.unmet;
+        return [...asked.sections, ...askedOf(asked.conditions, fields)];
+    });
+}
+export function conditionedSections(definition, fields) {
+    const { conditions } = compiledOf(definition);
+    return withLinearRegExp(() => askedOf(conditions, fields));
+}
 export function fitsItem(definition, section, text) {
     const spec = definition.sections[section];
     const validator = compiledOf(definition).sections.get(section);
     if (spec?.kind !== 'list' || validator === undefined)
         return false;
     const typed = spec.items.type === 'string' ? text : interpretPlain(text);
-    return validator.validate(typed).valid;
+    return withLinearRegExp(() => validator.validate(typed).valid);
 }