@astrale-os/kernel-dsl 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/v1/language/validation/rule.js

@@ -0,0 +1,116 @@
+/**
+ * Every value diagnostic code with the rule it reports. A code added to the language does not
+ * compile until it is described here.
+ */
+export const VALUE_RULES = frozen({
+    CALLABLE_INPUT_FIELD_UNKNOWN: {
+        stage: 'value',
+        positions: [''],
+        statement: 'An input field validated on its own is a field of the Callable input, which has fields only when it is a closed object.',
+    },
+    DOMAIN_CLASS_ABSTRACT: {
+        stage: 'value',
+        positions: ['/class'],
+        statement: 'Properties are validated for a concrete Class only.',
+    },
+    DOMAIN_PROPERTY_INPUT_INVALID: {
+        stage: 'value',
+        positions: ['/properties'],
+        statement: 'The Properties of a Class are a canonical map of Property keys to portable values.',
+    },
+    DOMAIN_PROPERTY_REQUIRED: {
+        stage: 'value',
+        positions: ['/properties/{key}'],
+        statement: 'Every required Property of the Class has a value.',
+    },
+    DOMAIN_PROPERTY_UNKNOWN: {
+        stage: 'value',
+        positions: ['/properties/{key}'],
+        statement: 'Every Property given a value is a Property of the Class, its own or inherited.',
+    },
+    VALUE_SCHEMA_INSTANCE_INVALID: {
+        stage: 'value',
+        positions: ['{/path*}'],
+        statement: 'A value satisfies its complete value schema.',
+    },
+    VS_DIALECT: {
+        stage: 'schema',
+        positions: ['{/path*}/$schema'],
+        statement: 'A value schema names $schema at its root only, and there names the dialect https://schemas.astrale.ai/dsl/v1/value-schema.',
+    },
+    VS_DYNAMIC_FORBIDDEN: {
+        stage: 'schema',
+        positions: [
+            '{/path*}/$anchor',
+            '{/path*}/$dynamicAnchor',
+            '{/path*}/$dynamicRef',
+            '{/path*}/$vocabulary',
+        ],
+        statement: 'A value schema names none of $anchor, $dynamicAnchor, $dynamicRef and $vocabulary.',
+    },
+    VS_KEYWORD_CLOSED: {
+        stage: 'schema',
+        positions: ['{/path*}/{keyword}'],
+        statement: 'Every keyword of a value schema is one of the closed V1 vocabulary.',
+    },
+    VS_META_SCHEMA: {
+        stage: 'schema',
+        positions: ['{/path*}'],
+        statement: 'A value schema is JSON valid under the meta-schema of the dialect, with fullMatch a string and no two equal values in an enum, at every location.',
+    },
+    VS_NUMBER_DOMAIN: {
+        stage: 'value',
+        positions: ['{/path*}'],
+        statement: 'A value, like a value schema, is portable JSON: its numbers are finite and not negative zero, its strings well formed, and its size within the value limits.',
+    },
+    VS_PATH_EXTENSION: {
+        stage: 'schema',
+        positions: ['{/path*}/x-astrale-path{/path*}', '{/path*}'],
+        statement: 'x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema, and reads target node, cardinality one and a non-empty set of Node Class refs it accepts.',
+    },
+    VS_RECURSION_PRODUCTIVE: {
+        stage: 'schema',
+        positions: ['{/path*}'],
+        statement: 'Every reference cycle of a value schema crosses a keyword that steps into the value: to a member, a member name or an item.',
+    },
+    VS_REFERENCE_FORM: {
+        stage: 'schema',
+        positions: ['{/path*}/$ref'],
+        statement: 'A $ref is a JSON Pointer fragment into its own value schema, or the id of the graph NodePath schema beside x-astrale-path.',
+    },
+    VS_REFERENCE_RESOLUTION: {
+        stage: 'context',
+        positions: [
+            '{/path*}/$ref',
+            '{/path*}/x-astrale-path/accepts/{index}',
+            '',
+            '/registry{/path*}',
+        ],
+        statement: 'A $ref resolves to a location of its own value schema, x-astrale-path accepts Node Classes of the Domain or of a direct dependency, and the schema is checked with the exact dependency closure of its Domain.',
+    },
+    VS_REGEX_PORTABLE: {
+        stage: 'schema',
+        positions: ['{/path*}/pattern', '{/path*}/fullMatch', '{/path*}/patternProperties/{pattern}'],
+        statement: 'Every pattern, fullMatch and patternProperties name is an RFC 9485 I-Regexp within the regular-expression limits.',
+    },
+    VS_RESOURCE_ID: {
+        stage: 'schema',
+        positions: ['{/path*}/$id'],
+        statement: 'A value schema declares no $id: it is embedded, not a resource of its own.',
+    },
+    VS_VALUE_KIND: {
+        stage: 'schema',
+        positions: ['{/path*}/x-astrale-value-kind'],
+        statement: 'x-astrale-value-kind declares instant beside type string at any location, or blob as the whole schema of a Property, exactly as values.blob writes it.',
+    },
+    VS_VALUE_KIND_JSON: {
+        stage: 'warning',
+        positions: ['/classes/{class}/properties/{property}'],
+        statement: 'A Property of value kind json is filtered by equality only, so its author is warned.',
+    },
+});
+function frozen(rules) {
+    for (const rule of Object.values(rules))
+        Object.freeze(Object.freeze(rule).positions);
+    return Object.freeze(rules);
+}

