@hyperscale0/hsx 5.7.0 → 5.8.0

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+# HSX 5.8.0
+
+The checker names misspelled fields, parties and states at the misspelled word,
+with the nearest declared name: "`amont` is not a field or party of `deposit`.
+Did you mean `amount`?" This covers moves, actor parties, and field paths in
+`requires`, `unique ... on`, `set`, `calculate:`, `invoke`, `invariants` and the
+`at:` of `due` and `deadline`. The check runs once on the lowered program, so
+it also names a wrong segment deep in a path ("`balanse` is not a field of
+`self.held`"), `input.x` and `party.x` names, invoke instruments, actions and
+inputs, selection instruments, `where` fields and references, `ref<...>`
+targets and the list of an `at` calculation. Swapped adjacent letters count as
+one edit when picking the suggestion. A state typo in `from`, `to` or `initial` is one error
+instead of an invalid transition plus every unreachable state. A program
+instrument attached before its declaration reports each mistake once.
+
+A `ref<T>[]` binding accepts a list of sibling attachments, so `on: [plan]`
+compiles to the same program as `on: plan`.
+
 # HSX 5.7.0
 
 Follows UDL 4.9.0. Object `entryActions` admits enrolled customers through named

package/dist/src/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.ts"],"names":[],"mappings":"AAEA,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAeL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAC;AAS1B,OAAO,EAIL,KAAK,UAAU,EAKf,KAAK,IAAI,EACV,MAAM,UAAU,CAAC;AAClB,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;CACpC;AACD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,aAAa,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3E;AACD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACnB;AACD,MAAM,WAAW,cAAc;IAC7B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;CAClE;AACD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjC,SAAS,CAAC,EAAE;QACV,QAAQ,EAAE,WAAW,CAAC;QACtB,YAAY,EAAE,eAAe,CAAC;QAC9B,SAAS,EAAE,qBAAqB,EAAE,CAAC;KACpC,CAAC;CACH;AAqTD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B,aAAa,CA8yGf"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.ts"],"names":[],"mappings":"AAOA,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAeL,KAAK,WAAW,EAQjB,MAAM,kBAAkB,CAAC;AAS1B,OAAO,EAIL,KAAK,UAAU,EAKf,KAAK,IAAI,EACV,MAAM,UAAU,CAAC;AAClB,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;CACpC;AACD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,aAAa,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3E;AACD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACnB;AACD,MAAM,WAAW,cAAc;IAC7B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;CAClE;AACD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjC,SAAS,CAAC,EAAE;QACV,QAAQ,EAAE,WAAW,CAAC;QACtB,YAAY,EAAE,eAAe,CAAC;QAC9B,SAAS,EAAE,qBAAqB,EAAE,CAAC;KACpC,CAAC;CACH;AAqTD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B,aAAa,CAwnHf"}

package/dist/src/compile.js

@@ -1,4 +1,4 @@
-import { CompileFailure, fail, failWithCode } from "./diagnostics.js";
+import { CompileFailure, didYouMean, fail, failWithCode, } from "./diagnostics.js";
 import { hash as sha256 } from "fast-sha256";
 import { buildUdlCostManifest } from "./cost.js";
 import { validateUdl, resolveField, sameObjectField, subjectPartyRoles, RESERVED_OBJECT_NAMES, udlObjectFieldSchema, udlInstrumentSchema, } from "@hyperscale0/udl";
@@ -253,6 +253,11 @@ export function compile(source, options = {}) {
         severity: "error",
         stage,
     });
+    // A program instrument lowers once standalone and once per attachment, so
+    // one authored mistake can fail each copy at the same place.
+    const distinct = (list) => list.filter((d, index) => list.findIndex((other) => other.source === d.source &&
+        other.span.start === d.span.start &&
+        other.message === d.message) === index);
     if (parsed.diagnostics.length)
         return {
             verdict: "invalid",
@@ -403,6 +408,10 @@ export function compile(source, options = {}) {
             }
         }
         const origins = [];
