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

package/dist/v1/schema/{policy/validation → validation/policy}/budgets.js

@@ -1,13 +1,7 @@
+import { policyObjectOrigin, policyVariableClass } from '../../../language/index.js';
+import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, } from '../../../language/policy/analysis/budgets.js';
 import { escapePointer } from './context.js';
-export const MAX_PATTERN_DEPTH = 4;
-export const MAX_BRANCHES = 8;
-export const MAX_VARIABLES = 4;
-export const MAX_EDGES = 6;
-export const MAX_REPEAT = 3;
-export const MAX_DOMAINS = 4;
-export const MAX_CHECK_DEPTH = 4;
-export const MAX_CHECK_LEAVES = 8;
-export const BRANCH_OVERFLOW = MAX_BRANCHES + 1;
+export { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, };
 export function validatePolicyBudgets(context) {
     for (const name of Object.keys(context.environment.candidate.policies)) {
         const measure = measurePolicy(context, name, new Set());
@@ -22,27 +16,13 @@ export function validatePolicyBudgets(context) {
         }
         const edgeMaximum = Math.max(0, ...measure.edgeCounts);
         if (edgeMaximum > MAX_EDGES) {
-            context.add('PL_BUDGET', pointer, `A normalized branch contains ${edgeMaximum} Edge predicates; the maximum is ${MAX_EDGES}.`);
+            context.add('PL_BUDGET', pointer, `A normalized branch contains ${edgeMaximum} graph predicates; the maximum is ${MAX_EDGES}.`);
         }
         if (measure.domains.size > MAX_DOMAINS) {
             context.add('PL_BUDGET', pointer, `Expanded Pattern references ${measure.domains.size} Domains; the maximum is ${MAX_DOMAINS}.`);
         }
     }
 }
