@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

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

@@ -7,10 +7,11 @@ const TYPE_RANK = new Map(TYPE_ORDER.map((name, index) => [name, index]));
 const encoder = new TextEncoder();
 /** Canonicalizes syntax without rewriting the schema's algebra. Validate first. */
 export function canonicalizeValueSchema(schema, context, registry) {
+    void context;
     void registry;
-    return canonicalizeSchema(schema, true, context);
+    return canonicalizeSchema(schema, true);
 }
-function canonicalizeSchema(schema, root, context) {
+function canonicalizeSchema(schema, root) {
     if (typeof schema === 'boolean')
         return schema;
     const result = {};
@@ -39,17 +40,17 @@ function canonicalizeSchema(schema, root, context) {
             result[keyword] = canonicalizePathAnnotation(value);
         }
         else if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
-            result[keyword] = canonicalizeSchema(value, false, context);
+            result[keyword] = canonicalizeSchema(value, false);
         }
         else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
-            result[keyword] = value.map((entry) => isJsonSchema(entry) ? canonicalizeSchema(entry, false, context) : canonicalizeJson(entry));
+            result[keyword] = value.map((entry) => isJsonSchema(entry) ? canonicalizeSchema(entry, false) : canonicalizeJson(entry));
         }
         else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
             const schemas = {};
             for (const name of Object.keys(value).sort()) {
                 const entry = value[name];
                 schemas[name] = isJsonSchema(entry)
-                    ? canonicalizeSchema(entry, false, context)
+                    ? canonicalizeSchema(entry, false)
                     : canonicalizeJson(entry);
             }
             result[keyword] = schemas;

package/dist/v1/language/value/profile/json.validate.d.ts

@@ -1,2 +1,4 @@
+import { type Options } from '@astrale-os/kernel-dsl/value';
 import type { Diagnostic } from '../../validation/diagnostic.js';
-export declare function validateCanonicalJsonDomain(value: unknown, pointer: string): readonly Diagnostic[];
+/** Whether `value` is a portable JSON Value, within the portable limits `options` overrides. */
+export declare function validateCanonicalJsonDomain(value: unknown, pointer: string, options?: Options): readonly Diagnostic[];

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

