@astrale-os/kernel-dsl 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/v1/builder/lowering/schema/lifetime.d.ts

@@ -0,0 +1,11 @@
+import type { DomainSchemaEntry } from '../../../schema/dependency/lookup.js';
+import type { DomainSchema } from '../../../schema/model/schema.js';
+/**
+ * Authoring refuses two Edge Classes that acceptance keeps, because a stored Schema must decode
+ * again with the lifetimes it derives (BUILDER-EDGE-LIFETIMES):
+ * - one with an endpoint that can hold a Node of another Domain while an endpoint requires an Edge.
+ *   It can neither restrict that Domain's deletions nor detach below the required count, so the
+ *   required endpoint must become optional;
+ * - one whose lifetimes differ from those of an Edge Class it extends, the root Edge aside.
+ */
+export declare function assertAuthoredLifetimes(schema: DomainSchema, dependencies: readonly DomainSchemaEntry[]): void;

package/dist/v1/builder/lowering/schema/lifetime.js

@@ -0,0 +1,55 @@
+import { Key } from '../../../addressing/key.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { isGraphRoot } from '../../../language/class/inheritance.js';
+import { contractEndpoints, edgeLifetimes, lifetimeScope, reachesAnotherDomain, requiredEndpoint, } from '../../../language/class/lifetime.js';
+import { BuilderError, diagnostic, escapeToken } from '../../schema/diagnostic.js';
+/**
+ * Authoring refuses two Edge Classes that acceptance keeps, because a stored Schema must decode
+ * again with the lifetimes it derives (BUILDER-EDGE-LIFETIMES):
+ * - one with an endpoint that can hold a Node of another Domain while an endpoint requires an Edge.
+ *   It can neither restrict that Domain's deletions nor detach below the required count, so the
+ *   required endpoint must become optional;
+ * - one whose lifetimes differ from those of an Edge Class it extends, the root Edge aside.
+ */
+export function assertAuthoredLifetimes(schema, dependencies) {
+    const classes = [
+        ...Object.values(schema.classes),
+        ...dependencies.flatMap((entry) => Object.values(entry.schema.classes)),
+    ];
+    const scope = lifetimeScope(classes);
+    const declarations = new Map(classes.map((declaration) => [definitionRefIndex(declaration.ref), declaration]));
+    const diagnostics = Object.entries(schema.classes).flatMap(([name, declaration]) => {
+        if (declaration.kind !== 'edge')
+            return [];
+        const pointer = `/classes/${escapeToken(name)}`;
+        const endpoints = contractEndpoints(declaration);
+        const keys = declaration.orientation === 'directed' ? ['source', 'target'] : ['0', '1'];
+        const counts = declaration.orientation === 'directed' ? ['outgoing', 'incoming'] : ['incident', 'incident'];
+        const found = [];
+        const required = requiredEndpoint(declaration);
+        const reaching = endpoints.find(({ endpoint }) => reachesAnotherDomain(schema.origin, endpoint, scope));
+        if (required !== undefined && reaching !== undefined)
+            found.push(diagnostic('BUILDER_EDGE_LIFETIME', `${pointer}/endpoints/${keys[required.index]}/${counts[required.index]}`, `${Key.of(declaration.ref)} endpoint ${reaching.endpoint.role} can hold Nodes of another ` +
+                `Domain, so it cannot restrict their deletion, and endpoint ${required.endpoint.role} ` +
+                `requires ${required.count} Edges, so it cannot detach: make ${required.endpoint.role} optional.`));
+        const lifetimes = edgeLifetimes(declaration, scope);
+        declaration.extends.forEach((ref, index) => {
+            const parent = declarations.get(definitionRefIndex(ref));
+            if (parent?.kind !== 'edge' || isGraphRoot(parent))
+                return;
+            const inherited = edgeLifetimes(parent, scope);
+            const same = (order) => order.every((at, position) => lifetimes[position] === inherited[at]);
+            if (same([0, 1]) || (declaration.orientation === 'undirected' && same([1, 0])))
+                return;
+            found.push(diagnostic('BUILDER_EDGE_LIFETIME', `${pointer}/extends/${index}`, `${Key.of(declaration.ref)} has lifetimes ${spell(endpoints, lifetimes)}, and ` +
+                `${Key.of(parent.ref)} it extends has ${spell(contractEndpoints(parent), inherited)}: ` +
+                `an Edge Class keeps the lifetimes of the Classes it extends.`));
+        });
+        return found;
+    });
+    if (diagnostics.length > 0)
+        throw new BuilderError(diagnostics);
+}
+function spell(endpoints, lifetimes) {
+    return `${endpoints[0].endpoint.role} ${lifetimes[0]} and ${endpoints[1].endpoint.role} ${lifetimes[1]}`;
+}

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

