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

package/dist/v1/compiled/admission/semantics/core.js

@@ -1,7 +1,7 @@
 import { Key } from '../../../addressing/index.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../../language/class/unique.js';
-import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, } from '../../../language/core/facts.js';
+import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, DOMAIN_ENDPOINT_CLASS, } from '../../../language/core/facts.js';
 import {} from '../../../language/core/model/core.js';
 import { policyObjectOrigin, policyObjectKey, projectedMemberClass, } from '../../../language/index.js';
 import { bindValueProgram } from '../../../language/value/compile/load.js';
@@ -123,7 +123,7 @@ function validateCoreProperties(values, analysis, path) {
 }
 function resolveCoreEndpoint(context, entry, ref, nodes, path) {
     if (ref.kind === 'domain')
-        return { key: 'domain' };
+        return { key: 'domain', member: { class: DOMAIN_ENDPOINT_CLASS, pointer: path } };
     const undeclared = () => fail(path, 'Core endpoint does not name a declared local Definition.');
     if (policyObjectOrigin(ref) !== entry.origin)
         return undeclared();
@@ -151,9 +151,5 @@ function declaresProjectedMember(context, entry, ref) {
     return declarations.some((declaration) => declaration.ref.name === ref.name);
 }
 function endpointSatisfies(context, endpoint, accepts) {
-    if ('value' in endpoint)
-        return classSatisfiesAny(context, endpoint.value.class, accepts);
-    if ('member' in endpoint)
-        return classSatisfiesAny(context, endpoint.member.class, accepts);
-    return true;
+    return classSatisfiesAny(context, 'value' in endpoint ? endpoint.value.class : endpoint.member.class, accepts);
 }

package/dist/v1/compiled/admission/semantics/policy/parity.js

@@ -1,6 +1,6 @@
 import {} from '../../../../addressing/index.js';
 import { branchesOf, targetMode, isConnected, } from '../../../../language/policy/analysis/branches.js';
-import { MAX_PATTERN_DEPTH, MAX_BRANCHES, MAX_EDGES, MAX_DOMAINS, measureChecks, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, policyMeasurer, } from '../../../../language/policy/analysis/budgets.js';
+import { exceededLimits, measureChecks, policyMeasurer, } from '../../../../language/policy/analysis/budgets.js';
 import { neverAdmittedClasses, } from '../../../../language/policy/analysis/checks.js';
 import {} from '../../../../language/policy/analysis/typing.js';
 import { checksNameTheCaller, isClassRuleChecks, } from '../../../../language/policy/model/policy.js';
@@ -28,11 +28,7 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
             }
         }
         const measure = measurePolicy(name);
-        if (measure !== undefined &&
-            (measure.depth > MAX_PATTERN_DEPTH ||
-                measure.edgeCounts.length > MAX_BRANCHES ||
-                Math.max(0, ...measure.edgeCounts) > MAX_EDGES ||
-                measure.domains.size > MAX_DOMAINS)) {
+        if (measure !== undefined && exceededLimits(measure).length > 0) {
             fail(path, 'Policy expansion exceeds the V1 depth, branch, Edge, or Domain budget.');
         }
         const branches = typing.expandedBranches(name, `$${name}`);
@@ -98,10 +94,7 @@ function validatePolicyChecks(context, typing, entry, expression, input, receive
     if (!checksNameTheCaller(expression)) {
         fail(path, `${SITE[site].checks} must check a Policy on every branch: sameNode alone names no caller.`);
     }
-    const measure = measureChecks(expression);
-    if (measure.depth > MAX_CHECK_DEPTH ||
-        measure.branches > MAX_BRANCHES ||
-        measure.leaves > MAX_CHECK_LEAVES) {
+    if (exceededLimits(measureChecks(expression)).length > 0) {
         fail(path, `${SITE[site].checks} exceed the V1 depth, branch, or leaf budget.`);
     }
     const leaves = new Map();

package/dist/v1/language/core/facts.d.ts

@@ -1,9 +1,17 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { EdgeContract, EdgeCount, EdgeEndpointBase, IncidentEndpoint } from '../class/model/edge.js';
+/**
+ * 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 declare const DOMAIN_ENDPOINT_CLASS: ClassRef;
 /** One endpoint of a Core Edge: a Core Node, a projected member or the owning Domain. */
 export interface CoreFactEndpoint {
     readonly key: string;
-    /** Set on a projected member: its Kernel Class, and where a breach of its degree is reported. */
+    /**
+     * Set on a projected member and on the owning Domain: the Kernel Class it is a Node of, and where
+     * a breach of its degree is reported.
+     */
     readonly member?: {
         readonly class: ClassRef;
         readonly pointer: string;
@@ -26,10 +34,12 @@ export interface CoreDegreeSubject {
 }
 export interface CoreEdgeSet<Edge> {
     readonly edges: readonly CoreFactEdge<Edge>[];
-    /** The local exact Edge Classes, in the order their slices are checked. */
+    /** The local Edge Classes, in the order their slices are checked. */
     readonly classes: readonly {
         readonly key: string;
-        readonly contract: EdgeContract;
+        readonly contract: EdgeContract & {
+            readonly abstract: boolean;
+        };
     }[];
     readonly nodes: readonly CoreDegreeSubject[];
     readonly satisfies: (ref: ClassRef, accepts: readonly ClassRef[]) => boolean;
@@ -68,5 +78,8 @@ export declare function coreEndpointsSatisfy<Endpoint>(contract: EdgeContract, s
  * DV-EDGE-UNIQUE); Activation checks them against stored data.
  */
 export declare function checkHeldKeys<Fact>(facts: Iterable<Fact>, keys: (fact: Fact) => readonly string[], report: (fact: Fact, previous: Fact) => void): void;
-/** 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 declare function checkCoreEdgeSet<Edge>(set: CoreEdgeSet<Edge>): void;

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/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/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,8 @@ 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[]];
 }
 /**
  * Every value diagnostic code with the rule it reports. A code added to the language does not

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

@@ -92,6 +92,7 @@ export const VALUE_RULES = frozen({
         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',
@@ -110,7 +111,10 @@ 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);
+    }
     return Object.freeze(rules);
 }

package/dist/v1/language/value/regexp/ast.js

@@ -1,8 +1,7 @@
+import { limits } from '../../limits.js';
 import { categoryRanges, complement, mergeRanges } from './unicode.js';
 const CATEGORY = /^(?:L[lmotu]?|M[cen]?|N[dlo]?|P[cdefios]?|Z[lps]?|S[ckmo]?|C[cfno]?)$/u;
-const MAX_CODE_POINTS = 4096;
-const MAX_NESTING = 32;
-const MAX_REPEAT = 1000;
+const { maxCodePoints, maxNesting, maxRepeat } = limits.regexp;
 const DOT_RANGES = [
     [0, 9],
     [11, 12],
@@ -14,7 +13,7 @@ export function parseIRegexp(source) {
     if (!isUnicodeScalarString(source) || source === '[^]')
         return undefined;
     const characters = Array.from(source);
-    if (characters.length > MAX_CODE_POINTS)
+    if (characters.length > maxCodePoints)
         return undefined;
     const parser = new Parser(characters);
     const expression = parser.expression(undefined, 0);
@@ -30,7 +29,7 @@ class Parser {
         return this.index === this.characters.length;
     }
     expression(stop, depth) {
-        if (depth > MAX_NESTING)
+        if (depth > maxNesting)
             return undefined;
         const alternatives = [];
         const first = this.sequence(stop, depth);
@@ -112,14 +111,14 @@ class Parser {
     quantifier() {
         this.index++;
         const minimum = this.integer();
-        if (minimum === undefined || minimum > MAX_REPEAT)
+        if (minimum === undefined || minimum > maxRepeat)
             return undefined;
         let maximum = minimum;
         if (this.peek() === ',') {
             this.index++;
             maximum = this.integer();
         }
-        if ((maximum !== undefined && (maximum > MAX_REPEAT || maximum < minimum)) ||
+        if ((maximum !== undefined && (maximum > maxRepeat || maximum < minimum)) ||
             this.peek() !== '}') {
             return undefined;
         }

package/dist/v1/language/value/regexp/compile.d.ts

@@ -1,16 +1,9 @@
 import type { Pattern, RunPattern } from '../compile/model.js';
 import type { Expression } from './ast.js';
 /**
- * The most states the machine of one I-Regexp may have (`limits.regexp.maxStates`), an
- * implementation limit as RFC 9485 §8 allows. Counted repetitions are expanded copy by copy, so the
- * parser's bounds on length, nesting and counts alone admit machines of billions of states. The
- * counted-run form never expands, so it is not subject to this budget.
- */
-export declare const MAX_STATES = 10000;
-/**
- * Thrown when an I-Regexp source compiles to a machine of more than `MAX_STATES` states. A short
- * branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and cost seconds per
- * validated value (P1-I-01); it is refused before any state is built.
+ * Thrown when an I-Regexp source compiles to a machine of more than `limits.regexp.maxStates`
+ * states. A short branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and
+ * cost seconds per validated value (P1-I-01); it is refused before any state is built.
  */
 export declare class PatternComplexityError extends RangeError {
     readonly limit: number;
@@ -20,7 +13,8 @@ export declare class PatternComplexityError extends RangeError {
 export declare function compilePattern(source: string): Pattern | RunPattern;
 /**
  * Whether a parsed I-Regexp compiles within the state budget: as counted runs, which never expand,
- * or as a machine of at most `MAX_STATES` states, counted from the AST before anything is built.
+ * or as a machine of at most `limits.regexp.maxStates` states, counted from the AST before anything
+ * is built.
  */
 export declare function withinStateBudget(expression: Expression): boolean;
 /**

package/dist/v1/language/value/regexp/compile.js

@@ -1,19 +1,20 @@
+import { limits } from '../../limits.js';
 import { parseIRegexp } from './ast.js';
 /**
- * The most states the machine of one I-Regexp may have (`limits.regexp.maxStates`), an
- * implementation limit as RFC 9485 §8 allows. Counted repetitions are expanded copy by copy, so the
- * parser's bounds on length, nesting and counts alone admit machines of billions of states. The
- * counted-run form never expands, so it is not subject to this budget.
+ * The most states the machine of one I-Regexp may have, an implementation limit as RFC 9485 §8
+ * allows. Counted repetitions are expanded copy by copy, so the parser's bounds on length, nesting
+ * and counts alone admit machines of billions of states. The counted-run form never expands, so it
+ * is not subject to this budget.
  */
-export const MAX_STATES = 10_000;
+const { maxStates } = limits.regexp;
 /**
- * Thrown when an I-Regexp source compiles to a machine of more than `MAX_STATES` states. A short
- * branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and cost seconds per
- * validated value (P1-I-01); it is refused before any state is built.
+ * Thrown when an I-Regexp source compiles to a machine of more than `limits.regexp.maxStates`
+ * states. A short branching source such as `(a{0,1000}){0,60}b` would unroll to ~120k states and
+ * cost seconds per validated value (P1-I-01); it is refused before any state is built.
  */
 export class PatternComplexityError extends RangeError {
     limit;
-    constructor(limit = MAX_STATES) {
+    constructor(limit = maxStates) {
         super(`Cannot compile an I-Regexp machine of more than ${limit} states.`);
         this.limit = limit;
         this.name = 'PatternComplexityError';
@@ -27,7 +28,7 @@ export function compilePattern(source) {
     const runs = scalarRuns(expression);
     if (runs !== undefined)
         return Object.freeze({ source, runs });
-    if (states(expression) > MAX_STATES)
+    if (states(expression) > maxStates)
         throw new PatternComplexityError();
     const builder = new Builder();
     const fragment = builder.expression(expression);
@@ -40,10 +41,11 @@ export function compilePattern(source) {
 }
 /**
  * Whether a parsed I-Regexp compiles within the state budget: as counted runs, which never expand,
- * or as a machine of at most `MAX_STATES` states, counted from the AST before anything is built.
+ * or as a machine of at most `limits.regexp.maxStates` states, counted from the AST before anything
+ * is built.
  */
 export function withinStateBudget(expression) {
-    return scalarRuns(expression) !== undefined || states(expression) <= MAX_STATES;
+    return scalarRuns(expression) !== undefined || states(expression) <= maxStates;
 }
 /**
  * The number of states `Builder` builds for an expression, computed from the AST alone: `states`