@astrale-os/kernel-dsl 0.2.0-beta.8 → 0.2.0

package/dist/v1/compiled/generated.js

@@ -0,0 +1,15 @@
+import { realize } from './loader/load.js';
+/** Realize immutable, build-owned compiled material without repeating external admission. */
+export function load(input) {
+    return realize(deepFreeze(input));
+}
+function deepFreeze(input, seen = new WeakSet()) {
+    if (input === null || typeof input !== 'object' || seen.has(input))
+        return input;
+    seen.add(input);
+    for (const value of Object.values(input))
+        deepFreeze(value, seen);
+    if (!Object.isFrozen(input))
+        Object.freeze(input);
+    return input;
+}

package/dist/v1/compiled/loader/load.d.ts

@@ -2,3 +2,8 @@ import type { CompiledSchema, DomainOfCompiled } from '../model/schema.js';
 /** Load admitted compiled data through the one resolved Domain constructor. */
 export declare function load<const Input extends CompiledSchema>(input: Input): DomainOfCompiled<Input>;
 export declare function load(input: unknown): import('../../domain/model/domain.js').Domain;
+/**
+ * Realize compiled material whose exact embedded bytes were already proven by generated build code.
+ * External bytes and caller-provided values must continue through {@link load}.
+ */
+export declare function realize(compiled: CompiledSchema): import('../../domain/model/domain.js').Domain;

package/dist/v1/compiled/loader/load.js

@@ -2,10 +2,17 @@ import { Key, MethodKey, PropertyKey as PropertyKeyValue } from '../../addressin
 import { compareUnicode } from '../../addressing/ordering.js';
 import { createDomain } from '../../domain/create.js';
 import { combineDomainValidation, createDomainValidation, unknownInputField, } from '../../domain/validation/create.js';
