@astrale-os/kernel-dsl 0.2.0-beta.27 → 0.2.0-beta.29

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

@@ -91,7 +91,7 @@ export type ProjectionOfCallable<Value extends Function | Method> = Value extend
 /** Internal lowering access; Callable authoring handles expose no public configuration object. */
 export declare function callableConfiguration(value: Function | Method): CallableInput;
 export type PolicyObjectAuthoring = Class | Function | Policy | View | CoreNode;
-export type PolicyObjectInput = Lazy<PolicyObjectAuthoring>;
+export type PolicyObjectInput = Lazy<PolicyObjectAuthoring | PolicyObjectRef>;
 export declare function func<const Config extends FunctionInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth']>(config: Config): Function<CallableProjection<Input, Output, Auth, false, 'default'>>;
 export declare function method<const Config extends MethodInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Static extends boolean = Config extends {
     readonly static: true;

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

@@ -43,6 +43,7 @@ export interface NodeClassInput {
     readonly data?: MediaType;
     readonly methods?: Readonly<Record<string, Method>>;
     readonly icon?: string;
+    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
     readonly policies?: {
         readonly read?: Lazy<Policy>;
         readonly traverse?: Lazy<Policy>;
@@ -53,6 +54,7 @@ export interface EdgeClassOptions {
     readonly description?: string;
     readonly extends?: readonly EdgeClassReferenceInput[];
     readonly properties?: PropertyRecordInput;
+    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
     readonly policies?: {
         readonly read?: Lazy<Policy>;
         readonly traverse?: Lazy<Policy>;

package/dist/v1/builder/lowering/schema/context.js

@@ -50,22 +50,22 @@ export class BuilderContext {
         this.capturePolicyObject(value, ref);
     }
     capturePolicy(value, ref, pointer) {
-        this.ownership.capture(value, `${ref.origin}:policy.${ref.name}`, pointer);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.policies.set(value, ref);
         this.capturePolicyObject(value, ref);
     }
     captureCoreNode(value, slug, pointer) {
-        this.ownership.capture(value, `${this.origin}:core.${slug}`, pointer);
         const ref = { origin: this.origin, kind: 'core', name: slug };
+        this.ownership.captureDefinition(value, ref, pointer);
         this.coreNodes.set(value, ref);
         this.capturePolicyObject(value, ref);
     }
     captureFunction(value, ref, pointer) {
-        this.ownership.capture(value, `${ref.origin}:function.${ref.name}`, pointer);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
     captureView(value, ref, pointer) {
-        this.ownership.capture(value, `${ref.origin}:view.${ref.name}`, pointer);
+        this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
     resolveClass(input, kind, pointer) {
@@ -112,13 +112,18 @@ export class BuilderContext {
         const ref = isPolicyObjectRef(value)
             ? value
             : typeof value === 'object' && value !== null
-                ? this.policyObjects.get(value)
+                ? (this.policyObjects.get(value) ?? this.ownership.definition(value))
                 : undefined;
-        if (ref === undefined ||
-            ref.origin !== this.origin ||
-            !this.policyObjectRefs.has(definitionRefIndex(ref))) {
-            fail('BUILDER_POLICY_REF', pointer, 'Policy ref(...) must name one registered local Definition, Function, Policy, View, or Core Node.');
+        const dependency = ref === undefined ? undefined : this.#dependencies.get(ref.origin)?.schema;
+        const admitted = ref !== undefined &&
+            (ref.origin === this.origin
+                ? this.policyObjectRefs.has(definitionRefIndex(ref))
+                : dependency !== undefined && hasPolicyObject(dependency, ref));
+        if (!admitted || ref === undefined) {
+            fail('BUILDER_POLICY_REF', pointer, 'Policy ref(...) must name one registered local or direct-dependency Definition, Function, Policy, View, or Core Node.');
         }
+        if (ref.origin !== this.origin)
+            this.usedForeignOrigins.add(ref.origin);
         return { ...ref };
     }
     resolveCoreEndpoint(value, pointer) {
@@ -245,3 +250,17 @@ function definitionRefsOf(schema) {
     }
     return refs.sort(compareDefinitionRefs);
 }
+function hasPolicyObject(schema, ref) {
+    switch (ref.kind) {
+        case 'class':
+            return Object.hasOwn(schema.classes, ref.name);
+        case 'function':
+            return Object.hasOwn(schema.functions, ref.name);
+        case 'policy':
+            return Object.hasOwn(schema.policies, ref.name);
+        case 'view':
+            return Object.hasOwn(schema.views, ref.name);
+        case 'core':
+            return Object.hasOwn(schema.core.nodes, ref.name);
+    }
+}

package/dist/v1/builder/lowering/schema/ownership.d.ts

@@ -1,8 +1,8 @@
-import type { DefinitionRef } from '../../../addressing/index.js';
+import type { PolicyObjectRef } from '../../../language/policy/model/policy.js';
 export declare class OwnershipCapture {
     #private;
-    captureDefinition(value: object, ref: DefinitionRef, pointer: string): void;
+    captureDefinition(value: object, ref: PolicyObjectRef, pointer: string): void;
     capture(value: object, owner: string, pointer: string): void;
-    definition(value: object): DefinitionRef | undefined;
+    definition(value: object): PolicyObjectRef | undefined;
     commit(): void;
 }

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

@@ -178,6 +178,10 @@ function policyKey(value) {
 }
 function validateClassFacets(context) {
     for (const located of context.classes.values()) {
+        if (located.value.abstract &&
+            (located.value.policies.read !== undefined || located.value.policies.traverse !== undefined)) {
+            fail(`${located.pointer}/policies`, 'Abstract Classes cannot declare observation Policies.');
+        }
         for (const [index, property] of located.value.properties.entries()) {
             const path = `${located.pointer}/properties/${index}`;
             if (property.auto !== undefined) {
@@ -252,26 +256,7 @@ function edgeRefines(context, child, parent) {
     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;
+    return refine(0, 1) && refine(1, 0);
 }
 function endpointRefines(context, child, parent) {
     return child.accepts.every((accepted) => classSatisfiesAny(context, accepted, parent.accepts));
@@ -438,11 +423,8 @@ function validateCallablePolicy(context, entry, expression, inputIndex, fields,
                 !isSingleNodePathField(context, entry, inputIndex, object.field))
                 fail(`${path}/object`, 'Callable Policy input target must be a direct required single-Node Path field.');
         }
-        if (object.kind === 'ref') {
-            if (object.ref.origin !== entry.origin ||
-                context.definitions.get(Key.of(object.ref)) === undefined)
-                fail(`${path}/object/ref`, 'Callable Policy object refs must name an exact local Definition.');
-        }
+        // validateClosure already establishes that object refs name existing local
+        // or exact direct-dependency Definitions. Named Policy execution stays local.
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;

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

@@ -1,4 +1,4 @@
-import { compareUnicode, Key, MethodKey as MethodKeyValue, PropertyKey as PropertyKeyValue, } from '../../addressing/index.js';
+import { Key, MethodKey as MethodKeyValue, PropertyKey as PropertyKeyValue, } from '../../addressing/index.js';
 import { acceptPropertyValues } from '../../language/class/property-values.js';
 import { appendPointer } from '../../language/value/syntax/pointer.js';
 import { createMethodCollection, createPropertyCollection } from '../namespace/member-collection.js';
@@ -24,16 +24,6 @@ export function createClasses(definitions, validation) {
             throw new TypeError(`Class ${key} extends a Class of another graph kind.`);
         }
         const shell = {};
-        const policies = Object.freeze({
-            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]),
-            ])),
-        });
         const effectiveProperties = new Map();
         const effectiveMethods = new Map();
         let inheritedData;
@@ -102,7 +92,7 @@ export function createClasses(definitions, validation) {
             abstract: definition.abstract,
             definition,
             extends: Object.freeze(parents),
-            policies,
+            policies: definition.policies,
             data: definition.kind === 'node' ? (ownData ?? inheritedData) : undefined,
             properties: createPropertyCollection(effectiveProperties.values()),
             methods: createMethodCollection(instanceMethods),
@@ -110,7 +100,6 @@ export function createClasses(definitions, validation) {
             self: Object.freeze({
                 data: definition.kind === 'node' ? ownData : undefined,
                 properties: createPropertyCollection(ownProperties),
-                policies: definition.policies,
                 methods: createMethodCollection(ownInstanceMethods),
                 static: Object.freeze({ methods: createMethodCollection(ownStaticMethods) }),
             }),
@@ -138,12 +127,6 @@ export function createClasses(definitions, validation) {
         resolve(definition.ref);
     return resolved;
 }
-function uniquePolicyRefs(values) {
-    const result = new Map();
-    for (const value of values)
-        result.set(Key.of(value), value);
-    return [...result.values()].sort((left, right) => compareUnicode(Key.of(left), Key.of(right)));
-}
 function validateProperties(abstract, properties, input) {
     if (abstract) {
         return [

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

@@ -1,5 +1,5 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
-import type { ClassRef, DefinitionKey, Key, PolicyRef, PropertyKey } from '../../addressing/index.js';
+import type { ClassRef, DefinitionKey, Key, PropertyKey } from '../../addressing/index.js';
 import type { ResolvedMethodCollection } from '../callable/resolved.js';
 import type { StateTopology } from '../state/index.js';
 import type { Diagnostic } from '../validation/diagnostic.js';
@@ -25,11 +25,6 @@ export interface ResolvedData {
     readonly owner: ResolvedClass<'node'>;
     readonly definition: DataDefinition;
 }
-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]> & {
     readonly byKey: ByKey;
     get<Key extends keyof ByKey>(key: Key): ByKey[Key];
@@ -47,8 +42,8 @@ export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties ex
     readonly abstract: boolean;
     readonly definition: Definition;
     readonly extends: Parents & readonly ResolvedClass<Kind>[];
-    /** Effective inherited Policy conjunction, deduplicated by exact Policy ref. */
-    readonly policies: ResolvedClassPolicies;
+    /** Local observation Policies; Class inheritance never contributes an attachment. */
+    readonly policies: Definition['policies'];
     readonly data: Kind extends 'node' ? ResolvedData | undefined : undefined;
     readonly properties: Properties;
     readonly methods: Kind extends 'node' ? InstanceMethods : ResolvedMethodCollection<Record<never, never>>;
@@ -58,8 +53,6 @@ export interface ResolvedClass<Kind extends ClassKind = ClassKind, Properties ex
     readonly self: {
         readonly data: Kind extends 'node' ? ResolvedData | undefined : undefined;
         readonly properties: SelfProperties;
-        /** Policies declared by this exact Class only. */
-        readonly policies: Definition['policies'];
         readonly methods: Kind extends 'node' ? SelfInstanceMethods : ResolvedMethodCollection<Record<never, never>>;
         readonly static: {
             readonly methods: Kind extends 'node' ? SelfStaticMethods : ResolvedMethodCollection<Record<never, never>>;

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

@@ -15,6 +15,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') {
@@ -159,27 +163,7 @@ function edgeContractRefines(environment, child, parent) {
     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;
+    return refines(0, 1) && refines(1, 0);
 }
 function endpointRefines(environment, child, parent) {
     return child.accepts.every((accepted) => classSatisfies(environment, accepted, parent.accepts));

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

@@ -122,7 +122,14 @@ function visitChecks(validation, typing, expression, context, pointer) {
 }
 function referenceContracts(validation, ref, pointer) {
     const candidate = validation.environment.candidate;
-    if (ref.origin !== candidate.origin)
+    const local = ref.origin === candidate.origin;
+    const direct = Object.values(candidate.dependencies).some((entry) => entry.origin === ref.origin);
+    const owner = local
+        ? candidate
+        : direct
+            ? validation.environment.dependencies.get(ref.origin)
+            : undefined;
+    if (owner === undefined)
         return invalidPolicyObjectRef(validation, ref, pointer);
     switch (ref.kind) {
         case 'class': {
@@ -132,26 +139,26 @@ function referenceContracts(validation, ref, pointer) {
                 : invalidPolicyObjectRef(validation, ref, pointer);
         }
         case 'function':
-            return candidate.functions[ref.name] === undefined
+            return owner.functions[ref.name] === undefined
                 ? invalidPolicyObjectRef(validation, ref, pointer)
                 : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
         case 'policy':
-            return candidate.policies[ref.name] === undefined
+            return owner.policies[ref.name] === undefined
                 ? invalidPolicyObjectRef(validation, ref, pointer)
                 : [{ kind: 'exact', ref: PROJECTION_POLICY }];
         case 'view':
-            return candidate.views[ref.name] === undefined
+            return owner.views[ref.name] === undefined
                 ? invalidPolicyObjectRef(validation, ref, pointer)
                 : [{ kind: 'exact', ref: PROJECTION_VIEW }];
         case 'core': {
-            const node = candidate.core.nodes[ref.name];
+            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 !== candidate.origin ||
+            if (node.class.origin !== owner.origin ||
                 resolved?.ref.kind !== 'class' ||
                 resolved.kind !== 'node' ||
                 analyzed === undefined) {
@@ -163,7 +170,7 @@ function referenceContracts(validation, ref, pointer) {
     return invalidPolicyObjectRef(validation, ref, pointer);
 }
 function invalidPolicyObjectRef(validation, ref, pointer) {
-    validation.add('PL_REF', `${pointer}/ref`, `${formatDefinitionRef(ref)} is not an exact local projected Policy object.`, formatDefinitionRef(ref));
+    validation.add('PL_REF', `${pointer}/ref`, `${formatDefinitionRef(ref)} is not an exact local or direct-dependency projected Policy object.`, formatDefinitionRef(ref));
     return undefined;
 }
 function selfContracts(validation, context, pointer) {

package/package.json

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