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

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

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

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

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

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

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

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

@@ -22,6 +22,8 @@ export function analyzeClasses(classes) {
             const parent = classes.get(Key.of(ref));
             if (parent === undefined)
                 fail(`${located.pointer}/extends/${index}`, 'Parent Class is absent.');
+            if (parent.value.inheritance === 'final')
+                fail(`${located.pointer}/extends/${index}`, 'A final Class has no subclass.');
             return analyze(parent);
         });
         const properties = new Map();

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, edgeUniqueTuple } 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']
+        : ['description', 'inheritance', 'unique']);
     definitionRef(value.ref, 'class', 'Class ref', `${path}/ref`);
     boolean(value.abstract, 'Class abstract', `${path}/abstract`);
+    if (value.inheritance !== undefined &&
+        value.inheritance !== 'open' &&
+        value.inheritance !== 'final')
+        invalid('Class inheritance', undefined, `${path}/inheritance`);
     description(value.description, 'Class description', `${path}/description`);
     const extendsPath = `${path}/extends`;
     const parents = array(value.extends, 'Class extends', extendsPath).map((parent, index) => definitionRef(parent, 'class', 'Class parent', `${extendsPath}/${index}`));
@@ -93,9 +100,13 @@ function edgeContract(value, path) {
             object(endpoints.target, 'directed Edge target', `${endpointsPath}/target`).role) {
             invalid('Edge endpoint roles', undefined, endpointsPath);
         }
+        if (value.unique !== undefined)
+            uniqueTuples(value.unique, `${path}/unique`);
         return;
     }
-    if (value.orientation !== 'undirected' || constraints.acyclic !== undefined) {
+    if (value.orientation !== 'undirected' ||
+        constraints.acyclic !== undefined ||
+        value.unique !== undefined) {
         invalid('Edge orientation', undefined, `${path}/orientation`);
     }
     const endpointsPath = `${path}/endpoints`;
@@ -109,6 +120,22 @@ function edgeContract(value, path) {
         invalid('Edge endpoint roles', undefined, endpointsPath);
     }
 }