package/dist/v1/language/value/profile/meta-schema.compiled.js

@@ -4,7 +4,7 @@
 "use strict";
 export const validate = validate20;
 export default validate20;
-const schema31 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.astrale.ai/dsl/v1/value-schema", "$vocabulary": {}, "allOf": [{ "$ref": "https://json-schema.org/draft/2020-12/schema" }], "properties": { "fullMatch": { "type": "string" }, "x-astrale-path": { "type": "object" } } };
+const schema31 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.astrale.ai/dsl/v1/value-schema", "$dynamicAnchor": "meta", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/core": true, "https://json-schema.org/draft/2020-12/vocab/applicator": true, "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, "https://json-schema.org/draft/2020-12/vocab/validation": true, "https://json-schema.org/draft/2020-12/vocab/meta-data": true, "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, "https://json-schema.org/draft/2020-12/vocab/content": true, "https://schemas.astrale.ai/dsl/v1/value-schema/vocabulary": true }, "title": "Astrale V1 value schema", "$comment": "The meta-schema of the V1 value-schema dialect: Draft 2020-12 and the required Astrale vocabulary (fullMatch, x-astrale-path, x-astrale-value-kind). Its $dynamicAnchor extends Draft 2020-12 at every subschema, not only the root. The rules of the profile beyond it are published as schema.values.RULES.", "allOf": [{ "$ref": "https://json-schema.org/draft/2020-12/schema" }], "properties": { "fullMatch": { "type": "string" }, "x-astrale-path": { "type": "object" } } };
 const schema0 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/schema", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/core": true, "https://json-schema.org/draft/2020-12/vocab/applicator": true, "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, "https://json-schema.org/draft/2020-12/vocab/validation": true, "https://json-schema.org/draft/2020-12/vocab/meta-data": true, "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, "https://json-schema.org/draft/2020-12/vocab/content": true }, "$dynamicAnchor": "meta", "title": "Core and Validation specifications meta-schema", "allOf": [{ "$ref": "meta/core" }, { "$ref": "meta/applicator" }, { "$ref": "meta/unevaluated" }, { "$ref": "meta/validation" }, { "$ref": "meta/meta-data" }, { "$ref": "meta/format-annotation" }, { "$ref": "meta/content" }], "type": ["object", "boolean"], "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.", "properties": { "definitions": { "$comment": "\"definitions\" has been replaced by \"$defs\".", "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "deprecated": true, "default": {} }, "dependencies": { "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.", "type": "object", "additionalProperties": { "anyOf": [{ "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" }] }, "deprecated": true, "default": {} }, "$recursiveAnchor": { "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".", "$ref": "meta/core#/$defs/anchorString", "deprecated": true }, "$recursiveRef": { "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".", "$ref": "meta/core#/$defs/uriReferenceString", "deprecated": true } } };
 const schema23 = { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "default": [] };
 const schema5 = { "type": "string", "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$" };
