@astrale-os/kernel-dsl 1.0.0-beta.14 → 1.0.0-beta.16

package/dist/v1/compiled/admission/semantics/core.js

@@ -1,7 +1,7 @@
 import { Key } from '../../../addressing/index.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../../language/class/unique.js';
-import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, } from '../../../language/core/facts.js';
+import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, DOMAIN_ENDPOINT_CLASS, } from '../../../language/core/facts.js';
 import {} from '../../../language/core/model/core.js';
 import { policyObjectOrigin, policyObjectKey, projectedMemberClass, } from '../../../language/index.js';
 import { bindValueProgram } from '../../../language/value/compile/load.js';
@@ -123,7 +123,7 @@ function validateCoreProperties(values, analysis, path) {
 }
 function resolveCoreEndpoint(context, entry, ref, nodes, path) {
     if (ref.kind === 'domain')
-        return { key: 'domain' };
+        return { key: 'domain', member: { class: DOMAIN_ENDPOINT_CLASS, pointer: path } };
     const undeclared = () => fail(path, 'Core endpoint does not name a declared local Definition.');
     if (policyObjectOrigin(ref) !== entry.origin)
         return undeclared();
@@ -151,9 +151,5 @@ function declaresProjectedMember(context, entry, ref) {
     return declarations.some((declaration) => declaration.ref.name === ref.name);
 }
 function endpointSatisfies(context, endpoint, accepts) {
-    if ('value' in endpoint)
-        return classSatisfiesAny(context, endpoint.value.class, accepts);
-    if ('member' in endpoint)
-        return classSatisfiesAny(context, endpoint.member.class, accepts);
-    return true;
+    return classSatisfiesAny(context, 'value' in endpoint ? endpoint.value.class : endpoint.member.class, accepts);
 }

package/dist/v1/compiled/admission/semantics/policy/parity.js

@@ -1,6 +1,6 @@
 import {} from '../../../../addressing/index.js';
 import { branchesOf, targetMode, isConnected, } from '../../../../language/policy/analysis/branches.js';
-import { MAX_PATTERN_DEPTH, MAX_BRANCHES, MAX_EDGES, MAX_DOMAINS, measureChecks, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, policyMeasurer, } from '../../../../language/policy/analysis/budgets.js';
+import { exceededLimits, measureChecks, policyMeasurer, } from '../../../../language/policy/analysis/budgets.js';
 import { neverAdmittedClasses, } from '../../../../language/policy/analysis/checks.js';
 import {} from '../../../../language/policy/analysis/typing.js';
 import { checksNameTheCaller, isClassRuleChecks, } from '../../../../language/policy/model/policy.js';
@@ -28,11 +28,7 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
             }
         }
         const measure = measurePolicy(name);
-        if (measure !== undefined &&
-            (measure.depth > MAX_PATTERN_DEPTH ||
-                measure.edgeCounts.length > MAX_BRANCHES ||
-                Math.max(0, ...measure.edgeCounts) > MAX_EDGES ||
-                measure.domains.size > MAX_DOMAINS)) {
+        if (measure !== undefined && exceededLimits(measure).length > 0) {
             fail(path, 'Policy expansion exceeds the V1 depth, branch, Edge, or Domain budget.');
         }
         const branches = typing.expandedBranches(name, `$${name}`);
@@ -98,10 +94,7 @@ function validatePolicyChecks(context, typing, entry, expression, input, receive
     if (!checksNameTheCaller(expression)) {
         fail(path, `${SITE[site].checks} must check a Policy on every branch: sameNode alone names no caller.`);
     }
-    const measure = measureChecks(expression);
-    if (measure.depth > MAX_CHECK_DEPTH ||
-        measure.branches > MAX_BRANCHES ||
-        measure.leaves > MAX_CHECK_LEAVES) {
+    if (exceededLimits(measureChecks(expression)).length > 0) {
         fail(path, `${SITE[site].checks} exceed the V1 depth, branch, or leaf budget.`);
     }
     const leaves = new Map();

package/dist/v1/compiled/admission/semantics/policy/typing.js

@@ -2,7 +2,7 @@ import { Key } from '../../../../addressing/index.js';
 import { PolicyTyping } from '../../../../language/policy/analysis/typing.js';
 import {} from '../../../../language/policy/model/policy.js';
 import {} from '../../../model/schema.js';
-import { classSatisfiesAny, isCompiledEdge } from '../context.js';
+import { isCompiledEdge } from '../context.js';
 import { referenceContract } from './contracts.js';
 /** Types one entry's Policies against the Node Classes of its own closure, as source admission. */
 export function compiledPolicyTyping(context, entry, normalized, origins) {
@@ -14,7 +14,7 @@ export function compiledPolicyTyping(context, entry, normalized, origins) {
         allNodeClasses: nodeClasses.map((value) => value.ref),
         concreteNodeClasses: nodeClasses.filter((value) => !value.abstract).map((value) => value.ref),
         isLocalPolicy: (ref) => ref.origin === entry.origin && ref.kind === 'policy',
-        classExtends: (candidate, required) => classSatisfiesAny(context, candidate, [required]),
+        resolveClass: (ref) => context.classes.get(Key.of(ref))?.value,
         edgeDeclaration: (ref) => {
             const value = context.classes.get(Key.of(ref))?.value;
             return value !== undefined && isCompiledEdge(value) ? value : undefined;

package/dist/v1/language/.spec/schemas/draft-2020-12.schema.json

@@ -0,0 +1,462 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://schemas.astrale.ai/dsl/v1/draft-2020-12",
+    "title": "JSON Schema Draft 2020-12",
+    "$comment": "The Draft 2020-12 meta-schemas the V1 value-schema dialect composes, each under its own $id, exactly as the validator of the dialect embeds them. With value-schema.schema.json, they resolve the dialect without a network fetch.",
+    "$defs": {
+        "schema": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/schema",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/core": true,
+                "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+                "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+                "https://json-schema.org/draft/2020-12/vocab/validation": true,
+                "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+                "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+                "https://json-schema.org/draft/2020-12/vocab/content": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Core and Validation specifications meta-schema",
+            "allOf": [
+                {
+                    "$ref": "meta/core"
+                },
+                {
+                    "$ref": "meta/applicator"
+                },
+                {
+                    "$ref": "meta/unevaluated"
+                },
+                {
+                    "$ref": "meta/validation"
+                },
+                {
+                    "$ref": "meta/meta-data"
+                },
+                {
+                    "$ref": "meta/format-annotation"
+                },
+                {
+                    "$ref": "meta/content"
+                }
+            ],
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+            "properties": {
+                "definitions": {
+                    "$comment": "\"definitions\" has been replaced by \"$defs\".",
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "deprecated": true,
+                    "default": {}
+                },
+                "dependencies": {
+                    "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+                    "type": "object",
+                    "additionalProperties": {
+                        "anyOf": [
+                            {
+                                "$dynamicRef": "#meta"
+                            },
+                            {
+                                "$ref": "meta/validation#/$defs/stringArray"
+                            }
+                        ]
+                    },
+                    "deprecated": true,
+                    "default": {}
+                },
+                "$recursiveAnchor": {
+                    "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+                    "$ref": "meta/core#/$defs/anchorString",
+                    "deprecated": true
+                },
+                "$recursiveRef": {
+                    "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+                    "$ref": "meta/core#/$defs/uriReferenceString",
+                    "deprecated": true
+                }
+            }
+        },
+        "core": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/core",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/core": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Core vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "$id": {
+                    "$ref": "#/$defs/uriReferenceString",
+                    "$comment": "Non-empty fragments not allowed.",
+                    "pattern": "^[^#]*#?$"
+                },
+                "$schema": {
+                    "$ref": "#/$defs/uriString"
+                },
+                "$ref": {
+                    "$ref": "#/$defs/uriReferenceString"
+                },
+                "$anchor": {
+                    "$ref": "#/$defs/anchorString"
+                },
+                "$dynamicRef": {
+                    "$ref": "#/$defs/uriReferenceString"
+                },
+                "$dynamicAnchor": {
+                    "$ref": "#/$defs/anchorString"
+                },
+                "$vocabulary": {
+                    "type": "object",
+                    "propertyNames": {
+                        "$ref": "#/$defs/uriString"
+                    },
+                    "additionalProperties": {
+                        "type": "boolean"
+                    }
+                },
+                "$comment": {
+                    "type": "string"
+                },
+                "$defs": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    }
+                }
+            },
+            "$defs": {
+                "anchorString": {
+                    "type": "string",
+                    "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+                },
+                "uriString": {
+                    "type": "string",
+                    "format": "uri"
+                },
+                "uriReferenceString": {
+                    "type": "string",
+                    "format": "uri-reference"
+                }
+            }
+        },
+        "applicator": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/applicator",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/applicator": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Applicator vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "prefixItems": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "items": {
+                    "$dynamicRef": "#meta"
+                },
+                "contains": {
+                    "$dynamicRef": "#meta"
+                },
+                "additionalProperties": {
+                    "$dynamicRef": "#meta"
+                },
+                "properties": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "default": {}
+                },
+                "patternProperties": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "propertyNames": {
+                        "format": "regex"
+                    },
+                    "default": {}
+                },
+                "dependentSchemas": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$dynamicRef": "#meta"
+                    },
+                    "default": {}
+                },
+                "propertyNames": {
+                    "$dynamicRef": "#meta"
+                },
+                "if": {
+                    "$dynamicRef": "#meta"
+                },
+                "then": {
+                    "$dynamicRef": "#meta"
+                },
+                "else": {
+                    "$dynamicRef": "#meta"
+                },
+                "allOf": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "anyOf": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "oneOf": {
+                    "$ref": "#/$defs/schemaArray"
+                },
+                "not": {
+                    "$dynamicRef": "#meta"
+                }
+            },
+            "$defs": {
+                "schemaArray": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": {
+                        "$dynamicRef": "#meta"
+                    }
+                }
+            }
+        },
+        "unevaluated": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Unevaluated applicator vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "unevaluatedItems": {
+                    "$dynamicRef": "#meta"
+                },
+                "unevaluatedProperties": {
+                    "$dynamicRef": "#meta"
+                }
+            }
+        },
+        "validation": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/validation",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/validation": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Validation vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "type": {
+                    "anyOf": [
+                        {
+                            "$ref": "#/$defs/simpleTypes"
+                        },
+                        {
+                            "type": "array",
+                            "items": {
+                                "$ref": "#/$defs/simpleTypes"
+                            },
+                            "minItems": 1,
+                            "uniqueItems": true
+                        }
+                    ]
+                },
+                "const": true,
+                "enum": {
+                    "type": "array",
+                    "items": true
+                },
+                "multipleOf": {
+                    "type": "number",
+                    "exclusiveMinimum": 0
+                },
+                "maximum": {
+                    "type": "number"
+                },
+                "exclusiveMaximum": {
+                    "type": "number"
+                },
+                "minimum": {
+                    "type": "number"
+                },
+                "exclusiveMinimum": {
+                    "type": "number"
+                },
+                "maxLength": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minLength": {
+                    "$ref": "#/$defs/nonNegativeIntegerDefault0"
+                },
+                "pattern": {
+                    "type": "string",
+                    "format": "regex"
+                },
+                "maxItems": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minItems": {
+                    "$ref": "#/$defs/nonNegativeIntegerDefault0"
+                },
+                "uniqueItems": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "maxContains": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minContains": {
+                    "$ref": "#/$defs/nonNegativeInteger",
+                    "default": 1
+                },
+                "maxProperties": {
+                    "$ref": "#/$defs/nonNegativeInteger"
+                },
+                "minProperties": {
+                    "$ref": "#/$defs/nonNegativeIntegerDefault0"
+                },
+                "required": {
+                    "$ref": "#/$defs/stringArray"
+                },
+                "dependentRequired": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "$ref": "#/$defs/stringArray"
+                    }
+                }
+            },
+            "$defs": {
+                "nonNegativeInteger": {
+                    "type": "integer",
+                    "minimum": 0
+                },
+                "nonNegativeIntegerDefault0": {
+                    "$ref": "#/$defs/nonNegativeInteger",
+                    "default": 0
+                },
+                "simpleTypes": {
+                    "enum": [
+                        "array",
+                        "boolean",
+                        "integer",
+                        "null",
+                        "number",
+                        "object",
+                        "string"
+                    ]
+                },
+                "stringArray": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "uniqueItems": true,
+                    "default": []
+                }
+            }
+        },
+        "meta-data": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Meta-data vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "title": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "default": true,
+                "deprecated": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "readOnly": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "writeOnly": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "examples": {
+                    "type": "array",
+                    "items": true
+                }
+            }
+        },
+        "format-annotation": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Format vocabulary meta-schema for annotation results",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "format": {
+                    "type": "string"
+                }
+            }
+        },
+        "content": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://json-schema.org/draft/2020-12/meta/content",
+            "$vocabulary": {
+                "https://json-schema.org/draft/2020-12/vocab/content": true
+            },
+            "$dynamicAnchor": "meta",
+            "title": "Content vocabulary meta-schema",
+            "type": [
+                "object",
+                "boolean"
+            ],
+            "properties": {
+                "contentEncoding": {
+                    "type": "string"
+                },
+                "contentMediaType": {
+                    "type": "string"
+                },
+                "contentSchema": {
+                    "$dynamicRef": "#meta"
+                }
+            }
+        }
+    }
+}

package/dist/v1/language/core/facts.d.ts

@@ -1,9 +1,17 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { EdgeContract, EdgeCount, EdgeEndpointBase, IncidentEndpoint } from '../class/model/edge.js';
+/**
+ * The Class of the owning Domain's Node: every Domain principal is a Node of the final Kernel
+ * `Domain` Class, so a Core Edge that names the Domain must accept that Class at that endpoint.
+ */
+export declare const DOMAIN_ENDPOINT_CLASS: ClassRef;
 /** One endpoint of a Core Edge: a Core Node, a projected member or the owning Domain. */
 export interface CoreFactEndpoint {
     readonly key: string;
-    /** Set on a projected member: its Kernel Class, and where a breach of its degree is reported. */
+    /**
+     * Set on a projected member and on the owning Domain: the Kernel Class it is a Node of, and where
+     * a breach of its degree is reported.
+     */
     readonly member?: {
         readonly class: ClassRef;
         readonly pointer: string;
@@ -26,10 +34,12 @@ export interface CoreDegreeSubject {
 }
 export interface CoreEdgeSet<Edge> {
     readonly edges: readonly CoreFactEdge<Edge>[];
-    /** The local exact Edge Classes, in the order their slices are checked. */
+    /** The local Edge Classes, in the order their slices are checked. */
     readonly classes: readonly {
         readonly key: string;
-        readonly contract: EdgeContract;
+        readonly contract: EdgeContract & {
+            readonly abstract: boolean;
+        };
     }[];
     readonly nodes: readonly CoreDegreeSubject[];
     readonly satisfies: (ref: ClassRef, accepts: readonly ClassRef[]) => boolean;
@@ -68,5 +78,8 @@ export declare function coreEndpointsSatisfy<Endpoint>(contract: EdgeContract, s
  * DV-EDGE-UNIQUE); Activation checks them against stored data.
  */
 export declare function checkHeldKeys<Fact>(facts: Iterable<Fact>, keys: (fact: Fact) => readonly string[], report: (fact: Fact, previous: Fact) => void): void;
-/** Check normalized Edge identity, noSelf, keys, exact-Class acyclicity and Core degrees. */
+/**
+ * Check normalized Edge identity, noSelf, keys, and the acyclicity and Core degrees of each exact
+ * concrete Edge Class over its own Edges.
+ */
 export declare function checkCoreEdgeSet<Edge>(set: CoreEdgeSet<Edge>): void;

package/dist/v1/language/core/facts.js

@@ -1,5 +1,18 @@
 import { compareUnicode } from '../../addressing/ordering.js';
-import { countBounds, hasDirectedCycle } from '../class/inheritance.js';
+import { countBounds, hasDirectedCycle, KERNEL_ORIGIN } from '../class/inheritance.js';
+/*
+ * The Core fact rules that authored and compiled admission share. Each admission resolves its own
+ * Core Nodes and Edges, then reports every issue under its own codes, messages and pointers.
+ */
+/**
+ * The Class of the owning Domain's Node: every Domain principal is a Node of the final Kernel
+ * `Domain` Class, so a Core Edge that names the Domain must accept that Class at that endpoint.
+ */
+export const DOMAIN_ENDPOINT_CLASS = Object.freeze({
+    origin: KERNEL_ORIGIN,
+    kind: 'class',
+    name: 'Domain',
+});
 /** Whether the endpoints satisfy the contract: in order when directed, in either order when not. */
 export function coreEndpointsSatisfy(contract, source, target, satisfies) {
     if (contract.orientation === 'directed') {
@@ -27,7 +40,10 @@ export function checkHeldKeys(facts, keys, report) {
                 holders.set(key, fact);
     }
 }
-/** Check normalized Edge identity, noSelf, keys, exact-Class acyclicity and Core degrees. */
+/**
+ * Check normalized Edge identity, noSelf, keys, and the acyclicity and Core degrees of each exact
+ * concrete Edge Class over its own Edges.
+ */
 export function checkCoreEdgeSet(set) {
     const identities = new Map();
     const slices = new Map(set.classes.map(({ key }) => [key, []]));
@@ -48,6 +64,10 @@ export function checkCoreEdgeSet(set) {
     }
     checkHeldKeys(set.edges, set.keys, (fact, previous) => set.report({ kind: 'key', edge: fact.edge, previous: previous.edge }));
     for (const { key, contract } of set.classes) {
+        // No Edge is of an abstract Class exactly, so it bounds no degree and closes no cycle of its
+        // own: each concrete descendant carries the counts it refines, over its own Edges.
+        if (contract.abstract)
+            continue;
         const slice = slices.get(key);
         if (contract.constraints.acyclic === true && hasDirectedCycle(slice))
             set.report({ kind: 'acyclic', class: key });
@@ -78,9 +98,10 @@ function checkDegrees(set, contract, slice) {
     }
 }
 /**
- * Every declared Core Node proves its own complete degree, so both bounds hold. A projected member
- * is only named by the Edges that reach it: the Domain may also create ordinary Edges of the same
- * Class against it, so a minimum is unprovable here and only the maximum is enforced.
+ * Every declared Core Node proves its own complete degree, so both bounds hold. A projected member,
+ * and the owning Domain, is only named by the Edges that reach it: the Domain may also create
+ * ordinary Edges of the same Class against it, so a minimum is unprovable here and only the maximum
+ * is enforced.
  */
 function degreeSubjects(nodes, slice) {
     const subjects = new Map(nodes.map((node) => [node.key, { ...node, minimum: true }]));