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

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,23 @@ 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 = ConcreteCallableInput & {
+    readonly static?: boolean;
+    /** Require every concrete descendant to declare this contract locally. */
+    readonly abstract?: boolean;
 };
-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 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;
@@ -93,12 +96,12 @@ export type ProjectionOfCallable<Value extends Function | Method> = Value extend
 export declare function callableConfiguration(value: Function | Method): CallableInput;
 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,14 +20,11 @@ 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) {
-            fail('BUILDER_ABSTRACT_POLICY', `${placement.pointer}/policy`, 'An abstract Method cannot declare a Policy check.');
-        }
+        const isAbstract = method ? (config.abstract ?? false) : undefined;
         const input = this.values.schema(config.input, 'callable-input', `${placement.pointer}/input`);
         const output = this.compileOutput(config.output, `${placement.pointer}/output`);
         const policy = config.policy === undefined
@@ -46,7 +43,7 @@ export class V1CallableCompiler {
         return {
             ...contract,
             static: isStatic,
-            inheritance: inheritance,
+            abstract: isAbstract,
         };
     }
     compileOutput(value, pointer) {

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 { isMethodExecutable } from '../../../language/callable/executable.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';
@@ -260,7 +261,7 @@ function hasPolicyObject(schema, ref) {
         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';
+            return method !== undefined && isMethodExecutable(owner, method);
         }
         case 'class':
             return Object.hasOwn(schema.classes, ref.name);

package/dist/v1/builder/schema/projection.d.ts

@@ -4,7 +4,7 @@ import type * as language from '../../language/index.js';
 import type { StateTopology } from '../../language/state/index.js';
 import type { DomainOfSchema, DomainSchema } from '../../schema/model/schema.js';
 import type { CallableProjection, Function, Method } from '../callable/authoring.js';
-import type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassIdentityProjectionOf, ClassOwnerProjection, ClassOwnerProjectionOf, ClassReferenceProjection, ClassReferenceProjectionOf, DirectedEdgeClass, NodeClass, ProjectionOfClass, UndirectedEdgeClass } from '../class/authoring.js';
+import type { AuthoredPropertyProjection, Class, ClassIdentityProjection, ClassIdentityProjectionOf, ClassOwnerProjection, ClassOwnerProjectionOf, ClassReferenceProjection, ClassReferenceProjectionOf, DirectedEdgeClass, NodeClass, ProjectionOfClass, UndirectedEdgeClass } from '../class/authoring.js';
 import type { DomainSchemaInput } from './input.js';
 export interface PropertyProjection<Value = unknown, Required extends boolean = boolean, Name extends string = string, Key extends language.PropertyKey = language.PropertyKey, State extends StateTopology | undefined = StateTopology | undefined> {
     readonly value: Value;
@@ -13,11 +13,13 @@ 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> {
+type MethodExecutableOf<OwnerAbstract extends boolean, MethodAbstract extends boolean> = MethodAbstract extends false ? true : OwnerAbstract extends false ? true : false;
+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, Executable extends boolean = boolean> {
     readonly input: Input;
     readonly output: Output;
     readonly static: Static;
-    readonly inheritance: Inheritance;
+    readonly abstract: Abstract;
+    readonly executable: Executable;
     readonly auth: Auth;
     readonly name: Name;
     readonly key: Key;
@@ -251,20 +253,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<infer Owner, infer Name, infer Value> ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableAbstractOf<Value>, CallableAuthOf<Value>, Name, language.MethodKey<Origin, OwnerName, Name>, MethodExecutableOf<AbstractOf<ClassInputOf<Owner>>, CallableAbstractOf<Value>>> : 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, Value['executable']> : never;
 type PropertiesOfCollection<Value> = Value extends {
     readonly byKey: infer ByKey extends Readonly<Record<language.PropertyKey, language.ResolvedProperty<unknown, boolean>>>;
 } ? PropertyProjectionOfResolved<ByKey[keyof ByKey]> : never;
@@ -299,20 +301,14 @@ type EffectivePropertyProjectionOfEntry<Origin extends string, CurrentName exten
 type EffectivePropertyProjectionsOf<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput> = EffectivePropertyEntriesOfClass<Value> extends infer Entry ? Entry extends unknown ? EffectivePropertyProjectionOfEntry<Origin, Name, Root, Entry> : never : never;
 type OwnInstanceMethodProjectionsOf<Origin extends string, Name extends string, Value> = MethodProjectionOfEntries<Origin, Name, OwnMethodEntries<Value, false>>;
 type OwnStaticMethodProjectionsOf<Origin extends string, Name extends string, Value> = MethodProjectionOfEntries<Origin, Name, OwnMethodEntries<Value, true>>;
-type EffectiveMethodEntriesOfClass<Value, Static extends boolean> = ClassInputOf<Value> extends {
-    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 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;
-}, language.DefinitionKey<Origin, 'class', Name>, readonly language.AnyResolvedClass[], EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, EffectiveMethodProjectionsOf<Origin, Name, Value, Root, false>, EffectiveMethodProjectionsOf<Origin, Name, Value, Root, true>, OwnPropertyProjectionsOf<Origin, Name, Value>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>> : Value extends DirectedEdgeClass | UndirectedEdgeClass ? ClassProjection<'edge', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, language.ClassRef<Name> & {
+}, language.DefinitionKey<Origin, 'class', Name>, readonly language.AnyResolvedClass[], EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>, OwnPropertyProjectionsOf<Origin, Name, Value>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>> : Value extends DirectedEdgeClass | UndirectedEdgeClass ? ClassProjection<'edge', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, language.ClassRef<Name> & {
     readonly origin: Origin;
 }, language.DefinitionKey<Origin, 'class', Name>, readonly language.AnyResolvedClass[], EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, never, never, OwnPropertyProjectionsOf<Origin, Name, Value>, never, never> : never;
 type ClassProjectionOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Seen = Value> = Value extends NodeClass ? ClassProjection<'node', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, language.ClassRef<Name> & {
     readonly origin: Origin;
-}, language.DefinitionKey<Origin, 'class', Name>, ParentClassProjectionTuple<Origin, ParentInputsOfConfig<ProjectionOfClass<Extract<Value, Class>>>, Root, Seen>, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, EffectiveMethodProjectionsOf<Origin, Name, Value, Root, false>, EffectiveMethodProjectionsOf<Origin, Name, Value, Root, true>, OwnPropertyProjectionsOf<Origin, Name, Value>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>> : Value extends DirectedEdgeClass | UndirectedEdgeClass ? ClassProjection<'edge', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, language.ClassRef<Name> & {
+}, language.DefinitionKey<Origin, 'class', Name>, ParentClassProjectionTuple<Origin, ParentInputsOfConfig<ProjectionOfClass<Extract<Value, Class>>>, Root, Seen>, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>, OwnPropertyProjectionsOf<Origin, Name, Value>, OwnInstanceMethodProjectionsOf<Origin, Name, Value>, OwnStaticMethodProjectionsOf<Origin, Name, Value>> : Value extends DirectedEdgeClass | UndirectedEdgeClass ? ClassProjection<'edge', Extract<ProjectedClassDefinition<Origin, Name, Value>, language.EdgeClassDefinition>, language.ClassRef<Name> & {
     readonly origin: Origin;
 }, language.DefinitionKey<Origin, 'class', Name>, ParentClassProjectionTuple<Origin, ParentInputsOfConfig<ProjectionOfClass<Extract<Value, Class>>>, Root, Seen>, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, never, never, OwnPropertyProjectionsOf<Origin, Name, Value>, never, never> : never;
 type FunctionProjectionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends Function ? FunctionProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, language.FunctionRef<Name> & {
@@ -335,8 +331,9 @@ 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, infer Executable> ? language.ResolvedMethod<Input, Output, Static, Abstract, Auth, language.PolicyCheckExpression, Key> & {
     readonly name: Name;
+    readonly executable: Executable;
 } : never;
 type ProjectionMethodByKey<Entries extends MethodProjection> = Readonly<{
     [Key in Entries['key']]: ResolvedMethodOfProjection<Extract<Entries, {

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') {
             invalid('Callable Policy placement', undefined, `${path}/policy`);
         }
         policyCheck(value.policy, 0, `${path}/policy`);

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

@@ -1,10 +1,12 @@
 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 { isMethodExecutable } from '../../language/callable/executable.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 { 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 +106,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 +142,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 +161,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 (!isMethodExecutable(located.value, method) && method.policy !== undefined) {
                     fail(`${located.pointer}/methods/${index}/policy`, 'An abstract Method cannot have a Policy.');
                 }
             }
@@ -398,7 +364,7 @@ function validatePolicyTerm(context, term, path, 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')
+    if (method === undefined || !isMethodExecutable(owner, method))
         fail(path, 'Policy Method ref must name an exact concrete Method declaration.');
 }
 function validatePolicyCycles(entry, local, entryIndex) {

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

@@ -1,4 +1,5 @@
 import { Key, MethodKey as MethodKeyValue, PropertyKey as PropertyKeyValue, } from '../../addressing/index.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
 import { acceptPropertyValues } from '../../language/class/property-values.js';
 import { appendPointer } from '../../language/value/syntax/pointer.js';
 import { createMethodCollection, createPropertyCollection } from '../namespace/member-collection.js';
@@ -25,16 +26,11 @@ export function createClasses(definitions, validation) {
         }
         const shell = {};
         const effectiveProperties = new Map();
-        const effectiveMethods = 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);
-            }
             if (parent.kind === 'node' && inheritedData === undefined)
                 inheritedData = parent.data;
         }
@@ -72,19 +68,17 @@ export function createClasses(definitions, validation) {
                     auth: methodDefinition.auth,
                     policy: methodDefinition.policy,
                     static: methodDefinition.static,
-                    inheritance: methodDefinition.inheritance,
+                    abstract: methodDefinition.abstract,
+                    executable: isMethodExecutable(definition, methodDefinition),
                     ...(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),
                 });
