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

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

@@ -0,0 +1,318 @@
+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';
+const formatDefinitionRef = Key.of;
+export function validateCore(environment, analysis, registry) {
+    const diagnostics = [];
+    const nodesByRef = resolveCoreNodes(environment, analysis, registry, diagnostics);
+    const edges = resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnostics);
+    validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics);
+    return Object.freeze(diagnostics);
+}
+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.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(definitionRefIndex(node.class));
+        if (definition === undefined)
+            continue;
+        validateCreationProperties(definition, node.properties, registry, 'DV_CORE_NODE_PROPERTIES', `${pointer}/properties`, diagnostics);
+        const key = definitionRefIndex(ref);
+        nodes.set(key, { kind: 'core', slug, ref, key, classRef: node.class, analysis: definition });
+    }
+    return nodes;
+}
+function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnostics) {
+    const edges = [];
+    for (const [index, edge] of environment.candidate.core.edges.entries()) {
+        const pointer = `/core/edges/${index}`;
+        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 ||
+            resolved.ref.kind !== '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(definitionRefIndex(edge.class));
+        if (definition === undefined)
+            continue;
+        validateCreationProperties(definition, edge.properties, registry, 'DV_CORE_EDGE_PROPERTIES', `${pointer}/properties`, diagnostics);
+        const declaration = resolved.declaration;
+        if (source === undefined || target === undefined)
+            continue;
+        const endpointsSatisfy = declaration.orientation === 'directed'
+            ? endpointSatisfies(environment, source, declaration.endpoints.source.accepts) &&
+                endpointSatisfies(environment, target, declaration.endpoints.target.accepts)
+            : (endpointSatisfies(environment, source, declaration.endpoints[0].accepts) &&
+                endpointSatisfies(environment, target, declaration.endpoints[1].accepts)) ||
+                (endpointSatisfies(environment, source, declaration.endpoints[1].accepts) &&
+                    endpointSatisfies(environment, target, declaration.endpoints[0].accepts));
+        if (!endpointsSatisfy) {
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.`, formatDefinitionRef(edge.class)));
+            continue;
+        }
+        edges.push({ source, target, declaration, value: edge, pointer });
+    }
+    return edges;
+}
+function resolveCoreEndpoint(environment, ref, pointer, nodesByRef, diagnostics) {
+    if (ref.kind === 'domain')
+        return { kind: 'domain', ref, key: 'domain' };
+    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);
+    }
+    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.
+    // Its concrete Class contract is therefore admitted by the projection compiler.
+    return endpoint.kind === 'domain' || classSatisfies(environment, endpoint.classRef, accepts);
+}
+function validateCreationProperties(definition, properties, registry, code, pointer, diagnostics) {
+    const schema = {
+        type: 'object',
+        properties: Object.fromEntries([...definition.properties]
+            .filter(([, field]) => field.auto === undefined)
+            .map(([name, field]) => [name, field.schema])),
+        required: [...definition.properties]
+            .filter(([, field]) => field.required && field.auto === undefined)
+            .map(([name]) => name)
+            .sort(compareUnicode),
+        additionalProperties: false,
+    };
+    for (const failure of validateJsonInstance(schema, properties, registry, pointer)) {
+        diagnostics.push(diagnostic(code, failure.pointer, failure.message, failure.ref));
+    }
+}
+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.kind !== 'edge')
+            continue;
+        const ref = {
+            origin: environment.candidate.origin,
+            kind: 'class',
+            name,
+        };
+        const resolved = environment.resolve(ref);
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
+            continue;
+        }
+        edgeSlices.set(definitionRefIndex(ref), {
+            declaration: resolved.declaration,
+            edges: [],
+        });
+    }
+    for (const edge of edges) {
+        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]
+            : [edge.source.key, edge.target.key];
+        const key = `${classKey}\u0000${source}\u0000${target}`;
+        const previous = seen.get(key);
+        if (previous !== undefined) {
+            diagnostics.push(diagnostic('DV_CORE_EDGE_KEY', edge.pointer, `Core Edge duplicates the normalized EdgeKey declared at ${previous}.`));
+        }
+        else {
+            seen.set(key, edge.pointer);
+        }
+        const slice = edgeSlices.get(classKey) ?? {
+            declaration: edge.declaration,
+            edges: [],
+        };
+        slice.edges.push(edge);
+        edgeSlices.set(classKey, slice);
+        if (edge.declaration.constraints.noSelf === true && edge.source.key === edge.target.key) {
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', edge.pointer, 'Core Edge violates noSelf.'));
+        }
+    }
+    for (const { declaration, edges: classEdges } of edgeSlices.values()) {
+        if (declaration.constraints.acyclic === true && hasDirectedCycle(classEdges)) {
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', '/core/edges', 'Core Edge set violates exact-Class acyclicity.'));
+        }
+        validateCardinality(environment, declaration, classEdges, 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 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 === subject.key || edge.target.key === subject.key).length;
+            if (matchesFirst)
+                checkBound(first, first.incident, degree, subject, diagnostics);
+            if (matchesSecond && !sameIncidentEndpointContract(first, second)) {
+                checkBound(second, second.incident, degree, subject, diagnostics);
+            }
+        }
+        return;
+    }
+    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, 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, subject, diagnostics) {
+    const [minimum, maximum] = countBounds(count);
+    if (degree <= maximum && (degree >= minimum || !subject.minimum))
+        return;
+    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 &&
+        left.accepts.length === right.accepts.length &&
+        left.accepts.every((ref, index) => definitionRefIndex(ref) === definitionRefIndex(right.accepts[index])));
+}
+function countBounds(value) {
+    switch (value) {
+        case '0..*':
+            return [0, Number.POSITIVE_INFINITY];
+        case '1..*':
+            return [1, Number.POSITIVE_INFINITY];
+        case '0..1':
+            return [0, 1];
+        case '1':
+            return [1, 1];
+    }
+}
+function hasDirectedCycle(edges) {
+    const outgoing = new Map();
+    for (const edge of edges) {
+        const targets = outgoing.get(edge.source.key) ?? [];
+        targets.push(edge.target.key);
+        outgoing.set(edge.source.key, targets);
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (key) => {
+        if (visiting.has(key))
+            return true;
+        if (visited.has(key))
+            return false;
+        visiting.add(key);
+        for (const target of outgoing.get(key) ?? [])
+            if (visit(target))
+                return true;
+        visiting.delete(key);
+        visited.add(key);
+        return false;
+    };
+    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

@@ -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/validation/domain.js

@@ -0,0 +1,36 @@
+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);
+    const registry = createValueSchemaRegistry(context);
+    const diagnostics = [
+        ...context.diagnostics,
+        ...validateEmbeddedValueSchemas(schema, registry),
+        ...validateDefinitions(context, analysis),
+        ...validatePolicies(context, analysis),
+        ...validateViews(context),
+        ...validateCore(context, analysis, registry),
+    ];
+    return Object.freeze({
+        context,
+        analysis,
+        diagnostics: Object.freeze(orderAndDeduplicate(diagnostics)),
+    });
+}
+function orderAndDeduplicate(diagnostics) {
+    const unique = new Map();
+    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) => compareUnicode(left.pointer, right.pointer) ||
+        compareUnicode(left.code, right.code) ||
+        compareUnicode(left.message, right.message));
+}

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