@@ -1,5 +1,5 @@
 import type { DiagnosticCode as LanguageDiagnosticCode } from '../../language/validation/diagnostic.js';
-export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_IMMUTABLE' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_PROPERTY_IMMUTABLE_INVALID' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
+export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_IMMUTABLE' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CLASS_INHERITANCE' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_EDGE_LIFETIME' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_PROPERTY_IMMUTABLE_INVALID' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNIQUE_PROPERTY' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
 export interface BuilderDiagnostic<out Code extends BuilderDiagnosticCode = BuilderDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

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

@@ -1,5 +1,5 @@
 import { type CompiledSchemaEntry } from '../../model/schema.js';
 import { type SemanticIndex } from './context.js';
 import { type CoreNode, type CoreEdgeValue } from './core.js';
-/** Check normalized Edge uniqueness, noSelf, cycles and complete Core degrees. */
+/** Check normalized Edge identity, keys, noSelf, cycles and complete Core degrees. */
 export declare function validateCoreEdgeSet(context: SemanticIndex, entry: CompiledSchemaEntry, entryIndex: number, nodes: ReadonlyMap<string, CoreNode>, edges: readonly CoreEdgeValue[]): void;

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

@@ -1,12 +1,13 @@
 import { Key } from '../../../addressing/index.js';
 import { compareUnicode } from '../../../addressing/ordering.js';
 import {} from '../../../language/class/model/edge.js';
+import { coveringEdgeUniqueTuples, edgeUniqueKeys } from '../../../language/class/unique.js';
 import {} from '../../model/schema.js';
 import { fail } from '../diagnostic.js';
 import { isCompiledEdge, classSatisfiesAny, } from './context.js';
 import {} from './core.js';
 import { sameIncidentEndpoint, countBounds } from './edge.js';