-export function measureChecks(expression) {
-    if ('check' in expression)
-        return { depth: 1, branches: 1, leaves: 1 };
-    const { key, values } = checkOperands(expression);
-    const children = values.map(measureChecks);
-    const branches = key === 'allOf'
-        ? children.reduce((value, child) => saturatingProduct(value, child.branches), 1)
-        : children.reduce((value, child) => Math.min(BRANCH_OVERFLOW, value + child.branches), 0);
-    return {
-        depth: 1 + Math.max(0, ...children.map((child) => child.depth)),
-        branches,
-        leaves: children.reduce((value, child) => value + child.leaves, 0),
-    };
-}
 function measurePolicy(context, name, visiting) {
     if (visiting.has(name))
         return undefined;
@@ -66,11 +46,24 @@ function measurePolicy(context, name, visiting) {
     return combineMeasures('allOf' in declaration ? 'allOf' : 'anyOf', children);
 }
 function measurePattern(pattern, ownOrigin) {
+    if ('sameNode' in pattern)
+        return {
+            depth: 1,
+            edgeCounts: [1],
+            domains: new Set([
+                ownOrigin,
+                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
+            ]),
+        };
     if (isEdge(pattern)) {
         return {
             depth: 1,
             edgeCounts: [1],
-            domains: new Set([ownOrigin, pattern.class.origin]),
+            domains: new Set([
+                ownOrigin,
+                pattern.class.origin,
+                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
+            ]),
         };
     }
     if ('exists' in pattern) {
@@ -80,7 +73,10 @@ function measurePattern(pattern, ownOrigin) {
             edgeCounts: child.edgeCounts,
             domains: new Set([
                 ...child.domains,
-                ...pattern.exists.nodes.map((node) => node.class.origin),
+                ...pattern.exists.nodes.flatMap((node) => {
+                    const ref = policyVariableClass(node);
+                    return ref === undefined ? [] : [ref.origin];
+                }),
             ]),
         };
     }
@@ -113,20 +109,11 @@ function combineMeasures(key, children) {
     }
     return { depth, edgeCounts, domains };
 }
-function saturatingProduct(left, right) {
-    return Math.min(BRANCH_OVERFLOW, left * right);
-}
 function patternOperands(value) {
     return 'allOf' in value
         ? { key: 'allOf', values: value.allOf }
         : { key: 'anyOf', values: value.anyOf };
 }
-function checkOperands(value) {
-    return 'allOf' in value
-        ? { key: 'allOf', values: value.allOf }
-        : { key: 'anyOf', values: value.anyOf };
-}
 function isEdge(value) {
     return 'source' in value;
 }
-//# sourceMappingURL=budgets.js.map

package/dist/v1/schema/validation/policy/context.d.ts

@@ -0,0 +1,28 @@
+import type { ClassDefinition } from '../../../language/class/model/class.js';
+import type { PolicyExpression } from '../../../language/policy/model/policy.js';
+import type { DefinitionAnalysisResult } from '../../analysis/class.js';
+import type { SchemaDiagnostic, SchemaDiagnosticCode } from '../../diagnostic.js';
+import type { DomainResolutionContext } from '../../resolution/context.js';
+import type { IndexedClassDefinition } from '../../resolution/definition.index.js';
+import { type ClassRef, type PolicyRef } from '../../../addressing/index.js';
+export declare class PolicyValidationContext {
+    #private;
+    readonly environment: DomainResolutionContext;
+    readonly analysis: DefinitionAnalysisResult;
+    readonly diagnostics: SchemaDiagnostic[];
+    readonly normalized: Map<string, PolicyExpression>;
+    readonly allNodeClasses: readonly ClassRef[];
+    readonly concreteNodeClasses: readonly ClassRef[];
+    constructor(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult);
+    resolveNodeClass(ref: ClassRef, pointer: string): IndexedClassDefinition | undefined;
+    resolveEdge(ref: ClassRef, pointer: string): IndexedClassDefinition | undefined;
+    resolvePolicy(ref: PolicyRef, pointer: string): boolean;
+    isLocalPolicy(ref: PolicyRef): boolean;
+    edgeDeclaration(ref: ClassRef): Extract<ClassDefinition, {
+        readonly kind: 'edge';
+    }> | undefined;
+    /** Return true when candidate is the required Class or a same-kind descendant. */
+    classExtends(candidate: ClassRef, required: ClassRef): boolean;
+    add(code: SchemaDiagnosticCode, pointer: string, message: string, ref?: string): void;
+}
+export declare function escapePointer(value: string): string;

package/dist/v1/schema/{policy/validation → validation/policy}/context.js

@@ -1,37 +1,42 @@
+import { Key } from '../../../addressing/index.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
 import { diagnostic } from '../../diagnostic.js';
-import { schemaRefIndex, formatSchemaRef, } from '../../reference.js';
+const formatDefinitionRef = Key.of;
 export class PolicyValidationContext {
     environment;
     analysis;
     diagnostics = [];
     normalized = new Map();
     allNodeClasses;
+    concreteNodeClasses;
     #invalidPolicyRefs = new Set();
     constructor(environment, analysis) {
         this.environment = environment;
         this.analysis = analysis;
-        this.allNodeClasses = [...environment.definitions.values()]
-            .filter((value) => value.ref.kind === 'class' && value.family === 'node')
+        const nodeClasses = [...environment.definitions.values()].filter((value) => value.ref.kind === 'class' && value.kind === 'node');
+        this.allNodeClasses = nodeClasses.map((value) => value.ref);
+        this.concreteNodeClasses = nodeClasses
+            .filter((value) => !value.declaration.abstract)
             .map((value) => value.ref);
     }
     resolveNodeClass(ref, pointer) {
         const resolved = this.environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'node') {
-            this.add('PL_REF', pointer, `${formatSchemaRef(ref)} does not resolve to an owning/direct-dependency Node Class.`, formatSchemaRef(ref));
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
+            this.add('PL_REF', pointer, `${formatDefinitionRef(ref)} does not resolve to an owning/direct-dependency Node Class.`, formatDefinitionRef(ref));
             return undefined;
         }
         return resolved;
     }
     resolveEdge(ref, pointer) {
         const resolved = this.environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'edge') {
-            this.add('PL_REF', pointer, `${formatSchemaRef(ref)} does not resolve to an owning/direct-dependency Edge Class.`, formatSchemaRef(ref));
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
+            this.add('PL_REF', pointer, `${formatDefinitionRef(ref)} does not resolve to an owning/direct-dependency Edge Class.`, formatDefinitionRef(ref));
             return undefined;
         }
         return resolved;
     }
     resolvePolicy(ref, pointer) {
-        const key = `${pointer}\u0000${schemaRefIndex(ref)}`;
+        const key = `${pointer}\u0000${definitionRefIndex(ref)}`;
         if (this.#invalidPolicyRefs.has(key))
             return false;
         const declaration = this.environment.resolvePolicy(ref);
@@ -39,7 +44,7 @@ export class PolicyValidationContext {
             ref.kind !== 'policy' ||
             declaration === undefined) {
             this.#invalidPolicyRefs.add(key);
-            this.add('PL_REF', pointer, `${formatSchemaRef(ref)} is not an exact local named Policy ref.`, formatSchemaRef(ref));
+            this.add('PL_REF', pointer, `${formatDefinitionRef(ref)} is not an exact local named Policy ref.`, formatDefinitionRef(ref));
             return false;
         }
         return true;
@@ -51,41 +56,27 @@ export class PolicyValidationContext {
     }
     edgeDeclaration(ref) {
         const resolved = this.environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'edge') {
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
             return undefined;
         }
-        const declaration = resolved.declaration;
-        return declaration.family === 'edge' ? declaration : undefined;
+        return resolved.declaration;
     }
-    classImplements(candidate, required) {
-        const resolved = this.environment.resolveAny(candidate);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'node') {
-            return false;
-        }
-        const declaration = resolved.declaration;
-        if (declaration.family !== 'node')
-            return false;
-        return declaration.implements.some((parent) => this.interfaceExtends(parent, required));
-    }
-    interfaceExtends(candidate, required) {
-        if (schemaRefIndex(candidate) === schemaRefIndex(required))
+    /** Return true when candidate is the required Class or a same-kind descendant. */
+    classExtends(candidate, required) {
+        if (definitionRefIndex(candidate) === definitionRefIndex(required))
             return true;
         const visited = new Set();
         const visit = (ref) => {
-            const key = schemaRefIndex(ref);
-            if (key === schemaRefIndex(required))
+            const key = definitionRefIndex(ref);
+            if (key === definitionRefIndex(required))
                 return true;
             if (visited.has(key))
                 return false;
             visited.add(key);
             const resolved = this.environment.resolveAny(ref);
-            if (resolved === undefined ||
-                resolved.ref.kind !== 'interface' ||
-                (resolved.family !== 'node' && resolved.family !== 'both')) {
+            if (resolved === undefined || resolved.ref.kind !== 'class')
                 return false;
-            }
-            const declaration = resolved.declaration;
-            return declaration.extends.some(visit);
+            return resolved.declaration.extends.some(visit);
         };
         return visit(candidate);
     }
@@ -96,4 +87,3 @@ export class PolicyValidationContext {
 export function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=context.js.map

package/dist/v1/schema/validation/policy/objects.d.ts

@@ -0,0 +1,4 @@
+import type { PolicyObjectRef } from '../../../language/index.js';
+import type { PolicyValidationContext } from './context.js';
+import type { ObjectContract } from './typing.js';
+export declare function referenceContracts(validation: PolicyValidationContext, ref: PolicyObjectRef, pointer: string): readonly ObjectContract[] | undefined;

package/dist/v1/schema/validation/policy/objects.js

@@ -0,0 +1,70 @@
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
+const KERNEL_ORIGIN = 'kernel.astrale.ai';
+const PROJECTION_CLASS = nodeClassRef('Class');
+const PROJECTION_FUNCTION = nodeClassRef('Function');
+const PROJECTION_POLICY = nodeClassRef('Policy');
+const PROJECTION_VIEW = nodeClassRef('View');
+export function referenceContracts(validation, ref, pointer) {
+    const candidate = validation.environment.candidate;
+    const local = policyObjectOrigin(ref) === candidate.origin;
+    const direct = Object.values(candidate.dependencies).some((entry) => entry.origin === policyObjectOrigin(ref));
+    const owner = local
+        ? candidate
+        : direct
+            ? validation.environment.dependencies.get(policyObjectOrigin(ref))
+            : undefined;
+    if (owner === undefined)
+        return invalidPolicyObjectRef(validation, ref, pointer);
+    switch (ref.kind) {
+        case 'class': {
+            const resolved = validation.environment.resolve(ref);
+            return resolved?.ref.kind === ref.kind
+                ? [{ kind: 'exact', ref: PROJECTION_CLASS }]
+                : invalidPolicyObjectRef(validation, ref, pointer);
+        }
+        case 'method': {
+            const declaringClass = owner.classes[ref.owner.name];
+            const method = declaringClass?.kind === 'node' ? declaringClass.methods[ref.name] : undefined;
+            return method === undefined || method.inheritance === 'abstract'
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
+        }
+        case 'function':
+            return owner.functions[ref.name] === undefined
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
+        case 'policy':
+            return owner.policies[ref.name] === undefined
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_POLICY }];
+        case 'view':
+            return owner.views[ref.name] === undefined
+                ? invalidPolicyObjectRef(validation, ref, pointer)
+                : [{ kind: 'exact', ref: PROJECTION_VIEW }];
+        case 'core': {
+            const node = owner.core.nodes[ref.name];
+            if (node === undefined)
+                return invalidPolicyObjectRef(validation, ref, pointer);
+            const resolved = validation.environment.resolve(node.class);
+            const analyzed = validation.analysis.definitions.get(definitionRefIndex(node.class));
+            // Core validation owns invalid Core Class diagnostics. Avoid adding Policy noise for
+            // a Node that cannot materialize in the first place.
+            if (node.class.origin !== owner.origin ||
+                resolved?.ref.kind !== 'class' ||
+                resolved.kind !== 'node' ||
+                analyzed === undefined) {
+                return undefined;
+            }
+            return [{ kind: 'exact', ref: node.class }];
+        }
+    }
+    return invalidPolicyObjectRef(validation, ref, pointer);
+}
+function invalidPolicyObjectRef(validation, ref, pointer) {
+    validation.add('PL_REF', `${pointer}/ref`, `${policyObjectKey(ref)} is not an exact local or direct-dependency projected Policy object.`, policyObjectKey(ref));
+    return undefined;
+}
+function nodeClassRef(name) {
+    return { origin: KERNEL_ORIGIN, kind: 'class', name };
+}

