@astrale-os/kernel-dsl 0.2.0-beta.3 → 0.2.0-beta.31

package/dist/v1/schema/{dependency.meaning.js → compatibility/meaning.js}

@@ -1,13 +1,15 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { Key, PropertyKey, Ref } from '../addressing/index.js';
-import { digestDomainSchemaBytes } from './canonical/domain.digest.js';
-import { DomainSchemaError, diagnostic } from './diagnostic.js';
-import { resolveDomainSchema } from './domain.resolve.js';
-import { revisionOfDomainSchema } from './domain.revision.js';
-import { compareSchemaRefs, compareUnicode, schemaRefIndex } from './reference.js';
-import { collectCallableRefs, collectClassRefs, collectInterfaceRefs, collectPolicyDeclarationRefs, collectValueSchemaRefs, } from './resolution/origins.js';
-import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from './value/location/keywords.js';
-import { isValueObject as isJsonObject } from './value/object.js';
+import { Key, MethodKey, PropertyKey } from '../../addressing/index.js';
+import { compareDefinitionRefs, compareUnicode, definitionRefIndex, } from '../../addressing/ordering.js';
+import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
+import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../../language/value/syntax/keywords.js';
+import { digestDomainSchemaBytes } from '../canonical/domain.digest.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { knownDomainClosure, lookupForDomainClosure } from '../resolution/closure.js';
+import { resolve } from '../resolution/domain.js';
+import { collectCallableRefs, collectClassRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, } from '../resolution/origins.js';
+import { validateDomainSchemaSemantics } from '../validation/domain.js';
 const VALUE_SCHEMA_ANNOTATIONS = new Set([
     '$comment',
     'contentEncoding',
@@ -28,16 +30,17 @@ const VALUE_SCHEMA_ANNOTATIONS = new Set([
  * lifecycle-compatibility decision.
  */
 export function compareDependencyMeaning(dependent, target) {
-    const resolution = resolveDomainSchema(dependent);
-    const source = resolution.$.closure.find((candidate) => candidate.origin === target.origin);
+    resolve(dependent);
+    const closure = knownDomainClosure(dependent) ?? [];
+    const source = closure.find((candidate) => candidate.schema.origin === target.origin)?.schema;
     if (source === undefined) {
-        throw new DomainSchemaError([
+        throw new SchemaError([
             diagnostic('DM_DEPENDENCY_NOT_RETAINED', '/target/origin', `Domain ${dependent.origin} was not admitted with a dependency at ${target.origin}.`),
         ]);
     }
     const schemas = new Map([
         [dependent.origin, dependent],
-        ...resolution.$.closure.map((candidate) => [candidate.origin, candidate]),
+        ...closure.map(({ schema: candidate }) => [candidate.origin, candidate]),
     ]);
     const sourceMeanings = collectDependencyMeanings(dependent, source.origin, schemas);
     return compareSourceMeanings(source, target, sourceMeanings);
@@ -45,19 +48,20 @@ export function compareDependencyMeaning(dependent, target) {
 /** Compare one explicit non-empty source member surface and its reachable V1 meaning. */
 export function compareMemberMeaning(source, target, roots) {
     if (source.origin !== target.origin) {
-        throw new DomainSchemaError([
+        throw new SchemaError([
             diagnostic('DM_MEMBER_ORIGIN_MISMATCH', '/target/origin', `Member comparison target ${target.origin} does not match source ${source.origin}.`),
         ]);
     }
     if (!Array.isArray(roots) || roots.length === 0 || new Set(roots).size !== roots.length) {
-        throw new DomainSchemaError([
+        throw new SchemaError([
             diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', 'Member comparison roots must be one non-empty duplicate-free Key set.'),
         ]);
     }
-    const resolution = resolveDomainSchema(source);
+    resolve(source);
+    const closure = knownDomainClosure(source) ?? [];
     const schemas = new Map([
         [source.origin, source],
-        ...resolution.$.closure.map((candidate) => [candidate.origin, candidate]),
+        ...closure.map(({ schema: candidate }) => [candidate.origin, candidate]),
     ]);
     const coordinates = roots.map((key, index) => coordinateForKey(source, key, index));
     const sourceMeanings = collectReachableMeanings(coordinates, source.origin, schemas);
@@ -65,7 +69,7 @@ export function compareMemberMeaning(source, target, roots) {
 }
 function compareSourceMeanings(source, target, sourceMeanings) {
     // Prove the candidate still has an exact accepted semantic context before comparing it.
-    resolveDomainSchema(target);
+    resolve(target);
     const footprint = Object.freeze([...sourceMeanings.keys()].sort(compareUnicode));
     const changes = [];
     const comparisonCoordinates = [];
@@ -129,7 +133,7 @@ function collectReachableMeanings(roots, selectedOrigin, schemas) {
         const owner = schemas.get(Key.origin(coordinate.key));
         const meaning = owner === undefined ? undefined : meaningForCoordinate(owner, coordinate);
         if (owner === undefined || meaning === undefined) {
-            throw new DomainSchemaError([
+            throw new SchemaError([
                 diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', `Member comparison root ${coordinate.key} does not exist in its source context.`, coordinate.key),
             ]);
         }
@@ -138,20 +142,20 @@ function collectReachableMeanings(roots, selectedOrigin, schemas) {
     }
     for (let index = 0; index < pending.length; index += 1) {
         const ref = pending[index];
-        const refIndex = schemaRefIndex(ref);
+        const refIndex = definitionRefIndex(ref);
         if (visited.has(refIndex))
             continue;
         visited.add(refIndex);
         const owner = schemas.get(ref.origin);
         if (owner === undefined) {
-            throw new DomainSchemaError([
-                diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Retained acceptance context cannot resolve ${Key.fromSchema(ref)}.`, String(Key.fromSchema(ref))),
+            throw new SchemaError([
+                diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Retained acceptance context cannot resolve ${keyForDefinitionRef(ref)}.`, keyForDefinitionRef(ref)),
             ]);
         }
         const primary = memberCoordinate(ref);
         const primaryMeaning = meaningForCoordinate(owner, primary);
         if (primaryMeaning === undefined) {
-            throw new DomainSchemaError([
+            throw new SchemaError([
                 diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Retained acceptance context has no meaning for ${primary.key}.`, primary.key),
             ]);
         }
@@ -159,7 +163,7 @@ function collectReachableMeanings(roots, selectedOrigin, schemas) {
         collectMemberSemanticRefs(owner, ref, (candidate) => pending.push(requireMemberRef(candidate)));
         if (!isDefinitionRef(ref))
             continue;
-        const analysis = resolveDomainSchema(owner).$.refs.effective(ref);
+        const analysis = effectiveDefinition(owner, ref);
         if (analysis === undefined)
             continue;
         collectEffectiveMeanings(analysis, selectedOrigin, meanings, (candidate) => pending.push(requireMemberRef(candidate)));
@@ -167,16 +171,16 @@ function collectReachableMeanings(roots, selectedOrigin, schemas) {
     return meanings;
 }
 function collectCoordinateSemanticRefs(owner, coordinate, add) {
-    const analysis = resolveDomainSchema(owner).$.refs.effective(coordinate.owner);
+    const analysis = effectiveDefinition(owner, coordinate.owner);
     if (analysis === undefined)
         return;
     if (coordinate.kind === 'property') {
         const field = analysis.properties.get(coordinate.key);
         if (field !== undefined)
-            collectValueSchemaRefs(semanticValueSchema(field.schema), add);
+            collectValueDefinitionRefs(semanticValueSchema(field.schema), add);
         return;
     }
-    const method = [...analysis.methods.values()].find((candidate) => methodKey(candidate.owner, candidate.name) === coordinate.key);
+    const method = [...analysis.methods.values()].find((candidate) => MethodKey.of(candidate.owner, candidate.name) === coordinate.key);
     if (method !== undefined)
         collectCallableRefs(semanticMethod(method.declaration), add);
 }
@@ -185,7 +189,7 @@ function collectEffectiveMeanings(analysis, dependencyOrigin, meanings, add) {
         const coordinate = propertyCoordinate(field.owner, field.name);
         retainMeaning(meanings, dependencyOrigin, coordinate, propertyMeaning(field));
         add(field.owner);
-        collectValueSchemaRefs(semanticValueSchema(field.schema), add);
+        collectValueDefinitionRefs(semanticValueSchema(field.schema), add);
     }
     for (const method of analysis.methods.values()) {
         const coordinate = methodCoordinate(method.owner, method.name);
@@ -200,7 +204,7 @@ function retainMeaning(meanings, dependencyOrigin, coordinate, meaning) {
     const fingerprint = fingerprintMeaning(meaning);
     const previous = meanings.get(coordinate.key);
     if (previous !== undefined && previous.fingerprint !== fingerprint) {
-        throw new DomainSchemaError([
+        throw new SchemaError([
             diagnostic('DM_MEANING_INCONSISTENT', '', `Semantic coordinate ${coordinate.key} produced inconsistent effective meaning.`, coordinate.key),
         ]);
     }
@@ -210,14 +214,8 @@ function collectSchemaSemanticRefs(owner) {
     const refs = new Map();
     const add = (ref) => {
         const member = requireMemberRef(ref);
-        refs.set(schemaRefIndex(member), member);
+        refs.set(definitionRefIndex(member), member);
     };
-    for (const value of Object.values(owner.types)) {
-        collectValueSchemaRefs(semanticValueSchema(value), add);
-    }
-    for (const declaration of Object.values(owner.interfaces)) {
-        collectInterfaceRefs(semanticDefinition(declaration), add);
-    }
     for (const declaration of Object.values(owner.classes)) {
         collectClassRefs(semanticDefinition(declaration), add);
     }
@@ -225,7 +223,7 @@ function collectSchemaSemanticRefs(owner) {
         collectCallableRefs(semanticFunction(declaration), add);
     }
     for (const declaration of Object.values(owner.policies)) {
-        collectPolicyDeclarationRefs(semanticPolicy(declaration), add);
+        collectPolicyDefinitionRefs(semanticPolicy(declaration), add);
     }
     for (const declaration of Object.values(owner.views)) {
         if (declaration.target.kind === 'definition')
@@ -240,23 +238,10 @@ function collectSchemaSemanticRefs(owner) {
         if (edge.target.kind !== 'domain')
             add(edge.target);
     }
-    return [...refs.values()].sort(compareSchemaRefs);
+    return [...refs.values()].sort(compareDefinitionRefs);
 }
 function collectMemberSemanticRefs(owner, ref, add) {
     switch (ref.kind) {
-        case 'type': {
-            const declaration = owner.types[ref.name];
-            if (declaration !== undefined)
-                collectValueSchemaRefs(semanticValueSchema(declaration), add);
-            return;
-        }
-        case 'interface': {
-            const declaration = owner.interfaces[ref.name];
-            if (declaration !== undefined) {
-                collectInterfaceRefs(semanticDefinition(declaration), add);
-            }
-            return;
-        }
         case 'class': {
             const declaration = owner.classes[ref.name];
             if (declaration !== undefined) {
@@ -273,7 +258,7 @@ function collectMemberSemanticRefs(owner, ref, add) {
         case 'policy': {
             const declaration = owner.policies[ref.name];
             if (declaration !== undefined) {
-                collectPolicyDeclarationRefs(semanticPolicy(declaration), add);
+                collectPolicyDefinitionRefs(semanticPolicy(declaration), add);
             }
             return;
         }
@@ -303,27 +288,20 @@ function meaningForCoordinate(owner, coordinate) {
         return undefined;
     if (coordinate.kind === 'member')
         return memberMeaning(owner, coordinate.ref);
-    const analysis = resolveDomainSchema(owner).$.refs.effective(coordinate.owner);
+    const analysis = effectiveDefinition(owner, coordinate.owner);
     if (analysis === undefined)
         return undefined;
     if (coordinate.kind === 'property') {
         const field = analysis.properties.get(coordinate.key);
         return field === undefined ? undefined : propertyMeaning(field);
     }
-    const method = [...analysis.methods.values()].find((candidate) => methodKey(candidate.owner, candidate.name) === coordinate.key);
+    const method = [...analysis.methods.values()].find((candidate) => MethodKey.of(candidate.owner, candidate.name) === coordinate.key);
     return method === undefined ? undefined : methodMeaning(method);
 }
 function memberMeaning(owner, ref) {
     if (ref.origin !== owner.origin)
         return undefined;
     switch (ref.kind) {
-        case 'type': {
-            const declaration = owner.types[ref.name];
-            return declaration === undefined
-                ? undefined
-                : { kind: ref.kind, schema: semanticValueSchema(declaration) };
-        }
-        case 'interface':
         case 'class':
             return definitionMeaning(owner, ref);
         case 'function': {
@@ -357,44 +335,49 @@ function memberMeaning(owner, ref) {
     }
 }
 function definitionMeaning(owner, ref) {
-    const resolution = resolveDomainSchema(owner);
-    const resolved = resolution.$.refs.definition(ref);
-    const effective = resolution.$.refs.effective(ref);
-    if (resolved === undefined || effective === undefined || resolved.owner !== owner)
+    const declaration = owner.classes[ref.name];
+    const effective = effectiveDefinition(owner, ref);
+    if (declaration === undefined || effective === undefined || ref.origin !== owner.origin)
         return undefined;
     return {
         kind: ref.kind,
-        declaration: semanticDefinition(resolved.declaration),
+        declaration: semanticDefinition(declaration),
         effective: {
             properties: [...effective.properties.keys()].sort(compareUnicode),
             methods: [...effective.methods.values()]
-                .map((method) => methodKey(method.owner, method.name))
+                .map((method) => MethodKey.of(method.owner, method.name))
                 .sort(compareUnicode),
             ...(effective.data === undefined
                 ? {}
                 : {
                     data: {
-                        owner: Key.fromSchema(effective.data.owner),
+                        owner: keyForDefinitionRef(effective.data.owner),
                         declaration: effective.data.declaration,
                     },
                 }),
         },
     };
 }
+function effectiveDefinition(owner, ref) {
+    const validation = validateDomainSchemaSemantics(owner, lookupForDomainClosure(owner));
+    if (validation.diagnostics.length > 0)
+        return undefined;
+    return validation.analysis.definitions.get(definitionRefIndex(ref));
+}
 function propertyMeaning(field) {
     return {
         kind: 'property',
-        owner: Key.fromSchema(field.owner),
+        owner: keyForDefinitionRef(field.owner),
         name: field.name,
         schema: semanticValueSchema(field.schema),
         required: field.required,
-        visibility: field.visibility,
+        ...(field.state === undefined ? {} : { state: field.state }),
     };
 }
 function methodMeaning(method) {
     return {
         kind: 'method',
-        owner: Key.fromSchema(method.owner),
+        owner: keyForDefinitionRef(method.owner),
         name: method.name,
         declaration: semanticMethod(method.declaration),
     };
@@ -403,7 +386,13 @@ function semanticDefinition(declaration) {
     const { description: _description, ...rest } = declaration;
     const semantic = {
         ...rest,
-        properties: semanticValueSchema(declaration.properties),
+        properties: Object.fromEntries(Object.entries(declaration.properties).map(([name, property]) => [
+            name,
+            {
+                ...property,
+                schema: semanticValueSchema(property.schema),
+            },
+        ])),
     };
     if ('methods' in declaration) {
         semantic.methods = Object.fromEntries(Object.entries(declaration.methods).map(([name, method]) => [name, semanticMethod(method)]));
@@ -419,11 +408,11 @@ function semanticFunction(declaration) {
     };
 }
 function semanticMethod(declaration) {
-    const semantic = semanticFunction(declaration);
+    const { description: _description, ...rest } = declaration;
     return {
-        ...semantic,
-        static: declaration.static,
-        inheritance: declaration.inheritance,
+        ...rest,
+        input: semanticValueSchema(declaration.input),
+        output: semanticOutput(declaration.output),
     };
 }
 function semanticOutput(output) {
@@ -480,50 +469,48 @@ function coordinateForKey(source, input, index) {
     if (Key.origin(key) !== source.origin) {
         return invalidMemberRoot(key, index, `belongs to ${Key.origin(key)}, not source ${source.origin}`);
     }
-    const ref = Key.ref(key);
+    const reference = keyReference(key);
     let coordinate;
-    if (Ref.isProperty(ref) || Ref.isMethod(ref)) {
-        const owner = definitionRefFor(source, Ref.namespace(ref), Ref.member(ref));
-        const name = Ref.child(ref);
-        if (owner === undefined || name === undefined) {
+    if ((reference.member === 'property' || reference.member === 'method') &&
+        reference.ownerKind === 'class' &&
+        reference.ownerName !== undefined) {
+        const owner = definitionRefFor(source, reference.ownerKind, reference.ownerName);
+        if (owner === undefined) {
             return invalidMemberRoot(key, index, 'has no exact owning Definition');
         }
-        coordinate = Ref.isProperty(ref)
-            ? propertyCoordinate(owner, name)
-            : methodCoordinate(owner, name);
+        coordinate =
+            reference.member === 'property'
+                ? propertyCoordinate(owner, reference.name)
+                : methodCoordinate(owner, reference.name);
     }
-    else if (Ref.isDefinition(ref)) {
-        const member = memberRefFor(source, ref);
+    else if (reference.kind !== 'core') {
+        const member = memberRefFor(source, {
+            origin: source.origin,
+            kind: reference.kind,
+            name: reference.name,
+        });
         if (member === undefined)
             return invalidMemberRoot(key, index, 'does not exist in the source');
         coordinate = memberCoordinate(member);
     }
-    else if (ref.startsWith('core.')) {
+    else {
         coordinate = memberCoordinate({
             origin: source.origin,
             kind: 'core',
-            name: Ref.member(ref),
+            name: reference.name,
         });
     }
-    else {
-        return invalidMemberRoot(key, index, 'is not an independently comparable V1 member');
-    }
     if (meaningForCoordinate(source, coordinate) === undefined) {
         return invalidMemberRoot(key, index, 'does not exist in the source');
     }
     return coordinate;
 }
 function memberRefFor(source, ref) {
-    const namespace = Ref.namespace(ref);
-    const name = Ref.member(ref);
-    const owner = definitionRefFor(source, namespace, name);
+    const name = ref.name;
+    const owner = definitionRefFor(source, ref.kind, name);
     if (owner !== undefined)
         return owner;
-    switch (namespace) {
-        case 'type':
-            return source.types[name] === undefined
-                ? undefined
-                : { origin: source.origin, kind: 'type', name };
+    switch (ref.kind) {
         case 'function':
             return source.functions[name] === undefined
                 ? undefined
@@ -546,29 +533,50 @@ function definitionRefFor(source, namespace, name) {
             ? undefined
             : { origin: source.origin, kind: 'class', name };
     }
-    if (namespace === 'interface') {
-        return source.interfaces[name] === undefined
-            ? undefined
-            : { origin: source.origin, kind: 'interface', name };
-    }
     return undefined;
 }
 function invalidMemberRoot(key, index, reason) {
-    throw new DomainSchemaError([
+    throw new SchemaError([
         diagnostic('DM_MEMBER_ROOT_INVALID', `/roots/${index}`, `Member comparison root ${JSON.stringify(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
     ]);
 }
 function memberCoordinate(ref) {
-    return Object.freeze({ kind: 'member', key: Key.fromSchema(ref), ref });
+    return Object.freeze({ kind: 'member', key: keyForDefinitionRef(ref), ref });
 }
 function propertyCoordinate(owner, name) {
     return Object.freeze({ kind: 'property', key: PropertyKey.of(owner, name), owner, name });
 }
 function methodCoordinate(owner, name) {
-    return Object.freeze({ kind: 'method', key: methodKey(owner, name), owner, name });
-}
-function methodKey(owner, name) {
-    return Key.of(owner.origin, Ref.method(Ref.fromSchema(owner), name));
+    return Object.freeze({ kind: 'method', key: MethodKey.of(owner, name), owner, name });
+}
+function keyForDefinitionRef(ref) {
+    return ref.kind === 'core'
+        ? Key.of(ref)
+        : Key.of(ref);
+}
+function keyReference(key) {
+    const semantic = key.slice(key.indexOf(':') + 1);
+    const parts = semantic.split('.');
+    if (parts[0] === 'core' && parts.length === 2) {
+        return { kind: 'core', name: parts[1] };
+    }
+    if (parts.length === 2) {
+        return { kind: parts[0], name: parts[1] };
+    }
+    if (parts.length === 4 &&
+        parts[0] === 'class' &&
+        (parts[2] === 'property' || parts[2] === 'method')) {
+        return {
+            kind: 'class',
+            name: parts[3],
+            member: parts[2],
+            ownerKind: 'class',
+            ownerName: parts[1],
+        };
+    }
+    throw new SchemaError([
+        diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', `Key ${key} has no supported V1 shape.`, key),
+    ]);
 }
 function incidentCoreEdges(owner, name) {
     return owner.core.edges.filter((edge) => (edge.source.kind === 'core' && edge.source.name === name) ||
@@ -578,31 +586,20 @@ function fingerprintMeaning(value) {
     return digestDomainSchemaBytes(json.encode(value));
 }
 function isDefinitionRef(ref) {
-    switch (ref.kind) {
-        case 'interface':
-        case 'class':
-            return true;
-        default:
-            return false;
-    }
+    return ref.kind === 'class';
 }
 function requireMemberRef(ref) {
     switch (ref.kind) {
-        case 'type':
-        case 'interface':
         case 'class':
         case 'function':
         case 'policy':
         case 'view':
+            return ref;
         case 'core':
             return ref;
-        default:
-            throw new DomainSchemaError([
-                diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Semantic reference kind ${JSON.stringify(ref.kind)} is outside V1.`),
-            ]);
     }
+    return ref;
 }
 function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);
 }
-//# sourceMappingURL=dependency.meaning.js.map

package/dist/v1/schema/{domain.lookup.d.ts → dependency/lookup.d.ts}

@@ -1,6 +1,6 @@
-import type { Key } from '../addressing/index.js';
-import type { DomainSchema } from './domain.ir.js';
-import type { Revision } from './reference.js';
+import type { Key } from '../../addressing/index.js';
+import type { Revision } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
 /** Exact revision-addressed lookup used while accepting a dependency closure. */
 export interface DomainSchemaLookup {
     get(origin: Key.Origin, revision: Revision): DomainSchema | undefined;
@@ -16,4 +16,3 @@ export declare class MemoryDomainSchemaLookup implements DomainSchemaLookup {
     set(entry: DomainSchemaEntry): this;
 }
 export declare function emptyDomainSchemaLookup(): DomainSchemaLookup;
-//# sourceMappingURL=domain.lookup.d.ts.map

package/dist/v1/schema/{domain.lookup.js → dependency/lookup.js}

@@ -1,4 +1,4 @@
-import { revisionOfDomainSchema } from './domain.revision.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
 export class MemoryDomainSchemaLookup {
     #entries = new Map();
     constructor(entries = []) {
@@ -29,4 +29,3 @@ export function emptyDomainSchemaLookup() {
 function lookupKey(origin, revision) {
     return `${origin}\u0000${revision}`;
 }
-//# sourceMappingURL=domain.lookup.js.map

package/dist/v1/schema/diagnostic.d.ts

@@ -1,12 +1,12 @@
-export interface DomainDiagnostic {
-    readonly code: string;
+export type SchemaDiagnosticCode = 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'DV_VIEW_TARGET' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
+export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode = SchemaDiagnosticCode> {
+    readonly code: Code;
     readonly pointer: string;
     readonly message: string;
     readonly ref?: string;
 }
-export declare class DomainSchemaError extends Error {
-    readonly diagnostics: readonly DomainDiagnostic[];
-    constructor(diagnostics: readonly DomainDiagnostic[]);
+export declare function diagnostic<const Code extends SchemaDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): SchemaDiagnostic<Code>;
+export declare class SchemaError extends Error {
+    readonly diagnostics: readonly SchemaDiagnostic[];
+    constructor(diagnostics: readonly SchemaDiagnostic[]);
 }
-export declare function diagnostic(code: string, pointer: string, message: string, ref?: string): DomainDiagnostic;
-//# sourceMappingURL=diagnostic.d.ts.map

package/dist/v1/schema/diagnostic.js

@@ -1,21 +1,21 @@
-export class DomainSchemaError extends Error {
+import { compareUnicode } from '../addressing/ordering.js';
+export function diagnostic(code, pointer, message, ref) {
+    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
+}
+export class SchemaError extends Error {
     diagnostics;
     constructor(diagnostics) {
         const ordered = [...diagnostics].sort(compareDiagnostic);
         super(ordered.map(formatDiagnostic).join('\n'));
-        this.name = 'DomainSchemaError';
+        this.name = 'SchemaError';
         this.diagnostics = Object.freeze(ordered);
     }
 }
-export function diagnostic(code, pointer, message, ref) {
-    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
-}
 function compareDiagnostic(left, right) {
-    return (left.pointer.localeCompare(right.pointer) ||
-        left.code.localeCompare(right.code) ||
-        left.message.localeCompare(right.message));
+    return (compareUnicode(left.pointer, right.pointer) ||
+        compareUnicode(left.code, right.code) ||
+        compareUnicode(left.message, right.message));
 }
 function formatDiagnostic(value) {
     return `${value.pointer || '/'} [${value.code}] ${value.message}`;
 }
-//# sourceMappingURL=diagnostic.js.map