-/** Check normalized Edge uniqueness, noSelf, cycles and complete Core degrees. */
+/** Check normalized Edge identity, keys, noSelf, cycles and complete Core degrees. */
 export function validateCoreEdgeSet(context, entry, entryIndex, nodes, edges) {
     const seen = new Set();
     const slices = new Map();
@@ -26,6 +27,20 @@ export function validateCoreEdgeSet(context, entry, entryIndex, nodes, edges) {
         if (edge.class.value.constraints.noSelf === true && edge.source.key === edge.target.key)
             fail(edge.pointer, 'Core Edge violates noSelf.');
     }
+    // No two Core Edges hold one key under a tuple covering their Classes (DV-EDGE-UNIQUE).
+    const resolve = (ref) => context.classes.get(Key.of(ref))?.value;
+    const holders = new Set();
+    for (const edge of edges) {
+        const keys = edgeUniqueKeys(coveringEdgeUniqueTuples(edge.class.value, resolve), {
+            source: edge.source.key,
+            target: edge.target.key,
+            props: edge.value.properties,
+        });
+        if (keys.some((key) => holders.has(key)))
+            fail(edge.pointer, 'Core Edge holds a key another Core Edge holds.');
+        for (const key of keys)
+            holders.add(key);
+    }
     for (const edgeClass of entry.definitions.classes) {
         if (!isCompiledEdge(edgeClass))
             continue;

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

@@ -2,6 +2,7 @@ import { json } from '@astrale-os/kernel-dsl/value';
 import { Key, PropertyKey as PropertyKeyValue, } from '../../../addressing/index.js';
 import { composeMethods } from '../../../language/callable/composition.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
+import { keyableProperty } from '../../../language/class/unique.js';
 import { bindValueProgram } from '../../../language/value/compile/load.js';
 import {} from '../../model/schema.js';
 import { fail } from '../diagnostic.js';
@@ -22,6 +23,8 @@ export function analyzeClasses(classes) {
             const parent = classes.get(Key.of(ref));
             if (parent === undefined)
                 fail(`${located.pointer}/extends/${index}`, 'Parent Class is absent.');
+            if (parent.value.inheritance === 'final')
+                fail(`${located.pointer}/extends/${index}`, 'A final Class has no subclass.');
             return analyze(parent);
         });
         const properties = new Map();
@@ -114,11 +117,38 @@ export function validateClassFacets(context) {
                 }
             }
         }
+        if (located.value.unique !== undefined) {
+            const properties = context.analyses.get(Key.of(located.value.ref))?.properties;
+            const keyable = (key, at) => {
+                const property = properties?.get(key)?.declaration;
+                if (property === undefined || !keyableProperty(property.ordering, property.auto)) {
+                    fail(at, 'A key Property is a keyable Property of the Class.');
+                }
+            };
+            // A Node tuple names Properties only; an Edge tuple names them as `{ property }`.
+            const value = located.value;
+            if (value.kind === 'node') {
+                for (const [t, tuple] of (value.unique ?? []).entries())
+                    for (const [f, key] of tuple.entries())
+                        keyable(key, `${located.pointer}/unique/${t}/${f}`);
+            }
+            else {
+                for (const [t, tuple] of (value.unique ?? []).entries())
+                    for (const [f, field] of tuple.entries())
+                        if (typeof field !== 'string')
+                            keyable(field.property, `${located.pointer}/unique/${t}/${f}/property`);
+            }
+        }
         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/semantics/core.js

@@ -1,5 +1,6 @@
 import { Key } from '../../../addressing/index.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
+import { coveringNodeUniqueTuples, nodeUniqueKeys } from '../../../language/class/unique.js';
 import {} from '../../../language/core/model/core.js';
 import { policyObjectOrigin, policyObjectKey, projectedMemberClass, } from '../../../language/index.js';
 import { bindValueProgram } from '../../../language/value/compile/load.js';
@@ -31,6 +32,7 @@ export function validateCore(candidate, context) {
                 pointer: path,
             });
         }
+        validateCoreNodeKeys(context, nodes);
         const edges = [];
         for (const [index, value] of entry.facts.core.entries()) {
             const path = `/closure/${entryIndex}/facts/core/${index}`;
@@ -67,6 +69,20 @@ export function validateCore(candidate, context) {
         validateCoreEdgeSet(context, entry, entryIndex, nodes, edges);
     }
 }
