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

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

@@ -15,8 +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 { 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,6 +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 { 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,6 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { compareDefinitionRefs, compareUnicode } from '../../addressing/ordering.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { 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';
@@ -72,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'
@@ -81,7 +83,7 @@ function canonicalizeClass(value) {
             endpoints: canonicalizeDirectedEndpoints(value.endpoints),
             policies: value.policies,
             constraints: value.constraints,
-            ...(value.unique === undefined ? {} : { unique: value.unique }),
+            ...(value.unique === undefined ? {} : { unique: canonicalizeUnique(value.unique) }),
         }
         : {
             ...base,
@@ -91,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 the source and the slug. No tuple is spelled by the absence of the field, never by
-// an empty list: one spelling per meaning, one revision.
-const edgeUniqueSchema = uniqueArray(tuple([literal('source'), literal('slug')])).min(1);
+// 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 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.6",
+  "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 {};

package/dist/v1/builder/lowering/core-properties.js

@@ -1,76 +0,0 @@
-import { PropertyKey as admitPropertyKey } from '../../addressing/index.js';
-import { definitionRefIndex } from '../../addressing/ordering.js';
-import { createPropertyValues } from '../../language/class/property-values.js';
-import { analyzeDefinitions } from '../../schema/analysis/class.js';
-import { buildDomainResolutionContext } from '../../schema/resolution/context.js';
-import { escapeToken, fail } from '../schema/diagnostic.js';
-/** Lower rich builder shorthand to the canonical full-key Core representation. */
-export function canonicalizeCorePropertyKeys(candidate, lookup) {
-    // Core Property values do not participate in Class composition. Analyze the
-    // already-canonical Definition surface, then admit Core values below.
-    const analysisCandidate = {
-        ...candidate,
-        core: { nodes: {}, edges: [] },
-    };
-    const definitions = analyzeDefinitions(buildDomainResolutionContext(analysisCandidate, lookup)).definitions;
-    const nodes = Object.fromEntries(Object.entries(candidate.core.nodes).map(([slug, node]) => {
-        const definition = definitions.get(definitionRefIndex(node.class));
-        if (definition === undefined) {
-            fail('BUILDER_CORE_PROPERTY', `/core/nodes/${escapeToken(slug)}/class`, 'Core property shorthand requires a resolvable concrete Class.');
-        }
-        return [
-            slug,
-            {
-                ...node,
-                properties: qualify(node.properties, definition, `/core/nodes/${escapeToken(slug)}/properties`),
-            },
-        ];
-    }));
-    const edges = candidate.core.edges.map((edge, index) => {
-        const definition = definitions.get(definitionRefIndex(edge.class));
-        if (definition === undefined) {
-            fail('BUILDER_CORE_PROPERTY', `/core/edges/${index}/class`, 'Core property shorthand requires a resolvable concrete Class.');
-        }
-        return {
-            ...edge,
-            properties: qualify(edge.properties, definition, `/core/edges/${index}/properties`),
-        };
-    });
-    return { nodes, edges };
-}
-function qualify(input, definition, pointer) {
-    const byName = new Map();
-    for (const [key, field] of definition.properties) {
-        const candidates = byName.get(field.name) ?? [];
-        candidates.push(key);
-        byName.set(field.name, candidates);
-    }
-    const result = {};
-    const sourceByKey = new Map();
-    for (const [inputKey, value] of Object.entries(input)) {
-        const key = resolveInputKey(inputKey, definition, byName, `${pointer}/${escapeToken(inputKey)}`);
-        const previous = sourceByKey.get(key);
-        if (previous !== undefined) {
-            fail('BUILDER_CORE_PROPERTY', `${pointer}/${escapeToken(inputKey)}`, `Property is supplied twice through ${JSON.stringify(previous)} and ${JSON.stringify(inputKey)}.`);
-        }
-        sourceByKey.set(key, inputKey);
-        result[key] = value;
-    }
-    return createPropertyValues(Object.entries(result).map(([key, value]) => [admitPropertyKey(key), value]));
-}
-function resolveInputKey(input, definition, byName, pointer) {
-    if (admitPropertyKey.is(input)) {
-        const key = admitPropertyKey(input);
-        if (!definition.properties.has(key)) {
-            fail('BUILDER_CORE_PROPERTY', pointer, `Property ${input} is not present on the Core Class.`);
-        }
-        return key;
-    }
-    const candidates = byName.get(input) ?? [];
-    if (candidates.length === 1)
-        return candidates[0];
-    if (candidates.length === 0) {
-        fail('BUILDER_CORE_PROPERTY', pointer, `Property ${JSON.stringify(input)} does not exist.`);
-    }
-    fail('BUILDER_CORE_PROPERTY', pointer, `Property ${JSON.stringify(input)} is ambiguous; use one of: ${candidates.join(', ')}.`);
-}