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

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

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.7",
+  "version": "1.0.0-beta.9",
   "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(', ')}.`);
-}