@astrale-os/kernel-dsl 0.2.0-beta.8 → 0.2.0

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

@@ -1,4 +1,6 @@
 import { compareDefinitionRefs, definitionRefIndex } from '../../addressing/ordering.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { isClassRuleChecks, 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. */
@@ -11,7 +13,8 @@ export function collectUsedForeignOrigins(schema) {
 export function collectDomainDefinitionRefs(schema) {
     const result = new Map();
     const add = (ref) => {
-        result.set(definitionRefIndex(ref), ref);
+        const definition = ref.kind === 'method' ? ref.owner : ref;
+        result.set(definitionRefIndex(definition), definition);
     };
     for (const declaration of Object.values(schema.classes)) {
         collectClassRefs(declaration, add);
@@ -22,51 +25,66 @@ export function collectDomainDefinitionRefs(schema) {
     for (const declaration of Object.values(schema.policies)) {
         collectPolicyDefinitionRefs(declaration, add);
     }
-    for (const declaration of Object.values(schema.views)) {
-        if (declaration.target.kind === 'definition')
-            declaration.target.definitions.forEach(add);
-    }
+    collectCoreRefs(schema, add);
+    return Object.freeze([...result.values()].sort(compareDefinitionRefs));
+}
+export function collectCoreRefs(schema, add) {
     for (const node of Object.values(schema.core.nodes))
-        add(node.class);
+        add(node.class, 'core');
     for (const edge of schema.core.edges) {
-        add(edge.class);
-        if (edge.source.kind !== 'domain')
-            add(edge.source);
-        if (edge.target.kind !== 'domain')
-            add(edge.target);
+        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');
+        }
     }
-    return Object.freeze([...result.values()].sort(compareDefinitionRefs));
+}
+/** 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.extends.forEach(add);
+    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);
-        if (declaration.policies.traverse !== undefined)
-            add(declaration.policies.traverse);
         return;
     }
     Object.values(declaration.methods).forEach((method) => collectCallableRefs(method, add));
-    if (declaration.policies.read !== undefined)
-        add(declaration.policies.read);
-    if (declaration.policies.traverse !== undefined)
-        add(declaration.policies.traverse);
 }
-function collectEndpointRefs(declaration, add) {
+export function collectClassPolicyRefs(declaration, add) {
+    for (const policy of [declaration.policies.read, declaration.policies.traverse]) {
+        if (isClassRuleChecks(policy))
+            collectPolicyCheckRefs(policy, add);
+        else if (typeof policy === 'object')
+            add(policy, 'policy');
+    }
+}
+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) {
-    collectValueDefinitionRefs(declaration.input, add);
+    collectCallableContractRefs(declaration, add);
+    if (typeof declaration.policy === 'object') {
+        collectPolicyCheckRefs(declaration.policy, 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);
-    if (declaration.policy !== undefined)
-        collectPolicyCheckRefs(declaration.policy, add);
 }
 export function collectPolicyDefinitionRefs(declaration, add) {
     collectPolicyExpressionRefs(declaration.expression, add);
@@ -77,15 +95,28 @@ function collectPolicyExpressionRefs(expression, add) {
         return;
     }
     const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
-    refs.forEach(add);
+    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, 'policy');
+        return;
+    }
     if ('source' in expression) {
-        add(expression.class);
+        for (const term of [expression.source, expression.target])
+            if (term.kind === 'ref')
+                add(term.ref, 'policy');
+        add(expression.class, 'pattern');
         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;
     }
@@ -93,10 +124,16 @@ 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, '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, 'policy');
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;
@@ -114,7 +151,7 @@ export function collectValueDefinitionRefs(schema, add) {
                 typeof candidate.origin === 'string' &&
                 typeof candidate.kind === 'string' &&
                 typeof candidate.name === 'string') {
-                add(candidate);
+                add(candidate, 'value');
             }
         }
     });

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

@@ -1,5 +1,15 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
 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[];
+/** Whether `child` safely refines its parent Edge contract `parent`. */
+export declare function edgeContractRefines(environment: DomainResolutionContext, child: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>, parent: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>): boolean;
+/** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
+export declare function classSatisfies(environment: DomainResolutionContext, candidate: ClassRef, accepts: readonly ClassRef[]): boolean;

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

@@ -1,5 +1,9 @@
 import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
+import { classSatisfies as satisfiesClass, isGraphRoot } from '../../language/class/inheritance.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';
@@ -14,6 +18,10 @@ export function validateDefinitions(environment, analysis) {
         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') {
@@ -26,22 +34,60 @@ export function validateDefinitions(environment, analysis) {
 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.immutable !== undefined) {
+            const immutablePointer = `${propertyPointer}/immutable`;
+            if (property.auto !== undefined || property.state !== undefined) {
+                diagnostics.push(diagnostic('DV_PROPERTY_IMMUTABLE', immutablePointer, 'An immutable Property is neither automatic nor a State Property.'));
+            }
+            if (property.immutable === 'once' && property.required) {
+                diagnostics.push(diagnostic('DV_PROPERTY_IMMUTABLE', immutablePointer, 'A required immutable Property is written at creation: declare it create, not once.'));
+            }
+        }
         if (property.auto === undefined)
             continue;
-        const propertyPointer = `${pointer}/properties/${escapePointer(name)}/auto`;
+        const autoPointer = `${propertyPointer}/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.'));
+            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', `${propertyPointer}/set`, 'The instant setter requires an Instant value schema.'));
+            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) {
+        if (!isMethodExecutable(declaration, method) && method.policy !== undefined) {
             diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/policy`, 'Abstract Methods cannot have a Policy.'));
         }
     }
@@ -66,19 +112,24 @@ function validateEdgeContract(environment, owner, declaration, diagnostics) {
     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);
+    const counts = declaration.orientation === 'directed'
+        ? [declaration.endpoints.source.outgoing, declaration.endpoints.target.incoming]
+        : [declaration.endpoints[0].incident, declaration.endpoints[1].incident];
+    validateEndpoint(environment, owner, endpoints[0], counts[0], declaration.orientation === 'directed' ? 'source' : 'first endpoint', diagnostics);
+    validateEndpoint(environment, owner, endpoints[1], counts[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) {
+function validateEndpoint(environment, owner, endpoint, count, side, diagnostics) {
+    // An Edge Class binds only the Nodes of its Domain and its dependents: it cannot oblige the
+    // Nodes of a Class another Domain owns to carry its Edges.
+    const foreign = endpoint.accepts.find((ref) => ref.origin !== owner.origin);
+    if (foreign !== undefined && (count === '1' || count === '1..*')) {
+        diagnostics.push(diagnostic('DV_EDGE_FOREIGN_MINIMUM', '', `${formatDefinitionRef(owner)} ${side} accepts ${formatDefinitionRef(foreign)} of another Domain and cannot require ${count} Edges.`));
+    }
     const seen = new Set();
     for (const ref of endpoint.accepts) {
         const key = definitionRefIndex(ref);
@@ -113,7 +164,10 @@ function validateEdgeClassComposition(environment, diagnostics) {
         }
     }
 }
-function edgeContractRefines(environment, child, parent) {
+/** Whether `child` safely refines its parent Edge contract `parent`. */
+export function edgeContractRefines(environment, child, parent) {
+    if (isGraphRoot(parent))
+        return true;
     if (child.orientation !== parent.orientation)
         return false;
     if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
@@ -130,7 +184,10 @@ function edgeContractRefines(environment, child, parent) {
         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));
+    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));
@@ -146,56 +203,18 @@ function countRefines(child, parent) {
     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) {
+/** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
+export 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') {
+    const resolve = (ref) => environment.resolveAny(ref)?.declaration;
+    const actual = resolve(candidate);
+    if (actual?.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;
+    return accepts.some((ref) => {
+        const required = resolve(ref);
+        return required !== undefined && satisfiesClass(actual, required, resolve);
+    });
 }
 function localRef(origin, name) {
     return { origin, kind: 'class', name };

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

@@ -1,7 +1,10 @@
 import { Key } from '../../addressing/key.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
+import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { diagnostic } from '../diagnostic.js';
+import { classSatisfies } from './class.js';
 const formatDefinitionRef = Key.of;
 export function validateCore(environment, analysis, registry) {
     const diagnostics = [];
@@ -42,8 +45,8 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
     const edges = [];
     for (const [index, edge] of environment.candidate.core.edges.entries()) {
         const pointer = `/core/edges/${index}`;
-        const source = resolveCoreEndpoint(edge.source, `${pointer}/source`, nodesByRef, diagnostics);
-        const target = resolveCoreEndpoint(edge.target, `${pointer}/target`, nodesByRef, diagnostics);
+        const source = resolveCoreEndpoint(environment, edge.source, `${pointer}/source`, nodesByRef, diagnostics);
+        const target = resolveCoreEndpoint(environment, edge.target, `${pointer}/target`, nodesByRef, diagnostics);
         const resolved = environment.resolve(edge.class);
         if (edge.class.origin !== environment.candidate.origin ||
             resolved === undefined ||
@@ -75,14 +78,37 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
     }
     return edges;
 }
-function resolveCoreEndpoint(ref, pointer, nodesByRef, diagnostics) {
+function resolveCoreEndpoint(environment, ref, pointer, nodesByRef, diagnostics) {
     if (ref.kind === 'domain')
         return { kind: 'domain', ref, key: 'domain' };
-    const node = nodesByRef.get(definitionRefIndex(ref));
-    if (node === undefined) {
-        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${formatDefinitionRef(ref)} does not name a declared local Core Node.`, formatDefinitionRef(ref)));
+    const undeclared = () => {
+        const key = policyObjectKey(ref);
+        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${key} does not name a declared local Definition.`, key));
+        return undefined;
+    };
+    if (policyObjectOrigin(ref) !== environment.candidate.origin)
+        return undeclared();
+    if (ref.kind === 'core')
+        return nodesByRef.get(definitionRefIndex(ref)) ?? undeclared();
+    if (!declaresProjectedMember(environment, ref))
+        return undeclared();
+    return { kind: 'member', key: policyObjectKey(ref), classRef: projectedMemberClass(ref) };
+}
+/** Only a projected declaration can carry a Core fact; an abstract Method is never projected. */
+function declaresProjectedMember(environment, ref) {
+    const candidate = environment.candidate;
+    if (ref.kind === 'method') {
+        const owner = candidate.classes[ref.owner.name];
+        const method = owner?.kind === 'node' ? owner.methods[ref.name] : undefined;
+        return method !== undefined && isMethodExecutable(owner, method);
     }
-    return node;
+    if (ref.kind === 'class')
+        return Object.hasOwn(candidate.classes, ref.name);
+    if (ref.kind === 'function')
+        return Object.hasOwn(candidate.functions, ref.name);
+    if (ref.kind === 'policy')
+        return Object.hasOwn(candidate.policies, ref.name);
+    return Object.hasOwn(candidate.views, ref.name);
 }
 function endpointSatisfies(environment, endpoint, accepts) {
     // The owning Domain is a graph-projection identity, not a Definition declared by this DSL.
@@ -92,9 +118,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,
@@ -155,41 +183,68 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
     }
 }
 function validateCardinality(environment, declaration, edges, nodesByRef, diagnostics) {
+    const subjects = cardinalitySubjects(edges, nodesByRef);
     if (declaration.orientation === 'undirected') {
         const [first, second] = declaration.endpoints;
-        for (const node of nodesByRef.values()) {
-            const matchesFirst = classSatisfies(environment, node.classRef, first.accepts);
-            const matchesSecond = classSatisfies(environment, node.classRef, second.accepts);
+        for (const subject of subjects) {
+            const matchesFirst = classSatisfies(environment, subject.classRef, first.accepts);
+            const matchesSecond = classSatisfies(environment, subject.classRef, second.accepts);
             if (!matchesFirst && !matchesSecond)
                 continue;
-            const degree = edges.filter((edge) => edge.source.key === node.key || edge.target.key === node.key).length;
+            const degree = edges.filter((edge) => edge.source.key === subject.key || edge.target.key === subject.key).length;
             if (matchesFirst)
-                checkIncidentBound(first, degree, node, diagnostics);
+                checkBound(first, first.incident, degree, subject, diagnostics);
             if (matchesSecond && !sameIncidentEndpointContract(first, second)) {
-                checkIncidentBound(second, degree, node, diagnostics);
+                checkBound(second, second.incident, degree, subject, 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, declaration.endpoints.source.outgoing, degree, node, diagnostics);
+    for (const subject of subjects) {
+        if (classSatisfies(environment, subject.classRef, declaration.endpoints.source.accepts)) {
+            const degree = edges.filter((edge) => edge.source.key === subject.key).length;
+            checkBound(declaration.endpoints.source, declaration.endpoints.source.outgoing, degree, subject, 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, declaration.endpoints.target.incoming, degree, node, diagnostics);
+        if (classSatisfies(environment, subject.classRef, declaration.endpoints.target.accepts)) {
+            const degree = edges.filter((edge) => edge.target.key === subject.key).length;
+            checkBound(declaration.endpoints.target, declaration.endpoints.target.incoming, degree, subject, diagnostics);
+        }
+    }
+}
+/**
+ * Every declared Core Node proves its own complete degree, so both bounds hold. A Definition
+ * endpoint is only named by the Edges that reach it: the Domain may also create ordinary Edges of
+ * the same Class against it, so a minimum is unprovable here and only the maximum is enforced.
+ */
+function cardinalitySubjects(edges, nodesByRef) {
+    const subjects = new Map();
+    for (const node of nodesByRef.values()) {
+        subjects.set(node.key, {
+            key: node.key,
+            classRef: node.classRef,
+            pointer: `/core/nodes/${escapePointer(node.slug)}`,
+            minimum: true,
+        });
+    }
+    for (const edge of edges) {
+        for (const endpoint of [edge.source, edge.target]) {
+            if (endpoint.kind !== 'member' || subjects.has(endpoint.key))
+                continue;
+            subjects.set(endpoint.key, {
+                key: endpoint.key,
+                classRef: endpoint.classRef,
+                pointer: edge.pointer,
+                minimum: false,
+            });
         }
     }
+    return Object.freeze([...subjects.values()]);
 }
-function checkBound(endpoint, count, degree, node, diagnostics) {
+function checkBound(endpoint, count, degree, subject, diagnostics) {
     const [minimum, maximum] = countBounds(count);
-    if (degree >= minimum && degree <= maximum)
+    if (degree <= maximum && (degree >= minimum || !subject.minimum))
         return;
-    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);
+    diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', subject.pointer, `Core degree ${degree} violates ${endpoint.role} Edge count ${count}.`));
 }
 function sameIncidentEndpointContract(left, right) {
     return (left.incident === right.incident &&
@@ -232,33 +287,6 @@ function hasDirectedCycle(edges) {
     };
     return [...outgoing.keys()].some(visit);
 }
-function classSatisfies(environment, classRef, accepts) {
-    if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(classRef)))
-        return true;
-    const resolved = environment.resolveAny(classRef);
-    if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
-        return false;
-    }
-    return classExtendsAny(environment, resolved.declaration.extends, accepts, new Set());
-}
-function classExtendsAny(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' &&
-            classExtendsAny(environment, resolved.declaration.extends, accepts, visited)) {
-            return true;
-        }
-    }
-    return false;
-}
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }

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

@@ -3,9 +3,10 @@ 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 {
+interface DomainSchemaValidation {
     readonly context: DomainResolutionContext;
     readonly analysis: DefinitionAnalysisResult;
     readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function validateDomainSchemaSemantics(schema: DomainSchemaIR, lookup: DomainSchemaLookup): DomainSchemaValidation;
+export {};