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

package/dist/v1/language/value/reference/registry.index.js

@@ -4,11 +4,21 @@ import { diagnostic } from '../../validation/diagnostic.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 import { JSON_SCHEMA_DIALECT } from '../model/schema.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../syntax/node-path/schema.js';
+// A registry is an immutable value, and every value schema of a Domain is validated against the
+// same one: an index that admitted it without a diagnostic is reused, so the closure is indexed
+// once per registry rather than once per value schema.
+const admittedIndexes = new WeakMap();
 export function indexRegistry(registry, pointer) {
+    const admitted = admittedIndexes.get(registry);
+    if (admitted !== undefined)
+        return { index: admitted, diagnostics: [] };
     const diagnostics = [];
     const domains = new Map();
     domains.set(registry.current.origin, registry.current);
-    validateDomainRegistry(registry.current, `${pointer}/registry/current`, false, diagnostics);
+    // The registry is the closure the Kernel builds for the schema at `pointer`, not a document: a
+    // fault of one of its entries is a fault of the closure that schema is checked with, reported
+    // there, the entry named in the message.
+    validateDomainRegistry(registry.current, 'current', false, pointer, diagnostics);
     const dependencies = [
         ...registry.directDependencies.map((domain) => ({ domain, lane: 'directDependencies' })),
         ...registry.transitiveDependencies.map((domain) => ({
@@ -17,10 +27,9 @@ export function indexRegistry(registry, pointer) {
         })),
     ];
     dependencies.forEach(({ domain, lane }, index) => {
-        const domainPointer = `${pointer}/registry/${lane}/${index}`;
-        validateDomainRegistry(domain, domainPointer, true, diagnostics);
+        validateDomainRegistry(domain, `${lane}/${index}`, true, pointer, diagnostics);
         if (domain.origin === registry.current.origin || domains.has(domain.origin)) {
-            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', domainPointer, `Registry origin ${domain.origin} is duplicated in the exact closure.`));
+            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Registry origin ${domain.origin} is duplicated in the exact closure, at ${lane}/${index}.`));
             return;
         }
         domains.set(domain.origin, domain);
@@ -37,31 +46,38 @@ export function indexRegistry(registry, pointer) {
             }
         }
     }
-    validateGraphNodePathResource(registry.graphNodePath, `${pointer}/registry/graphNodePath`, diagnostics);
-    return { index: { registry, domains, dependenciesByOwner }, diagnostics };
+    const nodeDefinitions = new Set();
+    for (const domain of domains.values()) {
+        for (const ref of domain.nodeDefinitions) {
+            if (ref.origin === domain.origin)
+                nodeDefinitions.add(definitionRefIndex(ref));
+        }
+    }
+    validateGraphNodePathResource(registry.graphNodePath, pointer, diagnostics);
+    const index = { registry, domains, dependenciesByOwner, nodeDefinitions };
+    if (diagnostics.length === 0)
+        admittedIndexes.set(registry, index);
+    return { index, diagnostics };
 }
 export function isOriginVisibleFrom(index, ownerOrigin, targetOrigin) {
     return (ownerOrigin === targetOrigin ||
         index.dependenciesByOwner.get(ownerOrigin)?.has(targetOrigin) === true);
 }
 export function hasNodeDefinition(index, ref, ownerOrigin) {
-    if (!isOriginVisibleFrom(index, ownerOrigin, ref.origin))
-        return false;
-    return (index.domains
-        .get(ref.origin)
-        ?.nodeDefinitions.some((candidate) => definitionRefIndex(candidate) === definitionRefIndex(ref)) === true);
+    return (isOriginVisibleFrom(index, ownerOrigin, ref.origin) &&
+        index.nodeDefinitions.has(definitionRefIndex(ref)));
 }
-function validateDomainRegistry(domain, pointer, revisionRequired, diagnostics) {
+function validateDomainRegistry(domain, entry, revisionRequired, pointer, diagnostics) {
     if (!DOMAIN_ORIGIN_PATTERN.test(domain.origin)) {
-        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/origin`, 'Registry origin is invalid.'));
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Registry origin is invalid, at ${entry}.`));
     }
     if ((revisionRequired && domain.revision === undefined) ||
         (domain.revision !== undefined && !DOMAIN_REVISION_PATTERN.test(domain.revision))) {
-        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/revision`, 'A dependency-closure registry entry requires its exact sha256 revision.'));
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `A dependency-closure registry entry requires its exact sha256 revision, at ${entry}.`));
     }
     for (const ref of domain.nodeDefinitions) {
         if (ref.origin !== domain.origin) {
-            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/nodeDefinitions`, 'A registry domain can list only its own Node Definitions.'));
+            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `A registry domain can list only its own Node Definitions, at ${entry}.`));
         }
     }
 }

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`

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

@@ -1,5 +1,6 @@
+import { limits } from '../../limits.js';
 import { parseIRegexp } from './ast.js';
-import { MAX_STATES, withinStateBudget } from './compile.js';
+import { withinStateBudget } from './compile.js';
 /** The refusal of one source, through the same AST and state count as compilation. */
 export function refuseIRegexp(source) {
     const expression = parseIRegexp(source);
@@ -13,5 +14,5 @@ export function isIRegexp(source) {
 }
 /** The authoring explanation of a `states` refusal of `subject` (`pattern`, `fullMatch`, ...). */
 export function stateBudgetMessage(subject) {
-    return `${subject} expands its counted repetitions into more than ${MAX_STATES} states, the I-Regexp implementation limit (RFC 9485 §8); nest fewer or smaller counts.`;
+    return `${subject} expands its counted repetitions into more than ${limits.regexp.maxStates} states, the I-Regexp implementation limit (RFC 9485 §8); nest fewer or smaller counts.`;
 }

package/dist/v1/schema/.spec/schemas/domain-schema.schema.json

@@ -46,7 +46,7 @@
             "code": "DV_VALUE_SCHEMA",
             "valueCode": "VS_PATH_EXTENSION",
             "stage": "rule",
-            "statement": "x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema, and reads target node, cardinality one and a non-empty set of Node Class refs it accepts.",
+            "statement": "x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema.",
             "positions": [
                 "#/$defs/value-location/anyOf/1/properties/x-astrale-path"
             ]
@@ -75,6 +75,7 @@
             "stage": "context",
             "statement": "A $ref resolves to a location of its own value schema, and x-astrale-path accepts Node Classes of the Domain or of a direct dependency.",
             "positions": [
+                "#/$defs/path-annotation/properties/accepts/items",
                 "#/$defs/value-location/anyOf/1/properties/$ref"
             ]
         },
@@ -1384,6 +1385,33 @@
             "maxLength": 253,
             "pattern": "^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$"
         },
+        "path-annotation": {
+            "type": "object",
+            "properties": {
+                "target": {
+                    "type": "string",
+                    "const": "node"
+                },
+                "cardinality": {
+                    "type": "string",
+                    "const": "one"
+                },
+                "accepts": {
+                    "type": "array",
+                    "minItems": 1,
+                    "uniqueItems": true,
+                    "items": {
+                        "$ref": "#/$defs/class-ref"
+                    }
+                }
+            },
+            "required": [
+                "target",
+                "cardinality",
+                "accepts"
+            ],
+            "additionalProperties": false
+        },
         "policy-check-expr": {
             "anyOf": [
                 {
@@ -2100,7 +2128,7 @@
                             "type": "string"
                         },
                         "x-astrale-path": {
-                            "type": "object"
+                            "$ref": "#/$defs/path-annotation"
                         },
                         "additionalProperties": {
                             "$ref": "#/$defs/value-subschema"

package/dist/v1/schema/admission/accept.js

@@ -1,22 +1,11 @@
-import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
 import { canonicalDomainSchemaAfterValidation } from '../canonical/revision.js';
 import { emptyDomainSchemaLookup } from '../dependency/lookup.js';
-import { SchemaError, diagnostic } from '../diagnostic.js';
+import { SchemaError } from '../diagnostic.js';
 import { rememberDomainClosure } from '../resolution/closure.js';
 import { validateDomainSchemaSemantics } from '../validation/domain.js';
-import { routeDomainSchema } from '../validation/domain.route.js';
+import { structureDomainSchema } from '../validation/domain.route.js';
 export function acceptDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
-    let admitted;
-    try {
-        admitted = acceptJsonValue(input);
-    }
-    catch (error) {
-        if (error instanceof JsonBoundaryError) {
-            throw new SchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
-        }
-        throw error;
-    }
-    const structured = routeDomainSchema(admitted);
+    const structured = structureDomainSchema(input);
     const validation = validateDomainSchemaSemantics(structured, lookup);
     if (validation.diagnostics.length > 0)
         throw new SchemaError(validation.diagnostics);

package/dist/v1/schema/admission/callable.d.ts

@@ -0,0 +1,21 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { CallableValidation } from '../../domain/validation/create.js';
+import type { CallableDefinition } from '../../language/callable/model/callable.js';
+import type { DomainSchema } from '../model/schema.js';
+/** One admitted callable contract and the validators of its exact owner environment. */
+export interface AcceptedCallable extends CallableValidation {
+    readonly definition: CallableDefinition;
+}
+/**
+ * Accept one callable contract in the exact environment of its owner Domain, by the one validation
+ * every contract passes wherever it is declared (`validateContract`, `validateContractPolicy`,
+ * `validateCheckBudget`): the structure of a Function declaration without `ref`, its value schemas
+ * against the owner registry, its execution modifier and admission age, and its Policy with the
+ * budget of its checks. `receiver` is the owner Node Class whose Node receives the call and which
+ * the Policy names `self`: the Class of a Function instance, whose Node carries the contract, or
+ * the owner of an instance Method. Without it, as at a Function declaration, the Policy names none.
+ * Returns the canonical definition and its validators.
+ */
+export declare function acceptCallable(input: unknown, owner: DomainSchema, options?: {
+    readonly receiver?: ClassRef;
+}): AcceptedCallable;

package/dist/v1/schema/admission/callable.js

@@ -0,0 +1,96 @@
+import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { measureChecks } from '../../language/policy/analysis/budgets.js';
+import { PolicyTyping } from '../../language/policy/analysis/typing.js';
+import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
+import {} from '../../language/value/evaluate/preparation.js';
+import { analyzeDefinitions } from '../analysis/class.js';
+import { deepFreeze } from '../canonical/freeze.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { canonicalizeCallable } from '../normalization/domain.js';
+import { lookupForDomainClosure } from '../resolution/closure.js';
+import { buildDomainResolutionContext } from '../resolution/context.js';
+import { callableValidation } from '../resolution/domain.js';
+import { createDomainValueSchemaRegistry } from '../resolution/value.registry.js';
+import { validateContract } from '../validation/callable.js';
+import { parseCallableContract } from '../validation/domain.structure.js';
+import { validateCheckBudget } from '../validation/policy/budgets.js';
+import { PolicyValidationContext } from '../validation/policy/context.js';
+import { validatePolicyReferences } from '../validation/policy/references.js';
+import { validateContractPolicy } from '../validation/policy/uses.js';
+// An accepted DomainSchema is immutable and retains its closure, so its environment is reusable.
+const environments = new WeakMap();
+/**
+ * Accept one callable contract in the exact environment of its owner Domain, by the one validation
+ * every contract passes wherever it is declared (`validateContract`, `validateContractPolicy`,
+ * `validateCheckBudget`): the structure of a Function declaration without `ref`, its value schemas
+ * against the owner registry, its execution modifier and admission age, and its Policy with the
+ * budget of its checks. `receiver` is the owner Node Class whose Node receives the call and which
+ * the Policy names `self`: the Class of a Function instance, whose Node carries the contract, or
+ * the owner of an instance Method. Without it, as at a Function declaration, the Policy names none.
+ * Returns the canonical definition and its validators.
+ */
+export function acceptCallable(input, owner, options = {}) {
+    let value;
+    try {
+        value = acceptJsonValue(input);
+    }
+    catch (error) {
+        if (error instanceof JsonBoundaryError) {
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
+        }
+        throw error;
+    }
+    const callable = parseCallableContract(value);
+    const environment = ownerEnvironment(owner);
+    const { receiver } = options;
+    if (receiver !== undefined) {
+        const resolved = environment.resolution.resolve(receiver);
+        if (resolved === undefined ||
+            resolved.ref.kind !== 'class' ||
+            resolved.kind !== 'node' ||
+            definitionRefIndex(resolved.ref) !== definitionRefIndex(receiver) ||
+            receiver.origin !== owner.origin) {
+            throw new SchemaError([
+                diagnostic('DV_REF_RESOLVES', '', 'A receiver must be a Node Class of the owner Domain.'),
+            ]);
+        }
+    }
+    const issues = [];
+    validateContract(callable, '', environment.registry, issues);
+    if (typeof callable.policy === 'object') {
+        const policies = new PolicyValidationContext(environment.resolution, environment.analysis);
+        // Normalizes the owner's named Policies, which the Policy's checks are typed against.
+        validatePolicyReferences(policies);
+        validateContractPolicy(policies, new PolicyTyping(policies), callable, '', receiver);
+        // A document measures its own check trees (`validatePolicyBudgets`); this one is in none.
+        validateCheckBudget(policies, '/policy', measureChecks(normalizePolicyChecks(callable.policy)));
+        issues.push(...policies.diagnostics);
+    }
+    if (issues.length > 0)
+        throw new SchemaError(issues);
+    const definition = deepFreeze(canonicalizeCallable(callable));
+    const validation = callableValidation(isBinaryInput(definition.input) ? definition.input.metadata : definition.input, definition.output.mode === 'binary'
+        ? undefined
+        : definition.output.mode === 'value'
+            ? definition.output.schema
+            : definition.output.item, environment.registry, 
+    // Patterns live with these validators: carried contracts never grow a process-wide pool.
+    new Map());
+    return Object.freeze({ ...validation, definition });
+}
+function ownerEnvironment(owner) {
+    const cached = environments.get(owner);
+    if (cached !== undefined)
+        return cached;
+    const lookup = lookupForDomainClosure(owner);
+    const resolution = buildDomainResolutionContext(owner, lookup);
+    const environment = Object.freeze({
+        resolution,
+        analysis: analyzeDefinitions(resolution),
+        registry: createDomainValueSchemaRegistry(owner, lookup),
+    });
+    environments.set(owner, environment);
+    return environment;
+}

package/dist/v1/schema/index.d.ts

@@ -9,6 +9,8 @@ export interface Resolve {
 export declare const resolve: Resolve;
 export type { SchemaDiagnosticCode as DiagnosticCode } from './diagnostic.js';
 export { acceptDomainSchema as accept } from './admission/accept.js';
+export { acceptCallable } from './admission/callable.js';
+export type { AcceptedCallable } from './admission/callable.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
 export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint } from './compatibility/index.js';
@@ -22,6 +24,11 @@ export { SchemaError as Error } from './diagnostic.js';
 export type { SchemaDiagnostic as Diagnostic } from './diagnostic.js';
 export { RULES } from './rule.js';
 export type { SchemaRule as Rule, SchemaRuleStage as RuleStage } from './rule.js';
+export { limits } from '../language/limits.js';
+export type { LimitKey } from '../language/limits.js';
+export { measurePolicies } from './validation/policy/budgets.js';
+export type { PolicyMeasures } from './validation/policy/budgets.js';
+export type { CheckMeasure, PolicyMeasure } from '../language/policy/analysis/budgets.js';
 export type { DomainSchemaLookup as Lookup } from './dependency/lookup.js';
 export type { DomainSchemaHeader as Header } from './codec/header.js';
 export type { DomainDependency } from '../addressing/index.js';

package/dist/v1/schema/index.js

@@ -2,6 +2,7 @@
 import { resolve as resolveDomainSchema } from './resolution/domain.js';
 export const resolve = resolveDomainSchema;
 export { acceptDomainSchema as accept } from './admission/accept.js';
+export { acceptCallable } from './admission/callable.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
 export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint } from './compatibility/index.js';
@@ -11,5 +12,7 @@ export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/form
 export { compile, load } from '../compiled/index.js';
 export { SchemaError as Error } from './diagnostic.js';
 export { RULES } from './rule.js';
+export { limits } from '../language/limits.js';
+export { measurePolicies } from './validation/policy/budgets.js';
 /** The versioned value-schema grammar embedded in declarations. */
 export * as values from './validation/value-api.js';

package/dist/v1/schema/normalization/domain.d.ts

@@ -1,2 +1,4 @@
+import type { CallableDefinition } from '../../language/callable/model/callable.js';
 import type { DomainSchemaIR } from '../model/schema.js';
 export declare function normalizeDomainSchema(schema: DomainSchemaIR): DomainSchemaIR;
+export declare function canonicalizeCallable(value: CallableDefinition): CallableDefinition;

package/dist/v1/schema/normalization/domain.js

@@ -118,7 +118,7 @@ function canonicalizeFunction(value) {
         ...canonicalizeCallable(value),
     };
 }
-function canonicalizeCallable(value) {
+export function canonicalizeCallable(value) {
     const base = {
         ...withDescription(value),
         input: isBinaryInput(value.input)

package/dist/v1/schema/resolution/context.js

@@ -1,6 +1,6 @@
-import { dependencyLimits } from '../../addressing/domain-dependency.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { DOMAIN_REVISION_PATTERN } from '../../addressing/patterns.js';
+import { limits } from '../../language/limits.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { diagnostic } from '../diagnostic.js';
@@ -11,8 +11,8 @@ export function buildDomainResolutionContext(candidate, lookup) {
     const dependencies = new Map();
     const definitions = new Map();
     const directOrigins = new Set();
-    if (Object.keys(candidate.dependencies).length > dependencyLimits.direct) {
-        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
+    if (Object.keys(candidate.dependencies).length > limits.dependency.direct) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A Domain may declare at most ${limits.dependency.direct} direct dependency aliases.`));
     }
     for (const [alias, dependency] of Object.entries(candidate.dependencies)) {
         const pointer = `/dependencies/${escapePointerToken(alias)}`;
@@ -121,16 +121,16 @@ function loadDependencyClosure(candidate, dependencies, lookup, diagnostics) {
             continue;
         }
         dependencies.set(nested.origin, nested);
-        if (dependencies.size + 1 > dependencyLimits.closure) {
+        if (dependencies.size + 1 > limits.dependency.closure) {
             if (!closureLimitReported) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A dependency closure may contain at most ${dependencyLimits.closure} Domains.`));
+                diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A dependency closure may contain at most ${limits.dependency.closure} Domains.`));
                 closureLimitReported = true;
             }
             continue;
         }
         const depth = frame.depth + 1;
-        if (depth > dependencyLimits.depth) {
-            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', pointer, `Dependency depth ${depth} exceeds the maximum ${dependencyLimits.depth}.`));
+        if (depth > limits.dependency.depth) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', pointer, `Dependency depth ${depth} exceeds the maximum ${limits.dependency.depth}.`));
             continue;
         }
         const key = `${dependency.origin}\u0000${dependency.revision}`;

package/dist/v1/schema/resolution/domain.d.ts

@@ -1,7 +1,12 @@
 import type { SourceDomain } from '../../domain/model/domain.js';
+import type { CallableValidation } from '../../domain/validation/create.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
 import type { DomainSchema } from '../model/schema.js';
+import { type PatternPool } from '../../language/value/evaluate/preparation.js';
 /**
  * Resolve one accepted Schema through its exact retained source closure. Acceptance validated it
  * against that closure, which is the only way a Schema retains one, so it is not validated again.
  */
 export declare function resolve<const S extends DomainSchema>(schema: S): SourceDomain<S>;
+export declare function callableValidation(input: JsonSchema, output: JsonSchema | undefined, registry: ValueSchemaRegistry, patterns: PatternPool): CallableValidation;

package/dist/v1/schema/resolution/domain.js

@@ -88,7 +88,7 @@ function sourceValidation(closure, registries) {
     }
     return createDomainValidation(properties, callables);
 }
-function callableValidation(input, output, registry, patterns) {
+export function callableValidation(input, output, registry, patterns) {
     const prepared = prepareValueSchema(input, registry, '', patterns);
     if (!prepared.compiled) {
         throw new TypeError(`Accepted callable input cannot be prepared: ${prepared.message}`);

package/dist/v1/schema/rule.d.ts

@@ -1,4 +1,5 @@
 import type { SchemaDiagnosticCode } from './diagnostic.js';
+import { type LimitKey } from '../language/limits.js';
 /**
  * What a rule reads to decide. `structure`: the shape of the document alone. `rule`: the whole
  * document. `context`: the document and its environment, so one document can be accepted in one
@@ -21,6 +22,14 @@ export interface SchemaRule {
     readonly statement: string;
     /** What the feature the rule guards enforces on data or on calls, where it enforces something. */
     readonly enforces?: string;
+    /** The limits of `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, `#/$defs/edge-class/if`, whose failure
+     * refuses a document with this rule's code.
+     */
+    readonly conditions?: readonly [string, ...string[]];
 }
 /**
  * Every Schema diagnostic code with the rule it reports. A code added to the DSL does not compile