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

package/dist/v1/language/value/compile/fields.js

@@ -1,3 +1,5 @@
+import { compareCodeUnits } from '../../../addressing/ordering.js';
+import { escapePointerToken } from '../syntax/pointer.js';
 /** Exact field constraints available for independent scalar route validation. */
 export function inputFieldNodes(program) {
     const fields = new Map();
@@ -34,7 +36,7 @@ export function inputFieldNodes(program) {
             Array.isArray(schema.properties))
             return;
         for (const name of Object.keys(schema.properties)) {
-            const child = node.children[`properties/${escapePointer(name)}`];
+            const child = node.children[`properties/${escapePointerToken(name)}`];
             if (child === undefined)
                 throw new TypeError(`Compiled input field ${name} is absent.`);
             const constraints = fields.get(name) ?? new Set();
@@ -46,15 +48,9 @@ export function inputFieldNodes(program) {
     if (!closed || unsupported)
         return undefined;
     return Object.freeze(Object.fromEntries([...fields]
-        .sort(([left], [right]) => compare(left, right))
+        .sort(([left], [right]) => compareCodeUnits(left, right))
         .map(([name, nodes]) => [
         name,
         Object.freeze([...nodes].sort((left, right) => left - right)),
     ])));
 }
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

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

@@ -4,8 +4,11 @@ import { blob, BLOB_VALUE_KIND } from '../model/blob.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 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) => {
@@ -13,11 +16,11 @@ 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)) {
-                diagnostics.push(diagnostic('VS_KEYWORD_CLOSED', `${currentPointer}/${escapeToken(keyword)}`, `Keyword ${keyword} is outside the closed V1 Draft 2020-12 vocabulary.`));
+            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)) {
-                diagnostics.push(diagnostic('VS_DYNAMIC_FORBIDDEN', `${currentPointer}/${escapeToken(keyword)}`, `Keyword ${keyword} is forbidden by V1.`));
+            if (FORBIDDEN.has(keyword)) {
+                diagnostics.push(diagnostic('VS_DYNAMIC_FORBIDDEN', `${currentPointer}/${escapePointerToken(keyword)}`, `Keyword ${keyword} is forbidden by V1.`));
             }
         }
         if (Object.hasOwn(location.schema, '$schema')) {
@@ -28,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);
     });
@@ -73,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/${escapeToken(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);
     }
@@ -103,7 +90,7 @@ function validateRegexes(schema, pointer, diagnostics) {
     }
     if (isJsonObject(schema.patternProperties)) {
         for (const pattern of Object.keys(schema.patternProperties)) {
-            portableRegex(pattern, `${pointer}/patternProperties/${escapeToken(pattern)}`, 'A patternProperties key', 'patternProperties keys must satisfy RFC 9485 I-Regexp syntax.', diagnostics);
+            portableRegex(pattern, `${pointer}/patternProperties/${escapePointerToken(pattern)}`, 'A patternProperties key', 'patternProperties keys must satisfy RFC 9485 I-Regexp syntax.', diagnostics);
         }
     }
 }
@@ -113,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;
@@ -134,12 +111,9 @@ 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);
     }
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

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

@@ -1,4 +1,4 @@
-import { compareUnicode } from '../../../addressing/ordering.js';
+import { orderAndDeduplicate } from '../../validation/diagnostic.js';
 import { collectResourceClosure } from '../reference/closure.js';
 import { validateProductiveRecursion } from '../reference/recursion.js';
 import { hasNodeDefinition, indexRegistry } from '../reference/registry.index.js';
@@ -28,12 +28,3 @@ export function validateValueSchema(schema, context, registry, pointer = '') {
     diagnostics.push(...validateProductiveRecursion(closure.resources, closure.resolutions));
     return orderAndDeduplicate(diagnostics);
 }
-function orderAndDeduplicate(diagnostics) {
-    const unique = new Map();
-    for (const value of diagnostics) {
-        unique.set(`${value.pointer}\u0000${value.code}\u0000${value.ref ?? ''}\u0000${value.message}`, value);
-    }
-    return [...unique.values()].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-        compareUnicode(left.code, right.code) ||
-        compareUnicode(left.message, right.message));
-}

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/recursion.js

@@ -1,8 +1,7 @@
 import { diagnostic } from '../../validation/diagnostic.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
-import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../syntax/keywords.js';
 import { appendPointer } from '../syntax/pointer.js';
