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

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.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;

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

@@ -1,7 +1,8 @@
 import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { classSatisfies, isGraphRoot } from '../../class/inheritance.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,8 +13,12 @@ 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();
+    #nodeClasses;
+    #concreteClasses;
+    #satisfaction;
     constructor(scope) {
         this.scope = scope;
     }
@@ -68,7 +73,9 @@ export class PolicyTyping {
         return branches !== undefined && branches.every((branch) => this.branchIsTyped(branch, use));
     }
     #concreteEndpointClasses(accepts) {
-        return this.scope.concreteNodeClasses.filter((candidate) => this.#classSatisfiesEndpoint(candidate, accepts));
+        this.#concreteClasses ??= new Set(this.scope.concreteNodeClasses.map(definitionRefIndex));
+        const concrete = this.#concreteClasses;
+        return this.#satisfyingOneOf(accepts).filter((ref) => concrete.has(definitionRefIndex(ref)));
     }
     #expandedBranches(name, visiting, namespace) {
         if (visiting.has(name))
@@ -157,7 +164,11 @@ export class PolicyTyping {
             if (contract.kind === 'exact')
                 return this.#applyExact(candidates, contract.ref);
             if (contract.kind === 'default') {
-                return uniqueCandidates(this.scope.allNodeClasses.flatMap((ref) => this.#applyExact(candidates, ref)));
+                return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
+                    ? this.#isNodeClass(candidate.ref)
+                        ? [candidate]
+                        : []
+                    : this.#nodeCandidates(candidate)));
             }
             return candidates;
         }
@@ -182,26 +193,30 @@ export class PolicyTyping {
                 if (definitionRefIndex(candidate.ref) === definitionRefIndex(exact))
                     result.push(candidate);
             }
-            else if (candidate.requirements.every((required) => this.scope.classExtends(exact, required))) {
+            else if (candidate.kind === 'node') {
+                if (this.#isNodeClass(exact) && this.#satisfiesLists(exact, candidate.lists)) {
+                    result.push({ kind: 'exact', ref: exact });
+                }
+            }
+            else if (candidate.requirements.every((required) => this.#classExtends(exact, required))) {
                 result.push({ kind: 'exact', ref: exact });
             }
         }
         return uniqueCandidates(result);
     }
     #applyAnyNodeClass(candidates) {
-        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
-            ? [candidate]
-            : this.scope.allNodeClasses
-                .filter((ref) => candidate.requirements.every((required) => this.scope.classExtends(ref, required)))
-                .map((ref) => ({ kind: 'exact', ref }))));
+        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact' ? [candidate] : this.#nodeCandidates(candidate)));
     }
     #applyRequirement(candidates, required) {
         const result = [];
         for (const candidate of candidates) {
             if (candidate.kind === 'exact') {
-                if (this.scope.classExtends(candidate.ref, required))
+                if (this.#classExtends(candidate.ref, required))
                     result.push(candidate);
             }
+            else if (candidate.kind === 'node') {
+                result.push(...this.#inhabited([...candidate.lists, [required]]));
+            }
             else {
                 result.push({
                     kind: 'open',
@@ -219,6 +234,11 @@ export class PolicyTyping {
                     result.push(candidate);
                 continue;
             }
+            if (candidate.kind === 'node') {
+                if (accepts.length > 0)
+                    result.push(...this.#inhabited([...candidate.lists, accepts]));
+                continue;
+            }
             for (const accept of accepts) {
                 result.push({
                     kind: 'open',
@@ -229,8 +249,105 @@ export class PolicyTyping {
         return uniqueCandidates(result);
     }
     #classSatisfiesEndpoint(candidate, accepts) {
-        return accepts.some((accept) => this.scope.classExtends(candidate, accept));
+        return accepts.some((accept) => this.#classExtends(candidate, accept));
+    }
+    /** Whether `candidate` is the `required` Class or a same-kind descendant. */
+    #classExtends(candidate, required) {
+        const resolve = (ref) => this.scope.resolveClass(ref);
+        const actual = resolve(candidate);
+        const target = resolve(required);
+        return actual !== undefined && target !== undefined && classSatisfies(actual, target, resolve);
+    }
+    /**
+     * The Node Classes of the closure that satisfy one Class of `accepts`, in closure order: those
+     * `#classSatisfiesEndpoint` accepts, read from the index rather than tested one by one.
+     */
+    #satisfyingOneOf(accepts) {
+        const index = (this.#satisfaction ??= satisfactionIndex(this.scope));
+        const positions = new Set();
+        for (const accept of accepts) {
+            const required = this.scope.resolveClass(accept);
+            if (required?.kind !== 'node')
+                continue;
+            if (isGraphRoot(required))
+                return index.nodeClasses;
+            for (const position of index.satisfying.get(ancestryKey(required.ref)) ?? []) {
+                positions.add(position);
+            }
+        }
+        return [...positions].sort((left, right) => left - right).map((at) => index.nodeClasses[at]);
+    }
+    #satisfiesLists(ref, lists) {
+        return lists.every((accepts) => this.#classSatisfiesEndpoint(ref, accepts));
+    }
+    #isNodeClass(ref) {
+        this.#nodeClasses ??= new Set(this.scope.allNodeClasses.map(definitionRefIndex));
+        return this.#nodeClasses.has(definitionRefIndex(ref));
+    }
+    /** The Node Classes an open or `node` candidate can be. */
+    #nodeCandidates(candidate) {
+        return candidate.kind === 'node'
+            ? [candidate]
+            : this.#inhabited(candidate.requirements.map((required) => [required]));
+    }
+    /**
+     * The `node` candidate of these lists when some Node Class of the closure satisfies them, so that
+     * an empty one is dropped where its expansion would have been empty. A witness is almost always a
+     * Class the lists name; only when none is does the search read the Classes that satisfy the
+     * narrowest list, every witness being one of them.
+     */
+    #inhabited(lists) {
+        const fits = (ref) => this.#isNodeClass(ref) && this.#satisfiesLists(ref, lists);
+        const inhabited = lists.some((accepts) => accepts.some(fits)) ||
+            (lists.length === 0
+                ? this.scope.allNodeClasses
+                : lists
+                    .map((accepts) => this.#satisfyingOneOf(accepts))
+                    .reduce((narrowest, next) => (next.length < narrowest.length ? next : narrowest))).some(fits);
+        return inhabited ? [{ kind: 'node', lists }] : [];
+    }
+}
+/** Classes are satisfied by origin and name, as `classSatisfies` compares them. */
+function ancestryKey(ref) {
+    return `${ref.origin}\u0000${ref.name}`;
+}
+/**
+ * Index each Node Class of the closure under every Class its ancestry reaches, walked as
+ * `classSatisfies` walks it: the Class itself, then each declared parent that resolves to a Node
+ * Class. A Class then satisfies a non-root Node Class exactly when it is indexed under it.
+ */
+function satisfactionIndex(scope) {
+    const nodeClasses = [];
+    const satisfying = new Map();
+    for (const ref of scope.allNodeClasses) {
+        const actual = scope.resolveClass(ref);
+        if (actual?.kind !== 'node')
+            continue;
+        const position = nodeClasses.push(ref) - 1;
+        const seen = new Set();
+        const keys = new Set();
+        const pending = [actual];
+        for (let value = pending.pop(); value !== undefined; value = pending.pop()) {
+            if (seen.has(value))
+                continue;
+            seen.add(value);
+            const key = ancestryKey(value.ref);
+            if (!keys.has(key)) {
+                keys.add(key);
+                const positions = satisfying.get(key);
+                if (positions === undefined)
+                    satisfying.set(key, [position]);
+                else
+                    positions.push(position);
+            }
+            for (const parent of value.extends) {
+                const resolved = scope.resolveClass(parent);
+                if (resolved?.kind === 'node')
+                    pending.push(resolved);
+            }
+        }
     }
+    return { nodeClasses, satisfying };
 }
 function targetContract(term, use) {
     if (use.kind === 'object')
@@ -269,7 +386,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);
@@ -328,7 +445,12 @@ function uniqueCandidates(values) {
     for (const value of values) {
         const key = value.kind === 'exact'
             ? `exact:${definitionRefIndex(value.ref)}`
-            : `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`;
+            : value.kind === 'open'
+                ? `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`
+                : `node:${value.lists
+                    .map((accepts) => accepts.map(definitionRefIndex).sort().join(','))
+                    .sort()
+                    .join('|')}`;
         result.set(key, value);
     }
     return [...result.values()];

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

@@ -1,3 +1,4 @@
+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
@@ -18,6 +19,14 @@ export interface ValueRule {
     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[]];
+    /**
+     * The conditions of the published JSON Schema of the document that state the rule, where some
+     * do: the URI fragment of each `if` or `not` subschema whose failure refuses a value schema of
+     * the document with `DV_VALUE_SCHEMA` and this rule's code as its `valueCode`.
+     */
+    readonly conditions?: readonly [string, ...string[]];
 }
 /**
  * Every value diagnostic code with the rule it reports. A code added to the language does not

package/dist/v1/language/validation/rule.js

@@ -80,18 +80,14 @@ export const VALUE_RULES = frozen({
     },
     VS_REFERENCE_RESOLUTION: {
         stage: 'context',
-        positions: [
-            '{/path*}/$ref',
-            '{/path*}/x-astrale-path/accepts/{index}',
-            '',
-            '/registry{/path*}',
-        ],
+        positions: ['{/path*}/$ref', '{/path*}/x-astrale-path/accepts/{index}', ''],
         statement: 'A $ref resolves to a location of its own value schema, x-astrale-path accepts Node Classes of the Domain or of a direct dependency, and the schema is checked with the exact dependency closure of its Domain.',
     },
     VS_REGEX_PORTABLE: {
         stage: 'schema',
         positions: ['{/path*}/pattern', '{/path*}/fullMatch', '{/path*}/patternProperties/{pattern}'],
         statement: 'Every pattern, fullMatch and patternProperties name is an RFC 9485 I-Regexp within the regular-expression limits.',
+        limits: ['regexp.maxCodePoints', 'regexp.maxNesting', 'regexp.maxRepeat', 'regexp.maxStates'],
     },
     VS_RESOURCE_ID: {
         stage: 'schema',
@@ -102,6 +98,7 @@ export const VALUE_RULES = frozen({
         stage: 'schema',
         positions: ['{/path*}/x-astrale-value-kind'],
         statement: 'x-astrale-value-kind declares instant beside type string at any location, or blob as the whole schema of a Property, exactly as values.blob writes it.',
+        conditions: ['#/$defs/value-location/anyOf/1/if'],
     },
     VS_VALUE_KIND_JSON: {
         stage: 'warning',
@@ -110,7 +107,12 @@ export const VALUE_RULES = frozen({
     },
 });
 function frozen(rules) {
-    for (const rule of Object.values(rules))
+    for (const rule of Object.values(rules)) {
         Object.freeze(Object.freeze(rule).positions);
+        if (rule.limits !== undefined)
+            Object.freeze(rule.limits);
+        if (rule.conditions !== undefined)
+            Object.freeze(rule.conditions);
+    }
     return Object.freeze(rules);
 }

package/dist/v1/language/value/ordering.d.ts

@@ -14,6 +14,11 @@ export declare function classifyOrdering(contract: JsonSchema, registry: ValueSc
 /** Recompute the scalar ordering classification from one admitted portable value program. */
 export declare function classifyValueProgramOrdering(program: ValueProgram): OrderingKind | undefined;
 export declare function classifyPreparedOrdering(compiled: CompiledInstanceSchema): OrderingKind | undefined;
+/**
+ * Every value kind `classifyValueKind` returns, frozen, in the order `ValueKind` names them. A kind
+ * added to `ValueKind` does not compile until it is listed here.
+ */
+export declare const VALUE_KINDS: readonly ValueKind[];
 /**
  * The value kind of a property schema (page "Fondations Query v7", § Atoms et value kinds, Y4):
  * the one kind its non-null values admit, `null` being a point of every kind. An annotated

package/dist/v1/language/value/ordering.js

@@ -34,6 +34,20 @@ export function classifyPreparedOrdering(compiled) {
         ? kind
         : undefined;
 }
+const valueKinds = {
+    text: true,
+    number: true,
+    instant: true,
+    enum: true,
+    boolean: true,
+    set: true,
+    json: true,
+};
+/**
+ * Every value kind `classifyValueKind` returns, frozen, in the order `ValueKind` names them. A kind
+ * added to `ValueKind` does not compile until it is listed here.
+ */
+export const VALUE_KINDS = Object.freeze(Object.keys(valueKinds));
 /**
  * The value kind of a property schema (page "Fondations Query v7", § Atoms et value kinds, Y4):
  * the one kind its non-null values admit, `null` being a point of every kind. An annotated

package/dist/v1/language/value/reference/closure.js

@@ -36,10 +36,9 @@ export function collectResourceClosure(schema, context, index, pointer) {
             const target = result.resolved.resource;
             if (resources.has(target.key))
                 return;
-            const registered = {
-                ...target,
-                diagnosticPointer: `${pointer}/registry/graphNodePath`,
-            };
+            // The graph NodePath resource is no part of the schema: what it holds is reported at the
+            // $ref that names it.
+            const registered = { ...target, diagnosticPointer: refPointer };
             resources.set(target.key, registered);
             queue.push(registered);
         });

package/dist/v1/language/value/reference/registry.index.d.ts

@@ -5,6 +5,8 @@ export interface RegistryIndex {
     readonly registry: ValueSchemaRegistry;
     readonly domains: ReadonlyMap<string, ValueSchemaDomainRegistry>;
     readonly dependenciesByOwner: ReadonlyMap<string, ReadonlyMap<string, string>>;
+    /** The `definitionRefIndex` of each Node Definition its own Domain lists. */
+    readonly nodeDefinitions: ReadonlySet<string>;
 }
 export declare function indexRegistry(registry: ValueSchemaRegistry, pointer: string): {
     readonly index: RegistryIndex;