@astrale-os/kernel-dsl 1.0.0-beta.4 → 1.0.0-beta.6

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

@@ -1,7 +1,7 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
 import type { PolicyRef } from '../../addressing/index.js';
-import type { BinaryInputProjection, CallableExecution, FunctionAuth } from '../../language/callable/model/callable.js';
+import type { BinaryInputProjection, CallableAdmission, CallableExecution, 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';
@@ -62,6 +62,8 @@ export interface CallableInputBase<Input extends FunctionInputSchema = ValueSche
     readonly output: CallableOutputInput;
     /** `{ durable: true }` makes an invocation return an Execution reference. */
     readonly execution?: CallableExecution;
+    /** `{ maxAge }`: how old, in seconds, the admission a call is served under may be. */
+    readonly admission?: CallableAdmission;
 }
 type ConcreteCallableInput<Input extends FunctionInputSchema = ValueSchemaInput> = CallableInputBase<Input> & ({
     readonly auth: 'anonymous';
@@ -83,7 +85,7 @@ export type MethodInput = ConcreteCallableInput & {
     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, out Execution extends CallableExecution | undefined = CallableExecution | undefined> {
+export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Abstract extends boolean = boolean, out Execution extends CallableExecution | undefined = CallableExecution | undefined, out Admission extends CallableAdmission | undefined = CallableAdmission | undefined> {
     readonly [CALLABLE_PROJECTION_VALUE]: true;
     readonly input: Input;
     readonly output: Output;
@@ -91,6 +93,7 @@ export interface CallableProjection<out Input = unknown, out Output = unknown, o
     readonly static: Static;
     readonly abstract: Abstract;
     readonly execution: Execution;
+    readonly admission: Admission;
 }
 type ValueInputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
 type FunctionInputOf<Schema> = Schema extends BinaryInputAuthoring<infer Metadata> ? BinaryInputProjection<ValueInputOf<Metadata>> : ValueInputOf<Schema>;
@@ -98,6 +101,9 @@ type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Valu
 type ExecutionOfConfig<Config extends CallableInput> = Config extends {
     readonly execution: infer Execution extends CallableExecution;
 } ? Execution : undefined;
+type AdmissionOfConfig<Config extends CallableInput> = Config extends {
+    readonly admission: infer Admission extends CallableAdmission;
+} ? Admission : undefined;
 type CallableOutputOf<Input extends CallableOutputInput> = Input extends StreamOutput<infer Item> ? {
     readonly mode: 'stream';
     readonly item: ValueOutputOf<Item>;
@@ -120,12 +126,12 @@ export type ProjectionOfCallable<Value extends Function | Method> = Value extend
 export declare function callableConfiguration(value: Function | Method): CallableInput;
 type PolicyObjectAuthoring = Class | Function | Method | Policy | View | CoreNode;
 export type PolicyObjectInput = Lazy<PolicyObjectAuthoring | PolicyObjectRef>;
-export declare function func<const Config extends FunctionInput, Input = FunctionInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false, Execution>>;
+export declare function func<const Config extends FunctionInput, Input = FunctionInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>, Admission extends CallableAdmission | undefined = AdmissionOfConfig<Config>>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false, Execution, Admission>>;
 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, Abstract extends boolean = Config extends {
     readonly abstract: infer Value extends boolean;
-} ? Value : false, Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract, Execution>>;
+} ? Value : false, Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>, Admission extends CallableAdmission | undefined = AdmissionOfConfig<Config>>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract, Execution, Admission>>;
 export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
     readonly kind: 'input';
 }>;

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

@@ -18,6 +18,7 @@ export function func(config) {
         'static',
         'abstract',
         'execution',
+        'admission',
     ]);
     const value = authoringValue('function', {});
     callableInputs.set(value, { ...config });
@@ -33,6 +34,7 @@ export function method(config) {
         'static',
         'abstract',
         'execution',
+        'admission',
     ]);
     const value = authoringValue('method', {});
     callableInputs.set(value, { ...config });

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

@@ -3,8 +3,9 @@ import type { z } from 'zod';
 import type { ClassRef } from '../../addressing/index.js';
 import type { MethodRecord } from '../../language/callable/model/callable.js';
 import type { ResolvedMethod } from '../../language/callable/resolved.js';
+import type { Inheritance } from '../../language/class/model/class.js';
 import type { MediaType } from '../../language/class/model/data.js';
-import type { EdgeCount } from '../../language/class/model/edge.js';
+import type { EdgeCount, EdgeUniqueTuple } from '../../language/class/model/edge.js';
 import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
 import type { ClassRuleChecks, ClassRuleObject } from '../../language/policy/model/policy.js';
 import type { StateTopology, StateTopologyOf } from '../../language/state/topology.js';
@@ -58,6 +59,8 @@ export interface NodeClassPoliciesInput {
 }
 export interface NodeClassInput {
     readonly abstract?: boolean;
+    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
+    readonly inheritance?: Inheritance;
     readonly description?: string;
     readonly extends?: readonly NodeClassReferenceInput[];
     readonly properties?: PropertyRecordInput;
@@ -69,6 +72,8 @@ export interface NodeClassInput {
 }
 export interface EdgeClassOptions {
     readonly abstract?: boolean;
+    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
+    readonly inheritance?: Inheritance;
     readonly description?: string;
     readonly extends?: readonly EdgeClassReferenceInput[];
     readonly properties?: PropertyRecordInput;
@@ -83,6 +88,11 @@ export interface DirectedEdgeInput extends EdgeClassOptions {
     readonly orientation: 'directed';
     readonly source: DirectedSourceInput;
     readonly target: DirectedTargetInput;
+    /**
+     * The tuples no two Edges of this Class and of its active concrete descendants share; omitted,
+     * none. A descendant is covered without declaring them again.
+     */
+    readonly unique?: readonly EdgeUniqueTuple[];
 }
 export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints'> {
     readonly orientation: 'undirected';

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

@@ -17,6 +17,7 @@ export function nodeClass(config) {
     const admitted = config ?? {};
     assertKnownKeys(admitted, [
         'abstract',
+        'inheritance',
         'description',
         'extends',
         'properties',
@@ -39,15 +40,17 @@ export const edgeClass = Object.freeze({
             'source',
             'target',
             'abstract',
+            'inheritance',
             'description',
             'extends',
             'properties',
             'policies',
             'constraints',
+            'unique',
         ]);
         validateDirectedSourceInput(input.source);
         validateDirectedTargetInput(input.target);
-        const { source, target, ...options } = input;
+        const { source, target, unique, ...options } = input;
         validateEdgeClassOptions(options);
         const value = authoringValue('definition', {
             kind: 'edge',
@@ -56,6 +59,10 @@ export const edgeClass = Object.freeze({
         classInputs.set(value, {
             source: { ...source },
             target: { ...target },
+            // Copied, so the declaration does not follow later changes to the author's arrays.
+            ...(unique === undefined
+                ? {}
+                : { unique: unique.map((tuple) => [...tuple]) }),
             ...options,
             abstract: options.abstract ?? false,
         });
@@ -65,6 +72,7 @@ export const edgeClass = Object.freeze({
         assertKnownKeys(input, [
             'endpoints',
             'abstract',
+            'inheritance',
             'description',
             'extends',
             'properties',
@@ -107,6 +115,7 @@ function validateIncidentEndpointInput(value) {
 function validateEdgeClassOptions(value) {
     assertKnownKeys(value, [
         'abstract',
+        'inheritance',
         'description',
         'extends',
         'properties',
@@ -121,6 +130,7 @@ function validateEdgeClassOptions(value) {
 function validateUndirectedEdgeClassOptions(value) {
     assertKnownKeys(value, [
         'abstract',
+        'inheritance',
         'description',
         'extends',
         'properties',

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

@@ -42,6 +42,7 @@ export class V1CallableCompiler {
             input,
             output,
             ...(config.execution === undefined ? {} : { execution: config.execution }),
+            ...(config.admission === undefined ? {} : { admission: config.admission }),
         };
         const contract = auth === 'authorized'
             ? { ...base, auth, ...(policy === undefined ? {} : { policy }) }

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

@@ -31,6 +31,7 @@ export class V1DefinitionCompiler {
             ref: { origin: this.context.origin, kind: 'class', name },
             kind: 'node',
             abstract: input.abstract ?? false,
+            ...declaredInheritance(input.inheritance),
             ...(input.description === undefined ? {} : { description: input.description }),
             extends: this.parents(input.extends, 'node', `${pointer}/extends`),
             properties: facet,
@@ -53,6 +54,7 @@ export class V1DefinitionCompiler {
                         target: this.directedTarget(directed.target, `${pointer}/endpoints/target`),
                     },
                     constraints: directedConstraints(directed),
+                    ...(directed.unique === undefined ? {} : { unique: directed.unique }),
                 };
             }
             const undirected = classConfiguration(value);
@@ -69,6 +71,7 @@ export class V1DefinitionCompiler {
             ref: { origin: this.context.origin, kind: 'class', name },
             kind: 'edge',
             abstract: input.abstract ?? false,
+            ...declaredInheritance(input.inheritance),
             ...(input.description === undefined ? {} : { description: input.description }),
             extends: this.parents(input.extends, 'edge', `${pointer}/extends`),
             properties: facet,
@@ -158,6 +161,10 @@ export class V1DefinitionCompiler {
         }));
     }
 }
+/** The default `'internal'` is never declared, so a Class that keeps it keeps its revision. */
+function declaredInheritance(inheritance) {
+    return inheritance === undefined || inheritance === 'internal' ? {} : { inheritance };
+}
 function dataDeclaration(mediaType) {
     return mediaType === undefined ? undefined : { mediaType };
 }

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

@@ -18,6 +18,7 @@ type CallableConfig<Value> = Value extends Method<infer Config> ? Config extends
 type CallableInputValue<Value extends Method | Function> = CallableConfig<Value>['input'];
 type CallableOutputValue<Value extends Method | Function> = CallableConfig<Value>['output'];
 type CallableExecutionOf<Value extends Method | Function> = CallableConfig<Value>['execution'];
+type CallableAdmissionOf<Value extends Method | Function> = CallableConfig<Value>['admission'];
 type CallableStaticOf<Value extends Method> = CallableConfig<Value> extends {
     readonly static: true;
 } ? true : false;
@@ -25,11 +26,11 @@ 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<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>>, CallableExecutionOf<Value>> : 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>>, CallableExecutionOf<Value>, CallableAdmissionOf<Value>> : never;
 type MethodProjectionOfEntries<Origin extends string, OwnerName extends string, Entries> = Entries extends unknown ? MethodProjectionOfEntry<Origin, OwnerName, Entries> : 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, Value['executable'], Value['execution']> : never;
+} ? MethodProjection<Input, Output, Static, Abstract, Auth, Name, Key, Value['executable'], Value['execution'], Value['admission']> : never;
 /** Capture each Method through its qualified lookup key. */
 export type MethodsOfCollection<Value> = Value extends {
     readonly byKey: infer ByKey extends Readonly<Record<language.MethodKey, language.ResolvedMethod>>;
@@ -41,11 +42,12 @@ export type OwnStaticMethodProjectionsOf<Origin extends string, Name extends str
 /** Bind an authored Function to its exact Domain coordinates. */
 export type FunctionProjectionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends Function ? FunctionProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, language.FunctionRef<Name> & {
     readonly origin: Origin;
-}, language.DefinitionKey<Origin, 'function', Name>, CallableExecutionOf<Value>> : never;
-/** Restore a resolved Function while preserving its execution modifier. */
-export type ResolvedFunctionOfProjection<Value extends FunctionProjection> = Value extends FunctionProjection<infer Input, infer Output, infer Auth, infer Ref, infer Key, infer Execution> ? language.ResolvedFunction<Input, Output, Auth, language.CallablePolicy> & {
+}, language.DefinitionKey<Origin, 'function', Name>, CallableExecutionOf<Value>, CallableAdmissionOf<Value>> : never;
+/** Restore a resolved Function while preserving its execution modifier and admission age. */
+export type ResolvedFunctionOfProjection<Value extends FunctionProjection> = Value extends FunctionProjection<infer Input, infer Output, infer Auth, infer Ref, infer Key, infer Execution, infer Admission> ? language.ResolvedFunction<Input, Output, Auth, language.CallablePolicy> & {
     readonly ref: Ref;
     readonly key: Key;
     readonly execution: Execution;
+    readonly admission: Admission;
 } : never;
 export {};

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

@@ -10,7 +10,7 @@ export interface PropertyProjection<Value = unknown, Required extends boolean =
     readonly input: Input;
 }
 /** A Method’s exact callable, ownership and executable contracts. */
-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, Execution extends language.CallableExecution | undefined = language.CallableExecution | undefined> {
+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, Execution extends language.CallableExecution | undefined = language.CallableExecution | undefined, Admission extends language.CallableAdmission | undefined = language.CallableAdmission | undefined> {
     readonly input: Input;
     readonly output: Output;
     readonly static: Static;
@@ -20,15 +20,17 @@ export interface MethodProjection<Input = unknown, Output = unknown, Static exte
     readonly name: Name;
     readonly key: Key;
     readonly execution: Execution;
+    readonly admission: Admission;
 }
 /** A Function’s exact callable and declaration contracts. */
-export interface FunctionProjection<Input = unknown, Output = unknown, Auth extends language.FunctionAuth = language.FunctionAuth, Ref extends language.FunctionRef = language.FunctionRef, Key extends language.DefinitionKey<string, 'function'> = language.DefinitionKey<string, 'function'>, Execution extends language.CallableExecution | undefined = language.CallableExecution | undefined> {
+export interface FunctionProjection<Input = unknown, Output = unknown, Auth extends language.FunctionAuth = language.FunctionAuth, Ref extends language.FunctionRef = language.FunctionRef, Key extends language.DefinitionKey<string, 'function'> = language.DefinitionKey<string, 'function'>, Execution extends language.CallableExecution | undefined = language.CallableExecution | undefined, Admission extends language.CallableAdmission | undefined = language.CallableAdmission | undefined> {
     readonly input: Input;
     readonly output: Output;
     readonly auth: Auth;
     readonly ref: Ref;
     readonly key: Key;
     readonly execution: Execution;
+    readonly admission: Admission;
 }
 /** A compact Class witness with effective members and exact self facets. */
 export interface ClassProjection<Kind extends language.ClassKind = language.ClassKind, Definition extends Extract<language.ClassDefinition, {

package/dist/v1/builder/schema/projection/resolved-class.d.ts

@@ -56,10 +56,11 @@ type ProjectionPropertyByName<Entries extends PropertyProjection> = Readonly<{
 /** Restore qualified lookup and unambiguous named Property access. */
 type PropertyCollectionOfProjection<Entries extends PropertyProjection> = language.ResolvedPropertyCollection<ProjectionPropertyByKey<Entries>, ProjectionPropertyByName<Entries>>;
 type MethodCollectionOperation = 'byKey' | 'get';
-type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer Name, infer Key, infer Executable, infer Execution> ? language.ResolvedMethod<Input, Output, Static, Abstract, Auth, language.CallablePolicy, Key> & {
+type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer Name, infer Key, infer Executable, infer Execution, infer Admission> ? language.ResolvedMethod<Input, Output, Static, Abstract, Auth, language.CallablePolicy, Key> & {
     readonly name: Name;
     readonly executable: Executable;
     readonly execution: Execution;
+    readonly admission: Admission;
 } : never;
 type ProjectionMethodByKey<Entries extends MethodProjection> = Readonly<{
     [Key in Entries['key']]: ResolvedMethodOfProjection<Extract<Entries, {

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

@@ -22,6 +22,8 @@ export function analyzeClasses(classes) {
             const parent = classes.get(Key.of(ref));
             if (parent === undefined)
                 fail(`${located.pointer}/extends/${index}`, 'Parent Class is absent.');
+            if (parent.value.inheritance === 'final')
+                fail(`${located.pointer}/extends/${index}`, 'A final Class has no subclass.');
             return analyze(parent);
         });
         const properties = new Map();
@@ -116,9 +118,14 @@ export function validateClassFacets(context) {
         }
         if (located.value.kind === 'node') {
             for (const [index, method] of located.value.methods.entries()) {
-                if (!isMethodExecutable(located.value, method) && method.policy !== undefined) {
+                if (isMethodExecutable(located.value, method))
+                    continue;
+                if (method.policy !== undefined) {
                     fail(`${located.pointer}/methods/${index}/policy`, 'An abstract Method cannot have a Policy.');
                 }
+                if (method.admission !== undefined) {
+                    fail(`${located.pointer}/methods/${index}/admission`, 'An abstract Method cannot have an admission age.');
+                }
             }
         }
     }

package/dist/v1/compiled/admission/wire/callable.js

@@ -1,4 +1,5 @@
 import {} from '@astrale-os/kernel-dsl/value';
+import { isAdmissionMaxAge } from '../../../language/callable/admission.js';
 import {} from '../../model/schema.js';
 import { invalid, pointer } from '../diagnostic.js';
 import { callablePolicy } from './policy.js';
@@ -16,7 +17,7 @@ export function compiledCallable(input, values, method, path) {
     const value = object(input, 'Compiled Callable', path);
     exact(value, method
         ? ['name', 'auth', 'static', 'abstract', 'input', 'output']
-        : ['ref', 'auth', 'input', 'output'], 'Compiled Callable', path, ['policy', 'description', 'execution', 'fields']);
+        : ['ref', 'auth', 'input', 'output'], 'Compiled Callable', path, ['policy', 'description', 'execution', 'admission', 'fields']);
     if (method) {
         memberName(value.name, 'Method name', `${path}/name`);
         boolean(value.static, 'Method static', `${path}/static`);
@@ -87,4 +88,13 @@ export function compiledCallable(input, values, method, path) {
             invalid('durable Callable output', 'COMPILED_SOURCE_INVALID', `${outputPath}/mode`);
         }
     }
+    if (value.admission !== undefined) {
+        const admissionPath = `${path}/admission`;
+        const admission = object(value.admission, 'Callable admission', admissionPath);
+        exact(admission, ['maxAge'], 'Callable admission', admissionPath);
+        // An absent admission age is the only spelling of a call admitted afresh.
+        if (!isAdmissionMaxAge(admission.maxAge)) {
+            invalid('Callable admission age', 'COMPILED_SOURCE_INVALID', `${admissionPath}/maxAge`);
+        }
+    }
 }

package/dist/v1/compiled/admission/wire/class.js

@@ -25,9 +25,15 @@ export function compiledClass(input, values, path) {
             'constraints',
             'properties',
             'policies',
-        ], 'Compiled Class', path, value.kind === 'node' ? ['data', 'description', 'icon'] : ['description']);
+        ], 'Compiled Class', path, value.kind === 'node'
+        ? ['data', 'description', 'icon', 'inheritance']
+        : ['description', 'inheritance', 'unique']);
     definitionRef(value.ref, 'class', 'Class ref', `${path}/ref`);
     boolean(value.abstract, 'Class abstract', `${path}/abstract`);
+    if (value.inheritance !== undefined &&
+        value.inheritance !== 'open' &&
+        value.inheritance !== 'final')
+        invalid('Class inheritance', undefined, `${path}/inheritance`);
     description(value.description, 'Class description', `${path}/description`);
     const extendsPath = `${path}/extends`;
     const parents = array(value.extends, 'Class extends', extendsPath).map((parent, index) => definitionRef(parent, 'class', 'Class parent', `${extendsPath}/${index}`));
@@ -93,9 +99,13 @@ function edgeContract(value, path) {
             object(endpoints.target, 'directed Edge target', `${endpointsPath}/target`).role) {
             invalid('Edge endpoint roles', undefined, endpointsPath);
         }
+        if (value.unique !== undefined)
+            uniqueTuples(value.unique, `${path}/unique`);
         return;
     }
-    if (value.orientation !== 'undirected' || constraints.acyclic !== undefined) {
+    if (value.orientation !== 'undirected' ||
+        constraints.acyclic !== undefined ||
+        value.unique !== undefined) {
         invalid('Edge orientation', undefined, `${path}/orientation`);
     }
     const endpointsPath = `${path}/endpoints`;
@@ -109,6 +119,18 @@ function edgeContract(value, path) {
         invalid('Edge endpoint roles', undefined, endpointsPath);
     }
 }
+/** A nonempty list of distinct tuples, each naming the source and then the slug. */
+function uniqueTuples(input, path) {
+    const tuples = array(input, 'Edge unique tuples', path);
+    if (tuples.length === 0)
+        invalid('Edge unique tuples', undefined, path);
+    for (const [index, tuple] of tuples.entries()) {
+        const fields = array(tuple, 'Edge unique tuple', `${path}/${index}`);
+        if (fields.length !== 2 || fields[0] !== 'source' || fields[1] !== 'slug')
+            invalid('Edge unique tuple', undefined, `${path}/${index}`);
+    }
+    unique(tuples.map((tuple) => JSON.stringify(tuple)), 'Edge unique tuples', path);
+}
 function edgeEndpoint(input, count, label, path) {
     const value = object(input, label, path);
     exact(value, ['role', 'accepts', count], label, path);

package/dist/v1/compiled/compiler/compile.js

@@ -89,6 +89,7 @@ function compileEntry(schema, lookup) {
                 static: method.static,
                 abstract: method.abstract,
                 ...(method.execution === undefined ? {} : { execution: method.execution }),
+                ...(method.admission === undefined ? {} : { admission: method.admission }),
                 input,
                 ...(fields === undefined ? {} : { fields }),
                 output: output(method.output, `${pointer}/methods/${name}/output`),
@@ -117,6 +118,7 @@ function compileEntry(schema, lookup) {
             ...(definition.policy === undefined ? {} : { policy: definition.policy }),
             ...(definition.description === undefined ? {} : { description: definition.description }),
             ...(definition.execution === undefined ? {} : { execution: definition.execution }),
+            ...(definition.admission === undefined ? {} : { admission: definition.admission }),
             input,
             ...(fields === undefined ? {} : { fields }),
             output: output(definition.output, `/functions/${definition.ref.name}/output`),

package/dist/v1/domain/create.js

@@ -130,6 +130,7 @@ function createDefinitions(declarations, classesByKey, input) {
                 input: definition.input,
                 output: definition.output,
                 ...(definition.execution === undefined ? {} : { execution: definition.execution }),
+                ...(definition.admission === undefined ? {} : { admission: definition.admission }),
                 auth: definition.auth,
                 policy: definition.policy,
                 ...(inputFields === undefined ? {} : { inputFields }),

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

@@ -70,6 +70,9 @@ export function createClasses(definitions, validation) {
                     ...(methodDefinition.execution === undefined
                         ? {}
                         : { execution: methodDefinition.execution }),
+                    ...(methodDefinition.admission === undefined
+                        ? {}
+                        : { admission: methodDefinition.admission }),
                     auth: methodDefinition.auth,
                     policy: methodDefinition.policy,
                     static: methodDefinition.static,

package/dist/v1/index.d.ts

@@ -5,7 +5,7 @@ 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, 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 type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, Inheritance, 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/language/callable/admission.d.ts

@@ -0,0 +1,15 @@
+import type { CallablePolicy } from '../policy/model/policy.js';
+/**
+ * The language ceiling of a declared admission age, in seconds. Raising it later widens the
+ * language; lowering it would refuse accepted Schemas.
+ */
+export declare const MAXIMUM_ADMISSION_AGE_SECONDS = 300;
+/** Whether `value` is a declarable admission age: an integer from 1 to the language ceiling. */
+export declare function isAdmissionMaxAge(value: unknown): value is number;
+/**
+ * The input fields an admission of this callable reads: the `field` of every `input` check object
+ * of its Policy, unique and in Unicode code-point order. A callable without Policy checks reads no
+ * input field. Two calls that agree on these fields, and on everything else the admission reads,
+ * receive the same admission.
+ */
+export declare function admissionInputFields(policy: CallablePolicy | undefined): readonly string[];

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

@@ -0,0 +1,43 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+/**
+ * The language ceiling of a declared admission age, in seconds. Raising it later widens the
+ * language; lowering it would refuse accepted Schemas.
+ */
+export const MAXIMUM_ADMISSION_AGE_SECONDS = 300;
+/** Whether `value` is a declarable admission age: an integer from 1 to the language ceiling. */
+export function isAdmissionMaxAge(value) {
+    return (typeof value === 'number' &&
+        Number.isInteger(value) &&
+        value >= 1 &&
+        value <= MAXIMUM_ADMISSION_AGE_SECONDS);
+}
+/**
+ * The input fields an admission of this callable reads: the `field` of every `input` check object
+ * of its Policy, unique and in Unicode code-point order. A callable without Policy checks reads no
+ * input field. Two calls that agree on these fields, and on everything else the admission reads,
+ * receive the same admission.
+ */
+export function admissionInputFields(policy) {
+    if (policy === undefined || policy === true)
+        return Object.freeze([]);
+    const fields = new Set();
+    collectInputFields(policy, fields);
+    return Object.freeze([...fields].sort(compareUnicode));
+}
+function collectInputFields(expression, fields) {
+    if ('check' in expression) {
+        if (expression.object.kind === 'input')
+            fields.add(expression.object.field);
+        return;
+    }
+    if ('sameNode' in expression) {
+        for (const object of [expression.sameNode.left, expression.sameNode.right]) {
+            if (object.kind === 'input')
+                fields.add(object.field);
+        }
+        return;
+    }
+    for (const child of 'allOf' in expression ? expression.allOf : expression.anyOf) {
+        collectInputFields(child, fields);
+    }
+}

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

@@ -21,6 +21,15 @@ export type OutputMode = CallableOutput['mode'];
 export interface CallableExecution {
     readonly durable: boolean;
 }
+/**
+ * Admission age of a callable: how old, in whole seconds, the admission decision used for one of its
+ * calls may be. A destination may reuse an admission it received within that age; a Runtime that
+ * never reuses one conforms. Absent means every call is admitted afresh, and `maxAge` is an integer
+ * from 1 to `MAXIMUM_ADMISSION_AGE_SECONDS`.
+ */
+export interface CallableAdmission {
+    readonly maxAge: number;
+}
 /** A binary Function receives portable metadata and one required byte stream. */
 export interface BinaryInput {
     readonly mode: 'binary';
@@ -39,6 +48,7 @@ export interface CallableDefinitionBase<Input extends CallableInputContract = Ca
     readonly input: Input;
     readonly output: CallableOutput;
     readonly execution?: CallableExecution;
+    readonly admission?: CallableAdmission;
 }
 export type CallableDefinition<Input extends CallableInputContract = CallableInputContract> = CallableDefinitionBase<Input> & ({
     readonly auth: 'anonymous' | 'authenticated';

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

@@ -2,7 +2,7 @@ import type { DefinitionKey, FunctionRef, Key, MethodKey } from '../../addressin
 import type { ResolvedClass } from '../class/resolved.js';
 import type { CallablePolicy } from '../policy/model/policy.js';
 import type { Diagnostic } from '../validation/diagnostic.js';
-import type { BinaryInputProjection, CallableExecution, FunctionDefinition, MethodDefinition } from './model/callable.js';
+import type { BinaryInputProjection, CallableAdmission, CallableExecution, FunctionDefinition, MethodDefinition } from './model/callable.js';
 import type { FunctionAuth } from './model/callable.js';
 type CallableDefinitionOf<Definition extends FunctionDefinition | MethodDefinition, Auth extends FunctionAuth, Policy extends CallablePolicy> = Omit<Definition, 'auth' | 'policy'> & (Auth extends FunctionAuth ? {
     readonly auth: Auth;
@@ -22,6 +22,8 @@ export interface ResolvedMethod<out Input = unknown, out Output = unknown, out S
     readonly output: MethodDefinition['output'];
     /** Present only for a durable Method. */
     readonly execution?: CallableExecution;
+    /** Present only when the Method declares an admission age. */
+    readonly admission?: CallableAdmission;
     readonly auth: Auth;
     readonly policy?: Auth extends 'authorized' ? Policy : never;
     readonly static: Static;
@@ -53,6 +55,8 @@ export interface ResolvedFunction<out Input = unknown, out Output = unknown, out
     readonly output: FunctionDefinition['output'];
     /** Present only for a durable Function. */
     readonly execution?: CallableExecution;
+    /** Present only when the Function declares an admission age. */
+    readonly admission?: CallableAdmission;
     readonly auth: Auth;
     readonly policy?: Auth extends 'authorized' ? Policy : never;
     /** Present only when the callable input is a safely enumerable closed object. */

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

@@ -1,12 +1,16 @@
 import type { ClassRef } from '../../addressing/index.js';
-import type { ClassKind } from './model/class.js';
-/** The representation shared by source, compiled and resolved Class admission. */
-export interface ClassInheritance {
+import type { ClassKind, Inheritance } from './model/class.js';
+/** A Class as satisfaction reads it, shared by source, compiled and resolved Class admission. */
+export interface ClassAncestry {
     readonly ref: ClassRef;
     readonly kind: ClassKind;
     readonly extends: readonly ClassRef[];
 }
 /** Kernel graph roots are intrinsic supertypes, not authored structural Edge contracts. */
-export declare function isGraphRoot(value: Pick<ClassInheritance, 'ref' | 'kind'>): boolean;
+export declare function isGraphRoot(value: Pick<ClassAncestry, 'ref' | 'kind'>): boolean;
 /** Same-kind satisfaction includes the intrinsic root and the declared parent closure. */
-export declare function classSatisfies(candidate: ClassInheritance, required: ClassInheritance, resolve: (ref: ClassRef) => ClassInheritance | undefined): boolean;
+export declare function classSatisfies(candidate: ClassAncestry, required: ClassAncestry, resolve: (ref: ClassRef) => ClassAncestry | undefined): boolean;
+/** The inheritance a Class declares, `'internal'` when it declares none. */
+export declare function inheritanceOf(declaration: {
+    readonly inheritance?: Inheritance;
+}): Inheritance;

package/dist/v1/language/class/inheritance.js

@@ -23,3 +23,7 @@ export function classSatisfies(candidate, required, resolve) {
     };
     return visit(candidate);
 }
+/** The inheritance a Class declares, `'internal'` when it declares none. */
+export function inheritanceOf(declaration) {
+    return declaration.inheritance ?? 'internal';
+}