@agentshouse/mdmodel 0.1.0-alpha.8 → 0.1.0-c2987f5d89720

package/dist/paths.d.ts

@@ -1,9 +1,6 @@
 export declare function dirname(path: string): string;
 export declare function join(base: string, relative: string): string;
 export declare function normalize(path: string): string | null;
-export declare function isTypesPath(path: string): boolean;
-export declare function typeNameFromPath(path: string): string;
-export declare function hrefSuffix(href: string): string;
 export declare function classifyHref(from: string, href: string): {
     kind: 'skip';
 } | {
@@ -12,4 +9,9 @@ export declare function classifyHref(from: string, href: string): {
 } | {
     kind: 'invalid';
 };
+export declare function target(from: string, href: string): string | null;
+export declare function retarget(href: string, to: string): string;
+export declare function relative(from: string, target: string): string;
+export declare const SHELL_ROOMS = "/rooms/";
+export declare function shellTarget(href: string, handle: string): string | null;
 //# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5C;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG3D;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYrD;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAUzE"}
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5C;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG3D;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYrD;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAUzE;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAW7D;AAED,eAAO,MAAM,WAAW,YAAY,CAAC;AAErC,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKvE"}

package/dist/paths.js

@@ -3,15 +3,18 @@ export function dirname(path) {
     return index === -1 ? '' : path.slice(0, index);
 }
 export function join(base, relative) {
-    if (base === '') return relative;
+    if (base === '')
+        return relative;
     return `${base}/${relative}`;
 }
 export function normalize(path) {
     const parts = [];
-    for (const part of path.split('/')){
-        if (part === '' || part === '.') continue;
+    for (const part of path.split('/')) {
+        if (part === '' || part === '.')
+            continue;
         if (part === '..') {
-            if (parts.length === 0) return null;
+            if (parts.length === 0)
+                return null;
             parts.pop();
             continue;
         }
@@ -19,41 +22,48 @@ export function normalize(path) {
     }
     return parts.join('/');
 }
-export function isTypesPath(path) {
-    return path === 'types' || path.startsWith('types/');
+export function classifyHref(from, href) {
+    const trimmed = href.trim();
+    if (trimmed === '' || trimmed.startsWith('#'))
+        return { kind: 'skip' };
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed))
+        return { kind: 'skip' };
+    if (trimmed.startsWith('/'))
+        return { kind: 'invalid' };
+    const bare = trimmed.replace(/[?#].*$/, '');
+    if (bare === '')
+        return { kind: 'skip' };
+    const resolved = normalize(join(dirname(from), bare));
+    if (resolved === null || resolved === '')
+        return { kind: 'invalid' };
+    return { kind: 'path', path: resolved };
 }
-export function typeNameFromPath(path) {
-    const base = path.slice(path.lastIndexOf('/') + 1);
-    return base.endsWith('.md') ? base.slice(0, -3) : base;
+export function target(from, href) {
+    const resolved = classifyHref(from, href);
+    return resolved.kind === 'path' ? resolved.path : null;
 }
-export function hrefSuffix(href) {
+export function retarget(href, to) {
     const trimmed = href.trim();
     const match = /[?#]/.exec(trimmed);
-    return match === null ? '' : trimmed.slice(match.index);
+    return match === null ? to : to + trimmed.slice(match.index);
+}
+export function relative(from, target) {
+    const base = dirname(from)
+        .split('/')
+        .filter((part) => part !== '');
+    const parts = target.split('/');
+    let shared = 0;
+    while (shared < base.length && shared + 1 < parts.length && base[shared] === parts[shared]) {
+        shared += 1;
+    }
+    const up = Array.from({ length: base.length - shared }, () => '..');
+    return [...up, ...parts.slice(shared)].join('/');
+}
+export const SHELL_ROOMS = '/rooms/';
+export function shellTarget(href, handle) {
+    const prefix = `${SHELL_ROOMS}${handle}/`;
+    if (!href.startsWith(prefix))
+        return null;
+    const path = normalize(href.slice(prefix.length).replace(/[?#].*$/s, ''));
+    return path === null || path === '' ? null : path;
 }
-export function classifyHref(from, href) {
-    const trimmed = href.trim();
-    if (trimmed === '' || trimmed.startsWith('#')) return {
-        kind: 'skip'
-    };
-    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed)) return {
-        kind: 'skip'
-    };
-    if (trimmed.startsWith('/')) return {
-        kind: 'invalid'
-    };
-    const bare = trimmed.replace(/[?#].*$/, '');
-    if (bare === '') return {
-        kind: 'skip'
-    };
-    const resolved = normalize(join(dirname(from), bare));
-    if (resolved === null || resolved === '') return {
-        kind: 'invalid'
-    };
-    return {
-        kind: 'path',
-        path: resolved
-    };
-}
-
-//# sourceMappingURL=paths.js.map

package/dist/profile.js

@@ -1,7 +1,5 @@
 export const MARKDOWN_SYNTAX_PROFILE = {
     name: 'GitHub Flavored Markdown',
     spec: '0.29',
-    url: 'https://github.github.com/gfm/'
+    url: 'https://github.github.com/gfm/',
 };
-
-//# sourceMappingURL=profile.js.map

package/dist/project.d.ts

@@ -1,3 +1,21 @@
-import type { Document, Projection, ProjectionContext } from './types.js';
+import type { Document, Extent, Projection, ProjectionContext, Refusal } from './types.js';
+export type Piece = Extent & {
+    readonly text: string;
+};
+export type Edit = Piece;
+export type Input = {
+    readonly values: readonly Piece[];
+    readonly ranges: readonly Extent[];
+    readonly edits: readonly Edit[];
+};
+export type InputResult = {
+    readonly ok: true;
+    readonly input: Input;
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+export declare function rangeText(content: string, range: Extent, edits: readonly Edit[]): string;
+export declare function projectionInput(document: Document, file: string, context: ProjectionContext): InputResult;
 export declare function project(document: Document, file: string, context?: ProjectionContext): Projection;
 //# sourceMappingURL=project.d.ts.map

package/dist/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA8C1E,wBAAgB,OAAO,CACrB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,iBAA2C,GACnD,UAAU,CA0BZ"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG3F,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC;AAEzB,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GAC5C;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAmCtD,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,MAAM,CASxF;AA4BD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,iBAAiB,GACzB,WAAW,CAyBb;AAED,wBAAgB,OAAO,CACrB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,iBAA2C,GACnD,UAAU,CAMZ"}

package/dist/project.js

@@ -1,96 +1,105 @@
-import { readDefinition } from './definition.js';
-import { parse } from './document.js';
+import { memberFacts } from './definition.js';
+import { frontmatter } from './document.js';
 import { linkInventory } from './links.js';
-import { classifyHref } from './paths.js';
+import { target } from './paths.js';
 import { refusal } from './refuse.js';
 import { headingSpans } from './sections.js';
 import { bodyStartOf } from './yaml.js';
-function internalEdits(body, file, documentTargets) {
-    const inventory = linkInventory(body);
+function internalEdits(content, bodyStart, file, documentTargets) {
+    const inventory = linkInventory(content.slice(bodyStart));
     const internal = new Set();
     const edits = [];
-    for (const use of inventory.uses){
-        const resolved = classifyHref(file, use.destination.href);
-        if (resolved.kind !== 'path' || !documentTargets.has(resolved.path)) continue;
+    const uses = [...inventory.uses].sort((left, right) => left.end - left.start - (right.end - right.start));
+    for (const use of uses) {
+        const resolved = target(file, use.destination.href);
+        if (resolved === null || !documentTargets.has(resolved))
+            continue;
         internal.add(use.destination.start);
+        const label = { start: bodyStart + use.labelStart, end: bodyStart + use.labelEnd };
+        const inner = edits
+            .filter((edit) => edit.start >= label.start && edit.end <= label.end)
+            .sort((left, right) => left.start - right.start);
         edits.push({
-            start: use.start,
-            end: use.end,
-            text: body.slice(use.labelStart, use.labelEnd)
+            start: bodyStart + use.start,
+            end: bodyStart + use.end,
+            text: rangeText(content, label, inner),
         });
     }
-    for (const block of inventory.blocks){
-        if (!internal.has(block.destination.start)) continue;
-        edits.push({
-            start: block.start,
-            end: block.end,
-            text: ''
-        });
+    for (const block of inventory.blocks) {
+        if (!internal.has(block.destination.start))
+            continue;
+        edits.push({ start: bodyStart + block.start, end: bodyStart + block.end, text: '' });
     }
-    return edits.sort((left, right)=>left.start - right.start);
+    return edits.sort((left, right) => left.start - right.start);
 }
-function projected(body, spans, edits) {
+export function rangeText(content, range, edits) {
     let text = '';
-    for (const [from, to] of spans){
-        let cursor = from;
-        for (const edit of edits){
-            if (edit.start < cursor || edit.end > to) continue;
-            text += body.slice(cursor, edit.start) + edit.text;
-            cursor = edit.end;
-        }
-        text += body.slice(cursor, to);
+    let cursor = range.start;
+    for (const edit of edits) {
+        if (edit.start < cursor || edit.end > range.end)
+            continue;
+        text += content.slice(cursor, edit.start) + edit.text;
+        cursor = edit.end;
+    }
+    return text + content.slice(cursor, range.end);
+}
+function structural(spec) {
+    return spec.kind === 'list' && !spec.items.prose;
+}
+function proseValues(node, facts, values) {
+    if (facts === undefined)
+        return;
+    if (node.kind === 'scalar') {
+        if (facts.prose && typeof node.value === 'string')
+            values.push({ start: node.start, end: node.end, text: `${node.value}\n\n` });
+        return;
+    }
+    if (node.kind === 'seq') {
+        for (const item of node.items)
+            proseValues(item, facts.items, values);
+        return;
     }
-    return text;
+    for (const entry of node.entries)
+        proseValues(entry.value, memberFacts(facts, entry.key), values);
 }
-export function project(document, file, context = {
-    documentTargets: []
-}) {
-    const bodyStart = bodyStartOf(document.content);
-    const body = document.content.slice(bodyStart);
-    const edits = internalEdits(body, file, new Set(context.documentTargets));
+function freeTextValues(definition, document) {
+    const root = frontmatter(document);
+    if (root === null)
+        return [];
+    const values = [];
+    proseValues(root, definition.frontmatter, values);
+    return values;
+}
+export function projectionInput(document, file, context) {
+    const content = document.content;
+    const bodyStart = bodyStartOf(content);
+    const edits = internalEdits(content, bodyStart, file, new Set(context.documentTargets));
     const declared = document.type;
     if (declared === undefined || declared === 'any') {
         return {
             ok: true,
-            text: projected(body, [
-                [
-                    0,
-                    body.length
-                ]
-            ], edits)
+            input: { values: [], ranges: [{ start: bodyStart, end: content.length }], edits },
         };
     }
-    const source = context.definition;
-    if (source === undefined) {
-        return {
-            ok: false,
-            refusal: refusal(file, 'unknown-type', {
-                location: 'type'
-            })
-        };
+    const definition = context.definition;
+    if (definition === undefined) {
+        return { ok: false, refusal: refusal(file, 'unknown-type', { location: 'type' }) };
     }
-    const definitionFile = `types/${declared}.md`;
-    const parsed = parse(source, definitionFile);
-    if (!parsed.ok) return {
-        ok: false,
-        refusal: parsed.refusal
-    };
-    const definition = readDefinition(definitionFile, parsed.document);
-    if ('rule' in definition) return {
-        ok: false,
-        refusal: definition
-    };
-    const free = new Set(Object.entries(definition.sections).flatMap(([name, spec])=>spec.kind === 'text' ? [
-            name
-        ] : []));
-    const spans = headingSpans(document.content, bodyStart).filter((span)=>free.has(span.name)).map((span)=>[
-            span.headingStart - bodyStart,
-            span.bodyEnd - bodyStart
-        ]);
-    return {
-        ok: true,
-        text: projected(body, spans, edits)
-    };
+    const structure = new Set(Object.entries(definition.sections).flatMap(([name, spec]) => (structural(spec) ? [name] : [])));
+    const headings = headingSpans(content, bodyStart);
+    const ranges = [{ start: bodyStart, end: headings[0]?.headingStart ?? content.length }];
+    for (const heading of headings) {
+        if (structure.has(heading.name))
+            continue;
+        ranges.push({ start: heading.headingStart, end: heading.bodyEnd });
+    }
+    return { ok: true, input: { values: freeTextValues(definition, document), ranges, edits } };
+}
+export function project(document, file, context = { documentTargets: [] }) {
+    const result = projectionInput(document, file, context);
+    if (!result.ok)
+        return { ok: false, refusal: result.refusal };
+    const { values, ranges, edits } = result.input;
+    const prose = ranges.map((range) => rangeText(document.content, range, edits)).join('');
+    return { ok: true, text: values.map((value) => value.text).join('') + prose };
 }
-
-//# sourceMappingURL=project.js.map

package/dist/references.d.ts

@@ -0,0 +1,4 @@
+import { type Definition } from './definition.js';
+import type { Document, Reference } from './types.js';
+export declare function references(document: Document, definition: Definition): readonly Reference[];
+//# sourceMappingURL=references.d.ts.map

package/dist/references.d.ts.map

@@ -0,0 +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,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAwBtD,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,GAAG,SAAS,SAAS,EAAE,CAI3F"}

package/dist/references.js

@@ -0,0 +1,25 @@
+import { escapePointer, itemFacts, memberFacts, } from './definition.js';
+import { isRecord } from './yaml.js';
+function collect(value, facts, pointer, found) {
+    if (facts === undefined)
+        return;
+    if (typeof value === 'string') {
+        if (facts.reference !== undefined)
+            found.push({ pointer, value, to: facts.reference });
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const [index, item] of value.entries())
+            collect(item, itemFacts(facts, index), `${pointer}/${index}`, found);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    for (const [key, held] of Object.entries(value))
+        collect(held, memberFacts(facts, key), `${pointer}/${escapePointer(key)}`, found);
+}
+export function references(document, definition) {
+    const found = [];
+    collect(document.fields, definition.frontmatter, '', found);
+    return found;
+}

package/dist/refuse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refuse.d.ts","sourceRoot":"","sources":["../src/refuse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG1C,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC3D,OAAO,CAQT"}
+{"version":3,"file":"refuse.d.ts","sourceRoot":"","sources":["../src/refuse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC3D,OAAO,CAOT"}

package/dist/refuse.js

@@ -1,16 +1,8 @@
-import { VERSION } from './version.js';
 export function refusal(file, rule, extra) {
     return {
         file,
         rule,
-        version: VERSION,
-        ...extra?.location === undefined ? {} : {
-            location: extra.location
-        },
-        ...extra?.referrers === undefined ? {} : {
-            referrers: extra.referrers
-        }
+        ...(extra?.location === undefined ? {} : { location: extra.location }),
+        ...(extra?.referrers === undefined ? {} : { referrers: extra.referrers }),
     };
 }
-
-//# sourceMappingURL=refuse.js.map

package/dist/schema.d.ts

@@ -1,6 +1,8 @@
-import type { FieldSpec } from './definition.js';
-export declare function validateFields(fields: Readonly<Record<string, FieldSpec>>, values: Readonly<Record<string, unknown>>): {
-    field: string;
-    rule: 'required-field' | 'field-enum' | 'field-kind';
-} | undefined;
+import { type Definition } from './definition.js';
+export type SchemaRefusal = {
+    readonly rule: string;
+    readonly location: string;
+};
+export declare function frontmatterRefusal(definition: Definition, fields: Readonly<Record<string, unknown>>): SchemaRefusal | undefined;
+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,KAAK,EAAE,SAAS,EAAc,MAAM,iBAAiB,CAAC;AAkB7D,wBAAgB,cAAc,CAC5B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,EAC3C,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,gBAAgB,GAAG,YAAY,GAAG,YAAY,CAAA;CAAE,GAAG,SAAS,CAUrF"}
+{"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"}

package/dist/schema.js

@@ -1,48 +1,163 @@
 import { Validator } from '@cfworker/json-schema';
-function scalarSchema(spec) {
-    if (spec.kind === 'string' || spec.kind === 'reference') return {
-        type: 'string'
-    };
-    if (spec.kind === 'number') return {
-        type: 'number'
-    };
-    if (spec.kind === 'date') return {
-        type: 'string',
-        format: 'date'
-    };
-    return {
-        type: 'string',
-        enum: [
-            ...spec.values
-        ]
-    };
+import { escapePointer, refTarget } from './definition.js';
+import { MEMBER_FIELD, RECEIVED_FIELD, SITE_FIELD } from './fields.js';
+import { interpretPlain, isRecord } from './yaml.js';
+const STANDING_MAPS = ['properties', 'patternProperties'];
+const STANDING = [
+    'additionalProperties',
+    'unevaluatedProperties',
+    'items',
+    'unevaluatedItems',
+    'contains',
+];
+const STANDING_LISTS = ['prefixItems'];
+const IN_PLACE = ['if', 'then', 'else'];
+const IN_PLACE_LISTS = ['allOf', 'anyOf', 'oneOf'];
+const IN_PLACE_MAPS = ['dependentSchemas'];
+const PASSING = new Set([
+    'properties',
+    'patternProperties',
+    '$ref',
+    'items',
+    'prefixItems',
+    'unevaluatedItems',
+    'allOf',
+    'if',
+    'dependentSchemas',
+]);
+const OPENING = new Set(['additionalProperties', 'unevaluatedProperties']);
+const REQUIRED = /required property "([\s\S]*)"\.$/u;
+const compiled = new WeakMap();
+function mapped(value, map) {
+    return Object.fromEntries(Object.entries(value).map(([key, held]) => [key, map(held)]));
 }
-function fieldSchema(spec) {
-    if (spec.kind === 'list') return {
-        type: 'array',
-        items: scalarSchema(spec.of)
-    };
-    return scalarSchema(spec);
+function objectSchema(node) {
+    const type = node.type;
+    return (type === 'object' ||
+        (Array.isArray(type) && type.includes('object')) ||
+        node.properties !== undefined ||
+        node.patternProperties !== undefined);
 }
-function ruleFor(error) {
-    return error.keyword === 'enum' ? 'field-enum' : 'field-kind';
+function inPlaceChildren(node) {
+    return [
+        ...IN_PLACE.map((key) => node[key]),
+        ...IN_PLACE_LISTS.flatMap((key) => (Array.isArray(node[key]) ? node[key] : [])),
+        ...IN_PLACE_MAPS.flatMap((key) => (isRecord(node[key]) ? Object.values(node[key]) : [])),
+    ];
 }
-export function validateFields(fields, values) {
-    for (const [name, spec] of Object.entries(fields)){
-        if (spec.required && values[name] === undefined) return {
-            field: name,
-            rule: 'required-field'
-        };
+function objecty(node, defs, seen) {
+    if (!isRecord(node))
+        return false;
+    if (objectSchema(node))
+        return true;
+    if (typeof node.$ref === 'string') {
+        const target = refTarget(node.$ref, defs)?.node;
+        if (target !== undefined &&
+            !seen.has(target) &&
+            objecty(target, defs, new Set([...seen, target])))
+            return true;
     }
-    for (const [name, spec] of Object.entries(fields)){
-        if (values[name] === undefined) continue;
-        const result = new Validator(fieldSchema(spec), '2020-12', false).validate(values[name]);
-        if (!result.valid) return {
-            field: name,
-            rule: ruleFor(result.errors[0])
-        };
+    return inPlaceChildren(node).some((child) => objecty(child, defs, seen));
+}
+function closed(node, inPlace, defs, always = false) {
+    if (!isRecord(node))
+        return node;
+    const out = { ...node };
+    const standing = (held) => closed(held, false, defs);
+    const nested = (held) => closed(held, true, defs);
+    for (const key of STANDING_MAPS)
+        if (isRecord(node[key]))
+            out[key] = mapped(node[key], standing);
+    for (const key of STANDING)
+        if (node[key] !== undefined)
+            out[key] = standing(node[key]);
+    for (const key of STANDING_LISTS)
+        if (Array.isArray(node[key]))
+            out[key] = node[key].map(standing);
+    for (const key of IN_PLACE)
+        if (node[key] !== undefined)
+            out[key] = nested(node[key]);
+    for (const key of IN_PLACE_LISTS)
+        if (Array.isArray(node[key]))
+            out[key] = node[key].map(nested);
+    for (const key of IN_PLACE_MAPS)
+        if (isRecord(node[key]))
+            out[key] = mapped(node[key], nested);
+    if (isRecord(node.$defs))
+        out.$defs = mapped(node.$defs, nested);
+    if (!inPlace &&
+        node.additionalProperties === undefined &&
+        node.unevaluatedProperties === undefined &&
+        (always || objecty(node, defs, new Set())))
+        out.unevaluatedProperties = false;
+    return out;
+}
+function copied(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function compile(definition) {
+    const defs = copied(definition.shape.defs);
+    const { sections, member_document: _mark, ...root } = copied(definition.shape.schema);
+    const closedDefs = mapped(defs, (held) => closed(held, true, defs));
+    const declared = isRecord(root.properties) ? root.properties : {};
+    const properties = {
+        type: true,
+        [SITE_FIELD]: true,
+        [RECEIVED_FIELD]: true,
+        ...(definition.memberDocument ? { [MEMBER_FIELD]: { type: 'string' } } : {}),
+        ...declared,
+    };
+    const frontmatter = new Validator({ ...closed({ ...root, properties }, false, defs, true), $defs: closedDefs }, '2020-12', false);
+    const lists = new Map();
+    for (const [name, spec] of Object.entries(isRecord(sections) ? sections : {})) {
+        if (!isRecord(spec) || spec.kind !== 'list')
+            continue;
+        lists.set(name, new Validator({ ...closed(spec.items, false, defs), $defs: closedDefs }, '2020-12', false));
     }
-    return undefined;
+    return { frontmatter, sections: lists };
+}
+function compiledOf(definition) {
+    const held = compiled.get(definition);
+    if (held !== undefined)
+        return held;
+    const made = compile(definition);
+    compiled.set(definition, made);
+    return made;
+}
+function pointer(location) {
+    return decodeURI(location.slice(1));
+}
+function refusalOf(errors) {
+    for (const [index, error] of errors.entries()) {
+        const next = errors[index + 1];
+        if (OPENING.has(error.keyword)) {
+            if (next?.keyword === 'false')
+                return { rule: 'undeclared-field', location: pointer(next.instanceLocation) };
+            if (next !== undefined)
+                continue;
+        }
+        if (PASSING.has(error.keyword) && next !== undefined)
+            continue;
+        if (error.keyword === 'required') {
+            const missing = REQUIRED.exec(error.error)?.[1] ?? '';
+            return {
+                rule: 'required',
+                location: `${pointer(error.instanceLocation)}/${escapePointer(missing)}`,
+            };
+        }
+        return { rule: error.keyword, location: pointer(error.instanceLocation) };
+    }
+    return { rule: 'schema', location: '' };
+}
+export function frontmatterRefusal(definition, fields) {
+    const result = compiledOf(definition).frontmatter.validate(fields);
+    return result.valid ? undefined : refusalOf(result.errors);
+}
+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;
 }
-
-//# sourceMappingURL=schema.js.map