-                effectiveMethods.set(name, method);
                 (methodDefinition.static ? ownStaticMethods : ownInstanceMethods).push(method);
             }
         }
-        const instanceMethods = [...effectiveMethods.values()].filter(({ definition }) => !definition.static);
-        const staticMethods = [...effectiveMethods.values()].filter(({ definition }) => definition.static);
         Object.assign(shell, {
             ref: definition.ref,
             key,
@@ -95,8 +89,8 @@ export function createClasses(definitions, validation) {
             policies: definition.policies,
             data: definition.kind === 'node' ? (ownData ?? inheritedData) : undefined,
             properties: createPropertyCollection(effectiveProperties.values()),
-            methods: createMethodCollection(instanceMethods),
-            static: Object.freeze({ methods: createMethodCollection(staticMethods) }),
+            methods: createMethodCollection(ownInstanceMethods),
+            static: Object.freeze({ methods: createMethodCollection(ownStaticMethods) }),
             self: Object.freeze({
                 data: definition.kind === 'node' ? ownData : undefined,
                 properties: createPropertyCollection(ownProperties),

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, ExecutableMethod, 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 && !missing.has(required.name)) {
+                missing.add(required.name);
+                report(`Concrete Class requires a local Method declaration of ${required.key}.`);
+            }
+        }
+    }
+    return { requirements, frontier, methods };
+}

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

@@ -0,0 +1,6 @@
+/** A local Method is executable unless both its contract and its owner are abstract. */
+export declare function isMethodExecutable(owner: {
+    readonly abstract: boolean;
+}, method: {
+    readonly abstract: boolean;
+}): boolean;

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

@@ -0,0 +1,4 @@
+/** A local Method is executable unless both its contract and its owner are abstract. */
+export function isMethodExecutable(owner, method) {
+    return !method.abstract || !owner.abstract;
+}

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>;
     };