@@ -1,8 +1,9 @@
 import { acceptForRead as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
 import { diagnostic } from '../../validation/diagnostic.js';
-export function validateCanonicalJsonDomain(value, pointer) {
+/** Whether `value` is a portable JSON Value, within the portable limits `options` overrides. */
+export function validateCanonicalJsonDomain(value, pointer, options) {
     try {
-        acceptJsonValue(value);
+        acceptJsonValue(value, options);
         return [];
     }
     catch (error) {

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

@@ -36,10 +36,9 @@ export function collectResourceClosure(schema, context, index, pointer) {
             const target = result.resolved.resource;
             if (resources.has(target.key))
                 return;
-            const registered = {
-                ...target,
-                diagnosticPointer: `${pointer}/registry/graphNodePath`,
-            };
+            // The graph NodePath resource is no part of the schema: what it holds is reported at the
+            // $ref that names it.
+            const registered = { ...target, diagnosticPointer: refPointer };
             resources.set(target.key, registered);
             queue.push(registered);
         });

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.d.ts

@@ -5,6 +5,8 @@ export interface RegistryIndex {
     readonly registry: ValueSchemaRegistry;
     readonly domains: ReadonlyMap<string, ValueSchemaDomainRegistry>;
     readonly dependenciesByOwner: ReadonlyMap<string, ReadonlyMap<string, string>>;
+    /** The `definitionRefIndex` of each Node Definition its own Domain lists. */
+    readonly nodeDefinitions: ReadonlySet<string>;
 }
 export declare function indexRegistry(registry: ValueSchemaRegistry, pointer: string): {
     readonly index: RegistryIndex;

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

@@ -4,11 +4,21 @@ import { diagnostic } from '../../validation/diagnostic.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 import { JSON_SCHEMA_DIALECT } from '../model/schema.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../syntax/node-path/schema.js';
+// A registry is an immutable value, and every value schema of a Domain is validated against the
+// same one: an index that admitted it without a diagnostic is reused, so the closure is indexed
+// once per registry rather than once per value schema.
+const admittedIndexes = new WeakMap();
 export function indexRegistry(registry, pointer) {
+    const admitted = admittedIndexes.get(registry);
+    if (admitted !== undefined)
+        return { index: admitted, diagnostics: [] };
     const diagnostics = [];
     const domains = new Map();
     domains.set(registry.current.origin, registry.current);
-    validateDomainRegistry(registry.current, `${pointer}/registry/current`, false, diagnostics);
+    // The registry is the closure the Kernel builds for the schema at `pointer`, not a document: a
+    // fault of one of its entries is a fault of the closure that schema is checked with, reported
+    // there, the entry named in the message.
+    validateDomainRegistry(registry.current, 'current', false, pointer, diagnostics);
     const dependencies = [
         ...registry.directDependencies.map((domain) => ({ domain, lane: 'directDependencies' })),
         ...registry.transitiveDependencies.map((domain) => ({
@@ -17,10 +27,9 @@ export function indexRegistry(registry, pointer) {
         })),
     ];
     dependencies.forEach(({ domain, lane }, index) => {
-        const domainPointer = `${pointer}/registry/${lane}/${index}`;
-        validateDomainRegistry(domain, domainPointer, true, diagnostics);
+        validateDomainRegistry(domain, `${lane}/${index}`, true, pointer, diagnostics);
         if (domain.origin === registry.current.origin || domains.has(domain.origin)) {
-            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', domainPointer, `Registry origin ${domain.origin} is duplicated in the exact closure.`));
+            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Registry origin ${domain.origin} is duplicated in the exact closure, at ${lane}/${index}.`));
             return;
         }
         domains.set(domain.origin, domain);
@@ -31,36 +40,44 @@ 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}.`));
             }
         }
     }
-    validateGraphNodePathResource(registry.graphNodePath, `${pointer}/registry/graphNodePath`, diagnostics);
-    return { index: { registry, domains, dependenciesByOwner }, diagnostics };
+    const nodeDefinitions = new Set();
+    for (const domain of domains.values()) {
+        for (const ref of domain.nodeDefinitions) {
+            if (ref.origin === domain.origin)
+                nodeDefinitions.add(definitionRefIndex(ref));
+        }
+    }
+    validateGraphNodePathResource(registry.graphNodePath, pointer, diagnostics);
+    const index = { registry, domains, dependenciesByOwner, nodeDefinitions };
+    if (diagnostics.length === 0)
+        admittedIndexes.set(registry, index);
+    return { index, diagnostics };
 }
 export function isOriginVisibleFrom(index, ownerOrigin, targetOrigin) {
     return (ownerOrigin === targetOrigin ||
         index.dependenciesByOwner.get(ownerOrigin)?.has(targetOrigin) === true);
 }
 export function hasNodeDefinition(index, ref, ownerOrigin) {
-    if (!isOriginVisibleFrom(index, ownerOrigin, ref.origin))
-        return false;
-    return (index.domains
-        .get(ref.origin)
-        ?.nodeDefinitions.some((candidate) => definitionRefIndex(candidate) === definitionRefIndex(ref)) === true);
+    return (isOriginVisibleFrom(index, ownerOrigin, ref.origin) &&
+        index.nodeDefinitions.has(definitionRefIndex(ref)));
 }
-function validateDomainRegistry(domain, pointer, revisionRequired, diagnostics) {
+function validateDomainRegistry(domain, entry, revisionRequired, pointer, diagnostics) {
     if (!DOMAIN_ORIGIN_PATTERN.test(domain.origin)) {
-        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/origin`, 'Registry origin is invalid.'));
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Registry origin is invalid, at ${entry}.`));
     }
     if ((revisionRequired && domain.revision === undefined) ||
         (domain.revision !== undefined && !DOMAIN_REVISION_PATTERN.test(domain.revision))) {
-        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/revision`, 'A dependency-closure registry entry requires its exact sha256 revision.'));
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `A dependency-closure registry entry requires its exact sha256 revision, at ${entry}.`));
     }
     for (const ref of domain.nodeDefinitions) {
         if (ref.origin !== domain.origin) {
-            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/nodeDefinitions`, 'A registry domain can list only its own Node Definitions.'));
+            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `A registry domain can list only its own Node Definitions, at ${entry}.`));
         }
     }
 }

package/dist/v1/language/value/regexp/ast.js

@@ -1,8 +1,7 @@
+import { limits } from '../../limits.js';
 import { categoryRanges, complement, mergeRanges } from './unicode.js';
 const CATEGORY = /^(?:L[lmotu]?|M[cen]?|N[dlo]?|P[cdefios]?|Z[lps]?|S[ckmo]?|C[cfno]?)$/u;
