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

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

@@ -1,17 +1,54 @@
 import type { ClassRef } from '../../addressing/index.js';
-import type { EdgeContract } from './model/edge.js';
+import type { ClassDefinition, EdgeClassDefinition } from './model/class.js';
+import type { EdgeContract, EdgeCount, EdgeEndpointBase, EdgeLifetime } from './model/edge.js';
+export type { EdgeLifetime } from './model/edge.js';
+/** The Classes lifetimes read: those of an Edge Class's Domain and of its dependency closure. */
+export interface LifetimeScope {
+    /**
+     * Whether a Node of another Domain may be of the Class: it is `'open'`, or a Class of its own
+     * Domain that extends it is.
+     */
+    readonly extendable: (ref: ClassRef) => boolean;
+}
+/** The lifetime scope of `classes`. */
+export declare function lifetimeScope(classes: Iterable<ClassDefinition>): LifetimeScope;
+/** One endpoint of an Edge contract and how many Edges of the Class each Node in it has. */
+export interface ContractEndpoint {
+    readonly endpoint: EdgeEndpointBase;
+    readonly count: EdgeCount;
+}
+/** The endpoints of an Edge contract in order: source then target, or the two incident ones. */
+export declare function contractEndpoints(contract: EdgeContract): readonly [ContractEndpoint, ContractEndpoint];
 /**
- * What deleting the Node at one endpoint does to an Edge: `restrict` requires the transition to
- * delete the Edge explicitly; `detach` deletes the Edge with the Node.
+ * Whether an endpoint of an Edge Class of `origin` can hold a Node of another Domain: it accepts a
+ * Class `origin` does not own, or one another Domain may extend.
  */
-export type EdgeLifetime = 'restrict' | 'detach';
+export declare function reachesAnotherDomain(origin: ClassRef['origin'], endpoint: EdgeEndpointBase, scope: LifetimeScope): boolean;
 /**
- * The lifetime of each endpoint of an Edge Class, in endpoint order (source then target, or the two
- * incident endpoints), derived from the contract its Domain `origin` declares.
+ * The lifetime of each endpoint of `edge`, in endpoint order: the one it declares, else the derived
+ * one.
  *
- * An Edge Class binds only the Nodes of its own Domain and of the Domains that depend on it. An
- * endpoint that accepts a Class `origin` does not own can therefore reach a Node it does not bind,
- * and such a foreign endpoint detaches, unless an endpoint declares a minimum count that
- * detaching would break. Every other endpoint restricts.
+ * An Edge Class binds only the Nodes of its own Domain and of the Domains that depend on it, and a
+ * Domain blocks only the deletion of its own Nodes. An endpoint that can hold a Node of another
+ * Domain therefore detaches, unless an endpoint of the Class declares a minimum count that
+ * detaching could break (`requiredEndpoint`). Every other endpoint restricts.
  */
-export declare function edgeLifetimes(origin: ClassRef['origin'], contract: EdgeContract): readonly [EdgeLifetime, EdgeLifetime];
+export declare function edgeLifetimes(edge: EdgeClassDefinition, scope: LifetimeScope): readonly [EdgeLifetime, EdgeLifetime];
+/** One breach of the lifetime laws at one endpoint of an Edge Class: its index and why. */
+export interface LifetimeBreach {
+    readonly index: 0 | 1;
+    readonly reason: string;
+}
+/**
+ * The breaches of the lifetime laws (LANGUAGE-EDGE-LIFETIME) by the lifetimes `edge` declares: an
+ * endpoint that can hold a Node of another Domain never restricts, and none detaches in a Class
+ * with an endpoint that requires an Edge (`requiredEndpoint`). A derived lifetime breaks neither.
+ */
+export declare function lifetimeBreaches(edge: EdgeClassDefinition, scope: LifetimeScope): readonly LifetimeBreach[];
+/**
+ * The first endpoint of an Edge Class that requires an Edge, if one does, with its index. Detaching
+ * there could leave a Node below its count, so an endpoint of such a Class never detaches.
+ */
+export declare function requiredEndpoint(edge: EdgeContract): (ContractEndpoint & {
+    readonly index: 0 | 1;
+}) | undefined;

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

