@astrale-os/kernel-dsl 1.0.0-beta.7 → 1.0.0-beta.9

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

@@ -5,7 +5,7 @@ import type { MethodRecord } from '../../language/callable/model/callable.js';
 import type { ResolvedMethod } from '../../language/callable/resolved.js';
 import type { Inheritance } from '../../language/class/model/class.js';
 import type { MediaType } from '../../language/class/model/data.js';
-import type { EdgeCount, EdgeUniqueTuple } from '../../language/class/model/edge.js';
+import type { EdgeCount, EdgeLifetime } from '../../language/class/model/edge.js';
 import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
 import type { ClassRuleChecks, ClassRuleObject } from '../../language/policy/model/policy.js';
 import type { StateTopology, StateTopologyOf } from '../../language/state/topology.js';
@@ -26,16 +26,22 @@ export interface DirectedSourceInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
     readonly outgoing: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
 }
 export interface DirectedTargetInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
     readonly incoming: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
 }
 export interface IncidentEndpointInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
     readonly incident: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
 }
 type ExactEndpointInput<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
 /** One observation slot: a local Policy, or its constant value. Absent means `true`. */
@@ -69,7 +75,17 @@ export interface NodeClassInput {
     readonly icon?: string;
     /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
     readonly policies?: NodeClassPoliciesInput;
+    /**
+     * The tuples no two Nodes of this Class and of its active concrete descendants share while every
+     * Property is present; omitted, none. A descendant is covered without declaring them again.
+     */
+    readonly unique?: readonly NodeUniqueTupleInput[];
 }
+/**
+ * The distinct Properties of one Node key, in any order, each a Property of the Class, own or
+ * inherited, by its name or, when names collide, by its full key.
+ */
+export type NodeUniqueTupleInput = readonly [string, ...string[]];
 export interface EdgeClassOptions {
     readonly abstract?: boolean;
     /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
@@ -84,15 +100,24 @@ export interface EdgeClassOptions {
         readonly acyclic?: true;
     };
 }
+/**
+ * A key field as authored: an endpoint, the slug, or a Property of the Class, own or inherited, by
+ * its name or, when names collide, by its full key.
+ */
+export type EdgeUniqueFieldInput = 'source' | 'target' | 'slug' | {
+    readonly property: string;
+};
+/** The distinct fields of one key, in any order. */
+export type EdgeUniqueTupleInput = readonly [EdgeUniqueFieldInput, ...EdgeUniqueFieldInput[]];
 export interface DirectedEdgeInput extends EdgeClassOptions {
     readonly orientation: 'directed';
     readonly source: DirectedSourceInput;
     readonly target: DirectedTargetInput;
     /**
-     * The tuples no two Edges of this Class and of its active concrete descendants share; omitted,
-     * none. A descendant is covered without declaring them again.
+     * The tuples no two Edges of this Class and of its active concrete descendants share while every
+     * field is present; omitted, none. A descendant is covered without declaring them again.
      */
-    readonly unique?: readonly EdgeUniqueTuple[];
+    readonly unique?: readonly EdgeUniqueTupleInput[];
 }
 export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints'> {
     readonly orientation: 'undirected';

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

@@ -25,13 +25,21 @@ export function nodeClass(config) {
         'methods',
         'icon',
         'policies',
+        'unique',
     ]);
     if (admitted.policies !== undefined)
         assertKnownKeys(admitted.policies, ['read', 'traverse']);
     const value = authoringValue('definition', {
         kind: 'node',
     });
