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

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 }]));

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/limits.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The limits of the V1 language, each defined once: every check of a source Schema, a Bundle or a
+ * compiled closure reads its bound here. Every limit is inclusive: a count equal to it is
+ * accepted, one more is refused. `schema.limits` publishes this object, and each rule of
+ * `schema.RULES` and `schema.values.RULES` that enforces some of them names them in `limits`.
+ */
+export declare const limits: Readonly<{
+    /** Bounds of the dependency graph of one Domain (`DV_DEPENDENCY_LIMITS`). */
+    dependency: Readonly<{
+        /** Direct dependencies one Domain declares. */
+        direct: 32;
+        /** Domains of a dependency closure, the Domain itself included. */
+        closure: 256;
+        /** Dependencies on the longest chain from a Domain: a direct dependency is at depth 1. */
+        depth: 32;
+    }>;
+    /** Bounds of one I-Regexp in a value schema (`VS_REGEX_PORTABLE`), as RFC 9485 §8 allows. */
+    regexp: Readonly<{
+        /** Code points of one source. */
+        maxCodePoints: 4096;
+        /** Groups nested in one another in one source. */
+        maxNesting: 32;
+        /** The greatest bound of a counted repetition `{n}` or `{n,m}`. */
+        maxRepeat: 1000;
+        /** States of one compiled machine; the counted-run form never expands and is not bounded. */
+        maxStates: 10000;
+    }>;
+    /**
+     * Bounds of the Policy language. A named Policy is measured once normalized and once each
+     * composition is expanded into the Policies it names; a check tree, the checks of a callable or
+     * of a Node Class rule, once normalized (`PL_BUDGET`). The structure bounds the others
+     * (`STRUCTURE_MAXIMUM`).
+     */
+    policy: Readonly<{
+        /**
+         * Levels of a Policy pattern: an Edge or sameNode is one, and each allOf, anyOf, exists and
+         * composition adds one.
+         */
+        patternDepth: 4;
+        /**
+         * Branches of a Policy's normal form: an anyOf adds those of its operands, an allOf multiplies
+         * them.
+         */
+        normalizedBranches: 8;
+        /** Nodes one exists declares. */
+        variablesPerExists: 4;
+        /** Graph predicates, Edges and sameNode equalities, of one normalized branch. */
+        edgePredicates: 6;
+        /** The greatest bound of a repeated Edge. */
+        repetition: 3;
+        /** Domains a Policy names: its own, and the origin of every Class and object it references. */
+        referencedDomains: 4;
+        /** Levels of a check tree: a check or sameNode is one, and each allOf and anyOf adds one. */
+        checkDepth: 4;
+        /** Branches of a check tree: an anyOf adds those of its operands, an allOf multiplies them. */
+        checkBranches: 8;
+        /** Checks and sameNode equalities of a check tree. */
+        checkLeaves: 8;
+    }>;
+}>;
+/** A limit by its key in `limits`, `<group>.<name>`: `policy.patternDepth`. */
+export type LimitKey = {
+    readonly [Group in keyof typeof limits & string]: `${Group}.${keyof (typeof limits)[Group] & string}`;
+}[keyof typeof limits & string];

package/dist/v1/language/limits.js

