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

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

@@ -14,11 +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 { admitsForeignSubclass, inheritanceOf } from './class/inheritance.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

@@ -3,8 +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 { admitsForeignSubclass, inheritanceOf } from './class/inheritance.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/compatibility/api.d.ts

@@ -1,3 +1,4 @@
 export { compare, compareMeaning, compareStructure } from './compare.js';
+export { closedParents } from './extension.js';
 export { requiredBump } from './versioning/index.js';
 export type { Analysis, Assessment, Bump, Comparison, ComparisonEntry, ComparisonEvidence, ComparisonRequest, ComparisonScope, Facet, Fingerprint, MeaningComparison, Observation, RequiredBump, SchemaIdentity, StructureComparison, Subject, Usage, VersionChange, } from './model.js';

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

@@ -1,2 +1,3 @@
 export { compare, compareMeaning, compareStructure } from './compare.js';
+export { closedParents } from './extension.js';
 export { requiredBump } from './versioning/index.js';

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

@@ -0,0 +1,11 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
+/**
+ * The Classes of the target's origin that a Class of the dependent extends and the target does not
+ * open to it, as Keys in order (DM-CLASS-INHERITANCE). A parent the target no longer declares is
+ * not closed: losing it is an ancestry change.
+ */
+export declare function closedParents({ dependent, target, }: {
+    readonly dependent: DomainSchema;
+    readonly target: DomainSchema;
+}): readonly Key[];

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

@@ -0,0 +1,22 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+import { admitsForeignSubclass } from '../../language/class/inheritance.js';
+import { keyForDefinitionRef } from './coordinate.js';
+/**
+ * The Classes of the target's origin that a Class of the dependent extends and the target does not
+ * open to it, as Keys in order (DM-CLASS-INHERITANCE). A parent the target no longer declares is
+ * not closed: losing it is an ancestry change.
+ */
+export function closedParents({ dependent, target, }) {
+    const closed = new Set();
+    if (dependent.origin === target.origin)
+        return [];
+    for (const declaration of Object.values(dependent.classes))
+        for (const parent of declaration.extends) {
+            if (parent.origin !== target.origin)
+                continue;
+            const declared = target.classes[parent.name];
+            if (declared !== undefined && !admitsForeignSubclass(declared))
+                closed.add(keyForDefinitionRef(parent));
+        }
+    return Object.freeze([...closed].sort(compareUnicode));
+}

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

