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

package/dist/v1/schema/validation/json.json-schema.d.ts

@@ -0,0 +1,24 @@
+import type { core as zodCore } from 'zod';
+type JsonSchema = zodCore.JSONSchema.JSONSchema;
+/**
+ * The check that a document is portable JSON, which `schema.decode` and `schema.accept` make first.
+ * JSON Schema reads a parsed value and compares numbers by their value: it states that no string or
+ * member name holds U+0000, and cannot state negative zero, a lone surrogate, a UTF-8 size, a
+ * nesting depth without one definition per level, a count of members, or what the text was.
+ */
+export declare const jsonValueRules: {
+    readonly 'portable-json': {
+        readonly code: 'DV_JSON_VALUE';
+        readonly statement: string;
+    };
+};
+export type JsonValueRule = keyof typeof jsonValueRules;
+/**
+ * Portable JSON in JSON Schema: `root` constrains the whole document, and `definitions` holds every
+ * value it reaches and every string. The named check leaves `x-astrale-rule` on `portable-json`.
+ */
+export declare function jsonValueJsonSchema(): {
+    readonly root: JsonSchema;
+    readonly definitions: Readonly<Record<string, JsonSchema>>;
+};
+export {};

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

@@ -0,0 +1,36 @@
+import { RULES } from '../rule.js';
+/**
+ * The check that a document is portable JSON, which `schema.decode` and `schema.accept` make first.
+ * JSON Schema reads a parsed value and compares numbers by their value: it states that no string or
+ * member name holds U+0000, and cannot state negative zero, a lone surrogate, a UTF-8 size, a
+ * nesting depth without one definition per level, a count of members, or what the text was.
+ */
+export const jsonValueRules = {
+    'portable-json': { code: 'DV_JSON_VALUE', statement: RULES.DV_JSON_VALUE.statement },
+};
+const VALUE = '#/$defs/portable-json';
+const TEXT = '#/$defs/portable-string';
+/**
+ * Portable JSON in JSON Schema: `root` constrains the whole document, and `definitions` holds every
+ * value it reaches and every string. The named check leaves `x-astrale-rule` on `portable-json`.
+ */
+export function jsonValueJsonSchema() {
+    return {
+        root: { $ref: VALUE },
+        definitions: {
+            'portable-json': {
+                anyOf: [
+                    { type: 'null' },
+                    { type: 'boolean' },
+                    { type: 'number' },
+                    { $ref: TEXT },
+                    { type: 'array', items: { $ref: VALUE } },
+                    { type: 'object', propertyNames: { $ref: TEXT }, additionalProperties: { $ref: VALUE } },
+                ],
+                'x-astrale-rule': 'portable-json',
+            },
+            // The pattern is the character itself, which every regular-expression dialect reads.
+            'portable-string': { type: 'string', not: { pattern: '\u0000' } },
+        },
+    };
+}

package/dist/v1/schema/validation/policy/references.js

@@ -3,7 +3,6 @@ import { branchesOf, isConnected, targetMode } from '../../../language/policy/an
 import { policyVariableClass } from '../../../language/policy/model/policy.js';
 import { normalizePolicyExpression, normalizePolicyPattern, } from '../../../language/policy/normalization/normalize.js';
 import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
