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

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

@@ -0,0 +1,241 @@
+import { Key } from '../../addressing/key.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { admitStateTopology } from '../../language/state/topology.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)));
+        }
+        if (declaration.abstract &&
+            (declaration.policies.read !== undefined || declaration.policies.traverse !== undefined)) {
+            diagnostics.push(diagnostic('DV_CLASS_ABSTRACT', `${pointer}/policies`, 'Abstract Classes cannot declare observation Policies.'));
+        }
+        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)) {
+        const propertyPointer = `${pointer}/properties/${escapePointer(name)}`;
+        if (property.state !== undefined) {
+            if (declaration.kind !== 'node') {
+                diagnostics.push(diagnostic('DV_PROPERTY_STATE', `${propertyPointer}/state`, 'A State Property may be declared only on a Node Class.'));
+            }
+            try {
+                const topology = admitStateTopology(property.state);
+                const expected = Object.keys(topology.transitions).sort();
+                const schema = property.schema;
+                const schemaMatches = schema !== null &&
+                    typeof schema === 'object' &&
+                    !Array.isArray(schema) &&
+                    Object.keys(schema).length === 2 &&
+                    schema.type === 'string' &&
+                    Array.isArray(schema.enum) &&
+                    schema.enum.length === expected.length &&
+                    [...schema.enum].sort().every((state, index) => state === expected[index]);
+                if (!property.required || property.auto !== undefined || !schemaMatches) {
+                    diagnostics.push(diagnostic('DV_PROPERTY_STATE', `${propertyPointer}/state`, 'A State Property is required, non-automatic, and has exactly its declared states.'));
+                }
+            }
+            catch (error) {
+                diagnostics.push(diagnostic('DV_PROPERTY_STATE', `${propertyPointer}/state`, error instanceof Error ? error.message : 'Invalid State topology.'));
+            }
+        }
+        if (property.auto === undefined)
+            continue;
+        const autoPointer = `${propertyPointer}/auto`;
+        if (property.required && !property.auto.on.includes('create')) {
+            diagnostics.push(diagnostic('DV_PROPERTY_AUTO', `${autoPointer}/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', `${autoPointer}/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);
+    const direct = refines(0, 0) && refines(1, 1);
+    if (direct)
+        return true;
+    return 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,11 +48,12 @@ 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);
@@ -59,7 +68,7 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
                 (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 ${formatSchemaRef(edge.class)}.`, formatSchemaRef(edge.class)));
+            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 });
@@ -69,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;
 }
@@ -83,9 +92,11 @@ function endpointSatisfies(environment, endpoint, accepts) {
 function validateCreationProperties(definition, properties, registry, code, pointer, diagnostics) {
     const schema = {
         type: 'object',
-        properties: Object.fromEntries([...definition.properties].map(([name, field]) => [name, field.schema])),
+        properties: Object.fromEntries([...definition.properties]
+            .filter(([, field]) => field.auto === undefined)
+            .map(([name, field]) => [name, field.schema])),
         required: [...definition.properties]
-            .filter(([, field]) => field.required)
+            .filter(([, field]) => field.required && field.auto === undefined)
             .map(([name]) => name)
             .sort(compareUnicode),
         additionalProperties: false,
@@ -98,7 +109,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,
@@ -106,16 +117,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]
@@ -185,7 +196,7 @@ function checkIncidentBound(endpoint, degree, node, diagnostics) {
 function sameIncidentEndpointContract(left, right) {
     return (left.incident === right.incident &&
         left.accepts.length === right.accepts.length &&
-        left.accepts.every((ref, index) => schemaRefIndex(ref) === schemaRefIndex(right.accepts[index])));
+        left.accepts.every((ref, index) => definitionRefIndex(ref) === definitionRefIndex(right.accepts[index])));
 }
 function countBounds(value) {
     switch (value) {
@@ -224,18 +235,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))
@@ -243,9 +254,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;
         }
     }
@@ -254,4 +264,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';
-export declare const domainSchemaStructuralSchema: z.ZodType<DomainSchemaIR>;
+import { type ZodType } from 'zod';
+import type { DomainSchemaIR } from '../model/schema.js';
+export declare const domainSchemaStructuralSchema: ZodType<DomainSchemaIR>;
 export declare function parseDomainSchemaStructure(input: unknown): DomainSchemaIR;
-//# sourceMappingURL=domain.structure.d.ts.map