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

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

@@ -1,6 +1,6 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
-import type { FunctionAuth, MethodInheritance } from '../../language/callable/model/callable.js';
+import type { FunctionAuth } from '../../language/callable/model/callable.js';
 import type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../../language/policy/model/policy.js';
 import type { Class } from '../class/authoring.js';
 import type { ValueSchemaInput } from '../class/property.js';
@@ -43,10 +43,8 @@ export interface CallableInputBase {
     readonly description?: string;
     readonly input: ValueSchemaInput;
     readonly output: CallableOutputInput;
-    readonly static?: boolean;
-    readonly inheritance?: MethodInheritance;
 }
-export type CallableInput = CallableInputBase & ({
+type ConcreteCallableInput = CallableInputBase & ({
     readonly auth: 'anonymous';
     readonly policy?: never;
 } | {
@@ -56,18 +54,27 @@ export type CallableInput = CallableInputBase & ({
     readonly auth: 'authorized';
     readonly policy?: CallablePolicyBuilder;
 });
-export type FunctionInput = CallableInput & {
+export type FunctionInput = ConcreteCallableInput & {
     readonly static?: never;
-    readonly inheritance?: never;
+    readonly abstract?: never;
 };
-export type MethodInput = CallableInput;
-export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Inheritance extends MethodInheritance = MethodInheritance> {
+export type MethodInput = (ConcreteCallableInput & {
+    readonly static?: boolean;
+    readonly abstract?: false;
+}) | (CallableInputBase & {
+    readonly static?: boolean;
+    readonly abstract: true;
+    readonly auth: FunctionAuth;
+    readonly policy?: never;
+});
+export type CallableInput = FunctionInput | MethodInput;
+export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Abstract extends boolean = boolean> {
     readonly [CALLABLE_PROJECTION_VALUE]: true;
     readonly input: Input;
     readonly output: Output;
     readonly auth: Auth;
     readonly static: Static;
-    readonly inheritance: Inheritance;
+    readonly abstract: Abstract;
 }
 type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
 type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
@@ -91,14 +98,14 @@ 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 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, false>>;
 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;
-} ? true : false, Inheritance extends MethodInheritance = Config extends {
-    readonly inheritance: infer Value extends MethodInheritance;
-} ? Value : 'default'>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Inheritance>>;
+} ? true : false, Abstract extends boolean = Config extends {
+    readonly abstract: infer Value extends boolean;
+} ? Value : false>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract>>;
 export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
     readonly kind: 'input';
 }>;

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

@@ -16,7 +16,7 @@ export function func(config) {
         'auth',
         'policy',
         'static',
-        'inheritance',
+        'abstract',
     ]);
     const value = authoringValue('function', {});
     callableInputs.set(value, { ...config });
@@ -30,7 +30,7 @@ export function method(config) {
         'auth',
         'policy',
         'static',
-        'inheritance',
+        'abstract',
     ]);
     const value = authoringValue('method', {});
     callableInputs.set(value, { ...config });

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

@@ -139,16 +139,32 @@ type OwnMethodProjectionsOf<Input, Static extends boolean> = {
     [Name in keyof MethodFieldsOf<Input>]: MethodFieldsOf<Input>[Name] extends infer Value extends Method ? MethodIsStatic<Value> extends Static ? AuthoredMethodProjection<Value, Extract<Name, string>> : never : never;
 }[keyof MethodFieldsOf<Input>];
 type BindMethodOwners<Entries, Owner> = Entries extends AuthoredMethodProjection<infer Value, infer Name, infer ExistingOwner> ? AuthoredMethodProjection<Value, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner> : Entries;
-type EffectiveMethodsOfReference<Value, Static extends boolean> = ResolveCompactLazy<Value> extends infer Resolved ? Resolved extends NodeClass<infer Config> ? Config extends {
-    readonly effectiveInstanceMethods: infer InstanceMethods;
-    readonly effectiveStaticMethods: infer StaticMethods;
-} ? BindMethodOwners<Static extends true ? StaticMethods : InstanceMethods, ClassOwnerProjectionOf<Resolved>> : never : Resolved extends ResolvedClass<'node'> ? Static extends true ? Resolved['static']['methods']['byKey'][keyof Resolved['static']['methods']['byKey']] : Resolved['methods']['byKey'][keyof Resolved['methods']['byKey']] : never : never;
+type AbstractMethodEntries<Entry> = Entry extends AuthoredMethodProjection<infer Value> ? ProjectionOfCallable<Value> extends {
+    readonly abstract: true;
+} ? Entry : never : Entry extends {
+    readonly abstract: true;
+} ? Entry : never;
+type AbstractMethodsOfReference<Value, Static extends boolean, Seen = never> = Value extends Seen ? never : ResolveCompactLazy<Value> extends infer Resolved ? Resolved extends NodeClass<infer Config> ? Config extends {
+    readonly abstractInstanceMethods: infer InstanceMethods;
+    readonly abstractStaticMethods: infer StaticMethods;
+} ? BindMethodOwners<Static extends true ? StaticMethods : InstanceMethods, ClassOwnerProjectionOf<Resolved>> : never : Resolved extends ResolvedClass<'node'> ? ResolvedAbstractMethods<Resolved, Static, Seen | Value> : never : never;
+type ResolvedOwnAbstractMethods<Value extends ResolvedClass<'node'>, Static extends boolean> = AbstractMethodEntries<Static extends true ? Value['self']['static']['methods']['byKey'][keyof Value['self']['static']['methods']['byKey']] : Value['self']['methods']['byKey'][keyof Value['self']['methods']['byKey']]>;
+type ParentTupleMembers<Parents> = Parents extends readonly [infer Parent, ...infer Rest] ? Parent | ParentTupleMembers<Rest> : never;
+type ResolvedParents<Value> = Value extends {
+    readonly extends: infer Parents;
+} ? ParentTupleMembers<Parents> : never;
+type ResolvedAbstractMethods<Value extends ResolvedClass<'node'>, Static extends boolean, Seen> = ResolvedOwnAbstractMethods<Value, Static> | WithoutMethodNames<AbstractMethodsOfReference<ResolvedParents<Value>, Static, Seen>, MethodNames<ResolvedOwnAbstractMethods<Value, Static>>>;
 type ParentMethodProjectionsOf<Input, Static extends boolean> = Input extends {
     readonly extends?: readonly (infer Parent)[];
-} ? EffectiveMethodsOfReference<Parent, Static> : never;
-type EffectiveMethodProjectionsOf<Input, Static extends boolean> = OwnMethodProjectionsOf<Input, Static> | (ParentMethodProjectionsOf<Input, Static> extends infer Entry ? Entry extends {
+} ? AbstractMethodsOfReference<Parent, Static> : never;
+type MethodNames<Entry> = Entry extends {
     readonly name: infer Name;
-} ? Name extends OwnMethodProjectionsOf<Input, Static>['name'] ? never : Entry : never : never);
+} ? Name : never;
+type WithoutMethodNames<Entry, Names> = Entry extends {
+    readonly name: infer Name;
+} ? Name extends Names ? never : Entry : never;
+type AbstractMethodProjectionsOf<Input, Static extends boolean> = AbstractMethodEntries<OwnMethodProjectionsOf<Input, Static>> | WithoutMethodNames<ParentMethodProjectionsOf<Input, Static>, AbstractMethodEntries<OwnMethodProjectionsOf<Input, Static>>['name']>;
+type EffectiveMethodProjectionsOf<Input, Static extends boolean> = OwnMethodProjectionsOf<Input, Static> | WithoutMethodNames<ParentMethodProjectionsOf<Input, Static>, keyof MethodFieldsOf<Input>>;
 type ClassDepthOf<Value> = ResolveCompactLazy<Value> extends infer Resolved ? Resolved extends NodeClass<infer Config> ? Config extends {
     readonly depth: infer Depth extends number;
 } ? Depth : 0 : Resolved extends DirectedEdgeClass<infer Config> | UndirectedEdgeClass<infer Config> ? Config extends {
@@ -222,13 +238,13 @@ type OwnerErasedPropertyProjection<Entry> = Entry extends AuthoredPropertyProjec
     readonly key: Key;
     readonly state?: State;
 } : never;
