@cruba/crubal 0.0.0-stage → 0.2.0

package/dist/src/dictionary.d.ts

@@ -0,0 +1,65 @@
+import type { ClassLine, Dictionary, Facet } from "./defs.ts";
+import type { Json, JsonObject, Record } from "./model.ts";
+/** A fold key (4.3): NFC, case-folded, trimmed, inner white space made one space. */
+export declare function foldKey(s: string): string;
+export declare function facetJson(f: Facet): JsonObject;
+export type Warning = {
+    line: number;
+    message: string;
+};
+/** Run every publish check on a dictionary. Throws the first error; returns warnings. */
+export declare function checkPackage(dict: Dictionary): Warning[];
+export type ResolvedLine = {
+    facet: string;
+    required?: boolean;
+    values?: string[];
+    length?: number;
+    pick?: string;
+    range?: {
+        min: string;
+        max: string;
+    };
+    levels: string[];
+    when?: string;
+    section?: string;
+    /** Every line that contributed, as `Class: line`, in resolution order. */
+    from: {
+        cls: string;
+        line: ClassLine;
+    }[];
+};
+/** Resolve the meet of classes (a class with its uses, or everything a record wears). */
+export declare function resolve(dict: Dictionary, names: string[], line?: number): ResolvedLine[];
+/** A resolved class as JSON, as the corpus states it. */
+export declare function resolvedJson(lines: ResolvedLine[]): JsonObject[];
+export declare function foldValue(f: Facet, v: Json, dict: Dictionary): Json;
+/** Fold a record: key aliases, value aliases and accepted units become real names (chapter 4.3). */
+export declare function foldRecord(r: Record, dict: Dictionary): Record;
+export type Outcome = {
+    [key: string]: Json;
+};
+declare const RANK: {
+    readonly year: 0;
+    readonly month: 1;
+    readonly day: 2;
+    readonly hour: 3;
+    readonly minute: 4;
+    readonly second: 5;
+};
+/** A date's precision and whether it is well formed (1.4.5): real calendar parts and clock parts. */
+export declare function dateParts(d: string): {
+    precision: keyof typeof RANK;
+    offset: string | null;
+} | null;
+/** Check one scalar against its facet: an outcome and an optional flag. */
+export declare function checkScalar(f: Facet, v: Json): {
+    outcome: string;
+    flag?: string;
+    cites?: JsonObject;
+};
+/** Check a record: every value against its facet and worn classes, required facets, and parts. */
+export declare function checkRecord(r: Record, dict: Dictionary): {
+    outcomes: Outcome[];
+    summary: Outcome;
+};
+export {};

package/dist/src/dictionary.js

