yarramate 0.18.0 → 0.19.0

package/dist/reconciliation.js

@@ -1,4 +1,4 @@
-import { ATTESTATION_PREDICATE_PREFIX, parseAttestationClaimValue, } from './compiler.js';
+import { ATTESTATION_PREDICATE_PREFIX, parseAttestationClaimValue, parseConstraintExpectsValue, } from './compiler.js';
 const assertedRelationshipsByClaim = (graph) => {
     const asserted = new Map();
     if (graph === undefined)
@@ -30,7 +30,8 @@ export const constraintExpectsPredicate = 'yarramate/constraint/expects';
 // A finding is now a union (ADR 0074); only the evidence arm can carry an
 // expectation, so ordering reads it through one narrowing helper.
 const expectationOf = (finding) => 'expectation' in finding ? finding.expectation : undefined;
-// Mirrors the compiler encoding (ADR 0075). Provider and key admit no
+// The compiler's parseConstraintExpectsValue is the sole authority for
+// decoding the encoded value (ADR 0075). Provider and key admit no
 // whitespace, so the first two spaces delimit them and everything after the
 // second space is the expected value verbatim, spaces included.
 const parseExpectation = (claim) => {
@@ -38,15 +39,15 @@ const parseExpectation = (claim) => {
         !('value' in claim.object)) {
         return undefined;
     }
-    const match = /^(\S+) (\S+) ([\s\S]+)$/.exec(claim.object.value);
-    if (match === null)
+    const parts = parseConstraintExpectsValue(claim.object.value);
+    if (parts === undefined)
         return undefined;
     return {
         claim: claim.id,
         subject: claim.subject,
-        provider: match[1],
-        key: match[2],
-        expected: match[3],
+        provider: parts.provider,
+        key: parts.key,
+        expected: parts.value,
         declared: {
             document: claim.source.document,
             path: claim.source.path,

package/dist/source-document.d.ts

@@ -21,6 +21,16 @@ export type SourceDocumentResult<T> = {
 };
 export declare const diagnosticOrder: (left: Diagnostic, right: Diagnostic) => number;
 export declare const describeSchemaViolation: (error: Pick<ErrorObject, 'keyword' | 'message' | 'params'>) => string;
+/**
+ * The errors worth reading, in the order Ajv found them.
+ *
+ * A discriminated union raises two errors when the tag itself is missing or
+ * mistyped: the `required`/`type` fault that names the property, and a
+ * `discriminator` row restating it. The second says nothing the first did not,
+ * so it is dropped. A tag that is present but names no branch keeps its row -
+ * that one is the only report of the fault.
+ */
+export declare const readableSchemaErrors: <T extends Pick<ErrorObject, 'keyword' | 'params'>>(errors: readonly T[]) => readonly T[];
 export declare const closestCandidate: (value: string, candidates: Iterable<string>) => string | undefined;
 export declare function locateSourcePath(sourcePath: string, yaml: ReturnType<typeof parseDocument>, lineCounter: LineCounter, yamlPath: readonly (string | number)[], pointer: string): SourceLocation;
 export declare function loadSourceDocument<T>(source: WorkspaceSource, validate: ValidateFunction, schemaLabel: string): SourceDocumentResult<T>;

package/dist/source-document.js

@@ -18,8 +18,28 @@ export const describeSchemaViolation = (error) => {
             .join(', ');
         return `${base}: ${shown}${allowed.length > 8 ? ', …' : ''}`;
     }
+    // The one pattern in these schemas that is a rule rather than a shape:
+    // `must match pattern "\S"` names the regex, not what the author did wrong.
+    if (error.keyword === 'pattern' && error.params.pattern === '\\S') {
+        return 'must not be blank';
+    }
+    // A tag naming no branch reads as a search failure ("must be in oneOf").
+    // Say what was named instead, since that is the value to correct.
+    if (error.keyword === 'discriminator' && error.params.error === 'mapping') {
+        return `unknown ${JSON.stringify(error.params.tag)} value ${JSON.stringify(error.params.tagValue)}`;
+    }
     return base;
 };
+/**
+ * The errors worth reading, in the order Ajv found them.
+ *
+ * A discriminated union raises two errors when the tag itself is missing or
+ * mistyped: the `required`/`type` fault that names the property, and a
+ * `discriminator` row restating it. The second says nothing the first did not,
+ * so it is dropped. A tag that is present but names no branch keeps its row -
+ * that one is the only report of the fault.
+ */
+export const readableSchemaErrors = (errors) => errors.filter((error) => error.keyword !== 'discriminator' || error.params.error === 'mapping');
 const editDistance = (left, right) => {
     const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
     for (let i = 1; i <= left.length; i += 1) {
@@ -86,7 +106,7 @@ export function loadSourceDocument(source, validate, schemaLabel) {
     if (!validate(value)) {
         return {
             ok: false,
-            diagnostics: (validate.errors ?? [])
+            diagnostics: readableSchemaErrors(validate.errors ?? [])
                 .map((error) => {
                 const property = error.keyword === 'additionalProperties'
                     ? String(error.params.additionalProperty)