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

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

@@ -1,6 +1,7 @@
 import {} from '@astrale-os/kernel-dsl/value';
 import { Key } from '../../../addressing/index.js';
 import { MEDIA_TYPE_PATTERN } from '../../../language/class/model/data.js';
+import { compareEdgeUniqueTuples, edgeUniqueTuple } from '../../../language/class/unique.js';
 import {} from '../../model/schema.js';
 import { invalid } from '../diagnostic.js';
 import { compiledCallable } from './callable.js';
@@ -119,17 +120,21 @@ function edgeContract(value, path) {
         invalid('Edge endpoint roles', undefined, endpointsPath);
     }
 }
-/** A nonempty list of distinct tuples, each naming the source and then the slug. */
+/** A nonempty list of tuples of `EDGE_UNIQUE_TUPLES`, distinct and in their canonical order. */
 function uniqueTuples(input, path) {
     const tuples = array(input, 'Edge unique tuples', path);
     if (tuples.length === 0)
         invalid('Edge unique tuples', undefined, path);
-    for (const [index, tuple] of tuples.entries()) {
-        const fields = array(tuple, 'Edge unique tuple', `${path}/${index}`);
-        if (fields.length !== 2 || fields[0] !== 'source' || fields[1] !== 'slug')
+    const known = tuples.map((tuple, index) => {
+        const fields = edgeUniqueTuple(array(tuple, 'Edge unique tuple', `${path}/${index}`));
+        if (fields === undefined)
             invalid('Edge unique tuple', undefined, `${path}/${index}`);
+        return fields;
+    });
+    for (const [index, tuple] of known.entries()) {
+        if (index > 0 && compareEdgeUniqueTuples(known[index - 1], tuple) >= 0)
+            invalid('Edge unique tuples', undefined, `${path}/${index}`);
     }
-    unique(tuples.map((tuple) => JSON.stringify(tuple)), 'Edge unique tuples', path);
 }
 function edgeEndpoint(input, count, label, path) {
     const value = object(input, label, path);

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

@@ -22,11 +22,13 @@ export interface UndirectedEdgeConstraints {
     readonly noSelf?: true;
     readonly acyclic?: never;
 }
+/** A field a uniqueness tuple names: an endpoint of the Edge, or its slug. */
+export type EdgeUniqueField = 'source' | 'target' | 'slug';
 /**
  * The fields one uniqueness tuple of a directed Edge Class names, which no two Edges of the Classes
- * it covers share: its source endpoint and its slug.
+ * it covers share: one endpoint, then the slug. `EDGE_UNIQUE_TUPLES` lists them in canonical order.
  */
-export type EdgeUniqueTuple = readonly ['source', 'slug'];
+export type EdgeUniqueTuple = readonly ['source', 'slug'] | readonly ['target', 'slug'];
 export interface DirectedEdgeContract {
     readonly orientation: 'directed';
     readonly endpoints: {

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

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

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

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

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

@@ -17,6 +17,8 @@ export type * from './class/model/edge.js';
 export { inheritanceOf } from './class/inheritance.js';
 export { edgeLifetimes } from './class/lifetime.js';
 export type { EdgeLifetime } from './class/lifetime.js';
+export { EDGE_UNIQUE_TUPLES, compareEdgeUniqueTuples, edgeUniqueTuple, edgeUniqueValue, includesEdgeUniqueTuple, } from './class/unique.js';
+export type { EdgeUniqueFacts } from './class/unique.js';
 export type * from './class/model/property.js';
 export type * from './class/resolved.js';
 export type * from './class/facets.js';

package/dist/v1/language/index.js

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

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

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

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

@@ -98,9 +98,9 @@ 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 an endpoint, then the slug (`EDGE_UNIQUE_TUPLES`). No tuple is spelled by the
+// absence of the field, never by an empty list: one spelling per meaning, one revision.
+const edgeUniqueSchema = uniqueArray(union([tuple([literal('source'), literal('slug')]), tuple([literal('target'), literal('slug')])])).min(1);
 const policyPatternSubjectSchema = strictObject({ kind: literal('subject') });
 const policyPatternObjectSchema = strictObject({ kind: literal('object') });
 const policyPatternSourceSchema = strictObject({ kind: literal('source') });

package/package.json

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