@@ -0,0 +1,557 @@
+// dictionary.ts: the Dictionary level (spec chapters 4 and 5). Definitions as JSON (4.6), the publish
+// checks on definitions and classes (4.7, 5.10), class resolution by meet (5.4), alias folding (4.3), and
+// checking each value against its facet and the classes its record wears (4.9, 5.3, 5.5, 5.6).
+import { evaluate, parseCondition } from "./conditions.js";
+import { itemText } from "./print-text.js";
+import { readUnder } from "./read-text.js";
+import { CrubalError } from "./tree.js";
+import { convert, knownUnit, unitOf } from "./units.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** A fold key (4.3): NFC, case-folded, trimmed, inner white space made one space. */
+export function foldKey(s) {
+    return s.normalize("NFC").toLowerCase().trim().replace(/\s+/g, " ");
+}
+// ─── Definitions as JSON (4.6) ────────────────────────────────────────────────
+export function facetJson(f) {
+    const o = { facet: f.key, type: f.type };
+    const put = (k, v, skip) => {
+        if (v === undefined || v === skip)
+            return;
+        if (Array.isArray(v) && v.length === 0)
+            return;
+        o[k] = v;
+    };
+    put("label", f.label);
+    put("ask", f.ask);
+    put("describe", f.describe);
+    put("pick", f.pick, "1");
+    put("ordered", f.ordered || undefined);
+    put("state", f.state, "active");
+    put("qualifiers", f.qualifiers);
+    put("aliases", f.aliases);
+    put("same-as", f.sameAs);
+    put("agree-by", f.agreeBy);
+    put("length", f.length === undefined ? undefined : String(f.length));
+    put("unit", f.unit);
+    put("accepts", f.accepts);
+    if (f.range)
+        o.range = { ...f.range };
+    put("places", f.places === undefined ? undefined : String(f.places));
+    put("precision", f.precision, "any");
+    if (f.words)
+        o.words = [...f.words];
+    if (f.values)
+        o.values = f.values.map((v) => (v.aliases.length ? { value: v.value, aliases: [...v.aliases] } : { value: v.value }));
+    put("open", f.open || undefined);
+    for (const k of ["fixed", "ranked", "scored", "required", "na", "unique", "transitions"])
+        put(k, f[k] || undefined);
+    put("to", f.to);
+    if (f.children)
+        o.facets = [...f.children.values()].map(facetJson);
+    put("identity", f.identity);
+    put("when", f.when);
+    put("combine", f.combine);
+    put("version", f.version);
+    for (const [k, v] of Object.entries(f.extra))
+        o[k] = v;
+    return o;
+}
+function checkFacet(f) {
+    const line = f.line;
+    if (f.type === "choice" && !f.values?.length)
+        throw new CrubalError(`the choice facet ${f.key} has no values`, line);
+    if (f.type === "compound" && !f.children?.size)
+        throw new CrubalError(`the compound facet ${f.key} has no children`, line);
+    if (f.open && f.fixed)
+        throw new CrubalError(`the list of ${f.key} is both open and fixed`, line);
+    if ((f.ranked || f.scored || f.fixed || f.open) && f.type !== "choice") {
+        throw new CrubalError(`${f.key}: ranked, scored, fixed and open lists are for choice facets`, line);
+    }
+    if (f.ordered && !f.many)
+        throw new CrubalError(`${f.key} is ordered but holds one value`, line);
+    if (f.accepts.length && !f.unit)
+        throw new CrubalError(`${f.key} accepts other units but has no unit`, line);
+    // 4.7 (6): a unit is a spelling from the units table, `currency`, or an ISO 4217 code.
+    for (const u of [...(f.unit ? [f.unit] : []), ...f.accepts])
+        if (!knownUnit(u))
+            throw new CrubalError(`${f.key}: ${u} isn't a unit the units table knows`, line);
+    if (f.range && Number(f.range.min) > Number(f.range.max))
+        throw new CrubalError(`${f.key}'s range runs backwards`, line);
+    if (f.identity) {
+        const child = f.children?.get(f.identity);
+        if (!child)
+            throw new CrubalError(`the identity child ${f.identity} of ${f.key} isn't one of its children`, line);
+        if (child.type !== "link")
+            throw new CrubalError(`the identity child ${f.identity} of ${f.key} is not a link`, line);
+    }
+    const seen = new Map();
+    for (const v of f.values ?? []) {
+        for (const spelling of [v.value, ...v.aliases]) {
+            const k = foldKey(spelling);
+            const owner = seen.get(k);
+            if (owner !== undefined && owner !== v.value) {
+                throw new CrubalError(`${f.key}: the spelling ${spelling} folds to the same as ${owner}`, line);
+            }
+            seen.set(k, v.value);
+        }
+    }
+    for (const c of f.children?.values() ?? []) {
+        if (["row", "origin", "via", "owner"].includes(c.key))
+            throw new CrubalError(`${f.key} has a child named ${c.key}, which is reserved`, line);
+        checkFacet(c);
+    }
+}
+/** Run every publish check on a dictionary. Throws the first error; returns warnings. */
+export function checkPackage(dict) {
+    const warnings = [];
+    // An identify key names a record, so it must be a facet and unique (11.2).
+    for (const [level, ks] of dict.identify) {
+        for (const k of ks) {
+            const f = dict.facets.get(k);
+            if (!f)
+                throw new CrubalError(`identify names ${k} at ${level}, which isn't a facet`);
+            if (!f.unique)
+                throw new CrubalError(`${k} is an identify key at ${level}, so it must be unique`, f.line);
+        }
+    }
+    const keys = new Map();
+    for (const f of dict.facets.values()) {
+        if (f.key.startsWith("crubal:"))
+            continue;
+        checkFacet(f);
+        for (const spelling of [f.key, ...f.aliases]) {
+            const k = foldKey(spelling);
+            const owner = keys.get(k);
+            if (owner !== undefined && owner !== f.key) {
+                const what = spelling === f.key ? `the key ${f.key}` : `the alias ${spelling} of ${f.key}`;
+                throw new CrubalError(`${what} folds to ${owner === k ? "the key" : "an alias"} of ${owner}`, f.line);
+            }
+            keys.set(k, f.key);
+        }
+    }
+    for (const c of dict.classes.values()) {
+        for (const l of c.lines)
+            checkClassLine(c, l, dict);
+        for (const slot of c.parts) {
+            if (!dict.classes.has(slot.wears))
+                throw new CrubalError(`the part slot ${slot.slot} wears ${slot.wears}, which isn't a class`, slot.line);
+        }
+    }
+    // 5.10 (4): a level prefix names a level of every kind in `for` (every kind, when `for` is absent).
+    const kindsAll = [...new Set(dict.levels.values())];
+    const levelsOf = (kind) => [...dict.levels].filter(([, k]) => k === kind).map(([l]) => l);
+    for (const c of dict.classes.values()) {
+        for (const l of c.lines) {
+            if (!l.level)
+                continue;
+            for (const kind of c.for.length ? c.for : kindsAll)
+                if (!levelsOf(kind).includes(l.level))
+                    throw new CrubalError(`${c.name}: ${l.level}:: isn't a level of ${kind}`, l.line);
+        }
+    }
+    for (const c of dict.classes.values()) {
+        findCycle(c.name, dict, []);
+        resolve(dict, [c.name], c.line);
+        warnings.push(...redundantLines(c, dict));
+    }
+    return warnings;
+}
+function checkClassLine(c, l, dict) {
+    const f = dict.facets.get(l.facet);
+    if (!f)
+        throw new CrubalError(`the class line ${l.text} names a facet that isn't defined`, l.line);
+    if (f.state === "candidate")
+        throw new CrubalError(`${f.key} is a candidate; a class line can only name an active facet`, l.line);
+    if (f.state === "retired")
+        throw new CrubalError(`${f.key} is retired; a class line can only name an active facet`, l.line);
+    const type = l.type;
+    if (type && type !== f.type)
+        throw new CrubalError(`the class line ${l.text} marks ${f.key} as ${type}, but it is ${f.type}`, l.line);
+    if (l.values) {
+        const real = new Set((f.values ?? []).map((v) => v.value));
+        const extra = l.values.filter((v) => !real.has(v));
+        if (extra.length)
+            throw new CrubalError(`the class line ${l.text} widens ${f.key}: ${extra.join(", ")} is not one of its values`, l.line);
+    }
+    if (l.length !== undefined && f.length !== undefined && l.length > f.length)
+        throw new CrubalError(`the class line ${l.text} widens ${f.key}'s length`, l.line);
+    if (l.pick && f.pick !== "any" && (l.pick === "any" || Number(l.pick) > Number(f.pick)))
+        throw new CrubalError(`the class line ${l.text} widens ${f.key}'s pick`, l.line);
+    if (l.range && f.range && (Number(l.range.min) < Number(f.range.min) || Number(l.range.max) > Number(f.range.max))) {
+        throw new CrubalError(`the class line ${l.text} widens ${f.key}'s range`, l.line);
+    }
+    if (l.when)
+        parseCondition(l.when, l.line);
+    if (l.frame && f.type !== "image")
+        throw new CrubalError(`the class line ${l.text} gives ${f.key} a frame, but it isn't an image`, l.line);
+    void c;
+}
+function findCycle(name, dict, path) {
+    if (path.includes(name)) {
+        const loop = path.slice(path.indexOf(name));
+        const first = dict.classes.get(loop[0]);
+        throw new CrubalError(`the classes ${loop.join(" and ")} use each other`, first?.line);
+    }
+    const c = dict.classes.get(name);
+    if (!c)
+        return;
+    for (const u of c.uses) {
+        if (!dict.classes.has(u))
+            throw new CrubalError(`${name} uses ${u}, which isn't a class`, c.line);
+        findCycle(u, dict, [...path, name]);
+    }
+}
+function order(dict, names, seen = new Set()) {
+    const out = [];
+    for (const n of names) {
+        if (seen.has(n))
+            continue;
+        const c = dict.classes.get(n);
+        if (!c)
+            continue;
+        seen.add(n);
+        out.push(...order(dict, c.uses, seen), c);
+    }
+    return out;
+}
+/** Resolve the meet of classes (a class with its uses, or everything a record wears). */
+export function resolve(dict, names, line) {
+    const lines = new Map();
+    for (const c of order(dict, names)) {
+        for (const l of c.lines) {
+            const f = dict.facets.get(l.facet);
+            let r = lines.get(l.facet);
+            if (!r) {
+                r = { facet: l.facet, levels: [], from: [] };
+                if (l.section)
+                    r.section = l.section;
+                lines.set(l.facet, r);
+            }
+            r.from.push({ cls: c.name, line: l });
+            if (l.required)
+                r.required = true;
+            if (l.level && !r.levels.includes(l.level))
+                r.levels.push(l.level);
+            if (l.when)
+                r.when = r.when ? `(${r.when}) and (${l.when})` : l.when;
+            if (l.values) {
+                const base = r.values ?? (f?.values ?? []).map((v) => v.value);
+                const next = base.filter((v) => l.values?.includes(v));
+                if (!next.length) {
+                    const others = r.from.filter((x) => x.line.values && x.cls !== c.name).map((x) => x.cls);
+                    throw new CrubalError(`${names.join(", ")} allows no value of ${l.facet}: ${[...new Set([...others, c.name])].join(" and ")} have nothing in common`, line ?? l.line);
+                }
+                r.values = next;
+            }
+            if (l.length !== undefined)
+                r.length = Math.min(r.length ?? Number.POSITIVE_INFINITY, l.length);
+            if (l.pick)
+                r.pick = r.pick && r.pick !== "any" && (l.pick === "any" || Number(r.pick) < Number(l.pick)) ? r.pick : l.pick;
+            if (l.range) {
+                const min = r.range ? String(Math.max(Number(r.range.min), Number(l.range.min))) : l.range.min;
+                const max = r.range ? String(Math.min(Number(r.range.max), Number(l.range.max))) : l.range.max;
+                r.range = { min, max };
+            }
+        }
+    }
+    return [...lines.values()];
+}
+/** A resolved class as JSON, as the corpus states it. */
+export function resolvedJson(lines) {
+    return lines.map((r) => {
+        const o = { facet: r.facet };
+        if (r.required)
+            o.required = true;
+        if (r.values)
+            o.values = r.values;
+        if (r.length !== undefined)
+            o.length = String(r.length);
+        if (r.pick)
+            o.pick = r.pick;
+        if (r.range)
+            o.range = r.range;
+        if (r.levels.length === 1)
+            o.level = r.levels[0];
+        else if (r.levels.length > 1)
+            o.levels = r.levels;
+        if (r.when)
+            o.when = r.when;
+        return o;
+    });
+}
+function redundantLines(c, dict) {
+    const inherited = new Map(resolve(dict, c.uses).map((r) => [r.facet, r]));
+    const out = [];
+    for (const l of c.lines) {
+        if (!inherited.has(l.facet))
+            continue;
+        const narrows = l.required || l.values || l.length !== undefined || l.pick || l.range || l.level || l.when;
+        if (!narrows)
+            out.push({ line: l.line, message: `${c.name} restates ${l.facet}, which a used class already asks for` });
+    }
+    return out;
+}
+// ─── Folding (4.3) ───────────────────────────────────────────────────────────
+function keyIndex(dict) {
+    const idx = new Map();
+    for (const f of dict.facets.values()) {
+        for (const s of [f.key, ...f.aliases])
+            idx.set(foldKey(s), f.key);
+    }
+    return idx;
+}
+function foldChoice(f, v) {
+    if (typeof v === "string" && f.values) {
+        const k = foldKey(v);
+        for (const cv of f.values)
+            if ([cv.value, ...cv.aliases].some((s) => foldKey(s) === k))
+                return cv.value;
+        return v;
+    }
+    if (isObj(v) && "$value" in v)
+        return { ...v, $value: foldChoice(f, v.$value) };
+    return v;
+}
+function foldQuantity(f, v, units) {
+    if (!isObj(v) || !("$qty" in v) || !f.unit)
+        return v;
+    const from = unitOf(String(v.unit), units) ?? String(v.unit);
+    if (from === f.unit)
+        return from === v.unit ? v : { $qty: v.$qty, unit: from };
+    if (!f.accepts.includes(from) && !f.accepts.includes(String(v.unit)))
+        return v;
+    const amount = convert(String(v.$qty), from, f.unit, f.places, units);
+    return amount === null ? v : { $qty: amount, unit: f.unit };
+}
+export function foldValue(f, v, dict) {
+    if (Array.isArray(v))
+        return v.map((x) => foldValue(f, x, dict));
+    if (f.type === "choice")
+        return foldChoice(f, v);
+    if (f.type === "number")
+        return foldQuantity(f, v, dict.units);
+    if (f.type === "compound" && isObj(v))
+        return foldFields(v, f.children ?? new Map(), dict);
+    return v;
+}
+function foldFields(obj, within, dict) {
+    const idx = within ? new Map([...within.keys()].map((k) => [foldKey(k), k])) : keyIndex(dict);
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        const lookup = within ?? dict.facets;
+        let key = k;
+        let value = v;
+        let f = lookup.get(k);
+        if (!f) {
+            const real = idx.get(foldKey(k));
+            const rf = real ? lookup.get(real) : undefined;
+            if (real && rf && typeof v === "string") {
+                key = real;
+                f = rf;
+                value = readUnder(rf, v, dict) ?? v;
+            }
+        }
+        out[key] = f ? foldValue(f, value, dict) : value;
+    }
+    return out;
+}
+/** Fold a record: key aliases, value aliases and accepted units become real names (chapter 4.3). */
+export function foldRecord(r, dict) {
+    const out = { ...r, values: foldFields(r.values, null, dict) };
+    if (r.parts) {
+        out.parts = r.parts.map((p) => (isObj(p) && isObj(p.values) ? { ...p, values: foldFields(p.values, null, dict) } : p));
+    }
+    return out;
+}
+const NUMBER = /^-?(0|[1-9]\d*)(\.\d+)?$/;
+const DATE = /^(\d{4})(?:-(\d{2})(?:-(\d{2})(?:T(\d{2})(?::(\d{2})(?::(\d{2}))?)?(Z|[+-]\d{2}:\d{2})?)?)?)?$/;
+const TIME = /^(\d{2}):(\d{2})(?::(\d{2}))?$/;
+const RANK = { year: 0, month: 1, day: 2, hour: 3, minute: 4, second: 5 };
+/** A date's precision and whether it is well formed (1.4.5): real calendar parts and clock parts. */
+export function dateParts(d) {
+    const m = d.match(DATE);
+    if (!m)
+        return null;
+    const [, , mo, dd, hh, mi, ss, off] = m;
+    if (mo && (Number(mo) < 1 || Number(mo) > 12))
+        return null;
+    if (dd && (Number(dd) < 1 || Number(dd) > 31))
+        return null;
+    if (hh && Number(hh) > 23)
+        return null;
+    if (mi && Number(mi) > 59)
+        return null;
+    if (ss && Number(ss) > 59)
+        return null;
+    const precision = ss ? "second" : mi ? "minute" : hh ? "hour" : dd ? "day" : mo ? "month" : "year";
+    return { precision, offset: off ?? null };
+}
+function core(v) {
+    return isObj(v) && "$value" in v ? v.$value : v;
+}
+/** Check one scalar against its facet: an outcome and an optional flag. */
+export function checkScalar(f, v) {
+    const c = core(v);
+    if (isObj(c) && "$empty" in c)
+        return { outcome: "absorbed" };
+    switch (f.type) {
+        case "number": {
+            let amount = null;
+            if (typeof c === "string" && NUMBER.test(c) && !f.unit)
+                amount = c;
+            if (isObj(c) && "$qty" in c && c.unit === f.unit)
+                amount = String(c.$qty);
+            if (isObj(c) && "$money" in c && (f.unit === "currency" || c.currency === f.unit))
+                amount = String(c.$money);
+            // A spelling the units table lacks is a unit question for review (11.9), not a contradiction.
+            if (amount === null && isObj(c) && "$qty" in c && f.unit && unitOf(String(c.unit)) === null)
+                return { outcome: "new", cites: { unit: String(c.unit) } };
+            if (amount === null)
+                return { outcome: "contradiction" };
+            if (f.range && (Number(amount) < Number(f.range.min) || Number(amount) > Number(f.range.max)))
+                return { outcome: "absorbed", flag: "range" };
+            return { outcome: "absorbed" };
+        }
+        case "date": {
+            const parts = typeof c === "string" ? dateParts(c) : null;
+            if (!parts)
+                return { outcome: "contradiction" };
+            const timed = RANK[parts.precision] >= RANK.hour;
+            // A moment carries its offset; a local wall-clock date never does (1.4.5).
+            if (timed && (f.zone === "local" ? parts.offset !== null : parts.offset === null))
+                return { outcome: "contradiction" };
+            const want = f.precision ?? "any";
+            if (want !== "any" && RANK[parts.precision] < RANK[want])
+                return { outcome: "absorbed", flag: "precision" };
+            return { outcome: "absorbed" };
+        }
+        case "time": {
+            const m = typeof c === "string" ? c.match(TIME) : null;
+            if (!m || Number(m[1]) > 23 || Number(m[2]) > 59 || (m[3] !== undefined && Number(m[3]) > 59))
+                return { outcome: "contradiction" };
+            return { outcome: "absorbed" };
+        }
+        case "yes-no":
+            return typeof c === "boolean" ? { outcome: "absorbed" } : { outcome: "contradiction" };
+        case "link":
+            return isObj(c) && "$link" in c ? { outcome: "absorbed" } : { outcome: "contradiction" };
+        case "image":
+            return isObj(c) && "$image" in c ? { outcome: "absorbed" } : { outcome: "contradiction" };
+        case "choice": {
+            if (typeof c !== "string")
+                return { outcome: "contradiction" };
+            if ((f.values ?? []).some((x) => x.value === c))
+                return { outcome: "absorbed" };
+            return f.fixed ? { outcome: "contradiction" } : { outcome: "new" };
+        }
+        case "compound":
+            return isObj(c) ? { outcome: "absorbed" } : { outcome: "contradiction" };
+        default: {
+            if (typeof c !== "string")
+                return { outcome: "contradiction" };
+            if (f.length !== undefined && [...c].length > f.length)
+                return { outcome: "absorbed", flag: "length" };
+            return { outcome: "absorbed" };
+        }
+    }
+}
+function outcome(record, address, r, cites) {
+    const o = { record, address, outcome: r.outcome };
+    if (r.flag)
+        o.flag = r.flag;
+    if (cites)
+        o.cites = cites;
+    else if (r.outcome === "contradiction")
+        o.cites = { type: address.replace(/\[.*$/, "").split(".").at(-1) };
+    return o;
+}
+function checkValue(record, f, key, v, address, narrow) {
+    const items = Array.isArray(v) ? v : null;
+    const pickLimit = narrow?.pick ?? f.pick;
+    if (items) {
+        if (pickLimit !== "any" && items.length > Number(pickLimit)) {
+            return [{ record, address, outcome: "contradiction", cites: { type: f.key } }];
+        }
+        return items.map((item) => itemOutcome(record, f, key, item, `${address}[${JSON.stringify(itemText(f, item))}]`, narrow));
+    }
+    return [itemOutcome(record, f, key, v, address, narrow)];
+}
+function citeLine(cls, l) {
+    return `${cls}: ${l.text}`;
+}
+function itemOutcome(record, f, _key, v, address, narrow) {
+    const base = checkScalar(f, v);
+    const c = core(v);
+    if (narrow?.values && typeof c === "string" && !(isObj(c) && "$empty" in c) && !narrow.values.includes(c)) {
+        const by = narrow.from.find((x) => x.line.values && !x.line.values.includes(c));
+        return outcome(record, address, { outcome: "contradiction" }, { rule: by ? citeLine(by.cls, by.line) : f.key });
+    }
+    return outcome(record, address, base);
+}
+function isEmptyValue(v) {
+    return v === undefined || (isObj(v) && v.$empty === "unknown");
+}
+/** Check a record: every value against its facet and worn classes, required facets, and parts. */
+export function checkRecord(r, dict) {
+    const outcomes = [];
+    const worn = (r.wears ?? []).filter((w) => dict.classes.has(w));
+    const resolved = resolve(dict, worn);
+    const byFacet = new Map(resolved.map((l) => [l.facet, l]));
+    const asked = [];
+    const missing = [];
+    for (const l of resolved) {
+        let holds = true;
+        if (l.when)
+            holds = evaluate(parseCondition(l.when), r.values);
+        if (holds !== true)
+            continue;
+        asked.push(l.facet);
+        if (l.required && isEmptyValue(r.values[l.facet])) {
+            missing.push(l.facet);
+            const by = l.from.find((x) => x.line.required);
+            outcomes.push({ record: r.id, address: l.facet, outcome: "incomplete", cites: { rule: by ? citeLine(by.cls, by.line) : l.facet } });
+        }
+    }
+    for (const [key, v] of Object.entries(r.values)) {
+        const f = dict.facets.get(key);
+        if (!f) {
+            outcomes.push({ record: r.id, address: key, outcome: "unknown" });
+            continue;
+        }
+        outcomes.push(...checkValue(r.id, f, key, v, key, byFacet.get(key)));
+    }
+    const slots = worn.flatMap((w) => (dict.classes.get(w)?.parts ?? []).map((s) => ({ cls: w, s })));
+    for (const p of r.parts ?? []) {
+        if (!isObj(p))
+            continue;
+        const row = String(p.$row);
+        const wears = Array.isArray(p.wears) ? p.wears.map(String) : [];
+        const slot = slots.find((x) => wears.includes(x.s.wears));
+        const at = `parts[${row}]`;
+        const cite = slot ? { type: `${slot.cls}: ${slot.s.slot}` } : undefined;
+        if (slot && !slot.s.fungible && (row === `${slot.s.slot}s` || row === `${slot.s.slot}es`)) {
+            outcomes.push({ record: r.id, address: at, outcome: "contradiction", cites: cite, reason: "plural of a non-fungible slot" });
+        }
+        const values = isObj(p.values) ? p.values : {};
+        for (const [key, v] of Object.entries(values)) {
+            const address = `${at}.${key}`;
+            if (key === "crubal:count") {
+                if (slot && !slot.s.fungible) {
+                    outcomes.push({ record: r.id, address, outcome: "contradiction", cites: cite, reason: "count on a non-fungible slot" });
+                    continue;
+                }
+            }
+            const f = dict.facets.get(key);
+            if (!f) {
+                outcomes.push({ record: r.id, address, outcome: "unknown" });
+                continue;
+            }
+            outcomes.push(...checkValue(r.id, f, key, v, address, undefined));
+        }
+    }
+    const summary = { record: r.id, asked, outcome: missing.length ? "incomplete" : "complete" };
+    if (missing.length)
+        summary.missing = missing;
+    return { outcomes, summary };
+}
+//# sourceMappingURL=dictionary.js.map