@astrale-os/kernel-dsl 1.0.0-beta.3 → 1.0.0-beta.5

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/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/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

@@ -116,9 +116,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/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

@@ -14,6 +14,7 @@ export { isDomain } from './domain/index.js';
 export type * as builder from './builder/index.js';
 export type { PathAuthoring, TypedValueSchema } from './builder/index.js';
 export type { PropertyValues as PropertyValuesValue } from './language/index.js';
+export type { BlobReceipt, BlobRef } from './language/value/model/blob.js';
 export type { CompiledSchema } from './compiled/index.js';
 export * as schema from './schema/index.js';
 export * as bundle from './bundle/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/index.d.ts

@@ -1,3 +1,4 @@
+export { admissionInputFields, isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from './callable/admission.js';
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodKey, PolicyRef, PropertyKey, ViewRef, } from '../addressing/index.js';

package/dist/v1/language/index.js

@@ -1,3 +1,4 @@
+export { admissionInputFields, isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from './callable/admission.js';
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export { valueProgramIncludes } from './value/inclusion/includes.js';

package/dist/v1/language/value/evaluate/validate.js

@@ -2,6 +2,7 @@ import { diagnostic } from '../../validation/diagnostic.js';
 import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
 import { evaluateInstance } from './evaluator.js';
 import { prepareValueSchema, } from './preparation.js';
+import { satisfies } from './validity.optimization.js';
 const validatorCache = new WeakMap();
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
@@ -30,6 +31,9 @@ export function validatePreparedInstance(compiled, value) {
         : instanceDiagnostics(compiled, value, '');
 }
 function instanceDiagnostics(compiled, value, pointer) {
+    // A value the compiled check finds valid has nothing to report; any other is evaluated.
+    if (satisfies(compiled, value) === true)
+        return [];
     const result = evaluateInstance(compiled, value);
     if (result.valid)
         return [];

package/dist/v1/language/value/evaluate/validity.optimization.d.ts

@@ -0,0 +1,14 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { CompiledInstanceSchema } from './types.js';
+/**
+ * Whether a value satisfies its prepared schema, as the evaluator decides it, without building a
+ * failure, an instance pointer or an annotation: the evaluator's verdict, or undefined when this
+ * check cannot give it. Only the evaluator reports why a value fails, so a caller keeps it for
+ * every value this check does not find valid.
+ *
+ * Each schema location is compiled once into a closure over its keywords, retained with the
+ * prepared schema. A schema whose closure holds an annotation-dependent keyword
+ * (`unevaluatedItems`, `unevaluatedProperties`) is left to the evaluator, as is a value nested
+ * deeper than this check follows, and any value whose check throws.
+ */
+export declare function satisfies(compiled: CompiledInstanceSchema, value: JsonValue): boolean | undefined;

package/dist/v1/language/value/evaluate/validity.optimization.js

@@ -0,0 +1,342 @@
+import { isCanonicalBlobRef } from '../model/blob.js';
+import { isInstantValue } from '../model/instant.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { codePointLength, isMultipleOf, jsonEqual, matchesType, unique } from './assertions.js';
+/**
+ * Whether a value satisfies its prepared schema, as the evaluator decides it, without building a
+ * failure, an instance pointer or an annotation: the evaluator's verdict, or undefined when this
+ * check cannot give it. Only the evaluator reports why a value fails, so a caller keeps it for
+ * every value this check does not find valid.
+ *
+ * Each schema location is compiled once into a closure over its keywords, retained with the
+ * prepared schema. A schema whose closure holds an annotation-dependent keyword
+ * (`unevaluatedItems`, `unevaluatedProperties`) is left to the evaluator, as is a value nested
+ * deeper than this check follows, and any value whose check throws.
+ */
+export function satisfies(compiled, value) {
+    let checks = compilations.get(compiled);
+    if (checks === undefined) {
+        checks = annotationFree(compiled) ? new Map() : null;
+        compilations.set(compiled, checks);
+    }
+    if (checks === null)
+        return undefined;
+    const outer = verdicts;
+    verdicts = new Map();
+    try {
+        return checkOf(compiled, checks, compiled.root)(value, 0);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        verdicts = outer;
+    }
+}
+/** Per prepared schema: its checks by location, or null when its closure needs annotations. */
+const compilations = new WeakMap();
+/** Locations one evaluation follows before leaving the value to the evaluator. */
+const MAXIMUM_DEPTH = 1_024;
+const UNDECIDED = new Error('The value is left to the evaluator.');
+/**
+ * The verdicts of the current evaluation by referenced location and value. Only a reference reaches
+ * one location from several places, so each referenced location is checked once per value, as the
+ * evaluator memoizes it, and a schema that references a location twice per level stays linear. A
+ * location entered again on the same value is a cycle, left to the evaluator.
+ */
+let verdicts = new Map();
+function annotationFree(compiled) {
+    for (const { schema } of compiled.locations.values()) {
+        if (isJsonObject(schema) &&
+            (Object.hasOwn(schema, 'unevaluatedItems') || Object.hasOwn(schema, 'unevaluatedProperties'))) {
+            return false;
+        }
+    }
+    return true;
+}
+/** The check of one location, compiled on its first use so that references may recur. */
+function checkOf(compiled, checks, location) {
+    let check = checks.get(location);
+    if (check === undefined) {
+        let body;
+        check = (value, depth) => {
+            if (depth > MAXIMUM_DEPTH)
+                throw UNDECIDED;
+            body ??= compileLocation(compiled, checks, location);
+            return body(value, depth);
+        };
+        checks.set(location, check);
+    }
+    return check;
+}
+/**
+ * The conjunction of the location's keywords, each as the evaluator applies it: an applicator
+ * checks the same value at its child location, a keyword of one type passes every other type.
+ */
+function compileLocation(compiled, checks, location) {
+    const schema = location.schema;
+    if (schema === true)
+        return () => true;
+    if (schema === false)
+        return () => false;
+    const child = (keyword, member) => checkOf(compiled, checks, compiled.child(location, keyword, member));
+    const parts = [];
+    if (Object.hasOwn(schema, '$ref')) {
+        const target = compiled.reference(location);
+        if (target === undefined)
+            throw UNDECIDED;
+        const check = checkOf(compiled, checks, target);
+        parts.push((value, depth) => {
+            let byValue = verdicts.get(target);
+            if (byValue === undefined)
+                verdicts.set(target, (byValue = new Map()));
+            const known = byValue.get(value);
+            if (known === null)
+                throw UNDECIDED;
+            if (known !== undefined)
+                return known;
+            byValue.set(value, null);
+            const verdict = check(value, depth + 1);
+            byValue.set(value, verdict);
+            return verdict;
+        });
+    }
+    compileCompositions(schema, child, parts);
+    compileCommon(schema, parts);
+    compileNumber(schema, parts);
+    compileString(compiled, schema, parts);
+    compileArray(schema, child, parts);
+    compileObject(compiled, schema, child, parts);
+    if (parts.length === 0)
+        return () => true;
+    if (parts.length === 1)
+        return parts[0];
+    return (value, depth) => {
+        for (const part of parts)
+            if (!part(value, depth))
+                return false;
+        return true;
+    };
+}
+function compileCompositions(schema, child, parts) {
+    const allOf = schemaList(schema.allOf)?.map((_, index) => child('allOf', index));
+    if (allOf !== undefined) {
+        parts.push((value, depth) => allOf.every((check) => check(value, depth + 1)));
+    }
+    const anyOf = schemaList(schema.anyOf)?.map((_, index) => child('anyOf', index));
+    if (anyOf !== undefined) {
+        parts.push((value, depth) => anyOf.some((check) => check(value, depth + 1)));
+    }
+    const oneOf = schemaList(schema.oneOf)?.map((_, index) => child('oneOf', index));
+    if (oneOf !== undefined) {
+        parts.push((value, depth) => {
+            let admitted = 0;
+            for (const check of oneOf)
+                if (check(value, depth + 1) && ++admitted > 1)
+                    return false;
+            return admitted === 1;
+        });
+    }
+    if (isSchema(schema.not)) {
+        const not = child('not');
+        parts.push((value, depth) => !not(value, depth + 1));
+    }
+    if (isSchema(schema.if)) {
+        const condition = child('if');
+        const then = isSchema(schema.then) ? child('then') : undefined;
+        const otherwise = isSchema(schema.else) ? child('else') : undefined;
+        parts.push((value, depth) => {
+            const branch = condition(value, depth + 1) ? then : otherwise;
+            return branch === undefined || branch(value, depth + 1);
+        });
+    }
+}
+function compileCommon(schema, parts) {
+    const kind = schema['x-astrale-value-kind'];
+    if (kind === 'instant')
+        parts.push((value) => isInstantValue(value));
+    if (kind === 'blob')
+        parts.push((value) => isCanonicalBlobRef(value));
+    const type = schema.type;
+    if (typeof type === 'string')
+        parts.push((value) => matchesType(type, value));
+    else if (Array.isArray(type)) {
+        const types = type.filter((candidate) => typeof candidate === 'string');
+        parts.push((value) => types.some((candidate) => matchesType(candidate, value)));
+    }
+    if (Object.hasOwn(schema, 'const')) {
+        const expected = schema.const;
+        parts.push((value) => jsonEqual(value, expected));
+    }
+    const choices = schema.enum;
+    if (Array.isArray(choices)) {
+        parts.push((value) => choices.some((candidate) => jsonEqual(value, candidate)));
+    }
+}
+function compileNumber(schema, parts) {
+    const { multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum } = schema;
+    const bounded = typeof multipleOf === 'number' ||
+        typeof maximum === 'number' ||
+        typeof exclusiveMaximum === 'number' ||
+        typeof minimum === 'number' ||
+        typeof exclusiveMinimum === 'number';
+    if (!bounded)
+        return;
+    parts.push((value) => typeof value !== 'number' ||
+        ((typeof multipleOf !== 'number' || isMultipleOf(value, multipleOf)) &&
+            (typeof maximum !== 'number' || value <= maximum) &&
+            (typeof exclusiveMaximum !== 'number' || value < exclusiveMaximum) &&
+            (typeof minimum !== 'number' || value >= minimum) &&
+            (typeof exclusiveMinimum !== 'number' || value > exclusiveMinimum)));
+}
+function compileString(compiled, schema, parts) {
+    const { maxLength, minLength, pattern, fullMatch } = schema;
+    if (typeof maxLength === 'number' || typeof minLength === 'number') {
+        // For n UTF-16 units, ceil(n / 2) <= code points <= n: count only when the bounds cannot
+        // decide, as the evaluator does.
+        parts.push((value) => {
+            if (typeof value !== 'string')
+                return true;
+            if ((typeof maxLength !== 'number' || value.length <= maxLength) &&
+                (typeof minLength !== 'number' || Math.ceil(value.length / 2) >= minLength)) {
+                return true;
+            }
+            const length = codePointLength(value);
+            return ((typeof maxLength !== 'number' || length <= maxLength) &&
+                (typeof minLength !== 'number' || length >= minLength));
+        });
+    }
+    if (typeof pattern === 'string') {
+        const matcher = compiled.matcher(pattern);
+        parts.push((value) => typeof value !== 'string' || matcher.test(value));
+    }
+    if (typeof fullMatch === 'string') {
+        const matcher = compiled.matcher(fullMatch);
+        parts.push((value) => typeof value !== 'string' || matcher.matches(value));
+    }
+}
+function compileArray(schema, child, parts) {
+    const { maxItems, minItems } = schema;
+    if (typeof maxItems === 'number' || typeof minItems === 'number' || schema.uniqueItems === true) {
+        const distinct = schema.uniqueItems === true;
+        parts.push((value) => !Array.isArray(value) ||
+            ((typeof maxItems !== 'number' || value.length <= maxItems) &&
+                (typeof minItems !== 'number' || value.length >= minItems) &&
+                (!distinct || unique(value))));
+    }
+    const prefix = schemaList(schema.prefixItems)?.map((_, index) => child('prefixItems', index));
+    const items = isSchema(schema.items) ? child('items') : undefined;
+    if (prefix !== undefined || items !== undefined) {
+        const leading = prefix ?? [];
+        parts.push((value, depth) => {
+            if (!Array.isArray(value))
+                return true;
+            for (let index = 0; index < value.length; index++) {
+                const check = index < leading.length ? leading[index] : items;
+                if (check !== undefined && !check(value[index], depth + 1))
+                    return false;
+            }
+            return true;
+        });
+    }
+    if (isSchema(schema.contains)) {
+        const contains = child('contains');
+        const least = typeof schema.minContains === 'number' ? schema.minContains : 1;
+        const most = typeof schema.maxContains === 'number' ? schema.maxContains : Number.POSITIVE_INFINITY;
+        parts.push((value, depth) => {
+            if (!Array.isArray(value))
+                return true;
+            let matches = 0;
+            for (const item of value)
+                if (contains(item, depth + 1))
+                    matches++;
+            return matches >= least && matches <= most;
+        });
+    }
+}
+function compileObject(compiled, schema, child, parts) {
+    const { maxProperties, minProperties } = schema;
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((name) => typeof name === 'string')
+        : [];
+    const dependentRequired = isJsonObject(schema.dependentRequired)
+        ? Object.entries(schema.dependentRequired).flatMap(([name, names]) => Array.isArray(names)
+            ? [[name, names.filter((other) => typeof other === 'string')]]
+            : [])
+        : [];
+    if (typeof maxProperties === 'number' ||
+        typeof minProperties === 'number' ||
+        required.length > 0 ||
+        dependentRequired.length > 0) {
+        parts.push((value) => {
+            if (!isJsonObject(value))
+                return true;
+            if (typeof maxProperties === 'number' || typeof minProperties === 'number') {
+                const count = Object.keys(value).length;
+                if (typeof maxProperties === 'number' && count > maxProperties)
+                    return false;
+                if (typeof minProperties === 'number' && count < minProperties)
+                    return false;
+            }
+            for (const name of required)
+                if (!Object.hasOwn(value, name))
+                    return false;
+            for (const [name, names] of dependentRequired) {
+                if (Object.hasOwn(value, name) && !names.every((other) => Object.hasOwn(value, other))) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    // Each member is checked by every pattern it matches, by its declared schema, and by the
+    // additional schema when neither declares it.
+    const declared = isJsonObject(schema.properties) ? schema.properties : {};
+    const properties = new Map(Object.keys(declared).map((name) => [name, child('properties', name)]));
+    const patterns = isJsonObject(schema.patternProperties)
+        ? Object.keys(schema.patternProperties).map((source) => [compiled.matcher(source), child('patternProperties', source)])
+        : [];
+    const additional = isSchema(schema.additionalProperties)
+        ? child('additionalProperties')
+        : undefined;
+    const names = isSchema(schema.propertyNames) ? child('propertyNames') : undefined;
+    if (properties.size > 0 || patterns.length > 0 || additional !== undefined || names) {
+        parts.push((value, depth) => {
+            if (!isJsonObject(value))
+                return true;
+            for (const name of Object.keys(value)) {
+                const member = value[name];
+                let matched = false;
+                for (const [matcher, check] of patterns) {
+                    if (!matcher.test(name))
+                        continue;
+                    matched = true;
+                    if (!check(member, depth + 1))
+                        return false;
+                }
+                const check = Object.hasOwn(declared, name) ? properties.get(name) : undefined;
+                if (check !== undefined) {
+                    if (!check(member, depth + 1))
+                        return false;
+                }
+                else if (!matched && additional !== undefined && !additional(member, depth + 1)) {
+                    return false;
+                }
+                if (names !== undefined && !names(name, depth + 1))
+                    return false;
+            }
+            return true;
+        });
+    }
+    if (isJsonObject(schema.dependentSchemas)) {
+        const dependent = Object.keys(schema.dependentSchemas).map((name) => [name, child('dependentSchemas', name)]);
+        parts.push((value, depth) => !isJsonObject(value) ||
+            dependent.every(([name, check]) => !Object.hasOwn(value, name) || check(value, depth + 1)));
+    }
+}
+function schemaList(input) {
+    return Array.isArray(input) ? input : undefined;
+}
+function isSchema(input) {
+    return typeof input === 'boolean' || isJsonObject(input);
+}

package/dist/v1/schema/compatibility/fields.d.ts

@@ -50,9 +50,11 @@ export declare const PROPERTY_FIELDS: Readonly<{
     }>;
 }>;
 /**
- * The auth level and Policy check are decided by the Runtime at invocation, never compiled against.
- * The execution modifier decides what an invocation returns; an accepted Schema carries it only
- * when durable, so ordinary callables keep their meaning unchanged.
+ * The auth level, the Policy check and the admission age are authorization: decided by the Runtime
+ * at invocation, never compiled against. The admission age only bounds how old the admission a
+ * destination decides a call under may be. The execution modifier decides what an invocation
+ * returns; an accepted Schema carries it only when durable, so ordinary callables keep their meaning
+ * unchanged.
  */
 export declare const CALLABLE_FIELDS: Readonly<{
     ref: Readonly<{
@@ -63,6 +65,9 @@ export declare const CALLABLE_FIELDS: Readonly<{
     static: "always";
     abstract: "always";
     execution: "always";
+    admission: Readonly<{
+        excluded: 'authorization';
+    }>;
     auth: Readonly<{
         excluded: 'authorization';
     }>;
@@ -148,6 +153,9 @@ export declare const FIELD_ROLES: Readonly<{
         static: "always";
         abstract: "always";
         execution: "always";
+        admission: Readonly<{
+            excluded: 'authorization';
+        }>;
         auth: Readonly<{
             excluded: 'authorization';
         }>;

package/dist/v1/schema/compatibility/fields.js

@@ -27,9 +27,11 @@ export const PROPERTY_FIELDS = Object.freeze({
     description: ANNOTATION,
 });
 /**
- * The auth level and Policy check are decided by the Runtime at invocation, never compiled against.
- * The execution modifier decides what an invocation returns; an accepted Schema carries it only
- * when durable, so ordinary callables keep their meaning unchanged.
+ * The auth level, the Policy check and the admission age are authorization: decided by the Runtime
+ * at invocation, never compiled against. The admission age only bounds how old the admission a
+ * destination decides a call under may be. The execution modifier decides what an invocation
+ * returns; an accepted Schema carries it only when durable, so ordinary callables keep their meaning
+ * unchanged.
  */
 export const CALLABLE_FIELDS = Object.freeze({
     ref: IDENTITY,
@@ -38,6 +40,7 @@ export const CALLABLE_FIELDS = Object.freeze({
     static: 'always',
     abstract: 'always',
     execution: 'always',
+    admission: AUTHORIZATION,
     auth: AUTHORIZATION,
     policy: AUTHORIZATION,
     description: ANNOTATION,

package/dist/v1/schema/diagnostic.d.ts

@@ -1,4 +1,4 @@
-export type SchemaDiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_FOREIGN_MINIMUM' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_ENTRYPOINT' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_IMMUTABLE' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
+export type SchemaDiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_ADMISSION' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_FOREIGN_MINIMUM' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_ENTRYPOINT' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_IMMUTABLE' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
 export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode = SchemaDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

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

@@ -115,6 +115,8 @@ function canonicalizeCallable(value) {
         output: canonicalizeCallableOutput(value.output),
         // Ordinary execution has one canonical form, so existing revisions never move.
         ...(value.execution?.durable === true ? { execution: { durable: true } } : {}),
+        // Absence is the one spelling of a call admitted afresh; validation refuses any other.
+        ...(value.admission === undefined ? {} : { admission: { maxAge: value.admission.maxAge } }),
     };
     return value.auth === 'authorized'
         ? {

package/dist/v1/schema/validation/callable.d.ts

@@ -1,4 +1,4 @@
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainSchemaIR } from '../model/schema.js';
-/** Validate the execution modifier of every local Function and Node Method. */
+/** Validate the execution modifier and admission age of every local Function and Node Method. */
 export declare function validateCallables(schema: DomainSchemaIR): readonly SchemaDiagnostic[];

package/dist/v1/schema/validation/callable.js

@@ -1,10 +1,13 @@
+import { isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from '../../language/callable/admission.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { diagnostic } from '../diagnostic.js';
-/** Validate the execution modifier of every local Function and Node Method. */
+/** Validate the execution modifier and admission age of every local Function and Node Method. */
 export function validateCallables(schema) {
     const diagnostics = [];
     for (const [name, declaration] of Object.entries(schema.functions)) {
-        validateExecution(declaration, `/functions/${escapePointer(name)}`, diagnostics);
+        const pointer = `/functions/${escapePointer(name)}`;
+        validateExecution(declaration, pointer, diagnostics);
+        validateAdmission(declaration, pointer, diagnostics);
     }
     for (const [name, declaration] of Object.entries(schema.classes)) {
         if (declaration.kind !== 'node')
@@ -12,10 +15,22 @@ export function validateCallables(schema) {
         for (const [method, value] of Object.entries(declaration.methods)) {
             const pointer = `/classes/${escapePointer(name)}/methods/${escapePointer(method)}`;
             validateExecution(value, pointer, diagnostics);
+            validateAdmission(value, pointer, diagnostics);
         }
     }
     return Object.freeze(diagnostics);
 }
+/**
+ * An admission age is a whole number of seconds within the language ceiling. It has no zero
+ * spelling: an absent admission age is the one canonical form of a call admitted afresh.
+ */
+function validateAdmission(declaration, pointer, diagnostics) {
+    if (declaration.admission === undefined)
+        return;
+    if (isAdmissionMaxAge(declaration.admission.maxAge))
+        return;
+    diagnostics.push(diagnostic('DV_CALLABLE_ADMISSION', `${pointer}/admission/maxAge`, `An admission age is an integer number of seconds from 1 to ${MAXIMUM_ADMISSION_AGE_SECONDS}; omit it to admit every call afresh.`));
+}
 /**
  * An Execution records its initiating caller and its admitted input, from which the run is
  * resubmitted, and retains one portable outcome. A durable callable therefore needs a known caller,

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

@@ -87,9 +87,15 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
         return;
     for (const [name, method] of Object.entries(declaration.methods)) {
         const methodPointer = `${pointer}/methods/${escapePointer(name)}`;
-        if (!isMethodExecutable(declaration, method) && method.policy !== undefined) {
+        if (isMethodExecutable(declaration, method))
+            continue;
+        if (method.policy !== undefined) {
             diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/policy`, 'Abstract Methods cannot have a Policy.'));
         }
+        // An admission age qualifies the admission of an executable declaration, like its Policy.
+        if (method.admission !== undefined) {
+            diagnostics.push(diagnostic('DV_METHOD_ABSTRACT', `${methodPointer}/admission`, 'Abstract Methods cannot have an admission age.'));
+        }
     }
 }
 function validateParents(environment, owner, ownerKind, parents, diagnostics) {

package/dist/v1/schema/validation/domain.structure.js

@@ -195,11 +195,16 @@ const valueFunctionInputSchema = jsonSchemaSchema.refine((value) => typeof value
 const callableExecutionSchema = strictObject({
     durable: boolean(),
 });
+// Its range is language meaning, refused by callable validation with DV_CALLABLE_ADMISSION.
+const callableAdmissionSchema = strictObject({
+    maxAge: number(),
+});
 const callableShape = {
     description: descriptionSchema.optional(),
     input: jsonSchemaSchema,
     output: callableOutputSchema,
     execution: callableExecutionSchema.optional(),
+    admission: callableAdmissionSchema.optional(),
     auth: enumeration(['anonymous', 'authenticated', 'authorized']),
     policy: union([literal(true), policyCheckExpressionSchema]).optional(),
 };

package/dist/value/canonical.d.ts

@@ -5,3 +5,8 @@ export declare function serialize(input: unknown, options?: Options): string;
 /** Serialize a trusted portable value whose default structural admission proof is still valid. */
 export declare function serializeAdmitted(input: Value): string;
 export declare function encode(input: unknown, options?: Options): Uint8Array;
+/**
+ * The UTF-8 byte length of a trusted Value's canonical JSON, `encode(input).byteLength`: an
+ * admission-owned immutable root counted its bytes when it was admitted, so it is not serialized.
+ */
+export declare function byteLength(input: Value): number;

package/dist/value/canonical.js

@@ -31,6 +31,18 @@ function serializeSnapshot(input, maxBytes) {
 export function encode(input, options) {
     return encoder.encode(serialize(input, options));
 }
+/**
+ * The UTF-8 byte length of a trusted Value's canonical JSON, `encode(input).byteLength`: an
+ * admission-owned immutable root counted its bytes when it was admitted, so it is not serialized.
+ */
+export function byteLength(input) {
+    if (input !== null && typeof input === 'object') {
+        const bytes = immutableSnapshotBytes(input);
+        if (bytes !== undefined)
+            return bytes;
+    }
+    return utf8Length(serializeAdmitted(input));
+}
 function serializeValue(value) {
     if (value === null)
         return 'null';

package/dist/value/json.d.ts

@@ -1,3 +1,3 @@
-export { encode, serialize, serializeAdmitted } from './canonical.js';
+export { byteLength, encode, serialize, serializeAdmitted } from './canonical.js';
 export { decode } from './decode.js';
 export { DecodeError } from './error.js';

package/dist/value/json.js

@@ -1,3 +1,3 @@
-export { encode, serialize, serializeAdmitted } from './canonical.js';
+export { byteLength, encode, serialize, serializeAdmitted } from './canonical.js';
 export { decode } from './decode.js';
 export { DecodeError } from './error.js';

package/package.json

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