+        // Lowered objects lose their spans, so each keeps the expression that
+        // produced it for the name check after lowering.
+        const authored = new WeakMap();
+        const declarations = new WeakMap();
         const exposures = [];
         const refundBindings = new Map();
         const resolveFamily = (rawPath, expr, required = true) => {
@@ -807,7 +816,8 @@ export function compile(source, options = {}) {
                         continue;
                     const t = param.value.kind === "default" ? param.value.type : param.value;
                     const type = t.kind === "type" || t.kind === "call" ? t.name : text(t);
-                    let v = (supplied.has(param.key) && !attachmentInfo) || type === "enum"
+                    const asWritten = (supplied.has(param.key) && !attachmentInfo) || type === "enum";
+                    let v = asWritten
                         ? actual
                         : resolve(actual, new Set(), !!attachmentInfo && type === "party");
                     if (type === "duration" &&
@@ -843,7 +853,15 @@ export function compile(source, options = {}) {
                                 : { party: v.value };
                     }
                     else if (type === "ref") {
-                        const values = v.kind === "list" ? v.items : [v];
+                        // Listed objects resolve like a single binding, so `on: [plan]`
+                        // names the sibling attachment that `on: plan` names.
+                        const values = v.kind !== "list"
+                            ? [v]
+                            : asWritten
+                                ? v.items
+                                : v.items.map((item) => resolve(item));
+                        if (v.kind === "list")
+                            environment.set(param.key, { ...v, items: values });
                         if (v.kind === "list" && (t.kind !== "type" || !t.many))
                             fail(v, `${param.key} accepts one reference`, "use one object name");
                         if (!values.length || values.length > 16)
@@ -1093,9 +1111,11 @@ export function compile(source, options = {}) {
             };
             const val = (expr) => {
                 const v = resolve(expr);
-                return v.kind === "name" && !["true", "false"].includes(v.value)
-                    ? { field: path(v) }
-                    : { literal: literal(v) };
+                if (v.kind !== "name" || ["true", "false"].includes(v.value))
+                    return { literal: literal(v) };
+                const value = { field: path(v) };
+                authored.set(value, expr);
+                return value;
             };
             const data = (expr) => {
                 if (expr.kind === "call" &&
@@ -1139,6 +1159,7 @@ export function compile(source, options = {}) {
                                 continue;
                             result[k] = data(v);
                         }
+                        authored.set(result, value);
                         return result;
                     }
                     const result = Object.fromEntries([...rawEntries].map(([key, value]) => [key, data(value)]));
@@ -1160,10 +1181,14 @@ export function compile(source, options = {}) {
                             };
                         return null;
                     }
+                    authored.set(result, value);
                     return result;
                 }
-                if (value.kind === "list")
-                    return value.items.map(data).filter((item) => item !== null);
+                if (value.kind === "list") {
+                    const items = value.items.map(data).filter((item) => item !== null);
+                    authored.set(items, value);
+                    return items;
+                }
                 if (value.kind === "call" &&
                     value.name === "child" &&
                     value.args.length === 2) {
@@ -1370,6 +1395,7 @@ export function compile(source, options = {}) {
                                 });
                             else
                                 fail(constant, `unknown calculation ${constant.name}`, "use rate, sum, minimum, subtract, multiply, divide, before or after");
+                            authored.set(calculations.at(-1), constant);
                         }
                         else if (type === "enum" && constant.kind === "name")
                             f.value = constant.value;
@@ -1382,12 +1408,25 @@ export function compile(source, options = {}) {
                         else
                             f.value = literal(constant, String(type));
                     }
+                    authored.set(f, row.value);
                     result.push(f);
                 }
                 return result;
             };
             fields.push(...lowerFields(asBlock(body.get("fields"))));
