@astrale-os/kernel-dsl 0.2.0-beta.5 → 0.2.0-beta.7

package/dist/v1/{schema → language}/value/ordering.js

@@ -1,5 +1,5 @@
-import { prepareValueSchema } from './instance/preparation.js';
-import { locationKey } from './resources/closure.js';
+import { loadValueProgram } from './compile/load.js';
+import { prepareValueSchema } from './evaluate/preparation.js';
 const ALL_JSON_KINDS = new Set([
     'null',
     'boolean',
@@ -26,6 +26,17 @@ export function classifyOrdering(contract, registry) {
         ? kind
         : undefined;
 }
+/** Recompute the scalar ordering classification from one admitted portable value program. */
+export function classifyValueProgramOrdering(program) {
+    const compiled = loadValueProgram(program);
+    const candidates = new OrderingClassifier(compiled).classify(compiled.root);
+    if (candidates.size !== 1)
+        return undefined;
+    const [kind] = candidates;
+    return kind === 'boolean' || kind === 'number' || kind === 'string' || kind === 'instant'
+        ? kind
+        : undefined;
+}
 class OrderingClassifier {
     compiled;
     active = new Set();
@@ -72,10 +83,7 @@ class OrderingClassifier {
             candidates = intersect(candidates, normalize(new Set(schema.enum.map(kindOfValue))));
         }
         if (Object.hasOwn(schema, '$ref')) {
-            const resolved = this.compiled.resolutions.get(location.key);
-            if (resolved === undefined)
-                return new Set();
-            const target = this.compiled.locations.get(locationKey(resolved.resource.key, resolved.pointer));
+            const target = this.compiled.reference(location);
             if (target === undefined)
                 return new Set();
             candidates = intersect(candidates, this.classify(target));
@@ -99,12 +107,7 @@ class OrderingClassifier {
         return candidates;
     }
     child(location, keyword, index) {
-        const suffix = index === undefined ? `/${keyword}` : `/${keyword}/${index}`;
-        const child = this.compiled.locations.get(`${location.key}${suffix}`);
-        if (child === undefined) {
-            throw new TypeError('Prepared value schema child is absent from its closure.');
-        }
-        return child;
+        return this.compiled.child(location, keyword, index);
     }
 }
 function typesOf(input) {
@@ -169,4 +172,3 @@ function normalize(input) {
 function schemaList(input) {
     return Array.isArray(input) ? input : undefined;
 }
-//# sourceMappingURL=ordering.js.map

package/dist/v1/{schema → language}/value/profile/canonicalize.d.ts

@@ -1,5 +1,4 @@
-import type { ValueSchemaRegistry } from '../registry.js';
-import type { JsonSchema, ValueSchemaContext } from '../schema.js';
+import type { JsonSchema, ValueSchemaContext } from '../model/schema.js';
+import type { ValueSchemaRegistry } from '../reference/registry.js';
 /** Canonicalizes syntax without rewriting the schema's algebra. Validate first. */
 export declare function canonicalizeValueSchema(schema: JsonSchema, context?: ValueSchemaContext, registry?: ValueSchemaRegistry): JsonSchema;
-//# sourceMappingURL=canonicalize.d.ts.map

package/dist/v1/{schema → language}/value/profile/canonicalize.js

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { compareSchemaRefs, compareUnicode } from '../../reference.js';
-import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../location/keywords.js';
-import { isValueObject as isJsonObject } from '../object.js';
+import { compareDefinitionRefs, compareUnicode } from '../../../addressing/ordering.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../syntax/keywords.js';
 const TYPE_ORDER = ['null', 'boolean', 'integer', 'number', 'string', 'array', 'object'];
 const TYPE_RANK = new Map(TYPE_ORDER.map((name, index) => [name, index]));
 const encoder = new TextEncoder();
@@ -17,8 +17,6 @@ function canonicalizeSchema(schema, root, context) {
     for (const keyword of Object.keys(schema).sort()) {
         if (root && keyword === '$schema')
             continue;
-        if (root && context === 'named-type' && keyword === '$id')
-            continue;
         const value = schema[keyword];
         if (keyword === 'required' && Array.isArray(value)) {
             assertUnique(value, String, 'required');
@@ -82,7 +80,7 @@ function canonicalizePathAnnotation(value) {
         if (key === 'accepts' && Array.isArray(entry)) {
             const accepts = entry.map(canonicalizeJson);
             assertUnique(accepts, json.serialize, 'x-astrale-path.accepts');
-            result[key] = accepts.sort((left, right) => compareSchemaRefs(left, right));
+            result[key] = accepts.sort((left, right) => compareDefinitionRefs(left, right));
         }
         else
             result[key] = canonicalizeJson(entry);
@@ -130,4 +128,3 @@ function assertUnique(values, keyOf, name) {
 function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);
 }
-//# sourceMappingURL=canonicalize.js.map

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

@@ -0,0 +1,2 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+export declare function validateCanonicalJsonDomain(value: unknown, pointer: string): readonly Diagnostic[];

package/dist/v1/{schema → language}/value/profile/json.validate.js

@@ -1,5 +1,5 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
-import { diagnostic } from '../../diagnostic.js';
+import { diagnostic } from '../../validation/diagnostic.js';
 export function validateCanonicalJsonDomain(value, pointer) {
     try {
         acceptJsonValue(value);
@@ -12,4 +12,3 @@ export function validateCanonicalJsonDomain(value, pointer) {
         return [diagnostic('VS_META_SCHEMA', pointer, 'Value is outside the JSON data model.')];
     }
 }
-//# sourceMappingURL=json.validate.js.map

package/dist/v1/{schema → language}/value/profile/meta-schema.compiled.d.ts

@@ -76,4 +76,3 @@ declare namespace validate20 {
         dynamicItems: boolean;
     };
 }
-//# sourceMappingURL=meta-schema.compiled.d.ts.map

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

@@ -2077,4 +2077,3 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
     return errors === 0;
 }
 validate20.evaluated = { "props": { "fullMatch": true, "x-astrale-path": true, "definitions": true, "dependencies": true, "$recursiveAnchor": true, "$recursiveRef": true, "contentEncoding": true, "contentMediaType": true, "contentSchema": true, "format": true, "title": true, "description": true, "default": true, "deprecated": true, "readOnly": true, "writeOnly": true, "examples": true, "type": true, "const": true, "enum": true, "multipleOf": true, "maximum": true, "exclusiveMaximum": true, "minimum": true, "exclusiveMinimum": true, "maxLength": true, "minLength": true, "pattern": true, "maxItems": true, "minItems": true, "uniqueItems": true, "maxContains": true, "minContains": true, "maxProperties": true, "minProperties": true, "required": true, "dependentRequired": true, "unevaluatedItems": true, "unevaluatedProperties": true, "prefixItems": true, "items": true, "contains": true, "additionalProperties": true, "properties": true, "patternProperties": true, "dependentSchemas": true, "propertyNames": true, "if": true, "then": true, "else": true, "allOf": true, "anyOf": true, "oneOf": true, "not": true, "$id": true, "$schema": true, "$ref": true, "$anchor": true, "$dynamicRef": true, "$dynamicAnchor": true, "$vocabulary": true, "$comment": true, "$defs": true }, "dynamicProps": false, "dynamicItems": false };
-//# sourceMappingURL=meta-schema.compiled.js.map

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/{schema → language}/value/profile/meta-schema.js

@@ -1,4 +1,4 @@
-import { diagnostic } from '../../diagnostic.js';
+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. */
@@ -17,4 +17,3 @@ export function validateValueSchemaMetaSchema(schema, pointer) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-//# sourceMappingURL=meta-schema.js.map

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/{schema → language}/value/profile/rules.js

@@ -1,16 +1,12 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { diagnostic } from '../../diagnostic.js';
-import { MEMBER_NAME_PATTERN, namedTypeUri } from '../../reference.js';
-import { walkSchema } from '../location/walk.js';
-import { isValueObject as isJsonObject } from '../object.js';
+import { diagnostic } from '../../validation/diagnostic.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { VALUE_SCHEMA_DIALECT } from '../model/schema.js';
 import { isIRegexp } from '../regexp/syntax.js';
-import { VALUE_SCHEMA_DIALECT } from '../schema.js';
+import { walkSchema } from '../syntax/walk.js';
 import { FORBIDDEN_DYNAMIC_KEYWORDS, STANDARD_SCHEMA_KEYWORDS } from './vocabulary.js';
-export function validateSchemaProfile(schema, context, pointer, namedType) {
+export function validateSchemaProfile(schema, context, pointer) {
     const diagnostics = [];
-    if (context === 'named-type' && namedType === undefined) {
-        diagnostics.push(diagnostic('VS_RESOURCE_ID', pointer, 'A named-type schema must have one exact identity in the supplied registry.'));
-    }
     walkSchema(schema, (location) => {
         if (!isJsonObject(location.schema))
             return;
@@ -29,22 +25,13 @@ export function validateSchemaProfile(schema, context, pointer, namedType) {
             }
         }
         if (Object.hasOwn(location.schema, '$id')) {
-            const expected = location.depth === 0 && context === 'named-type' && namedType !== undefined
-                ? namedTypeUri(namedType.origin, namedType.name)
-                : undefined;
-            if (expected === undefined || location.schema.$id !== expected) {
-                diagnostics.push(diagnostic('VS_RESOURCE_ID', `${currentPointer}/$id`, expected === undefined
-                    ? '$id is forbidden outside a named-type embedded root.'
-                    : `Named-type $id must be absent or equal ${expected}.`));
-            }
+            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, currentPointer, diagnostics);
         validateRegexes(location.schema, currentPointer, diagnostics);
     });
-    if (context === 'property-facet') {
-        validateFourKeyFacet(schema, pointer, diagnostics);
-    }
+    void context;
     return diagnostics;
 }
 function validateValueKind(schema, pointer, diagnostics) {
@@ -90,35 +77,6 @@ function validateRegexes(schema, pointer, diagnostics) {
         }
     }
 }
-function validateFourKeyFacet(schema, pointer, diagnostics) {
-    if (!isJsonObject(schema)) {
-        diagnostics.push(diagnostic('VS_PROPERTY_FACET', pointer, 'A property facet is an object schema.'));
-        return;
-    }
-    const keys = Object.keys(schema);
-    const expected = ['type', 'properties', 'required', 'additionalProperties'];
-    if (keys.length !== expected.length || !expected.every((key) => Object.hasOwn(schema, key))) {
-        diagnostics.push(diagnostic('VS_PROPERTY_FACET', pointer, 'A property facet root contains exactly type, properties, required, and additionalProperties.'));
-    }
-    if (schema.type !== 'object' ||
-        schema.additionalProperties !== false ||
-        !isJsonObject(schema.properties) ||
-        !Array.isArray(schema.required)) {
-        diagnostics.push(diagnostic('VS_PROPERTY_FACET', pointer, 'Facet constants are type object and additionalProperties false, with properties and required collections.'));
-        return;
-    }
-    const propertyNames = new Set(Object.keys(schema.properties));
-    for (const name of propertyNames) {
-        if (!MEMBER_NAME_PATTERN.test(name)) {
-            diagnostics.push(diagnostic('VS_PROPERTY_FACET', `${pointer}/properties/${escapeToken(name)}`, `Property name ${name} violates the V1 member-name grammar.`));
-        }
-    }
-    for (const required of schema.required) {
-        if (typeof required === 'string' && !propertyNames.has(required)) {
-            diagnostics.push(diagnostic('VS_PROPERTY_FACET', `${pointer}/required`, `Required member ${required} has no declared property schema.`));
-        }
-    }
-}
 function rejectPrimitiveDuplicates(values, pointer, name, diagnostics) {
     const seen = new Set();
     for (const value of values) {
@@ -149,4 +107,3 @@ function rejectCanonicalDuplicates(values, pointer, name, diagnostics) {
 function escapeToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=rules.js.map

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/{schema → language}/value/profile/validate.js

@@ -1,8 +1,9 @@
-import { GRAPH_NODE_PATH_SCHEMA_ID } from '../extensions/node-path/schema.js';
-import { validateNodePathExtension } from '../extensions/node-path/validate.js';
-import { collectResourceClosure } from '../resources/closure.js';
-import { validateProductiveRecursion } from '../resources/recursion.js';
-import { hasNodeDefinition, indexRegistry, inferNamedTypePlacement, } from '../resources/registry.index.js';
+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';
@@ -11,26 +12,18 @@ export function validateValueSchema(schema, context, registry, pointer = '') {
     diagnostics.push(...validateCanonicalJsonDomain(schema, pointer));
     const indexed = indexRegistry(registry, pointer);
     diagnostics.push(...indexed.diagnostics);
-    const namedType = context === 'named-type' ? inferNamedTypePlacement(schema, indexed.index, pointer) : undefined;
-    const closure = collectResourceClosure(schema, context, indexed.index, pointer, namedType);
+    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 and therefore
-        // must not be reinterpreted under named-type placement rules.
+        // 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;
-        const resourceContext = resource === closure.resources.values().next().value ? context : 'named-type';
-        const resourceIdentity = resource.origin === undefined || resource.name === undefined
-            ? resourceContext === 'named-type'
-                ? namedType
-                : undefined
-            : { origin: resource.origin, name: resource.name };
         diagnostics.push(...validateValueSchemaMetaSchema(resource.schema, resourcePointer));
         diagnostics.push(...validateCanonicalJsonDomain(resource.schema, resourcePointer));
-        diagnostics.push(...validateSchemaProfile(resource.schema, resourceContext, resourcePointer, resourceIdentity));
-        diagnostics.push(...validateNodePathExtension(resource.schema, resourceContext, resourcePointer, (ref) => hasNodeDefinition(indexed.index, ref, resource.ownerOrigin)));
+        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);
@@ -40,8 +33,7 @@ function orderAndDeduplicate(diagnostics) {
     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) => left.pointer.localeCompare(right.pointer) ||
-        left.code.localeCompare(right.code) ||
-        left.message.localeCompare(right.message));
+    return [...unique.values()].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
+        compareUnicode(left.code, right.code) ||
+        compareUnicode(left.message, right.message));
 }
-//# sourceMappingURL=validate.js.map

package/dist/v1/{schema → language}/value/profile/vocabulary.d.ts

@@ -1,3 +1,2 @@
 export declare const STANDARD_SCHEMA_KEYWORDS: Set<string>;
 export declare const FORBIDDEN_DYNAMIC_KEYWORDS: Set<string>;
-//# sourceMappingURL=vocabulary.d.ts.map

package/dist/v1/{schema → language}/value/profile/vocabulary.js

@@ -66,4 +66,3 @@ export const FORBIDDEN_DYNAMIC_KEYWORDS = new Set([
     '$dynamicRef',
     '$vocabulary',
 ]);
-//# sourceMappingURL=vocabulary.js.map

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/{schema/value/resources → language/value/reference}/closure.js

@@ -1,20 +1,16 @@
-import { diagnostic } from '../../diagnostic.js';
-import { namedTypeUri } from '../../reference.js';
-import { GRAPH_NODE_PATH_SCHEMA_ID, hasNodePathAnnotation } from '../extensions/node-path/schema.js';
-import { walkSchema } from '../location/walk.js';
-import { isValueObject as isJsonObject } from '../object.js';
-import { resolveSchemaReference, } from './references.js';
-export function collectResourceClosure(schema, context, index, pointer, namedType) {
+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: namedType === undefined
-            ? `urn:astrale:dsl:v1:embedded:${context}`
-            : namedTypeUri(namedType.origin, namedType.name),
+        key: `urn:astrale:dsl:v1:embedded:${context}`,
         schema,
-        ownerOrigin: namedType?.origin ?? index.registry.current.origin,
-        ...(namedType === undefined ? {} : namedType),
+        ownerOrigin: index.registry.current.origin,
         diagnosticPointer: pointer,
     };
     resources.set(initial.key, initial);
@@ -31,7 +27,7 @@ export function collectResourceClosure(schema, context, index, pointer, namedTyp
                 diagnostics.push(diagnostic('VS_REFERENCE_FORM', refPointer, '$ref must be a string URI-reference.'));
                 return;
             }
-            const result = resolveSchemaReference(location.schema.$ref, resource, index, refPointer, hasNodePathAnnotation(location.schema));
+            const result = resolveAddressReference(location.schema.$ref, resource, index, refPointer, hasNodePathAnnotation(location.schema));
             if (result.diagnostic !== undefined)
                 diagnostics.push(result.diagnostic);
             if (result.resolved === undefined)
@@ -40,10 +36,10 @@ export function collectResourceClosure(schema, context, index, pointer, namedTyp
             const target = result.resolved.resource;
             if (resources.has(target.key))
                 return;
-            const diagnosticPointer = target.key === GRAPH_NODE_PATH_SCHEMA_ID
-                ? `${pointer}/registry/graphNodePath`
-                : `${pointer}/registry/${escapeToken(target.origin ?? '')}/types/${escapeToken(target.name ?? '')}`;
-            const registered = { ...target, diagnosticPointer };
+            const registered = {
+                ...target,
+                diagnosticPointer: `${pointer}/registry/graphNodePath`,
+            };
             resources.set(target.key, registered);
             queue.push(registered);
         });
@@ -53,7 +49,3 @@ export function collectResourceClosure(schema, context, index, pointer, namedTyp
 export function locationKey(resourceKey, pointer) {
     return `${resourceKey}\u0000${pointer}`;
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
-//# sourceMappingURL=closure.js.map

package/dist/v1/{schema/value/resources → language/value/reference}/recursion.d.ts

@@ -1,6 +1,5 @@
-import type { DomainDiagnostic } from '../../diagnostic.js';
-import type { ResolvedSchemaReference, SchemaResource } from './references.js';
+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, ResolvedSchemaReference>): readonly DomainDiagnostic[];
-//# sourceMappingURL=recursion.d.ts.map
+export declare function validateProductiveRecursion(resources: ReadonlyMap<string, SchemaResource>, resolutions: ReadonlyMap<string, ResolvedAddressReference>): readonly Diagnostic[];

package/dist/v1/{schema/value/resources → language/value/reference}/recursion.js

@@ -1,8 +1,8 @@
-import { diagnostic } from '../../diagnostic.js';
-import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../location/keywords.js';
-import { appendPointer } from '../location/pointer.js';
-import { isJsonSchema, walkSchema } from '../location/walk.js';
-import { isValueObject as isJsonObject } from '../object.js';
+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',
@@ -93,4 +93,3 @@ function findCycle(node, adjacency, visiting, visited) {
     visited.add(node);
     return undefined;
 }
-//# sourceMappingURL=recursion.js.map

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/{schema/value → language/value/reference}/registry.d.ts

@@ -1,11 +1,14 @@
-import type { DefinitionRef, DomainDependency, Revision } from '../reference.js';
-import type { JsonSchema } from './schema.js';
+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?: Revision;
-    readonly dependencies: readonly DomainDependency[];
-    readonly types: Readonly<Record<string, JsonSchema>>;
-    readonly nodeDefinitions: readonly DefinitionRef[];
+    readonly revision?: `sha256:${string}`;
+    readonly dependencies: readonly ValueSchemaDependency[];
+    readonly nodeDefinitions: readonly ClassRef[];
 }
 /**
  * The exact closure visible while validating one DomainSchema.
@@ -19,4 +22,3 @@ export interface ValueSchemaRegistry {
     readonly transitiveDependencies: readonly ValueSchemaDomainRegistry[];
     readonly graphNodePath: JsonSchema;
 }
-//# sourceMappingURL=registry.d.ts.map

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/{schema/value/resources → language/value/reference}/registry.index.js

@@ -1,8 +1,9 @@
-import { diagnostic } from '../../diagnostic.js';
-import { schemaRefIndex, DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTERN, MEMBER_NAME_PATTERN, namedTypeUri, } from '../../reference.js';
-import { GRAPH_NODE_PATH_SCHEMA_ID } from '../extensions/node-path/schema.js';
-import { isValueObject as isJsonObject } from '../object.js';
-import { JSON_SCHEMA_DIALECT } from '../schema.js';
+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();
@@ -38,38 +39,6 @@ export function indexRegistry(registry, pointer) {
     validateGraphNodePathResource(registry.graphNodePath, `${pointer}/registry/graphNodePath`, diagnostics);
     return { index: { registry, domains, dependenciesByOwner }, diagnostics };
 }
-export function inferNamedTypePlacement(schema, index, pointer = '') {
-    const pointerMatch = /(?:^|\/)types\/([^/]+)$/u.exec(pointer);
-    if (pointerMatch !== null) {
-        const encodedName = pointerMatch[1] ?? '';
-        const name = encodedName.replaceAll('~1', '/').replaceAll('~0', '~');
-        if (index.registry.current.types[name] === schema) {
-            return { origin: index.registry.current.origin, name };
-        }
-    }
-    const matches = [];
-    for (const domain of index.domains.values()) {
-        for (const [name, registered] of Object.entries(domain.types)) {
-            if (registered === schema)
-                matches.push({ origin: domain.origin, name });
-        }
-    }
-    if (matches.length === 1)
-        return matches[0];
-    if (isJsonObject(schema) && typeof schema.$id === 'string') {
-        for (const domain of index.domains.values()) {
-            for (const name of Object.keys(domain.types)) {
-                if (schema.$id === namedTypeUri(domain.origin, name)) {
-                    return { origin: domain.origin, name };
-                }
-            }
-        }
-    }
-    return undefined;
-}
-export function getNamedType(index, origin, name) {
-    return index.domains.get(origin)?.types[name];
-}
 export function isOriginVisibleFrom(index, ownerOrigin, targetOrigin) {
     return (ownerOrigin === targetOrigin ||
         index.dependenciesByOwner.get(ownerOrigin)?.has(targetOrigin) === true);
@@ -79,8 +48,7 @@ export function hasNodeDefinition(index, ref, ownerOrigin) {
         return false;
     return (index.domains
         .get(ref.origin)
-        ?.nodeDefinitions.some((candidate) => schemaRefIndex(candidate) === schemaRefIndex(ref)) ===
-        true);
+        ?.nodeDefinitions.some((candidate) => definitionRefIndex(candidate) === definitionRefIndex(ref)) === true);
 }
 function validateDomainRegistry(domain, pointer, revisionRequired, diagnostics) {
     if (!DOMAIN_ORIGIN_PATTERN.test(domain.origin)) {
@@ -90,11 +58,6 @@ function validateDomainRegistry(domain, pointer, revisionRequired, diagnostics)
         (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 name of Object.keys(domain.types)) {
-        if (!MEMBER_NAME_PATTERN.test(name)) {
-            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/types`, `Named type ${name} does not satisfy the V1 member-name grammar.`));
-        }
-    }
     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.'));
@@ -111,4 +74,3 @@ function validateGraphNodePathResource(schema, pointer, diagnostics) {
         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));
     }
 }
-//# sourceMappingURL=registry.index.js.map

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

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

package/dist/v1/{schema → language}/value/regexp/ast.d.ts

@@ -19,4 +19,3 @@ export type Atom = {
 };
 /** Parse the complete RFC 9485 I-Regexp grammar into the one compiler AST. */
 export declare function parseIRegexp(source: string): Expression | undefined;
-//# sourceMappingURL=ast.d.ts.map

package/dist/v1/{schema → language}/value/regexp/ast.js

@@ -324,4 +324,3 @@ function isUnicodeScalarString(value) {
     }
     return true;
 }
-//# sourceMappingURL=ast.js.map