+/** No two Core Nodes hold one key under a tuple covering their Classes (DV-NODE-UNIQUE). */
+function validateCoreNodeKeys(context, nodes) {
+    const resolve = (ref) => context.classes.get(Key.of(ref))?.value;
+    const holders = new Set();
+    for (const node of nodes.values()) {
+        const keys = nodeUniqueKeys(coveringNodeUniqueTuples(node.class.value, resolve), {
+            props: node.value.properties,
+        });
+        if (keys.some((key) => holders.has(key)))
+            fail(node.pointer, 'Core Node holds a key another Core Node holds.');
+        for (const key of keys)
+            holders.add(key);
+    }
+}
 function validateCoreProperties(values, analysis, path) {
     for (const key of Object.keys(values))
         if (!analysis.properties.has(key))

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

@@ -57,8 +57,6 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
             const path = `/closure/${entryIndex}/definitions/classes/${classIndex}/policies/${operation}`;
             if (isClassRuleChecks(policy)) {
                 // The wire admits rules only on a Node Class and only over `self` and `ref` objects.
-                if (!checksNameTheCaller(policy))
-                    fail(path, 'Every branch of a Class rule must check a Policy: sameNode alone names no caller.');
                 validatePolicyChecks(context, typing, entry, policy, -1, definition.ref, path, 'class');
                 continue;
             }
@@ -102,6 +100,9 @@ const SITE = {
     class: { checks: 'Class rule checks', objects: 'the Class rule object contract' },
 };
 function validatePolicyChecks(context, typing, entry, expression, input, receiver, path, site) {
+    if (!checksNameTheCaller(expression)) {
+        fail(path, `${SITE[site].checks} must check a Policy on every branch: sameNode alone names no caller.`);
+    }
     const measure = measureChecks(expression);
     if (measure.depth > MAX_CHECK_DEPTH ||
         measure.branches > MAX_BRANCHES ||

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

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

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

@@ -1,6 +1,7 @@
 import {} from '@astrale-os/kernel-dsl/value';
 import { Key } from '../../../addressing/index.js';
 import { MEDIA_TYPE_PATTERN } from '../../../language/class/model/data.js';
+import { compareEdgeUniqueTuples, compareNodeUniqueTuples, edgeUniqueTuple, nodeUniqueTuple, } from '../../../language/class/unique.js';
 import {} from '../../model/schema.js';
 import { invalid } from '../diagnostic.js';
 import { compiledCallable } from './callable.js';
@@ -25,9 +26,15 @@ export function compiledClass(input, values, path) {
             'constraints',
             'properties',
             'policies',
-        ], 'Compiled Class', path, value.kind === 'node' ? ['data', 'description', 'icon'] : ['description']);
+        ], 'Compiled Class', path, value.kind === 'node'
+        ? ['data', 'description', 'icon', 'inheritance', 'unique']
+        : ['description', 'inheritance', 'unique']);
     definitionRef(value.ref, 'class', 'Class ref', `${path}/ref`);
     boolean(value.abstract, 'Class abstract', `${path}/abstract`);
+    if (value.inheritance !== undefined &&
+        value.inheritance !== 'open' &&
+        value.inheritance !== 'final')
+        invalid('Class inheritance', undefined, `${path}/inheritance`);
     description(value.description, 'Class description', `${path}/description`);
     const extendsPath = `${path}/extends`;
     const parents = array(value.extends, 'Class extends', extendsPath).map((parent, index) => definitionRef(parent, 'class', 'Class parent', `${extendsPath}/${index}`));
@@ -40,6 +47,8 @@ export function compiledClass(input, values, path) {
             dataDefinition(value.data, `${path}/data`);
         boundedString(value.icon, 1, 8000, 'Class icon', `${path}/icon`);
         classPolicies(value.policies, 'node', `${path}/policies`);
+        if (value.unique !== undefined)
+            nodeUniqueTuples(value.unique, `${path}/unique`);
         const methodsPath = `${path}/methods`;
         const methods = array(value.methods, 'Class methods', methodsPath);
         for (const [index, method] of methods.entries())
@@ -93,9 +102,13 @@ function edgeContract(value, path) {
             object(endpoints.target, 'directed Edge target', `${endpointsPath}/target`).role) {
             invalid('Edge endpoint roles', undefined, endpointsPath);
         }
+        if (value.unique !== undefined)
+            uniqueTuples(value.unique, `${path}/unique`);
         return;
     }
