@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.41

package/dist/v1/language/value/profile/meta-schema.d.ts

@@ -0,0 +1,4 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { JsonSchema } from '../model/schema.js';
+/** Validate untrusted value-schema structure with the pinned generated meta-schema validator. */
+export declare function validateValueSchemaMetaSchema(schema: JsonSchema, pointer: string): readonly Diagnostic[];

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

@@ -0,0 +1,19 @@
+import { diagnostic } from '../../validation/diagnostic.js';
+import validateMetaSchema from './meta-schema.compiled.js';
+const validate = validateMetaSchema;
+/** Validate untrusted value-schema structure with the pinned generated meta-schema validator. */
+export function validateValueSchemaMetaSchema(schema, pointer) {
+    try {
+        if (validate(schema))
+            return [];
+        return (validate.errors ?? []).map((error) => diagnostic('VS_META_SCHEMA', `${pointer}${error.instancePath}`, `Astrale V1 value-schema meta-schema rejected the schema: ${error.message ?? error.keyword}.`));
+    }
+    catch (error) {
+        return [
+            diagnostic('VS_META_SCHEMA', pointer, `Astrale V1 value-schema meta-schema validation failed closed: ${errorMessage(error)}.`),
+        ];
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -0,0 +1,3 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { JsonSchema, ValueSchemaContext } from '../model/schema.js';
+export declare function validateSchemaProfile(schema: JsonSchema, context: ValueSchemaContext, pointer: string): readonly Diagnostic[];

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

@@ -0,0 +1,141 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { diagnostic } from '../../validation/diagnostic.js';
+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 { isIRegexp } from '../regexp/syntax.js';
+import { walkSchema } from '../syntax/walk.js';
+import { FORBIDDEN_DYNAMIC_KEYWORDS, STANDARD_SCHEMA_KEYWORDS } from './vocabulary.js';
+export function validateSchemaProfile(schema, context, pointer) {
+    const diagnostics = [];
+    walkSchema(schema, (location) => {
+        if (!isJsonObject(location.schema))
+            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 (FORBIDDEN_DYNAMIC_KEYWORDS.has(keyword)) {
+                diagnostics.push(diagnostic('VS_DYNAMIC_FORBIDDEN', `${currentPointer}/${escapeToken(keyword)}`, `Keyword ${keyword} is forbidden by V1.`));
+            }
+        }
+        if (Object.hasOwn(location.schema, '$schema')) {
+            if (location.depth !== 0 || location.schema.$schema !== VALUE_SCHEMA_DIALECT) {
+                diagnostics.push(diagnostic('VS_DIALECT', `${currentPointer}/$schema`, `Embedded-root $schema is optional, but when present must equal ${VALUE_SCHEMA_DIALECT}.`));
+            }
+        }
+        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);
+        validateValueKind(location.schema, context, location.depth, currentPointer, diagnostics);
+        validateRegexes(location.schema, currentPointer, diagnostics);
+    });
+    return diagnostics;
+}
+function validateValueKind(schema, context, depth, pointer, diagnostics) {
+    if (!Object.hasOwn(schema, 'x-astrale-value-kind'))
+        return;
+    if (schema['x-astrale-value-kind'] === BLOB_VALUE_KIND) {
+        if (context !== 'property-facet' || depth !== 0 || !isCanonicalBlobSchema(schema)) {
+            diagnostics.push(diagnostic('VS_VALUE_KIND', `${pointer}/x-astrale-value-kind`, 'blob must be the exact schema.values.blob output at the root of a Node property.'));
+        }
+    }
+    else if (schema['x-astrale-value-kind'] !== 'instant' || schema.type !== 'string') {
+        diagnostics.push(diagnostic('VS_VALUE_KIND', `${pointer}/x-astrale-value-kind`, 'x-astrale-value-kind is exactly instant and requires type string at the same schema location.'));
+    }
+}
+function isCanonicalBlobSchema(input) {
+    const properties = input.properties;
+    if (!isJsonObject(properties))
+        return false;
+    const size = properties.size;
+    const mediaType = properties.mediaType;
+    if (!isJsonObject(size) || !isJsonObject(mediaType))
+        return false;
+    const maxBytes = size.maximum;
+    if (typeof maxBytes !== 'number' || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+        return false;
+    }
+    const mediaTypes = mediaType.enum;
+    if (mediaTypes !== undefined && (!Array.isArray(mediaTypes) || !mediaTypes.every(isString))) {
+        return false;
+    }
+    try {
+        return (json.serialize(input) ===
+            json.serialize(blob({ maxBytes, ...(mediaTypes === undefined ? {} : { mediaTypes }) })));
+    }
+    catch {
+        return false;
+    }
+}
+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);
+            }
+        }
+    }
+}
+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' && !isIRegexp(schema.fullMatch)) {
+        diagnostics.push(diagnostic('VS_REGEX_PORTABLE', `${pointer}/fullMatch`, 'fullMatch must satisfy the complete RFC 9485 I-Regexp syntax.'));
+    }
+    if (typeof schema.pattern === 'string' && !isIRegexp(schema.pattern)) {
+        diagnostics.push(diagnostic('VS_REGEX_PORTABLE', `${pointer}/pattern`, 'pattern must satisfy the complete RFC 9485 I-Regexp syntax.'));
+    }
+    if (isJsonObject(schema.patternProperties)) {
+        for (const pattern of Object.keys(schema.patternProperties)) {
+            if (!isIRegexp(pattern)) {
+                diagnostics.push(diagnostic('VS_REGEX_PORTABLE', `${pointer}/patternProperties/${escapeToken(pattern)}`, 'patternProperties keys must satisfy RFC 9485 I-Regexp syntax.'));
+            }
+        }
+    }
+}
+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) {
+    const seen = new Set();
+    for (const value of values) {
+        let key;
+        try {
+            key = json.serialize(value);
+        }
+        catch {
+            continue;
+        }
+        if (seen.has(key)) {
+            diagnostics.push(diagnostic('VS_META_SCHEMA', pointer, `${name} rejects canonically equal duplicates.`));
+            return;
+        }
+        seen.add(key);
+    }
+}
+function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

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