@@ -2042,6 +2042,9 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
     if (evaluated0.dynamicItems) {
         evaluated0.items = undefined;
     }
+    if (!dynamicAnchors.meta) {
+        dynamicAnchors.meta = validate20;
+    }
     if (!(validate0(data, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }))) {
         vErrors = vErrors === null ? validate0.errors : vErrors.concat(validate0.errors);
         errors = vErrors.length;

package/dist/v1/language/value/profile/rules.js

@@ -6,7 +6,9 @@ import { VALUE_SCHEMA_DIALECT } from '../model/schema.js';
 import { refuseIRegexp, stateBudgetMessage } from '../regexp/syntax.js';
 import { escapePointerToken } from '../syntax/pointer.js';
 import { walkSchema } from '../syntax/walk.js';
-import { FORBIDDEN_DYNAMIC_KEYWORDS, STANDARD_SCHEMA_KEYWORDS } from './vocabulary.js';
+import { FORBIDDEN_KEYWORDS, VALUE_KEYWORDS } from './vocabulary.js';
+const KEYWORDS = new Set(VALUE_KEYWORDS);
+const FORBIDDEN = new Set(FORBIDDEN_KEYWORDS);
 export function validateSchemaProfile(schema, context, pointer) {
     const diagnostics = [];
     walkSchema(schema, (location) => {
@@ -14,10 +16,10 @@ export function validateSchemaProfile(schema, context, pointer) {
             return;
         const currentPointer = `${pointer}${location.pointer}`;
         for (const keyword of Object.keys(location.schema)) {
-            if (!STANDARD_SCHEMA_KEYWORDS.has(keyword)) {
+            if (!KEYWORDS.has(keyword)) {
                 diagnostics.push(diagnostic('VS_KEYWORD_CLOSED', `${currentPointer}/${escapePointerToken(keyword)}`, `Keyword ${keyword} is outside the closed V1 Draft 2020-12 vocabulary.`));
             }
-            if (FORBIDDEN_DYNAMIC_KEYWORDS.has(keyword)) {
+            if (FORBIDDEN.has(keyword)) {
                 diagnostics.push(diagnostic('VS_DYNAMIC_FORBIDDEN', `${currentPointer}/${escapePointerToken(keyword)}`, `Keyword ${keyword} is forbidden by V1.`));
             }
         }
@@ -29,7 +31,11 @@ export function validateSchemaProfile(schema, context, pointer) {
         if (Object.hasOwn(location.schema, '$id')) {
             diagnostics.push(diagnostic('VS_RESOURCE_ID', `${currentPointer}/$id`, '$id is forbidden in an embedded V1 value schema.'));
         }
-        validateSemanticSets(location.schema, currentPointer, diagnostics);
+        // The dialect refuses a repeated type, required or dependentRequired entry; it lets an enum
+        // repeat a value.
+        if (Array.isArray(location.schema.enum)) {
+            rejectCanonicalDuplicates(location.schema.enum, `${currentPointer}/enum`, diagnostics);
+        }
         validateValueKind(location.schema, context, location.depth, currentPointer, diagnostics);
         validateRegexes(location.schema, currentPointer, diagnostics);
     });
@@ -74,28 +80,8 @@ function isCanonicalBlobSchema(input) {
 function isString(input) {
     return typeof input === 'string';
 }
-function validateSemanticSets(schema, pointer, diagnostics) {
-    if (Array.isArray(schema.type)) {
-        rejectPrimitiveDuplicates(schema.type, `${pointer}/type`, 'type', diagnostics);
-    }
-    if (Array.isArray(schema.required)) {
-        rejectPrimitiveDuplicates(schema.required, `${pointer}/required`, 'required', diagnostics);
-    }
-    if (Array.isArray(schema.enum)) {
-        rejectCanonicalDuplicates(schema.enum, `${pointer}/enum`, 'enum', diagnostics);
-    }
-    if (isJsonObject(schema.dependentRequired)) {
-        for (const [name, dependencies] of Object.entries(schema.dependentRequired)) {
-            if (Array.isArray(dependencies)) {
-                rejectPrimitiveDuplicates(dependencies, `${pointer}/dependentRequired/${escapePointerToken(name)}`, 'dependentRequired', diagnostics);
-            }
-        }
-    }
-}
+/** The dialect refuses a fullMatch that is not a string, at every location. */
 function validateRegexes(schema, pointer, diagnostics) {
-    if (Object.hasOwn(schema, 'fullMatch') && typeof schema.fullMatch !== 'string') {
-        diagnostics.push(diagnostic('VS_META_SCHEMA', `${pointer}/fullMatch`, 'fullMatch must be an I-Regexp source string.'));
-    }
     if (typeof schema.fullMatch === 'string') {
         portableRegex(schema.fullMatch, `${pointer}/fullMatch`, 'fullMatch', 'fullMatch must satisfy the complete RFC 9485 I-Regexp syntax.', diagnostics);
     }
@@ -114,17 +100,7 @@ function portableRegex(source, pointer, subject, syntax, diagnostics) {
         return;
     diagnostics.push(diagnostic('VS_REGEX_PORTABLE', pointer, refusal === 'syntax' ? syntax : stateBudgetMessage(subject)));
 }
-function rejectPrimitiveDuplicates(values, pointer, name, diagnostics) {
-    const seen = new Set();
-    for (const value of values) {
-        if (seen.has(value)) {
-            diagnostics.push(diagnostic('VS_META_SCHEMA', pointer, `${name} is a duplicate-free semantic set.`));
-            return;
-        }
-        seen.add(value);
-    }
-}
-function rejectCanonicalDuplicates(values, pointer, name, diagnostics) {
+function rejectCanonicalDuplicates(values, pointer, diagnostics) {
     const seen = new Set();
     for (const value of values) {
         let key;
@@ -135,7 +111,7 @@ function rejectCanonicalDuplicates(values, pointer, name, diagnostics) {
             continue;
         }
         if (seen.has(key)) {
-            diagnostics.push(diagnostic('VS_META_SCHEMA', pointer, `${name} rejects canonically equal duplicates.`));
+            diagnostics.push(diagnostic('VS_META_SCHEMA', pointer, 'enum rejects canonically equal duplicates.'));
             return;
         }
         seen.add(key);

package/dist/v1/language/value/profile/vocabulary.d.ts

@@ -1,2 +1,35 @@
-export declare const STANDARD_SCHEMA_KEYWORDS: Set<string>;
-export declare const FORBIDDEN_DYNAMIC_KEYWORDS: Set<string>;
+declare const keywords: readonly ['$anchor', '$comment', '$defs', '$dynamicAnchor', '$dynamicRef', '$id', '$ref', '$schema', '$vocabulary', 'additionalProperties', 'allOf', 'anyOf', 'const', 'contains', 'contentEncoding', 'contentMediaType', 'contentSchema', 'default', 'dependentRequired', 'dependentSchemas', 'deprecated', 'description', 'else', 'enum', 'examples', 'exclusiveMaximum', 'exclusiveMinimum', 'format', 'fullMatch', 'if', 'items', 'maxContains', 'maxItems', 'maxLength', 'maxProperties', 'maximum', 'minContains', 'minItems', 'minLength', 'minProperties', 'minimum', 'multipleOf', 'not', 'oneOf', 'pattern', 'patternProperties', 'prefixItems', 'properties', 'propertyNames', 'readOnly', 'required', 'then', 'title', 'type', 'unevaluatedItems', 'unevaluatedProperties', 'uniqueItems', 'writeOnly', 'x-astrale-path', 'x-astrale-value-kind'];
+export type ValueKeyword = (typeof keywords)[number];
+/**
+ * The closed V1 vocabulary: every keyword a value schema may name, the Astrale profile's included
+ * (`fullMatch`, `x-astrale-path`, `x-astrale-value-kind`). Any other keyword is refused
+ * (`VS_KEYWORD_CLOSED`). Other rules restrict some of these: the forbidden keywords never appear,
+ * `$id` never, `$schema` only at the root. Frozen and Unicode-ordered.
+ */
+export declare const VALUE_KEYWORDS: readonly ValueKeyword[];
+/** The keywords of the vocabulary refused wherever they appear (`VS_DYNAMIC_FORBIDDEN`). */
+export declare const FORBIDDEN_KEYWORDS: readonly ValueKeyword[];
+/**
+ * The keywords whose value holds subschemas, by its shape: one schema, an array of schemas, or an
+ * object of named schemas. A value schema's locations are its root and the subschemas these hold.
+ */
+export declare const SUBSCHEMA_KEYWORDS: {
+    readonly single: readonly ValueKeyword[];
+    readonly array: readonly ValueKeyword[];
+    readonly map: readonly ValueKeyword[];
+};
+/** A value kind a schema declares with `x-astrale-value-kind`, because no JSON type gives it. */
+export interface DeclaredValueKind {
+    /** The JSON type of its values, which the schema states beside the declaration. */
+    readonly type: 'string' | 'object';
+    /**
+     * Where a schema may declare it: at any location of any value schema, or only as the whole
+     * schema of a Node Property that is neither automatic nor a State Property.
+     */
+    readonly placement: 'any' | 'node-property';
+    /** The kind, in one plain sentence. */
+    readonly statement: string;
+}
+/** The value kinds `x-astrale-value-kind` declares; it admits no other value. */
+export declare const DECLARED_VALUE_KINDS: Readonly<Record<'instant' | 'blob', DeclaredValueKind>>;
+export {};

package/dist/v1/language/value/profile/vocabulary.js

@@ -1,4 +1,4 @@
-export const STANDARD_SCHEMA_KEYWORDS = new Set([
+const keywords = [
     '$anchor',
     '$comment',
     '$defs',
@@ -31,15 +31,15 @@ export const STANDARD_SCHEMA_KEYWORDS = new Set([
     'if',
     'items',
     'maxContains',
-    'maximum',
     'maxItems',
     'maxLength',
     'maxProperties',
+    'maximum',
     'minContains',
-    'minimum',
     'minItems',
     'minLength',
     'minProperties',
+    'minimum',
     'multipleOf',
     'not',
     'oneOf',
@@ -59,10 +59,57 @@ export const STANDARD_SCHEMA_KEYWORDS = new Set([
     'writeOnly',
     'x-astrale-path',
     'x-astrale-value-kind',
-]);
-export const FORBIDDEN_DYNAMIC_KEYWORDS = new Set([
+];
+/**
+ * The closed V1 vocabulary: every keyword a value schema may name, the Astrale profile's included
+ * (`fullMatch`, `x-astrale-path`, `x-astrale-value-kind`). Any other keyword is refused
+ * (`VS_KEYWORD_CLOSED`). Other rules restrict some of these: the forbidden keywords never appear,
+ * `$id` never, `$schema` only at the root. Frozen and Unicode-ordered.
+ */
+export const VALUE_KEYWORDS = Object.freeze(keywords);
+/** The keywords of the vocabulary refused wherever they appear (`VS_DYNAMIC_FORBIDDEN`). */
+export const FORBIDDEN_KEYWORDS = Object.freeze([
     '$anchor',
     '$dynamicAnchor',
     '$dynamicRef',
     '$vocabulary',
 ]);
+/**
+ * The keywords whose value holds subschemas, by its shape: one schema, an array of schemas, or an
+ * object of named schemas. A value schema's locations are its root and the subschemas these hold.
+ */
+export const SUBSCHEMA_KEYWORDS = Object.freeze({
+    single: Object.freeze([
+        'additionalProperties',
+        'contains',
+        'contentSchema',
+        'else',
+        'if',
+        'items',
+        'not',
+        'propertyNames',
+        'then',
+        'unevaluatedItems',
+        'unevaluatedProperties',
+    ]),
+    array: Object.freeze(['allOf', 'anyOf', 'oneOf', 'prefixItems']),
+    map: Object.freeze([
+        '$defs',
+        'dependentSchemas',
+        'patternProperties',
+        'properties',
+    ]),
+});
+/** The value kinds `x-astrale-value-kind` declares; it admits no other value. */
+export const DECLARED_VALUE_KINDS = Object.freeze({
+    instant: Object.freeze({
+        type: 'string',
+        placement: 'any',
+        statement: 'A UTC instant written YYYY-MM-DDTHH:mm:ss.sssZ, in the years 0000 to 9999, whose text order is its chronological order.',
+    }),
+    blob: Object.freeze({
+        type: 'object',
+        placement: 'node-property',
+        statement: 'The Ref of stored contents, its digest, media type and size: the schema is exactly a values.blob output, and the Property is written with an upload receipt.',
+    }),
+});

package/dist/v1/language/value/reference/registry.index.js

@@ -31,8 +31,9 @@ export function indexRegistry(registry, pointer) {
         dependenciesByOwner.set(domain.origin, pins);
         for (const dependency of domain.dependencies) {
             const target = domains.get(dependency.origin);
+            // The schema at `pointer` cannot be judged without the closure it may reference.
             if (target === undefined || target.revision !== dependency.revision) {
-                diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/registry/${domain.origin}/dependencies`, `Registry closure is missing exact ${dependency.origin}@${dependency.revision} required by ${domain.origin}.`));
+                diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Registry closure is missing exact ${dependency.origin}@${dependency.revision} required by ${domain.origin}.`));
             }
         }
     }

package/dist/v1/language/value/syntax/keywords.d.ts

@@ -1,3 +1,3 @@
-export declare const SCHEMA_ARRAY_KEYWORDS: Set<string>;
-export declare const SCHEMA_MAP_KEYWORDS: Set<string>;
-export declare const SCHEMA_SINGLE_KEYWORDS: Set<string>;
+export declare const SCHEMA_ARRAY_KEYWORDS: ReadonlySet<string>;
+export declare const SCHEMA_MAP_KEYWORDS: ReadonlySet<string>;
+export declare const SCHEMA_SINGLE_KEYWORDS: ReadonlySet<string>;

package/dist/v1/language/value/syntax/keywords.js

@@ -1,20 +1,4 @@
-export const SCHEMA_ARRAY_KEYWORDS = new Set(['allOf', 'anyOf', 'oneOf', 'prefixItems']);
-export const SCHEMA_MAP_KEYWORDS = new Set([
-    '$defs',
-    'dependentSchemas',
-    'patternProperties',
-    'properties',
-]);
-export const SCHEMA_SINGLE_KEYWORDS = new Set([
-    'additionalProperties',
-    'contains',
-    'contentSchema',
-    'else',
-    'if',
-    'items',
-    'not',
-    'propertyNames',
-    'then',
-    'unevaluatedItems',
-    'unevaluatedProperties',
-]);
+import { SUBSCHEMA_KEYWORDS } from '../profile/vocabulary.js';
+export const SCHEMA_ARRAY_KEYWORDS = new Set(SUBSCHEMA_KEYWORDS.array);
+export const SCHEMA_MAP_KEYWORDS = new Set(SUBSCHEMA_KEYWORDS.map);
+export const SCHEMA_SINGLE_KEYWORDS = new Set(SUBSCHEMA_KEYWORDS.single);

package/dist/v1/language/value/syntax/node-path/validate.js

@@ -29,11 +29,10 @@ export function validateNodePathExtension(schema, context, pointer, definitionEx
             location.schema.$ref !== GRAPH_NODE_PATH_SCHEMA_ID) {
             diagnostics.push(diagnostic('VS_PATH_EXTENSION', `${pointer}${location.pointer}`, `A Path field schema contains exactly $ref ${GRAPH_NODE_PATH_SCHEMA_ID} and x-astrale-path.`, GRAPH_NODE_PATH_SCHEMA_ID));
         }
+        // The dialect refuses an annotation that is not an object, at every location.
         const annotation = location.schema['x-astrale-path'];
-        if (!isJsonObject(annotation)) {
-            diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path must be a closed annotation object.'));
+        if (!isJsonObject(annotation))
             return;
-        }
         if (!hasExactKeys(annotation, ['target', 'cardinality', 'accepts'])) {
             diagnostics.push(diagnostic('VS_PATH_EXTENSION', extensionPointer, 'x-astrale-path contains exactly target, cardinality, and accepts.'));
         }