-import { isJsonSchema, walkSchema } from '../syntax/walk.js';
+import { forEachSubschema, walkSchema } from '../syntax/walk.js';
 import { locationKey } from './closure.js';
 export const CONSUMING_SCHEMA_KEYWORDS = new Set([
     'additionalProperties',
@@ -43,26 +42,7 @@ export function validateProductiveRecursion(resources, resolutions) {
             for (const [keyword, value] of Object.entries(location.schema)) {
                 if (!NON_CONSUMING_SCHEMA_KEYWORDS.has(keyword))
                     continue;
-                const keywordPointer = appendPointer(location.pointer, keyword);
-                if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
-                    outgoing.add(locationKey(resource.key, keywordPointer));
-                    continue;
-                }
-                if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
-                    value.forEach((entry, index) => {
-                        if (isJsonSchema(entry)) {
-                            outgoing.add(locationKey(resource.key, appendPointer(keywordPointer, index)));
-                        }
-                    });
-                    continue;
-                }
-                if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
-                    for (const [name, entry] of Object.entries(value)) {
-                        if (isJsonSchema(entry)) {
-                            outgoing.add(locationKey(resource.key, appendPointer(keywordPointer, name)));
-                        }
-                    }
-                }
+                forEachSubschema(keyword, value, appendPointer(location.pointer, keyword), (_, at) => outgoing.add(locationKey(resource.key, at)));
             }
         });
     }

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.'));
         }

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

@@ -1,3 +1,5 @@
+/** Escape one JSON Pointer reference token: `~` as `~0`, then `/` as `~1`. */
+export declare function escapePointerToken(token: string): string;
 export declare function appendPointer(pointer: string, token: string | number): string;
 export declare function parseJsonPointerFragment(fragment: string): readonly string[] | undefined;
 export declare function tokensToPointer(tokens: readonly string[]): string;

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

@@ -1,6 +1,9 @@
+/** Escape one JSON Pointer reference token: `~` as `~0`, then `/` as `~1`. */
+export function escapePointerToken(token) {
+    return token.replaceAll('~', '~0').replaceAll('/', '~1');
+}
 export function appendPointer(pointer, token) {
-    const encoded = String(token).replaceAll('~', '~0').replaceAll('/', '~1');
-    return `${pointer}/${encoded}`;
+    return `${pointer}/${escapePointerToken(String(token))}`;
 }
 export function parseJsonPointerFragment(fragment) {
     if (!fragment.startsWith('#'))

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

@@ -6,5 +6,7 @@ export interface SchemaLocation {
     readonly parentKeyword?: string;
 }
 export declare function walkSchema(schema: JsonSchema, visit: (location: SchemaLocation) => void, pointer?: string): void;
+/** Visit each subschema `keyword` holds directly, with its pointer under `pointer`. */
+export declare function forEachSubschema(keyword: string, value: unknown, pointer: string, visit: (schema: JsonSchema, pointer: string) => void): void;
 export declare function collectSchemaPointers(schema: JsonSchema): ReadonlySet<string>;
 export declare function isJsonSchema(value: unknown): value is JsonSchema;

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

@@ -14,26 +14,7 @@ export function walkSchema(schema, visit, pointer = '') {
             if (!isJsonObject(current))
                 return;
             for (const [keyword, value] of Object.entries(current)) {
-                const keywordPointer = appendPointer(currentPointer, keyword);
-                if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
-                    walk(value, keywordPointer, depth + 1, keyword);
-                    continue;
-                }
-                if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
-                    value.forEach((entry, index) => {
-                        if (isJsonSchema(entry)) {
-                            walk(entry, appendPointer(keywordPointer, index), depth + 1, keyword);
-                        }
-                    });
-                    continue;
-                }
-                if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
-                    for (const [name, entry] of Object.entries(value)) {
-                        if (isJsonSchema(entry)) {
-                            walk(entry, appendPointer(keywordPointer, name), depth + 1, keyword);
-                        }
-                    }
-                }
+                forEachSubschema(keyword, value, appendPointer(currentPointer, keyword), (entry, at) => walk(entry, at, depth + 1, keyword));
             }
         }
         finally {
@@ -43,6 +24,24 @@ export function walkSchema(schema, visit, pointer = '') {
     }
     walk(schema, pointer, 0);
 }
+/** Visit each subschema `keyword` holds directly, with its pointer under `pointer`. */
+export function forEachSubschema(keyword, value, pointer, visit) {
+    if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
+        visit(value, pointer);
+    }
+    else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+        value.forEach((entry, index) => {
+            if (isJsonSchema(entry))
+                visit(entry, appendPointer(pointer, index));
+        });
+    }
+    else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
+        for (const [name, entry] of Object.entries(value)) {
+            if (isJsonSchema(entry))
+                visit(entry, appendPointer(pointer, name));
+        }
+    }
+}
 export function collectSchemaPointers(schema) {
     const pointers = new Set();
     walkSchema(schema, ({ pointer }) => pointers.add(pointer));