package/dist/v1/schema/{policy/validation → validation/policy}/references.d.ts

@@ -1,3 +1,2 @@
 import type { PolicyValidationContext } from './context.js';
 export declare function validatePolicyReferences(context: PolicyValidationContext): void;
-//# sourceMappingURL=references.d.ts.map

package/dist/v1/schema/{policy/validation → validation/policy}/references.js

@@ -1,15 +1,24 @@
-import { normalizePolicyDeclaration, normalizePolicyPattern } from '../normalize.js';
-import { branchesOf, isConnected, targetMode } from './branches.js';
+import { branchesOf, isConnected, targetMode } from '../../../language/policy/analysis/branches.js';
+import { policyVariableClass } from '../../../language/policy/model/policy.js';
+import { normalizePolicyExpression, normalizePolicyPattern, } from '../../../language/policy/normalization/normalize.js';
 import { MAX_REPEAT, MAX_VARIABLES } from './budgets.js';
 import { escapePointer } from './context.js';
+import { referenceContracts } from './objects.js';
 export function validatePolicyReferences(context) {
     for (const [name, declaration] of Object.entries(context.environment.candidate.policies)) {
         const pointer = `/policies/${escapePointer(name)}`;
-        context.normalized.set(name, normalizePolicyDeclaration(declaration));
-        if ('match' in declaration)
-            validateMatch(context, name, declaration.match, pointer);
+        const expected = { origin: context.environment.candidate.origin, kind: 'policy', name };
+        if (declaration.ref.origin !== expected.origin ||
+            declaration.ref.kind !== expected.kind ||
+            declaration.ref.name !== expected.name) {
+            context.add('DV_REF_RESOLVES', `${pointer}/ref`, `Policy ref must be exactly ${expected.origin}:policy.${expected.name}.`);
+        }
+        const expression = declaration.expression;
+        context.normalized.set(name, normalizePolicyExpression(expression));
+        if ('match' in expression)
+            validateMatch(context, name, expression.match, pointer);
         else
-            validateComposition(context, declaration, pointer);
+            validateComposition(context, expression, pointer);
     }
     validateCycles(context);
 }