-            const lifecycle = data(asBlock(body.get("lifecycle")));
+            const lifecycleBlock = asBlock(body.get("lifecycle"));
+            const lifecycle = data(lifecycleBlock);
+            const states = Array.isArray(lifecycle.states) ? lifecycle.states : [];
+            const checkState = (expr, state) => {
+                if (typeof state !== "string" || !states.length)
+                    return;
+                if (states.includes(state))
+                    return;
+                fail(expr, `\`${state}\` is not a state of \`${decl.name}\`.${didYouMean(state, states)}`, `Use one of ${states.join(", ")}, or add \`${state}\` to \`lifecycle.states\`.`);
+            };
+            const initialExpr = entries(lifecycleBlock).get("initial");
+            if (initialExpr)
+                checkState(initialExpr, lifecycle.initial);
             lifecycle.transitions = Object.create(null);
             const inst = {
                 id,
@@ -1656,6 +1695,7 @@ export function compile(source, options = {}) {
                     moves: [],
                     ...(actionSubject ? { subject: actionSubject } : {}),
                 };
+                authored.set(a, row.value);
                 for (const binding of boundaryBindings)
                     if (!a.subject?.adapters.find((entry) => entry.binding === binding)
                         ?.snapshot)
@@ -1667,10 +1707,13 @@ export function compile(source, options = {}) {
                     const to = slots.get("to");
                     if (!from || !to)
                         fail(row, `action ${name} needs from and to`, "declare its source and destination states");
-                    lifecycle.transitions[name] = {
-                        from: (from.kind === "list" ? from.items : [from]).map((e) => String(data(e))),
-                        to: String(data(to)),
-                    };
+                    const sources = from.kind === "list" ? from.items : [from];
+                    const fromStates = sources.map((e) => String(data(e)));
+                    const toState = String(data(to));
+                    sources.forEach((e, index) => checkState(e, fromStates[index]));
+                    if (toState !== "preserve")
+                        checkState(to, toState);
+                    lifecycle.transitions[name] = { from: fromStates, to: toState };
                 }
                 for (const [key, expr] of slots) {
                     if (["from", "to", "input", "summary", "subject"].includes(key))
@@ -1678,6 +1721,7 @@ export function compile(source, options = {}) {
                     if (key === "moves") {
                         const moves = expr.kind === "list" ? expr.items : [expr];
                         for (const [index, move] of moves.entries()) {
+                            const lowered = a.moves.length;
                             const parts = entries(asBlock(move));
                             const op = parts.has("operation")
                                 ? String(data(parts.get("operation")))
@@ -1831,6 +1875,8 @@ export function compile(source, options = {}) {
                                     }
                                     if (total !== 10000)
                                         fail(move, "split percentages must sum to 100%", "give the recipients exactly 100% together");
+                                    for (const item of a.moves.slice(lowered))
+                                        authored.set(item, move);
                                     continue;
                                 }
                                 if (!amount || !from || !to)
@@ -1972,6 +2018,8 @@ export function compile(source, options = {}) {
                                 });
                             else
                                 fail(move, `unknown transfer instruction ${op}`, "choose create, reserve, post, or void from internal_transfer");
+                            for (const item of a.moves.slice(lowered))
+                                authored.set(item, move);
                         }
                     }
                     else
@@ -2090,6 +2138,7 @@ export function compile(source, options = {}) {
                 };
             }
             document.instruments.push(inst);
