@astrale-os/kernel-dsl 0.2.0-beta.40 → 0.2.0-beta.42

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

@@ -1,6 +1,6 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
-import type { BinaryInputProjection, FunctionAuth } from '../../language/callable/model/callable.js';
+import type { BinaryInputProjection, 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';
@@ -51,6 +51,8 @@ export interface CallableInputBase<Input extends FunctionInputSchema = ValueSche
     readonly description?: string;
     readonly input: Input;
     readonly output: CallableOutputInput;
+    /** `{ durable: true }` makes an invocation return an Execution reference. */
+    readonly execution?: CallableExecution;
 }
 type ConcreteCallableInput<Input extends FunctionInputSchema = ValueSchemaInput> = CallableInputBase<Input> & ({
     readonly auth: 'anonymous';
@@ -72,17 +74,21 @@ 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> {
+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> {
     readonly [CALLABLE_PROJECTION_VALUE]: true;
     readonly input: Input;
     readonly output: Output;
     readonly auth: Auth;
     readonly static: Static;
     readonly abstract: Abstract;
+    readonly execution: Execution;
 }
 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>;
 type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type ExecutionOfConfig<Config extends CallableInput> = Config extends {
+    readonly execution: infer Execution extends CallableExecution;
+} ? Execution : undefined;
 type CallableOutputOf<Input extends CallableOutputInput> = Input extends StreamOutput<infer Item> ? {
     readonly mode: 'stream';
     readonly item: ValueOutputOf<Item>;
@@ -105,12 +111,12 @@ export type ProjectionOfCallable<Value extends Function | Method> = Value extend
 export declare function callableConfiguration(value: Function | Method): CallableInput;
 export type PolicyObjectAuthoring = Class | Function | Method | Policy | View | CoreNode;
 export type PolicyObjectInput = Lazy<PolicyObjectAuthoring | PolicyObjectRef>;
-export declare function func<const Config extends FunctionInput, Input = FunctionInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth']>(config: Config): Function<CallableProjection<Input, Output, Auth, false, false>>;
+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 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>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract>>;
+} ? Value : false, Execution extends CallableExecution | undefined = ExecutionOfConfig<Config>>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Abstract, Execution>>;
 export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
     readonly kind: 'input';
 }>;

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

@@ -17,6 +17,7 @@ export function func(config) {
         'policy',
         'static',
         'abstract',
+        'execution',
     ]);
     const value = authoringValue('function', {});
     callableInputs.set(value, { ...config });
@@ -31,6 +32,7 @@ export function method(config) {
         'policy',
         'static',
         'abstract',
+        'execution',
     ]);
     const value = authoringValue('method', {});
     callableInputs.set(value, { ...config });

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

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

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

@@ -16,7 +16,7 @@ export interface PropertyProjection<Value = unknown, Required extends boolean =
     readonly input: Input;
 }
 type MethodExecutableOf<OwnerAbstract extends boolean, MethodAbstract extends boolean> = MethodAbstract extends false ? true : OwnerAbstract extends false ? true : false;