-    classInputs.set(value, { ...admitted, abstract: admitted.abstract ?? false });
+    classInputs.set(value, {
+        ...admitted,
+        // Copied, so the declaration does not follow later changes to the author's arrays.
+        ...(admitted.unique === undefined
+            ? {}
+            : { unique: admitted.unique.map((tuple) => [...tuple]) }),
+        abstract: admitted.abstract ?? false,
+    });
     return value;
 }
 export const edgeClass = Object.freeze({
@@ -62,7 +70,9 @@ export const edgeClass = Object.freeze({
             // Copied, so the declaration does not follow later changes to the author's arrays.
             ...(unique === undefined
                 ? {}
-                : { unique: unique.map((tuple) => [...tuple]) }),
+                : {
+                    unique: unique.map((tuple) => tuple.map((field) => typeof field === 'string' ? field : { property: field.property })),
+                }),
             ...options,
             abstract: options.abstract ?? false,
         });
@@ -104,13 +114,13 @@ export function classConfiguration(value) {
     return input;
 }
 function validateDirectedSourceInput(value) {
-    assertKnownKeys(value, ['as', 'accepts', 'outgoing']);
+    assertKnownKeys(value, ['as', 'accepts', 'outgoing', 'onDelete']);
 }
 function validateDirectedTargetInput(value) {
-    assertKnownKeys(value, ['as', 'accepts', 'incoming']);
+    assertKnownKeys(value, ['as', 'accepts', 'incoming', 'onDelete']);
 }
 function validateIncidentEndpointInput(value) {
-    assertKnownKeys(value, ['as', 'accepts', 'incident']);
+    assertKnownKeys(value, ['as', 'accepts', 'incident', 'onDelete']);
 }
 function validateEdgeClassOptions(value) {
     assertKnownKeys(value, [

package/dist/v1/builder/index.d.ts

@@ -14,7 +14,7 @@ export { BuilderError as Error } from './schema/diagnostic.js';
 export type { BuilderDiagnostic as Diagnostic, BuilderDiagnosticCode as DiagnosticCode, } from './schema/diagnostic.js';
 export type { CallableInputBase, CallableInput, BinaryInputAuthoring, CallableOutputInput, CallableProjection, CallablePolicyBuilder, CallablePolicyContext, PolicyCheckContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
 export type { CoreEdge, CoreEndpoint, CoreInput, CoreNode } from './core/authoring.js';
-export type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
+export type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
 export type { PathAuthoring } from './value/path.js';
 export type { Lazy } from './schema/lazy.js';
 export type { MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeInput, PolicyExistsContext, PolicyInput, PolicyNodeBinder, PolicyPatternContext, } from './policy/authoring.js';

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

@@ -39,6 +39,11 @@ export class V1DefinitionCompiler {
             ...(data === undefined ? {} : { data }),
             ...(input.icon === undefined ? {} : { icon: input.icon }),
             policies: this.classPolicies(input, 'node', `${pointer}/policies`),
+            // Property names stay as authored until `canonicalizeUniquePropertyKeys` qualifies them
+            // against the Class's effective Properties, once every Class is lowered.
+            ...(input.unique === undefined
+                ? {}
+                : { unique: input.unique }),
         };
     }
     edgeClass(value, name, pointer) {
@@ -54,7 +59,11 @@ export class V1DefinitionCompiler {
                         target: this.directedTarget(directed.target, `${pointer}/endpoints/target`),
                     },
                     constraints: directedConstraints(directed),
-                    ...(directed.unique === undefined ? {} : { unique: directed.unique }),
+                    // Property names stay as authored until `canonicalizeUniquePropertyKeys` qualifies them
+                    // against the Class's effective Properties, once every Class is lowered.
+                    ...(directed.unique === undefined
+                        ? {}
+                        : { unique: directed.unique }),
                 };
             }
             const undirected = classConfiguration(value);
@@ -129,6 +138,7 @@ export class V1DefinitionCompiler {
             accepts: value.accepts
                 .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/accepts/${index}`))
                 .sort(compareDefinitionRefs),
+            ...(value.onDelete === undefined ? {} : { onDelete: value.onDelete }),
         };
     }
     directedSource(value, pointer) {
@@ -142,7 +152,7 @@ export class V1DefinitionCompiler {
     }
     parents(values, kind, pointer) {
         return (values ?? [])
-            .map((entry, index) => this.context.resolveClass(entry, kind, `${pointer}/${index}`))
+            .map((entry, index) => this.context.resolveParent(entry, kind, `${pointer}/${index}`))
             .sort(compareDefinitionRefs);
     }
     methods(values, abstractOwner, pointer) {

package/dist/v1/builder/lowering/property-keys.d.ts

@@ -0,0 +1,27 @@
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { CoreContent } from '../../language/core/model/core.js';
+import type { DefinitionAnalysis } from '../../schema/analysis/class.js';
+import type { DomainSchemaLookup } from '../../schema/dependency/lookup.js';
+import type { DomainSchemaIR } from '../../schema/model/schema.js';
+import type { UnqualifiedCoreContent } from './core.js';
+type UnqualifiedDomainSchema = Omit<DomainSchemaIR, 'core'> & {
+    readonly core: UnqualifiedCoreContent;
+};
+/** The effective Properties of every Class `candidate` resolves, by `definitionRefIndex`. */
+export type PropertyOwners = ReadonlyMap<string, DefinitionAnalysis>;
+/**
+ * Analyze the already-canonical Definition surface of `candidate` once, so Property shorthand
+ * resolves against each Class's own and inherited Properties. Core values and key tuples take no
+ * part in Class composition, so they are left out of the analysis.
+ */
+export declare function analyzePropertyOwners(candidate: UnqualifiedDomainSchema, lookup: DomainSchemaLookup): PropertyOwners;
+/** Lower rich builder shorthand to the canonical full-key Core representation. */
+export declare function canonicalizeCorePropertyKeys(core: UnqualifiedCoreContent, owners: PropertyOwners): CoreContent;
+/**
+ * Lower each Property a key tuple names by its name to its full key among the Class's own and
+ * inherited Properties; a full key stays as authored. Ambiguity and absence are refused here, so a
+ * tuple never names a Property the author did not mean. A Node tuple names Properties only; an Edge
+ * tuple names them as `{ property }` beside its structural fields.
+ */
+export declare function canonicalizeUniquePropertyKeys(classes: Readonly<Record<string, ClassDefinition>>, origin: string, owners: PropertyOwners): Readonly<Record<string, ClassDefinition>>;
+export {};

package/dist/v1/builder/lowering/property-keys.js

@@ -0,0 +1,108 @@
+import { PropertyKey as admitPropertyKey } from '../../addressing/index.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { createPropertyValues } from '../../language/class/property-values.js';
+import { analyzeDefinitions } from '../../schema/analysis/class.js';
+import { buildDomainResolutionContext } from '../../schema/resolution/context.js';
+import { escapeToken, fail } from '../schema/diagnostic.js';
+/**
+ * Analyze the already-canonical Definition surface of `candidate` once, so Property shorthand
+ * resolves against each Class's own and inherited Properties. Core values and key tuples take no
+ * part in Class composition, so they are left out of the analysis.
+ */
+export function analyzePropertyOwners(candidate, lookup) {
+    const analysisCandidate = {
+        ...candidate,
+        core: { nodes: {}, edges: [] },
+    };
+    return analyzeDefinitions(buildDomainResolutionContext(analysisCandidate, lookup)).definitions;
+}
+/** Lower rich builder shorthand to the canonical full-key Core representation. */
+export function canonicalizeCorePropertyKeys(core, owners) {
+    const nodes = Object.fromEntries(Object.entries(core.nodes).map(([slug, node]) => {
+        const definition = owners.get(definitionRefIndex(node.class));
+        if (definition === undefined) {
+            fail('BUILDER_CORE_PROPERTY', `/core/nodes/${escapeToken(slug)}/class`, 'Core property shorthand requires a resolvable concrete Class.');
+        }
+        return [
+            slug,
+            {
+                ...node,
+                properties: qualify(node.properties, definition, `/core/nodes/${escapeToken(slug)}/properties`),
+            },
+        ];
+    }));
+    const edges = core.edges.map((edge, index) => {
+        const definition = owners.get(definitionRefIndex(edge.class));
+        if (definition === undefined) {
+            fail('BUILDER_CORE_PROPERTY', `/core/edges/${index}/class`, 'Core property shorthand requires a resolvable concrete Class.');
+        }
+        return {
+            ...edge,
+            properties: qualify(edge.properties, definition, `/core/edges/${index}/properties`),
+        };
+    });
+    return { nodes, edges };
+}
+/**
+ * Lower each Property a key tuple names by its name to its full key among the Class's own and
+ * inherited Properties; a full key stays as authored. Ambiguity and absence are refused here, so a
+ * tuple never names a Property the author did not mean. A Node tuple names Properties only; an Edge
+ * tuple names them as `{ property }` beside its structural fields.
+ */
+export function canonicalizeUniquePropertyKeys(classes, origin, owners) {
+    return Object.fromEntries(Object.entries(classes).map(([name, declaration]) => {
+        if (declaration.kind === 'edge' && declaration.orientation !== 'directed') {
+            return [name, declaration];
+        }
+        if (declaration.unique === undefined)
+            return [name, declaration];
+        const ref = { origin, kind: 'class', name };
+        const definition = owners.get(definitionRefIndex(ref));
+        const pointer = `/classes/${escapeToken(name)}/unique`;
+        const resolve = (input, at) => {
+            if (definition === undefined) {
+                fail('BUILDER_UNIQUE_PROPERTY', at, 'A key Property requires a resolvable Class.');
+            }
+            return resolveInputKey(input, definition, 'BUILDER_UNIQUE_PROPERTY', at);
+        };
+        if (declaration.kind === 'node') {
+            const unique = declaration.unique.map((tuple, t) => tuple.map((key, f) => resolve(key, `${pointer}/${t}/${f}`)));
+            return [name, { ...declaration, unique }];
+        }
+        const unique = declaration.unique.map((tuple, t) => tuple.map((field, f) => typeof field === 'string'
+            ? field
+            : { property: resolve(field.property, `${pointer}/${t}/${f}/property`) }));
+        return [name, { ...declaration, unique }];
+    }));
+}
+function qualify(input, definition, pointer) {
+    const result = {};
+    const sourceByKey = new Map();
+    for (const [inputKey, value] of Object.entries(input)) {
+        const key = resolveInputKey(inputKey, definition, 'BUILDER_CORE_PROPERTY', `${pointer}/${escapeToken(inputKey)}`);
+        const previous = sourceByKey.get(key);
+        if (previous !== undefined) {
+            fail('BUILDER_CORE_PROPERTY', `${pointer}/${escapeToken(inputKey)}`, `Property is supplied twice through ${JSON.stringify(previous)} and ${JSON.stringify(inputKey)}.`);
+        }
+        sourceByKey.set(key, inputKey);
+        result[key] = value;
+    }
+    return createPropertyValues(Object.entries(result).map(([key, value]) => [admitPropertyKey(key), value]));
+}
+/** The full key of the Property `input` names on `definition`: its full key, or its unique name. */
+function resolveInputKey(input, definition, code, pointer) {
+    if (admitPropertyKey.is(input)) {
+        const key = admitPropertyKey(input);
+        if (!definition.properties.has(key)) {
+            fail(code, pointer, `Property ${input} is not present on the Class.`);
+        }
+        return key;
+    }
+    const candidates = [...definition.properties].flatMap(([key, field]) => field.name === input ? [key] : []);
+    if (candidates.length === 1)
+        return candidates[0];
+    if (candidates.length === 0) {
+        fail(code, pointer, `Property ${JSON.stringify(input)} does not exist.`);
+    }
+    fail(code, pointer, `Property ${JSON.stringify(input)} is ambiguous; use one of: ${candidates.join(', ')}.`);
+}

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

@@ -7,13 +7,14 @@ import { parseDomainSchemaStructure } from '../../../schema/validation/domain.st
 import { assertKnownKeys, escapeToken } from '../../schema/diagnostic.js';
 import { V1CallableCompiler } from '../callable.js';
 import { V1DefinitionCompiler } from '../class.js';
-import { canonicalizeCorePropertyKeys } from '../core-properties.js';
 import { compileCore } from '../core.js';
 import { assertPolicyCompositionAcyclic, V1PolicyCompiler } from '../policy.js';
+import { analyzePropertyOwners, canonicalizeCorePropertyKeys, canonicalizeUniquePropertyKeys, } from '../property-keys.js';
 import { BuilderValueSchemas } from '../value/compile.js';
 import { V1ViewCompiler } from '../view.js';
 import { captureSchema, commitSchemaOwnership } from './capture.js';
 import { BuilderContext } from './context.js';
+import { assertAuthoredLifetimes } from './lifetime.js';
 /**
  * Compile the V1 TypeScript builder graph through the same semantic acceptance
  * path used for untrusted decoded schemas.
@@ -21,9 +22,11 @@ import { BuilderContext } from './context.js';
  * This is the private implementation behind defineSchema.
  */
 export function compileSchema(origin, input) {
-    const lookup = new MemoryDomainSchemaLookup(lookupEntriesForDependencies(input.dependencies ?? {}));
+    const dependencies = lookupEntriesForDependencies(input.dependencies ?? {});
+    const lookup = new MemoryDomainSchemaLookup(dependencies);
     const candidate = assembleDomainSchema(origin, input, lookup);
     const accepted = acceptDomainSchema(candidate, lookup);
+    assertAuthoredLifetimes(accepted, dependencies);
     commitSchemaOwnership(input, origin);
     return accepted;
 }
@@ -75,9 +78,11 @@ function assembleDomainSchema(origin, input, lookup) {
         views,
         core,
     };
+    const owners = analyzePropertyOwners(semanticContent, lookup);
     const qualifiedContent = {
         ...semanticContent,
-        core: canonicalizeCorePropertyKeys(semanticContent, lookup),
+        classes: canonicalizeUniquePropertyKeys(classes, origin, owners),
+        core: canonicalizeCorePropertyKeys(core, owners),
     };
     context.noteDomainEndpointReferences(qualifiedContent);
     const candidate = {

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

@@ -29,6 +29,8 @@ export declare class BuilderContext {
     captureFunction(value: Function, ref: FunctionRef, pointer: string): void;
     captureView(value: View, ref: ViewRef, pointer: string): void;
     resolveClass(input: ClassReferenceInput, kind: ClassKind, pointer: string): ClassRef;
+    /** A parent of another Domain must be open to it in the dependency revision authored against. */
+    resolveParent(input: ClassReferenceInput, kind: ClassKind, pointer: string): ClassRef;
     resolveNodeClass(input: ClassReferenceInput, pointer: string): ClassRef;
     resolveEdgeClass(input: ClassReferenceInput, pointer: string): ClassRef;
     resolvePolicy(input: Lazy<unknown>, pointer: string): PolicyRef;

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

@@ -1,6 +1,7 @@
 import { compareDefinitionRefs, compareUnicode, definitionRefIndex, } from '../../../addressing/ordering.js';
 import { DEPENDENCY_ALIAS_PATTERN } from '../../../addressing/patterns.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
+import { admitsForeignSubclass, inheritanceOf } from '../../../language/class/inheritance.js';
 import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
 import { graphNodePathSchema } from '../../../language/value/syntax/node-path/schema.js';
 import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
@@ -90,6 +91,17 @@ export class BuilderContext {
         }
         return { ...ref };
     }
+    /** A parent of another Domain must be open to it in the dependency revision authored against. */
+    resolveParent(input, kind, pointer) {
+        const ref = this.resolveClass(input, kind, pointer);
+        if (ref.origin === this.origin)
+            return ref;
+        const parent = this.#dependencies.get(ref.origin).schema.classes[ref.name];
+        if (!admitsForeignSubclass(parent)) {
+            fail('BUILDER_CLASS_INHERITANCE', pointer, `Class ${ref.origin}:class.${ref.name} is ${inheritanceOf(parent)}: only an open Class admits a subclass of another Domain.`);
+        }
+        return ref;
+    }
     resolveNodeClass(input, pointer) {
         return this.resolveClass(input, 'node', pointer);
     }

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/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';
@@ -116,6 +117,28 @@ 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))

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