@@ -23,12 +23,14 @@ export interface ResolvedMethod<out Input = unknown, out Output = unknown, out S
     readonly auth: Auth;
     readonly policy?: Auth extends 'authorized' ? Policy : never;
     readonly static: Static;
-    readonly inheritance: Inheritance;
+    readonly abstract: Abstract;
+    /** Whether this exact local declaration requires an implementation. */
+    readonly executable: Abstract extends false ? true : boolean;
     /** Present only when the callable input is a safely enumerable closed object. */
     readonly inputFields?: readonly string[];
     readonly definition: CallableDefinitionOf<MethodDefinition, Auth, Policy> & {
         readonly static: Static;
-        readonly inheritance: Inheritance;
+        readonly abstract: Abstract;
     };
     validateInput(input: unknown): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
@@ -65,4 +67,8 @@ export type MethodOwnerKeyOf<Method> = Method extends {
 type MethodOwnerKeyOfKey<ExactKey extends MethodKey> = ExactKey extends `${infer Origin}:class.${infer Owner}.method.${string}` ? DefinitionKey<Extract<Origin, Key.Origin>, 'class', Owner> : never;
 export type CallableInputOf<Callable> = Callable extends ResolvedMethod<infer Input, unknown, boolean> ? Input : Callable extends ResolvedFunction<infer Input, unknown> ? Input : never;
 export type CallableOutputOf<Callable> = Callable extends ResolvedMethod<unknown, infer Output, boolean> ? Output : Callable extends ResolvedFunction<unknown, infer Output> ? Output : never;
+/** An exact local Method whose Schema requires an implementation. */
+export type ExecutableMethod<Input = unknown, Output = unknown, Static extends boolean = boolean> = ResolvedMethod<Input, Output, Static> & {
+    readonly executable: true;
+};
 export {};

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

@@ -40,7 +40,9 @@ export type CallableResultOf<Callable, Binary = unknown> = CallableOutputOf<Call
 } ? AsyncIterable<Item> : Output extends {
     readonly mode: 'binary';
 } ? Binary : never : never;