@@ -27,15 +36,20 @@ function validateMatch(context, name, pattern, pointer) {
     for (const [index, branch] of branches.entries()) {
         const mode = targetMode(branch);
         if (mode === undefined) {
-            context.add('PL_TARGET', `${pointer}/match`, `Normalized branch ${index} must use object or both source and target, without mixing target modes.`);
+            context.add('PL_TARGET', `${pointer}/match`, `Normalized branch ${index} must use object or at least one of source and target, without mixing target modes.`);
             continue;
         }
         if (!isConnected(branch)) {
-            context.add('PL_CONNECTIVITY', `${pointer}/match`, `Normalized ${mode} branch ${index} does not connect subject, its target terms, and every scoped term.`);
+            context.add('PL_CONNECTIVITY', `${pointer}/match`, `Normalized ${mode} branch ${index} does not connect subject, every referenced protected term, and every scoped term.`);
         }
     }
 }
 function validatePatternNode(context, pattern, pointer, scope, declarations, uses) {
+    if ('sameNode' in pattern) {
+        validateTerm(context, pattern.sameNode.left, `${pointer}/sameNode/left`, scope, uses);
+        validateTerm(context, pattern.sameNode.right, `${pointer}/sameNode/right`, scope, uses);
+        return;
+    }
     if (isEdge(pattern)) {
         context.resolveEdge(pattern.class, `${pointer}/class`);
         validateTerm(context, pattern.source, `${pointer}/source`, scope, uses);
@@ -64,13 +78,16 @@ function validatePatternNode(context, pattern, pointer, scope, declarations, use
                 context.add('PL_VARIABLE_SCOPE', `${declarationPointer}/variable/id`, `Variable ${id} is declared more than once; variable IDs are globally unique.`);
             }
             else {
-                declarations.set(id, { ref: node.class, pointer: declarationPointer });
+                declarations.set(id, { pointer: declarationPointer });
             }
             if (nested.has(id)) {
                 context.add('PL_VARIABLE_SCOPE', `${declarationPointer}/variable/id`, `Variable ${id} shadows an enclosing variable.`);
             }
             nested.add(id);
-            context.resolveNodeClass(node.class, `${declarationPointer}/class`);
+            const classRef = policyVariableClass(node);
+            if (classRef !== undefined) {
+                context.resolveNodeClass(classRef, `${declarationPointer}/${'class' in node ? 'class' : 'selector/class'}`);
+            }
         }
         validatePatternNode(context, pattern.exists.where, `${pointer}/exists/where`, nested, declarations, uses);
         return;
@@ -82,6 +99,8 @@ function validatePatternNode(context, pattern, pointer, scope, declarations, use
     values.forEach((child, index) => validatePatternNode(context, child, `${pointer}/${key}/${index}`, scope, declarations, uses));
 }
 function validateTerm(context, term, pointer, scope, uses) {
+    if (term.kind === 'ref')
+        referenceContracts(context, term.ref, pointer);
     if (term.kind === 'variable') {
         if (!scope.has(term.id)) {
             context.add('PL_VARIABLE_SCOPE', pointer, `Variable ${term.id} is free, escaped, or outside its defining exists scope.`);
@@ -111,8 +130,9 @@ function validateCycles(context) {
             return;
         visiting.add(name);
         const declaration = context.environment.candidate.policies[name];
-        if (declaration !== undefined && !('match' in declaration)) {
-            const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
+        const expression = declaration?.expression;
+        if (expression !== undefined && !('match' in expression)) {
+            const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
             for (const ref of refs) {
                 if (ref.origin === context.environment.candidate.origin && ref.kind === 'policy') {
                     visit(ref.name, [...stack, name]);
@@ -133,4 +153,3 @@ function patternOperands(value) {
 function isEdge(value) {
     return 'source' in value;
 }
-//# sourceMappingURL=references.js.map

package/dist/v1/schema/{policy/validation → validation/policy}/typing.d.ts

@@ -1,13 +1,10 @@
+import type { ClassRef } from '../../../addressing/index.js';
 import type { PolicyValidationContext } from './context.js';
-import { type ClassRef, type DefinitionRef, type InterfaceRef } from '../../reference.js';
 export type ObjectContract = {
     readonly kind: 'default';
 } | {
     readonly kind: 'exact';
     readonly ref: ClassRef;
-} | {
-    readonly kind: 'universal-interface';
-    readonly ref: InterfaceRef;
 };
 export declare class PolicyTyping {
     #private;
@@ -16,8 +13,7 @@ export declare class PolicyTyping {
     validatePolicies(): void;
     policyAccepts(name: string, object: ObjectContract): boolean;
     policyAcceptsEdge(name: string, source: ObjectContract, target: ObjectContract): boolean;
-    concreteEndpointClasses(accepts: readonly DefinitionRef[]): readonly ClassRef[];
-    endpointsOverlap(left: readonly DefinitionRef[], right: readonly DefinitionRef[]): boolean;
+    concreteEndpointClasses(accepts: readonly ClassRef[]): readonly ClassRef[];
+    endpointsOverlap(left: readonly ClassRef[], right: readonly ClassRef[]): boolean;
 }
-export declare function contractOfNodeDefinition(ref: DefinitionRef): ObjectContract;
-//# sourceMappingURL=typing.d.ts.map
+export declare function contractOfNodeDefinition(ref: ClassRef): ObjectContract;