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

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

@@ -1,46 +1,257 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { ClassKey } from '../../addressing/class-key.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { PropertyKey } from '../../addressing/property-key.js';
+/** The kinds of key fields, in canonical order: the endpoints, the slug, then the Properties. */
+const KINDS = Object.freeze([
+    'source',
+    'target',
+    'slug',
+    'property',
+]);
+/** The canonical order of forms: kind by kind, a form before every form it prefixes. */
+const compareForms = compareSequences(compareKinds);
 /**
- * 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.
+ * Every form a key tuple may take, in canonical order: each nonempty set of field kinds. A Property
+ * kind stands for one Property or more, whatever their keys.
  */
-export const EDGE_UNIQUE_TUPLES = Object.freeze([
-    Object.freeze(['source', 'slug']),
-    Object.freeze(['target', 'slug']),
+export const EDGE_UNIQUE_FORMS = Object.freeze(Array.from({ length: (1 << KINDS.length) - 1 }, (_, index) => Object.freeze(KINDS.filter((_, kind) => ((index + 1) & (1 << kind)) !== 0))).sort(compareForms));
+/** The one form a Node key tuple takes: its fields are Properties, whatever their keys. */
+export const NODE_UNIQUE_FORMS = Object.freeze([
+    Object.freeze(['property']),
 ]);
-/** 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. */
+/** Every form of every kind, which a backend enforcing any key tuple announces. */
+export const UNIQUE_FORMS = Object.freeze({
+    edge: EDGE_UNIQUE_FORMS,
+    node: NODE_UNIQUE_FORMS,
+});
+/** No form of either kind: a backend that announces none enforces no key tuple. */
+export const NO_UNIQUE_FORMS = Object.freeze({
+    edge: Object.freeze([]),
+    node: Object.freeze([]),
+});
+/** The kind of `field`. */
+function kindOf(field) {
+    return typeof field === 'string' ? field : 'property';
+}
+function compareKinds(left, right) {
+    return KINDS.indexOf(left) - KINDS.indexOf(right);
+}
+/** The canonical order of fields: source, target, slug, then Properties by key. */
+export function compareEdgeUniqueFields(left, right) {
+    return (compareKinds(kindOf(left), kindOf(right)) ||
+        (typeof left === 'string' || typeof right === 'string'
+            ? 0
+            : compareUnicode(left.property, right.property)));
+}
+/** The canonical order of tuples: field by field, a tuple before every tuple it prefixes. */
+export const compareEdgeUniqueTuples = compareSequences(compareEdgeUniqueFields);
+/** The field `value` spells, detached, or undefined when it spells none. */
+function edgeUniqueField(value) {
+    if (value === 'source' || value === 'target' || value === 'slug')
+        return value;
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const keys = Object.keys(value);
+    const property = value.property;
+    return keys.length === 1 && keys[0] === 'property' && PropertyKey.is(property)
+        ? Object.freeze({ property })
+        : undefined;
+}
+/**
+ * The tuple `value` spells, detached, or undefined when it spells none: a nonempty list of fields,
+ * distinct and in canonical order, so one set of fields has one spelling.
+ */
 export function edgeUniqueTuple(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const fields = [];
+    for (const item of value) {
+        const field = edgeUniqueField(item);
+        if (field === undefined)
+            return undefined;
+        if (fields.length > 0 && compareEdgeUniqueFields(fields.at(-1), field) >= 0)
+            return undefined;
+        fields.push(field);
+    }
+    return Object.freeze(fields);
+}
+/** The canonical order of Node tuples: Property by Property, a tuple before every one it prefixes. */
+export const compareNodeUniqueTuples = compareSequences(compareUnicode);
+/**
+ * The Node tuple `value` spells, detached, or undefined when it spells none: a nonempty list of
+ * Property keys, distinct and in code-point order, so one set of Properties has one spelling.
+ */
+export function nodeUniqueTuple(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    const keys = [];
+    for (const key of value) {
+        if (!PropertyKey.is(key))
+            return undefined;
+        if (keys.length > 0 && compareUnicode(keys.at(-1), key) >= 0)
+            return undefined;
+        keys.push(key);
+    }
+    return Object.freeze(keys);
+}
+/** The form of `NODE_UNIQUE_FORMS` that `value` spells, or undefined when it spells none. */
+export function nodeUniqueForm(value) {
+    return Array.isArray(value) && value.length === 1 && value[0] === 'property'
+        ? NODE_UNIQUE_FORMS[0]
+        : undefined;
+}
+/**
+ * Whether a backend announcing `forms` for Nodes enforces the Node tuple `value` spells: every
+ * Node tuple has the one Node form. False when `value` spells no tuple.
+ */
+export function enforcesNodeUniqueTuple(forms, value) {
+    return forms.length > 0 && nodeUniqueTuple(value) !== undefined;
+}
+/** The form of `tuple`: the kinds of its fields, each once. */
+export function edgeUniqueFormOf(tuple) {
+    const kinds = new Set(tuple.map(kindOf));
+    return EDGE_UNIQUE_FORMS.find((form) => form.length === kinds.size && form.every((kind) => kinds.has(kind)));
+}
+/** The form of `EDGE_UNIQUE_FORMS` that `value` spells, or undefined when it spells none. */
+export function edgeUniqueForm(value) {
     if (!Array.isArray(value))
         return undefined;
-    return EDGE_UNIQUE_TUPLES.find((tuple) => tuple.length === value.length && tuple.every((field, index) => field === value[index]));
+    return EDGE_UNIQUE_FORMS.find((form) => form.length === value.length && form.every((kind, index) => kind === value[index]));
 }
-/** Whether `tuples` lists the tuple `value` spells: false when it spells none. */
-export function includesEdgeUniqueTuple(tuples, value) {
+/**
+ * Whether a backend announcing `forms` enforces the tuple `value` spells: its form is one of them.
+ * False when `value` spells no tuple, so a tuple is never taken as enforced by mistake.
+ */
+export function enforcesEdgeUniqueTuple(forms, 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;
+    if (tuple === undefined)
+        return false;
+    const form = edgeUniqueFormOf(tuple);
+    return forms.some((candidate) => compareForms(candidate, form) === 0);
+}
+/**
+ * Whether a Property may be a key field (D-S1): a single-kind scalar by its ordering facet, a
+ * string, number, boolean or instant, that no automatic program writes.
+ */
+export function keyableProperty(ordering, auto) {
+    return ordering !== undefined && auto === undefined;
+}
+/**
+ * The values of the fields of `tuple` on `edge`, in order, or undefined when one of them is absent,
+ * so that an Edge without a slug or without a Property never collides.
+ */
+export function edgeUniqueValues(tuple, edge) {
+    return keyValues(tuple, (field) => typeof field === 'string' ? edge[field] : propertyOf(edge.props, field.property));
 }
 /**
- * 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.
+ * The value `edge` takes under `tuple`, the canonical JSON of the values of its fields, or
+ * undefined when one of them is absent: two distinct Edges of the Classes a tuple covers collide
+ * exactly when they take one value. Endpoints compare by NodeId, slugs by exact text and
+ * Properties by canonical Value.
  */
 export function edgeUniqueValue(tuple, edge) {
+    return serialized(edgeUniqueValues(tuple, edge));
+}
+/**
+ * The values of the Properties of `tuple` on `node`, in order, or undefined when one of them is
+ * absent, so that a Node without one of them never collides, like NULL in an SQL UNIQUE.
+ */
+export function nodeUniqueValues(tuple, node) {
+    return keyValues(tuple, (key) => propertyOf(node.props, key));
+}
+/**
+ * The value `node` takes under `tuple`, the canonical JSON of the values of its Properties, or
+ * undefined when one of them is absent: two distinct Nodes of the Classes a tuple covers collide
+ * exactly when they take one value. Properties compare by canonical Value, nothing normalized.
+ */
+export function nodeUniqueValue(tuple, node) {
+    return serialized(nodeUniqueValues(tuple, node));
+}
+/**
+ * The tuples covering `candidate`: those it and each of its ancestors declare, each with the Class
+ * declaring it, ancestors found by `resolve`. A descendant never restates them.
+ */
+export function coveringEdgeUniqueTuples(candidate, resolve) {
+    return coveringTuples(candidate, resolve);
+}
+/**
+ * The Node tuples covering `candidate`: those it and each of its ancestors declare, each with the
+ * Class declaring it, ancestors found by `resolve`. A descendant never restates them.
+ */
+export function coveringNodeUniqueTuples(candidate, resolve) {
+    return coveringTuples(candidate, resolve);
+}
+/**
+ * The keys `edge` holds: its value under each tuple of `tuples`, tagged by the Class declaring the
+ * tuple, so two Edges collide exactly when they hold one key.
+ */
+export function edgeUniqueKeys(tuples, edge) {
+    return heldKeys(tuples, (fields) => edgeUniqueValue(fields, edge));
+}
+/**
+ * The keys `node` holds: its value under each tuple of `tuples`, tagged by the Class declaring the
+ * tuple, so two Nodes collide exactly when they hold one key.
+ */
+export function nodeUniqueKeys(tuples, node) {
+    return heldKeys(tuples, (fields) => nodeUniqueValue(fields, node));
+}
+/** The values `read` gives the fields of `tuple`, in order, or undefined when one is absent. */
+function keyValues(tuple, read) {
     const values = [];
     for (const field of tuple) {
-        const value = edge[field];
+        const value = read(field);
         if (value === undefined)
             return undefined;
         values.push(value);
     }
-    return JSON.stringify(values);
+    return Object.freeze(values);
+}
+/** The value of the Property `key` in `props`, or undefined when it is absent. */
+function propertyOf(props, key) {
+    return Object.hasOwn(props, key) ? props[key] : undefined;
+}
+/** The canonical JSON of a key's values, or undefined when it has none. */
+function serialized(values) {
+    return values === undefined ? undefined : json.serializeAdmitted(values);
+}
+/**
+ * The tuples `candidate` and its ancestors declare, each with its declarer. Only ancestors of the
+ * candidate's kind are visited, so every tuple is of that kind.
+ */
+function coveringTuples(candidate, resolve) {
+    const tuples = [];
+    const seen = new Set();
+    const visit = (value) => {
+        if (seen.has(value) || value.kind !== candidate.kind)
+            return;
+        seen.add(value);
+        for (const fields of value.unique ?? [])
+            tuples.push(Object.freeze({ class: ClassKey.of(value.ref), fields }));
+        for (const ref of value.extends) {
+            const parent = resolve(ref);
+            if (parent !== undefined)
+                visit(parent);
+        }
+    };
+    visit(candidate);
+    return Object.freeze(tuples);
+}
+/** The keys a fact holds under `tuples`, its value under each tagged by the declaring Class. */
+function heldKeys(tuples, valueOf) {
+    return tuples.flatMap(({ class: declaring, fields }) => {
+        const value = valueOf(fields);
+        return value === undefined ? [] : [JSON.stringify([declaring, fields, value])];
+    });
+}
+/** The lexicographic order of sequences by `compare`, a sequence before every one it prefixes. */
+function compareSequences(compare) {
+    return (left, right) => {
+        for (let index = 0; index < Math.min(left.length, right.length); index += 1) {
+            const order = compare(left[index], right[index]);
+            if (order !== 0)
+                return order;
+        }
+        return left.length - right.length;
+    };
 }

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

@@ -15,10 +15,10 @@ 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 { edgeLifetimes, lifetimeScope } from './class/lifetime.js';
+export type { LifetimeScope } from './class/lifetime.js';
+export { EDGE_UNIQUE_FORMS, NODE_UNIQUE_FORMS, NO_UNIQUE_FORMS, UNIQUE_FORMS, compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueForm, edgeUniqueFormOf, edgeUniqueKeys, edgeUniqueTuple, edgeUniqueValue, edgeUniqueValues, enforcesEdgeUniqueTuple, enforcesNodeUniqueTuple, keyableProperty, nodeUniqueForm, nodeUniqueKeys, nodeUniqueTuple, nodeUniqueValue, nodeUniqueValues, } from './class/unique.js';
+export type { DeclaredEdgeUniqueTuple, DeclaredNodeUniqueTuple, EdgeUniqueFacts, NodeUniqueFacts, UniqueForms, } 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

@@ -4,7 +4,7 @@ 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 { edgeLifetimes, lifetimeScope } from './class/lifetime.js';
+export { EDGE_UNIQUE_FORMS, NODE_UNIQUE_FORMS, NO_UNIQUE_FORMS, UNIQUE_FORMS, compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueForm, edgeUniqueFormOf, edgeUniqueKeys, edgeUniqueTuple, edgeUniqueValue, edgeUniqueValues, enforcesEdgeUniqueTuple, enforcesNodeUniqueTuple, keyableProperty, nodeUniqueForm, nodeUniqueKeys, nodeUniqueTuple, nodeUniqueValue, nodeUniqueValues, } 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/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_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 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_EDGE_UNIQUE' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_NODE_UNIQUE' | '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_LIFETIME' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_EDGE_UNIQUE' | 'DV_ENTRYPOINT' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_NODE_UNIQUE' | '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,7 +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 { compareEdgeUniqueFields, compareEdgeUniqueTuples, compareNodeUniqueTuples, } 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';
@@ -73,6 +73,7 @@ function canonicalizeClass(value) {
             ...(value.data === undefined ? {} : { data: { mediaType: value.data.mediaType } }),
             ...(value.icon === undefined ? {} : { icon: value.icon }),
             policies: canonicalizeNodePolicies(value.policies),
+            ...(value.unique === undefined ? {} : { unique: canonicalizeNodeUnique(value.unique) }),
         };
     }
     return value.orientation === 'directed'
@@ -82,9 +83,7 @@ function canonicalizeClass(value) {
             endpoints: canonicalizeDirectedEndpoints(value.endpoints),
             policies: value.policies,
             constraints: value.constraints,
-            ...(value.unique === undefined
-                ? {}
-                : { unique: [...value.unique].sort(compareEdgeUniqueTuples) }),
+            ...(value.unique === undefined ? {} : { unique: canonicalizeUnique(value.unique) }),
         }
         : {
             ...base,
@@ -94,6 +93,18 @@ function canonicalizeClass(value) {
             constraints: value.constraints,
         };
 }
+/** A set of Node key tuples, each a set of Property keys, both in their canonical order. */
+function canonicalizeNodeUnique(tuples) {
+    return tuples
+        .map((tuple) => [...tuple].sort(compareUnicode))
+        .sort(compareNodeUniqueTuples);
+}
+/** A set of key tuples, each a set of fields: fields and tuples take their canonical order. */
+function canonicalizeUnique(tuples) {
+    return tuples
+        .map((tuple) => [...tuple].sort(compareEdgeUniqueFields))
+        .sort(compareEdgeUniqueTuples);
+}
 /** A rule keeps one spelling: normalized checks, or the Policy a lone `self` check names. */
 function canonicalizeNodePolicies(value) {
     return {

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

@@ -2,16 +2,19 @@ import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
 import { classSatisfies as satisfiesClass, isGraphRoot } from '../../language/class/inheritance.js';
+import { lifetimeBreaches, lifetimeScope } from '../../language/class/lifetime.js';
+import { keyableProperty } from '../../language/class/unique.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { isBlobValueSchema } from '../../language/value/model/blob.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
 import { diagnostic } from '../diagnostic.js';
-import { createValueSchemaRegistry } from '../resolution/value.registry.js';
+import { createDomainValueSchemaRegistry, createValueSchemaRegistry, } from '../resolution/value.registry.js';
 const formatDefinitionRef = Key.of;
 /** Validate the semantic contracts owned by Class declarations. */
 export function validateDefinitions(environment, analysis) {
     const diagnostics = [...analysis.diagnostics];
     const schema = environment.candidate;
+    let scope;
     for (const [name, declaration] of Object.entries(schema.classes)) {
         const ref = localRef(schema.origin, name);
         const pointer = `/classes/${escapePointer(name)}`;
@@ -26,7 +29,10 @@ export function validateDefinitions(environment, analysis) {
         validateParents(environment, ref, declaration.kind, declaration.extends, diagnostics);
         if (declaration.kind === 'edge') {
             validateEdgeContract(environment, ref, declaration, diagnostics);
+            scope ??= lifetimeScope([...environment.definitions.values()].map(({ declaration }) => declaration));
+            validateEdgeLifetimes(scope, ref, declaration, pointer, diagnostics);
         }
+        validateUniqueProperties(environment, analysis, ref, declaration, pointer, diagnostics);
     }
     validateEdgeClassComposition(environment, diagnostics);
     return Object.freeze(diagnostics);
@@ -132,6 +138,56 @@ function validateEdgeContract(environment, owner, declaration, diagnostics) {
         }
     }
 }
+/**
+ * Each Property a key tuple names is one of the Class's own or inherited Properties, and keyable:
+ * a single-kind scalar by its ordering facet that no automatic program writes (D-S1). Properties
+ * inherit without redefinition, so the key reads one meaning on every descendant it covers. A Node
+ * tuple names Properties only; an Edge tuple names them as `{ property }` beside its other fields.
+ */
+function validateUniqueProperties(environment, analysis, owner, declaration, pointer, diagnostics) {
+    if (declaration.kind === 'edge' && declaration.orientation !== 'directed')
+        return;
+    if (declaration.unique === undefined)
+        return;
+    const properties = analysis.definitions.get(definitionRefIndex(owner))?.properties;
+    if (properties === undefined)
+        return;
+    const code = declaration.kind === 'node' ? 'DV_NODE_UNIQUE' : 'DV_EDGE_UNIQUE';
+    const registries = new Map();
+    const registryOf = (origin) => {
+        if (!registries.has(origin)) {
+            const schema = environment.dependencies.get(origin);
+            const registry = origin === environment.candidate.origin
+                ? createValueSchemaRegistry(environment)
+                : schema === undefined
+                    ? undefined
+                    : createDomainValueSchemaRegistry(schema);
+            if (registry !== undefined)
+                registries.set(origin, registry);
+        }
+        return registries.get(origin);
+    };
+    const check = (key, at) => {
+        const property = properties.get(key);
+        if (property === undefined) {
+            diagnostics.push(diagnostic(code, at, `${key} is not a Property of the Class.`));
+            return;
+        }
+        const registry = registryOf(property.owner.origin);
+        const ordering = registry === undefined ? undefined : classifyOrdering(property.schema, registry);
+        if (!keyableProperty(ordering, property.auto)) {
+            diagnostics.push(diagnostic(code, at, 'A key Property is a string, number, boolean or instant that no automatic program writes.'));
+        }
+    };
+    if (declaration.kind === 'node') {
+        declaration.unique.forEach((tuple, t) => tuple.forEach((key, f) => check(key, `${pointer}/unique/${t}/${f}`)));
+        return;
+    }
+    declaration.unique.forEach((tuple, t) => tuple.forEach((field, f) => {
+        if (typeof field !== 'string')
+            check(field.property, `${pointer}/unique/${t}/${f}/property`);
+    }));
+}
 function validateEndpoint(environment, owner, endpoint, count, side, diagnostics) {
     // An Edge Class binds only the Nodes of its Domain and its dependents: it cannot oblige the
     // Nodes of a Class another Domain owns to carry its Edges.
@@ -154,6 +210,19 @@ function validateEndpoint(environment, owner, endpoint, count, side, diagnostics
         }
     }
 }
+/**
+ * The lifetime laws over the lifetimes a Schema declares. What an endpoint derives where it
+ * declares nothing is never refused here: a stored Registry decoded again keeps it.
+ */
+function validateEdgeLifetimes(scope, owner, declaration, pointer, diagnostics) {
+    const sides = declaration.orientation === 'directed'
+        ? ['source', 'target']
+        : ['first endpoint', 'second endpoint'];
+    const keys = declaration.orientation === 'directed' ? ['source', 'target'] : ['0', '1'];
+    for (const { index, reason } of lifetimeBreaches(declaration, scope)) {
+        diagnostics.push(diagnostic('DV_EDGE_LIFETIME', `${pointer}/endpoints/${keys[index]}/onDelete`, `${formatDefinitionRef(owner)} ${sides[index]} ${reason}`));
+    }
+}
 /** Edge inheritance is refinement, not a second interface composition mechanism. */
 function validateEdgeClassComposition(environment, diagnostics) {
     for (const resolved of environment.definitions.values()) {

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

@@ -1,6 +1,7 @@
 import { Key } from '../../addressing/key.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
+import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../language/class/unique.js';
 import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { diagnostic } from '../diagnostic.js';
@@ -10,9 +11,34 @@ export function validateCore(environment, analysis, registry) {
     const diagnostics = [];
     const nodesByRef = resolveCoreNodes(environment, analysis, registry, diagnostics);
     const edges = resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnostics);
+    validateCoreNodeKeys(environment, nodesByRef, diagnostics);
     validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics);
     return Object.freeze(diagnostics);
 }
+/**
+ * No two Core Nodes hold one key under a tuple covering their Classes, whichever Class or ancestor
+ * declares it (DV-NODE-UNIQUE); Activation checks them against stored data.
+ */
+function validateCoreNodeKeys(environment, nodesByRef, diagnostics) {
+    const resolve = (ref) => environment.resolveAny(ref)?.declaration;
+    const holders = new Map();
+    for (const node of nodesByRef.values()) {
+        const declaration = resolve(node.classRef);
+        if (declaration === undefined)
+            continue;
+        const pointer = `/core/nodes/${escapePointer(node.slug)}`;
+        const keys = nodeUniqueKeys(coveringNodeUniqueTuples(declaration, resolve), {
+            props: environment.candidate.core.nodes[node.slug].properties,
+        });
+        const previous = keys.map((key) => holders.get(key)).find((at) => at !== undefined);
+        if (previous !== undefined) {
+            diagnostics.push(diagnostic('DV_CORE_NODE_UNIQUE', pointer, `Core Node holds a key the Core Node at ${previous} holds.`));
+        }
+        for (const key of keys)
+            if (!holders.has(key))
+                holders.set(key, pointer);
+    }
+}
 function resolveCoreNodes(environment, analysis, registry, diagnostics) {
     const nodes = new Map();
     for (const [slug, node] of Object.entries(environment.candidate.core.nodes)) {
@@ -175,6 +201,7 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
             diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', edge.pointer, 'Core Edge violates noSelf.'));
         }
     }
+    validateCoreEdgeKeys(environment, edges, diagnostics);
     for (const { declaration, edges: classEdges } of edgeSlices.values()) {
         if (declaration.constraints.acyclic === true && hasDirectedCycle(classEdges)) {
             diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', '/core/edges', 'Core Edge set violates exact-Class acyclicity.'));
@@ -182,6 +209,29 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
         validateCardinality(environment, declaration, classEdges, nodesByRef, diagnostics);
     }
 }
+/**
+ * No two Core Edges hold one key under a tuple covering their Classes, whichever Class or ancestor
+ * declares it (DV-EDGE-UNIQUE). Core Edges have no slug, so only tuples of endpoints and
+ * Properties can bind them; Activation checks them against stored data.
+ */
+function validateCoreEdgeKeys(environment, edges, diagnostics) {
+    const resolve = (ref) => environment.resolveAny(ref)?.declaration;
+    const holders = new Map();
+    for (const edge of edges) {
+        const keys = edgeUniqueKeys(coveringEdgeUniqueTuples(edge.declaration, resolve), {
+            source: edge.source.key,
+            target: edge.target.key,
+            props: edge.value.properties,
+        });
+        const previous = keys.map((key) => holders.get(key)).find((pointer) => pointer !== undefined);
+        if (previous !== undefined) {
+            diagnostics.push(diagnostic('DV_CORE_EDGE_UNIQUE', edge.pointer, `Core Edge holds a key the Core Edge at ${previous} holds.`));
+        }
+        for (const key of keys)
+            if (!holders.has(key))
+                holders.set(key, edge.pointer);
+    }
+}
 function validateCardinality(environment, declaration, edges, nodesByRef, diagnostics) {
     const subjects = cardinalitySubjects(edges, nodesByRef);
     if (declaration.orientation === 'undirected') {

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

@@ -83,6 +83,7 @@ const coreEndpointRefSchema = discriminatedUnion('kind', [
 const edgeEndpointBaseShape = {
     role: memberNameSchema,
     accepts: uniqueArray(classRefSchema).min(1),
+    onDelete: enumeration(['restrict', 'detach']).optional(),
 };
 const edgeCountSchema = enumeration(['0..*', '1..*', '0..1', '1']);
 const directedEdgeEndpointsSchema = strictObject({
@@ -98,9 +99,21 @@ 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
+// A tuple names distinct fields: endpoints, the slug and Properties by key. Normalization puts
+// them, and the tuples, in canonical order (`compareEdgeUniqueFields`). 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 edgeUniqueFieldSchema = union([
+    literal('source'),
+    literal('target'),
+    literal('slug'),
+    strictObject({ property: propertyKeySchema }),
+]);
+const edgeUniqueSchema = uniqueArray(uniqueArray(edgeUniqueFieldSchema).min(1), (tuple) => 
+// Two spellings of one set of fields are one tuple, repeated.
+JSON.stringify(tuple.map(canonicalJson).sort())).min(1);
+// A Node tuple names distinct Properties by key, which normalization puts in code-point order, as
+// it does the tuples (`compareNodeUniqueTuples`). Two orders of one set of keys are one tuple.
+const nodeUniqueSchema = uniqueArray(uniqueArray(propertyKeySchema).min(1), (tuple) => JSON.stringify([...tuple].sort())).min(1);
 const policyPatternSubjectSchema = strictObject({ kind: literal('subject') });
 const policyPatternObjectSchema = strictObject({ kind: literal('object') });
 const policyPatternSourceSchema = strictObject({ kind: literal('source') });
@@ -250,6 +263,7 @@ const nodeClassSchema = strictObject({
     data: dataDeclarationSchema.optional(),
     icon: iconSchema.optional(),
     policies: nodeClassPoliciesSchema,
+    unique: nodeUniqueSchema.optional(),
 });
 const edgeClassShape = {
     ref: classRefSchema,
@@ -389,11 +403,11 @@ function isStateTransitions(input) {
 function isRecord(input) {
     return input !== null && typeof input === 'object' && !Array.isArray(input);
 }
-function uniqueArray(element) {
+function uniqueArray(element, keyOf = canonicalJson) {
     return array(element).superRefine((values, context) => {
         const firstIndexByValue = new Map();
         values.forEach((value, index) => {
-            const key = canonicalJson(value);
+            const key = keyOf(value);
             const firstIndex = firstIndexByValue.get(key);
             if (firstIndex === undefined) {
                 firstIndexByValue.set(key, index);

package/package.json

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

package/dist/v1/builder/lowering/core-properties.d.ts

@@ -1,10 +0,0 @@
-import type { CoreContent } from '../../language/core/model/core.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;
-};
-/** Lower rich builder shorthand to the canonical full-key Core representation. */
-export declare function canonicalizeCorePropertyKeys(candidate: UnqualifiedDomainSchema, lookup: DomainSchemaLookup): CoreContent;
-export {};