-type ExecutableMethod<Method> = Method extends ResolvedMethod<unknown, unknown, false, infer Inheritance> ? Inheritance extends 'abstract' ? never : Method : never;
+type ExecutableMethod<Method> = Method extends ResolvedMethod<unknown, unknown, false> & {
+    readonly executable: true;
+} ? Method : never;
 export type BoundMethodOf<Method, Binary = unknown> = ExecutableMethod<Method> extends infer Callable ? [Callable] extends [never] ? never : (input: CallableInputOf<Callable>) => Promise<CallableResultOf<Callable, Binary>> : never;
 /** Collision-safe direct bound Methods. Client supplies graph/wrapper reserved names. */
 export type BoundMethodShortcutsOf<Class, Binary = unknown, Reserved extends MemberName = never> = Readonly<{

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

@@ -1,3 +1,4 @@
+export { isMethodExecutable } from './callable/executable.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';
 export type { Value as PropertyValue } from '@astrale-os/kernel-dsl/value';
 export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, } from './value/model/schema.js';

package/dist/v1/language/index.js

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

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

@@ -1,5 +1,6 @@
 import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
 import { diagnostic } from '../diagnostic.js';
@@ -71,7 +72,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 (!isMethodExecutable(declaration, method) && 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

@@ -188,16 +188,8 @@ 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) {
-        context.addIssue({
-            code: 'custom',
-            path: ['policy'],
-            message: 'An abstract method cannot declare a policy.',
-            params: { structureCode: 'STRUCTURE_ABSTRACT_POLICY' },
-        });
-    }
     if (method.auth !== 'authorized' && method.policy !== undefined) {
         context.addIssue({
             code: 'custom',

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

@@ -1,4 +1,5 @@
 import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 const KERNEL_ORIGIN = 'kernel.astrale.ai';
 const PROJECTION_CLASS = nodeClassRef('Class');
@@ -26,7 +27,7 @@ export function referenceContracts(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'
+            return method === undefined || !isMethodExecutable(declaringClass, method)
                 ? invalidPolicyObjectRef(validation, ref, pointer)
                 : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
         }

package/package.json

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