+/** A nonempty list of tuples of `EDGE_UNIQUE_TUPLES`, distinct and in their 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}`);
+    }
+}
 function edgeEndpoint(input, count, label, path) {
     const value = object(input, label, path);
     exact(value, ['role', 'accepts', count], label, path);

package/dist/v1/index.d.ts

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

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

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

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

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

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

@@ -5,6 +5,11 @@ import type { DataFacet } from './data.js';
 import type { EdgeContract } from './edge.js';
 import type { PropertyFacet } from './property.js';
 export type ClassKind = 'node' | 'edge';
+/**
+ * Which Classes may extend a Class: `'open'`, those of its Domain and of every Domain that depends
+ * on that Domain; `'internal'`, those of its Domain only; `'final'`, none.
+ */
+export type Inheritance = 'open' | 'internal' | 'final';
 /** An absent observation rule admits every caller; a delegation is still scoped by its ceiling. */
 export interface NodeClassPolicies {
     readonly read?: NodeClassPolicy;
@@ -18,6 +23,8 @@ export interface EdgeClassPolicies {
 export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet, DataFacet {
     readonly kind: 'node';
     readonly abstract: boolean;
+    /** Absent when `'internal'`, the default, so a Class that keeps the default keeps its revision. */
+    readonly inheritance?: Exclude<Inheritance, 'internal'>;
     readonly description?: string;
     readonly extends: readonly ClassRef[];
     readonly methods: MethodRecord;
@@ -27,6 +34,8 @@ export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyF
 export type EdgeClassDefinition = DefinitionBase<ClassRef> & PropertyFacet & EdgeContract & {
     readonly kind: 'edge';
     readonly abstract: boolean;
+    /** Absent when `'internal'`, the default, so a Class that keeps the default keeps its revision. */
+    readonly inheritance?: Exclude<Inheritance, 'internal'>;
     readonly description?: string;
     readonly extends: readonly ClassRef[];
     readonly policies: EdgeClassPolicies;

package/dist/v1/language/class/model/edge.d.ts

@@ -22,6 +22,13 @@ export interface UndirectedEdgeConstraints {
     readonly noSelf?: true;
     readonly acyclic?: never;
 }
+/** A field a uniqueness tuple names: an endpoint of the Edge, or its slug. */
+export type EdgeUniqueField = 'source' | 'target' | 'slug';
+/**
+ * The fields one uniqueness tuple of a directed Edge Class names, which no two Edges of the Classes
+ * it covers share: one endpoint, then the slug. `EDGE_UNIQUE_TUPLES` lists them in canonical order.
+ */
+export type EdgeUniqueTuple = readonly ['source', 'slug'] | readonly ['target', 'slug'];
 export interface DirectedEdgeContract {
     readonly orientation: 'directed';
     readonly endpoints: {
@@ -29,10 +36,16 @@ export interface DirectedEdgeContract {
         readonly target: DirectedTargetEndpoint;
     };
     readonly constraints: DirectedEdgeConstraints;
+    /**
+     * The tuples no two Edges of this Class and of its active concrete descendants share. Absent
+     * when the Class declares none, so a Class without one keeps its revision; never empty.
+     */
+    readonly unique?: readonly EdgeUniqueTuple[];
 }
 export interface UndirectedEdgeContract {
     readonly orientation: 'undirected';
     readonly endpoints: readonly [IncidentEndpoint, IncidentEndpoint];
     readonly constraints: UndirectedEdgeConstraints;
+    readonly unique?: never;
 }
 export type EdgeContract = DirectedEdgeContract | UndirectedEdgeContract;

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

@@ -0,0 +1,24 @@
+import type { EdgeUniqueTuple } from './model/edge.js';
+/**
+ * Every uniqueness tuple a directed Edge Class may declare, in canonical order: an endpoint, then
+ * the slug. The source tuple names entries under their source; the target tuple, under their target.
+ */
+export declare const EDGE_UNIQUE_TUPLES: readonly EdgeUniqueTuple[];
+/** The fields of an Edge a uniqueness tuple reads; the slug is absent from an Edge without one. */
+export interface EdgeUniqueFacts {
+    readonly source: string;
+    readonly target: string;
+    readonly slug?: string;
+}
+/** The tuple `value` spells, or undefined when it spells none. */
+export declare function edgeUniqueTuple(value: unknown): EdgeUniqueTuple | undefined;
+/** Whether `tuples` lists the tuple `value` spells: false when it spells none. */
+export declare function includesEdgeUniqueTuple(tuples: readonly EdgeUniqueTuple[], value: unknown): boolean;
+/** The canonical order of tuples: field by field, source before target before slug. */
+export declare function compareEdgeUniqueTuples(left: EdgeUniqueTuple, right: EdgeUniqueTuple): number;
+/**
+ * The value `edge` takes under `tuple`, or undefined when one of its fields is absent, so that an
+ * Edge without a slug never collides: two distinct Edges of the Classes a tuple covers collide
+ * exactly when they take one value.
+ */
+export declare function edgeUniqueValue(tuple: EdgeUniqueTuple, edge: EdgeUniqueFacts): string | undefined;

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

@@ -0,0 +1,46 @@
+/**
+ * Every uniqueness tuple a directed Edge Class may declare, in canonical order: an endpoint, then
+ * the slug. The source tuple names entries under their source; the target tuple, under their target.
+ */
+export const EDGE_UNIQUE_TUPLES = Object.freeze([
+    Object.freeze(['source', 'slug']),
+    Object.freeze(['target', 'slug']),
+]);
+/** The fields a tuple names, in canonical order. */
+const FIELDS = Object.freeze(['source', 'target', 'slug']);
+/** The tuple `value` spells, or undefined when it spells none. */
+export function edgeUniqueTuple(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return EDGE_UNIQUE_TUPLES.find((tuple) => tuple.length === value.length && tuple.every((field, index) => field === value[index]));
+}
+/** Whether `tuples` lists the tuple `value` spells: false when it spells none. */
+export function includesEdgeUniqueTuple(tuples, value) {
+    const tuple = edgeUniqueTuple(value);
+    return (tuple !== undefined &&
+        tuples.some((candidate) => compareEdgeUniqueTuples(candidate, tuple) === 0));
+}
+/** The canonical order of tuples: field by field, source before target before slug. */
+export function compareEdgeUniqueTuples(left, right) {
+    for (let index = 0; index < Math.min(left.length, right.length); index += 1) {
+        const order = FIELDS.indexOf(left[index]) - FIELDS.indexOf(right[index]);
+        if (order !== 0)
+            return order;
+    }
+    return left.length - right.length;
+}
+/**
+ * The value `edge` takes under `tuple`, or undefined when one of its fields is absent, so that an
+ * Edge without a slug never collides: two distinct Edges of the Classes a tuple covers collide
+ * exactly when they take one value.
+ */
+export function edgeUniqueValue(tuple, edge) {
+    const values = [];
+    for (const field of tuple) {
+        const value = edge[field];
+        if (value === undefined)
+            return undefined;
+        values.push(value);
+    }
+    return JSON.stringify(values);
+}

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

@@ -14,8 +14,11 @@ export type * from './callable/resolved.js';
 export type * from './class/model/class.js';
 export type { DataDefinition, DataFacet, MediaType } from './class/model/data.js';
 export type * from './class/model/edge.js';
+export { inheritanceOf } from './class/inheritance.js';
 export { edgeLifetimes } from './class/lifetime.js';
 export type { EdgeLifetime } from './class/lifetime.js';
+export { EDGE_UNIQUE_TUPLES, compareEdgeUniqueTuples, edgeUniqueTuple, edgeUniqueValue, includesEdgeUniqueTuple, } from './class/unique.js';
+export type { EdgeUniqueFacts } from './class/unique.js';
 export type * from './class/model/property.js';
 export type * from './class/resolved.js';
 export type * from './class/facets.js';

package/dist/v1/language/index.js

@@ -3,6 +3,8 @@ export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export { valueProgramIncludes } from './value/inclusion/includes.js';
 export { stateMachine } from './state/index.js';
+export { inheritanceOf } from './class/inheritance.js';
 export { edgeLifetimes } from './class/lifetime.js';
+export { EDGE_UNIQUE_TUPLES, compareEdgeUniqueTuples, edgeUniqueTuple, edgeUniqueValue, includesEdgeUniqueTuple, } from './class/unique.js';
 export { PropertyValues } from './class/property-values.js';
 export { isClassRuleChecks, policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

package/dist/v1/language/value/profile/canonicalize.js

@@ -7,10 +7,11 @@ const TYPE_RANK = new Map(TYPE_ORDER.map((name, index) => [name, index]));
 const encoder = new TextEncoder();
 /** Canonicalizes syntax without rewriting the schema's algebra. Validate first. */
 export function canonicalizeValueSchema(schema, context, registry) {
+    void context;
     void registry;
-    return canonicalizeSchema(schema, true, context);
+    return canonicalizeSchema(schema, true);
 }
-function canonicalizeSchema(schema, root, context) {
+function canonicalizeSchema(schema, root) {
     if (typeof schema === 'boolean')
         return schema;
     const result = {};
@@ -39,17 +40,17 @@ function canonicalizeSchema(schema, root, context) {
             result[keyword] = canonicalizePathAnnotation(value);
         }
         else if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(value)) {
-            result[keyword] = canonicalizeSchema(value, false, context);
+            result[keyword] = canonicalizeSchema(value, false);
         }
         else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
-            result[keyword] = value.map((entry) => isJsonSchema(entry) ? canonicalizeSchema(entry, false, context) : canonicalizeJson(entry));
+            result[keyword] = value.map((entry) => isJsonSchema(entry) ? canonicalizeSchema(entry, false) : canonicalizeJson(entry));
         }
         else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(value)) {
             const schemas = {};
             for (const name of Object.keys(value).sort()) {
                 const entry = value[name];
                 schemas[name] = isJsonSchema(entry)
-                    ? canonicalizeSchema(entry, false, context)
+                    ? canonicalizeSchema(entry, false)
                     : canonicalizeJson(entry);
             }
             result[keyword] = schemas;

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

@@ -1,5 +1,6 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import type { Key as SemanticKey } from '../../../addressing/index.js';
+import type { Inheritance } from '../../../language/class/model/class.js';
 import type { EffectiveField } from '../../analysis/class.js';
 import type { Context } from '../context.js';
 import type { ClassCoordinate } from '../coordinate.js';
@@ -38,6 +39,8 @@ export declare function compareLostProperties({ pair, report, }: {
     readonly pair: SubjectPair;
     readonly report: Report;
 }): void;
+/** Which Classes may extend a Class, as an extension facet compares it. */
+export declare function inheritanceMeaning(inheritance: Inheritance): JsonValue;
 /** Newly required data is an obligation even though it was absent from the source footprint. */
 export declare function compareAddedProperties({ context, pair, report, }: {
     readonly context: ComparisonContext;

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

@@ -139,6 +139,10 @@ function propertyIdentities(identities) {
         properties: Object.fromEntries(identities.map((identity) => [identity, true])),
     });
 }
+/** Which Classes may extend a Class, as an extension facet compares it. */
+export function inheritanceMeaning(inheritance) {
+    return deepFreeze({ coordinate: 'class', inheritance });
+}
 /** Newly required data is an obligation even though it was absent from the source footprint. */
 export function compareAddedProperties({ context, pair, report, }) {
     if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')

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

@@ -5,7 +5,7 @@ import type { ComparisonContext, SubjectPair } from '../scope.js';
 export declare function compareFacet({ context, pair, facet, }: {
     readonly context: ComparisonContext;
     readonly pair: SubjectPair;
-    readonly facet: Exclude<Facet, 'class.composition' | 'class.properties' | 'property.required'>;
+    readonly facet: Exclude<Facet, 'class.composition' | 'class.properties' | 'class.inheritance' | 'property.required'>;
 }): {
     readonly before?: Value;
     readonly after?: Value;

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

@@ -15,7 +15,7 @@ export type DependencyMeaningLevel = 'reference' | 'inherit';
  * compile until it is classified, so meaning can only be narrowed by an explicit decision.
  */
 export type FieldRole = 'always' | 'inherit' | 'members' | {
-    readonly excluded: 'identity' | 'annotation' | 'authorization' | 'presentation';
+    readonly excluded: 'identity' | 'annotation' | 'authorization' | 'extension' | 'presentation';
 };
 /** The coordinate Key already names the declaration; its `ref` is never repeated in the meaning. */
 export declare const CLASS_FIELDS: Readonly<{
@@ -24,12 +24,16 @@ export declare const CLASS_FIELDS: Readonly<{
     }>;
     kind: "always";
     abstract: "always";
+    inheritance: Readonly<{
+        excluded: 'extension';
+    }>;
     orientation: "always";
     extends: "inherit";
     policies: "inherit";
     data: "inherit";
     endpoints: "inherit";
     constraints: "inherit";
+    unique: "always";
     properties: "members";
     methods: "members";
     description: Readonly<{
@@ -119,12 +123,16 @@ export declare const FIELD_ROLES: Readonly<{
         }>;
         kind: "always";
         abstract: "always";
+        inheritance: Readonly<{
+            excluded: 'extension';
+        }>;
         orientation: "always";
         extends: "inherit";
         policies: "inherit";
         data: "inherit";
         endpoints: "inherit";
         constraints: "inherit";
+        unique: "always";
         properties: "members";
         methods: "members";
         description: Readonly<{

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

@@ -1,18 +1,24 @@
 const IDENTITY = Object.freeze({ excluded: 'identity' });
 const ANNOTATION = Object.freeze({ excluded: 'annotation' });
 const AUTHORIZATION = Object.freeze({ excluded: 'authorization' });
+/** Who may extend a Class is no meaning a dependent compiles against. */
+const EXTENSION = Object.freeze({ excluded: 'extension' });
 const PRESENTATION = Object.freeze({ excluded: 'presentation' });
 /** The coordinate Key already names the declaration; its `ref` is never repeated in the meaning. */
 export const CLASS_FIELDS = Object.freeze({
     ref: IDENTITY,
     kind: 'always',
     abstract: 'always',
+    inheritance: EXTENSION,
     orientation: 'always',
     extends: 'inherit',
     policies: 'inherit',
     data: 'inherit',
     endpoints: 'inherit',
     constraints: 'inherit',
+    // A uniqueness tuple bounds every write of the Classes it covers and what a step through them
+    // reaches, so every dependent that names the Class relies on it, not only one that extends it.
+    unique: 'always',
     properties: 'members',
     methods: 'members',
     description: ANNOTATION,

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

@@ -46,7 +46,7 @@ export interface Usage {
     readonly key?: Key;
     readonly relation: ReferenceSite | 'member' | 'abstract' | 'selection' | 'capability';
 }
-export type Facet = 'class.reference' | 'class.inherit' | 'class.composition' | 'class.properties' | 'class.endpoints' | 'property' | 'property.required' | 'method.existence' | 'method.object' | 'method.inheritance' | 'method.signature' | 'function.existence' | 'function.signature' | 'policy' | 'view' | 'core';
+export type Facet = 'class.reference' | 'class.inherit' | 'class.composition' | 'class.properties' | 'class.endpoints' | 'class.inheritance' | 'property' | 'property.required' | 'method.existence' | 'method.object' | 'method.inheritance' | 'method.signature' | 'function.existence' | 'function.signature' | 'policy' | 'view' | 'core';
 /** A fact about a compared facet, including unchanged facets. No admission decision is implied. */
 export interface Observation {
     readonly id: string;
@@ -81,8 +81,9 @@ export interface Assessment {
  * meaning evidence never records whether capabilities were declared. A referenced or inherited Class
  * that loses an effective Property (`class.properties`) raises structure to version 4 and meaning to
  * version 2, and structure is version 4 too when it records that a dependent Policy lost what it
- * relies on (`method.object`, `class.endpoints`). Those facts are recorded only on such a loss, so
- * every other comparison, every compatible one included, keeps its bytes.
+ * relies on (`method.object`, `class.endpoints`) or that a Class the dependent extends became final
+ * (`class.inheritance`). Those facts are recorded only on such a loss, so every other comparison,
+ * every compatible one included, keeps its bytes.
  */
 export interface ComparisonEvidence {
     readonly kind: 'structure' | 'meaning';

package/dist/v1/schema/compatibility/structure/index.js

@@ -12,8 +12,9 @@ export function analyzeStructure(context) {
         ...result,
         compatible: result.assessments.every(({ satisfied }) => satisfied),
         // Each version adds one requirement policy and applies only when its fact is present: 3 a
-        // declared capability root, 4 a lost effective Property of a reached Class or a failed Policy
-        // reliance, facts recorded only when they fail. Without one, evidence keeps its version-2 bytes.
+        // declared capability root, 4 a lost effective Property of a reached Class, a failed Policy
+        // reliance or a refused extension, facts recorded only when they fail. Without one, evidence
+        // keeps its version-2 bytes.
         evidence: evidenceOf({
             kind: 'structure',
             version: recordsFailureOnlyFact(result.assessments)
@@ -27,13 +28,14 @@ export function analyzeStructure(context) {
 }
 /**
  * The facts structure records only when they fail: a referenced or inherited Class that lost an
- * effective Property, and what a dependent Policy relies on (a Method object, a matched Edge's
- * endpoints).
+ * effective Property, what a dependent Policy relies on (a Method object, a matched Edge's
+ * endpoints), and a Class the dependent extends that became final.
  */
 const FAILURE_ONLY_FACETS = new Set([
     'class.properties',
     'method.object',
     'class.endpoints',
+    'class.inheritance',
 ]);
 function recordsFailureOnlyFact(assessments) {
     return assessments.some(({ requirement }) => FAILURE_ONLY_FACETS.has(requirement.kind));

package/dist/v1/schema/compatibility/structure/requirements.js

@@ -1,5 +1,6 @@
 import { Key } from '../../../addressing/index.js';
-import { compareAddedProperties, compareLostProperties } from '../comparators/classes.js';
+import { inheritanceOf } from '../../../language/class/inheritance.js';
+import { compareAddedProperties, compareLostProperties, inheritanceMeaning, } from '../comparators/classes.js';
 import { compareFacet } from '../comparators/index.js';
 import { fingerprintMeaning } from '../comparators/values.js';
 import { contextInvalid } from '../context.js';
@@ -73,6 +74,7 @@ export function compareRequirements({ context, report, }) {
             compareLostProperties({ pair, report });
     }
     compareReliance({ context, report });
+    compareExtension({ context, report });
 }
 /**
  * What a dependent Policy relies on is recorded only when it fails: a Method it names that is gone
@@ -95,3 +97,29 @@ function compareReliance({ context, report, }) {
         report.record({ pair, facet, before, after, requirement: { kind: facet } });
     }
 }
+/**
+ * A Class one of the dependent's own Classes extends must still admit it: the dependent is refused
+ * once the compared origin declares that Class `'final'`. The fact is recorded only when it fails,
+ * like a Policy reliance, so a compatible comparison keeps its evidence bytes.
+ */
+function compareExtension({ context, report, }) {
+    for (const reference of context.roots) {
+        if (reference.usage.relation !== 'extends')
+            continue;
+        if (Key.origin(reference.coordinate.key) !== context.source.origin)
+            continue;
+        const pair = context.pair(reference.coordinate);
+        if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')
+            continue;
+        if (pair.target.analysis.declaration.inheritance !== 'final')
+            continue;
+        report.note(reference);
+        report.record({
+            pair,
+            facet: 'class.inheritance',
+            before: inheritanceMeaning(inheritanceOf(pair.source.analysis.declaration)),
+            after: inheritanceMeaning('final'),
+            requirement: { kind: 'class.inheritance' },
+        });
+    }
+}

package/dist/v1/schema/compatibility/versioning/surface.d.ts

@@ -1,7 +1,7 @@
 import type { Report } from '../report.js';
 import type { ComparisonContext } from '../scope.js';
 /**
- * Compare inherited contracts and newly imposed obligations on existing Classes.
+ * Compare inherited contracts, newly imposed obligations and who may extend existing Classes.
  * Obligations are reported at their declaring Method: changed signatures retain their comparison;
  * an unchanged obligation newly inherited by a Class is added and unsatisfied.
  */

package/dist/v1/schema/compatibility/versioning/surface.js

@@ -1,10 +1,11 @@
+import { inheritanceOf } from '../../../language/class/inheritance.js';
 import { methodInheritance } from '../comparators/callables.js';
-import { compareAddedProperties } from '../comparators/classes.js';
+import { compareAddedProperties, inheritanceMeaning } from '../comparators/classes.js';
 import { compareFacet } from '../comparators/index.js';
 import { fingerprintMeaning } from '../comparators/values.js';
 import { classCoordinate, methodCoordinate } from '../coordinate.js';
 /**
- * Compare inherited contracts and newly imposed obligations on existing Classes.
+ * Compare inherited contracts, newly imposed obligations and who may extend existing Classes.
  * Obligations are reported at their declaring Method: changed signatures retain their comparison;
  * an unchanged obligation newly inherited by a Class is added and unsatisfied.
  */
@@ -25,6 +26,7 @@ export function compareSurface({ context, report, }) {
             requirement: { kind: 'class.inherit' },
         });
         compareAddedProperties({ context, pair, report });
+        compareExtension({ pair, report });
         for (const [key, method] of source.analysis.requirements)
             if (!established.has(key))
                 established.set(key, method);
@@ -54,6 +56,27 @@ export function compareSurface({ context, report, }) {
             });
     }
 }
+/**
+ * A changed inheritance is observed on its Class, and is major when the Class was `'open'` or
+ * becomes `'final'`. Closing an `'open'` Class withdraws what its declaration granted other Domains;
+ * acceptance refuses a subclass of a `'final'` Class of any Domain and admits one of another
+ * Domain's `'internal'` Class (DV-CLASS-INHERITANCE), so finalizing that Class can refuse a dependent.
+ */
+function compareExtension({ pair, report, }) {
+    if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')
+        return;
+    const before = inheritanceOf(pair.source.analysis.declaration);
+    const after = inheritanceOf(pair.target.analysis.declaration);
+    if (before === after)
+        return;
+    report.record({
+        pair,
+        facet: 'class.inheritance',
+        before: inheritanceMeaning(before),
+        after: inheritanceMeaning(after),
+        requirement: { kind: 'class.inheritance', satisfied: before !== 'open' && after !== 'final' },
+    });
+}
 function changed({ before, after }) {
     return (before === undefined ||
         after === undefined ||

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

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

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

@@ -1,6 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { compareDefinitionRefs, compareUnicode } from '../../addressing/ordering.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { compareEdgeUniqueTuples } from '../../language/class/unique.js';
 import { normalizeClassRule, normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
@@ -61,6 +62,7 @@ function canonicalizeClass(value) {
         ref: value.ref,
         kind: value.kind,
         abstract: value.abstract,
+        ...(value.inheritance === undefined ? {} : { inheritance: value.inheritance }),
         extends: [...value.extends].sort(compareDefinitionRefs),
         properties: mapRecord(value.properties, canonicalizeProperty),
     };
@@ -80,6 +82,9 @@ function canonicalizeClass(value) {
             endpoints: canonicalizeDirectedEndpoints(value.endpoints),
             policies: value.policies,
             constraints: value.constraints,
+            ...(value.unique === undefined
+                ? {}
+                : { unique: [...value.unique].sort(compareEdgeUniqueTuples) }),
         }
         : {
             ...base,

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

@@ -109,6 +109,9 @@ function validateParents(environment, owner, ownerKind, parents, diagnostics) {
         if (target.ref.kind !== 'class' || target.declaration.kind !== ownerKind) {
             diagnostics.push(diagnostic('DV_CLASS_KIND', pointer, `${formatDefinitionRef(owner)} cannot extend different-kind Class ${formatDefinitionRef(parent)}.`, formatDefinitionRef(parent)));
         }
+        else if (target.declaration.inheritance === 'final') {
+            diagnostics.push(diagnostic('DV_CLASS_INHERITANCE', pointer, `${formatDefinitionRef(owner)} cannot extend final Class ${formatDefinitionRef(parent)}.`, formatDefinitionRef(parent)));
+        }
     }
 }
 function validateEdgeContract(environment, owner, declaration, diagnostics) {

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

@@ -98,6 +98,9 @@ const edgeConstraintsSchema = strictObject({
     noSelf: literal(true).optional(),
     acyclic: literal(true).optional(),
 });
+// A tuple names an endpoint, then the slug (`EDGE_UNIQUE_TUPLES`). No tuple is spelled by the
+// absence of the field, never by an empty list: one spelling per meaning, one revision.
+const edgeUniqueSchema = uniqueArray(union([tuple([literal('source'), literal('slug')]), tuple([literal('target'), literal('slug')])])).min(1);
 const policyPatternSubjectSchema = strictObject({ kind: literal('subject') });
 const policyPatternObjectSchema = strictObject({ kind: literal('object') });
 const policyPatternSourceSchema = strictObject({ kind: literal('source') });
@@ -233,10 +236,13 @@ const edgeClassPoliciesSchema = strictObject({
     read: classPolicySchema.optional(),
     traverse: classPolicySchema.optional(),
 });
+// The default `'internal'` is the absence of the field: one spelling per meaning, one revision.
+const inheritanceSchema = enumeration(['open', 'final']);
 const nodeClassSchema = strictObject({
     ref: classRefSchema,
     kind: literal('node'),
     abstract: boolean(),
+    inheritance: inheritanceSchema.optional(),
     description: descriptionSchema.optional(),
     extends: uniqueArray(classRefSchema),
     properties: propertyRecordSchema,
@@ -249,10 +255,12 @@ const edgeClassShape = {
     ref: classRefSchema,
     kind: literal('edge'),
     abstract: boolean(),
+    inheritance: inheritanceSchema.optional(),
     description: descriptionSchema.optional(),
     extends: uniqueArray(classRefSchema),
     properties: propertyRecordSchema,
     constraints: edgeConstraintsSchema,
+    unique: edgeUniqueSchema.optional(),
 };
 const edgeClassSchema = strictObject({
     ...edgeClassShape,
@@ -262,14 +270,22 @@ const edgeClassSchema = strictObject({
 }).superRefine(validateEdgeOrientationShape);
 const classDeclarationSchema = discriminatedUnion('kind', [nodeClassSchema, edgeClassSchema]);
 function validateEdgeOrientationShape(value, context) {
-    if ((value.orientation === 'undirected') === Array.isArray(value.endpoints))
-        return;
-    context.addIssue({
-        code: 'custom',
-        path: ['endpoints'],
-        message: `${value.orientation} Edge endpoints have the wrong structural shape.`,
-        params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
-    });
+    if ((value.orientation === 'undirected') !== Array.isArray(value.endpoints)) {
+        context.addIssue({
+            code: 'custom',
+            path: ['endpoints'],
+            message: `${value.orientation} Edge endpoints have the wrong structural shape.`,
+            params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
+        });
+    }
+    if (value.orientation === 'undirected' && value.unique !== undefined) {
+        context.addIssue({
+            code: 'custom',
+            path: ['unique'],
+            message: 'Only a directed Edge Class declares unique tuples.',
+            params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
+        });
+    }
 }
 const functionDefinitionSchema = strictObject({
     ref: functionRefSchema,

package/package.json

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