@astrale-os/kernel-dsl 0.2.0-beta.14 → 0.2.0-beta.15

package/dist/v1/builder/class/authoring.d.ts

@@ -53,6 +53,7 @@ export interface EdgeClassOptions {
     readonly extends?: readonly EdgeClassReferenceInput[];
     readonly properties?: PropertyRecordInput;
     readonly policies?: {
+        readonly read?: Lazy<Policy>;
         readonly traverse?: Lazy<Policy>;
     };
     readonly constraints?: {

package/dist/v1/builder/class/authoring.js

@@ -114,7 +114,7 @@ function validateEdgeClassOptions(value) {
         'constraints',
     ]);
     if (value.policies !== undefined)
-        assertKnownKeys(value.policies, ['traverse']);
+        assertKnownKeys(value.policies, ['read', 'traverse']);
     if (value.constraints !== undefined)
         assertKnownKeys(value.constraints, ['noSelf', 'acyclic']);
 }
@@ -128,7 +128,7 @@ function validateUndirectedEdgeClassOptions(value) {
         'constraints',
     ]);
     if (value.policies !== undefined)
-        assertKnownKeys(value.policies, ['traverse']);
+        assertKnownKeys(value.policies, ['read', 'traverse']);
     if (value.constraints !== undefined)
         assertKnownKeys(value.constraints, ['noSelf']);
 }

package/dist/v1/builder/lowering/class.js

