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

package/dist/v1/schema/resolution/origins.js

@@ -1,24 +1,20 @@
-import { compareSchemaRefs, schemaRefIndex } from '../reference.js';
-import { walkSchema } from '../value/location/walk.js';
-import { isValueObject as isJsonObject } from '../value/object.js';
-import { parseNamedTypeReference } from '../value/resources/references.js';
+import { compareDefinitionRefs, definitionRefIndex } from '../../addressing/ordering.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { policyVariableClass } from '../../language/policy/model/policy.js';
+import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
+import { walkSchema } from '../../language/value/syntax/walk.js';
 /** Collect only semantic refs, never strings or objects embedded as JSON data. */
 export function collectUsedForeignOrigins(schema) {
-    return new Set(collectDomainSchemaRefs(schema)
+    return new Set(collectDomainDefinitionRefs(schema)
         .filter((ref) => ref.origin !== schema.origin)
         .map((ref) => ref.origin));
 }
 /** Complete structured references in one schema, in canonical order. */
-export function collectDomainSchemaRefs(schema) {
+export function collectDomainDefinitionRefs(schema) {
     const result = new Map();
     const add = (ref) => {
-        result.set(schemaRefIndex(ref), ref);
+        result.set(definitionRefIndex(ref), ref);
     };
-    for (const value of Object.values(schema.types))
-        collectValueSchemaRefs(value, add);
-    for (const declaration of Object.values(schema.interfaces)) {
-        collectInterfaceRefs(declaration, add);
-    }
     for (const declaration of Object.values(schema.classes)) {
         collectClassRefs(declaration, add);
     }
@@ -26,69 +22,102 @@ export function collectDomainSchemaRefs(schema) {
         collectCallableRefs(declaration, add);
     }
     for (const declaration of Object.values(schema.policies)) {
-        collectPolicyDeclarationRefs(declaration, add);
+        collectPolicyDefinitionRefs(declaration, add);
     }
     for (const declaration of Object.values(schema.views)) {
-        if (declaration.target.kind === 'definition')
-            declaration.target.definitions.forEach(add);
+        if (declaration.target.kind === 'definition') {
+            declaration.target.definitions.forEach((ref) => add(ref, 'view'));
+        }
     }
-    for (const node of Object.values(schema.core.nodes))
-        add(node.class);
-    for (const edge of schema.core.edges)
-        add(edge.class);
-    return Object.freeze([...result.values()].sort(compareSchemaRefs));
+    collectCoreRefs(schema, add);
+    return Object.freeze([...result.values()].sort(compareDefinitionRefs));
 }
-export function collectInterfaceRefs(declaration, add) {
-    declaration.extends.forEach(add);
-    collectValueSchemaRefs(declaration.properties, add);
-    if ('methods' in declaration) {
-        Object.values(declaration.methods).forEach((method) => collectCallableRefs(method, add));
+export function collectCoreRefs(schema, add) {
+    for (const node of Object.values(schema.core.nodes))
+        add(node.class, 'core');
+    for (const edge of schema.core.edges) {
+        add(edge.class, 'core');
+        for (const endpoint of [edge.source, edge.target]) {
+            const ref = coreEndpointDefinitionRef(endpoint);
+            // An endpoint names the Definition without instantiating it, exactly like an accepts contract.
+            if (ref !== undefined)
+                add(ref, 'endpoint');
+        }
     }
-    if (declaration.family === 'edge')
-        collectEndpointRefs(declaration, add);
+}
+/** The owning Domain addresses no Definition, and a Method is addressed through its owner Class. */
+export function coreEndpointDefinitionRef(endpoint) {
+    if (endpoint.kind === 'domain')
+        return undefined;
+    return endpoint.kind === 'method' ? endpoint.owner : endpoint;
 }
 export function collectClassRefs(declaration, add) {
-    declaration.implements.forEach(add);
-    collectValueSchemaRefs(declaration.properties, add);
-    if (declaration.family === 'edge') {
+    declaration.extends.forEach((ref) => add(ref, 'extends'));
+    Object.values(declaration.properties).forEach((property) => collectValueDefinitionRefs(property.schema, add));
+    collectClassPolicyRefs(declaration, add);
+    if (declaration.kind === 'edge') {
         collectEndpointRefs(declaration, add);
         return;
     }
     Object.values(declaration.methods).forEach((method) => collectCallableRefs(method, add));
+}
+export function collectClassPolicyRefs(declaration, add) {
     if (declaration.policies.read !== undefined)
-        add(declaration.policies.read);
+        add(declaration.policies.read, 'policy');
+    if (declaration.policies.traverse !== undefined)
+        add(declaration.policies.traverse, 'policy');
 }
-function collectEndpointRefs(declaration, add) {
+export function collectEndpointRefs(declaration, add) {
     const endpoints = declaration.orientation === 'directed'
         ? [declaration.endpoints.source, declaration.endpoints.target]
         : declaration.endpoints;
-    endpoints[0].accepts.forEach(add);
-    endpoints[1].accepts.forEach(add);
+    endpoints[0].accepts.forEach((ref) => add(ref, 'endpoint'));
+    endpoints[1].accepts.forEach((ref) => add(ref, 'endpoint'));
 }
 export function collectCallableRefs(declaration, add) {
-    collectValueSchemaRefs(declaration.input, add);
-    if (declaration.output.mode === 'value')
-        collectValueSchemaRefs(declaration.output.schema, add);
-    if (declaration.output.mode === 'stream')
-        collectValueSchemaRefs(declaration.output.item, add);
+    collectCallableContractRefs(declaration, add);
     if (declaration.policy !== undefined)
         collectPolicyCheckRefs(declaration.policy, add);
 }
-export function collectPolicyDeclarationRefs(declaration, add) {
-    if ('match' in declaration) {
-        collectPolicyPatternRefs(declaration.match, add);
+/** References inside the contract a caller compiles against: the input and output value schemas. */
+export function collectCallableContractRefs(declaration, add) {
+    collectValueDefinitionRefs(isBinaryInput(declaration.input) ? declaration.input.metadata : declaration.input, add);
+    if (declaration.output.mode === 'value')
+        collectValueDefinitionRefs(declaration.output.schema, add);
+    if (declaration.output.mode === 'stream')
+        collectValueDefinitionRefs(declaration.output.item, add);
+}
+export function collectPolicyDefinitionRefs(declaration, add) {
+    collectPolicyExpressionRefs(declaration.expression, add);
+}
+function collectPolicyExpressionRefs(expression, add) {
+    if ('match' in expression) {
+        collectPolicyPatternRefs(expression.match, add);
         return;
     }
-    const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
-    refs.forEach(add);
+    const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
+    refs.forEach((ref) => add(ref, 'policy'));
 }
 function collectPolicyPatternRefs(expression, add) {
+    if ('sameNode' in expression) {
+        for (const term of [expression.sameNode.left, expression.sameNode.right])
+            if (term.kind === 'ref')
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
+        return;
+    }
     if ('source' in expression) {
-        add(expression.class);
+        for (const term of [expression.source, expression.target])
+            if (term.kind === 'ref')
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
+        add(expression.class, 'policy');
         return;
     }
     if ('exists' in expression) {
-        expression.exists.nodes.forEach((node) => add(node.class));
+        expression.exists.nodes.forEach((node) => {
+            const ref = policyVariableClass(node);
+            if (ref !== undefined)
+                add(ref, 'policy');
+        });
         collectPolicyPatternRefs(expression.exists.where, add);
         return;
     }
@@ -96,26 +125,27 @@ function collectPolicyPatternRefs(expression, add) {
     children.forEach((child) => collectPolicyPatternRefs(child, add));
 }
 function collectPolicyCheckRefs(expression, add) {
+    if ('sameNode' in expression) {
+        for (const term of [expression.sameNode.left, expression.sameNode.right])
+            if (term.kind === 'ref')
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
+        return;
+    }
     if ('check' in expression) {
-        add(expression.check);
+        add(expression.check, 'policy');
         if (expression.object.kind === 'ref')
-            add(expression.object.ref);
+            add(expression.object.ref.kind === 'method'
+                ? expression.object.ref.owner
+                : expression.object.ref, 'policy');
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;
     children.forEach((child) => collectPolicyCheckRefs(child, add));
 }
-export function collectValueSchemaRefs(schema, add) {
+export function collectValueDefinitionRefs(schema, add) {
     walkSchema(schema, ({ schema: current }) => {
         if (!isJsonObject(current))
             return;
-        if (typeof current.$ref === 'string') {
-            const named = parseNamedTypeReference(current.$ref);
-            if (named !== undefined) {
-                const ref = { origin: named.origin, kind: 'type', name: named.name };
-                add(ref);
-            }
-        }
         const annotation = current['x-astrale-path'];
         if (!isJsonObject(annotation) || !Array.isArray(annotation.accepts))
             return;
@@ -124,9 +154,8 @@ export function collectValueSchemaRefs(schema, add) {
                 typeof candidate.origin === 'string' &&
                 typeof candidate.kind === 'string' &&
                 typeof candidate.name === 'string') {
-                add(candidate);
+                add(candidate, 'value');
             }
         }
     });
 }
-//# sourceMappingURL=origins.js.map

package/dist/v1/schema/resolution/value.registry.d.ts

@@ -1,8 +1,7 @@
-import type { DomainSchema } from '../domain.ir.js';
-import type { DomainSchemaLookup } from '../domain.lookup.js';
-import type { ValueSchemaRegistry } from '../value/registry.js';
+import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { DomainSchema } from '../model/schema.js';
 import type { DomainResolutionContext } from './context.js';
 /** Build the exact value-schema resource closure for one installed Domain. */
 export declare function createDomainValueSchemaRegistry(schema: DomainSchema, lookup?: DomainSchemaLookup): ValueSchemaRegistry;
 export declare function createValueSchemaRegistry(context: DomainResolutionContext): ValueSchemaRegistry;
-//# sourceMappingURL=value.registry.d.ts.map

package/dist/v1/schema/resolution/value.registry.js

@@ -1,5 +1,5 @@
-import { revisionOfDomainSchema } from '../domain.revision.js';
-import { graphNodePathSchema } from '../value/extensions/node-path/schema.js';
+import { graphNodePathSchema } from '../../language/value/syntax/node-path/schema.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { lookupForDomainClosure } from './closure.js';
 import { buildDomainResolutionContext } from './context.js';
 /** Build the exact value-schema resource closure for one installed Domain. */
@@ -9,7 +9,7 @@ export function createDomainValueSchemaRegistry(schema, lookup = lookupForDomain
 export function createValueSchemaRegistry(context) {
     const directDependencies = [];
     const transitiveDependencies = [];
-    const directOrigins = new Set(context.candidate.dependencies.map(({ origin }) => origin));
+    const directOrigins = new Set(Object.values(context.candidate.dependencies).map(({ origin }) => origin));
     for (const schema of context.dependencies.values()) {
         const entry = {
             ...domainValueRegistry(schema),
@@ -28,19 +28,12 @@ export function createValueSchemaRegistry(context) {
     });
 }
 function domainValueRegistry(schema) {
-    const nodeDefinitions = [
-        ...Object.entries(schema.interfaces)
-            .filter(([, declaration]) => declaration.family === 'node')
-            .map(([name]) => ({ origin: schema.origin, kind: 'interface', name })),
-        ...Object.entries(schema.classes)
-            .filter(([, declaration]) => declaration.family === 'node')
-            .map(([name]) => ({ origin: schema.origin, kind: 'class', name })),
-    ];
+    const nodeDefinitions = Object.entries(schema.classes)
+        .filter(([, declaration]) => declaration.kind === 'node')
+        .map(([name]) => ({ origin: schema.origin, kind: 'class', name }));
     return Object.freeze({
         origin: schema.origin,
-        dependencies: schema.dependencies,
-        types: schema.types,
+        dependencies: Object.values(schema.dependencies),
         nodeDefinitions: Object.freeze(nodeDefinitions),
     });
 }
-//# sourceMappingURL=value.registry.js.map

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

@@ -0,0 +1 @@
+export { revisionOfDomainSchema as revision } from './canonical/revision.js';

package/dist/v1/schema/revision.js

@@ -0,0 +1 @@
+export { revisionOfDomainSchema as revision } from './canonical/revision.js';

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

@@ -0,0 +1,4 @@
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+/** Validate the execution modifier of every local Function and Node Method. */
+export declare function validateCallables(schema: DomainSchemaIR): readonly SchemaDiagnostic[];

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

@@ -0,0 +1,39 @@
+import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { diagnostic } from '../diagnostic.js';
+/** Validate the execution modifier of every local Function and Node Method. */
+export function validateCallables(schema) {
+    const diagnostics = [];
+    for (const [name, declaration] of Object.entries(schema.functions)) {
+        validateExecution(declaration, `/functions/${escapePointer(name)}`, diagnostics);
+    }
+    for (const [name, declaration] of Object.entries(schema.classes)) {
+        if (declaration.kind !== 'node')
+            continue;
+        for (const [method, value] of Object.entries(declaration.methods)) {
+            const pointer = `/classes/${escapePointer(name)}/methods/${escapePointer(method)}`;
+            validateExecution(value, pointer, diagnostics);
+        }
+    }
+    return Object.freeze(diagnostics);
+}
+/**
+ * An Execution records its initiating caller and its admitted input, from which the run is
+ * resubmitted, and retains one portable outcome. A durable callable therefore needs a known caller,
+ * a value input and a replayable value output.
+ */
+function validateExecution(declaration, pointer, diagnostics) {
+    if (declaration.execution?.durable !== true)
+        return;
+    if (declaration.auth === 'anonymous') {
+        diagnostics.push(diagnostic('DV_CALLABLE_AUTH', `${pointer}/auth`, 'A durable callable requires authenticated or authorized auth.'));
+    }
+    if (isBinaryInput(declaration.input)) {
+        diagnostics.push(diagnostic('DV_CALLABLE_IO', `${pointer}/input/mode`, 'A durable callable requires a value input.'));
+    }
+    if (declaration.output.mode !== 'value') {
+        diagnostics.push(diagnostic('DV_CALLABLE_IO', `${pointer}/output/mode`, 'A durable callable requires a value output.'));
+    }
+}
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

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

@@ -0,0 +1,5 @@
+import type { DefinitionAnalysisResult } from '../analysis/class.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainResolutionContext } from '../resolution/context.js';
+/** Validate the semantic contracts owned by Class declarations. */
+export declare function validateDefinitions(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];

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

@@ -0,0 +1,247 @@
+import { Key } from '../../addressing/key.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
+import { admitStateTopology } from '../../language/state/topology.js';
+import { isBlobValueSchema } from '../../language/value/model/blob.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 (isBlobValueSchema(property.schema) &&
+            (declaration.kind !== 'node' || property.auto !== undefined || property.state !== undefined)) {
+            diagnostics.push(diagnostic('DV_VALUE_SCHEMA', `${propertyPointer}/schema/x-astrale-value-kind`, 'Blob values are allowed only on non-automatic, non-state Node properties.'));
+        }
+        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 (!isMethodExecutable(declaration, method) && 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[];