@@ -0,0 +1,60 @@
+/**
+ * The limits of the V1 language, each defined once: every check of a source Schema, a Bundle or a
+ * compiled closure reads its bound here. Every limit is inclusive: a count equal to it is
+ * accepted, one more is refused. `schema.limits` publishes this object, and each rule of
+ * `schema.RULES` and `schema.values.RULES` that enforces some of them names them in `limits`.
+ */
+export const limits = Object.freeze({
+    /** Bounds of the dependency graph of one Domain (`DV_DEPENDENCY_LIMITS`). */
+    dependency: Object.freeze({
+        /** Direct dependencies one Domain declares. */
+        direct: 32,
+        /** Domains of a dependency closure, the Domain itself included. */
+        closure: 256,
+        /** Dependencies on the longest chain from a Domain: a direct dependency is at depth 1. */
+        depth: 32,
+    }),
+    /** Bounds of one I-Regexp in a value schema (`VS_REGEX_PORTABLE`), as RFC 9485 §8 allows. */
+    regexp: Object.freeze({
+        /** Code points of one source. */
+        maxCodePoints: 4096,
+        /** Groups nested in one another in one source. */
+        maxNesting: 32,
+        /** The greatest bound of a counted repetition `{n}` or `{n,m}`. */
+        maxRepeat: 1000,
+        /** States of one compiled machine; the counted-run form never expands and is not bounded. */
+        maxStates: 10_000,
+    }),
+    /**
+     * Bounds of the Policy language. A named Policy is measured once normalized and once each
+     * composition is expanded into the Policies it names; a check tree, the checks of a callable or
+     * of a Node Class rule, once normalized (`PL_BUDGET`). The structure bounds the others
+     * (`STRUCTURE_MAXIMUM`).
+     */
+    policy: Object.freeze({
+        /**
+         * Levels of a Policy pattern: an Edge or sameNode is one, and each allOf, anyOf, exists and
+         * composition adds one.
+         */
+        patternDepth: 4,
+        /**
+         * Branches of a Policy's normal form: an anyOf adds those of its operands, an allOf multiplies
+         * them.
+         */
+        normalizedBranches: 8,
+        /** Nodes one exists declares. */
+        variablesPerExists: 4,
+        /** Graph predicates, Edges and sameNode equalities, of one normalized branch. */
+        edgePredicates: 6,
+        /** The greatest bound of a repeated Edge. */
+        repetition: 3,
+        /** Domains a Policy names: its own, and the origin of every Class and object it references. */
+        referencedDomains: 4,
+        /** Levels of a check tree: a check or sameNode is one, and each allOf and anyOf adds one. */
+        checkDepth: 4,
+        /** Branches of a check tree: an anyOf adds those of its operands, an allOf multiplies them. */
+        checkBranches: 8,
+        /** Checks and sameNode equalities of a check tree. */
+        checkLeaves: 8,
+    }),
+});

package/dist/v1/language/policy/analysis/budgets.d.ts

@@ -1,28 +1,49 @@
 import type { PolicyRef } from '../../../addressing/index.js';
 import type { PolicyCheckExpression, PolicyExpression } from '../model/policy.js';
-export declare const MAX_PATTERN_DEPTH = 4;
-export declare const MAX_BRANCHES = 8;
-export declare const MAX_VARIABLES = 4;
-export declare const MAX_EDGES = 6;
-export declare const MAX_REPEAT = 3;
-export declare const MAX_DOMAINS = 4;
-export declare const MAX_CHECK_DEPTH = 4;
-export declare const MAX_CHECK_LEAVES = 8;
+import { limits } from '../../limits.js';
+/** A key of `limits.policy`. */
+export type PolicyLimit = keyof typeof limits.policy;
+/**
+ * Where a count of Policy branches stops: one past its limit. Each branch count is exact up to its
+ * limit plus one and reads as that once it is over, so expansion stays bounded.
+ */
 export declare const BRANCH_OVERFLOW: number;
-export interface PatternMeasure {
-    readonly depth: number;
-    readonly edgeCounts: readonly number[];
-    readonly domains: ReadonlySet<string>;
+/**
+ * What `PL_BUDGET` compares with `limits.policy` for one named Policy once normalized and each of
+ * its compositions expanded, every count under the key of its limit. The branch count stops one
+ * past its limit: it is exact up to that, and once it is over, `edgePredicates` reads the branches
+ * it counted only. The other counts are exact.
+ */
+export interface PolicyMeasure {
+    /** Levels of the expanded pattern. */
+    readonly patternDepth: number;
+    /** Branches of its normal form, at most `limits.policy.normalizedBranches + 1`. */
+    readonly normalizedBranches: number;
+    /** The most graph predicates, Edges and sameNode equalities, of one branch. */
+    readonly edgePredicates: number;
+    /** Domains the expanded pattern names, its own included. */
+    readonly referencedDomains: number;
+}
+/**
+ * What `PL_BUDGET` compares with `limits.policy` for one check tree once normalized, every count
+ * under the key of its limit. The branch count stops one past its limit; the other counts are
+ * exact.
+ */
+export interface CheckMeasure {
+    /** Levels of the tree. */
+    readonly checkDepth: number;
+    /** Branches of its normal form, at most `limits.policy.checkBranches + 1`. */
+    readonly checkBranches: number;
+    /** Checks and sameNode equalities of the tree. */
+    readonly checkLeaves: number;
 }
+/** The limits of `limits.policy` a measure exceeds, in the order the measure lists them. */
+export declare function exceededLimits<Measure extends PolicyMeasure | CheckMeasure>(measure: Measure): readonly (keyof Measure & PolicyLimit)[];
 /**
  * Measure named Policies by their expanded branches, depth and referenced Domains. A Policy has no
  * measure when it is not normalized, when its expansion reaches itself, or when a composition names
  * a Policy `isLocal` refuses or one without a measure.
  */
-export declare function policyMeasurer(origin: string, normalized: ReadonlyMap<string, PolicyExpression>, isLocal: (ref: PolicyRef) => boolean): (name: string) => PatternMeasure | undefined;
-export interface CheckMeasure {
-    readonly depth: number;
-    readonly branches: number;
-    readonly leaves: number;
-}
+export declare function policyMeasurer(origin: string, normalized: ReadonlyMap<string, PolicyExpression>, isLocal: (ref: PolicyRef) => boolean): (name: string) => PolicyMeasure | undefined;
+/** Measure one normalized check tree. */
 export declare function measureChecks(expression: PolicyCheckExpression): CheckMeasure;

package/dist/v1/language/policy/analysis/budgets.js

@@ -1,13 +1,15 @@
+import { limits } from '../../limits.js';
 import { policyObjectOrigin, policyVariableClass } from '../model/policy.js';
-export const MAX_PATTERN_DEPTH = 4;
-export const MAX_BRANCHES = 8;
-export const MAX_VARIABLES = 4;
-export const MAX_EDGES = 6;
-export const MAX_REPEAT = 3;
-export const MAX_DOMAINS = 4;
-export const MAX_CHECK_DEPTH = 4;
-export const MAX_CHECK_LEAVES = 8;
-export const BRANCH_OVERFLOW = MAX_BRANCHES + 1;
+/**
+ * Where a count of Policy branches stops: one past its limit. Each branch count is exact up to its
+ * limit plus one and reads as that once it is over, so expansion stays bounded.
+ */
+export const BRANCH_OVERFLOW = limits.policy.normalizedBranches + 1;
+const CHECK_BRANCH_OVERFLOW = limits.policy.checkBranches + 1;
+/** The limits of `limits.policy` a measure exceeds, in the order the measure lists them. */
+export function exceededLimits(measure) {
+    return Object.keys(measure).filter((limit) => measure[limit] > limits.policy[limit]);
+}
 /**
  * Measure named Policies by their expanded branches, depth and referenced Domains. A Policy has no
  * measure when it is not normalized, when its expansion reaches itself, or when a composition names
@@ -48,7 +50,17 @@ export function policyMeasurer(origin, normalized, isLocal) {
             return undefined;
         return combineMeasures('allOf' in declaration ? 'allOf' : 'anyOf', children);
     };
-    return (name) => measurePolicy(name, new Set());
+    return (name) => {
+        const measure = measurePolicy(name, new Set());
+        return measure === undefined
+            ? undefined
+            : {
+                patternDepth: measure.depth,
+                normalizedBranches: measure.edgeCounts.length,
+                edgePredicates: Math.max(0, ...measure.edgeCounts),
+                referencedDomains: measure.domains.size,
+            };
+    };
 }
 function measurePattern(pattern, origin) {
     if ('sameNode' in pattern)
@@ -111,19 +123,17 @@ function combineMeasures(kind, children) {
     }
     return { depth, edgeCounts, domains };
 }
+/** Measure one normalized check tree. */
 export function measureChecks(expression) {
     if ('check' in expression || 'sameNode' in expression)
-        return { depth: 1, branches: 1, leaves: 1 };
+        return { checkDepth: 1, checkBranches: 1, checkLeaves: 1 };
     const children = ('allOf' in expression ? expression.allOf : expression.anyOf).map(measureChecks);
-    const branches = 'allOf' in expression
-        ? children.reduce((value, child) => saturatingProduct(value, child.branches), 1)
-        : children.reduce((value, child) => Math.min(BRANCH_OVERFLOW, value + child.branches), 0);
+    const checkBranches = 'allOf' in expression
+        ? children.reduce((value, child) => Math.min(CHECK_BRANCH_OVERFLOW, value * child.checkBranches), 1)
+        : children.reduce((value, child) => Math.min(CHECK_BRANCH_OVERFLOW, value + child.checkBranches), 0);
     return {
-        depth: 1 + Math.max(0, ...children.map((child) => child.depth)),
-        branches,
-        leaves: children.reduce((value, child) => value + child.leaves, 0),
+        checkDepth: 1 + Math.max(0, ...children.map((child) => child.checkDepth)),
+        checkBranches,
+        checkLeaves: children.reduce((value, child) => value + child.checkLeaves, 0),
     };
 }
-function saturatingProduct(left, right) {
-    return Math.min(BRANCH_OVERFLOW, left * right);
-}

package/dist/v1/language/policy/analysis/checks.js

@@ -1,5 +1,6 @@
+import { limits } from '../../limits.js';
 import { policyObjectKey } from '../model/policy.js';
-import { MAX_BRANCHES, measureChecks } from './budgets.js';
+import { measureChecks } from './budgets.js';
 /** Names a callable check object. Every leaf over one object sees the same Node at runtime. */
 function checkObjectName(object) {
     if (object.kind === 'self')
@@ -36,7 +37,7 @@ export function admittedCheckClasses(typing) {
  * check budget is already refused, so it is not expanded.
  */
 export function neverAdmittedClasses(expression, leaves) {
-    if (measureChecks(expression).branches > MAX_BRANCHES)
+    if (measureChecks(expression).checkBranches > limits.policy.checkBranches)
         return [];
     const accepted = new Map();
     for (const [leaf, classes] of leaves)

package/dist/v1/language/policy/analysis/typing.js

@@ -1,7 +1,7 @@
 import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { limits } from '../../limits.js';
 import { branchesOf, branchProduct, capBranches, targetMode, termKey, UnionFind, } from './branches.js';
-import { MAX_REPEAT } from './budgets.js';
 import { admittedCheckClasses } from './checks.js';
 export class PolicyTyping {
     scope;
@@ -12,7 +12,8 @@ export class PolicyTyping {
     // independent of the reaching path up to the opaque term-namespace labels, which only ever
     // disambiguate variables within one branch and leave targetMode and branch typing unchanged.
     // Two occurrences of one Policy in a branch share labels only when a Policy reaches it by two
-    // paths; for that to merge distinct variables, the Policy expands deeper than MAX_PATTERN_DEPTH.
+    // paths; for that to merge distinct variables, the Policy expands deeper than
+    // `limits.policy.patternDepth`.
     #expansions = new Map();
     constructor(scope) {
         this.scope = scope;
@@ -269,7 +270,7 @@ function variantsForEdge(use, typing) {
         !Number.isInteger(bounds.max) ||
         bounds.min < 0 ||
         bounds.max < bounds.min ||
-        bounds.max > MAX_REPEAT) {
+        bounds.max > limits.policy.repetition) {
         return [];
     }
     const sourceKey = termKey(edge.source, use.namespace);

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,29 @@
+import type { LimitKey } from '../limits.js';
+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;
+    /** The limits of `schema.limits` the rule enforces, by key, where it enforces some. */
+    readonly limits?: readonly [LimitKey, ...LimitKey[]];
+}
+/**
+ * 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>>;