@@ -76,11 +76,16 @@ export class V1DefinitionCompiler {
             extends: this.parents(input.extends, 'edge', `${pointer}/extends`),
             properties: facet,
             ...contract,
-            policies: input.policies?.traverse === undefined
-                ? {}
-                : {
-                    traverse: this.policies.ref(input.policies.traverse, `${pointer}/policies/traverse`),
-                },
+            policies: {
+                ...(input.policies?.read === undefined
+                    ? {}
+                    : { read: this.policies.ref(input.policies.read, `${pointer}/policies/read`) }),
+                ...(input.policies?.traverse === undefined
+                    ? {}
+                    : {
+                        traverse: this.policies.ref(input.policies.traverse, `${pointer}/policies/traverse`),
+                    }),
+            },
         };
     }
     endpointBase(value, pointer) {

package/dist/v1/compiled/admission/accept.js

@@ -166,7 +166,7 @@ function compiledClass(input, values, path) {
         if (value.data !== undefined)
             dataDefinition(value.data, `${path}/data`);
         boundedString(value.icon, 1, 8000, 'Class icon', `${path}/icon`);
-        classPolicies(value.policies, true, `${path}/policies`);
+        classPolicies(value.policies, `${path}/policies`);
         const methodsPath = `${path}/methods`;
         const methods = array(value.methods, 'Class methods', methodsPath);
         for (const [index, method] of methods.entries())
@@ -174,7 +174,7 @@ function compiledClass(input, values, path) {
         unique(methods.map((method, index) => string(object(method, 'Compiled Method', `${methodsPath}/${index}`).name, 'Method name', `${methodsPath}/${index}/name`)), 'Class Methods', methodsPath);
     }
     else {
-        classPolicies(value.policies, false, `${path}/policies`);
+        classPolicies(value.policies, `${path}/policies`);
         edgeContract(value, path);
     }
     return value;
@@ -313,9 +313,9 @@ function propertyAuto(input, path) {
     if (value.set !== 'instant')
         invalid('Property auto setter', undefined, `${path}/set`);
 }
-function classPolicies(input, node, path) {
+function classPolicies(input, path) {
     const value = object(input, 'Class Policies', path);
-    exact(value, [], 'Class Policies', path, node ? ['read', 'traverse'] : ['traverse']);
+    exact(value, [], 'Class Policies', path, ['read', 'traverse']);
     if (value.read !== undefined)
         definitionRef(value.read, 'policy', 'Class read Policy', `${path}/read`);
     if (value.traverse !== undefined)

package/dist/v1/compiled/admission/semantics.js

@@ -248,7 +248,29 @@ function edgeRefines(context, child, parent) {
         return false;
     const refine = (a, b) => endpointRefines(context, child.endpoints[a], parent.endpoints[b]) &&
         countRefines(child.endpoints[a].incident, parent.endpoints[b].incident);
-    return (refine(0, 0) && refine(1, 1)) || (refine(0, 1) && refine(1, 0));
+    const direct = refine(0, 0) && refine(1, 1);
+    if (direct)
+        return true;
+    const reverse = refine(0, 1) && refine(1, 0);
+    return reverse && !hasEffectiveEdgePolicy(context, parent, new Set());
+}
+function hasEffectiveEdgePolicy(context, declaration, visited) {
+    if (declaration.policies.read !== undefined || declaration.policies.traverse !== undefined) {
+        return true;
+    }
+    for (const parentRef of declaration.extends) {
+        const key = Key.of(parentRef);
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        const parent = context.classes.get(key)?.value;
+        if (parent !== undefined &&
+            isCompiledEdge(parent) &&
+            hasEffectiveEdgePolicy(context, parent, visited)) {
+            return true;
+        }
+    }
+    return false;
 }
 function endpointRefines(context, child, parent) {
     return child.accepts.every((accepted) => classSatisfiesAny(context, accepted, parent.accepts));
@@ -502,16 +524,15 @@ function validatePolicyParity(context, entry, entryIndex, policies) {
         }
     }
     for (const [classIndex, definition] of entry.definitions.classes.entries()) {
-        if (definition.kind === 'node' && definition.policies.read !== undefined) {
-            if (!typing.policyAccepts(definition.policies.read.name, { kind: 'exact', ref: definition.ref })) {
-                fail(`/closure/${entryIndex}/definitions/classes/${classIndex}/policies/read`, 'Read Policy is incompatible with its protected Node Class.');
-            }
-        }
-        const traverse = definition.policies.traverse;
-        if (traverse !== undefined) {
+        for (const operation of ['read', 'traverse']) {
+            const policy = definition.policies[operation];
+            if (policy === undefined)
+                continue;
+            const path = `/closure/${entryIndex}/definitions/classes/${classIndex}/policies/${operation}`;
+            const label = operation === 'read' ? 'Read' : 'Traverse';
             if (definition.kind === 'node') {
-                if (!typing.policyAccepts(traverse.name, { kind: 'exact', ref: definition.ref })) {
-                    fail(`/closure/${entryIndex}/definitions/classes/${classIndex}/policies/traverse`, 'Traverse Policy is incompatible with its protected Node Class.');
+                if (!typing.policyAccepts(policy.name, { kind: 'exact', ref: definition.ref })) {
+                    fail(path, `${label} Policy is incompatible with its protected Node Class.`);
                 }
             }
             else if (isCompiledEdge(definition)) {
@@ -520,8 +541,8 @@ function validatePolicyParity(context, entry, entryIndex, policies) {
                     : definition.endpoints;
                 const sources = typing.concreteEndpointClasses(endpoints[0].accepts);
                 const targets = typing.concreteEndpointClasses(endpoints[1].accepts);
-                if (sources.some((source) => targets.some((target) => !typing.policyAcceptsEdge(traverse.name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })))) {
-                    fail(`/closure/${entryIndex}/definitions/classes/${classIndex}/policies/traverse`, 'Traverse Policy is incompatible with an accepted Edge endpoint pair.');
+                if (sources.some((source) => targets.some((target) => !typing.policyAcceptsEdge(policy.name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })))) {
+                    fail(path, `${label} Policy is incompatible with an accepted Edge endpoint pair.`);
                 }
             }
         }

package/dist/v1/domain/projection/classes.js

@@ -25,12 +25,10 @@ export function createClasses(definitions, validation) {
         }
         const shell = {};
         const policies = Object.freeze({
-            read: Object.freeze(definition.kind === 'node'
-                ? uniquePolicyRefs([
-                    ...parents.flatMap((parent) => parent.kind === 'node' ? [...parent.policies.read] : []),
-                    ...(definition.policies.read === undefined ? [] : [definition.policies.read]),
-                ])
-                : []),
+            read: Object.freeze(uniquePolicyRefs([
+                ...parents.flatMap((parent) => [...parent.policies.read]),
+                ...(definition.policies.read === undefined ? [] : [definition.policies.read]),
+            ])),
             traverse: Object.freeze(uniquePolicyRefs([
                 ...parents.flatMap((parent) => [...parent.policies.traverse]),
                 ...(definition.policies.traverse === undefined ? [] : [definition.policies.traverse]),

package/dist/v1/language/class/model/class.d.ts

@@ -9,6 +9,7 @@ export interface NodeClassPolicies {
     readonly traverse?: PolicyRef;
 }
 export interface EdgeClassPolicies {
+    readonly read?: PolicyRef;
     readonly traverse?: PolicyRef;
 }
 export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet, DataFacet {

package/dist/v1/language/class/resolved.d.ts

@@ -23,8 +23,9 @@ export interface ResolvedData {
     readonly owner: ResolvedClass<'node'>;
     readonly definition: DataDefinition;
 }
-export interface ResolvedClassPolicies<Kind extends ClassKind = ClassKind> {
-    readonly read: Kind extends 'node' ? readonly PolicyRef[] : readonly [];
+export interface ResolvedClassPolicies {
+    /** Effective read Policies for this Node or Edge Class. */
+    readonly read: readonly PolicyRef[];
     readonly traverse: readonly PolicyRef[];
 }
 export type ResolvedPropertyCollection<ByKey extends Readonly<Record<PropertyKey, ResolvedProperty<unknown>>> = Readonly<Record<PropertyKey, ResolvedProperty<unknown>>>, ByName extends Readonly<Record<string, ResolvedProperty<unknown>>> = Readonly<Record<never, never>>> = Readonly<ByName> & Iterable<ByKey[keyof ByKey]> & {
@@ -45,7 +46,7 @@ export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties ex
     readonly definition: Definition;
     readonly extends: Parents & readonly ResolvedClass<Kind>[];
     /** Effective inherited Policy conjunction, deduplicated by exact Policy ref. */
-    readonly policies: ResolvedClassPolicies<Kind>;
+    readonly policies: ResolvedClassPolicies;
     readonly data: Kind extends 'node' ? ResolvedData | undefined : undefined;
     readonly properties: Properties;
     readonly methods: Kind extends 'node' ? InstanceMethods : ResolvedMethodCollection<Record<never, never>>;

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

@@ -40,17 +40,15 @@ export function collectDomainDefinitionRefs(schema) {
 export function collectClassRefs(declaration, add) {
     declaration.extends.forEach(add);
     Object.values(declaration.properties).forEach((property) => collectValueDefinitionRefs(property.schema, add));
+    if (declaration.policies.read !== undefined)
+        add(declaration.policies.read);
+    if (declaration.policies.traverse !== undefined)
+        add(declaration.policies.traverse);
     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) {
     const endpoints = declaration.orientation === 'directed'

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

@@ -130,7 +130,30 @@ 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;
+    const reverse = refines(0, 1) && refines(1, 0);
+    return reverse && !hasEffectiveEdgePolicy(environment, parent, new Set());
+}
+function hasEffectiveEdgePolicy(environment, declaration, visited) {
+    if (declaration.policies.read !== undefined || declaration.policies.traverse !== undefined) {
+        return true;
+    }
+    for (const parentRef of declaration.extends) {
+        const key = definitionRefIndex(parentRef);
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        const parent = environment.resolveAny(parentRef);
+        if (parent !== undefined &&
+            parent.ref.kind === 'class' &&
+            parent.declaration.kind === 'edge' &&
+            hasEffectiveEdgePolicy(environment, parent.declaration, visited)) {
+            return true;
+        }
+    }
+    return false;
 }
 function endpointRefines(environment, child, parent) {
     return child.accepts.every((accepted) => classSatisfies(environment, accepted, parent.accepts));

package/dist/v1/schema/validation/domain.structure.js

@@ -203,6 +203,7 @@ const nodeClassPoliciesSchema = z.strictObject({
     traverse: policyRefSchema.optional(),
 });
 const edgeClassPoliciesSchema = z.strictObject({
+    read: policyRefSchema.optional(),
     traverse: policyRefSchema.optional(),
 });
 const nodeClassSchema = z.strictObject({

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

@@ -12,29 +12,17 @@ const PROJECTION_FUNCTION = nodeClassRef('Function');
 const PROJECTION_POLICY = nodeClassRef('Policy');
 const PROJECTION_VIEW = nodeClassRef('View');
 export function validateReadUses(context, typing) {
-    for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
-        if (declaration.kind !== 'node' || declaration.policies.read === undefined) {
-            continue;
-        }
-        const pointer = `/classes/${escapePointer(name)}/policies/read`;
-        const ref = declaration.policies.read;
-        if (!context.resolvePolicy(ref, pointer))
-            continue;
-        const object = {
-            kind: 'exact',
-            ref: { origin: context.environment.candidate.origin, kind: 'class', name },
-        };
-        if (!typing.policyAccepts(ref.name, object)) {
-            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of protected Class ${name}.`, formatDefinitionRef(ref));
-        }
-    }
+    validateClassPolicyUses(context, typing, 'read');
 }
 export function validateTraverseUses(context, typing) {
+    validateClassPolicyUses(context, typing, 'traverse');
+}
+function validateClassPolicyUses(context, typing, operation) {
     for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
-        const ref = declaration.policies.traverse;
+        const ref = declaration.policies[operation];
         if (ref === undefined)
             continue;
-        const pointer = `/classes/${escapePointer(name)}/policies/traverse`;
+        const pointer = `/classes/${escapePointer(name)}/policies/${operation}`;
         if (!context.resolvePolicy(ref, pointer))
             continue;
         if (declaration.kind === 'node') {
@@ -42,9 +30,9 @@ export function validateTraverseUses(context, typing) {
                 kind: 'exact',
                 ref: { origin: context.environment.candidate.origin, kind: 'class', name },
             };
-            if (!typing.policyAccepts(ref.name, object)) {
-                context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of traversed Node Class ${name}.`, formatDefinitionRef(ref));
-            }
+            if (typing.policyAccepts(ref.name, object))
+                continue;
+            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of ${operation} Node Class ${name}.`, formatDefinitionRef(ref));
             continue;
         }
         const endpoints = declaration.orientation === 'directed'
@@ -52,19 +40,9 @@ export function validateTraverseUses(context, typing) {
             : declaration.endpoints;
         const sources = typing.concreteEndpointClasses(endpoints[0].accepts);
         const targets = typing.concreteEndpointClasses(endpoints[1].accepts);
-        let accepted = true;
-        for (const source of sources) {
-            for (const target of targets) {
-                if (!typing.policyAcceptsEdge(ref.name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })) {
-                    accepted = false;
-                    break;
-                }
-            }
-            if (!accepted)
-                break;
-        }
+        const accepted = sources.every((source) => targets.every((target) => typing.policyAcceptsEdge(ref.name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })));
         if (!accepted) {
-            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every concrete source/target pair of traversed Edge Class ${name}.`, formatDefinitionRef(ref));
+            context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every concrete source/target pair of ${operation} Edge Class ${name}.`, formatDefinitionRef(ref));
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.14",
+  "version": "0.2.0-beta.15",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {