@astrale-os/kernel-dsl 1.0.0-beta.12 → 1.0.0-beta.13

package/dist/v1/schema/compatibility/meaning/footprint.js

@@ -1,59 +1,25 @@
-import { Key } from '../../../addressing/index.js';
-import { compareAddedProperties, compareLostProperties } from '../comparators/classes.js';
-import { compareFacet } from '../comparators/index.js';
-import { contextInvalid } from '../context.js';
 import { callableReferences, classReferences, inherits, memberReferences, valueReferences, } from '../references.js';
+import { walkReferences } from '../walk.js';
 /** Meaning follows complete callable contracts through the exact authored reference closure. */
 export function compareFootprint({ context, report, }) {
-    const queue = [...context.roots];
-    const visited = new Set();
-    for (const reference of queue) {
-        report.note(reference);
-        const { coordinate, usage } = reference;
-        const visit = `${coordinate.key}:${usage.relation}`;
-        if (visited.has(visit))
-            continue;
-        visited.add(visit);
-        const pair = context.pair(coordinate);
-        const subject = pair.source;
-        if (subject === undefined)
-            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
-        let facet;
+    walkReferences({ context, report }, (subject, { usage }, reach) => {
         switch (subject.kind) {
-            case 'class': {
-                facet = inherits(usage) ? 'class.inherit' : 'class.reference';
-                queue.push(...classReferences(subject, false));
+            case 'class':
+                reach(...classReferences(subject, false));
                 if (inherits(usage))
-                    queue.push(...classReferences(subject, true));
-                break;
-            }
+                    reach(...classReferences(subject, true));
+                return inherits(usage) ? 'class.inherit' : 'class.reference';
             case 'property':
-                facet = 'property';
-                queue.push(...valueReferences(subject));
-                break;
+                reach(...valueReferences(subject));
+                return 'property';
             case 'method':
-                facet = 'method.signature';
-                queue.push(...callableReferences(subject));
-                break;
-            case 'member': {
-                facet =
-                    subject.coordinate.ref.kind === 'function'
-                        ? 'function.signature'
-                        : subject.coordinate.ref.kind;
-                queue.push(...memberReferences(subject));
-            }
+                reach(...callableReferences(subject));
+                return 'method.signature';
+            case 'member':
+                reach(...memberReferences(subject));
+                return subject.coordinate.ref.kind === 'function'
+                    ? 'function.signature'
+                    : subject.coordinate.ref.kind;
         }
-        if (Key.origin(coordinate.key) !== context.source.origin)
-            continue;
-        report.record({
-            pair,
-            facet,
-            ...compareFacet({ context, pair, facet }),
-            requirement: { kind: facet },
-        });
-        if (facet === 'class.inherit')
-            compareAddedProperties({ context, pair, report });
-        if (subject.kind === 'class')
-            compareLostProperties({ pair, report });
-    }
+    });
 }

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

@@ -1,79 +1,47 @@
-import { Key } from '../../../addressing/index.js';
 import { inheritanceOf } from '../../../language/class/inheritance.js';
-import { compareAddedProperties, compareLostProperties, inheritanceMeaning, } from '../comparators/classes.js';
+import { inheritanceMeaning } from '../comparators/classes.js';
 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';
+import { walkReferences } from '../walk.js';
 /** Structure follows data and abstract obligations; concrete IO never expands its requirements. */
 export function compareRequirements({ context, report, }) {
-    const queue = [...context.roots];
-    const visited = new Set();
-    for (const reference of queue) {
-        report.note(reference);
-        const { coordinate, usage } = reference;
-        const visit = `${coordinate.key}:${usage.relation}`;
-        if (visited.has(visit))
-            continue;
-        visited.add(visit);
-        const pair = context.pair(coordinate);
-        const subject = pair.source;
-        if (subject === undefined)
-            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
-        let facet;
+    walkReferences({ context, report }, (subject, { coordinate, usage }, reach) => {
         switch (subject.kind) {
-            case 'class': {
-                facet = inherits(usage) ? 'class.inherit' : 'class.reference';
-                queue.push(...classReferences(subject, false));
+            case 'class':
+                reach(...classReferences(subject, false));
                 if (inherits(usage)) {
-                    queue.push(...classReferences(subject, true));
+                    reach(...classReferences(subject, true));
                     for (const method of subject.analysis.requirements.values())
-                        queue.push({
+                        reach({
                             coordinate: methodCoordinate(method.owner, method.name),
                             usage: usageOf(subject.schema, 'abstract', coordinate.key),
                         });
                 }
-                break;
-            }
+                return inherits(usage) ? 'class.inherit' : 'class.reference';
             case 'property':
-                facet = 'property';
-                queue.push(...valueReferences(subject));
-                break;
-            case 'method': {
-                facet = usage.relation === 'abstract' ? 'method.inheritance' : 'method.existence';
-                if (facet === 'method.inheritance')
-                    queue.push(...callableReferences(subject));
-                break;
-            }
-            case 'member': {
-                facet =
-                    subject.coordinate.ref.kind === 'function'
-                        ? 'function.existence'
-                        : subject.coordinate.ref.kind;
-                if (facet !== 'function.existence')
-                    queue.push(...memberReferences(subject));
-            }
+                reach(...valueReferences(subject));
+                return 'property';
+            case 'method':
+                if (usage.relation !== 'abstract')
+                    return 'method.existence';
+                reach(...callableReferences(subject));
+                return 'method.inheritance';
+            case 'member':
+                if (subject.coordinate.ref.kind === 'function')
+                    return 'function.existence';
+                reach(...memberReferences(subject));
+                return subject.coordinate.ref.kind;
         }
-        if (Key.origin(coordinate.key) !== context.source.origin)
-            continue;
-        // Class membership does not establish an invocation dependency. Explicit member selection,
-        // a Method the dependent declares as a capability, and inherited abstract obligations do.
-        const required = facet !== 'method.existence' ||
-            usage.relation === 'selection' ||
-            usage.relation === 'capability';
-        report.record({
-            pair,
-            facet,
-            ...compareFacet({ context, pair, facet }),
-            ...(required ? { requirement: { kind: facet } } : {}),
-        });
-        if (facet === 'class.inherit')
-            compareAddedProperties({ context, pair, report });
-        if (subject.kind === 'class')
-            compareLostProperties({ pair, report });
-    }
+    }, 
+    // Class membership does not establish an invocation dependency. Explicit member selection,
+    // a Method the dependent declares as a capability, and inherited abstract obligations do.
+    (facet, usage) => facet !== 'method.existence' ||
+        usage.relation === 'selection' ||
+        usage.relation === 'capability');
     compareReliance({ context, report });
     compareExtension({ context, report });
 }

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

@@ -0,0 +1,17 @@
+import type { Usage } from './model.js';
+import type { Reference } from './references.js';
+import type { Report } from './report.js';
+import type { ComparisonContext } from './scope.js';
+import type { ResolvedSubject } from './subjects.js';
+import { compareFacet } from './comparators/index.js';
+type WalkedFacet = Parameters<typeof compareFacet>[0]['facet'];
+/**
+ * Follow the reference closure from the roots once per coordinate and usage relation. `expand`
+ * names the facet a reached subject is compared under and `reach`es what it references; a subject
+ * of the compared origin is then recorded, as a requirement when `required` says so.
+ */
+export declare function walkReferences({ context, report }: {
+    readonly context: ComparisonContext;
+    readonly report: Report;
+}, expand: (subject: ResolvedSubject, reference: Reference, reach: (...references: readonly Reference[]) => void) => WalkedFacet, required?: (facet: WalkedFacet, usage: Usage) => boolean): void;
+export {};

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

@@ -0,0 +1,41 @@
+import { Key } from '../../addressing/index.js';
+import { compareAddedProperties, compareLostProperties } from './comparators/classes.js';
+import { compareFacet } from './comparators/index.js';
+import { contextInvalid } from './context.js';
+/**
+ * Follow the reference closure from the roots once per coordinate and usage relation. `expand`
+ * names the facet a reached subject is compared under and `reach`es what it references; a subject
+ * of the compared origin is then recorded, as a requirement when `required` says so.
+ */
+export function walkReferences({ context, report }, expand, required = () => true) {
+    const queue = [...context.roots];
+    const reach = (...references) => {
+        queue.push(...references);
+    };
+    const visited = new Set();
+    for (const reference of queue) {
+        report.note(reference);
+        const { coordinate, usage } = reference;
+        const visit = `${coordinate.key}:${usage.relation}`;
+        if (visited.has(visit))
+            continue;
+        visited.add(visit);
+        const pair = context.pair(coordinate);
+        const subject = pair.source;
+        if (subject === undefined)
+            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
+        const facet = expand(subject, reference, reach);
+        if (Key.origin(coordinate.key) !== context.source.origin)
+            continue;
+        report.record({
+            pair,
+            facet,
+            ...compareFacet({ context, pair, facet }),
+            ...(required(facet, usage) ? { requirement: { kind: facet } } : {}),
+        });
+        if (facet === 'class.inherit')
+            compareAddedProperties({ context, pair, report });
+        if (subject.kind === 'class')
+            compareLostProperties({ pair, report });
+    }
+}

package/dist/v1/schema/diagnostic.js

@@ -1,21 +1,13 @@
-import { compareUnicode } from '../addressing/ordering.js';
+import { formatDiagnostics, orderDiagnostics } from '../language/validation/diagnostic.js';
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
 export class SchemaError extends Error {
     diagnostics;
     constructor(diagnostics) {
-        const ordered = [...diagnostics].sort(compareDiagnostic);
-        super(ordered.map(formatDiagnostic).join('\n'));
+        const ordered = orderDiagnostics(diagnostics);
+        super(formatDiagnostics(ordered));
         this.name = 'SchemaError';
         this.diagnostics = Object.freeze(ordered);
     }
 }
-function compareDiagnostic(left, right) {
-    return (compareUnicode(left.pointer, right.pointer) ||
-        compareUnicode(left.code, right.code) ||
-        compareUnicode(left.message, right.message));
-}
-function formatDiagnostic(value) {
-    return `${value.pointer || '/'} [${value.code}] ${value.message}`;
-}

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

@@ -1,6 +1,7 @@
 import { dependencyLimits } from '../../addressing/domain-dependency.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { DOMAIN_REVISION_PATTERN } from '../../addressing/patterns.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { diagnostic } from '../diagnostic.js';
 import { indexSchemaDefinitions } from './definition.index.js';
@@ -14,7 +15,7 @@ export function buildDomainResolutionContext(candidate, lookup) {
         diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
     }
     for (const [alias, dependency] of Object.entries(candidate.dependencies)) {
-        const pointer = `/dependencies/${escapeToken(alias)}`;
+        const pointer = `/dependencies/${escapePointerToken(alias)}`;
         if (!DOMAIN_REVISION_PATTERN.test(dependency.revision))
             continue;
         if (dependency.origin === candidate.origin) {
@@ -94,7 +95,7 @@ function loadDependencyClosure(candidate, dependencies, lookup, diagnostics) {
             continue;
         }
         const [alias, dependency] = edge;
-        const pointer = frames.length === 1 ? `/dependencies/${escapeToken(alias)}` : '/dependencies';
+        const pointer = frames.length === 1 ? `/dependencies/${escapePointerToken(alias)}` : '/dependencies';
         if (activeOrigins.has(dependency.origin)) {
             diagnostics.push(diagnostic('DV_DEPENDENCY_ACYCLIC', pointer, `Dependency cycle reaches ${dependency.origin}.`));
             continue;
@@ -153,6 +154,3 @@ function validateDependencyUse(candidate, directOrigins, diagnostics) {
         }
     }
 }
-function escapeToken(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

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

@@ -1,11 +1,12 @@
 import { isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from '../../language/callable/admission.js';
 import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
 /** Validate the execution modifier and admission age of every local Function and Node Method. */
 export function validateCallables(schema) {
     const diagnostics = [];
     for (const [name, declaration] of Object.entries(schema.functions)) {
-        const pointer = `/functions/${escapePointer(name)}`;
+        const pointer = `/functions/${escapePointerToken(name)}`;
         validateExecution(declaration, pointer, diagnostics);
         validateAdmission(declaration, pointer, diagnostics);
     }
@@ -13,7 +14,7 @@ export function validateCallables(schema) {
         if (declaration.kind !== 'node')
             continue;
         for (const [method, value] of Object.entries(declaration.methods)) {
-            const pointer = `/classes/${escapePointer(name)}/methods/${escapePointer(method)}`;
+            const pointer = `/classes/${escapePointerToken(name)}/methods/${escapePointerToken(method)}`;
             validateExecution(value, pointer, diagnostics);
             validateAdmission(value, pointer, diagnostics);
         }
@@ -49,6 +50,3 @@ function validateExecution(declaration, pointer, diagnostics) {
         diagnostics.push(diagnostic('DV_CALLABLE_IO', `${pointer}/output/mode`, 'A durable callable requires a value output.'));
     }
 }
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

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

@@ -1,12 +1,14 @@
+import { equalDefinitionRefs } from '../../addressing/definition-ref.js';
 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 { classSatisfies as satisfiesClass, edgeContractRefines as refinesEdgeContract, } 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 { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
 import { createDomainValueSchemaRegistry, createValueSchemaRegistry, } from '../resolution/value.registry.js';
 const formatDefinitionRef = Key.of;
@@ -16,9 +18,9 @@ export function validateDefinitions(environment, analysis) {
     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)}`;
-        if (!sameRef(declaration.ref, ref)) {
+        const ref = { origin: schema.origin, kind: 'class', name };
+        const pointer = `/classes/${escapePointerToken(name)}`;
+        if (!equalDefinitionRefs(declaration.ref, ref)) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Class ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(declaration.ref)));
         }
         if (declaration.abstract &&
@@ -40,7 +42,7 @@ export function validateDefinitions(environment, analysis) {
 function validateFacet(environment, declaration, pointer, diagnostics) {
     const valueRegistry = createValueSchemaRegistry(environment);
     for (const [name, property] of Object.entries(declaration.properties)) {
-        const propertyPointer = `${pointer}/properties/${escapePointer(name)}`;
+        const propertyPointer = `${pointer}/properties/${escapePointerToken(name)}`;
         if (isBlobValueSchema(property.schema) &&
             (declaration.kind !== 'node' || property.auto !== undefined || property.state !== undefined)) {
             diagnostics.push(diagnostic('DV_VALUE_SCHEMA', `${propertyPointer}/schema/x-astrale-value-kind`, 'Blob values are allowed only on non-automatic, non-state Node properties.'));
@@ -92,7 +94,7 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
     if (declaration.kind !== 'node')
         return;
     for (const [name, method] of Object.entries(declaration.methods)) {
-        const methodPointer = `${pointer}/methods/${escapePointer(name)}`;
+        const methodPointer = `${pointer}/methods/${escapePointerToken(name)}`;
         if (isMethodExecutable(declaration, method))
             continue;
         if (method.policy !== undefined) {
@@ -107,7 +109,7 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
 function validateParents(environment, owner, ownerKind, parents, diagnostics) {
     for (const [index, parent] of parents.entries()) {
         const target = environment.resolve(parent);
-        const pointer = `/classes/${escapePointer(owner.name)}/extends/${index}`;
+        const pointer = `/classes/${escapePointerToken(owner.name)}/extends/${index}`;
         if (target === undefined) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', pointer, `Parent ${formatDefinitionRef(parent)} does not resolve exactly.`, formatDefinitionRef(parent)));
             continue;
@@ -244,42 +246,7 @@ function validateEdgeClassComposition(environment, diagnostics) {
 }
 /** Whether `child` safely refines its parent Edge contract `parent`. */
 export function edgeContractRefines(environment, child, parent) {
-    if (isGraphRoot(parent))
-        return true;
-    if (child.orientation !== parent.orientation)
-        return false;
-    if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
-        return false;
-    if (parent.constraints.acyclic === true && child.constraints.acyclic !== true)
-        return false;
-    if (child.orientation === 'directed' && parent.orientation === 'directed') {
-        return (endpointRefines(environment, child.endpoints.source, parent.endpoints.source) &&
-            countRefines(child.endpoints.source.outgoing, parent.endpoints.source.outgoing) &&
-            endpointRefines(environment, child.endpoints.target, parent.endpoints.target) &&
-            countRefines(child.endpoints.target.incoming, parent.endpoints.target.incoming));
-    }
-    if (child.orientation !== 'undirected' || parent.orientation !== 'undirected')
-        return false;
-    const refines = (childIndex, parentIndex) => endpointRefines(environment, child.endpoints[childIndex], parent.endpoints[parentIndex]) &&
-        countRefines(child.endpoints[childIndex].incident, parent.endpoints[parentIndex].incident);
-    const direct = refines(0, 0) && refines(1, 1);
-    if (direct)
-        return true;
-    return refines(0, 1) && refines(1, 0);
-}
-function endpointRefines(environment, child, parent) {
-    return child.accepts.every((accepted) => classSatisfies(environment, accepted, parent.accepts));
-}
-function countRefines(child, parent) {
-    const bounds = {
-        '0..*': [0, Number.POSITIVE_INFINITY],
-        '1..*': [1, Number.POSITIVE_INFINITY],
-        '0..1': [0, 1],
-        '1': [1, 1],
-    };
-    const [childMinimum, childMaximum] = bounds[child];
-    const [parentMinimum, parentMaximum] = bounds[parent];
-    return childMinimum >= parentMinimum && childMaximum <= parentMaximum;
+    return refinesEdgeContract(child, parent, (candidate, accepts) => classSatisfies(environment, candidate, accepts));
 }
 /** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
 export function classSatisfies(environment, candidate, accepts) {
@@ -294,12 +261,3 @@ export function classSatisfies(environment, candidate, accepts) {
         return required !== undefined && satisfiesClass(actual, required, resolve);
     });
 }
-function localRef(origin, name) {
-    return { origin, kind: 'class', name };
-}
-function sameRef(left, right) {
-    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
-}
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}