@@ -0,0 +1,4 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { JsonSchema, ValueSchemaContext } from '../model/schema.js';
+import type { ValueSchemaRegistry } from '../reference/registry.js';
+export declare function validateValueSchema(schema: JsonSchema, context: ValueSchemaContext, registry: ValueSchemaRegistry, pointer?: string): Diagnostic[];

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

@@ -0,0 +1,39 @@
+import { compareUnicode } from '../../../addressing/ordering.js';
+import { collectResourceClosure } from '../reference/closure.js';
+import { validateProductiveRecursion } from '../reference/recursion.js';
+import { hasNodeDefinition, indexRegistry } from '../reference/registry.index.js';
+import { GRAPH_NODE_PATH_SCHEMA_ID } from '../syntax/node-path/schema.js';
+import { validateNodePathExtension } from '../syntax/node-path/validate.js';
+import { validateCanonicalJsonDomain } from './json.validate.js';
+import { validateValueSchemaMetaSchema } from './meta-schema.js';
+import { validateSchemaProfile } from './rules.js';
+export function validateValueSchema(schema, context, registry, pointer = '') {
+    const diagnostics = [];
+    diagnostics.push(...validateCanonicalJsonDomain(schema, pointer));
+    const indexed = indexRegistry(registry, pointer);
+    diagnostics.push(...indexed.diagnostics);
+    const closure = collectResourceClosure(schema, context, indexed.index, pointer);
+    diagnostics.push(...closure.diagnostics);
+    for (const resource of closure.resources.values()) {
+        // The Core-owned graph locator artifact is admitted exactly by indexRegistry. It participates
+        // in instance evaluation, but it is not an embedded V1 value-schema resource.
+        if (resource.key === GRAPH_NODE_PATH_SCHEMA_ID)
+            continue;
+        const resourcePointer = resource.diagnosticPointer ?? pointer;
+        diagnostics.push(...validateValueSchemaMetaSchema(resource.schema, resourcePointer));
+        diagnostics.push(...validateCanonicalJsonDomain(resource.schema, resourcePointer));
+        diagnostics.push(...validateSchemaProfile(resource.schema, context, resourcePointer));
+        diagnostics.push(...validateNodePathExtension(resource.schema, context, resourcePointer, (ref) => hasNodeDefinition(indexed.index, ref, resource.ownerOrigin)));
+    }
+    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

@@ -0,0 +1,2 @@
+export declare const STANDARD_SCHEMA_KEYWORDS: Set<string>;
+export declare const FORBIDDEN_DYNAMIC_KEYWORDS: Set<string>;

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

@@ -0,0 +1,68 @@
+export const STANDARD_SCHEMA_KEYWORDS = new Set([
+    '$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',
+    'maximum',
+    'maxItems',
+    'maxLength',
+    'maxProperties',
+    'minContains',
+    'minimum',
+    'minItems',
+    'minLength',
+    'minProperties',
+    '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 const FORBIDDEN_DYNAMIC_KEYWORDS = new Set([
+    '$anchor',
+    '$dynamicAnchor',
+    '$dynamicRef',
+    '$vocabulary',
+]);

package/dist/v1/language/value/reference/closure.d.ts

@@ -0,0 +1,11 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { JsonSchema, ValueSchemaContext } from '../model/schema.js';
+import type { RegistryIndex } from './registry.index.js';
+import { type ResolvedAddressReference, type SchemaResource } from './references.js';
+export interface ValueSchemaResourceClosure {
+    readonly resources: ReadonlyMap<string, SchemaResource>;
+    readonly resolutions: ReadonlyMap<string, ResolvedAddressReference>;
+    readonly diagnostics: readonly Diagnostic[];
+}
+export declare function collectResourceClosure(schema: JsonSchema, context: ValueSchemaContext, index: RegistryIndex, pointer: string): ValueSchemaResourceClosure;
+export declare function locationKey(resourceKey: string, pointer: string): string;

package/dist/v1/language/value/reference/closure.js

@@ -0,0 +1,51 @@
+import { diagnostic } from '../../validation/diagnostic.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { hasNodePathAnnotation } from '../syntax/node-path/schema.js';
+import { walkSchema } from '../syntax/walk.js';
+import { resolveAddressReference, } from './references.js';
+export function collectResourceClosure(schema, context, index, pointer) {
+    const diagnostics = [];
+    const resources = new Map();
+    const resolutions = new Map();
+    const initial = {
+        key: `urn:astrale:dsl:v1:embedded:${context}`,
+        schema,
+        ownerOrigin: index.registry.current.origin,
+        diagnosticPointer: pointer,
+    };
+    resources.set(initial.key, initial);
+    const queue = [initial];
+    while (queue.length > 0) {
+        const resource = queue.shift();
+        if (resource === undefined)
+            break;
+        walkSchema(resource.schema, (location) => {
+            if (!isJsonObject(location.schema) || !Object.hasOwn(location.schema, '$ref'))
+                return;
+            const refPointer = `${resource.diagnosticPointer ?? pointer}${location.pointer}/$ref`;
+            if (typeof location.schema.$ref !== 'string') {
+                diagnostics.push(diagnostic('VS_REFERENCE_FORM', refPointer, '$ref must be a string URI-reference.'));
+                return;
+            }
+            const result = resolveAddressReference(location.schema.$ref, resource, index, refPointer, hasNodePathAnnotation(location.schema));
+            if (result.diagnostic !== undefined)
+                diagnostics.push(result.diagnostic);
+            if (result.resolved === undefined)
+                return;
+            resolutions.set(locationKey(resource.key, location.pointer), result.resolved);
+            const target = result.resolved.resource;
+            if (resources.has(target.key))
+                return;
+            const registered = {
+                ...target,
+                diagnosticPointer: `${pointer}/registry/graphNodePath`,
+            };
+            resources.set(target.key, registered);
+            queue.push(registered);
+        });
+    }
+    return { resources, resolutions, diagnostics };
+}
+export function locationKey(resourceKey, pointer) {
+    return `${resourceKey}\u0000${pointer}`;
+}

package/dist/v1/language/value/reference/recursion.d.ts

@@ -0,0 +1,5 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { ResolvedAddressReference, SchemaResource } from './references.js';
+export declare const CONSUMING_SCHEMA_KEYWORDS: Set<string>;
+export declare const NON_CONSUMING_SCHEMA_KEYWORDS: Set<string>;
+export declare function validateProductiveRecursion(resources: ReadonlyMap<string, SchemaResource>, resolutions: ReadonlyMap<string, ResolvedAddressReference>): readonly Diagnostic[];

package/dist/v1/language/value/reference/recursion.js

@@ -0,0 +1,95 @@
+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 { locationKey } from './closure.js';
+export const CONSUMING_SCHEMA_KEYWORDS = new Set([
+    'additionalProperties',
+    'contains',
+    'items',
+    'patternProperties',
+    'prefixItems',
+    'properties',
+    'propertyNames',
+    'unevaluatedItems',
+    'unevaluatedProperties',
+]);
+export const NON_CONSUMING_SCHEMA_KEYWORDS = new Set([
+    '$defs',
+    'allOf',
+    'anyOf',
+    'dependentSchemas',
+    'else',
+    'if',
+    'not',
+    'oneOf',
+    'then',
+]);
+export function validateProductiveRecursion(resources, resolutions) {
+    const adjacency = new Map();
+    const diagnosticPointers = new Map();
+    for (const resource of resources.values()) {
+        walkSchema(resource.schema, (location) => {
+            const source = locationKey(resource.key, location.pointer);
+            diagnosticPointers.set(source, `${resource.diagnosticPointer ?? ''}${location.pointer}`);
+            const outgoing = adjacency.get(source) ?? new Set();
+            adjacency.set(source, outgoing);
+            if (!isJsonObject(location.schema))
+                return;
+            const ref = resolutions.get(source);
+            if (ref !== undefined)
+                outgoing.add(locationKey(ref.resource.key, ref.pointer));
+            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)));
+                        }
+                    }
+                }
+            }
+        });
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    for (const node of adjacency.keys()) {
+        const cycleAt = findCycle(node, adjacency, visiting, visited);
+        if (cycleAt !== undefined) {
+            return [
+                diagnostic('VS_RECURSION_PRODUCTIVE', diagnosticPointers.get(cycleAt) ?? '', 'Every recursive cycle must cross an instance-consuming schema edge.'),
+            ];
+        }
+    }
+    return [];
+}
+function findCycle(node, adjacency, visiting, visited) {
+    if (visiting.has(node))
+        return node;
+    if (visited.has(node))
+        return undefined;
+    visiting.add(node);
+    for (const target of adjacency.get(node) ?? []) {
+        const cycleAt = findCycle(target, adjacency, visiting, visited);
+        if (cycleAt !== undefined)
+            return cycleAt;
+    }
+    visiting.delete(node);
+    visited.add(node);
+    return undefined;
+}