-const MAX_CODE_POINTS = 4096;
-const MAX_NESTING = 32;
-const MAX_REPEAT = 1000;
+const { maxCodePoints, maxNesting, maxRepeat } = limits.regexp;
 const DOT_RANGES = [
     [0, 9],
     [11, 12],
@@ -14,7 +13,7 @@ export function parseIRegexp(source) {
     if (!isUnicodeScalarString(source) || source === '[^]')
         return undefined;
     const characters = Array.from(source);
-    if (characters.length > MAX_CODE_POINTS)
+    if (characters.length > maxCodePoints)
         return undefined;
     const parser = new Parser(characters);
     const expression = parser.expression(undefined, 0);
@@ -30,7 +29,7 @@ class Parser {
         return this.index === this.characters.length;
     }
     expression(stop, depth) {
-        if (depth > MAX_NESTING)
+        if (depth > maxNesting)
             return undefined;
         const alternatives = [];
         const first = this.sequence(stop, depth);
@@ -112,14 +111,14 @@ class Parser {
     quantifier() {
         this.index++;
         const minimum = this.integer();
-        if (minimum === undefined || minimum > MAX_REPEAT)
+        if (minimum === undefined || minimum > maxRepeat)
             return undefined;
         let maximum = minimum;
         if (this.peek() === ',') {
             this.index++;
             maximum = this.integer();
         }
-        if ((maximum !== undefined && (maximum > MAX_REPEAT || maximum < minimum)) ||
+        if ((maximum !== undefined && (maximum > maxRepeat || maximum < minimum)) ||
             this.peek() !== '}') {
             return undefined;
         }

package/dist/v1/language/value/regexp/compile.d.ts

@@ -1,16 +1,9 @@
 import type { Pattern, RunPattern } from '../compile/model.js';
 import type { Expression } from './ast.js';
 /**
- * The most states the machine of one I-Regexp may have (`limits.regexp.maxStates`), an
- * implementation limit as RFC 9485 §8 allows. Counted repetitions are expanded copy by copy, so the
- * parser's bounds on length, nesting and counts alone admit machines of billions of states. The
- * counted-run form never expands, so it is not subject to this budget.
- */
-export declare const MAX_STATES = 10000;
-/**
- * Thrown when an I-Regexp source compiles to a machine of more than `MAX_STATES` states. A short
- * branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and cost seconds per
- * validated value (P1-I-01); it is refused before any state is built.
+ * Thrown when an I-Regexp source compiles to a machine of more than `limits.regexp.maxStates`
+ * states. A short branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and
+ * cost seconds per validated value (P1-I-01); it is refused before any state is built.
  */
 export declare class PatternComplexityError extends RangeError {
     readonly limit: number;
@@ -20,7 +13,8 @@ export declare class PatternComplexityError extends RangeError {
 export declare function compilePattern(source: string): Pattern | RunPattern;
 /**
  * Whether a parsed I-Regexp compiles within the state budget: as counted runs, which never expand,
- * or as a machine of at most `MAX_STATES` states, counted from the AST before anything is built.
+ * or as a machine of at most `limits.regexp.maxStates` states, counted from the AST before anything
+ * is built.
  */
 export declare function withinStateBudget(expression: Expression): boolean;
 /**

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

@@ -1,19 +1,20 @@
+import { limits } from '../../limits.js';
 import { parseIRegexp } from './ast.js';
 /**
- * The most states the machine of one I-Regexp may have (`limits.regexp.maxStates`), an
- * implementation limit as RFC 9485 §8 allows. Counted repetitions are expanded copy by copy, so the
- * parser's bounds on length, nesting and counts alone admit machines of billions of states. The
- * counted-run form never expands, so it is not subject to this budget.
+ * The most states the machine of one I-Regexp may have, an implementation limit as RFC 9485 §8
+ * allows. Counted repetitions are expanded copy by copy, so the parser's bounds on length, nesting
+ * and counts alone admit machines of billions of states. The counted-run form never expands, so it
+ * is not subject to this budget.
  */
-export const MAX_STATES = 10_000;
+const { maxStates } = limits.regexp;
 /**
- * Thrown when an I-Regexp source compiles to a machine of more than `MAX_STATES` states. A short
- * branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and cost seconds per
- * validated value (P1-I-01); it is refused before any state is built.
+ * Thrown when an I-Regexp source compiles to a machine of more than `limits.regexp.maxStates`
+ * states. A short branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and
+ * cost seconds per validated value (P1-I-01); it is refused before any state is built.
  */
 export class PatternComplexityError extends RangeError {
     limit;
-    constructor(limit = MAX_STATES) {
+    constructor(limit = maxStates) {
         super(`Cannot compile an I-Regexp machine of more than ${limit} states.`);
         this.limit = limit;
         this.name = 'PatternComplexityError';
@@ -27,7 +28,7 @@ export function compilePattern(source) {
     const runs = scalarRuns(expression);
     if (runs !== undefined)
         return Object.freeze({ source, runs });
-    if (states(expression) > MAX_STATES)
+    if (states(expression) > maxStates)
         throw new PatternComplexityError();
     const builder = new Builder();
     const fragment = builder.expression(expression);
@@ -40,10 +41,11 @@ export function compilePattern(source) {
 }
 /**
  * Whether a parsed I-Regexp compiles within the state budget: as counted runs, which never expand,
- * or as a machine of at most `MAX_STATES` states, counted from the AST before anything is built.
+ * or as a machine of at most `limits.regexp.maxStates` states, counted from the AST before anything
+ * is built.
  */
 export function withinStateBudget(expression) {
-    return scalarRuns(expression) !== undefined || states(expression) <= MAX_STATES;
+    return scalarRuns(expression) !== undefined || states(expression) <= maxStates;
 }
 /**
  * The number of states `Builder` builds for an expression, computed from the AST alone: `states`