-export interface MethodProjection<Input = unknown, Output = unknown, Static extends boolean = boolean, Abstract extends boolean = boolean, Auth extends language.FunctionAuth = language.FunctionAuth, Name extends string = string, Key extends language.MethodKey = language.MethodKey, Executable extends boolean = boolean> {
+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> {
     readonly input: Input;
     readonly output: Output;
     readonly static: Static;
@@ -25,13 +25,15 @@ export interface MethodProjection<Input = unknown, Output = unknown, Static exte
     readonly auth: Auth;
     readonly name: Name;
     readonly key: Key;
+    readonly execution: Execution;
 }
-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'>> {
+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> {
     readonly input: Input;
     readonly output: Output;
     readonly auth: Auth;
     readonly ref: Ref;
     readonly key: Key;
+    readonly execution: Execution;
 }
 export interface ClassProjection<Kind extends language.ClassKind = language.ClassKind, Definition extends Extract<language.ClassDefinition, {
     readonly kind: Kind;
@@ -253,6 +255,7 @@ type OwnMethodEntries<Value, Static extends boolean> = {
 type CallableConfig<Value> = Value extends Method<infer Config> ? Config extends CallableProjection ? Config : never : Value extends Function<infer Config> ? Config extends CallableProjection ? Config : never : never;
 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 CallableStaticOf<Value extends Method> = CallableConfig<Value> extends {
     readonly static: true;
 } ? true : false;
@@ -260,7 +263,7 @@ type CallableAbstractOf<Value extends Method> = CallableConfig<Value> extends {
     readonly abstract: infer Abstract extends boolean;
 } ? Abstract : false;
 type CallableAuthOf<Value extends Method | Function> = CallableConfig<Value>['auth'];
-type MethodProjectionOfEntry<Origin extends string, OwnerName extends string, Entry> = Entry extends language.ResolvedMethod ? MethodProjectionOfResolved<Entry> : Entry extends AuthoredMethodEntry<infer Owner, infer Name, infer Value> ? MethodProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableStaticOf<Value>, CallableAbstractOf<Value>, CallableAuthOf<Value>, Name, language.MethodKey<Origin, OwnerName, Name>, MethodExecutableOf<AbstractOf<ClassInputOf<Owner>>, CallableAbstractOf<Value>>> : never;
+type 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 MethodProjectionOfEntries<Origin extends string, OwnerName extends string, Entries> = Entries extends unknown ? MethodProjectionOfEntry<Origin, OwnerName, Entries> : never;
 type MethodCollectionOperation = 'byKey' | 'get';
 type PropertyProjectionOfResolved<Value> = Value extends language.ResolvedProperty<infer PropertyValue, infer Required, infer State, infer Input> & {
@@ -269,7 +272,7 @@ type PropertyProjectionOfResolved<Value> = Value extends language.ResolvedProper
 } ? PropertyProjection<PropertyValue, Required, Name, Key, State, Input> : 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']> : never;
+} ? MethodProjection<Input, Output, Static, Abstract, Auth, Name, Key, Value['executable'], Value['execution']> : never;
 type PropertiesOfCollection<Value> = Value extends {
     readonly byKey: infer ByKey extends Readonly<Record<language.PropertyKey, language.ResolvedProperty<unknown, boolean>>>;
 } ? PropertyProjectionOfResolved<ByKey[keyof ByKey]> : never;
@@ -316,7 +319,7 @@ type ClassProjectionOfAuthoring<Origin extends string, Name extends string, Valu
 }, language.DefinitionKey<Origin, 'class', Name>, ParentClassProjectionTuple<Origin, ParentInputsOfConfig<ProjectionOfClass<Extract<Value, Class>>>, Root, Seen>, EffectivePropertyProjectionsOf<Origin, Name, Value, Root>, never, never, OwnPropertyProjectionsOf<Origin, Name, Value>, never, never> : never;
 type FunctionProjectionOfAuthoring<Origin extends string, Name extends string, Value> = Value extends Function ? FunctionProjection<CallableInputValue<Value>, CallableOutputValue<Value>, CallableAuthOf<Value>, language.FunctionRef<Name> & {
     readonly origin: Origin;
-}, language.DefinitionKey<Origin, 'function', Name>> : never;
+}, language.DefinitionKey<Origin, 'function', Name>, CallableExecutionOf<Value>> : never;
 type ResolvedPropertyOfProjection<Value> = Value extends PropertyProjection<infer PropertyValue, infer Required, infer Name, infer Key, infer State, infer Input> ? language.ResolvedProperty<PropertyValue, Required, State, Input> & {
     readonly name: Name;
     readonly key: Key;
@@ -334,9 +337,10 @@ type ProjectionPropertyByName<Entries extends PropertyProjection> = Readonly<{
     }>>;
 }>;
 type PropertyCollectionOfProjection<Entries extends PropertyProjection> = language.ResolvedPropertyCollection<ProjectionPropertyByKey<Entries>, ProjectionPropertyByName<Entries>>;
