@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.11

package/dist/v1/schema/validation/class.js

@@ -0,0 +1,208 @@
+import { Key } from '../../addressing/key.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { classifyOrdering } from '../../language/value/ordering.js';
+import { diagnostic } from '../diagnostic.js';
+import { createValueSchemaRegistry } from '../resolution/value.registry.js';
+const formatDefinitionRef = Key.of;
+/** Validate the semantic contracts owned by Class declarations. */
+export function validateDefinitions(environment, analysis) {
+    const diagnostics = [...analysis.diagnostics];
+    const schema = environment.candidate;
+    for (const [name, declaration] of Object.entries(schema.classes)) {
+        const ref = localRef(schema.origin, name);
+        const pointer = `/classes/${escapePointer(name)}`;
+        if (!sameRef(declaration.ref, ref)) {
+            diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Class ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(declaration.ref)));
+        }
+        validateFacet(environment, declaration, pointer, diagnostics);
+        validateParents(environment, ref, declaration.kind, declaration.extends, diagnostics);
+        if (declaration.kind === 'edge') {
+            validateEdgeContract(environment, ref, declaration, diagnostics);
+        }
+    }
+    validateEdgeClassComposition(environment, diagnostics);
+    return Object.freeze(diagnostics);
+}
+function validateFacet(environment, declaration, pointer, diagnostics) {
+    const valueRegistry = createValueSchemaRegistry(environment);
+    for (const [name, property] of Object.entries(declaration.properties)) {
+        if (property.auto === undefined)
+            continue;
+        const propertyPointer = `${pointer}/properties/${escapePointer(name)}/auto`;
+        if (property.required && !property.auto.on.includes('create')) {
+            diagnostics.push(diagnostic('DV_PROPERTY_AUTO', `${propertyPointer}/on`, 'A required auto Property must run on create.'));
+        }
+        if (property.auto.set === 'instant' &&
+            classifyOrdering(property.schema, valueRegistry) !== 'instant') {
+            diagnostics.push(diagnostic('DV_PROPERTY_AUTO', `${propertyPointer}/set`, 'The instant setter requires an Instant value schema.'));
+        }
+    }
+    if (declaration.kind !== 'node')
+        return;
+    for (const [name, method] of Object.entries(declaration.methods)) {
+        const methodPointer = `${pointer}/methods/${escapePointer(name)}`;
+        if (method.inheritance === 'abstract' && method.policy !== undefined) {
+            diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/policy`, 'Abstract Methods cannot have a Policy.'));
+        }
+    }
+}
+function validateParents(environment, owner, ownerKind, parents, diagnostics) {
+    for (const [index, parent] of parents.entries()) {
+        const target = environment.resolve(parent);
+        const pointer = `/classes/${escapePointer(owner.name)}/extends/${index}`;
+        if (target === undefined) {
+            diagnostics.push(diagnostic('DV_REF_RESOLVES', pointer, `Parent ${formatDefinitionRef(parent)} does not resolve exactly.`, formatDefinitionRef(parent)));
+            continue;
+        }
+        if (target.ref.kind !== 'class' || target.declaration.kind !== ownerKind) {
+            diagnostics.push(diagnostic('DV_CLASS_KIND', pointer, `${formatDefinitionRef(owner)} cannot extend different-kind Class ${formatDefinitionRef(parent)}.`, formatDefinitionRef(parent)));
+        }
+    }
+}
+function validateEdgeContract(environment, owner, declaration, diagnostics) {
+    const endpoints = declaration.orientation === 'directed'
+        ? [declaration.endpoints.source, declaration.endpoints.target]
+        : declaration.endpoints;
+    if (endpoints[0].role === endpoints[1].role) {
+        diagnostics.push(diagnostic('DV_EDGE_ROLE', '', `${formatDefinitionRef(owner)} has equal endpoint roles.`));
+    }
+    validateEndpoint(environment, owner, endpoints[0], declaration.orientation === 'directed' ? 'source' : 'first endpoint', diagnostics);
+    validateEndpoint(environment, owner, endpoints[1], declaration.orientation === 'directed' ? 'target' : 'second endpoint', diagnostics);
+    if (declaration.orientation === 'undirected') {
+        if (!sameIncidentEndpointContract(declaration.endpoints[0], declaration.endpoints[1]) &&
+            undirectedEndpointsOverlap(environment, declaration.endpoints)) {
+            diagnostics.push(diagnostic('DV_EDGE_UNDIRECTED', '', `${formatDefinitionRef(owner)} has unequal undirected endpoint contracts whose accepted Node families overlap.`));
+        }
+        if (declaration.constraints.acyclic === true) {
+            diagnostics.push(diagnostic('DV_EDGE_CONSTRAINT', '', 'acyclic is valid only for directed Edge contracts.'));
+        }
+    }
+}
+function validateEndpoint(environment, owner, endpoint, side, diagnostics) {
+    const seen = new Set();
+    for (const ref of endpoint.accepts) {
+        const key = definitionRefIndex(ref);
+        if (seen.has(key)) {
+            diagnostics.push(diagnostic('DV_EDGE_ACCEPTS', '', `${formatDefinitionRef(owner)} ${side} repeats ${formatDefinitionRef(ref)}.`));
+        }
+        seen.add(key);
+        const resolved = environment.resolve(ref);
+        if (resolved === undefined ||
+            resolved.ref.kind !== 'class' ||
+            resolved.declaration.kind !== 'node') {
+            diagnostics.push(diagnostic('DV_EDGE_ACCEPTS', '', `${formatDefinitionRef(owner)} ${side} ref ${formatDefinitionRef(ref)} does not resolve to a Node Class.`));
+        }
+    }
+}
+/** Edge inheritance is refinement, not a second interface composition mechanism. */
+function validateEdgeClassComposition(environment, diagnostics) {
+    for (const resolved of environment.definitions.values()) {
+        if (resolved.ref.kind !== 'class' || resolved.declaration.kind !== 'edge')
+            continue;
+        const child = resolved.declaration;
+        for (const parentRef of child.extends) {
+            const parent = environment.resolveAny(parentRef);
+            if (parent === undefined ||
+                parent.ref.kind !== 'class' ||
+                parent.declaration.kind !== 'edge') {
+                continue;
+            }
+            if (!edgeContractRefines(environment, child, parent.declaration)) {
+                diagnostics.push(diagnostic('DV_EDGE_CLASS_COMPOSITION', '', `${formatDefinitionRef(resolved.ref)} does not safely refine ${formatDefinitionRef(parentRef)}.`));
+            }
+        }
+    }
+}
+function edgeContractRefines(environment, child, parent) {
+    if (child.orientation !== parent.orientation)
+        return false;
+    if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
+        return false;
+    if (parent.constraints.acyclic === true && child.constraints.acyclic !== true)
+        return false;
+    if (child.orientation === 'directed' && parent.orientation === 'directed') {
+        return (endpointRefines(environment, child.endpoints.source, parent.endpoints.source) &&
+            countRefines(child.endpoints.source.outgoing, parent.endpoints.source.outgoing) &&
+            endpointRefines(environment, child.endpoints.target, parent.endpoints.target) &&
+            countRefines(child.endpoints.target.incoming, parent.endpoints.target.incoming));
+    }
+    if (child.orientation !== 'undirected' || parent.orientation !== 'undirected')
+        return false;
+    const refines = (childIndex, parentIndex) => endpointRefines(environment, child.endpoints[childIndex], parent.endpoints[parentIndex]) &&
+        countRefines(child.endpoints[childIndex].incident, parent.endpoints[parentIndex].incident);
+    return (refines(0, 0) && refines(1, 1)) || (refines(0, 1) && refines(1, 0));
+}
+function endpointRefines(environment, child, parent) {
+    return child.accepts.every((accepted) => classSatisfies(environment, accepted, parent.accepts));
+}
+function countRefines(child, parent) {
+    const bounds = {
+        '0..*': [0, Number.POSITIVE_INFINITY],
+        '1..*': [1, Number.POSITIVE_INFINITY],
+        '0..1': [0, 1],
+        '1': [1, 1],
+    };
+    const [childMinimum, childMaximum] = bounds[child];
+    const [parentMinimum, parentMaximum] = bounds[parent];
+    return childMinimum >= parentMinimum && childMaximum <= parentMaximum;
+}
+function sameIncidentEndpointContract(left, right) {
+    if (left.incident !== right.incident)
+        return false;
+    const a = [...left.accepts].map(definitionRefIndex).sort();
+    const b = [...right.accepts].map(definitionRefIndex).sort();
+    return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function undirectedEndpointsOverlap(environment, endpoints) {
+    for (const resolved of environment.definitions.values()) {
+        if (resolved.ref.kind !== 'class' ||
+            resolved.declaration.kind !== 'node' ||
+            resolved.declaration.abstract) {
+            continue;
+        }
+        const candidate = resolved.ref;
+        if (classSatisfies(environment, candidate, endpoints[0].accepts) &&
+            classSatisfies(environment, candidate, endpoints[1].accepts)) {
+            return true;
+        }
+    }
+    return false;
+}
+function classSatisfies(environment, candidate, accepts) {
+    if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(candidate)))
+        return true;
+    const resolved = environment.resolveAny(candidate);
+    if (resolved === undefined ||
+        resolved.ref.kind !== 'class' ||
+        resolved.declaration.kind !== 'node') {
+        return false;
+    }
+    return extendsAny(environment, resolved.declaration.extends, accepts, new Set());
+}
+function extendsAny(environment, parents, accepts, visited) {
+    const accepted = new Set(accepts.map(definitionRefIndex));
+    for (const parent of parents) {
+        const key = definitionRefIndex(parent);
+        if (accepted.has(key))
+            return true;
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        const resolved = environment.resolveAny(parent);
+        if (resolved !== undefined &&
+            resolved.ref.kind === 'class' &&
+            extendsAny(environment, resolved.declaration.extends, accepts, visited)) {
+            return true;
+        }
+    }
+    return false;
+}
+function localRef(origin, name) {
+    return { origin, kind: 'class', name };
+}
+function sameRef(left, right) {
+    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
+}
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

package/dist/v1/schema/validation/core.d.ts

@@ -0,0 +1,5 @@
+import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
+import type { DefinitionAnalysisResult } from '../analysis/class.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainResolutionContext } from '../resolution/context.js';
+export declare function validateCore(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult, registry: ValueSchemaRegistry): readonly SchemaDiagnostic[];

package/dist/v1/schema/{core/validate.js → validation/core.js}

@@ -1,6 +1,8 @@
+import { Key } from '../../addressing/key.js';
+import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
+import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { diagnostic } from '../diagnostic.js';
-import { schemaRefIndex, compareUnicode, formatSchemaRef } from '../reference.js';
-import { validateJsonInstance } from '../value/instance.validate.js';
+const formatDefinitionRef = Key.of;
 export function validateCore(environment, analysis, registry) {
     const diagnostics = [];
     const nodesByRef = resolveCoreNodes(environment, analysis, registry, diagnostics);
@@ -12,20 +14,26 @@ function resolveCoreNodes(environment, analysis, registry, diagnostics) {
     const nodes = new Map();
     for (const [slug, node] of Object.entries(environment.candidate.core.nodes)) {
         const pointer = `/core/nodes/${escapePointer(slug)}`;
+        const ref = { origin: environment.candidate.origin, kind: 'core', name: slug };
+        if (node.ref.origin !== ref.origin ||
+            node.ref.kind !== ref.kind ||
+            node.ref.name !== ref.name) {
+            diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Core ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(node.ref)));
+        }
         const resolved = environment.resolve(node.class);
         if (node.class.origin !== environment.candidate.origin ||
             resolved === undefined ||
             resolved.ref.kind !== 'class' ||
-            resolved.family !== 'node') {
-            diagnostics.push(diagnostic('DV_CORE_NODE_CLASS', `${pointer}/class`, `Core Node Class ${formatSchemaRef(node.class)} must resolve to a local concrete Node Class.`, formatSchemaRef(node.class)));
+            resolved.kind !== 'node' ||
+            resolved.declaration.abstract) {
+            diagnostics.push(diagnostic('DV_CORE_NODE_CLASS', `${pointer}/class`, `Core Node Class ${formatDefinitionRef(node.class)} must resolve to a local concrete Node Class.`, formatDefinitionRef(node.class)));
             continue;
         }
-        const definition = analysis.definitions.get(schemaRefIndex(node.class));
+        const definition = analysis.definitions.get(definitionRefIndex(node.class));
         if (definition === undefined)
             continue;
         validateCreationProperties(definition, node.properties, registry, 'DV_CORE_NODE_PROPERTIES', `${pointer}/properties`, diagnostics);
-        const ref = { origin: environment.candidate.origin, kind: 'core', name: slug };
-        const key = schemaRefIndex(ref);
+        const key = definitionRefIndex(ref);
         nodes.set(key, { kind: 'core', slug, ref, key, classRef: node.class, analysis: definition });
     }
     return nodes;
@@ -40,20 +48,27 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
         if (edge.class.origin !== environment.candidate.origin ||
             resolved === undefined ||
             resolved.ref.kind !== 'class' ||
-            resolved.family !== 'edge') {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', `${pointer}/class`, `Core Edge Class ${formatSchemaRef(edge.class)} must resolve to a local concrete Edge Class.`, formatSchemaRef(edge.class)));
+            resolved.kind !== 'edge' ||
+            resolved.declaration.abstract) {
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', `${pointer}/class`, `Core Edge Class ${formatDefinitionRef(edge.class)} must resolve to a local concrete Edge Class.`, formatDefinitionRef(edge.class)));
             continue;
         }
-        const definition = analysis.definitions.get(schemaRefIndex(edge.class));
+        const definition = analysis.definitions.get(definitionRefIndex(edge.class));
         if (definition === undefined)
             continue;
         validateCreationProperties(definition, edge.properties, registry, 'DV_CORE_EDGE_PROPERTIES', `${pointer}/properties`, diagnostics);
         const declaration = resolved.declaration;
         if (source === undefined || target === undefined)
             continue;
-        if (!endpointSatisfies(environment, source, declaration.endpoints.source.accepts) ||
-            !endpointSatisfies(environment, target, declaration.endpoints.target.accepts)) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatSchemaRef(edge.class)}.`, formatSchemaRef(edge.class)));
+        const endpointsSatisfy = declaration.orientation === 'directed'
+            ? endpointSatisfies(environment, source, declaration.endpoints.source.accepts) &&
+                endpointSatisfies(environment, target, declaration.endpoints.target.accepts)
+            : (endpointSatisfies(environment, source, declaration.endpoints[0].accepts) &&
+                endpointSatisfies(environment, target, declaration.endpoints[1].accepts)) ||
+                (endpointSatisfies(environment, source, declaration.endpoints[1].accepts) &&
+                    endpointSatisfies(environment, target, declaration.endpoints[0].accepts));
+        if (!endpointsSatisfy) {
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.`, formatDefinitionRef(edge.class)));
             continue;
         }
         edges.push({ source, target, declaration, value: edge, pointer });
@@ -63,9 +78,9 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
 function resolveCoreEndpoint(ref, pointer, nodesByRef, diagnostics) {
     if (ref.kind === 'domain')
         return { kind: 'domain', ref, key: 'domain' };
-    const node = nodesByRef.get(schemaRefIndex(ref));
+    const node = nodesByRef.get(definitionRefIndex(ref));
     if (node === undefined) {
-        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${formatSchemaRef(ref)} does not name a declared local Core Node.`, formatSchemaRef(ref)));
+        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${formatDefinitionRef(ref)} does not name a declared local Core Node.`, formatDefinitionRef(ref)));
     }
     return node;
 }
@@ -92,7 +107,7 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
     const seen = new Map();
     const edgeSlices = new Map();
     for (const [name, candidate] of Object.entries(environment.candidate.classes)) {
-        if (candidate.family !== 'edge')
+        if (candidate.kind !== 'edge')
             continue;
         const ref = {
             origin: environment.candidate.origin,
@@ -100,16 +115,16 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
             name,
         };
         const resolved = environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'edge') {
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
             continue;
         }
-        edgeSlices.set(schemaRefIndex(ref), {
+        edgeSlices.set(definitionRefIndex(ref), {
             declaration: resolved.declaration,
             edges: [],
         });
     }
     for (const edge of edges) {
-        const classKey = schemaRefIndex(edge.value.class);
+        const classKey = definitionRefIndex(edge.value.class);
         const [source, target] = edge.declaration.orientation === 'undirected' &&
             compareUnicode(edge.source.key, edge.target.key) > 0
             ? [edge.target.key, edge.source.key]
@@ -141,33 +156,47 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
 }
 function validateCardinality(environment, declaration, edges, nodesByRef, diagnostics) {
     if (declaration.orientation === 'undirected') {
+        const [first, second] = declaration.endpoints;
         for (const node of nodesByRef.values()) {
-            if (!classSatisfies(environment, node.classRef, declaration.endpoints.source.accepts)) {
+            const matchesFirst = classSatisfies(environment, node.classRef, first.accepts);
+            const matchesSecond = classSatisfies(environment, node.classRef, second.accepts);
+            if (!matchesFirst && !matchesSecond)
                 continue;
-            }
             const degree = edges.filter((edge) => edge.source.key === node.key || edge.target.key === node.key).length;
-            checkBound(declaration.endpoints.source, degree, node, diagnostics);
+            if (matchesFirst)
+                checkIncidentBound(first, degree, node, diagnostics);
+            if (matchesSecond && !sameIncidentEndpointContract(first, second)) {
+                checkIncidentBound(second, degree, node, diagnostics);
+            }
         }
         return;
     }
     for (const node of nodesByRef.values()) {
         if (classSatisfies(environment, node.classRef, declaration.endpoints.source.accepts)) {
             const degree = edges.filter((edge) => edge.source.key === node.key).length;
-            checkBound(declaration.endpoints.source, degree, node, diagnostics);
+            checkBound(declaration.endpoints.source, declaration.endpoints.source.outgoing, degree, node, diagnostics);
         }
         if (classSatisfies(environment, node.classRef, declaration.endpoints.target.accepts)) {
             const degree = edges.filter((edge) => edge.target.key === node.key).length;
-            checkBound(declaration.endpoints.target, degree, node, diagnostics);
+            checkBound(declaration.endpoints.target, declaration.endpoints.target.incoming, degree, node, diagnostics);
         }
     }
 }
-function checkBound(endpoint, degree, node, diagnostics) {
-    const [minimum, maximum] = cardinalityBounds(endpoint.cardinality);
+function checkBound(endpoint, count, degree, node, diagnostics) {
+    const [minimum, maximum] = countBounds(count);
     if (degree >= minimum && degree <= maximum)
         return;
-    diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', `/core/nodes/${escapePointer(node.slug)}`, `Core degree ${degree} violates ${endpoint.role} cardinality ${endpoint.cardinality}.`));
+    diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', `/core/nodes/${escapePointer(node.slug)}`, `Core degree ${degree} violates ${endpoint.role} Edge count ${count}.`));
+}
+function checkIncidentBound(endpoint, degree, node, diagnostics) {
+    checkBound(endpoint, endpoint.incident, degree, node, diagnostics);
+}
+function sameIncidentEndpointContract(left, right) {
+    return (left.incident === right.incident &&
+        left.accepts.length === right.accepts.length &&
+        left.accepts.every((ref, index) => definitionRefIndex(ref) === definitionRefIndex(right.accepts[index])));
 }
-function cardinalityBounds(value) {
+function countBounds(value) {
     switch (value) {
         case '0..*':
             return [0, Number.POSITIVE_INFINITY];
@@ -204,18 +233,18 @@ function hasDirectedCycle(edges) {
     return [...outgoing.keys()].some(visit);
 }
 function classSatisfies(environment, classRef, accepts) {
-    if (accepts.some((ref) => schemaRefIndex(ref) === schemaRefIndex(classRef)))
+    if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(classRef)))
         return true;
     const resolved = environment.resolveAny(classRef);
-    if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'node') {
+    if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
         return false;
     }
-    return classImplementsAny(environment, resolved.declaration.implements, accepts, new Set());
+    return classExtendsAny(environment, resolved.declaration.extends, accepts, new Set());
 }
-function classImplementsAny(environment, parents, accepts, visited) {
-    const accepted = new Set(accepts.map(schemaRefIndex));
+function classExtendsAny(environment, parents, accepts, visited) {
+    const accepted = new Set(accepts.map(definitionRefIndex));
     for (const parent of parents) {
-        const key = schemaRefIndex(parent);
+        const key = definitionRefIndex(parent);
         if (accepted.has(key))
             return true;
         if (visited.has(key))
@@ -223,9 +252,8 @@ function classImplementsAny(environment, parents, accepts, visited) {
         visited.add(key);
         const resolved = environment.resolveAny(parent);
         if (resolved !== undefined &&
-            resolved.ref.kind === 'interface' &&
-            (resolved.family === 'node' || resolved.family === 'both') &&
-            classImplementsAny(environment, resolved.declaration.extends, accepts, visited)) {
+            resolved.ref.kind === 'class' &&
+            classExtendsAny(environment, resolved.declaration.extends, accepts, visited)) {
             return true;
         }
     }
@@ -234,4 +262,3 @@ function classImplementsAny(environment, parents, accepts, visited) {
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=validate.js.map

package/dist/v1/schema/validation/domain.d.ts

@@ -0,0 +1,11 @@
+import type { DefinitionAnalysisResult } from '../analysis/class.js';
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+import type { DomainResolutionContext } from '../resolution/context.js';
+export interface DomainSchemaValidation {
+    readonly context: DomainResolutionContext;
+    readonly analysis: DefinitionAnalysisResult;
+    readonly diagnostics: readonly SchemaDiagnostic[];
+}
+export declare function validateDomainSchemaSemantics(schema: DomainSchemaIR, lookup: DomainSchemaLookup): DomainSchemaValidation;

package/dist/v1/schema/{domain.validate.js → validation/domain.js}

@@ -1,11 +1,12 @@
-import { validateCore } from './core/validate.js';
-import { analyzeDefinitions } from './definition/analysis.js';
-import { validateDefinitions } from './definition/validate.js';
-import { validatePolicies } from './policy/validation/validate.js';
-import { buildDomainResolutionContext } from './resolution/context.js';
-import { createValueSchemaRegistry } from './resolution/value.registry.js';
-import { validateEmbeddedValueSchemas } from './validation/value.js';
-import { validateViews } from './view/validate.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { analyzeDefinitions } from '../analysis/class.js';
+import { buildDomainResolutionContext } from '../resolution/context.js';
+import { createValueSchemaRegistry } from '../resolution/value.registry.js';
+import { validateDefinitions } from './class.js';
+import { validateCore } from './core.js';
+import { validatePolicies } from './policy/validate.js';
+import { validateEmbeddedValueSchemas } from './value.js';
+import { validateViews } from './view.js';
 export function validateDomainSchemaSemantics(schema, lookup) {
     const context = buildDomainResolutionContext(schema, lookup);
     const analysis = analyzeDefinitions(context);
@@ -29,8 +30,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=domain.validate.js.map

package/dist/v1/schema/validation/domain.route.d.ts

@@ -1,5 +1,4 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { DomainSchemaIR } from '../domain.ir.js';
+import type { DomainSchemaIR } from '../model/schema.js';
 /** Select the exact Domain language contract before entering its structural grammar. */
 export declare function routeDomainSchema(input: JsonValue): DomainSchemaIR;
-//# sourceMappingURL=domain.route.d.ts.map

package/dist/v1/schema/validation/domain.route.js

@@ -1,5 +1,5 @@
-import { DomainSchemaError, diagnostic } from '../diagnostic.js';
-import { DOMAIN_FORMAT, DOMAIN_VERSION } from '../reference.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { DOMAIN_FORMAT, DOMAIN_VERSION } from '../model/format.js';
 import { parseDomainSchemaStructure } from './domain.structure.js';
 const decoders = new Map([
     [DOMAIN_FORMAT, new Map([[DOMAIN_VERSION, parseDomainSchemaStructure]])],
@@ -28,6 +28,5 @@ function describe(value) {
     return value === undefined ? '(missing)' : JSON.stringify(value);
 }
 function unsupported(code, pointer, message) {
-    throw new DomainSchemaError([diagnostic(code, pointer, message)]);
+    throw new SchemaError([diagnostic(code, pointer, message)]);
 }
-//# sourceMappingURL=domain.route.js.map

package/dist/v1/schema/validation/domain.structure.d.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import type { DomainSchemaIR } from '../domain.ir.js';
+import type { DomainSchemaIR } from '../model/schema.js';
 export declare const domainSchemaStructuralSchema: z.ZodType<DomainSchemaIR>;
 export declare function parseDomainSchemaStructure(input: unknown): DomainSchemaIR;
-//# sourceMappingURL=domain.structure.d.ts.map