-type OwnerErasedMethodProjection<Entry> = Entry extends AuthoredMethodProjection<infer Value, infer Name, unknown> ? AuthoredMethodProjection<Value, Name, unknown> : Entry extends ResolvedMethod<infer Input, infer Output, infer Static, infer Inheritance, infer Auth, infer _Policy, infer Key> & {
+type OwnerErasedMethodProjection<Entry> = Entry extends AuthoredMethodProjection<infer Value, infer Name, unknown> ? AuthoredMethodProjection<Value, Name, unknown> : Entry extends ResolvedMethod<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer _Policy, infer Key> & {
     readonly name: infer Name;
 } ? {
     readonly input: Input;
     readonly output: Output;
     readonly static: Static;
-    readonly inheritance: Inheritance;
+    readonly abstract: Abstract;
     readonly auth: Auth;
     readonly name: Name;
     readonly key: Key;
@@ -274,6 +290,8 @@ type CompactNodeInput<Input extends NodeClassInput> = {
         readonly methods?: infer Value;
     } ? NonNullable<Value> : Readonly<Record<never, never>> : Readonly<Record<never, never>>;
     readonly effectiveProperties: EffectivePropertyProjectionsOf<Input>;
+    readonly abstractInstanceMethods: AbstractMethodProjectionsOf<Input, false>;
+    readonly abstractStaticMethods: AbstractMethodProjectionsOf<Input, true>;
     readonly effectiveInstanceMethods: EffectiveMethodProjectionsOf<Input, false>;
     readonly effectiveStaticMethods: EffectiveMethodProjectionsOf<Input, true>;
 };

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

@@ -20,12 +20,12 @@ export class V1CallableCompiler {
             fail('BUILDER_CALLABLE_POLICY_AUTH', `${placement.pointer}/policy`, 'Only an authorized Function or Method may declare a Policy check.');
         }
         const method = placement.kind !== 'function';
-        if (!method && (config.static !== undefined || config.inheritance !== undefined)) {
-            fail('BUILDER_CALLABLE_PLACEMENT', placement.pointer, 'A standalone Function cannot declare Method staticness or inheritance.');
+        if (!method && (config.static !== undefined || config.abstract !== undefined)) {
+            fail('BUILDER_CALLABLE_PLACEMENT', placement.pointer, 'A standalone Function cannot declare Method staticness or abstractness.');
         }
         const isStatic = method ? (config.static ?? false) : undefined;
-        const inheritance = method ? (config.inheritance ?? 'default') : undefined;
-        if (inheritance === 'abstract' && config.policy !== undefined) {
+        const isAbstract = method ? (config.abstract ?? false) : undefined;
+        if (isAbstract === true && config.policy !== undefined) {
             fail('BUILDER_ABSTRACT_POLICY', `${placement.pointer}/policy`, 'An abstract Method cannot declare a Policy check.');
         }
         const input = this.values.schema(config.input, 'callable-input', `${placement.pointer}/input`);
@@ -46,7 +46,7 @@ export class V1CallableCompiler {
         return {
             ...contract,
             static: isStatic,
-            inheritance: inheritance,
+            abstract: isAbstract,
         };
     }
     compileOutput(value, pointer) {

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.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/builder/schema/projection.d.ts

@@ -13,11 +13,11 @@ export interface PropertyProjection<Value = unknown, Required extends boolean =
     readonly key: Key;
     readonly state?: State;
 }
-export interface MethodProjection<Input = unknown, Output = unknown, Static extends boolean = boolean, Inheritance extends language.MethodInheritance = language.MethodInheritance, Auth extends language.FunctionAuth = language.FunctionAuth, Name extends string = string, Key extends language.MethodKey = language.MethodKey> {
+export interface MethodProjection<Input = unknown, Output = unknown, Static extends boolean = boolean, Abstract extends boolean = boolean, Auth extends language.FunctionAuth = language.FunctionAuth, Name extends string = string, Key extends language.MethodKey = language.MethodKey> {
     readonly input: Input;
     readonly output: Output;
     readonly static: Static;
-    readonly inheritance: Inheritance;
+    readonly abstract: Abstract;
     readonly auth: Auth;
     readonly name: Name;
     readonly key: Key;
@@ -251,20 +251,20 @@ type CallableOutputValue<Value extends Method | Function> = CallableConfig<Value
 type CallableStaticOf<Value extends Method> = CallableConfig<Value> extends {
     readonly static: true;
 } ? true : false;
-type CallableInheritanceOf<Value extends Method> = CallableConfig<Value> extends {
-    readonly inheritance: infer Inheritance extends language.MethodInheritance;
-} ? Inheritance : 'default';
+type CallableAbstractOf<Value extends Method> = CallableConfig<Value> extends {
+    readonly abstract: infer Abstract extends boolean;
+} ? Abstract : false;
 type CallableAuthOf<Value extends Method | Function> = CallableConfig<Value>['auth'];
-type MethodProjectionOfEntry<Origin extends string, OwnerName extends string, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodEntry<unknown, infer Name, infer Value> ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableInheritanceOf<Value>, CallableAuthOf<Value>, Name, language.MethodKey<Origin, OwnerName, Name>> : never;
+type MethodProjectionOfEntry<Origin extends string, OwnerName extends string, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodEntry<unknown, infer Name, infer Value> ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableAbstractOf<Value>, CallableAuthOf<Value>, Name, language.MethodKey<Origin, OwnerName, Name>> : never;
 type MethodProjectionOfEntries<Origin extends string, OwnerName extends string, Entries> = Entries extends unknown ? MethodProjectionOfEntry<Origin, OwnerName, Entries> : never;
 type MethodCollectionOperation = 'byKey' | 'get';
 type PropertyProjectionOfResolved<Value> = Value extends language.ResolvedProperty<infer PropertyValue, infer Required, infer State> & {
     readonly name: infer Name extends string;
     readonly key: infer Key extends language.PropertyKey;
 } ? PropertyProjection<PropertyValue, Required, Name, Key, State> : never;
-type MethodProjectionOfResolved<Value> = Value extends language.ResolvedMethod<infer Input, infer Output, infer Static, infer Inheritance, infer Auth, infer _Policy, infer Key> & {
+type MethodProjectionOfResolved<Value> = Value extends language.ResolvedMethod<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer _Policy, infer Key> & {
     readonly name: infer Name extends string;
-} ? MethodProjection<Input, Output, Static, Inheritance, Auth, Name, Key> : never;
+} ? MethodProjection<Input, Output, Static, Abstract, Auth, Name, Key> : never;
 type PropertiesOfCollection<Value> = Value extends {
     readonly byKey: infer ByKey extends Readonly<Record<language.PropertyKey, language.ResolvedProperty<unknown, boolean>>>;
 } ? PropertyProjectionOfResolved<ByKey[keyof ByKey]> : never;
@@ -303,7 +303,7 @@ type EffectiveMethodEntriesOfClass<Value, Static extends boolean> = ClassInputOf
     readonly effectiveInstanceMethods: infer InstanceMethods;
     readonly effectiveStaticMethods: infer StaticMethods;
 } ? Static extends true ? StaticMethods : InstanceMethods : never;
-type EffectiveMethodProjectionOfEntry<Origin extends string, CurrentName extends string, Root extends DomainSchemaInput, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodProjection<infer Value, infer MethodName, infer Owner> ? OwnerNameOf<Root, CurrentName, Owner> extends infer OwnerName extends string ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableInheritanceOf<Value>, CallableAuthOf<Value>, MethodName, language.MethodKey<Origin, OwnerName, MethodName>> : never : never;
+type EffectiveMethodProjectionOfEntry<Origin extends string, CurrentName extends string, Root extends DomainSchemaInput, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodProjection<infer Value, infer MethodName, infer Owner> ? OwnerNameOf<Root, CurrentName, Owner> extends infer OwnerName extends string ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableAbstractOf<Value>, CallableAuthOf<Value>, MethodName, language.MethodKey<Origin, OwnerName, MethodName>> : never : never;
 type EffectiveMethodProjectionsOf<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Static extends boolean> = EffectiveMethodEntriesOfClass<Value, Static> extends infer Entry ? Entry extends unknown ? EffectiveMethodProjectionOfEntry<Origin, Name, Root, Entry> : never : never;
 type ShallowClassProjectionOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput> = Value extends NodeClass<infer _Config> ? ClassProjection<'node', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, language.ClassRef<Name> & {
     readonly origin: Origin;
@@ -335,7 +335,7 @@ type ProjectionPropertyByName<Entries extends PropertyProjection> = Readonly<{
     }>>;
 }>;
 type PropertyCollectionOfProjection<Entries extends PropertyProjection> = language.ResolvedPropertyCollection<ProjectionPropertyByKey<Entries>, ProjectionPropertyByName<Entries>>;
-type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Inheritance, infer Auth, infer Name, infer Key> ? language.ResolvedMethod<Input, Output, Static, Inheritance, Auth, language.PolicyCheckExpression, Key> & {
+type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer Name, infer Key> ? language.ResolvedMethod<Input, Output, Static, Abstract, Auth, language.PolicyCheckExpression, Key> & {
     readonly name: Name;
 } : never;
 type ProjectionMethodByKey<Entries extends MethodProjection> = Readonly<{

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

@@ -237,23 +237,19 @@ function compiledProperty(input, values, node, path) {
 function compiledCallable(input, values, method, path) {
     const value = object(input, 'Compiled Callable', path);
     exact(value, method
-        ? ['name', 'auth', 'static', 'inheritance', 'input', 'output']
+        ? ['name', 'auth', 'static', 'abstract', 'input', 'output']
         : ['ref', 'auth', 'input', 'output'], 'Compiled Callable', path, ['policy', 'description', 'fields']);
     if (method) {
         memberName(value.name, 'Method name', `${path}/name`);
         boolean(value.static, 'Method static', `${path}/static`);
-        if (value.inheritance !== 'abstract' &&
-            value.inheritance !== 'default' &&
-            value.inheritance !== 'sealed') {
-            invalid('Method inheritance', undefined, `${path}/inheritance`);
-        }
+        boolean(value.abstract, 'Method abstract', `${path}/abstract`);
     }
     if (value.auth !== 'anonymous' && value.auth !== 'authenticated' && value.auth !== 'authorized') {
         invalid('Callable auth', undefined, `${path}/auth`);
     }
     description(value.description, 'Callable description', `${path}/description`);
     if (value.policy !== undefined) {
-        if (value.auth !== 'authorized' || (method && value.inheritance === 'abstract')) {
+        if (value.auth !== 'authorized' || (method && value.abstract === true)) {
             invalid('Callable Policy placement', undefined, `${path}/policy`);
         }
         policyCheck(value.policy, 0, `${path}/policy`);
@@ -494,7 +490,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 +544,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 +556,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,10 +1,11 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { Key, PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
 import { compareUnicode } from '../../addressing/ordering.js';
+import { composeMethods } from '../../language/callable/composition.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 { 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';
 import { invalidCompiled } from '../diagnostic.js';
@@ -104,55 +105,22 @@ function analyzeClasses(classes) {
                 fail(`${located.pointer}/data`, 'Data cannot redeclare an inherited contract.');
             dataOwner = located.value.ref;
         }
-        const inherited = new Map();
-        for (const parent of parents) {
-            for (const [name, method] of parent.methods) {
-                const values = inherited.get(name) ?? [];
-                if (!values.some(({ key }) => key === method.key))
-                    values.push(method);
-                inherited.set(name, values);
-            }
-        }
-        const methods = new Map();
-        for (const [name, values] of inherited)
-            if (values.length === 1)
-                methods.set(name, values[0]);
-        if (located.value.kind === 'node') {
-            for (const own of located.value.methods) {
-                const inheritedMethods = inherited.get(own.name) ?? [];
-                for (const parent of inheritedMethods) {
-                    if (parent.declaration.inheritance === 'sealed') {
-                        fail(`${located.pointer}/methods`, `Method ${own.name} overrides a sealed Method.`);
-                    }
-                    if (!sameMethodSignature(located.entry, own, parent.entry, parent.declaration)) {
-                        fail(`${located.pointer}/methods`, `Method ${own.name} changes its inherited signature.`);
-                    }
-                    if (parent.declaration.inheritance !== 'abstract' &&
-                        policyKey(parent.declaration.policy) !== policyKey(own.policy)) {
-                        fail(`${located.pointer}/methods`, `Method ${own.name} changes an executable inherited Policy.`);
-                    }
-                }
-                methods.set(own.name, {
-                    key: `${Key.of(located.value.ref)}.method.${own.name}`,
-                    owner: located.value.ref,
-                    declaration: own,
-                    entry: located.entry,
-                });
-                inherited.delete(own.name);
-            }
-            for (const [name, values] of inherited) {
-                if (values.length > 1)
-                    fail(`${located.pointer}/methods`, `Inherited Method ${name} is ambiguous.`);
-            }
-            if (!located.value.abstract) {
-                for (const [name, method] of methods) {
-                    if (method.declaration.inheritance === 'abstract') {
-                        fail(`${located.pointer}/methods`, `Concrete Class leaves Method ${name} abstract.`);
-                    }
-                }
-            }
-        }
-        const analysis = { properties, methods, ...(dataOwner === undefined ? {} : { dataOwner }) };
+        const own = new Map((located.value.kind === 'node' ? located.value.methods : []).map((method) => [
+            method.name,
+            {
+                key: `${classKey}.method.${method.name}`,
+                name: method.name,
+                owner: located.value.ref,
+                declaration: method,
+                entry: located.entry,
+            },
+        ]));
+        const composition = composeMethods(parents, own, located.value.abstract, (left, right) => sameMethodSignature(left.entry, left.declaration, right.entry, right.declaration), (message) => fail(`${located.pointer}/methods`, message));
+        const analysis = {
+            properties,
+            ...composition,
+            ...(dataOwner === undefined ? {} : { dataOwner }),
+        };
         analyses.set(classKey, analysis);
         visiting.delete(classKey);
         return analysis;
@@ -173,9 +141,6 @@ function outputKey(entry, output) {
 function programKey(entry, value) {
     return json.serialize(entry.values[value]);
 }
-function policyKey(value) {
-    return json.serialize((value === undefined ? null : normalizePolicyChecks(value)));
-}
 function validateClassFacets(context) {
     for (const located of context.classes.values()) {
         if (located.value.abstract &&
@@ -195,7 +160,7 @@ function validateClassFacets(context) {
         }
         if (located.value.kind === 'node') {
             for (const [index, method] of located.value.methods.entries()) {
-                if (method.inheritance === 'abstract' && method.policy !== undefined) {
+                if (method.abstract === true && method.policy !== undefined) {
                     fail(`${located.pointer}/methods/${index}/policy`, 'An abstract Method cannot have a Policy.');
                 }
             }
@@ -348,15 +313,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 +354,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.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 +395,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 +565,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 +868,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 +878,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/compiled/compiler/compile.js

@@ -70,7 +70,7 @@ function compileEntry(schema, lookup) {
                 ...(method.policy === undefined ? {} : { policy: method.policy }),
                 ...(method.description === undefined ? {} : { description: method.description }),
                 static: method.static,
-                inheritance: method.inheritance,
+                abstract: method.abstract,
                 input,
                 ...(fields === undefined ? {} : { fields }),
                 output: output(method.output, `${pointer}/methods/${name}/output`),

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

@@ -8,6 +8,7 @@ export function createClasses(definitions, validation) {
         .map((value) => [Key.of(value.ref), value]));
     const resolved = new Map();
     const visiting = new Set();
+    const frontiers = new Map();
     const resolve = (ref) => {
         const key = Key.of(ref);
         const cached = resolved.get(key);
@@ -25,19 +26,18 @@ export function createClasses(definitions, validation) {
         }
         const shell = {};
         const effectiveProperties = new Map();
-        const effectiveMethods = new Map();
+        const frontier = new Map();
         let inheritedData;
         for (const parent of parents) {
             for (const property of parent.properties) {
                 effectiveProperties.set(property.key, property);
             }
-            for (const method of [...parent.methods, ...parent.static.methods]) {
-                if (!effectiveMethods.has(method.name))
-                    effectiveMethods.set(method.name, method);
-            }
+            for (const [name, method] of frontiers.get(parent.key))
+                frontier.set(name, method);
             if (parent.kind === 'node' && inheritedData === undefined)
                 inheritedData = parent.data;
         }
+        const effectiveMethods = new Map(frontier);
         const ownProperties = [];
         for (const [name, propertyDefinition] of Object.entries(definition.properties)) {
             const propertyKey = PropertyKeyValue.of(ref, name);
@@ -72,13 +72,15 @@ export function createClasses(definitions, validation) {
                     auth: methodDefinition.auth,
                     policy: methodDefinition.policy,
                     static: methodDefinition.static,
-                    inheritance: methodDefinition.inheritance,
+                    abstract: methodDefinition.abstract,
                     ...(inputFields === undefined ? {} : { inputFields }),
                     definition: methodDefinition,
                     validateInput: (input) => validation.callableInput(methodKey, input),
                     validateInputField: (field, input) => validation.callableInputField(methodKey, field, input),
                     validateOutput: (output) => validation.callableOutput(methodKey, output),
                 });
+                if (method.abstract)
+                    frontier.set(name, method);
                 effectiveMethods.set(name, method);
                 (methodDefinition.static ? ownStaticMethods : ownInstanceMethods).push(method);
             }
@@ -119,6 +121,7 @@ export function createClasses(definitions, validation) {
             },
         });
         const value = Object.freeze(shell);
+        frontiers.set(key, frontier);
         resolved.set(key, value);
         visiting.delete(key);
         return value;

package/dist/v1/index.d.ts

@@ -4,7 +4,7 @@ export { stateMachine } from './language/state/index.js';
 export type { EventOf, StateMachine, StateOf } from './language/state/index.js';
 export { PropertyValues } from './language/index.js';
 export * as metadata from './language/definition/metadata.js';
-export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, MethodDefinition, MethodInheritance, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedData, ResolvedFunction, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
+export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, MethodDefinition, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedData, ResolvedFunction, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
 export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodAddress, PolicyRef, Revision, ViewRef, } from './addressing/index.js';
 export type { Definition } from './language/index.js';

package/dist/v1/language/callable/composition.d.ts

@@ -0,0 +1,15 @@
+interface MethodMember {
+    readonly key: string;
+    readonly name: string;
+    readonly declaration: {
+        readonly abstract: boolean;
+    };
+}
+export interface MethodComposition<Method> {
+    readonly requirements: ReadonlyMap<string, Method>;
+    readonly frontier: ReadonlyMap<string, Method>;
+    readonly methods: ReadonlyMap<string, Method>;
+}
+/** Concrete implementations never discharge a descendant's abstract obligations. */
+export declare function composeMethods<Method extends MethodMember>(parents: readonly MethodComposition<Method>[], own: ReadonlyMap<string, Method>, abstract: boolean, sameSignature: (left: Method, right: Method) => boolean, report: (message: string) => void): MethodComposition<Method>;
+export {};

package/dist/v1/language/callable/composition.js

@@ -0,0 +1,42 @@
+/** Concrete implementations never discharge a descendant's abstract obligations. */
+export function composeMethods(parents, own, abstract, sameSignature, report) {
+    const requirements = new Map(parents.flatMap((parent) => [...parent.requirements]));
+    const frontier = new Map(parents.flatMap((parent) => [...parent.frontier]));
+    for (const required of requirements.values()) {
+        const local = own.get(required.name);
+        if (local !== undefined && !sameSignature(local, required)) {
+            report(`Method ${local.key} does not exactly preserve abstract signature ${required.key}.`);
+        }
+    }
+    for (const local of own.values()) {
+        if (!local.declaration.abstract)
+            continue;
+        requirements.set(local.key, local);
+        for (const [key, inherited] of frontier) {
+            if (inherited.name === local.name)
+                frontier.delete(key);
+        }
+        frontier.set(local.key, local);
+    }
+    const methods = new Map();
+    for (const inherited of frontier.values()) {
+        const prior = methods.get(inherited.name);
+        if (prior !== undefined && !own.has(inherited.name)) {
+            report(`Inherited Method ${inherited.name} is ambiguous: ${prior.key}, ${inherited.key}.`);
+        }
+        methods.set(inherited.name, inherited);
+    }
+    for (const [name, local] of own)
+        methods.set(name, local);
+    if (!abstract) {
+        const missing = new Set();
+        for (const required of requirements.values()) {
+            const local = own.get(required.name);
+            if ((local === undefined || local.declaration.abstract) && !missing.has(required.name)) {
+                missing.add(required.name);
+                report(`Concrete Class requires a local concrete implementation of ${required.key}.`);
+            }
+        }
+    }
+    return { requirements, frontier, methods };
+}

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

@@ -1,7 +1,6 @@
 import type { DefinitionBase, FunctionRef } from '../../../addressing/index.js';
 import type { PolicyCheckExpression } from '../../policy/model/policy.js';
 import type { JsonSchema } from '../../value/model/schema.js';
-export type MethodInheritance = 'abstract' | 'default' | 'sealed';
 export type FunctionAuth = 'anonymous' | 'authenticated' | 'authorized';
 export type CallableOutput = {
     readonly mode: 'value';
@@ -28,6 +27,6 @@ export type CallableDefinition = CallableDefinitionBase & ({
 export type FunctionDefinition = DefinitionBase<FunctionRef> & CallableDefinition;
 export type MethodDefinition = CallableDefinition & {
     readonly static: boolean;
-    readonly inheritance: MethodInheritance;
+    readonly abstract: boolean;
 };
 export type MethodRecord = Readonly<Record<string, MethodDefinition>>;

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

@@ -11,7 +11,7 @@ type CallableDefinitionOf<Definition extends FunctionDefinition | MethodDefiniti
 } : {
     readonly policy?: never;
 }) : never);
-export interface ResolvedMethod<out Input = unknown, out Output = unknown, out Static extends boolean = boolean, out Inheritance extends MethodDefinition['inheritance'] = MethodDefinition['inheritance'], out Auth extends FunctionAuth = FunctionAuth, out Policy extends PolicyCheckExpression = PolicyCheckExpression, out ExactKey extends MethodKey = MethodKey> {
+export interface ResolvedMethod<out Input = unknown, out Output = unknown, out Static extends boolean = boolean, out Abstract extends MethodDefinition['abstract'] = MethodDefinition['abstract'], out Auth extends FunctionAuth = FunctionAuth, out Policy extends PolicyCheckExpression = PolicyCheckExpression, out ExactKey extends MethodKey = MethodKey> {
     readonly owner: ResolvedClass<'node'> & {
         readonly key: MethodOwnerKeyOfKey<ExactKey>;
     };
@@ -21,14 +21,14 @@ export interface ResolvedMethod<out Input = unknown, out Output = unknown, out S
     readonly input: MethodDefinition['input'];
     readonly output: MethodDefinition['output'];
     readonly auth: Auth;
-    readonly policy?: Auth extends 'authorized' ? Policy : never;
+    readonly policy?: Abstract extends true ? never : Auth extends 'authorized' ? Policy : never;
     readonly static: Static;
-    readonly inheritance: Inheritance;
+    readonly abstract: Abstract;
     /** Present only when the callable input is a safely enumerable closed object. */
     readonly inputFields?: readonly string[];
-    readonly definition: CallableDefinitionOf<MethodDefinition, Auth, Policy> & {
+    readonly definition: CallableDefinitionOf<MethodDefinition, Auth, Abstract extends true ? never : Policy> & {
         readonly static: Static;
-        readonly inheritance: Inheritance;
+        readonly abstract: Abstract;
     };
     validateInput(input: unknown): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];

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/analysis/class.d.ts

@@ -8,6 +8,7 @@ import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
 import { PropertyKey } from '../../addressing/index.js';
+import { type MethodComposition } from '../../language/callable/composition.js';
 export interface EffectiveField {
     readonly identity: PropertyKey;
     readonly owner: ClassRef;
@@ -18,7 +19,7 @@ export interface EffectiveField {
     readonly state?: StateTopology;
 }
 export interface EffectiveMethod {
-    readonly identity: string;
+    readonly key: string;
     readonly owner: ClassRef;
     readonly name: string;
     readonly declaration: MethodDefinition;
@@ -28,12 +29,11 @@ export interface EffectiveData {
     readonly owner: ClassRef;
     readonly declaration: DataDefinition;
 }
-export interface DefinitionAnalysis {
+export interface DefinitionAnalysis extends MethodComposition<EffectiveMethod> {
     readonly ref: ClassRef;
     readonly declaration: ClassDefinition;
     readonly properties: ReadonlyMap<PropertyKey, EffectiveField>;
     readonly data?: EffectiveData;
-    readonly methods: ReadonlyMap<string, EffectiveMethod>;
 }
 export interface DefinitionAnalysisResult {
     readonly definitions: ReadonlyMap<string, DefinitionAnalysis>;

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

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { Key, PropertyKey } from '../../addressing/index.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
-import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
+import { composeMethods } from '../../language/callable/composition.js';
 import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
 import { diagnostic } from '../diagnostic.js';
 const formatDefinitionRef = Key.of;
@@ -41,7 +41,7 @@ export function analyzeDefinitions(environment) {
             declaration,
             properties,
             ...(data === undefined ? {} : { data }),
-            methods,
+            ...methods,
         };
         result.set(key, analysis);
         visiting.delete(key);
@@ -107,57 +107,11 @@ function mergeData(owner, declaration, parents, diagnostics) {
     };
 }
 function mergeMethods(owner, declaration, parents, diagnostics) {
-    if (!('methods' in declaration))
-        return new Map();
-    const inherited = new Map();
-    for (const parent of parents) {
-        for (const [name, method] of parent.methods) {
-            const entries = inherited.get(name) ?? [];
-            if (!entries.some((entry) => entry.identity === method.identity))
-                entries.push(method);
-            inherited.set(name, entries);
-        }
-    }
-    const result = new Map();
-    for (const [name, entries] of inherited) {
-        if (entries.length === 1)
-            result.set(name, entries[0]);
-    }
-    for (const [name, ownMethod] of Object.entries(declaration.methods)) {
-        const parentsForName = inherited.get(name) ?? [];
-        for (const parent of parentsForName) {
-            if (parent.declaration.inheritance === 'sealed') {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} cannot override sealed ${formatDefinitionRef(parent.owner)}.${name}.`));
-            }
-            if (!sameMethodSignature(ownMethod, parent.declaration)) {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} does not exactly preserve its inherited signature.`));
-            }
-            if (parent.declaration.inheritance !== 'abstract' &&
-                canonicalPolicy(parent.declaration.policy) !== canonicalPolicy(ownMethod.policy)) {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} changes an executable inherited Policy.`));
-            }
-        }
-        result.set(name, {
-            identity: `${definitionRefIndex(owner)}\u0000method\u0000${name}`,
-            owner,
-            name,
-            declaration: ownMethod,
-        });
-        inherited.delete(name);
-    }
-    for (const [name, entries] of inherited) {
-        if (entries.length > 1) {
-            diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Inherited method ${name} is ambiguous and has no local override.`));
-        }
-    }
-    if (declaration.kind === 'node' && !declaration.abstract) {
-        for (const [name, method] of result) {
-            if (method.declaration.inheritance === 'abstract') {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Concrete Class ${owner.name} leaves method ${name} abstract.`));
-            }
-        }
-    }
-    return result;
+    const own = new Map(Object.entries('methods' in declaration ? declaration.methods : {}).map(([name, method]) => [
+        name,
+        { key: `${Key.of(owner)}.method.${name}`, owner, name, declaration: method },
+    ]));
+    return composeMethods(parents, own, declaration.abstract, (left, right) => sameMethodSignature(left.declaration, right.declaration), (message) => diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', message, Key.of(owner))));
 }
 function sameMethodSignature(left, right) {
     return (json.serialize(canonicalizeValueSchema(left.input, 'callable-input')) ===
@@ -176,6 +130,3 @@ function canonicalMethodOutput(value) {
             return 'binary';
     }
 }
-function canonicalPolicy(value) {
-    return json.serialize(value === undefined ? null : normalizePolicyChecks(value));
-}

package/dist/v1/schema/normalization/domain.js

@@ -107,7 +107,7 @@ function canonicalizeMethod(value) {
     return {
         ...canonicalizeCallable(value),
         static: value.static,
-        inheritance: value.inheritance,
+        abstract: value.abstract,
     };
 }
 function canonicalizeCallableOutput(value) {

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/class.js

@@ -71,7 +71,7 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
         return;
     for (const [name, method] of Object.entries(declaration.methods)) {
         const methodPointer = `${pointer}/methods/${escapePointer(name)}`;
-        if (method.inheritance === 'abstract' && method.policy !== undefined) {
+        if (method.abstract === true && method.policy !== undefined) {
             diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/policy`, 'Abstract Methods cannot have a Policy.'));
         }
     }

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,
@@ -187,9 +188,9 @@ const callableShape = {
 const methodDeclarationSchema = strictObject({
     ...callableShape,
     static: boolean(),
-    inheritance: enumeration(['abstract', 'default', 'sealed']),
+    abstract: boolean(),
 }).superRefine((method, context) => {
-    if (method.inheritance === 'abstract' && method.policy !== undefined) {
+    if (method.abstract === true && method.policy !== undefined) {
         context.addIssue({
             code: 'custom',
             path: ['policy'],

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.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.32",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {