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

package/dist/v1/schema/validation/value.json-schema.js

@@ -0,0 +1,126 @@
+import { VALUE_SCHEMA_DIALECT } from '../../language/value/model/schema.js';
+import { FORBIDDEN_KEYWORDS, SUBSCHEMA_KEYWORDS, VALUE_KEYWORDS, } from '../../language/value/profile/vocabulary.js';
+/**
+ * The checks on value schemas JSON Schema cannot state, which the published document names with
+ * the positions it constrains. The Kernel reports each as `DV_VALUE_SCHEMA`, with its value code.
+ */
+export const valueSchemaRules = {
+    'value-blob': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_VALUE_KIND',
+        statement: 'A blob is declared only by the whole schema of a Property, exactly as values.blob writes it.',
+    },
+    'value-path': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_PATH_EXTENSION',
+        statement: 'x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema, and reads target node, cardinality one and a non-empty set of Node Class refs it accepts.',
+    },
+    'value-recursion': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_RECURSION_PRODUCTIVE',
+        statement: 'Every reference cycle of a value schema crosses a keyword that steps into the value: to a member, a member name or an item.',
+    },
+    'value-reference-form': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_REFERENCE_FORM',
+        statement: 'A $ref is a JSON Pointer fragment into its own value schema, or the id of the graph NodePath schema beside x-astrale-path.',
+    },
+    'value-reference-resolution': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_REFERENCE_RESOLUTION',
+        statement: 'A $ref resolves to a location of its own value schema, and x-astrale-path accepts Node Classes of the Domain or of a direct dependency.',
+    },
+    'value-regexp': {
+        code: 'DV_VALUE_SCHEMA',
+        valueCode: 'VS_REGEX_PORTABLE',
+        statement: 'Every pattern, fullMatch and patternProperties name is an RFC 9485 I-Regexp within the regular-expression limits.',
+    },
+};
+const KIND = 'x-astrale-value-kind';
+const LOCATION = '#/$defs/value-location';
+const SUBSCHEMA = '#/$defs/value-subschema';
+/**
+ * The value language in JSON Schema, for the document that embeds value schemas: `root` constrains
+ * the `value-schema` definition with the published dialect and what the profile adds to it,
+ * `definitions` holds the locations it reaches, and `nodeProperty` constrains a Node Property
+ * definition. A named check leaves `x-astrale-rule` at the positions it constrains.
+ */
+export function valueSchemaJsonSchema() {
+    return {
+        root: [
+            { $ref: VALUE_SCHEMA_DIALECT },
+            { $ref: LOCATION },
+            objectOrBoolean({
+                properties: {
+                    $schema: { const: VALUE_SCHEMA_DIALECT },
+                    [KIND]: {
+                        enum: ['instant', 'blob'],
+                        'x-astrale-rule': 'value-blob',
+                    },
+                },
+            }),
+        ],
+        definitions: {
+            // Every location, the root included: the closed vocabulary and the subschemas it holds.
+            'value-location': objectOrBoolean({
+                propertyNames: {
+                    enum: VALUE_KEYWORDS.filter((keyword) => !FORBIDDEN_KEYWORDS.includes(keyword)),
+                },
+                properties: {
+                    $id: false,
+                    $ref: {
+                        type: 'string',
+                        'x-astrale-rule': [
+                            'value-recursion',
+                            'value-reference-form',
+                            'value-reference-resolution',
+                        ],
+                    },
+                    enum: { type: 'array', uniqueItems: true },
+                    fullMatch: { type: 'string', 'x-astrale-rule': 'value-regexp' },
+                    pattern: { type: 'string', 'x-astrale-rule': 'value-regexp' },
+                    'x-astrale-path': { type: 'object', 'x-astrale-rule': 'value-path' },
+                    ...Object.fromEntries(SUBSCHEMA_KEYWORDS.single.map((keyword) => [keyword, { $ref: SUBSCHEMA }])),
+                    ...Object.fromEntries(SUBSCHEMA_KEYWORDS.array.map((keyword) => [
+                        keyword,
+                        { type: 'array', items: { $ref: SUBSCHEMA } },
+                    ])),
+                    ...Object.fromEntries(SUBSCHEMA_KEYWORDS.map.map((keyword) => [
+                        keyword,
+                        {
+                            type: 'object',
+                            additionalProperties: { $ref: SUBSCHEMA },
+                            ...(keyword === 'patternProperties' ? { 'x-astrale-rule': 'value-regexp' } : {}),
+                        },
+                    ])),
+                },
+                // An instant is a string.
+                if: { required: [KIND], properties: { [KIND]: { const: 'instant' } } },
+                // oxlint-disable-next-line unicorn/no-thenable -- the JSON Schema keyword
+                then: { required: ['type'], properties: { type: { const: 'string' } } },
+            }),
+            // A location below the root: no $schema, and no blob.
+            'value-subschema': {
+                allOf: [
+                    { $ref: LOCATION },
+                    objectOrBoolean({ properties: { $schema: false, [KIND]: { const: 'instant' } } }),
+                ],
+            },
+        },
+        // An automatic or State Property holds no blob.
+        nodeProperty: {
+            if: { anyOf: [{ required: ['auto'] }, { required: ['state'] }] },
+            // oxlint-disable-next-line unicorn/no-thenable -- the JSON Schema keyword
+            then: {
+                properties: {
+                    schema: {
+                        not: { type: 'object', required: [KIND], properties: { [KIND]: { const: 'blob' } } },
+                    },
+                },
+            },
+        },
+    };
+}
+function objectOrBoolean(object) {
+    return { anyOf: [{ type: 'boolean' }, { type: 'object', ...object }] };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.13",
+  "version": "1.0.0-beta.15",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -79,6 +79,8 @@
       "types": "./dist/v1/schema/revision.d.ts",
       "import": "./dist/v1/schema/revision.js"
     },
+    "./v1/schema/domain-schema.schema.json": "./dist/v1/schema/.spec/schemas/domain-schema.schema.json",
+    "./v1/schema/value-schema.schema.json": "./dist/v1/language/.spec/schemas/value-schema.schema.json",
     "./v1/value/full-match": {
       "types": "./dist/v1/value/full-match.d.ts",
       "import": "./dist/v1/value/full-match.js"