+import { bindValueProgram } from '../../language/value/compile/load.js';
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
 import { acceptCompiledSchema } from '../admission/accept.js';
 export function load(input) {
-    const compiled = acceptCompiledSchema(input);
+    return realize(acceptCompiledSchema(input));
+}
+/**
+ * Realize compiled material whose exact embedded bytes were already proven by generated build code.
+ * External bytes and caller-provided values must continue through {@link load}.
+ */
+export function realize(compiled) {
     const entries = new Map(compiled.closure.map((entry) => [entry.origin, loadEntry(entry)]));
     const root = entries.get(compiled.root.origin);
     if (root === undefined || root.entry.revision !== compiled.root.revision) {
@@ -62,7 +69,7 @@ function loadEntry(entry) {
             ...entry.definitions.views,
             ...entry.definitions.core,
         ]),
-        validation: programValidation(entry.values, propertyPrograms, propertyOrdering, callablePrograms),
+        validation: programValidation(entry.values.map((value) => bindValueProgram(value, entry.patterns)), propertyPrograms, propertyOrdering, callablePrograms),
     };
 }
 function loadMethod(entry, value) {
@@ -77,7 +84,13 @@ function loadFunction(entry, value) {
     const { input, fields: _, output, ...definition } = value;
     return Object.freeze({
         ...definition,
-        input: schemaOf(entry, input),
+        input: typeof input === 'number'
+            ? schemaOf(entry, input)
+            : {
+                mode: 'binary',
+                metadata: schemaOf(entry, input.metadata),
+                maximumBytes: input.maximumBytes,
+            },
         output: loadOutput(entry, output),
     });
 }
@@ -98,7 +111,7 @@ function schemaOf(entry, index) {
 }
 function callableProgram(value) {
     return {
-        input: value.input,
+        input: typeof value.input === 'number' ? value.input : value.input.metadata,
         ...(value.fields === undefined ? {} : { fields: value.fields }),
         ...(value.output.mode === 'binary' ? {} : { output: value.output.value }),
     };
@@ -112,6 +125,7 @@ function programValidation(programs, properties, propertyOrdering, callables) {
         propertyValidation.set(key, Object.freeze({
             ordering: propertyOrdering.get(key),
             validate: (value) => validateValueProgram(program, value),
+            program: () => program,
         }));
     }
     const callableValidation = new Map();

package/dist/v1/compiled/model/schema.d.ts

@@ -1,15 +1,15 @@
 import type { Key } from '../../addressing/index.js';
-import type { DomainDependency, DomainDependencyMap, Revision } from '../../addressing/index.js';
+import type { DomainDependency, DomainDependencyMap, Revision, ViewRef } from '../../addressing/index.js';
 import type { Domain } from '../../domain/model/domain.js';
 import type { MethodDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { PropertyDefinition } from '../../language/class/model/property.js';
 import type { CoreDefinition, CoreEdge } from '../../language/core/model/core.js';
 import type { PolicyDefinition } from '../../language/policy/model/policy.js';
-import type { ValueProgram } from '../../language/value/compile/model.js';
+import type { IndexedValueProgram, Pattern, RunPattern } from '../../language/value/compile/model.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
 import type { ViewDefinition } from '../../language/view/model/view.js';
-export type { Pattern, PatternState, PatternTransition, ScalarRange, ValueNode, ValueProgram, } from '../../language/value/compile/model.js';
+export type { Pattern, PatternState, PatternTransition, RunPattern, ScalarRun, ScalarRange, IndexedValueProgram, ValueNode, ValueProgram, } from '../../language/value/compile/model.js';
 export interface CompiledProperty extends Omit<PropertyDefinition, 'schema'> {
     readonly name: string;
     readonly value: number;
@@ -38,7 +38,11 @@ export type CompiledClass = (Omit<Extract<ClassDefinition, {
     readonly properties: readonly CompiledProperty[];
 });
 export interface CompiledFunction extends Omit<import('../../language/callable/model/callable.js').FunctionDefinition, 'input' | 'output'> {
-    readonly input: number;
+    readonly input: number | {
+        readonly mode: 'binary';
+        readonly metadata: number;
+        readonly maximumBytes: number;
+    };
     readonly fields?: Readonly<Record<string, readonly number[]>>;
     readonly output: CompiledOutput;
 }
@@ -49,6 +53,10 @@ export type CompiledCoreEdge = CoreEdge;
 export interface CompiledSchemaEntry {
     readonly origin: Key.Origin;
     readonly revision: Revision;
+    /** The source Domain display name. */
+    readonly name: string;
+    /** The source Domain entrypoint View. */
+    readonly entrypoint?: ViewRef;
     readonly dependencies: DomainDependencyMap;
     readonly definitions: {
         readonly classes: readonly CompiledClass[];
@@ -60,14 +68,15 @@ export interface CompiledSchemaEntry {
     readonly facts: {
         readonly core: readonly CoreEdge[];
     };
-    readonly values: readonly ValueProgram[];
+    readonly values: readonly IndexedValueProgram[];
+    readonly patterns: readonly (Pattern | RunPattern)[];
 }
 declare const COMPILED_DOMAIN: unique symbol;
 export interface CompiledSchema<Resolved = Domain> {
     readonly format: 'astrale.dsl.compiled-schema';
-    readonly version: 1;
+    readonly version: 2;
     readonly root: DomainDependency;
     readonly closure: readonly CompiledSchemaEntry[];
-    readonly [COMPILED_DOMAIN]?: Resolved;
+    readonly [COMPILED_DOMAIN]: Resolved;
 }
 export type DomainOfCompiled<Value extends CompiledSchema> = Value extends CompiledSchema<infer Resolved> ? Resolved : Domain;

package/dist/v1/domain/create.js

@@ -1,4 +1,4 @@
-import { Key } from '../addressing/index.js';
+import { Key, MethodKey } from '../addressing/index.js';
 import { frozenRecord } from './namespace/member-collection.js';
 import { createClasses } from './projection/classes.js';
 const admittedDomains = new WeakSet();
@@ -58,14 +58,13 @@ export function createDomain(input) {
             if (classValue?.kind !== 'edge') {
                 throw new TypeError(`Core Edge has no Edge Class ${Key.of(edge.class)}.`);
             }
+            const endpoint = (ref) => ref.kind === 'domain'
+                ? domainEndpoint
+                : requiredCoreEndpoint(definitionsByKey, callables, ref);
             return Object.freeze({
                 class: classValue,
-                source: edge.source.kind === 'domain'
-                    ? domainEndpoint
-                    : requiredCore(definitionsByKey, edge.source),
-                target: edge.target.kind === 'domain'
-                    ? domainEndpoint
-                    : requiredCore(definitionsByKey, edge.target),
+                source: endpoint(edge.source),
+                target: endpoint(edge.target),
                 properties: edge.properties,
             });
         }));
@@ -105,24 +104,6 @@ export function createDomain(input) {
             definitions(kind) {
                 return kind === undefined ? local : local.filter(({ ref }) => ref.kind === kind);
             },
-            viewsFor(target) {
-                return Object.freeze(Object.values(views).filter((view) => {
-                    if (view.target.kind === 'domain')
-                        return target === 'domain';
-                    if (target === 'domain')
-                        return false;
-                    return view.target.definitions.some((ref) => {
-                        const selected = classesByKey.get(Key.of(ref));
-                        if (target.kind === 'node' && selected?.kind === 'node') {
-                            return target.satisfies(selected);
-                        }
-                        if (target.kind === 'edge' && selected?.kind === 'edge') {
-                            return target.satisfies(selected);
-                        }
-                        return false;
-                    });
-                }));
-            },
         };
         const admitted = Object.freeze(domain);
         facades.set(entry.origin, admitted);
@@ -148,6 +129,7 @@ function createDefinitions(declarations, classesByKey, input) {
                 description: definition.description,
                 input: definition.input,
                 output: definition.output,
+                ...(definition.execution === undefined ? {} : { execution: definition.execution }),
                 auth: definition.auth,
                 policy: definition.policy,
                 ...(inputFields === undefined ? {} : { inputFields }),
@@ -175,7 +157,6 @@ function createDefinitions(declarations, classesByKey, input) {
             definitionsByKey.set(key, Object.freeze({
                 ref: definition.ref,
                 key,
-                target: definition.target,
                 description: definition.description,
                 definition,
             }));
@@ -241,9 +222,18 @@ function namespace(definitions, kind) {
         .filter((value) => value.ref.kind === kind)
         .map((value) => [value.ref.name, value]));
 }
-function requiredCore(definitions, ref) {
+/** Every non-Domain Core endpoint addresses one already-resolved local Definition or Method. */
+function requiredCoreEndpoint(definitions, callables, ref) {
+    if (ref.kind === 'method') {
+        const key = MethodKey.of(ref.owner, ref.name);
+        const method = callables.get(key);
+        if (method === undefined || !('owner' in method)) {
+            throw new TypeError(`Core endpoint ${key} is absent.`);
+        }
+        return method;
+    }
     const value = definitions.get(Key.of(ref));
-    if (value?.ref.kind !== 'core')
+    if (value === undefined)
         throw new TypeError(`Core endpoint ${Key.of(ref)} is absent.`);
     return value;
 }

package/dist/v1/domain/model/domain.d.ts

@@ -36,7 +36,6 @@ export interface Domain<Classes extends Readonly<Record<string, unknown>> = Read
     callable(key: Key.Callable): ResolvedCallable | undefined;
     definitions(): readonly ResolvedDefinition[];
     definitions<const Kind extends DefinitionRef['kind']>(kind: Kind): readonly ResolvedDefinitionOf<Kind>[];
-    viewsFor(target: 'domain' | AnyResolvedClass): readonly Views[keyof Views][];
 }
 declare const DOMAIN_SOURCE_RESOLVED: unique symbol;
 /** Type-only witness carried by a source that retains its exact resolved Domain. */

package/dist/v1/domain/model/input.d.ts

@@ -3,6 +3,7 @@ import type { DomainDependency, DomainDependencyMap } from '../../addressing/ind
 import type { CoreEdge } from '../../language/core/model/core.js';
 import type { Definition } from '../../language/definition.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { ValueProgram } from '../../language/value/compile/model.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
 /** One admitted Schema entry in a dependency-closed Domain universe. */
 export interface DomainEntryInput {
@@ -22,6 +23,8 @@ export interface DomainInput {
 export interface DomainValidation {
     propertyExists(key: PropertyKey): boolean;
     property(key: PropertyKey, input: unknown): readonly Diagnostic[];
+    /** The admitted program `property` evaluates. */
+    propertyProgram(key: PropertyKey): ValueProgram;
     propertyOrdering(key: PropertyKey): OrderingKind | undefined;
     callableExists(key: AddressKey.Callable): boolean;
     callableInput(key: AddressKey.Callable, input: unknown): readonly Diagnostic[];

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

@@ -1,4 +1,6 @@
-import { compareUnicode, Key, MethodKey as MethodKeyValue, PropertyKey as PropertyKeyValue, } from '../../addressing/index.js';
+import { Key, MethodKey as MethodKeyValue, PropertyKey as PropertyKeyValue, } from '../../addressing/index.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
+import { classSatisfies } from '../../language/class/inheritance.js';
 import { acceptPropertyValues } from '../../language/class/property-values.js';
 import { appendPointer } from '../../language/value/syntax/pointer.js';
 import { createMethodCollection, createPropertyCollection } from '../namespace/member-collection.js';
@@ -24,29 +26,12 @@ export function createClasses(definitions, validation) {
             throw new TypeError(`Class ${key} extends a Class of another graph kind.`);
         }
         const shell = {};
-        const policies = Object.freeze({
-            read: Object.freeze(definition.kind === 'node'
-                ? uniquePolicyRefs([
-                    ...parents.flatMap((parent) => parent.kind === 'node' ? [...parent.policies.read] : []),
-                    ...(definition.policies.read === undefined ? [] : [definition.policies.read]),
-                ])
-                : []),
-            traverse: Object.freeze(uniquePolicyRefs([
-                ...parents.flatMap((parent) => [...parent.policies.traverse]),
-                ...(definition.policies.traverse === undefined ? [] : [definition.policies.traverse]),
-            ])),
-        });
         const effectiveProperties = new Map();
-        const effectiveMethods = new Map();
         let inheritedData;
         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;
         }
@@ -61,6 +46,7 @@ export function createClasses(definitions, validation) {
                 definition: propertyDefinition,
                 ...(ordering === undefined ? {} : { ordering }),
                 validate: (input) => validation.property(propertyKey, input),
+                program: () => validation.propertyProgram(propertyKey),
             });
             ownProperties.push(property);
             effectiveProperties.set(property.key, property);
@@ -81,22 +67,23 @@ export function createClasses(definitions, validation) {
                     description: methodDefinition.description,
                     input: methodDefinition.input,
                     output: methodDefinition.output,
+                    ...(methodDefinition.execution === undefined
+                        ? {}
+                        : { execution: methodDefinition.execution }),
                     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,
@@ -104,28 +91,19 @@ export function createClasses(definitions, validation) {
             abstract: definition.abstract,
             definition,
             extends: Object.freeze(parents),
-            policies,
+            policies: definition.policies,
             data: definition.kind === 'node' ? (ownData ?? inheritedData) : undefined,
             properties: createPropertyCollection(effectiveProperties.values()),
-            methods: createMethodCollection(instanceMethods),
-            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),
-                policies: definition.policies,
                 methods: createMethodCollection(ownInstanceMethods),
                 static: Object.freeze({ methods: createMethodCollection(ownStaticMethods) }),
             }),
             satisfies(selected) {
-                if (key === selected.key)
-                    return true;
-                return parents.some((parent) => {
-                    if (parent.kind === 'node' && selected.kind === 'node')
-                        return parent.satisfies(selected);
-                    if (parent.kind === 'edge' && selected.kind === 'edge')
-                        return parent.satisfies(selected);
-                    return false;
-                });
+                return classSatisfies(definition, selected.definition, (ref) => declarations.get(Key.of(ref)));
             },
             validateProperties(input) {
                 return validateProperties(definition.abstract, effectiveProperties, input);
@@ -140,12 +118,6 @@ export function createClasses(definitions, validation) {
         resolve(definition.ref);
     return resolved;
 }
-function uniquePolicyRefs(values) {
-    const result = new Map();
-    for (const value of values)
-        result.set(Key.of(value), value);
-    return [...result.values()].sort((left, right) => compareUnicode(Key.of(left), Key.of(right)));
-}
 function validateProperties(abstract, properties, input) {
     if (abstract) {
         return [

package/dist/v1/domain/validation/create.d.ts

@@ -1,10 +1,12 @@
 import type { Key, PropertyKey } from '../../addressing/index.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { ValueProgram } from '../../language/value/compile/model.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
 import type { DomainValidation } from '../model/input.js';
 export interface PropertyValidation {
     readonly ordering?: OrderingKind;
     validate(input: unknown): readonly Diagnostic[];
+    program(): ValueProgram;
 }
 export interface CallableValidation {
     readonly fields?: readonly string[];

package/dist/v1/domain/validation/create.js

@@ -6,6 +6,12 @@ export function createDomainValidation(properties, callables) {
             const target = properties.get(key);
             return target === undefined ? unknownTarget('Property', key) : target.validate(input);
         },
+        propertyProgram(key) {
+            const target = properties.get(key);
+            if (target === undefined)
+                throw new TypeError(`Property ${key} is absent.`);
+            return target.program();
+        },
         propertyOrdering: (key) => properties.get(key)?.ordering,
         callableExists: (key) => callables.has(key),
         callableInput(key, input) {
@@ -33,6 +39,12 @@ export function combineDomainValidation(values) {
             const owner = values.find((value) => value.propertyExists(key));
             return owner === undefined ? unknownTarget('Property', key) : owner.property(key, input);
         },
+        propertyProgram(key) {
+            const owner = values.find((value) => value.propertyExists(key));
+            if (owner === undefined)
+                throw new TypeError(`Property ${key} is absent.`);
+            return owner.propertyProgram(key);
+        },
         propertyOrdering: (key) => values.find((value) => value.propertyExists(key))?.propertyOrdering(key),
         callableExists: (key) => values.some((value) => value.callableExists(key)),
         callableInput(key, input) {

package/dist/v1/index.d.ts

@@ -1,8 +1,11 @@
 /** Stable aggregate facade for the V1 language. */
-export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, method, nodeClass, output, path, policy, property, valueSchema, view, } from './builder/index.js';
+export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, input, method, nodeClass, output, path, policy, property, stateProperty, valueSchema, view, } from './builder/index.js';
+export { stateMachine } from './language/state/index.js';
+export { isBinaryInput } from './language/callable/model/callable.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, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, CallablePolicy, ClassPolicy, ClassRuleChecks, ClassRuleObject, NodeClassPolicy, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, 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/index.js

@@ -1,5 +1,7 @@
 /** Stable aggregate facade for the V1 language. */
-export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, method, nodeClass, output, path, policy, property, valueSchema, view, } from './builder/index.js';
+export { auto, core, defineClass, defineSchema, edgeClass, func, fullMatch, input, method, nodeClass, output, path, policy, property, stateProperty, valueSchema, view, } from './builder/index.js';
+export { stateMachine } from './language/state/index.js';
+export { isBinaryInput } from './language/callable/model/callable.js';
 export { PropertyValues } from './language/index.js';
 export * as metadata from './language/definition/metadata.js';
 export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';

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

@@ -0,0 +1,27 @@
+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>;
+}
+/** Structured failure facts; human diagnostic wording is not compatibility evidence. */
+export type MethodCompositionIssue = {
+    readonly kind: 'signature';
+    readonly local: string;
+    readonly required: string;
+} | {
+    readonly kind: 'ambiguous';
+    readonly methods: readonly [string, string];
+} | {
+    readonly kind: 'missing';
+    readonly required: string;
+};
+/** 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, issue: MethodCompositionIssue) => void): MethodComposition<Method>;
+export {};

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

@@ -0,0 +1,52 @@
+/** 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}.`, {
+                kind: 'signature',
+                local: local.key,
+                required: 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}.`, {
+                kind: 'ambiguous',
+                methods: [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}.`, {
+                    kind: 'missing',
+                    required: 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 { CallablePolicy } 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';
@@ -13,21 +12,47 @@ export type CallableOutput = {
     readonly mode: 'binary';
 };
 export type OutputMode = CallableOutput['mode'];
-export interface CallableDefinitionBase {
+/**
+ * Execution modifier of a callable. Absent or `durable: false` means ordinary execution, and an
+ * accepted Schema keeps only `durable: true`. A durable invocation returns an Execution reference;
+ * the handler still returns `output`. Retry, retention and endpoint are never callable meaning. A
+ * durable callable takes a value input, which its Execution records so the run can be resubmitted.
+ */
+export interface CallableExecution {
+    readonly durable: boolean;
+}
+/** A binary Function receives portable metadata and one required byte stream. */
+export interface BinaryInput {
+    readonly mode: 'binary';
+    readonly metadata: JsonSchema;
+    readonly maximumBytes: number;
+}
+export type CallableInputContract = JsonSchema | BinaryInput;
+declare const BINARY_INPUT_PROJECTION: unique symbol;
+/** Type-only witness retained by authored Functions; never serialized as an input Value. */
+export interface BinaryInputProjection<out Metadata = unknown> {
+    readonly [BINARY_INPUT_PROJECTION]: Metadata;
+}
+export declare function isBinaryInput(input: CallableInputContract): input is BinaryInput;
+export interface CallableDefinitionBase<Input extends CallableInputContract = CallableInputContract> {
     readonly description?: string;
-    readonly input: JsonSchema;
+    readonly input: Input;
     readonly output: CallableOutput;
+    readonly execution?: CallableExecution;
 }
-export type CallableDefinition = CallableDefinitionBase & ({
+export type CallableDefinition<Input extends CallableInputContract = CallableInputContract> = CallableDefinitionBase<Input> & ({
     readonly auth: 'anonymous' | 'authenticated';
     readonly policy?: never;
-} | {
+}
+/** An absent Policy admits no caller beyond Kernel Root and exact Function ownership. */
+ | {
     readonly auth: 'authorized';
-    readonly policy?: PolicyCheckExpression;
+    readonly policy?: CallablePolicy;
 });
 export type FunctionDefinition = DefinitionBase<FunctionRef> & CallableDefinition;
-export type MethodDefinition = CallableDefinition & {
+export type MethodDefinition = CallableDefinition<JsonSchema> & {
     readonly static: boolean;
-    readonly inheritance: MethodInheritance;
+    readonly abstract: boolean;
 };
 export type MethodRecord = Readonly<Record<string, MethodDefinition>>;
+export {};

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

@@ -1 +1,3 @@
-export {};
+export function isBinaryInput(input) {
+    return typeof input === 'object' && input !== null && input.mode === 'binary';
+}