package/dist/v1/language/value/reference/references.d.ts

@@ -0,0 +1,17 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { JsonSchema } from '../model/schema.js';
+import type { RegistryIndex } from './registry.index.js';
+export interface SchemaResource {
+    readonly key: string;
+    readonly schema: JsonSchema;
+    readonly ownerOrigin: string;
+    readonly diagnosticPointer?: string;
+}
+export interface ResolvedAddressReference {
+    readonly resource: SchemaResource;
+    readonly pointer: string;
+}
+export declare function resolveAddressReference(ref: string, from: SchemaResource, index: RegistryIndex, pointer: string, nodePathPlacement: boolean): {
+    readonly resolved?: ResolvedAddressReference;
+    readonly diagnostic?: Diagnostic;
+};

package/dist/v1/language/value/reference/references.js

@@ -0,0 +1,45 @@
+import { diagnostic } from '../../validation/diagnostic.js';
+import { GRAPH_NODE_PATH_SCHEMA_ID } from '../syntax/node-path/schema.js';
+import { parseJsonPointerFragment, resolvePointer, tokensToPointer } from '../syntax/pointer.js';
+import { collectSchemaPointers } from '../syntax/walk.js';
+export function resolveAddressReference(ref, from, index, pointer, nodePathPlacement) {
+    if (ref === GRAPH_NODE_PATH_SCHEMA_ID) {
+        if (!nodePathPlacement) {
+            return {
+                diagnostic: diagnostic('VS_REFERENCE_FORM', pointer, 'The graph NodePath schema may be referenced only beside a valid x-astrale-path annotation.', ref),
+            };
+        }
+        return {
+            resolved: {
+                resource: {
+                    key: GRAPH_NODE_PATH_SCHEMA_ID,
+                    schema: index.registry.graphNodePath,
+                    ownerOrigin: from.ownerOrigin,
+                },
+                pointer: '',
+            },
+        };
+    }
+    if (ref.startsWith('#')) {
+        const tokens = parseJsonPointerFragment(ref);
+        if (tokens === undefined) {
+            return {
+                diagnostic: diagnostic('VS_REFERENCE_FORM', pointer, 'A local $ref must be a JSON Pointer fragment; anchors are forbidden.', ref),
+            };
+        }
+        return resolveTarget(from, tokens, pointer, ref);
+    }
+    return {
+        diagnostic: diagnostic('VS_REFERENCE_FORM', pointer, 'A $ref must be a local JSON Pointer or the graph NodePath id at its extension site.', ref),
+    };
+}
+function resolveTarget(resource, tokens, diagnosticPointer, ref) {
+    const target = resolvePointer(resource.schema, tokens);
+    const pointer = tokensToPointer(tokens);
+    if (target === undefined || !collectSchemaPointers(resource.schema).has(pointer)) {
+        return {
+            diagnostic: diagnostic('VS_REFERENCE_RESOLUTION', diagnosticPointer, 'The $ref does not resolve to an exact schema location in the registry.', ref),
+        };
+    }
+    return { resolved: { resource, pointer } };
+}

package/dist/v1/language/value/reference/registry.d.ts

@@ -0,0 +1,24 @@
+import type { ClassRef } from '../../../addressing/index.js';
+import type { JsonSchema } from '../model/schema.js';
+export interface ValueSchemaDependency {
+    readonly origin: string;
+    readonly revision: `sha256:${string}`;
+}
+export interface ValueSchemaDomainRegistry {
+    readonly origin: string;
+    readonly revision?: `sha256:${string}`;
+    readonly dependencies: readonly ValueSchemaDependency[];
+    readonly nodeDefinitions: readonly ClassRef[];
+}
+/**
+ * The exact closure visible while validating one DomainSchema.
+ *
+ * The exact closure is present, but each resource may see only its owning
+ * Domain and that owner's exact direct dependency pins.
+ */
+export interface ValueSchemaRegistry {
+    readonly current: ValueSchemaDomainRegistry;
+    readonly directDependencies: readonly ValueSchemaDomainRegistry[];
+    readonly transitiveDependencies: readonly ValueSchemaDomainRegistry[];
+    readonly graphNodePath: JsonSchema;
+}

package/dist/v1/language/value/reference/registry.index.d.ts

@@ -0,0 +1,14 @@
+import type { ClassRef } from '../../../addressing/index.js';
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { ValueSchemaDomainRegistry, ValueSchemaRegistry } from './registry.js';
+export interface RegistryIndex {
+    readonly registry: ValueSchemaRegistry;
+    readonly domains: ReadonlyMap<string, ValueSchemaDomainRegistry>;
+    readonly dependenciesByOwner: ReadonlyMap<string, ReadonlyMap<string, string>>;
+}
+export declare function indexRegistry(registry: ValueSchemaRegistry, pointer: string): {
+    readonly index: RegistryIndex;
+    readonly diagnostics: readonly Diagnostic[];
+};
+export declare function isOriginVisibleFrom(index: RegistryIndex, ownerOrigin: string, targetOrigin: string): boolean;
+export declare function hasNodeDefinition(index: RegistryIndex, ref: ClassRef, ownerOrigin: string): boolean;

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

