@astrale-os/kernel-dsl 0.2.0-beta.45 → 0.2.0-beta.47

package/dist/v1/schema/resolution/origins.d.ts

@@ -1,4 +1,4 @@
-import type { DefinitionRef } from '../../addressing/index.js';
+import type { DefinitionRef, MethodAddress } from '../../addressing/index.js';
 import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { CoreEndpointRef } from '../../language/core/model/core.js';
@@ -7,10 +7,17 @@ import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { DomainSchemaIR } from '../model/schema.js';
 /**
  * Where one schema references a Definition. `extends` and `core` mean the schema inherits from or
- * instantiates the Definition; every other site only refers to it.
+ * instantiates the Definition; every other site only refers to it. `pattern` is the Edge Class a
+ * Policy pattern matches, whose orientation and accepted endpoint Classes Policy typing reads.
  */
-export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'view' | 'core';
-export type ReferenceCollector = (ref: DefinitionRef, site: ReferenceSite) => void;
+export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'pattern' | 'view' | 'core';
+/**
+ * What a site names: a Definition, or the Class-owned Method a Policy object term names. A Policy
+ * keeps the Method itself, since it resolves that Method's own executable declaration; a collector
+ * that needs Definitions only takes its owner Class.
+ */
+export type ReferencedDefinition = DefinitionRef | MethodAddress;
+export type ReferenceCollector = (ref: ReferencedDefinition, site: ReferenceSite) => void;
 /** Collect only semantic refs, never strings or objects embedded as JSON data. */
 export declare function collectUsedForeignOrigins(schema: DomainSchemaIR): ReadonlySet<string>;
 /** Complete structured references in one schema, in canonical order. */

package/dist/v1/schema/resolution/origins.js

@@ -13,7 +13,8 @@ export function collectUsedForeignOrigins(schema) {
 export function collectDomainDefinitionRefs(schema) {
     const result = new Map();
     const add = (ref) => {
-        result.set(definitionRefIndex(ref), ref);
+        const definition = ref.kind === 'method' ? ref.owner : ref;
+        result.set(definitionRefIndex(definition), definition);
     };
     for (const declaration of Object.values(schema.classes)) {
         collectClassRefs(declaration, add);
@@ -102,14 +103,14 @@ function collectPolicyPatternRefs(expression, add) {
     if ('sameNode' in expression) {
         for (const term of [expression.sameNode.left, expression.sameNode.right])
             if (term.kind === 'ref')
-                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
+                add(term.ref, 'policy');
         return;
     }
     if ('source' in expression) {
         for (const term of [expression.source, expression.target])
             if (term.kind === 'ref')
-                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
-        add(expression.class, 'policy');
+                add(term.ref, 'policy');
+        add(expression.class, 'pattern');
         return;
     }
     if ('exists' in expression) {
@@ -128,15 +129,13 @@ function collectPolicyCheckRefs(expression, add) {
     if ('sameNode' in expression) {
         for (const term of [expression.sameNode.left, expression.sameNode.right])
             if (term.kind === 'ref')
-                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
+                add(term.ref, 'policy');
         return;
     }
     if ('check' in expression) {
         add(expression.check, 'policy');
         if (expression.object.kind === 'ref')
-            add(expression.object.ref.kind === 'method'
-                ? expression.object.ref.owner
-                : expression.object.ref, 'policy');
+            add(expression.object.ref, 'policy');
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;

package/dist/v1/schema/validation/class.d.ts

@@ -1,5 +1,15 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { DefinitionAnalysisResult } from '../analysis/class.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
 /** Validate the semantic contracts owned by Class declarations. */
 export declare function validateDefinitions(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];
+/** Whether `child` safely refines its parent Edge contract `parent`. */
+export declare function edgeContractRefines(environment: DomainResolutionContext, child: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>, parent: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>): boolean;
+/** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
+export declare function classSatisfies(environment: DomainResolutionContext, candidate: ClassRef, accepts: readonly ClassRef[]): boolean;

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

@@ -62,6 +62,15 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
                 diagnostics.push(diagnostic('DV_PROPERTY_STATE', `${propertyPointer}/state`, error instanceof Error ? error.message : 'Invalid State topology.'));
             }
         }
+        if (property.immutable !== undefined) {
+            const immutablePointer = `${propertyPointer}/immutable`;
+            if (property.auto !== undefined || property.state !== undefined) {
+                diagnostics.push(diagnostic('DV_PROPERTY_IMMUTABLE', immutablePointer, 'An immutable Property is neither automatic nor a State Property.'));
+            }
+            if (property.immutable === 'once' && property.required) {
+                diagnostics.push(diagnostic('DV_PROPERTY_IMMUTABLE', immutablePointer, 'A required immutable Property is written at creation: declare it create, not once.'));
+            }
+        }
         if (property.auto === undefined)
             continue;
         const autoPointer = `${propertyPointer}/auto`;
@@ -149,7 +158,8 @@ function validateEdgeClassComposition(environment, diagnostics) {
         }
     }
 }
-function edgeContractRefines(environment, child, parent) {
+/** Whether `child` safely refines its parent Edge contract `parent`. */
+export function edgeContractRefines(environment, child, parent) {
     if (child.orientation !== parent.orientation)
         return false;
     if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
@@ -207,7 +217,8 @@ function undirectedEndpointsOverlap(environment, endpoints) {
     }
     return false;
 }
-function classSatisfies(environment, candidate, accepts) {
+/** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
+export function classSatisfies(environment, candidate, accepts) {
     if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(candidate)))
         return true;
     const resolved = environment.resolveAny(candidate);

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

@@ -43,6 +43,7 @@ const propertyDefinitionSchema = strictObject({
         on: uniqueArray(enumeration(['create', 'update'])).min(1),
         set: literal('instant'),
     }).optional(),
+    immutable: enumeration(['create', 'once']).optional(),
     description: descriptionSchema.optional(),
     state: stateTopologySchema.optional(),
 });

package/package.json

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