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

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

@@ -58,15 +58,11 @@ export type FunctionInput = ConcreteCallableInput & {
     readonly static?: never;
     readonly abstract?: never;
 };
-export type MethodInput = (ConcreteCallableInput & {
+export type MethodInput = ConcreteCallableInput & {
     readonly static?: boolean;
-    readonly abstract?: false;
-}) | (CallableInputBase & {
-    readonly static?: boolean;
-    readonly abstract: true;
-    readonly auth: FunctionAuth;
-    readonly policy?: never;
-});
+    /** Require every concrete descendant to declare this contract locally. */
+    readonly abstract?: boolean;
+};
 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;

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

@@ -25,9 +25,6 @@ export class V1CallableCompiler {
         }
         const isStatic = method ? (config.static ?? false) : 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`);
         const output = this.compileOutput(config.output, `${placement.pointer}/output`);
         const policy = config.policy === undefined

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.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, Abstract extends boolean = boolean, 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 abstract: Abstract;
+    readonly executable: Executable;
     readonly auth: Auth;
     readonly name: Name;
     readonly key: Key;
@@ -255,7 +257,7 @@ 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>, CallableAbstractOf<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> & {
@@ -264,7 +266,7 @@ type PropertyProjectionOfResolved<Value> = Value extends language.ResolvedProper
 } ? PropertyProjection<PropertyValue, Required, Name, Key, State> : never;
 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, Abstract, 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>, 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;
-}, 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 Abstract, infer Auth, infer Name, infer Key> ? language.ResolvedMethod<Input, Output, Static, Abstract, 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

@@ -249,7 +249,7 @@ function compiledCallable(input, values, method, path) {
     }
     description(value.description, 'Callable description', `${path}/description`);
     if (value.policy !== undefined) {
-        if (value.auth !== 'authorized' || (method && value.abstract === true)) {
+        if (value.auth !== 'authorized') {
             invalid('Callable Policy placement', undefined, `${path}/policy`);
         }
         policyCheck(value.policy, 0, `${path}/policy`);

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

@@ -2,6 +2,7 @@ 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';
@@ -160,7 +161,7 @@ function validateClassFacets(context) {
         }
         if (located.value.kind === 'node') {
             for (const [index, method] of located.value.methods.entries()) {
-                if (method.abstract === true && method.policy !== undefined) {
+                if (!isMethodExecutable(located.value, method) && method.policy !== undefined) {
                     fail(`${located.pointer}/methods/${index}/policy`, 'An abstract Method cannot have a Policy.');
                 }
             }
@@ -363,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.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/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';
@@ -8,7 +9,6 @@ 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);
@@ -26,18 +26,14 @@ export function createClasses(definitions, validation) {
         }
         const shell = {};
         const effectiveProperties = 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 [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);
@@ -73,20 +69,16 @@ export function createClasses(definitions, validation) {
                     policy: methodDefinition.policy,
                     static: methodDefinition.static,
                     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),
                 });
-                if (method.abstract)
-                    frontier.set(name, method);
-                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,
@@ -97,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),
@@ -121,7 +113,6 @@ 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, 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.js

@@ -32,9 +32,9 @@ export function composeMethods(parents, own, abstract, sameSignature, report) {
         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)) {
+            if (local === undefined && !missing.has(required.name)) {
                 missing.add(required.name);
-                report(`Concrete Class requires a local concrete implementation of ${required.key}.`);
+                report(`Concrete Class requires a local Method declaration of ${required.key}.`);
             }
         }
     }

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

@@ -21,12 +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?: Abstract extends true ? never : Auth extends 'authorized' ? Policy : never;
+    readonly policy?: Auth extends 'authorized' ? Policy : never;
     readonly static: Static;
     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, Abstract extends true ? never : Policy> & {
+    readonly definition: CallableDefinitionOf<MethodDefinition, Auth, Policy> & {
         readonly static: Static;
         readonly abstract: Abstract;
     };
@@ -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/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.abstract === true && 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

@@ -190,14 +190,6 @@ const methodDeclarationSchema = strictObject({
     static: boolean(),
     abstract: boolean(),
 }).superRefine((method, context) => {
-    if (method.abstract === true && 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.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.32",
+  "version": "0.2.0-beta.33",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {