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

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/policy/analysis/typing.d.ts

@@ -2,6 +2,7 @@ import type { ClassRef, PolicyRef } from '../../../addressing/index.js';
 import type { EdgeContract } from '../../class/model/edge.js';
 import type { PolicyExpression, PolicyObjectRef } from '../model/policy.js';
 import type { CheckLeafClasses } from './checks.js';
+import { type ClassAncestry } from '../../class/inheritance.js';
 import { type PatternBranch } from './branches.js';
 export type ObjectContract = {
     readonly kind: 'default';
@@ -21,10 +22,11 @@ export type PolicyUseContract = {
 export interface PolicyTypingScope {
     readonly normalized: ReadonlyMap<string, PolicyExpression>;
     readonly allNodeClasses: readonly ClassRef[];
+    /** The concrete Classes of `allNodeClasses`, in its order. */
     readonly concreteNodeClasses: readonly ClassRef[];
     isLocalPolicy(ref: PolicyRef): boolean;
-    /** Whether `candidate` is the `required` Class or a same-kind descendant. */
-    classExtends(candidate: ClassRef, required: ClassRef): boolean;
+    /** The Class a ref names in the closure, as satisfaction reads it. */
+    resolveClass(ref: ClassRef): ClassAncestry | undefined;
     edgeDeclaration(ref: ClassRef): EdgeContract | undefined;
     /** The contract of a Node a Policy pattern references, `undefined` when it has none. */
     referenceContract(ref: PolicyObjectRef): ObjectContract | undefined;