-type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer Name, infer Key, infer Executable> ? language.ResolvedMethod<Input, Output, Static, Abstract, Auth, language.PolicyCheckExpression, Key> & {
+type ResolvedMethodOfProjection<Value> = Value extends MethodProjection<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer Name, infer Key, infer Executable, infer Execution> ? language.ResolvedMethod<Input, Output, Static, Abstract, Auth, language.PolicyCheckExpression, Key> & {
     readonly name: Name;
     readonly executable: Executable;
+    readonly execution: Execution;
 } : never;
 type ProjectionMethodByKey<Entries extends MethodProjection> = Readonly<{
     [Key in Entries['key']]: ResolvedMethodOfProjection<Extract<Entries, {
@@ -363,8 +367,9 @@ type ResolvedClassWithKind<Kind extends language.ClassKind, Definition extends E
     readonly ref: Ref;
     readonly key: Key;
 } : never;
-type ResolvedFunctionOfProjection<Value extends FunctionProjection> = Value extends FunctionProjection<infer Input, infer Output, infer Auth, infer Ref, infer Key> ? language.ResolvedFunction<Input, Output, Auth, language.PolicyCheckExpression> & {
+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.PolicyCheckExpression> & {
     readonly ref: Ref;
     readonly key: Key;
+    readonly execution: Execution;
 } : never;
 export {};

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

@@ -255,7 +255,7 @@ 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', 'fields']);
+        : ['ref', 'auth', 'input', 'output'], 'Compiled Callable', path, ['policy', 'description', 'execution', 'fields']);
     if (method) {
         memberName(value.name, 'Method name', `${path}/name`);
         boolean(value.static, 'Method static', `${path}/static`);
@@ -308,6 +308,24 @@ function compiledCallable(input, values, method, path) {
         exact(output, ['mode', 'value'], 'Callable output', outputPath);
         index(output.value, values.length, 'Callable output value', `${outputPath}/value`);
     }
+    if (value.execution !== undefined) {
+        const executionPath = `${path}/execution`;
+        const execution = object(value.execution, 'Callable execution', executionPath);
+        exact(execution, ['durable'], 'Callable execution', executionPath);
+        // Ordinary execution is canonically absent; only the durable modifier is retained.
+        if (!boolean(execution.durable, 'Callable execution durable', `${executionPath}/durable`)) {
+            invalid('Callable execution', 'COMPILED_CANONICAL_MISMATCH', `${executionPath}/durable`);
+        }
+        if (value.auth === 'anonymous') {
+            invalid('durable Callable auth', 'COMPILED_SOURCE_INVALID', `${path}/auth`);
+        }
+        if (typeof value.input === 'object' && value.input !== null) {
+            invalid('durable Callable input', 'COMPILED_SOURCE_INVALID', `${path}/input`);
+        }
+        if (output.mode !== 'value') {
+            invalid('durable Callable output', 'COMPILED_SOURCE_INVALID', `${outputPath}/mode`);
+        }
+    }
 }
 function compiledPolicy(input, path) {
     const value = object(input, 'Policy', path);

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

@@ -135,7 +135,8 @@ function sameMethodSignature(leftEntry, left, rightEntry, right) {
     return (programKey(leftEntry, left.input) === programKey(rightEntry, right.input) &&
         outputKey(leftEntry, left.output) === outputKey(rightEntry, right.output) &&
         left.auth === right.auth &&
-        left.static === right.static);
+        left.static === right.static &&
+        left.execution?.durable === right.execution?.durable);
 }
 function outputKey(entry, output) {
     return output.mode === 'binary' ? 'binary' : `${output.mode}:${programKey(entry, output.value)}`;

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

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

package/dist/v1/domain/create.js

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

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

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

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

@@ -12,6 +12,15 @@ export type CallableOutput = {
     readonly mode: 'binary';
 };
 export type OutputMode = CallableOutput['mode'];
+/**
+ * Execution modifier of a callable. Absent or `durable: false` means ordinary execution, and an
+ * accepted Schema keeps only `durable: true`. A durable invocation returns an Execution reference;
+ * the handler still returns `output`. Retry, retention and endpoint are never callable meaning. A
+ * durable callable takes a value input, which its Execution records so the run can be resubmitted.
+ */
+export interface CallableExecution {
+    readonly durable: boolean;
+}
 /** A binary Function receives portable metadata and one required byte stream. */
 export interface BinaryInput {
     readonly mode: 'binary';
@@ -29,6 +38,7 @@ export interface CallableDefinitionBase<Input extends CallableInputContract = Ca
     readonly description?: string;
     readonly input: Input;
     readonly output: CallableOutput;
+    readonly execution?: CallableExecution;
 }
 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 { PolicyCheckExpression } from '../policy/model/policy.js';
 import type { Diagnostic } from '../validation/diagnostic.js';
-import type { BinaryInputProjection, FunctionDefinition, MethodDefinition } from './model/callable.js';
+import type { BinaryInputProjection, 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 PolicyCheckExpression> = Omit<Definition, 'auth' | 'policy'> & (Auth extends FunctionAuth ? {
     readonly auth: Auth;
@@ -20,6 +20,8 @@ export interface ResolvedMethod<out Input = unknown, out Output = unknown, out S
     readonly description?: MethodDefinition['description'];
     readonly input: MethodDefinition['input'];
     readonly output: MethodDefinition['output'];
+    /** Present only for a durable Method. */
+    readonly execution?: CallableExecution;
     readonly auth: Auth;
     readonly policy?: Auth extends 'authorized' ? Policy : never;
     readonly static: Static;
@@ -49,6 +51,8 @@ export interface ResolvedFunction<out Input = unknown, out Output = unknown, out
     readonly description?: FunctionDefinition['description'];
     readonly input: FunctionDefinition['input'];
     readonly output: FunctionDefinition['output'];
+    /** Present only for a durable Function. */
+    readonly execution?: CallableExecution;
     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/policy/normalization/normalize.js

@@ -1,7 +1,6 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { definitionRefIndex, compareDefinitionRefs } from '../../../addressing/ordering.js';
 import { policyObjectKey, policyVariableSelector } from '../model/policy.js';
-const textEncoder = new TextEncoder();
 export function normalizePolicyExpression(value) {
     if ('match' in value) {
         return { match: normalizePolicyPattern(value.match) };
@@ -73,20 +72,22 @@ function normalizePatternNode(value) {
 function canonicalVariableIds(value) {
     const declarations = new Map();
     collectDeclarations(value, declarations);
-    const colors = new Map(declarations);
+    const uses = new Map([...declarations.keys()].map((id) => [id, []]));
+    collectUses(value, uses);
+    let colors = declarations;
+    // Color refinement. Each round names a variable by its declaration and the sorted colors of its
+    // uses, then replaces every name by its fixed-width rank among the round's names. Ranks keep the
+    // names' byte order, so a round decides what it would decide over uncompressed names, while a
+    // name stays linear in its variable's degree instead of embedding every neighbour's name. A
+    // round that reproduces its input is a fixed point of the next ones.
     for (let iteration = 0; iteration < declarations.size + 1; iteration++) {
-        const next = new Map();
-        for (const id of declarations.keys()) {
-            const uses = [];
-            collectUses(value, id, colors, uses);
-            uses.sort(compareUtf8Bytes);
-            next.set(id, `${declarations.get(id) ?? ''}|${uses.join('|')}`);
-        }
+        const next = rank(new Map([...uses].map(([id, list]) => {
+            const named = list.map(([prefix, term]) => `${prefix}${termColor(term, colors)}`);
+            return [id, `${declarations.get(id) ?? ''}|${named.sort(compareUtf8Bytes).join('|')}`];
+        })));
         if ([...next].every(([id, color]) => colors.get(id) === color))
             break;
-        colors.clear();
-        for (const [id, color] of next)
-            colors.set(id, color);
+        colors = next;
     }
     const firstUse = new Map();
     collectFirstUseKeys(value, colors, firstUse);
@@ -118,29 +119,34 @@ function collectDeclarations(value, result) {
         for (const child of value.anyOf)
             collectDeclarations(child, result);
 }
-function collectUses(value, target, colors, result) {
+function collectUses(value, result) {
     if ('sameNode' in value) {
         const { left, right } = value.sameNode;
-        if (left.kind === 'variable' && left.id === target)
-            result.push(`same:${termColor(right, colors)}`);
-        if (right.kind === 'variable' && right.id === target)
-            result.push(`same:${termColor(left, colors)}`);
+        if (left.kind === 'variable')
+            result.get(left.id)?.push(['same:', right]);
+        if (right.kind === 'variable')
+            result.get(right.id)?.push(['same:', left]);
         return;
     }
     if (isEdge(value)) {
-        if (value.source.kind === 'variable' && value.source.id === target) {
-            result.push(`s:${definitionRefIndex(value.class)}:${termColor(value.target, colors)}`);
-        }
-        if (value.target.kind === 'variable' && value.target.id === target) {
-            result.push(`t:${definitionRefIndex(value.class)}:${termColor(value.source, colors)}`);
-        }
+        const edge = definitionRefIndex(value.class);
+        if (value.source.kind === 'variable')
+            result.get(value.source.id)?.push([`s:${edge}:`, value.target]);
+        if (value.target.kind === 'variable')
+            result.get(value.target.id)?.push([`t:${edge}:`, value.source]);
         return;
     }
     if ('exists' in value)
-        return collectUses(value.exists.where, target, colors, result);
+        return collectUses(value.exists.where, result);
     const children = 'allOf' in value ? value.allOf : value.anyOf;
     for (const child of children)
-        collectUses(child, target, colors, result);
+        collectUses(child, result);
+}
+function rank(names) {
+    const distinct = [...new Set(names.values())].sort(compareUtf8Bytes);
+    const width = String(distinct.length).length;
+    const ranks = new Map(distinct.map((name, index) => [name, String(index).padStart(width, '0')]));
+    return new Map([...names].map(([id, name]) => [id, ranks.get(name) ?? '']));
 }
 function termColor(term, colors) {
     if (term.kind === 'variable')
@@ -181,8 +187,10 @@ function collectFirstUseKeys(value, colors, result, prefix = '$') {
     }
     const key = 'allOf' in value ? 'allOf' : 'anyOf';
     const operands = 'allOf' in value ? value.allOf : value.anyOf;
-    const children = [...operands].sort((left, right) => compareUtf8Bytes(patternSignature(left, colors), patternSignature(right, colors)));
-    children.forEach((child, index) => collectFirstUseKeys(child, colors, result, `${prefix}:${key}:${index}`));
+    const children = operands
+        .map((child) => [patternSignature(child, colors), child])
+        .sort(([left], [right]) => compareUtf8Bytes(left, right));
+    children.forEach(([, child], index) => collectFirstUseKeys(child, colors, result, `${prefix}:${key}:${index}`));
 }
 function patternSignature(value, colors) {
     if ('sameNode' in value)
@@ -255,15 +263,24 @@ function uniqueJson(values) {
         .sort(([left], [right]) => compareUtf8Bytes(left, right))
         .map(([, value]) => value);
 }
+/**
+ * UTF-8 byte order without encoding: it is code-point order, which UTF-16 code units already follow
+ * except that surrogates (U+10000 and above) sort after U+E000–U+FFFF.
+ */
 function compareUtf8Bytes(left, right) {
-    const a = textEncoder.encode(left);
-    const b = textEncoder.encode(right);
-    const length = Math.min(a.length, b.length);
+    const length = Math.min(left.length, right.length);
     for (let index = 0; index < length; index++) {
-        if (a[index] !== b[index])
-            return (a[index] ?? 0) - (b[index] ?? 0);
+        const a = left.charCodeAt(index);
+        const b = right.charCodeAt(index);
+        if (a !== b)
+            return codePointOrder(a) - codePointOrder(b);
     }
-    return a.length - b.length;
+    return left.length - right.length;
+}
+function codePointOrder(unit) {
+    if (unit >= 0xd800 && unit <= 0xdfff)
+        return unit + 0x2000;
+    return unit >= 0xe000 ? unit - 0x800 : unit;
 }
 function isEdge(value) {
     return 'source' in value;

package/dist/v1/schema/analysis/class.d.ts

@@ -42,7 +42,10 @@ export interface DefinitionAnalysisResult {
 export declare function analyzeDefinitions(environment: DomainResolutionContext): DefinitionAnalysisResult;
 /** The exact signature required by abstract Method composition. */
 export declare function sameMethodSignature(left: MethodDefinition, right: MethodDefinition): boolean;
-/** Shared canonical signature used by admission and compatibility explanations. */
+/**
+ * Shared canonical signature used by admission and compatibility explanations. The execution
+ * modifier appears only when durable, so absent and `durable: false` are the same signature.
+ */
 export declare function methodSignature(value: MethodDefinition): {
     input: JsonSchema;
     output: {
@@ -60,4 +63,7 @@ export declare function methodSignature(value: MethodDefinition): {
     };
     auth: "anonymous" | "authenticated" | "authorized";
     static: boolean;
+    execution?: {
+        durable: boolean;
+    } | undefined;
 };

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

@@ -117,13 +117,17 @@ function mergeMethods(owner, declaration, parents, diagnostics) {
 export function sameMethodSignature(left, right) {
     return json.serialize(methodSignature(left)) === json.serialize(methodSignature(right));
 }
-/** Shared canonical signature used by admission and compatibility explanations. */
+/**
+ * Shared canonical signature used by admission and compatibility explanations. The execution
+ * modifier appears only when durable, so absent and `durable: false` are the same signature.
+ */
 export function methodSignature(value) {
     return {
         input: canonicalizeValueSchema(value.input, 'callable-input'),
         output: canonicalMethodOutput(value),
         auth: value.auth,
         static: value.static,
+        ...(value.execution?.durable === true ? { execution: { durable: true } } : {}),
     };
 }
 function canonicalMethodOutput(value) {

package/dist/v1/schema/compatibility/comparators/callables.d.ts

@@ -1,5 +1,5 @@
 import type { Value } from '@astrale-os/kernel-dsl/value';
-import type { CallableOutput, CallableInputContract, FunctionDefinition, MethodDefinition } from '../../../language/callable/model/callable.js';
+import type { CallableExecution, CallableOutput, CallableInputContract, FunctionDefinition, MethodDefinition } from '../../../language/callable/model/callable.js';
 import type { ResolvedFunction, ResolvedMethod } from '../../../language/callable/resolved.js';
 import type { EffectiveMethod } from '../../analysis/class.js';
 import type { Fingerprint } from '../model.js';
@@ -10,18 +10,23 @@ export declare function functionSignature(declaration: FunctionDefinition): Valu
 export declare function functionExistence(): Value;
 /**
  * Fingerprint the contract a caller compiles against, independently of its Domain revision: the
- * exact key, the owner, dispatch and abstractness of a Method, and the semantic input and output
- * contracts; authorization is excluded (DM-CALLABLE-FINGERPRINT). A static consumer pins this
- * instead of a Domain revision, so a dependency release that leaves the callable contract untouched
- * keeps every bound invocation valid.
+ * exact key, the owner, dispatch and abstractness of a Method, the semantic input and output
+ * contracts, and the durable execution modifier; authorization is excluded
+ * (DM-CALLABLE-FINGERPRINT). A static consumer pins this instead of a Domain revision, so a
+ * dependency release that leaves the callable contract untouched keeps every bound invocation
+ * valid.
  */
 export declare function callableFingerprint(callable: ResolvedFunction | ResolvedMethod): Fingerprint;
 type CallableSignature = {
     readonly static?: boolean;
     readonly abstract?: boolean;
+    readonly execution?: CallableExecution;
     readonly input: CallableInputContract;
     readonly output: CallableOutput;
 };
-/** The `always` fields of CALLABLE_FIELDS: dispatch shape and the semantic input and output. */
-export declare function callableSignature(declaration: Pick<FunctionDefinition, 'input' | 'output'> | Pick<MethodDefinition, 'static' | 'abstract' | 'input' | 'output'>): CallableSignature;
+/**
+ * The `always` fields of CALLABLE_FIELDS: dispatch shape, the execution modifier, and the semantic
+ * input and output.
+ */
+export declare function callableSignature(declaration: Pick<FunctionDefinition, 'input' | 'output' | 'execution'> | Pick<MethodDefinition, 'static' | 'abstract' | 'input' | 'output' | 'execution'>): CallableSignature;
 export {};

package/dist/v1/schema/compatibility/comparators/callables.js

@@ -41,10 +41,11 @@ export function functionExistence() {
 }
 /**
  * Fingerprint the contract a caller compiles against, independently of its Domain revision: the
- * exact key, the owner, dispatch and abstractness of a Method, and the semantic input and output
- * contracts; authorization is excluded (DM-CALLABLE-FINGERPRINT). A static consumer pins this
- * instead of a Domain revision, so a dependency release that leaves the callable contract untouched
- * keeps every bound invocation valid.
+ * exact key, the owner, dispatch and abstractness of a Method, the semantic input and output
+ * contracts, and the durable execution modifier; authorization is excluded
+ * (DM-CALLABLE-FINGERPRINT). A static consumer pins this instead of a Domain revision, so a
+ * dependency release that leaves the callable contract untouched keeps every bound invocation
+ * valid.
  */
 export function callableFingerprint(callable) {
     // This digest input travels in every bound invocation and is recomputed by the Kernel; its
@@ -58,7 +59,10 @@ export function callableFingerprint(callable) {
         }
         : { kind: 'function', key: callable.key, ...callableSignature(callable) });
 }
-/** The `always` fields of CALLABLE_FIELDS: dispatch shape and the semantic input and output. */
+/**
+ * The `always` fields of CALLABLE_FIELDS: dispatch shape, the execution modifier, and the semantic
+ * input and output.
+ */
 export function callableSignature(declaration) {
     return {
         ...fieldsOf({ declaration, roles: CALLABLE_FIELDS }),

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

@@ -48,7 +48,11 @@ export declare const PROPERTY_FIELDS: Readonly<{
         excluded: 'annotation';
     }>;
 }>;
-/** The auth level and Policy check are decided by the Runtime at invocation, never compiled against. */
+/**
+ * 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.
+ */
 export declare const CALLABLE_FIELDS: Readonly<{
     ref: Readonly<{
         excluded: 'identity';
@@ -57,6 +61,7 @@ export declare const CALLABLE_FIELDS: Readonly<{
     output: "always";
     static: "always";
     abstract: "always";
+    execution: "always";
     auth: Readonly<{
         excluded: 'authorization';
     }>;
@@ -140,6 +145,7 @@ export declare const FIELD_ROLES: Readonly<{
         output: "always";
         static: "always";
         abstract: "always";
+        execution: "always";
         auth: Readonly<{
             excluded: 'authorization';
         }>;

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

@@ -25,13 +25,18 @@ export const PROPERTY_FIELDS = Object.freeze({
     state: 'always',
     description: ANNOTATION,
 });
-/** The auth level and Policy check are decided by the Runtime at invocation, never compiled against. */
+/**
+ * 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.
+ */
 export const CALLABLE_FIELDS = Object.freeze({
     ref: IDENTITY,
     input: 'always',
     output: 'always',
     static: 'always',
     abstract: 'always',
+    execution: 'always',
     auth: AUTHORIZATION,
     policy: AUTHORIZATION,
     description: ANNOTATION,

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

@@ -101,6 +101,8 @@ function canonicalizeCallable(value) {
             }
             : canonicalizeValueSchema(value.input, 'callable-input'),
         output: canonicalizeCallableOutput(value.output),
+        // Ordinary execution has one canonical form, so existing revisions never move.
+        ...(value.execution?.durable === true ? { execution: { durable: true } } : {}),
     };
     return value.auth === 'authorized'
         ? {

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

@@ -0,0 +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. */
+export declare function validateCallables(schema: DomainSchemaIR): readonly SchemaDiagnostic[];

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

@@ -0,0 +1,39 @@
+import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { diagnostic } from '../diagnostic.js';
+/** Validate the execution modifier 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);
+    }
+    for (const [name, declaration] of Object.entries(schema.classes)) {
+        if (declaration.kind !== 'node')
+            continue;
+        for (const [method, value] of Object.entries(declaration.methods)) {
+            const pointer = `/classes/${escapePointer(name)}/methods/${escapePointer(method)}`;
+            validateExecution(value, pointer, diagnostics);
+        }
+    }
+    return Object.freeze(diagnostics);
+}
+/**
+ * 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,
+ * a value input and a replayable value output.
+ */
+function validateExecution(declaration, pointer, diagnostics) {
+    if (declaration.execution?.durable !== true)
+        return;
+    if (declaration.auth === 'anonymous') {
+        diagnostics.push(diagnostic('DV_CALLABLE_AUTH', `${pointer}/auth`, 'A durable callable requires authenticated or authorized auth.'));
+    }
+    if (isBinaryInput(declaration.input)) {
+        diagnostics.push(diagnostic('DV_CALLABLE_IO', `${pointer}/input/mode`, 'A durable callable requires a value input.'));
+    }
+    if (declaration.output.mode !== 'value') {
+        diagnostics.push(diagnostic('DV_CALLABLE_IO', `${pointer}/output/mode`, 'A durable callable requires a value output.'));
+    }
+}
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

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

@@ -2,6 +2,7 @@ import { compareUnicode } from '../../addressing/ordering.js';
 import { analyzeDefinitions } from '../analysis/class.js';
 import { buildDomainResolutionContext } from '../resolution/context.js';
 import { createValueSchemaRegistry } from '../resolution/value.registry.js';
+import { validateCallables } from './callable.js';
 import { validateDefinitions } from './class.js';
 import { validateCore } from './core.js';
 import { validatePolicies } from './policy/validate.js';
@@ -15,6 +16,7 @@ export function validateDomainSchemaSemantics(schema, lookup) {
         ...context.diagnostics,
         ...validateEmbeddedValueSchemas(schema, registry),
         ...validateDefinitions(context, analysis),
+        ...validateCallables(schema),
         ...validatePolicies(context, analysis),
         ...validateViews(context),
         ...validateCore(context, analysis, registry),

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

@@ -189,10 +189,14 @@ const binaryInputSchema = strictObject({
     maximumBytes: number().int().min(1).max(Number.MAX_SAFE_INTEGER),
 });
 const valueFunctionInputSchema = jsonSchemaSchema.refine((value) => typeof value !== 'object' || value === null || value.mode !== 'binary', 'Binary input must declare metadata and maximumBytes.');
+const callableExecutionSchema = strictObject({
+    durable: boolean(),
+});
 const callableShape = {
     description: descriptionSchema.optional(),
     input: jsonSchemaSchema,
     output: callableOutputSchema,
+    execution: callableExecutionSchema.optional(),
     auth: enumeration(['anonymous', 'authenticated', 'authorized']),
     policy: policyCheckExpressionSchema.optional(),
 };

package/package.json

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