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

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

@@ -91,7 +91,7 @@ export interface Method<out Projection = unknown> {
 export type ProjectionOfCallable<Value extends Function | Method> = Value extends Function<infer Projection> ? Projection : Value extends Method<infer Projection> ? Projection : never;
 /** 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 PolicyObjectAuthoring = Class | Function | Method | Policy | View | CoreNode;
 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 {

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

@@ -1,4 +1,3 @@
-import { MethodKey } from '../../../addressing/index.js';
 import { classConfiguration } from '../../class/authoring.js';
 import { escapeToken, fail } from '../../schema/diagnostic.js';
 import { isAuthoringValue } from '../../schema/handle.js';
@@ -42,7 +41,13 @@ function captureExecutables(input, context) {
         for (const [methodName, method] of Object.entries(methods ?? {})) {
             const pointer = `/classes/${escapeToken(definitionName)}/methods/${escapeToken(methodName)}`;
             assertMethod(method, pointer);
-            context.ownership.capture(method, MethodKey.of({ origin: context.origin, kind: 'class', name: definitionName }, methodName), pointer);
+            const ref = {
+                kind: 'method',
+                owner: { origin: context.origin, kind: 'class', name: definitionName },
+                name: methodName,
+            };
+            context.ownership.captureDefinition(method, ref, pointer);
+            context.capturePolicyObject(method, ref);
         }
     }
     for (const [name, value] of Object.entries(input.views ?? {})) {

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

@@ -2,7 +2,7 @@ import type { CoreRef, ClassRef, DefinitionRef, FunctionRef, PolicyRef, ViewRef
 import type { DomainDependency } from '../../../addressing/index.js';
 import type { ClassKind } from '../../../language/class/model/class.js';
 import type { CoreEndpointRef } from '../../../language/core/model/core.js';
-import type { PolicyObjectRef } from '../../../language/policy/model/policy.js';
+import type { PolicyObjectRef } from '../../../language/index.js';
 import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
 import type { DomainSchema, DomainSchemaIR } from '../../../schema/model/schema.js';
 import type { Function, PolicyObjectInput } from '../../callable/authoring.js';
@@ -40,5 +40,5 @@ export declare class BuilderContext {
     noteDomainEndpointReferences(schema: DomainSchemaIR): void;
     private assertVisible;
     private classKind;
-    private capturePolicyObject;
+    capturePolicyObject(value: object, ref: PolicyObjectRef): void;
 }

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

@@ -1,5 +1,6 @@
 import { compareDefinitionRefs, compareUnicode, definitionRefIndex, } from '../../../addressing/ordering.js';
 import { DEPENDENCY_ALIAS_PATTERN } from '../../../addressing/patterns.js';
+import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 import { graphNodePathSchema } from '../../../language/value/syntax/node-path/schema.js';
 import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
 import { requireDomainClosure } from '../../../schema/resolution/closure.js';
@@ -114,16 +115,18 @@ export class BuilderContext {
             : typeof value === 'object' && value !== null
                 ? (this.policyObjects.get(value) ?? this.ownership.definition(value))
                 : undefined;
-        const dependency = ref === undefined ? undefined : this.#dependencies.get(ref.origin)?.schema;
+        const origin = ref === undefined ? undefined : policyObjectOrigin(ref);
+        const dependency = origin === undefined ? undefined : this.#dependencies.get(origin)?.schema;
         const admitted = ref !== undefined &&
-            (ref.origin === this.origin
-                ? this.policyObjectRefs.has(definitionRefIndex(ref))
+            (origin === this.origin
+                ? this.policyObjectRefs.has(policyObjectKey(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.');
+            fail('BUILDER_POLICY_REF', pointer, 'Policy ref(...) must name one registered local or direct-dependency Definition, Function, Method, Policy, View, or Core Node.');
         }
-        if (ref.origin !== this.origin)
-            this.usedForeignOrigins.add(ref.origin);
+        const admittedOrigin = policyObjectOrigin(ref);
+        if (admittedOrigin !== this.origin)
+            this.usedForeignOrigins.add(admittedOrigin);
         return { ...ref };
     }
     resolveCoreEndpoint(value, pointer) {
@@ -196,7 +199,7 @@ export class BuilderContext {
     }
     capturePolicyObject(value, ref) {
         this.policyObjects.set(value, ref);
-        this.policyObjectRefs.add(definitionRefIndex(ref));
+        this.policyObjectRefs.add(policyObjectKey(ref));
     }
 }
 function escapePointer(value) {
@@ -234,6 +237,8 @@ function isPolicyObjectRef(value) {
     if (typeof value !== 'object' || value === null)
         return false;
     const candidate = value;
+    if (candidate.kind === 'method')
+        return isDefinitionRef(candidate.owner) && typeof candidate.name === 'string';
     return (typeof candidate.origin === 'string' &&
         typeof candidate.name === 'string' &&
         (candidate.kind === 'class' ||
@@ -252,6 +257,11 @@ function definitionRefsOf(schema) {
 }
 function hasPolicyObject(schema, ref) {
     switch (ref.kind) {
+        case 'method': {
+            const owner = schema.classes[ref.owner.name];
+            const method = owner?.kind === 'node' ? owner.methods[ref.name] : undefined;
+            return method !== undefined && method.inheritance !== 'abstract';
+        }
         case 'class':
             return Object.hasOwn(schema.classes, ref.name);
         case 'function':

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

@@ -1,4 +1,4 @@
-import type { PolicyObjectRef } from '../../../language/policy/model/policy.js';
+import type { PolicyObjectRef } from '../../../language/index.js';
 export declare class OwnershipCapture {
     #private;
     captureDefinition(value: object, ref: PolicyObjectRef, pointer: string): void;

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

@@ -1,3 +1,4 @@
+import { policyObjectKey } from '../../../language/index.js';
 import { fail } from '../../schema/diagnostic.js';
 const definitionOwners = new WeakMap();
 const semanticOwners = new WeakMap();
@@ -5,7 +6,7 @@ export class OwnershipCapture {
     #definitions = new Map();
     #owners = new Map();
     captureDefinition(value, ref, pointer) {
-        this.capture(value, `${ref.origin}:${ref.kind}.${ref.name}`, pointer);
+        this.capture(value, policyObjectKey(ref), pointer);
         this.#definitions.set(value, ref);
     }
     capture(value, owner, pointer) {

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

@@ -494,7 +494,7 @@ function policyTerm(input, variableOnly, path) {
     const value = object(input, 'Policy pattern term', path);
     if (!variableOnly && value.kind === 'ref') {
         exact(value, ['kind', 'ref'], 'Policy reference term', path);
-        definitionRef(value.ref, undefined, 'Policy reference term', `${path}/ref`);
+        policyObjectRef(value.ref, `${path}/ref`);
         return;
     }
     if (value.kind === 'variable') {
@@ -548,7 +548,7 @@ function policyCheckObject(input, objectPath) {
     }
     else if (target.kind === 'ref') {
         exact(target, ['kind', 'ref'], 'Callable Policy object ref', objectPath);
-        definitionRef(target.ref, undefined, 'Callable Policy object ref', `${objectPath}/ref`);
+        policyObjectRef(target.ref, `${objectPath}/ref`);
     }
     else
         invalid('Callable Policy object', undefined, `${objectPath}/kind`);
@@ -560,6 +560,17 @@ function coreEndpoint(input, label, path) {
     else
         definitionRef(value, 'core', label, path);
 }
+function policyObjectRef(input, path) {
+    const ref = object(input, 'Policy object ref', path);
+    if (ref.kind !== 'method') {
+        definitionRef(input, undefined, 'Policy object ref', path);
+        return;
+    }
+    exact(ref, ['kind', 'owner', 'name'], 'Policy Method ref', path);
+    definitionRef(ref.owner, 'class', 'Policy Method owner', `${path}/owner`);
+    if (typeof ref.name !== 'string' || !MEMBER_NAME_PATTERN.test(ref.name))
+        invalid('Policy Method name', undefined, `${path}/name`);
+}
 function definitionRef(input, kind, label, path) {
     if (!isDefinitionRef(input) || (kind !== undefined && input.kind !== kind))
         invalid(label, undefined, path);

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

@@ -1,9 +1,9 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { Key, PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
 import { compareUnicode } from '../../addressing/ordering.js';
+import { policyObjectOrigin, policyVariableClass } from '../../language/index.js';
 import { branchesOf, branchProduct, capBranches, isConnected, targetMode, termKey, } from '../../language/policy/analysis/branches.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 { policyVariableClass } from '../../language/policy/model/policy.js';
 import { normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.js';
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../language/value/syntax/node-path/schema.js';
@@ -348,15 +348,15 @@ function validatePolicyExpression(context, entry, expression, path, local) {
 }
 function validatePattern(context, expression, path, scope, declared) {
     if ('sameNode' in expression) {
-        validatePolicyTerm(expression.sameNode.left, `${path}/sameNode/left`, scope);
-        validatePolicyTerm(expression.sameNode.right, `${path}/sameNode/right`, scope);
+        validatePolicyTerm(context, expression.sameNode.left, `${path}/sameNode/left`, scope);
+        validatePolicyTerm(context, expression.sameNode.right, `${path}/sameNode/right`, scope);
         return;
     }
     if ('source' in expression) {
         if (context.classes.get(Key.of(expression.class))?.value.kind !== 'edge')
             fail(`${path}/class`, 'Policy pattern Class must resolve to an Edge Class.');
-        validatePolicyTerm(expression.source, `${path}/source`, scope);
-        validatePolicyTerm(expression.target, `${path}/target`, scope);
+        validatePolicyTerm(context, expression.source, `${path}/source`, scope);
+        validatePolicyTerm(context, expression.target, `${path}/target`, scope);
         if (expression.repeat !== undefined &&
             (!Number.isInteger(expression.repeat.min) ||
                 !Number.isInteger(expression.repeat.max) ||
@@ -389,10 +389,18 @@ function validatePattern(context, expression, path, scope, declared) {
         fail(path, 'Policy pattern composition must be non-empty.');
     values.forEach((value, index) => validatePattern(context, value, `${path}/${index}`, scope, declared));
 }
-function validatePolicyTerm(term, path, scope) {
+function validatePolicyTerm(context, term, path, scope) {
+    if (term.kind === 'ref' && term.ref.kind === 'method')
+        validatePolicyMethod(context, term.ref, `${path}/ref`);
     if (term.kind === 'variable' && !scope.has(term.id))
         fail(path, 'Policy variable is outside its declaring scope.');
 }
+function validatePolicyMethod(context, ref, path) {
+    const owner = context.classes.get(Key.of(ref.owner))?.value;
+    const method = owner?.kind === 'node' ? owner.methods.find((method) => method.name === ref.name) : undefined;
+    if (method === undefined || method.inheritance === 'abstract')
+        fail(path, 'Policy Method ref must name an exact concrete Method declaration.');
+}
 function validatePolicyCycles(entry, local, entryIndex) {
     const visiting = new Set();
     const visited = new Set();
@@ -422,6 +430,8 @@ function validateCallablePolicy(context, entry, expression, inputIndex, fields,
             fail(`${path}/check`, 'Callable Policy must reference a local named Policy.');
         const objects = 'check' in expression ? { object: expression.object } : expression.sameNode;
         for (const [side, object] of Object.entries(objects)) {
+            if (object.kind === 'ref' && object.ref.kind === 'method')
+                validatePolicyMethod(context, object.ref, `${path}/${side}/ref`);
             if (object.kind === 'self' && !instanceMethod)
                 fail(`${path}/${side}`, 'self is valid only for an instance Method.');
             if (object.kind === 'input' &&
@@ -590,7 +600,7 @@ function callableObjectContracts(context, entry, input, receiver, object) {
     }
     const projection = ref.kind === 'class'
         ? 'Class'
-        : ref.kind === 'function'
+        : ref.kind === 'function' || ref.kind === 'method'
             ? 'Function'
             : ref.kind === 'policy'
                 ? 'Policy'
@@ -893,7 +903,7 @@ function measureCompiledPattern(pattern, origin) {
             edgeCounts: [1],
             domains: new Set([
                 origin,
-                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [term.ref.origin] : []),
+                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
             ]),
         };
     if ('source' in pattern)
@@ -903,7 +913,7 @@ function measureCompiledPattern(pattern, origin) {
             domains: new Set([
                 origin,
                 pattern.class.origin,
-                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [term.ref.origin] : []),
+                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
             ]),
         };
     if ('exists' in pattern) {

package/dist/v1/language/index.d.ts

@@ -20,7 +20,7 @@ export type { Definition } from './definition.js';
 export type { ResolvedDefinition, ResolvedDefinitionOf } from './resolved.js';
 export type { Diagnostic, DiagnosticCode } from './validation/diagnostic.js';
 export type * from './policy/model/policy.js';
-export { policyVariableClass, policyVariableSelector } from './policy/model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './policy/model/policy.js';
 export type * from './policy/resolved.js';
 export type * from './view/model/view.js';
 export type * from './view/resolved.js';

package/dist/v1/language/index.js

@@ -1,3 +1,3 @@
 export { stateMachine } from './state/index.js';
 export { PropertyValues } from './class/property-values.js';
-export { policyVariableClass, policyVariableSelector } from './policy/model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './policy/model/policy.js';

package/dist/v1/language/policy/analysis/branches.js

@@ -1,5 +1,5 @@
 import { definitionRefIndex } from '../../../addressing/ordering.js';
-import { policyVariableSelector } from '../model/policy.js';
+import { policyObjectKey, policyVariableSelector } from '../model/policy.js';
 import { BRANCH_OVERFLOW } from './budgets.js';
 export function branchesOf(pattern, namespace) {
     const variables = collectVariableClasses(pattern, namespace);
@@ -62,7 +62,7 @@ export function termKey(term, namespace) {
     return term.kind === 'variable'
         ? variableKey(namespace, term.id)
         : term.kind === 'ref'
-            ? `ref:${definitionRefIndex(term.ref)}`
+            ? `ref:${term.ref.kind === 'method' ? policyObjectKey(term.ref) : definitionRefIndex(term.ref)}`
             : term.kind;
 }
 function branchesForNode(pattern, namespace, variables) {

package/dist/v1/language/policy/index.d.ts

@@ -1,4 +1,4 @@
 export type * from './model/policy.js';
-export { policyVariableClass, policyVariableSelector } from './model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './model/policy.js';
 export type * from './resolved.js';
 export * from './normalization/normalize.js';

package/dist/v1/language/policy/index.js

@@ -1,2 +1,2 @@
-export { policyVariableClass, policyVariableSelector } from './model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './model/policy.js';
 export * from './normalization/normalize.js';

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

@@ -1,4 +1,4 @@
-import type { CoreRef, ClassRef, FunctionRef, PolicyRef, ViewRef, DefinitionBase } from '../../../addressing/index.js';
+import type { CoreRef, ClassRef, FunctionRef, PolicyRef, ViewRef, DefinitionBase, MethodAddress } from '../../../addressing/index.js';
 export type PolicyPatternTerm = {
     readonly kind: 'subject';
 } | {
@@ -85,7 +85,10 @@ export interface PolicyDefinition extends DefinitionBase<PolicyRef> {
     readonly description?: string;
 }
 /** Local Domain members whose installed projection resolves through one exact member Path. */
-export type PolicyObjectRef = ClassRef | FunctionRef | PolicyRef | ViewRef | CoreRef;
+export type PolicyObjectRef = ClassRef | FunctionRef | PolicyRef | ViewRef | CoreRef | MethodAddress;
+/** Exact projected identity, including Class-owned Method declarations. */
+export declare function policyObjectKey(ref: PolicyObjectRef): string;
+export declare function policyObjectOrigin(ref: PolicyObjectRef): string;
 export type PolicyCheckObject = {
     readonly kind: 'self';
 } | {

package/dist/v1/language/policy/model/policy.js

@@ -7,3 +7,12 @@ export function policyVariableClass(variable) {
     const selector = policyVariableSelector(variable);
     return selector.kind === 'any' ? undefined : selector.class;
 }
+/** Exact projected identity, including Class-owned Method declarations. */
+export function policyObjectKey(ref) {
+    return ref.kind === 'method'
+        ? `${ref.owner.origin}:class.${ref.owner.name}.method.${ref.name}`
+        : `${ref.origin}:${ref.kind}.${ref.name}`;
+}
+export function policyObjectOrigin(ref) {
+    return ref.kind === 'method' ? ref.owner.origin : ref.origin;
+}

package/dist/v1/language/policy/normalization/normalize.js

@@ -1,6 +1,6 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { definitionRefIndex, compareDefinitionRefs } from '../../../addressing/ordering.js';
-import { policyVariableSelector } from '../model/policy.js';
+import { policyObjectKey, policyVariableSelector } from '../model/policy.js';
 const textEncoder = new TextEncoder();
 export function normalizePolicyExpression(value) {
     if ('match' in value) {
@@ -146,7 +146,7 @@ function termColor(term, colors) {
     if (term.kind === 'variable')
         return `variable:${colors.get(term.id) ?? '?'}`;
     if (term.kind === 'ref')
-        return `ref:${definitionRefIndex(term.ref)}`;
+        return `ref:${term.ref.kind === 'method' ? policyObjectKey(term.ref) : definitionRefIndex(term.ref)}`;
     return term.kind;
 }
 function collectFirstUseKeys(value, colors, result, prefix = '$') {

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

@@ -82,13 +82,13 @@ 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);
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref);
         return;
     }
     if ('source' in expression) {
         for (const term of [expression.source, expression.target])
             if (term.kind === 'ref')
-                add(term.ref);
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref);
         add(expression.class);
         return;
     }
@@ -108,13 +108,15 @@ 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);
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref);
         return;
     }
     if ('check' in expression) {
         add(expression.check);
         if (expression.object.kind === 'ref')
-            add(expression.object.ref);
+            add(expression.object.ref.kind === 'method'
+                ? expression.object.ref.owner
+                : expression.object.ref);
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;

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

@@ -63,6 +63,7 @@ const coreRefSchema = strictObject({
 const domainRefSchema = strictObject({ kind: literal('domain') });
 const coreEndpointRefSchema = discriminatedUnion('kind', [coreRefSchema, domainRefSchema]);
 const policyObjectRefSchema = discriminatedUnion('kind', [
+    strictObject({ kind: literal('method'), owner: classRefSchema, name: memberNameSchema }),
     classRefSchema,
     functionRefSchema,
     policyRefSchema,

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

@@ -1,5 +1,5 @@
+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 { policyVariableClass } from '../../../language/policy/model/policy.js';
 import { escapePointer } from './context.js';
 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) {
@@ -52,7 +52,7 @@ function measurePattern(pattern, ownOrigin) {
             edgeCounts: [1],
             domains: new Set([
                 ownOrigin,
-                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [term.ref.origin] : []),
+                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
             ]),
         };
     if (isEdge(pattern)) {
@@ -62,7 +62,7 @@ function measurePattern(pattern, ownOrigin) {
             domains: new Set([
                 ownOrigin,
                 pattern.class.origin,
-                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [term.ref.origin] : []),
+                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
             ]),
         };
     }

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

@@ -1,4 +1,4 @@
-import type { PolicyObjectRef } from '../../../language/policy/model/policy.js';
+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

@@ -1,6 +1,5 @@
-import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
-const formatDefinitionRef = Key.of;
+import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 const KERNEL_ORIGIN = 'kernel.astrale.ai';
 const PROJECTION_CLASS = nodeClassRef('Class');
 const PROJECTION_FUNCTION = nodeClassRef('Function');
@@ -8,12 +7,12 @@ const PROJECTION_POLICY = nodeClassRef('Policy');
 const PROJECTION_VIEW = nodeClassRef('View');
 export function referenceContracts(validation, ref, pointer) {
     const candidate = validation.environment.candidate;
-    const local = ref.origin === candidate.origin;
-    const direct = Object.values(candidate.dependencies).some((entry) => entry.origin === ref.origin);
+    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(ref.origin)
+            ? validation.environment.dependencies.get(policyObjectOrigin(ref))
             : undefined;
     if (owner === undefined)
         return invalidPolicyObjectRef(validation, ref, pointer);
@@ -24,6 +23,13 @@ export function referenceContracts(validation, ref, pointer) {
                 ? [{ 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)
@@ -56,7 +62,7 @@ export 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 or direct-dependency projected Policy object.`, formatDefinitionRef(ref));
+    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) {

package/package.json

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