-import { MAX_REPEAT, MAX_VARIABLES } from './budgets.js';
 import { referenceContracts } from './objects.js';
 export function validatePolicyReferences(context) {
     for (const [name, declaration] of Object.entries(context.environment.candidate.policies)) {
@@ -15,9 +14,9 @@ export function validatePolicyReferences(context) {
         const expression = declaration.expression;
         context.normalized.set(name, normalizePolicyExpression(expression));
         if ('match' in expression)
-            validateMatch(context, name, expression.match, pointer);
+            validateMatch(context, name, expression.match, `${pointer}/expression`);
         else
-            validateComposition(context, expression, pointer);
+            validateComposition(context, expression, `${pointer}/expression`);
     }
     validateCycles(context);
 }
@@ -53,22 +52,13 @@ function validatePatternNode(context, pattern, pointer, scope, declarations, use
         context.resolveEdge(pattern.class, `${pointer}/class`);
         validateTerm(context, pattern.source, `${pointer}/source`, scope, uses);
         validateTerm(context, pattern.target, `${pointer}/target`, scope, uses);
-        if (pattern.repeat !== undefined) {
-            const { min, max } = pattern.repeat;
-            if (!Number.isInteger(min) ||
-                !Number.isInteger(max) ||
-                min < 0 ||
-                max < min ||
-                max > MAX_REPEAT) {
-                context.add('PL_REPEAT', `${pointer}/repeat`, `Repeat requires integral bounds 0 <= min <= max <= ${MAX_REPEAT}.`);
-            }
+        // The structure bounds each to an integer from 0 to MAX_REPEAT; only their order is left.
+        if (pattern.repeat !== undefined && pattern.repeat.max < pattern.repeat.min) {
+            context.add('PL_REPEAT', `${pointer}/repeat`, 'Repeat requires min <= max.');
         }
         return;
     }
     if ('exists' in pattern) {
-        if (pattern.exists.nodes.length > MAX_VARIABLES) {
-            context.add('PL_BUDGET', `${pointer}/exists/nodes`, `An exists expression declares ${pattern.exists.nodes.length} variables; the maximum is ${MAX_VARIABLES}.`);
-        }
         const nested = new Set(scope);
         for (const [index, node] of pattern.exists.nodes.entries()) {
             const id = node.variable.id;
@@ -92,9 +82,6 @@ function validatePatternNode(context, pattern, pointer, scope, declarations, use
         return;
     }
     const { key, values } = patternOperands(pattern);
-    if (values.length === 0) {
-        context.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
-    }
     values.forEach((child, index) => validatePatternNode(context, child, `${pointer}/${key}/${index}`, scope, declarations, uses));
 }
 function validateTerm(context, term, pointer, scope, uses) {
@@ -112,9 +99,6 @@ function validateTerm(context, term, pointer, scope, uses) {
 function validateComposition(context, declaration, pointer) {
     const key = 'allOf' in declaration ? 'allOf' : 'anyOf';
     const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
-    if (refs.length === 0) {
-        context.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
-    }
     refs.forEach((ref, index) => context.resolvePolicy(ref, `${pointer}/${key}/${index}`));
 }
 function validateCycles(context) {

package/dist/v1/schema/validation/policy/uses.js

@@ -147,9 +147,6 @@ function visitChecks(validation, typing, expression, context, pointer, leaves) {
         return;
     }
     const { key, values } = checkOperands(expression);
-    if (values.length === 0) {
-        validation.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
-    }
     values.forEach((child, index) => visitChecks(validation, typing, child, context, `${pointer}/${key}/${index}`, leaves));
 }
 function selfContracts(validation, context, pointer) {

package/dist/v1/schema/validation/value-api.d.ts

@@ -10,11 +10,22 @@ export type { BlobOptions, BlobReceipt, BlobRef, BlobSchema, } from '../../langu
 export type { JsonSchema as Schema, JsonSchemaObject as SchemaObject, PathAnnotation, PropertyObjectSchema as PropertySchema, ValueSchemaContext as Context, } from '../../language/value/model/schema.js';
 export { instant } from '../../language/value/model/instant.js';
 export type { OrderingKind } from '../../language/value/ordering.js';
+export { DECLARED_VALUE_KINDS as DECLARED_KINDS, FORBIDDEN_KEYWORDS, SUBSCHEMA_KEYWORDS, VALUE_KEYWORDS as KEYWORDS, } from '../../language/value/profile/vocabulary.js';
+export type { DeclaredValueKind as DeclaredKind, ValueKeyword as Keyword, } from '../../language/value/profile/vocabulary.js';
+export { VALUE_RULES as RULES } from '../../language/validation/rule.js';
+export type { ValueRule as Rule, ValueRuleStage as RuleStage, } from '../../language/validation/rule.js';
 /** Validate one complete JSON value under the exact accepted schema that owns the contract. */
 export declare function validate(owner: DomainSchema, contract: JsonSchema, input: unknown, pointer?: string): readonly Diagnostic[];
 /** Return the one portable scalar ordering domain admitted by a property schema, if any. */
 export declare function classifyOrdering(owner: DomainSchema, contract: JsonSchema): OrderingKind | undefined;
-/** The value kind of a property schema: what a graph language may test on the property (Y4). */
+/**
+ * The value kind of a property schema: what a graph language may test on the property (Y4). It is
+ * the one kind of every non-null value the schema admits: `text` for strings, `number` for numbers
+ * and integers, `instant` for strings declared `x-astrale-value-kind: instant`, `enum` for a finite
+ * set of strings (`const` or `enum`), `boolean`, and `set` for arrays of `uniqueItems`. An
+ * ambiguous union, an object, an array with repetitions, a blob or a schema that admits no value is
+ * `json`. `$ref`, `allOf`, `anyOf` and `oneOf` are followed; `null` is a point of every kind.
+ */
 export declare function classifyValueKind(owner: DomainSchema, contract: JsonSchema): ValueKind;
 /**
  * A warning for each class property whose value kind is `json` (an ambiguous union, an object, an

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

@@ -8,6 +8,8 @@ const registries = new WeakMap();
 export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
 export { blob, isBlobValueSchema as isBlob } from '../../language/value/model/blob.js';
 export { instant } from '../../language/value/model/instant.js';
+export { DECLARED_VALUE_KINDS as DECLARED_KINDS, FORBIDDEN_KEYWORDS, SUBSCHEMA_KEYWORDS, VALUE_KEYWORDS as KEYWORDS, } from '../../language/value/profile/vocabulary.js';
+export { VALUE_RULES as RULES } from '../../language/validation/rule.js';
 /** Validate one complete JSON value under the exact accepted schema that owns the contract. */
 export function validate(owner, contract, input, pointer = '') {
     return validateJsonInstance(contract, input, registryFor(owner), pointer);
@@ -16,7 +18,14 @@ export function validate(owner, contract, input, pointer = '') {
 export function classifyOrdering(owner, contract) {
     return classifyOrderingWithRegistry(contract, registryFor(owner));
 }
-/** The value kind of a property schema: what a graph language may test on the property (Y4). */
+/**
+ * The value kind of a property schema: what a graph language may test on the property (Y4). It is
+ * the one kind of every non-null value the schema admits: `text` for strings, `number` for numbers
+ * and integers, `instant` for strings declared `x-astrale-value-kind: instant`, `enum` for a finite
+ * set of strings (`const` or `enum`), `boolean`, and `set` for arrays of `uniqueItems`. An
+ * ambiguous union, an object, an array with repetitions, a blob or a schema that admits no value is
+ * `json`. `$ref`, `allOf`, `anyOf` and `oneOf` are followed; `null` is a point of every kind.
+ */
 export function classifyValueKind(owner, contract) {
     return classifyValueKindWithRegistry(contract, registryFor(owner));
 }

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

@@ -1,7 +1,7 @@
 import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { validateValueSchema } from '../../language/value/profile/validate.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
-import { diagnostic } from '../diagnostic.js';
+import { valueDiagnostic } from '../diagnostic.js';
 export function validateEmbeddedValueSchemas(schema, registry) {
     const diagnostics = [];
     for (const [name, declaration] of Object.entries(schema.classes)) {
@@ -37,7 +37,7 @@ function validateCallable(declaration, pointer, registry, diagnostics) {
     }
 }
 function validate(schema, context, pointer, registry, diagnostics) {
-    for (const failure of validateValueSchema(schema, context, registry, pointer)) {
-        diagnostics.push(diagnostic('DV_VALUE_SCHEMA', failure.pointer, `[${failure.code}] ${failure.message}`, failure.ref));
+    for (const refusal of validateValueSchema(schema, context, registry, pointer)) {
+        diagnostics.push(valueDiagnostic('DV_VALUE_SCHEMA', refusal));
     }
 }

package/dist/v1/schema/validation/value.json-schema.d.ts

@@ -0,0 +1,51 @@
+import type { core as zodCore } from 'zod';
+type JsonSchema = zodCore.JSONSchema.JSONSchema;
+/**
+ * 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 declare const valueSchemaRules: {
+    readonly 'value-blob': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_VALUE_KIND';
+        readonly statement: 'A blob is declared only by the whole schema of a Property, exactly as values.blob writes it.';
+    };
+    readonly 'value-path': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_PATH_EXTENSION';
+        readonly 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.';
+    };
+    readonly 'value-recursion': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_RECURSION_PRODUCTIVE';
+        readonly 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.';
+    };
+    readonly 'value-reference-form': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_REFERENCE_FORM';
+        readonly 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.';
+    };
+    readonly 'value-reference-resolution': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_REFERENCE_RESOLUTION';
+        readonly 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.';
+    };
+    readonly 'value-regexp': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_REGEX_PORTABLE';
+        readonly statement: 'Every pattern, fullMatch and patternProperties name is an RFC 9485 I-Regexp within the regular-expression limits.';
+    };
+};
+export type ValueSchemaRule = keyof typeof valueSchemaRules;
+/**
+ * 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 declare function valueSchemaJsonSchema(): {
+    readonly root: readonly JsonSchema[];
+    readonly definitions: Readonly<Record<string, JsonSchema>>;
+    readonly nodeProperty: JsonSchema;
+};
+export {};

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.14",
   "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"