@@ -1,26 +1,92 @@
-/**
- * The lifetime of each endpoint of an Edge Class, in endpoint order (source then target, or the two
- * incident endpoints), derived from the contract its Domain `origin` declares.
- *
- * An Edge Class binds only the Nodes of its own Domain and of the Domains that depend on it. An
- * endpoint that accepts a Class `origin` does not own can therefore reach a Node it does not bind,
- * and such a foreign endpoint detaches, unless an endpoint declares a minimum count that
- * detaching would break. Every other endpoint restricts.
- */
-export function edgeLifetimes(origin, contract) {
-    const endpoints = contract.orientation === 'directed'
+import { definitionRefIndex } from '../../addressing/ordering.js';
+/** The lifetime scope of `classes`. */
+export function lifetimeScope(classes) {
+    const declarations = new Map();
+    for (const declaration of classes)
+        declarations.set(definitionRefIndex(declaration.ref), declaration);
+    const extendable = new Set();
+    const open = (ref) => {
+        const key = definitionRefIndex(ref);
+        if (extendable.has(key))
+            return;
+        extendable.add(key);
+        for (const parent of declarations.get(key)?.extends ?? [])
+            if (parent.origin === ref.origin)
+                open(parent);
+    };
+    for (const declaration of declarations.values())
+        if (declaration.kind === 'node' && declaration.inheritance === 'open')
+            open(declaration.ref);
+    return Object.freeze({
+        extendable: (ref) => extendable.has(definitionRefIndex(ref)),
+    });
+}
+/** The endpoints of an Edge contract in order: source then target, or the two incident ones. */
+export function contractEndpoints(contract) {
+    return contract.orientation === 'directed'
         ? [
-            [contract.endpoints.source.accepts, contract.endpoints.source.outgoing],
-            [contract.endpoints.target.accepts, contract.endpoints.target.incoming],
+            { endpoint: contract.endpoints.source, count: contract.endpoints.source.outgoing },
+            { endpoint: contract.endpoints.target, count: contract.endpoints.target.incoming },
         ]
         : [
-            [contract.endpoints[0].accepts, contract.endpoints[0].incident],
-            [contract.endpoints[1].accepts, contract.endpoints[1].incident],
+            { endpoint: contract.endpoints[0], count: contract.endpoints[0].incident },
+            { endpoint: contract.endpoints[1], count: contract.endpoints[1].incident },
         ];
-    const required = endpoints.some(([, count]) => minimum(count) > 0);
-    const lifetime = ([accepts]) => !required && accepts.some((ref) => ref.origin !== origin) ? 'detach' : 'restrict';
-    return Object.freeze([lifetime(endpoints[0]), lifetime(endpoints[1])]);
 }
-function minimum(count) {
-    return count === '1' || count === '1..*' ? 1 : 0;
+/**
+ * Whether an endpoint of an Edge Class of `origin` can hold a Node of another Domain: it accepts a
+ * Class `origin` does not own, or one another Domain may extend.
+ */
+export function reachesAnotherDomain(origin, endpoint, scope) {
+    return endpoint.accepts.some((ref) => ref.origin !== origin || scope.extendable(ref));
+}
+/**
+ * The lifetime of each endpoint of `edge`, in endpoint order: the one it declares, else the derived
+ * one.
+ *
+ * An Edge Class binds only the Nodes of its own Domain and of the Domains that depend on it, and a
+ * Domain blocks only the deletion of its own Nodes. An endpoint that can hold a Node of another
+ * Domain therefore detaches, unless an endpoint of the Class declares a minimum count that
+ * detaching could break (`requiredEndpoint`). Every other endpoint restricts.
+ */
+export function edgeLifetimes(edge, scope) {
+    const required = requiredEndpoint(edge) !== undefined;
+    const [head, tail] = contractEndpoints(edge).map(({ endpoint }) => endpoint.onDelete ??
+        (!required && reachesAnotherDomain(edge.ref.origin, endpoint, scope) ? 'detach' : 'restrict'));
+    return Object.freeze([head, tail]);
+}
+/**
+ * The breaches of the lifetime laws (LANGUAGE-EDGE-LIFETIME) by the lifetimes `edge` declares: an
+ * endpoint that can hold a Node of another Domain never restricts, and none detaches in a Class
+ * with an endpoint that requires an Edge (`requiredEndpoint`). A derived lifetime breaks neither.
+ */
+export function lifetimeBreaches(edge, scope) {
+    const required = requiredEndpoint(edge)?.count;
+    return Object.freeze(contractEndpoints(edge).flatMap(({ endpoint }, index) => {
+        const at = index;
+        if (endpoint.onDelete === 'restrict' &&
+            reachesAnotherDomain(edge.ref.origin, endpoint, scope))
+            return [
+                {
+                    index: at,
+                    reason: 'can hold Nodes of another Domain and cannot restrict their deletion.',
+                },
+            ];
+        if (endpoint.onDelete === 'detach' && required !== undefined)
+            return [
+                {
+                    index: at,
+                    reason: `cannot detach: an endpoint of the Class requires ${required} Edges.`,
+                },
+            ];
+        return [];
+    }));
+}
+/**
+ * The first endpoint of an Edge Class that requires an Edge, if one does, with its index. Detaching
+ * there could leave a Node below its count, so an endpoint of such a Class never detaches.
+ */
+export function requiredEndpoint(edge) {
+    const index = contractEndpoints(edge).findIndex(({ count }) => count === '1' || count === '1..*');
+    return index === -1 ? undefined : { ...contractEndpoints(edge)[index], index: index };
 }

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

@@ -1,4 +1,4 @@
-import type { ClassRef, DefinitionBase } from '../../../addressing/index.js';
+import type { ClassRef, DefinitionBase, PropertyKey } from '../../../addressing/index.js';
 import type { MethodRecord } from '../../callable/model/callable.js';
 import type { ClassPolicy, NodeClassPolicy } from '../../policy/model/policy.js';
 import type { DataFacet } from './data.js';
@@ -20,6 +20,16 @@ export interface EdgeClassPolicies {
     readonly read?: ClassPolicy;
     readonly traverse?: ClassPolicy;
 }
+/**
+ * The Properties one key of a Node Class names, own or inherited, which no two Nodes of the Classes
+ * it covers share while each of them is present: distinct, by key in code-point order.
+ */
+export type NodeUniqueTuple = readonly [PropertyKey, ...PropertyKey[]];
+/**
+ * The form of a Node key tuple: its fields are Properties, whatever their keys and number. A
+ * backend announces it to enforce Node keys, so a tuple is never ignored where it is not.
+ */
+export type NodeUniqueForm = readonly ['property'];
 export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet, DataFacet {
     readonly kind: 'node';
     readonly abstract: boolean;
@@ -30,6 +40,11 @@ export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyF
     readonly methods: MethodRecord;
     readonly icon?: string;
     readonly policies: NodeClassPolicies;
+    /**
+     * The tuples no two Nodes of this Class and of its active concrete descendants share while every
+     * Property is present; absent, none. A descendant is covered without declaring them again.
+     */
+    readonly unique?: readonly NodeUniqueTuple[];
 }
 export type EdgeClassDefinition = DefinitionBase<ClassRef> & PropertyFacet & EdgeContract & {
     readonly kind: 'edge';

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

@@ -1,9 +1,16 @@
-import type { ClassRef } from '../../../addressing/index.js';
+import type { ClassRef, PropertyKey } from '../../../addressing/index.js';
 export type EdgeCount = '0..*' | '1..*' | '0..1' | '1';
 export type EdgeOrientation = 'directed' | 'undirected';
+/**
+ * What deleting the Node at one endpoint does to an Edge: `restrict` requires the transition to
+ * delete the Edge explicitly; `detach` deletes the Edge with the Node.
+ */
+export type EdgeLifetime = 'restrict' | 'detach';
 export interface EdgeEndpointBase {
     readonly role: string;
     readonly accepts: readonly ClassRef[];
+    /** Declared only when authored; otherwise derived (`edgeLifetimes`). */
+    readonly onDelete?: EdgeLifetime;
 }
 export interface DirectedSourceEndpoint extends EdgeEndpointBase {
     readonly outgoing: EdgeCount;
@@ -22,11 +29,22 @@ export interface UndirectedEdgeConstraints {
     readonly noSelf?: true;
     readonly acyclic?: never;
 }
+/** A field a key tuple names: an endpoint of the Edge, its slug, or one of its Properties. */
+export type EdgeUniqueField = 'source' | 'target' | 'slug' | {
+    readonly property: PropertyKey;
+};
+/**
+ * The fields one key of a directed Edge Class names, which no two Edges of the Classes it covers
+ * share while each of them is present: distinct, in canonical order (`compareEdgeUniqueFields`).
+ */
+export type EdgeUniqueTuple = readonly [EdgeUniqueField, ...EdgeUniqueField[]];
+/** The kind of a key field: an endpoint, the slug, or a Property whatever its key. */
+export type EdgeUniqueFieldKind = 'source' | 'target' | 'slug' | 'property';
 /**
- * The fields one uniqueness tuple of a directed Edge Class names, which no two Edges of the Classes
- * it covers share: its source endpoint and its slug.
+ * The form of a key tuple: the kinds of its fields, each once, in canonical order. A backend
+ * announces the forms it enforces, so a tuple of a form it does not announce is never ignored.
  */
-export type EdgeUniqueTuple = readonly ['source', 'slug'];
+export type EdgeUniqueForm = readonly [EdgeUniqueFieldKind, ...EdgeUniqueFieldKind[]];
 export interface DirectedEdgeContract {
     readonly orientation: 'directed';
     readonly endpoints: {

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

@@ -0,0 +1,134 @@
+import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { ClassRef } from '../../addressing/index.js';
+import type { OrderingKind } from '../value/ordering.js';
+import type { ClassAncestry } from './inheritance.js';
+import type { NodeUniqueForm, NodeUniqueTuple } from './model/class.js';
+import type { EdgeUniqueField, EdgeUniqueForm, EdgeUniqueTuple } from './model/edge.js';
+import { ClassKey } from '../../addressing/class-key.js';
+/**
+ * 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 declare const EDGE_UNIQUE_FORMS: readonly EdgeUniqueForm[];
+/** The one form a Node key tuple takes: its fields are Properties, whatever their keys. */
+export declare const NODE_UNIQUE_FORMS: readonly NodeUniqueForm[];
+/**
+ * The forms of key tuples a backend enforces, by the kind of the Classes they constrain: a Node key
+ * reads Node Properties and an Edge key the fields of an Edge, so announcing one says nothing of
+ * the other.
+ */
+export interface UniqueForms {
+    readonly edge: readonly EdgeUniqueForm[];
+    readonly node: readonly NodeUniqueForm[];
+}
+/** Every form of every kind, which a backend enforcing any key tuple announces. */
+export declare const UNIQUE_FORMS: UniqueForms;
+/** No form of either kind: a backend that announces none enforces no key tuple. */
+export declare const NO_UNIQUE_FORMS: UniqueForms;
+/** The fields of an Edge a key tuple reads; the slug is absent from an Edge without one. */
+export interface EdgeUniqueFacts {
+    readonly source: string;
+    readonly target: string;
+    readonly slug?: string;
+    /** Its Property values by key; a Property it lacks is absent. */
+    readonly props: Readonly<Record<string, PortableValue>>;
+}
+/** The Properties of a Node a key tuple reads by key; a Property it lacks is absent. */
+export interface NodeUniqueFacts {
+    readonly props: Readonly<Record<string, PortableValue>>;
+}
+/** The canonical order of fields: source, target, slug, then Properties by key. */
+export declare function compareEdgeUniqueFields(left: EdgeUniqueField, right: EdgeUniqueField): number;
+/** The canonical order of tuples: field by field, a tuple before every tuple it prefixes. */
+export declare const compareEdgeUniqueTuples: (left: EdgeUniqueTuple, right: EdgeUniqueTuple) => number;
+/**
+ * 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 declare function edgeUniqueTuple(value: unknown): EdgeUniqueTuple | undefined;
+/** The canonical order of Node tuples: Property by Property, a tuple before every one it prefixes. */
+export declare const compareNodeUniqueTuples: (left: NodeUniqueTuple, right: NodeUniqueTuple) => number;
+/**
+ * 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 declare function nodeUniqueTuple(value: unknown): NodeUniqueTuple | undefined;
+/** The form of `NODE_UNIQUE_FORMS` that `value` spells, or undefined when it spells none. */
+export declare function nodeUniqueForm(value: unknown): NodeUniqueForm | 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 declare function enforcesNodeUniqueTuple(forms: readonly NodeUniqueForm[], value: unknown): boolean;
+/** The form of `tuple`: the kinds of its fields, each once. */
+export declare function edgeUniqueFormOf(tuple: EdgeUniqueTuple): EdgeUniqueForm;
+/** The form of `EDGE_UNIQUE_FORMS` that `value` spells, or undefined when it spells none. */
+export declare function edgeUniqueForm(value: unknown): EdgeUniqueForm | undefined;
+/**
+ * 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 declare function enforcesEdgeUniqueTuple(forms: readonly EdgeUniqueForm[], value: unknown): boolean;
+/**
+ * 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 declare function keyableProperty(ordering: OrderingKind | undefined, auto: unknown): boolean;
+/**
+ * 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 declare function edgeUniqueValues(tuple: EdgeUniqueTuple, edge: EdgeUniqueFacts): readonly PortableValue[] | undefined;
+/**
+ * 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 declare function edgeUniqueValue(tuple: EdgeUniqueTuple, edge: EdgeUniqueFacts): string | undefined;
+/**
+ * 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 declare function nodeUniqueValues(tuple: NodeUniqueTuple, node: NodeUniqueFacts): readonly PortableValue[] | undefined;
+/**
+ * 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 declare function nodeUniqueValue(tuple: NodeUniqueTuple, node: NodeUniqueFacts): string | undefined;
+/** A Class with the key tuples it declares, an Edge Class or a Node Class. */
+type KeyedClass = ClassAncestry & {
+    readonly unique?: readonly (EdgeUniqueTuple | NodeUniqueTuple)[];
+};
+/** A key tuple together with the Class declaring it, whose descendants it covers. */
+export interface DeclaredEdgeUniqueTuple {
+    readonly class: ClassKey;
+    readonly fields: EdgeUniqueTuple;
+}
+/** A Node key tuple together with the Class declaring it, whose descendants it covers. */
+export interface DeclaredNodeUniqueTuple {
+    readonly class: ClassKey;
+    readonly fields: NodeUniqueTuple;
+}
+/**
+ * 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 declare function coveringEdgeUniqueTuples<Declaration extends KeyedClass>(candidate: Declaration, resolve: (ref: ClassRef) => Declaration | undefined): readonly DeclaredEdgeUniqueTuple[];
+/**
+ * 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 declare function coveringNodeUniqueTuples<Declaration extends KeyedClass>(candidate: Declaration, resolve: (ref: ClassRef) => Declaration | undefined): readonly DeclaredNodeUniqueTuple[];
+/**
+ * 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 declare function edgeUniqueKeys(tuples: readonly DeclaredEdgeUniqueTuple[], edge: EdgeUniqueFacts): readonly string[];
+/**
+ * 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 declare function nodeUniqueKeys(tuples: readonly DeclaredNodeUniqueTuple[], node: NodeUniqueFacts): readonly string[];
+export {};

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

@@ -0,0 +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 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_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']),
+]);
+/** 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_FORMS.find((form) => form.length === value.length && form.every((kind, index) => kind === value[index]));
+}
+/**
+ * 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);
+    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`, 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 = read(field);
+        if (value === undefined)
+            return undefined;
+        values.push(value);
+    }
+    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;
+    };
+}