@@ -17,6 +17,13 @@ export interface ComparisonRequest {
          * unresolvable or unsupported Key of the target origin, is rejected with DM_CAPABILITY_INVALID.
          */
         readonly capabilities?: readonly Key[];
+        /**
+         * `true` when the dependent already holds its binding to the target, as the installer holds
+         * one a Domain was installed with: the Classes of the target origin it extends are then not
+         * judged for inheritance (DM-CLASS-INHERITANCE). Otherwise each must be `'open'` in the
+         * target. It enters no evidence: a held comparison has the facts of a compatible judged one.
+         */
+        readonly held?: boolean;
     } | {
         readonly kind: 'members';
         readonly source: DomainSchema;

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

@@ -25,6 +25,8 @@ export interface ComparisonContext {
      * structure records them only when they fail, so a compatible comparison keeps its bytes.
      */
     readonly reliance: readonly Reference[];
+    /** Whether the dependent holds its binding to the target, so its extensions are not judged. */
+    readonly held: boolean;
     pair(coordinate: Coordinate): SubjectPair;
 }
 export declare function prepare(request: ComparisonRequest): ComparisonContext;

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

@@ -42,6 +42,7 @@ export function prepare(request) {
         roots: [...rootReferences(dependent), ...capabilities],
         capabilities,
         reliance: policyReliance(dependent, source.origin),
+        held: scope.held === true,
     });
 }
 /**
@@ -63,9 +64,10 @@ export function selectMembers(source, target, keys) {
         })),
         capabilities: [],
         reliance: [],
+        held: false,
     });
 }
-function comparisonContext({ kind, source, target, dependent, before, roots, capabilities, reliance, }) {
+function comparisonContext({ kind, source, target, dependent, before, roots, capabilities, reliance, held, }) {
     resolve(target);
     const after = contextOf(target);
     const pairs = new Map();
@@ -78,6 +80,7 @@ function comparisonContext({ kind, source, target, dependent, before, roots, cap
         roots,
         capabilities,
         reliance,
+        held,
         scope: Object.freeze({
             kind,
             source: schemaIdentity(source),

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

@@ -5,6 +5,7 @@ import { compareFacet } from '../comparators/index.js';
 import { fingerprintMeaning } from '../comparators/values.js';
 import { contextInvalid } from '../context.js';
 import { methodCoordinate } from '../coordinate.js';
+import { closedParents } from '../extension.js';
 import { callableReferences, classReferences, inherits, memberReferences, usageOf, valueReferences, } from '../references.js';
 /** Structure follows data and abstract obligations; concrete IO never expands its requirements. */
 export function compareRequirements({ context, report, }) {
@@ -98,27 +99,29 @@ function compareReliance({ context, report, }) {
     }
 }
 /**
- * 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.
+ * A Class of the compared origin one of the dependent's own Classes extends must be `'open'` in the
+ * target, unless the dependent holds its binding to that target. The fact is recorded only when it
+ * fails, like a Policy reliance, so a compatible comparison keeps its evidence bytes: `'open'`, what
+ * a subclass of another Domain requires, before, and the target's inheritance after.
  */
 function compareExtension({ context, report, }) {
+    if (context.held || context.dependent === undefined)
+        return;
+    const closed = new Set(closedParents({ dependent: context.dependent, target: context.target }));
+    if (closed.size === 0)
+        return;
     for (const reference of context.roots) {
-        if (reference.usage.relation !== 'extends')
-            continue;
-        if (Key.origin(reference.coordinate.key) !== context.source.origin)
+        if (reference.usage.relation !== 'extends' || !closed.has(reference.coordinate.key))
             continue;
         const pair = context.pair(reference.coordinate);
-        if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')
-            continue;
-        if (pair.target.analysis.declaration.inheritance !== 'final')
+        if (pair.target?.kind !== 'class')
             continue;
         report.note(reference);
         report.record({
             pair,
             facet: 'class.inheritance',
-            before: inheritanceMeaning(inheritanceOf(pair.source.analysis.declaration)),
-            after: inheritanceMeaning('final'),
+            before: inheritanceMeaning('open'),
+            after: inheritanceMeaning(inheritanceOf(pair.target.analysis.declaration)),
             requirement: { kind: 'class.inheritance' },
         });
     }

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

@@ -1,4 +1,4 @@
-import { inheritanceOf } from '../../../language/class/inheritance.js';
+import { admitsForeignSubclass, inheritanceOf } from '../../../language/class/inheritance.js';
 import { methodInheritance } from '../comparators/callables.js';
 import { compareAddedProperties, inheritanceMeaning } from '../comparators/classes.js';
 import { compareFacet } from '../comparators/index.js';
@@ -57,16 +57,18 @@ 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.
+ * A changed inheritance is observed on its Class, and is major when an `'open'` Class stops being
+ * open: only an `'open'` Class admits a subclass of another Domain (DM-CLASS-INHERITANCE). Closing
+ * or finalizing a Class no other Domain may extend takes nothing from a dependent; opening one
+ * grants an extension, which the floor, counting added members only, leaves at a patch.
  */
 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);
+    const source = pair.source.analysis.declaration;
+    const target = pair.target.analysis.declaration;
+    const before = inheritanceOf(source);
+    const after = inheritanceOf(target);
     if (before === after)
         return;
     report.record({
@@ -74,7 +76,10 @@ function compareExtension({ pair, report, }) {
         facet: 'class.inheritance',
         before: inheritanceMeaning(before),
         after: inheritanceMeaning(after),
-        requirement: { kind: 'class.inheritance', satisfied: before !== 'open' && after !== 'final' },
+        requirement: {
+            kind: 'class.inheritance',
+            satisfied: !admitsForeignSubclass(source) || admitsForeignSubclass(target),
+        },
     });
 }
 function changed({ before, after }) {

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 {