@@ -0,0 +1,76 @@
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTERN } from '../../../addressing/patterns.js';
+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';
+export function indexRegistry(registry, pointer) {
+    const diagnostics = [];
+    const domains = new Map();
+    domains.set(registry.current.origin, registry.current);
+    validateDomainRegistry(registry.current, `${pointer}/registry/current`, false, diagnostics);
+    const dependencies = [
+        ...registry.directDependencies.map((domain) => ({ domain, lane: 'directDependencies' })),
+        ...registry.transitiveDependencies.map((domain) => ({
+            domain,
+            lane: 'transitiveDependencies',
+        })),
+    ];
+    dependencies.forEach(({ domain, lane }, index) => {
+        const domainPointer = `${pointer}/registry/${lane}/${index}`;
+        validateDomainRegistry(domain, domainPointer, true, 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.`));
+            return;
+        }
+        domains.set(domain.origin, domain);
+    });
+    const dependenciesByOwner = new Map();
+    for (const domain of domains.values()) {
+        const pins = new Map(domain.dependencies.map((dependency) => [dependency.origin, dependency.revision]));
+        dependenciesByOwner.set(domain.origin, pins);
+        for (const dependency of domain.dependencies) {
+            const target = domains.get(dependency.origin);
+            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}.`));
+            }
+        }
+    }
+    validateGraphNodePathResource(registry.graphNodePath, `${pointer}/registry/graphNodePath`, diagnostics);
+    return { index: { registry, domains, dependenciesByOwner }, 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);
+}
+function validateDomainRegistry(domain, pointer, revisionRequired, diagnostics) {
+    if (!DOMAIN_ORIGIN_PATTERN.test(domain.origin)) {
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/origin`, 'Registry origin is invalid.'));
+    }
+    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.'));
+    }
+    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.'));
+        }
+    }
+}
+function validateGraphNodePathResource(schema, pointer, diagnostics) {
+    if (!isJsonObject(schema) ||
+        schema.$schema !== JSON_SCHEMA_DIALECT ||
+        schema.$id !== GRAPH_NODE_PATH_SCHEMA_ID ||
+        schema.type !== 'string' ||
+        schema.minLength !== 1 ||
+        schema.format !== 'astrale-node-path-v1') {
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `The graph NodePath artifact must be preloaded under exact id ${GRAPH_NODE_PATH_SCHEMA_ID}.`, GRAPH_NODE_PATH_SCHEMA_ID));
+    }
+}

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

@@ -0,0 +1 @@
+export {};