+            declarations.set(inst, decl);
             for (const [key, definition] of records) {
                 const childAttachment = attachmentInfo
                     ? {
@@ -2337,7 +2386,7 @@ export function compile(source, options = {}) {
         if (bindingDiagnostics.length)
             return {
                 verdict: "invalid",
-                diagnostics: bindingDiagnostics
+                diagnostics: distinct(bindingDiagnostics)
                     .sort((a, b) => a.span.start - b.span.start)
                     .map((d) => diagnostic(d, "check")),
             };
@@ -2521,6 +2570,220 @@ export function compile(source, options = {}) {
                     failWithCode(objects.get(kind.id), "subject_field_unknown", `column ${column} is unknown on ${kind.id}`, "name an authored field or attached requirement");
             }
         }
+        const byId = new Map(document.instruments.map((inst) => [inst.id, inst]));
+        const site = (owner, key, fallback) => {
+            const expr = authored.get(owner);
+            if (expr?.kind === "block")
+                return expr.entries.find((entry) => entry.key === key)?.value ?? expr;
+            if (expr?.kind === "list" && Array.isArray(owner))
+                return expr.items.length === owner.length
+                    ? expr.items[Number(key)]
+                    : expr;
+            return expr ?? fallback;
+        };
+        const keySite = (owner, key, fallback) => {
+            const expr = authored.get(owner);
+            const entry = expr?.kind === "block"
+                ? expr.entries.find((item) => item.key === key)
+                : undefined;
+            if (!entry)
+                return fallback;
+            return {
+                ...entry,
+                span: { start: entry.span.start, end: entry.span.start + key.length },
+            };
+        };
+        const builtins = (inst) => [
+            "id",
+            "now",
+            "createdAt",
+            "productRevision",
+            "status",
+            ...(inst.subject ? ["subject"] : []),
+        ];
+        const parties = (inst) => [
+            ...Object.keys(document.parties),
+            ...(inst.subject ? subjectPartyRoles : []),
+        ];
+        const members = (field) => {
+            if (field.type === "account")
+                return ["balance", "reserved"];
+            if (field.type !== "ref")
+                return [];
+            const [id] = [field.target].flat();
+            const target = field.targetKind === "object"
+                ? document.objects.find((object) => object.id === id)
+                : byId.get(id);
+            if (!target)
+                return [];
+            return [
+                ...target.fields.map((item) => item.name),
+                ...("lifecycle" in target ? builtins(target) : []),
+            ];
+        };
+        const checkParty = (name, at, inst) => {
+            const names = parties(inst);
+            if (!names.includes(name))
+                fail(at, `\`${name}\` is not a declared party.${didYouMean(name, names)}`, `Declare it with \`party ${name}: business\`, or name a declared party (${names.join(", ")}).`);
+        };
+        const checkInput = (name, at, label, input) => {
+            const names = input.map((field) => field.name);
+            if (!names.includes(name))
+                fail(at, `\`${name}\` is not an input of \`${label}\`.${didYouMean(name, names)}`, `Declare \`${name}\` in the input of \`${label}\`${names.length ? `, or use one of ${names.join(", ")}` : ""}.`);
+        };
+        const checkTarget = (id, at, objects = false) => {
+            const ids = [
+                ...byId.keys(),
+                ...(objects ? document.objects.map((object) => object.id) : []),
+            ];
+            const noun = objects ? "instrument or object" : "instrument";
+            if (!ids.includes(id))
+                fail(at, `\`${id}\` is not a declared ${noun}.${didYouMean(id, ids)}`, `Name a declared ${noun}.`);
+        };
+        const checkPath = (path, at, scope) => {
+            const { inst, action } = scope;
+            const parts = path.split(".");
+            const found = (count) => resolveField(document, inst, parts.slice(0, count).join("."), action?.input, action);
+            // Subject paths keep their own check against the action's requirements.
+            if (found(parts.length) || parts[0] === "subject")
+                return;
+            if (parts[0] === "party" && parts[1]) {
+                checkParty(parts[1], at, inst);
+                if (!found(2))
+                    return;
+            }
+            if (!["self", "input", "party"].includes(parts[0]))
+                parts.unshift("self");
+            let count = 2;
+            while (count <= parts.length && found(count))
+                count++;
+            if (count > parts.length)
+                return;
+            const name = parts[count - 1];
+            if (count > 2) {
+                const prefix = parts.slice(0, count - 1).join(".");
+                const names = members(found(count - 1));
+                fail(at, `\`${name}\` is not a field of \`${prefix}\`.${didYouMean(name, names)}`, names.length
+                    ? `Use one of ${names.join(", ")}.`
+                    : `\`${prefix}\` has no fields.`);
+            }
+            if (parts[0] === "input")
+                return checkInput(name, at, scope.label, action?.input ?? []);
+            const declared = declarations.get(inst).name;
+            const fields = inst.fields.map((field) => field.name);
+            fail(at, `\`${name}\` is not a field or party of \`${declared}\`.${didYouMean(name, [...fields, ...builtins(inst), ...parties(inst)])}`, `Use a field declared in \`${declared}\` (${fields.join(", ")}) or a declared party (${parties(inst).join(", ")}).`);
+        };
+        const scopeOf = (inst) => ({
+            inst,
+            label: declarations.get(inst).name,
+        });
+        const checkSelection = (selection, at, scope) => {
+            walk(selection.anchor, "anchor", site(selection, "anchor", at), scope);
+            walk(selection.where, "where", site(selection, "where", at), scope);
+            for (const id of [selection.instrument].flat()) {
+                checkTarget(id, site(selection, "instrument", at));
+                const target = scopeOf(byId.get(id));
+                const member = (key, where) => checkPath(key.startsWith("self.") ? key : `self.${key}`, where, target);
+                for (const key of Object.keys(selection.where ?? {}))
+                    member(key, keySite(selection.where, key, at));
+                member(selection.reference, site(selection, "reference", at));
+                selection.order?.forEach((key, index) => member(key, site(selection.order, index, at)));
+                if (selection.window)
+                    member(selection.window.field, site(selection.window, "field", at));
+            }
+        };
+        const checkCall = (call, at, scope) => {
+            const bind = "range" in call ? call.range?.bind : undefined;
+            for (const [key, value] of Object.entries(call))
+                if (key !== "input")
+                    walk(value, key, site(call, key, at), scope);
+            for (const [key, value] of Object.entries(call.input))
+                if (!("field" in value) || value.field !== bind)
+                    walk(value, key, site(call.input, key, at), scope);
+            if ("instrument" in call)
+                checkTarget(call.instrument, site(call, "instrument", at));
+            const reference = "reference" in call
+                ? resolveField(document, scope.inst, call.reference, scope.action?.input, scope.action)
+                : undefined;
+            const ids = "instrument" in call
+                ? [call.instrument]
+                : "selection" in call
+                    ? [call.selection.instrument].flat()
+                    : reference?.type === "ref" && reference.targetKind === "instrument"
+                        ? [reference.target].flat()
+                        : [];
+            for (const id of ids) {
+                const target = byId.get(id);
+                if (!target)
+                    continue;
+                const action = target.actions[call.action];
+                if (!action)
+                    fail(site(call, "action", at), `\`${call.action}\` is not an action of \`${id}\`.${didYouMean(call.action, target.actionOrder)}`, `Use one of ${target.actionOrder.join(", ")}.`);
+                for (const key of Object.keys(call.input))
+                    checkInput(key, keySite(call.input, key, at), `${id}.${call.action}`, action.input);
+            }
+        };
+        const pathKeys = [
+            "field",
+            "reference",
+            "anchor",
+            "at",
+            "list",
+            "from",
+            "to",
+            "transfer",
+            "subject",
+            "instruction",
+            "installment",
+            "recipient",
+            "dueAt",
+            "fields",
+        ];
+        const walk = (value, key, at, scope) => {
+            if (typeof value === "string") {
+                if (key === "party")
+                    checkParty(value, at, scope.inst);
+                if (key === "target")
+                    checkPath(`self.${value}`, at, scope);
+                if (pathKeys.includes(key))
+                    checkPath(value, at, scope);
+                return;
+            }
+            if (!value || typeof value !== "object")
+                return;
+            if (Array.isArray(value))
+                return value.forEach((item, index) => walk(item, key, site(value, index, at), scope));
+            if (key === "selection")
+                return checkSelection(value, at, scope);
+            if (key === "invoke")
+                return checkCall(value, at, scope);
+            if (key === "set")
+                for (const name of Object.keys(value))
+                    checkPath(`self.${name}`, keySite(value, name, at), scope);
+            for (const [child, item] of Object.entries(value))
+                walk(item, child, site(value, child, at), scope);
+        };
+        for (const inst of document.instruments) {
+            const decl = declarations.get(inst);
+            const scope = scopeOf(inst);
+            for (const field of [
+                ...inst.fields,
+                ...Object.values(inst.actions).flatMap((action) => action.input),
+            ])
+                if ("target" in field && field.target !== undefined)
+                    for (const id of [field.target].flat())
+                        checkTarget(id, site(field, "target", decl), true);
+            walk(inst.calculate, "calculate", decl, scope);
+            walk(inst.invariants, "invariants", decl, scope);
+            for (const [name, action] of Object.entries(inst.actions))
+                for (const [key, value] of Object.entries(action))
+                    if (key !== "input" && key !== "subject")
+                        walk(value, key, site(action, key, decl), {
+                            inst,
+                            label: `${decl.name}.${name}`,
+                            action,
+                        });
+        }
         const eliminatedStates = new Map();
         // Remove branches excluded by immutable tunables before checking reference states.
         for (const inst of document.instruments) {
@@ -2702,7 +2965,7 @@ export function compile(source, options = {}) {
         if (error instanceof CompileFailure)
             return {
                 verdict: "invalid",
-                diagnostics: [...bindingDiagnostics, error.diagnostic].map((d) => diagnostic(d, "check")),
+                diagnostics: distinct([...bindingDiagnostics, error.diagnostic]).map((d) => diagnostic(d, "check")),
             };
         throw error;
     }