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

package/dist/v1/addressing/key.js

@@ -1,7 +1,8 @@
 import { acceptDefinitionRef, } from './definition-ref.js';
 import { DOMAIN_ORIGIN_PATTERN } from './patterns.js';
 const DEFINITION_KEY = /^(?:class|function|policy|view)\.([A-Za-z][A-Za-z0-9_]*)$/u;
-const CORE_KEY = /^core\.([a-z][a-z0-9-]{0,99})$/u;
+// The slug is the whole rest of the coordinate, its own `.` included: no member follows a Core key.
+const CORE_KEY = /^core\.((?=.{1,100}$)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*)$/u;
 const MEMBER_KEY = /^class\.([A-Za-z][A-Za-z0-9_]*)\.(property|method)\.([A-Za-z][A-Za-z0-9_]*)$/u;
 /** The keys of frozen Definition coordinates, derived once each. */
 const derived = new WeakMap();

package/dist/v1/addressing/patterns.d.ts

@@ -3,6 +3,7 @@ export type DomainOrigin = string;
 export declare const DOMAIN_ORIGIN_PATTERN: RegExp;
 export declare const MEMBER_NAME_PATTERN: RegExp;
 export declare const DEPENDENCY_ALIAS_PATTERN: RegExp;
+/** Labels of `[a-z][a-z0-9-]*` joined by `.`, 100 code points at most: `graph.reader`. */
 export declare const CORE_SLUG_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_PATTERN: RegExp;
 export declare const PROPERTY_KEY_PATTERN: RegExp;

package/dist/v1/addressing/patterns.js

@@ -1,7 +1,8 @@
 export const DOMAIN_ORIGIN_PATTERN = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
 export const MEMBER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/u;
 export const DEPENDENCY_ALIAS_PATTERN = /^[a-z][A-Za-z0-9]*$/u;
-export const CORE_SLUG_PATTERN = /^[a-z][a-z0-9-]{0,99}$/u;
+/** Labels of `[a-z][a-z0-9-]*` joined by `.`, 100 code points at most: `graph.reader`. */
+export const CORE_SLUG_PATTERN = /^(?=.{1,100}$)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*$/u;
 export const DOMAIN_REVISION_PATTERN = /^sha256:[0-9a-f]{64}$/u;
 const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
 const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';

package/dist/v1/builder/class/property.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { AutoEvent, AutoSet, PropertyImmutability } from '../../language/class/model/property.js';
+import type { AutoEvent, AutoSet, PropertyAuto, PropertyImmutability } from '../../language/class/model/property.js';
 import type { StateMachine } from '../../language/state/index.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { AUTHORING } from '../schema/handle.js';
@@ -31,10 +31,7 @@ export interface AutoProperty<out PropertyValue extends Property = Property> {
     readonly [AUTHORING]: 'auto';
     readonly [AUTO_INPUT]: {
         readonly property: PropertyValue;
-        readonly options: {
-            readonly on: readonly AutoEvent[];
-            readonly set: AutoSet;
-        };
+        readonly options: PropertyAuto;
     };
 }
 type PropertyAuthoringInput<Value extends Property> = Value extends Property<infer Schema, infer Options, infer Machine> ? {
@@ -45,10 +42,7 @@ type PropertyAuthoringInput<Value extends Property> = Value extends Property<inf
 export declare function propertyAuthoringInput<const Value extends Property>(value: Value): PropertyAuthoringInput<Value>;
 export declare function autoPropertyAuthoringInput<const Value extends AutoProperty>(value: Value): Value extends AutoProperty<infer Property> ? {
     readonly property: Property;
-    readonly options: {
-        readonly on: readonly AutoEvent[];
-        readonly set: AutoSet;
-    };
+    readonly options: PropertyAuto;
 } : never;
 export type PropertyFieldInput = ValueSchemaInput | Property | AutoProperty;
 export type PropertyRecordInput = Readonly<Record<string, PropertyFieldInput>>;

package/dist/v1/builder/class/property.js

@@ -59,6 +59,7 @@ export function auto(property, options) {
     return authoringValue('auto', {
         [AUTO_INPUT]: {
             property,
+            // `events` holds at least the one authored event.
             options: { on: Object.freeze(events), set: options.set },
         },
     });

package/dist/v1/builder/lowering/class.js

@@ -48,6 +48,7 @@ export class V1DefinitionCompiler {
     }
     edgeClass(value, name, pointer) {
         const input = classConfiguration(value);
+        // The authoring types give an Edge no State Property; the structure refuses an erased one.
         const facet = this.values.properties(input.properties, `${pointer}/properties`);
         const contract = (() => {
             if (value.orientation === 'directed') {
@@ -63,7 +64,9 @@ export class V1DefinitionCompiler {
                     // against the Class's effective Properties, once every Class is lowered.
                     ...(directed.unique === undefined
                         ? {}
-                        : { unique: directed.unique }),
+                        : {
+                            unique: directed.unique,
+                        }),
                 };
             }
             const undirected = classConfiguration(value);
@@ -135,6 +138,7 @@ export class V1DefinitionCompiler {
     endpointBase(value, pointer) {
         return {
             role: value.as,
+            // An empty list stays as authored: the structure refuses it when it judges the candidate.
             accepts: value.accepts
                 .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/accepts/${index}`))
                 .sort(compareDefinitionRefs),

package/dist/v1/builder/lowering/policy.js

@@ -14,6 +14,7 @@ export class V1PolicyCompiler {
         const input = policyDeclaration(value);
         const ref = { origin: this.context.origin, kind: 'policy', name };
         if ('operator' in input) {
+            // One ref for each Policy of a non-empty composition.
             const refs = input.policies.map((policy, index) => this.context.resolvePolicy(policy, `${pointer}/${input.operator}/${index}`));
             return {
                 ref,

package/dist/v1/builder/policy/authoring.js

@@ -86,10 +86,11 @@ export function createPatternContext(options) {
             });
             Object.freeze(node);
             const where = build({ node });
-            if (nodes.length === 0) {
+            const [first, ...rest] = nodes;
+            if (first === undefined) {
                 fail('BUILDER_POLICY_EMPTY_EXISTS', `${options.pointer}/match/exists/nodes`, 'exists(...) must declare at least one variable Node.');
             }
-            return { exists: { nodes, where } };
+            return { exists: { nodes: [first, ...rest], where } };
         },
         allOf(...expressions) {
             nonEmpty(expressions, `${options.pointer}/match/allOf`);

package/dist/v1/bundle/codec.js

@@ -7,7 +7,7 @@ import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revisi
 import { revisionOfDomainSchema } from '../schema/canonical/revision.js';
 import { MemoryDomainSchemaLookup } from '../schema/dependency/lookup.js';
 import { SchemaError } from '../schema/diagnostic.js';
-import { BundleError, diagnostic } from './diagnostic.js';
+import { BundleError, diagnostic, schemaDiagnosticAt } from './diagnostic.js';
 import { asDomainSchemaBundle, } from './model.js';
 import { parseDomainSchemaBundleStructure } from './structure.js';
 export function acceptDomainSchemaBundle(input) {
@@ -99,7 +99,7 @@ function acceptBundleValue(input) {
         catch (error) {
             if (!(error instanceof SchemaError))
                 throw error;
-            throw new BundleError(error.diagnostics.map((item) => diagnostic(item.code, `${entry.pointer}${item.pointer}`, item.message, item.ref)));
+            throw new BundleError(error.diagnostics.map((item) => schemaDiagnosticAt(entry.pointer, item)));
         }
     };
     for (const entry of candidates.values()) {

package/dist/v1/bundle/diagnostic.d.ts

@@ -4,6 +4,8 @@ export type BundleDiagnostic<Code extends BundleDiagnosticCode = BundleDiagnosti
     readonly code: Code;
 };
 export declare function diagnostic<const Code extends BundleDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): BundleDiagnostic<Code>;
+/** A refusal of one bundled schema, its pointer rebased under the schema's place in the bundle. */
+export declare function schemaDiagnosticAt(pointer: string, refusal: SchemaDiagnostic): BundleDiagnostic;
 export declare class BundleError extends Error {
     readonly diagnostics: readonly BundleDiagnostic[];
     constructor(diagnostics: readonly BundleDiagnostic[]);

package/dist/v1/bundle/diagnostic.js

@@ -2,6 +2,12 @@ import { formatDiagnostics, orderDiagnostics } from '../language/validation/diag
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
+/** A refusal of one bundled schema, its pointer rebased under the schema's place in the bundle. */
+export function schemaDiagnosticAt(pointer, refusal) {
+    // Acceptance refuses a document with Schema codes only, never with comparison request codes.
+    const code = refusal.code;
+    return Object.freeze({ ...refusal, code, pointer: `${pointer}${refusal.pointer}` });
+}
 export class BundleError extends Error {
     diagnostics;
     constructor(diagnostics) {

package/dist/v1/bundle/structure.js

@@ -1,7 +1,7 @@
 import { escapePointerToken } from '../language/value/syntax/pointer.js';
 import { SchemaError } from '../schema/diagnostic.js';
 import { routeDomainSchema } from '../schema/validation/domain.route.js';
-import { BundleError, diagnostic } from './diagnostic.js';
+import { BundleError, diagnostic, schemaDiagnosticAt } from './diagnostic.js';
 import { DOMAIN_BUNDLE_FORMAT, DOMAIN_BUNDLE_VERSION } from './model.js';
 export function parseDomainSchemaBundleStructure(input) {
     if (!isObject(input)) {
@@ -57,7 +57,7 @@ function routeAt(value, pointer, diagnostics) {
     catch (error) {
         if (!(error instanceof SchemaError))
             throw error;
-        diagnostics.push(...error.diagnostics.map((entry) => diagnostic(entry.code, `${pointer}${entry.pointer}`, entry.message, entry.ref)));
+        diagnostics.push(...error.diagnostics.map((entry) => schemaDiagnosticAt(pointer, entry)));
         return undefined;
     }
 }

package/dist/v1/domain/validation/create.d.ts

@@ -14,6 +14,9 @@ export interface CallableValidation {
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
 }
-/** Build the one Domain-level router shared by source resolution and compiled loading. */
+/**
+ * Build the one Domain-level router shared by source resolution and compiled loading. The Domain
+ * built from the same entries asks only for the Properties and Callables they declare.
+ */
 export declare function createDomainValidation(properties: ReadonlyMap<PropertyKey, PropertyValidation>, callables: ReadonlyMap<Key.Callable, CallableValidation>): DomainValidation;
 export declare function unknownInputField(field: string): readonly Diagnostic[];

package/dist/v1/domain/validation/create.js

@@ -1,34 +1,30 @@
-/** Build the one Domain-level router shared by source resolution and compiled loading. */
+/**
+ * Build the one Domain-level router shared by source resolution and compiled loading. The Domain
+ * built from the same entries asks only for the Properties and Callables they declare.
+ */
 export function createDomainValidation(properties, callables) {
+    const propertyOf = (key) => {
+        const target = properties.get(key);
+        if (target === undefined)
+            throw new TypeError(`Property ${key} is absent.`);
+        return target;
+    };
+    const callableOf = (key) => {
+        const target = callables.get(key);
+        if (target === undefined)
+            throw new TypeError(`Callable ${key} is absent.`);
+        return target;
+    };
     const validation = {
         propertyExists: (key) => properties.has(key),
-        property(key, input) {
-            const target = properties.get(key);
-            return target === undefined ? unknownTarget('Property', key) : target.validate(input);
-        },
-        propertyProgram(key) {
-            const target = properties.get(key);
-            if (target === undefined)
-                throw new TypeError(`Property ${key} is absent.`);
-            return target.program();
-        },
+        property: (key, input) => propertyOf(key).validate(input),
+        propertyProgram: (key) => propertyOf(key).program(),
         propertyOrdering: (key) => properties.get(key)?.ordering,
         callableExists: (key) => callables.has(key),
-        callableInput(key, input) {
-            const target = callables.get(key);
-            return target === undefined ? unknownTarget('Callable', key) : target.validateInput(input);
-        },
+        callableInput: (key, input) => callableOf(key).validateInput(input),
         callableFields: (key) => callables.get(key)?.fields,
-        callableInputField(key, field, input) {
-            const target = callables.get(key);
-            return target === undefined
-                ? unknownTarget('Callable', key)
-                : target.validateInputField(field, input);
-        },
-        callableOutput(key, output) {
-            const target = callables.get(key);
-            return target === undefined ? unknownTarget('Callable', key) : target.validateOutput(output);
-        },
+        callableInputField: (key, field, input) => callableOf(key).validateInputField(field, input),
+        callableOutput: (key, output) => callableOf(key).validateOutput(output),
     };
     return Object.freeze(validation);
 }
@@ -41,12 +37,3 @@ export function unknownInputField(field) {
         }),
     ];
 }
-function unknownTarget(kind, key) {
-    return [
-        Object.freeze({
-            code: 'DOMAIN_VALIDATION_TARGET_UNKNOWN',
-            pointer: '',
-            message: `${kind} ${key} is absent.`,
-        }),
-    ];
-}

package/dist/v1/language/.spec/schemas/value-schema.schema.json

@@ -0,0 +1,22 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://schemas.astrale.ai/dsl/v1/value-schema",
+    "$dynamicAnchor": "meta",
+    "$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,
+        "https://schemas.astrale.ai/dsl/v1/value-schema/vocabulary": true
+    },
+    "title": "Astrale V1 value schema",
+    "$comment": "The meta-schema of the V1 value-schema dialect: Draft 2020-12 and the required Astrale vocabulary (fullMatch, x-astrale-path, x-astrale-value-kind). Its $dynamicAnchor extends Draft 2020-12 at every subschema, not only the root. The rules of the profile beyond it are published as schema.values.RULES.",
+    "allOf": [{ "$ref": "https://json-schema.org/draft/2020-12/schema" }],
+    "properties": {
+        "fullMatch": { "type": "string" },
+        "x-astrale-path": { "type": "object" }
+    }
+}

package/dist/v1/language/class/model/class.d.ts

@@ -3,7 +3,7 @@ import type { MethodRecord } from '../../callable/model/callable.js';
 import type { ClassPolicy, NodeClassPolicy } from '../../policy/model/policy.js';
 import type { DataFacet } from './data.js';
 import type { EdgeContract } from './edge.js';
-import type { PropertyFacet } from './property.js';
+import type { EdgePropertyDefinition, NodePropertyDefinition, PropertyFacet } from './property.js';
 export type ClassKind = 'node' | 'edge';
 /**
  * Which Classes may extend a Class: `'open'`, those of its Domain and of every Domain that depends
@@ -30,7 +30,7 @@ export type NodeUniqueTuple = readonly [PropertyKey, ...PropertyKey[]];
  * backend announces it to enforce Node keys, so a tuple is never ignored where it is not.
  */
 export type NodeUniqueForm = readonly ['property'];
-export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet, DataFacet {
+export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyFacet<NodePropertyDefinition>, DataFacet {
     readonly kind: 'node';
     readonly abstract: boolean;
     /** Absent when `'internal'`, the default, so a Class that keeps the default keeps its revision. */
@@ -44,9 +44,9 @@ export interface NodeClassDefinition extends DefinitionBase<ClassRef>, PropertyF
      * The tuples no two Nodes of this Class and of its active concrete descendants share while every
      * Property is present; absent, none. A descendant is covered without declaring them again.
      */
-    readonly unique?: readonly NodeUniqueTuple[];
+    readonly unique?: readonly [NodeUniqueTuple, ...NodeUniqueTuple[]];
 }
-export type EdgeClassDefinition = DefinitionBase<ClassRef> & PropertyFacet & EdgeContract & {
+export type EdgeClassDefinition = DefinitionBase<ClassRef> & PropertyFacet<EdgePropertyDefinition> & EdgeContract & {
     readonly kind: 'edge';
     readonly abstract: boolean;
     /** Absent when `'internal'`, the default, so a Class that keeps the default keeps its revision. */

package/dist/v1/language/class/model/edge.d.ts

@@ -8,7 +8,7 @@ export type EdgeOrientation = 'directed' | 'undirected';
 export type EdgeLifetime = 'restrict' | 'detach';
 export interface EdgeEndpointBase {
     readonly role: string;
-    readonly accepts: readonly ClassRef[];
+    readonly accepts: readonly [ClassRef, ...ClassRef[]];
     /** Declared only when authored; otherwise derived (`edgeLifetimes`). */
     readonly onDelete?: EdgeLifetime;
 }
@@ -56,7 +56,7 @@ export interface DirectedEdgeContract {
      * The tuples no two Edges of this Class and of its active concrete descendants share. Absent
      * when the Class declares none, so a Class without one keeps its revision; never empty.
      */
-    readonly unique?: readonly EdgeUniqueTuple[];
+    readonly unique?: readonly [EdgeUniqueTuple, ...EdgeUniqueTuple[]];
 }
 export interface UndirectedEdgeContract {
     readonly orientation: 'undirected';

package/dist/v1/language/class/model/property.d.ts

@@ -1,20 +1,29 @@
+import type { StateTopology } from '../../state/index.js';
+import type { JsonSchema } from '../../value/model/schema.js';
 export type AutoEvent = 'create' | 'update';
 export type AutoSet = 'instant';
 /** `create`: written only by node or edge creation. `once`: written while absent, never unset. */
 export type PropertyImmutability = 'create' | 'once';
 export interface PropertyAuto {
-    readonly on: readonly AutoEvent[];
+    readonly on: readonly [AutoEvent, ...AutoEvent[]];
     readonly set: AutoSet;
 }
-export interface PropertyDefinition {
-    readonly schema: import('../../value/model/schema.js').JsonSchema;
+/** A Property of a Node Class, which may be a State Property. */
+export interface NodePropertyDefinition {
+    readonly schema: JsonSchema;
     readonly required: boolean;
     readonly auto?: PropertyAuto;
     readonly immutable?: PropertyImmutability;
     readonly description?: string;
-    readonly state?: import('../../state/index.js').StateTopology;
+    readonly state?: StateTopology;
 }
-export type PropertyRecord = Readonly<Record<string, PropertyDefinition>>;
-export interface PropertyFacet {
-    readonly properties: PropertyRecord;
+/** A Property of an Edge Class: an Edge has no State Property. */
+export interface EdgePropertyDefinition extends Omit<NodePropertyDefinition, 'state'> {
+    readonly state?: never;
+}
+/** A Property of a Class of either kind. */
+export type PropertyDefinition = NodePropertyDefinition | EdgePropertyDefinition;
+export type PropertyRecord<Definition extends PropertyDefinition = PropertyDefinition> = Readonly<Record<string, Definition>>;
+export interface PropertyFacet<Definition extends PropertyDefinition = PropertyDefinition> {
+    readonly properties: PropertyRecord<Definition>;
 }

package/dist/v1/language/definition/metadata.d.ts

@@ -18,3 +18,8 @@ export declare const name: Readonly<{
 }>;
 /** The common source and compiled grammar for a name displayed exactly as authored. */
 export declare function isDomainNameText(value: string): boolean;
+/**
+ * The same grammar as a portable pattern: no control character, and neither first nor last a
+ * character `trim` removes, spelled out since `\s` differs between regular expression engines.
+ */
+export declare const DOMAIN_NAME_TEXT_PATTERN: RegExp;

package/dist/v1/language/definition/metadata.js

@@ -22,3 +22,10 @@ const DOMAIN_NAME_CONTROL = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/u;
 export function isDomainNameText(value) {
     return value.trim() === value && !DOMAIN_NAME_CONTROL.test(value);
 }
+/**
+ * The same grammar as a portable pattern: no control character, and neither first nor last a
+ * character `trim` removes, spelled out since `\s` differs between regular expression engines.
+ */
+export const DOMAIN_NAME_TEXT_PATTERN = 
+// oxlint-disable-next-line no-control-regex
+/^(?:[^\u0000-\u001f\u007f-\u009f\u0020\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff](?:[^\u0000-\u001f\u007f-\u009f\u2028\u2029]*[^\u0000-\u001f\u007f-\u009f\u0020\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff])?)?$/u;

package/dist/v1/language/policy/model/policy.d.ts

@@ -65,20 +65,20 @@ export interface PolicyEdgePattern {
 }
 export type PolicyPatternExpression = PolicyEdgePattern | PolicySameNode<PolicyPatternTerm> | {
     readonly exists: {
-        readonly nodes: readonly PolicyVariable[];
+        readonly nodes: readonly [PolicyVariable, ...PolicyVariable[]];
         readonly where: PolicyPatternExpression;
     };
 } | {
-    readonly allOf: readonly PolicyPatternExpression[];
+    readonly allOf: readonly [PolicyPatternExpression, ...PolicyPatternExpression[]];
 } | {
-    readonly anyOf: readonly PolicyPatternExpression[];
+    readonly anyOf: readonly [PolicyPatternExpression, ...PolicyPatternExpression[]];
 };
 export type PolicyExpression = {
     readonly match: PolicyPatternExpression;
 } | {
-    readonly allOf: readonly PolicyRef[];
+    readonly allOf: readonly [PolicyRef, ...PolicyRef[]];
 } | {
-    readonly anyOf: readonly PolicyRef[];
+    readonly anyOf: readonly [PolicyRef, ...PolicyRef[]];
 };
 export interface PolicyDefinition extends DefinitionBase<PolicyRef> {
     readonly expression: PolicyExpression;

package/dist/v1/language/policy/normalization/normalize.js

@@ -6,9 +6,9 @@ export function normalizePolicyExpression(value) {
         return { match: normalizePolicyPattern(value.match) };
     }
     if ('allOf' in value) {
-        return { allOf: uniqueRefs(value.allOf) };
+        return { allOf: operands(uniqueRefs(value.allOf)) };
     }
-    return { anyOf: uniqueRefs(value.anyOf) };
+    return { anyOf: operands(uniqueRefs(value.anyOf)) };
 }
 /**
  * Passes after the first, while one still changes the Pattern. A pass numbers variables by the
@@ -66,8 +66,7 @@ function unwrapSingleOperands(value) {
     }));
     if (children.length === 1)
         return children[0];
-    const operands = policyCheckComposition(children);
-    return all ? { allOf: operands } : { anyOf: operands };
+    return all ? { allOf: operands(children) } : { anyOf: operands(children) };
 }
 export function normalizePolicyChecks(value) {
     if ('check' in value)
@@ -79,17 +78,19 @@ export function normalizePolicyChecks(value) {
             const normalized = normalizePolicyChecks(child);
             return 'allOf' in normalized ? normalized.allOf : [normalized];
         });
-        return { allOf: policyCheckComposition(uniqueJson(children)) };
+        return { allOf: operands(uniqueJson(children)) };
     }
     const children = value.anyOf.flatMap((child) => {
         const normalized = normalizePolicyChecks(child);
         return 'anyOf' in normalized ? normalized.anyOf : [normalized];
     });
-    return { anyOf: policyCheckComposition(uniqueJson(children)) };
+    return { anyOf: operands(uniqueJson(children)) };
 }
-function policyCheckComposition(values) {
-    // Structural routing may carry an invalid empty array into semantic validation;
-    // validateChecks reports it before the DomainSchema can be accepted.
+/**
+ * The operands of a non-empty list, mapped, flattened, deduplicated or sorted one by one: still at
+ * least one. The structure and compiled admission refuse an empty list.
+ */
+function operands(values) {
     return values;
 }
 function normalizePatternNode(value) {
@@ -106,7 +107,7 @@ function normalizePatternNode(value) {
     if ('exists' in value) {
         return {
             exists: {
-                nodes: [...value.exists.nodes].sort((left, right) => left.variable.id - right.variable.id),
+                nodes: operands([...value.exists.nodes].sort((left, right) => left.variable.id - right.variable.id)),
                 where: normalizePatternNode(value.exists.where),
             },
         };
@@ -116,13 +117,13 @@ function normalizePatternNode(value) {
             const normalized = normalizePatternNode(child);
             return 'allOf' in normalized ? normalized.allOf : [normalized];
         });
-        return { allOf: uniqueJson(children) };
+        return { allOf: operands(uniqueJson(children)) };
     }
     const children = value.anyOf.flatMap((child) => {
         const normalized = normalizePatternNode(child);
         return 'anyOf' in normalized ? normalized.anyOf : [normalized];
     });
-    return { anyOf: uniqueJson(children) };
+    return { anyOf: operands(uniqueJson(children)) };
 }
 function canonicalVariableIds(value) {
     const declarations = new Map();
@@ -297,7 +298,7 @@ function rewriteVariables(value, ids) {
     if ('exists' in value) {
         return {
             exists: {
-                nodes: value.exists.nodes.map((node) => {
+                nodes: operands(value.exists.nodes.map((node) => {
                     const variable = {
                         kind: 'variable',
                         id: ids.get(node.variable.id) ?? node.variable.id,
@@ -305,14 +306,14 @@ function rewriteVariables(value, ids) {
                     return 'class' in node
                         ? { variable, class: node.class }
                         : { variable, selector: node.selector };
-                }),
+                })),
                 where: rewriteVariables(value.exists.where, ids),
             },
         };
     }
     if ('allOf' in value)
-        return { allOf: value.allOf.map((child) => rewriteVariables(child, ids)) };
-    return { anyOf: value.anyOf.map((child) => rewriteVariables(child, ids)) };
+        return { allOf: operands(value.allOf.map((child) => rewriteVariables(child, ids))) };
+    return { anyOf: operands(value.anyOf.map((child) => rewriteVariables(child, ids))) };
 }
 function selectorSignature(node) {
     const selector = policyVariableSelector(node);

package/dist/v1/language/validation/diagnostic.d.ts

@@ -1,4 +1,4 @@
-export type DiagnosticCode = 'CALLABLE_INPUT_FIELD_UNKNOWN' | 'DOMAIN_CLASS_ABSTRACT' | 'DOMAIN_PROPERTY_INPUT_INVALID' | 'DOMAIN_PROPERTY_REQUIRED' | 'DOMAIN_PROPERTY_UNKNOWN' | 'DOMAIN_VALIDATION_TARGET_UNKNOWN' | 'VALUE_SCHEMA_INSTANCE_INVALID' | 'VS_DIALECT' | 'VS_DYNAMIC_FORBIDDEN' | 'VS_KEYWORD_CLOSED' | 'VS_META_SCHEMA' | 'VS_NUMBER_DOMAIN' | 'VS_PATH_EXTENSION' | 'VS_RECURSION_PRODUCTIVE' | 'VS_REFERENCE_FORM' | 'VS_REFERENCE_RESOLUTION' | 'VS_REGEX_PORTABLE' | 'VS_RESOURCE_ID' | 'VS_VALUE_KIND' | 'VS_VALUE_KIND_JSON';
+export type DiagnosticCode = 'CALLABLE_INPUT_FIELD_UNKNOWN' | 'DOMAIN_CLASS_ABSTRACT' | 'DOMAIN_PROPERTY_INPUT_INVALID' | 'DOMAIN_PROPERTY_REQUIRED' | 'DOMAIN_PROPERTY_UNKNOWN' | 'VALUE_SCHEMA_INSTANCE_INVALID' | 'VS_DIALECT' | 'VS_DYNAMIC_FORBIDDEN' | 'VS_KEYWORD_CLOSED' | 'VS_META_SCHEMA' | 'VS_NUMBER_DOMAIN' | 'VS_PATH_EXTENSION' | 'VS_RECURSION_PRODUCTIVE' | 'VS_REFERENCE_FORM' | 'VS_REFERENCE_RESOLUTION' | 'VS_REGEX_PORTABLE' | 'VS_RESOURCE_ID' | 'VS_VALUE_KIND' | 'VS_VALUE_KIND_JSON';
 export interface Diagnostic<out Code extends DiagnosticCode = DiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

package/dist/v1/language/validation/rule.d.ts

@@ -0,0 +1,26 @@
+import type { DiagnosticCode } from './diagnostic.js';
+/**
+ * What a rule reads to decide. `schema`: a value schema alone, with its place in the declaration
+ * that holds it (a Property, a callable input or output). `context`: a value schema and what its
+ * Domain can reach, the Node Classes of the Domain and of its direct dependencies and the exact
+ * dependency closure. `value`: a value, under an accepted schema or a contract of the Domain.
+ * `warning`: a value schema, which the rule reports without refusing it.
+ */
+export type ValueRuleStage = 'schema' | 'context' | 'value' | 'warning';
+/** The rule one value diagnostic code reports. */
+export interface ValueRule {
+    readonly stage: ValueRuleStage;
+    /**
+     * The positions the rule constrains, which its diagnostics point at, relative to the value
+     * schema, the value or the Domain input it checks: JSON Pointer templates in which a `{name}`
+     * token stands for one token of the kind it names and `{/path*}` for any number of tokens.
+     */
+    readonly positions: readonly [string, ...string[]];
+    /** The rule, in one plain sentence. */
+    readonly statement: string;
+}
+/**
+ * Every value diagnostic code with the rule it reports. A code added to the language does not
+ * compile until it is described here.
+ */
+export declare const VALUE_RULES: Readonly<Record<DiagnosticCode, ValueRule>>;