-    if (value.orientation !== 'undirected' || constraints.acyclic !== undefined) {
+    if (value.orientation !== 'undirected' ||
+        constraints.acyclic !== undefined ||
+        value.unique !== undefined) {
         invalid('Edge orientation', undefined, `${path}/orientation`);
     }
     const endpointsPath = `${path}/endpoints`;
@@ -109,9 +122,41 @@ function edgeContract(value, path) {
         invalid('Edge endpoint roles', undefined, endpointsPath);
     }
 }
+/** A nonempty list of canonical tuples (`edgeUniqueTuple`), distinct and in canonical order. */
+function uniqueTuples(input, path) {
+    const tuples = array(input, 'Edge unique tuples', path);
+    if (tuples.length === 0)
+        invalid('Edge unique tuples', undefined, path);
+    const known = tuples.map((tuple, index) => {
+        const fields = edgeUniqueTuple(array(tuple, 'Edge unique tuple', `${path}/${index}`));
+        if (fields === undefined)
+            invalid('Edge unique tuple', undefined, `${path}/${index}`);
+        return fields;
+    });
+    for (const [index, tuple] of known.entries()) {
+        if (index > 0 && compareEdgeUniqueTuples(known[index - 1], tuple) >= 0)
+            invalid('Edge unique tuples', undefined, `${path}/${index}`);
+    }
+}
+/** A nonempty list of canonical Node tuples (`nodeUniqueTuple`), distinct and in canonical order. */
+function nodeUniqueTuples(input, path) {
+    const tuples = array(input, 'Node unique tuples', path);
+    if (tuples.length === 0)
+        invalid('Node unique tuples', undefined, path);
+    const known = tuples.map((tuple, index) => {
+        const keys = nodeUniqueTuple(array(tuple, 'Node unique tuple', `${path}/${index}`));
+        if (keys === undefined)
+            invalid('Node unique tuple', undefined, `${path}/${index}`);
+        return keys;
+    });
+    for (const [index, tuple] of known.entries()) {
+        if (index > 0 && compareNodeUniqueTuples(known[index - 1], tuple) >= 0)
+            invalid('Node unique tuples', undefined, `${path}/${index}`);
+    }
+}
 function edgeEndpoint(input, count, label, path) {
     const value = object(input, label, path);
-    exact(value, ['role', 'accepts', count], label, path);
+    exact(value, ['role', 'accepts', count], label, path, ['onDelete']);
     memberName(value.role, `${label} role`, `${path}/role`);
     const acceptsPath = `${path}/accepts`;
     const accepts = array(value.accepts, `${label} accepts`, acceptsPath).map((item, index) => definitionRef(item, 'class', `${label} accepted Class`, `${acceptsPath}/${index}`));
@@ -124,6 +169,8 @@ function edgeEndpoint(input, count, label, path) {
         value[count] !== '1') {
         invalid(`${label} ${count}`, undefined, `${path}/${count}`);
     }
+    if (value.onDelete !== undefined && value.onDelete !== 'restrict' && value.onDelete !== 'detach')
+        invalid(`${label} onDelete`, undefined, `${path}/onDelete`);
 }
 function dataDefinition(input, path) {
     const value = object(input, 'Class data', path);

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

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

package/dist/v1/domain/create.js

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

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

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

package/dist/v1/index.d.ts

@@ -5,7 +5,7 @@ export { isBinaryInput } from './language/callable/model/callable.js';
 export type { EventOf, StateMachine, StateOf } from './language/state/index.js';
 export { PropertyValues } from './language/index.js';
 export * as metadata from './language/definition/metadata.js';
-export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, CallablePolicy, ClassPolicy, ClassRuleChecks, ClassRuleObject, NodeClassPolicy, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
+export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, Inheritance, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, CallablePolicy, ClassPolicy, ClassRuleChecks, ClassRuleObject, NodeClassPolicy, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
 export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodAddress, PolicyRef, Revision, ViewRef, } from './addressing/index.js';
 export type { Definition } from './language/index.js';
@@ -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. */