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

package/dist/v1/schema/validation/json.json-schema.d.ts

@@ -0,0 +1,24 @@
+import type { core as zodCore } from 'zod';
+type JsonSchema = zodCore.JSONSchema.JSONSchema;
+/**
+ * The check that a document is portable JSON, which `schema.decode` and `schema.accept` make first.
+ * JSON Schema reads a parsed value and compares numbers by their value: it states that no string or
+ * member name holds U+0000, and cannot state negative zero, a lone surrogate, a UTF-8 size, a
+ * nesting depth without one definition per level, a count of members, or what the text was.
+ */
+export declare const jsonValueRules: {
+    readonly 'portable-json': {
+        readonly code: 'DV_JSON_VALUE';
+        readonly statement: string;
+    };
+};
+export type JsonValueRule = keyof typeof jsonValueRules;
+/**
+ * Portable JSON in JSON Schema: `root` constrains the whole document, and `definitions` holds every
+ * value it reaches and every string. The named check leaves `x-astrale-rule` on `portable-json`.
+ */
+export declare function jsonValueJsonSchema(): {
+    readonly root: JsonSchema;
+    readonly definitions: Readonly<Record<string, JsonSchema>>;
+};
+export {};

package/dist/v1/schema/validation/json.json-schema.js

@@ -0,0 +1,36 @@
+import { RULES } from '../rule.js';
+/**
+ * The check that a document is portable JSON, which `schema.decode` and `schema.accept` make first.
+ * JSON Schema reads a parsed value and compares numbers by their value: it states that no string or
+ * member name holds U+0000, and cannot state negative zero, a lone surrogate, a UTF-8 size, a
+ * nesting depth without one definition per level, a count of members, or what the text was.
+ */
+export const jsonValueRules = {
+    'portable-json': { code: 'DV_JSON_VALUE', statement: RULES.DV_JSON_VALUE.statement },
+};
+const VALUE = '#/$defs/portable-json';
+const TEXT = '#/$defs/portable-string';
+/**
+ * Portable JSON in JSON Schema: `root` constrains the whole document, and `definitions` holds every
+ * value it reaches and every string. The named check leaves `x-astrale-rule` on `portable-json`.
+ */
+export function jsonValueJsonSchema() {
+    return {
+        root: { $ref: VALUE },
+        definitions: {
+            'portable-json': {
+                anyOf: [
+                    { type: 'null' },
+                    { type: 'boolean' },
+                    { type: 'number' },
+                    { $ref: TEXT },
+                    { type: 'array', items: { $ref: VALUE } },
+                    { type: 'object', propertyNames: { $ref: TEXT }, additionalProperties: { $ref: VALUE } },
+                ],
+                'x-astrale-rule': 'portable-json',
+            },
+            // The pattern is the character itself, which every regular-expression dialect reads.
+            'portable-string': { type: 'string', not: { pattern: '\u0000' } },
+        },
+    };
+}

package/dist/v1/schema/validation/policy/budgets.d.ts

@@ -1,4 +1,35 @@
+import type { PolicyExpression } from '../../../language/policy/model/policy.js';
+import type { DomainSchemaIR } from '../../model/schema.js';
 import type { PolicyValidationContext } from './context.js';
-import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks } from '../../../language/policy/analysis/budgets.js';
-export { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, };
+import { type CheckMeasure, type PolicyMeasure } from '../../../language/policy/analysis/budgets.js';
+/** What `PL_BUDGET` compares with `limits.policy` in one document, frozen. */
+export interface PolicyMeasures {
+    /** Each named Policy the DSL can measure, by name. */
+    readonly policies: Readonly<Record<string, PolicyMeasure>>;
+    /**
+     * The named Policies the DSL cannot measure, in document order: a composition that reaches
+     * itself, or that names a Policy the document does not declare or one it cannot measure.
+     */
+    readonly unmeasured: readonly string[];
+    /**
+     * Each check tree by the JSON Pointer of its position: the Policy of a Function or a Method, or
+     * the read or traverse rule of a Node Class.
+     */
+    readonly checks: Readonly<Record<string, CheckMeasure>>;
+}
+/**
+ * Measure the Policies of a document as `PL_BUDGET` does: it reads the document's structure alone,
+ * so a document the structure admits is measured whatever its other rules decide. Throws
+ * `SchemaError` with the diagnostics of a document that is not portable JSON or that its
+ * structure refuses.
+ */
+export declare function measurePolicies(input: unknown): PolicyMeasures;
+/** The measures of one structured document, from its Policies once normalized. */
+export declare function measureDomainPolicies(schema: DomainSchemaIR, normalized?: ReadonlyMap<string, PolicyExpression>): PolicyMeasures;
+/** `PL_BUDGET`: every measure of the document within `limits.policy`. */
 export declare function validatePolicyBudgets(context: PolicyValidationContext): void;
+/**
+ * `PL_BUDGET` for one check tree at `pointer`, from its measure: the document's trees, and the
+ * checks of a contract a Node carries, which no document holds.
+ */
+export declare function validateCheckBudget(context: PolicyValidationContext, pointer: string, measure: CheckMeasure): void;

package/dist/v1/schema/validation/policy/budgets.js

@@ -1,25 +1,98 @@
-import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, policyMeasurer, } from '../../../language/policy/analysis/budgets.js';
+import { limits } from '../../../language/limits.js';
+import { exceededLimits, measureChecks, policyMeasurer, } from '../../../language/policy/analysis/budgets.js';
+import { isClassRuleChecks } from '../../../language/policy/model/policy.js';
+import { normalizePolicyChecks, normalizePolicyExpression, } from '../../../language/policy/normalization/normalize.js';
 import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
-export { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, };
-export function validatePolicyBudgets(context) {
-    const measurePolicy = policyMeasurer(context.environment.candidate.origin, context.normalized, (ref) => context.isLocalPolicy(ref));
-    for (const name of Object.keys(context.environment.candidate.policies)) {
+import { deepFreeze } from '../../canonical/freeze.js';
+import { structureDomainSchema } from '../domain.route.js';
+import { SITE } from './uses.js';
+/**
+ * Measure the Policies of a document as `PL_BUDGET` does: it reads the document's structure alone,
+ * so a document the structure admits is measured whatever its other rules decide. Throws
+ * `SchemaError` with the diagnostics of a document that is not portable JSON or that its
+ * structure refuses.
+ */
+export function measurePolicies(input) {
+    return measureDomainPolicies(structureDomainSchema(input));
+}
+/** The measures of one structured document, from its Policies once normalized. */
+export function measureDomainPolicies(schema, normalized = normalizedPolicies(schema)) {
+    const measurePolicy = policyMeasurer(schema.origin, normalized, (ref) => ref.origin === schema.origin &&
+        ref.kind === 'policy' &&
+        Object.hasOwn(schema.policies, ref.name));
+    const policies = {};
+    const unmeasured = [];
+    for (const name of Object.keys(schema.policies)) {
         const measure = measurePolicy(name);
         if (measure === undefined)
-            continue;
-        const pointer = `/policies/${escapePointerToken(name)}`;
-        if (measure.depth > MAX_PATTERN_DEPTH) {
-            context.add('PL_BUDGET', pointer, `Expanded Pattern depth ${measure.depth} exceeds ${MAX_PATTERN_DEPTH}.`);
+            unmeasured.push(name);
+        else
+            policies[name] = measure;
+    }
+    const checks = {};
+    for (const [pointer, expression] of checkTrees(schema)) {
+        checks[pointer] = measureChecks(normalizePolicyChecks(expression));
+    }
+    return deepFreeze({ policies, unmeasured, checks });
+}
+/** `PL_BUDGET`: every measure of the document within `limits.policy`. */
+export function validatePolicyBudgets(context) {
+    const measures = measureDomainPolicies(context.environment.candidate, context.normalized);
+    for (const [name, measure] of Object.entries(measures.policies)) {
+        for (const limit of exceededLimits(measure)) {
+            context.add('PL_BUDGET', `/policies/${escapePointerToken(name)}`, REFUSAL[limit](measure));
         }
-        if (measure.edgeCounts.length > MAX_BRANCHES) {
-            context.add('PL_BUDGET', pointer, `Expanded Pattern has more than ${MAX_BRANCHES} normalized branches.`);
+    }
+    for (const [pointer, measure] of Object.entries(measures.checks)) {
+        validateCheckBudget(context, pointer, measure);
+    }
+}
+/**
+ * `PL_BUDGET` for one check tree at `pointer`, from its measure: the document's trees, and the
+ * checks of a contract a Node carries, which no document holds.
+ */
+export function validateCheckBudget(context, pointer, measure) {
+    if (exceededLimits(measure).length === 0)
+        return;
+    const { checkDepth, checkBranches, checkLeaves } = limits.policy;
+    // A callable holds its checks at `policy`; a Node Class rule at `policies/{operation}`.
+    const site = SITE[pointer.endsWith('/policy') ? 'callable' : 'class'];
+    context.add('PL_BUDGET', pointer, `${site.checks} require depth <= ${checkDepth}, branches <= ${checkBranches}, and leaves <= ${checkLeaves}; got ${measure.checkDepth}, ${measure.checkBranches}, ${measure.checkLeaves}.`);
+}
+/** How `PL_BUDGET` explains each limit a named Policy exceeds. */
+const REFUSAL = {
+    patternDepth: (measure) => `Expanded Pattern depth ${measure.patternDepth} exceeds ${limits.policy.patternDepth}.`,
+    normalizedBranches: () => `Expanded Pattern has more than ${limits.policy.normalizedBranches} normalized branches.`,
+    edgePredicates: (measure) => `A normalized branch contains ${measure.edgePredicates} graph predicates; the maximum is ${limits.policy.edgePredicates}.`,
+    referencedDomains: (measure) => `Expanded Pattern references ${measure.referencedDomains} Domains; the maximum is ${limits.policy.referencedDomains}.`,
+};
+function normalizedPolicies(schema) {
+    return new Map(Object.entries(schema.policies).map(([name, declaration]) => [
+        name,
+        normalizePolicyExpression(declaration.expression),
+    ]));
+}
+/** Every check tree of a document with the pointer of its position, in document order. */
+function* checkTrees(schema) {
+    for (const [name, declaration] of Object.entries(schema.classes)) {
+        const owner = `/classes/${escapePointerToken(name)}`;
+        for (const operation of ['read', 'traverse']) {
+            const rule = declaration.policies[operation];
+            if (typeof rule === 'object' && isClassRuleChecks(rule)) {
+                yield [`${owner}/policies/${operation}`, rule];
+            }
         }
-        const edgeMaximum = Math.max(0, ...measure.edgeCounts);
-        if (edgeMaximum > MAX_EDGES) {
-            context.add('PL_BUDGET', pointer, `A normalized branch contains ${edgeMaximum} graph predicates; the maximum is ${MAX_EDGES}.`);
+        if (declaration.kind !== 'node')
+            continue;
+        for (const [method, value] of Object.entries(declaration.methods)) {
+            if (typeof value.policy === 'object') {
+                yield [`${owner}/methods/${escapePointerToken(method)}/policy`, value.policy];
+            }
         }
-        if (measure.domains.size > MAX_DOMAINS) {
-            context.add('PL_BUDGET', pointer, `Expanded Pattern references ${measure.domains.size} Domains; the maximum is ${MAX_DOMAINS}.`);
+    }
+    for (const [name, declaration] of Object.entries(schema.functions)) {
+        if (typeof declaration.policy === 'object') {
+            yield [`/functions/${escapePointerToken(name)}/policy`, declaration.policy];
         }
     }
 }

package/dist/v1/schema/validation/policy/references.js

@@ -3,7 +3,6 @@ import { branchesOf, isConnected, targetMode } from '../../../language/policy/an
 import { policyVariableClass } from '../../../language/policy/model/policy.js';
 import { normalizePolicyExpression, normalizePolicyPattern, } from '../../../language/policy/normalization/normalize.js';
 import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
-import { MAX_REPEAT, MAX_VARIABLES } from './budgets.js';
 import { referenceContracts } from './objects.js';
 export function validatePolicyReferences(context) {
     for (const [name, declaration] of Object.entries(context.environment.candidate.policies)) {
@@ -15,9 +14,9 @@ export function validatePolicyReferences(context) {
         const expression = declaration.expression;
         context.normalized.set(name, normalizePolicyExpression(expression));
         if ('match' in expression)
-            validateMatch(context, name, expression.match, pointer);
+            validateMatch(context, name, expression.match, `${pointer}/expression`);
         else
-            validateComposition(context, expression, pointer);
+            validateComposition(context, expression, `${pointer}/expression`);
     }
     validateCycles(context);
 }
@@ -53,22 +52,14 @@ function validatePatternNode(context, pattern, pointer, scope, declarations, use
         context.resolveEdge(pattern.class, `${pointer}/class`);
         validateTerm(context, pattern.source, `${pointer}/source`, scope, uses);
         validateTerm(context, pattern.target, `${pointer}/target`, scope, uses);
-        if (pattern.repeat !== undefined) {
-            const { min, max } = pattern.repeat;
-            if (!Number.isInteger(min) ||
-                !Number.isInteger(max) ||
-                min < 0 ||
-                max < min ||
-                max > MAX_REPEAT) {
-                context.add('PL_REPEAT', `${pointer}/repeat`, `Repeat requires integral bounds 0 <= min <= max <= ${MAX_REPEAT}.`);
-            }
+        // The structure bounds each to an integer from 0 to `limits.policy.repetition`; only their
+        // order is left.
+        if (pattern.repeat !== undefined && pattern.repeat.max < pattern.repeat.min) {
+            context.add('PL_REPEAT', `${pointer}/repeat`, 'Repeat requires min <= max.');
         }
         return;
     }
     if ('exists' in pattern) {
-        if (pattern.exists.nodes.length > MAX_VARIABLES) {
-            context.add('PL_BUDGET', `${pointer}/exists/nodes`, `An exists expression declares ${pattern.exists.nodes.length} variables; the maximum is ${MAX_VARIABLES}.`);
-        }
         const nested = new Set(scope);
         for (const [index, node] of pattern.exists.nodes.entries()) {
             const id = node.variable.id;
@@ -92,9 +83,6 @@ function validatePatternNode(context, pattern, pointer, scope, declarations, use
         return;
     }
     const { key, values } = patternOperands(pattern);
-    if (values.length === 0) {
-        context.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
-    }
     values.forEach((child, index) => validatePatternNode(context, child, `${pointer}/${key}/${index}`, scope, declarations, uses));
 }
 function validateTerm(context, term, pointer, scope, uses) {
@@ -112,9 +100,6 @@ function validateTerm(context, term, pointer, scope, uses) {
 function validateComposition(context, declaration, pointer) {
     const key = 'allOf' in declaration ? 'allOf' : 'anyOf';
     const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
-    if (refs.length === 0) {
-        context.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
-    }
     refs.forEach((ref, index) => context.resolvePolicy(ref, `${pointer}/${key}/${index}`));
 }
 function validateCycles(context) {

package/dist/v1/schema/validation/policy/uses.d.ts

@@ -1,5 +1,34 @@
+import type { CallableDefinition } from '../../../language/callable/model/callable.js';
 import type { PolicyTyping } from '../../../language/policy/analysis/typing.js';
+import type { PolicyCheckExpression } from '../../../language/policy/model/policy.js';
+import type { JsonSchema } from '../../../language/value/model/schema.js';
 import type { PolicyValidationContext } from './context.js';
+import { type ClassRef } from '../../../addressing/index.js';
+interface CheckContext {
+    readonly site: keyof typeof SITE;
+    readonly pointer: string;
+    readonly input: JsonSchema;
+    /** The Node Class that receives the call, which the checks name `self`; none, and none is named. */
+    readonly receiver?: ClassRef;
+}
+/** How a refusal names the checks of each site and the contract of their objects. */
+export declare const SITE: {
+    readonly callable: {
+        readonly checks: 'Callable checks';
+        readonly objects: 'the callable object contract';
+    };
+    readonly class: {
+        readonly checks: 'Class rule checks';
+        readonly objects: 'the Class rule object contract';
+    };
+};
 export declare function validateReadUses(context: PolicyValidationContext, typing: PolicyTyping): void;
 export declare function validateTraverseUses(context: PolicyValidationContext, typing: PolicyTyping): void;
 export declare function validateCallableUses(context: PolicyValidationContext, typing: PolicyTyping): void;
+/**
+ * Validate the Policy of one callable contract written at `pointer`, wherever it is declared:
+ * `self` names the Node of the `receiver` Class, and nothing where the call has no receiver.
+ */
+export declare function validateContractPolicy(context: PolicyValidationContext, typing: PolicyTyping, contract: CallableDefinition, pointer: string, receiver: ClassRef | undefined): void;
+export declare function validateChecks(validation: PolicyValidationContext, typing: PolicyTyping, expression: PolicyCheckExpression, context: CheckContext): void;
+export {};

package/dist/v1/schema/validation/policy/uses.js

@@ -6,12 +6,12 @@ import { checksNameTheCaller, isClassRuleChecks } from '../../../language/policy
 import { normalizePolicyChecks } from '../../../language/policy/normalization/normalize.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../../language/value/syntax/node-path/schema.js';
 import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
-import { MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, measureChecks } from './budgets.js';
+import { declaredContracts } from '../callable.js';
 import { referenceContracts } from './objects.js';
 import { contractOfNodeDefinition } from './typing.js';
 const formatDefinitionRef = Key.of;
 /** How a refusal names the checks of each site and the contract of their objects. */
-const SITE = {
+export const SITE = {
     callable: { checks: 'Callable checks', objects: 'the callable object contract' },
     class: { checks: 'Class rule checks', objects: 'the Class rule object contract' },
 };
@@ -34,7 +34,6 @@ function validateClassPolicyUses(context, typing, operation) {
                 pointer,
                 input: {},
                 receiver: { origin: context.environment.candidate.origin, kind: 'class', name },
-                instanceMethod: true,
             });
             continue;
         }
@@ -56,58 +55,39 @@ function validateClassPolicyUses(context, typing, operation) {
     }
 }
 export function validateCallableUses(context, typing) {
-    for (const [name, declaration] of Object.entries(context.environment.candidate.functions)) {
-        if (typeof declaration.policy !== 'object')
-            continue;
-        validateChecks(context, typing, declaration.policy, {
-            site: 'callable',
-            pointer: `/functions/${escapePointerToken(name)}/policy`,
-            input: isBinaryInput(declaration.input) ? declaration.input.metadata : declaration.input,
-            instanceMethod: false,
-        });
-    }
-    for (const [name, declaration] of Object.entries(context.environment.candidate.classes)) {
-        if (declaration.kind !== 'node')
-            continue;
-        validateDeclaredMethods(context, typing, 'classes', name, declaration.methods, {
-            origin: context.environment.candidate.origin,
-            kind: 'class',
-            name,
-        });
+    for (const { contract, pointer, receiver, method } of declaredContracts(context.environment.candidate)) {
+        // Definition analysis is the authority for the effective callable. A missing Method is already
+        // a definition diagnostic, so avoid inventing a second Policy interpretation for it.
+        if (method !== undefined) {
+            const owner = context.analysis.definitions.get(definitionRefIndex(method.owner));
+            if (owner !== undefined && !owner.methods.has(method.name))
+                continue;
+        }
+        validateContractPolicy(context, typing, contract, pointer, receiver);
     }
 }
-function validateDeclaredMethods(context, typing, namespace, name, methods, receiver) {
-    const ownerAnalysis = context.analysis.definitions.get(definitionRefIndex(receiver));
-    for (const [methodName, method] of Object.entries(methods)) {
-        if (typeof method.policy !== 'object')
-            continue;
-        // Definition analysis is the authority for the effective callable. A
-        // missing entry is already a definition diagnostic, so avoid inventing a
-        // second Policy interpretation for it.
-        if (ownerAnalysis !== undefined && !ownerAnalysis.methods.has(methodName))
-            continue;
-        validateChecks(context, typing, method.policy, {
-            site: 'callable',
-            pointer: `/${namespace}/${escapePointerToken(name)}/methods/${escapePointerToken(methodName)}/policy`,
-            input: method.input,
-            receiver,
-            instanceMethod: !method.static,
-        });
-    }
+/**
+ * Validate the Policy of one callable contract written at `pointer`, wherever it is declared:
+ * `self` names the Node of the `receiver` Class, and nothing where the call has no receiver.
+ */
+export function validateContractPolicy(context, typing, contract, pointer, receiver) {
+    if (typeof contract.policy !== 'object')
+        return;
+    validateChecks(context, typing, contract.policy, {
+        site: 'callable',
+        pointer: `${pointer}/policy`,
+        input: isBinaryInput(contract.input) ? contract.input.metadata : contract.input,
+        ...(receiver === undefined ? {} : { receiver }),
+    });
 }
-function validateChecks(validation, typing, expression, context) {
+export function validateChecks(validation, typing, expression, context) {
     // Checks decide the caller the way a named Policy does, so, as a Policy connects its subject,
     // each way they hold must pass through a check of the caller.
     if (!checksNameTheCaller(expression)) {
         validation.add('PL_CONNECTIVITY', context.pointer, `${SITE[context.site].checks} must check a Policy on every branch: sameNode alone names no caller.`);
     }
+    // Their budget is checked with the named Policies', from the same measure (`budgets.ts`).
     const normalized = normalizePolicyChecks(expression);
-    const measure = measureChecks(normalized);
-    if (measure.depth > MAX_CHECK_DEPTH ||
-        measure.branches > MAX_BRANCHES ||
-        measure.leaves > MAX_CHECK_LEAVES) {
-        validation.add('PL_BUDGET', context.pointer, `${SITE[context.site].checks} require depth <= ${MAX_CHECK_DEPTH}, branches <= ${MAX_BRANCHES}, and leaves <= ${MAX_CHECK_LEAVES}; got ${measure.depth}, ${measure.branches}, ${measure.leaves}.`);
-    }
     const leaves = new Map();
     visitChecks(validation, typing, normalized, context, context.pointer, leaves);
     for (const [object, className] of neverAdmittedClasses(normalized, leaves)) {
@@ -147,14 +127,11 @@ function visitChecks(validation, typing, expression, context, pointer, leaves) {
         return;
     }
     const { key, values } = checkOperands(expression);
-    if (values.length === 0) {
-        validation.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
-    }
     values.forEach((child, index) => visitChecks(validation, typing, child, context, `${pointer}/${key}/${index}`, leaves));
 }
 function selfContracts(validation, context, pointer) {
-    if (!context.instanceMethod || context.receiver === undefined) {
-        validation.add('PL_USE', pointer, 'self is valid only for a Node instance Method.');
+    if (context.receiver === undefined) {
+        validation.add('PL_USE', pointer, 'self is valid only where a Node receives the call: a Node instance Method, or a Function instance, whose Node carries the contract.');
         return undefined;
     }
     return [contractOfNodeDefinition(context.receiver)];

package/dist/v1/schema/validation/value-api.d.ts

@@ -10,11 +10,22 @@ export type { BlobOptions, BlobReceipt, BlobRef, BlobSchema, } from '../../langu
 export type { JsonSchema as Schema, JsonSchemaObject as SchemaObject, PathAnnotation, PropertyObjectSchema as PropertySchema, ValueSchemaContext as Context, } from '../../language/value/model/schema.js';
 export { instant } from '../../language/value/model/instant.js';
 export type { OrderingKind } from '../../language/value/ordering.js';
+export { DECLARED_VALUE_KINDS as DECLARED_KINDS, FORBIDDEN_KEYWORDS, SUBSCHEMA_KEYWORDS, VALUE_KEYWORDS as KEYWORDS, } from '../../language/value/profile/vocabulary.js';
+export type { DeclaredValueKind as DeclaredKind, ValueKeyword as Keyword, } from '../../language/value/profile/vocabulary.js';
+export { VALUE_RULES as RULES } from '../../language/validation/rule.js';
+export type { ValueRule as Rule, ValueRuleStage as RuleStage, } from '../../language/validation/rule.js';
 /** Validate one complete JSON value under the exact accepted schema that owns the contract. */
 export declare function validate(owner: DomainSchema, contract: JsonSchema, input: unknown, pointer?: string): readonly Diagnostic[];
 /** Return the one portable scalar ordering domain admitted by a property schema, if any. */
 export declare function classifyOrdering(owner: DomainSchema, contract: JsonSchema): OrderingKind | undefined;
-/** The value kind of a property schema: what a graph language may test on the property (Y4). */
+/**
+ * The value kind of a property schema: what a graph language may test on the property (Y4). It is
+ * the one kind of every non-null value the schema admits: `text` for strings, `number` for numbers
+ * and integers, `instant` for strings declared `x-astrale-value-kind: instant`, `enum` for a finite
+ * set of strings (`const` or `enum`), `boolean`, and `set` for arrays of `uniqueItems`. An
+ * ambiguous union, an object, an array with repetitions, a blob or a schema that admits no value is
+ * `json`. `$ref`, `allOf`, `anyOf` and `oneOf` are followed; `null` is a point of every kind.
+ */
 export declare function classifyValueKind(owner: DomainSchema, contract: JsonSchema): ValueKind;
 /**
  * A warning for each class property whose value kind is `json` (an ambiguous union, an object, an

package/dist/v1/schema/validation/value-api.js

@@ -8,6 +8,8 @@ const registries = new WeakMap();
 export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
 export { blob, isBlobValueSchema as isBlob } from '../../language/value/model/blob.js';
 export { instant } from '../../language/value/model/instant.js';
+export { DECLARED_VALUE_KINDS as DECLARED_KINDS, FORBIDDEN_KEYWORDS, SUBSCHEMA_KEYWORDS, VALUE_KEYWORDS as KEYWORDS, } from '../../language/value/profile/vocabulary.js';
+export { VALUE_RULES as RULES } from '../../language/validation/rule.js';
 /** Validate one complete JSON value under the exact accepted schema that owns the contract. */
 export function validate(owner, contract, input, pointer = '') {
     return validateJsonInstance(contract, input, registryFor(owner), pointer);
@@ -16,7 +18,14 @@ export function validate(owner, contract, input, pointer = '') {
 export function classifyOrdering(owner, contract) {
     return classifyOrderingWithRegistry(contract, registryFor(owner));
 }
-/** The value kind of a property schema: what a graph language may test on the property (Y4). */
+/**
+ * The value kind of a property schema: what a graph language may test on the property (Y4). It is
+ * the one kind of every non-null value the schema admits: `text` for strings, `number` for numbers
+ * and integers, `instant` for strings declared `x-astrale-value-kind: instant`, `enum` for a finite
+ * set of strings (`const` or `enum`), `boolean`, and `set` for arrays of `uniqueItems`. An
+ * ambiguous union, an object, an array with repetitions, a blob or a schema that admits no value is
+ * `json`. `$ref`, `allOf`, `anyOf` and `oneOf` are followed; `null` is a point of every kind.
+ */
 export function classifyValueKind(owner, contract) {
     return classifyValueKindWithRegistry(contract, registryFor(owner));
 }

package/dist/v1/schema/validation/value.d.ts

@@ -1,4 +1,7 @@
+import type { CallableDefinition } from '../../language/callable/model/callable.js';
 import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainSchemaIR } from '../model/schema.js';
 export declare function validateEmbeddedValueSchemas(schema: DomainSchemaIR, registry: ValueSchemaRegistry): readonly SchemaDiagnostic[];
+/** Validate the value schemas of one callable contract at `pointer`. */
+export declare function validateCallable(declaration: CallableDefinition, pointer: string, registry: ValueSchemaRegistry, diagnostics: SchemaDiagnostic[]): void;

package/dist/v1/schema/validation/value.js

@@ -1,28 +1,22 @@
 import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { validateValueSchema } from '../../language/value/profile/validate.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
-import { diagnostic } from '../diagnostic.js';
+import { valueDiagnostic } from '../diagnostic.js';
 export function validateEmbeddedValueSchemas(schema, registry) {
     const diagnostics = [];
     for (const [name, declaration] of Object.entries(schema.classes)) {
         validateDefinition(declaration, `/classes/${escapePointerToken(name)}`, registry, diagnostics);
     }
-    for (const [name, declaration] of Object.entries(schema.functions)) {
-        validateCallable(declaration, `/functions/${escapePointerToken(name)}`, registry, diagnostics);
-    }
+    // Callable contracts are validated at their site, as one contract (`validateContracts`).
     return Object.freeze(diagnostics);
 }
 function validateDefinition(declaration, pointer, registry, diagnostics) {
     for (const [name, property] of Object.entries(declaration.properties)) {
         validate(property.schema, 'property-facet', `${pointer}/properties/${escapePointerToken(name)}/schema`, registry, diagnostics);
     }
-    if ('methods' in declaration) {
-        for (const [name, method] of Object.entries(declaration.methods)) {
-            validateCallable(method, `${pointer}/methods/${escapePointerToken(name)}`, registry, diagnostics);
-        }
-    }
 }
-function validateCallable(declaration, pointer, registry, diagnostics) {
+/** Validate the value schemas of one callable contract at `pointer`. */
+export function validateCallable(declaration, pointer, registry, diagnostics) {
     if (isBinaryInput(declaration.input)) {
         validate(declaration.input.metadata, 'callable-input', `${pointer}/input/metadata`, registry, diagnostics);
     }
@@ -37,7 +31,7 @@ function validateCallable(declaration, pointer, registry, diagnostics) {
     }
 }
 function validate(schema, context, pointer, registry, diagnostics) {
-    for (const failure of validateValueSchema(schema, context, registry, pointer)) {
-        diagnostics.push(diagnostic('DV_VALUE_SCHEMA', failure.pointer, `[${failure.code}] ${failure.message}`, failure.ref));
+    for (const refusal of validateValueSchema(schema, context, registry, pointer)) {
+        diagnostics.push(valueDiagnostic('DV_VALUE_SCHEMA', refusal));
     }
 }

package/dist/v1/schema/validation/value.json-schema.d.ts

@@ -0,0 +1,51 @@
+import type { core as zodCore } from 'zod';
+type JsonSchema = zodCore.JSONSchema.JSONSchema;
+/**
+ * The checks on value schemas JSON Schema cannot state, which the published document names with
+ * the positions it constrains. The Kernel reports each as `DV_VALUE_SCHEMA`, with its value code.
+ */
+export declare const valueSchemaRules: {
+    readonly 'value-blob': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_VALUE_KIND';
+        readonly statement: 'A blob is declared only by the whole schema of a Property, exactly as values.blob writes it.';
+    };
+    readonly 'value-path': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_PATH_EXTENSION';
+        readonly 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.';
+    };
+    readonly 'value-recursion': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_RECURSION_PRODUCTIVE';
+        readonly statement: 'Every reference cycle of a value schema crosses a keyword that steps into the value: to a member, a member name or an item.';
+    };
+    readonly 'value-reference-form': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_REFERENCE_FORM';
+        readonly statement: 'A $ref is a JSON Pointer fragment into its own value schema, or the id of the graph NodePath schema beside x-astrale-path.';
+    };
+    readonly 'value-reference-resolution': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_REFERENCE_RESOLUTION';
+        readonly 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.';
+    };
+    readonly 'value-regexp': {
+        readonly code: 'DV_VALUE_SCHEMA';
+        readonly valueCode: 'VS_REGEX_PORTABLE';
+        readonly statement: 'Every pattern, fullMatch and patternProperties name is an RFC 9485 I-Regexp within the regular-expression limits.';
+    };
+};
+export type ValueSchemaRule = keyof typeof valueSchemaRules;
+/**
+ * The value language in JSON Schema, for the document that embeds value schemas: `root` constrains
+ * the `value-schema` definition with the published dialect and what the profile adds to it,
+ * `definitions` holds the locations it reaches, and `nodeProperty` constrains a Node Property
+ * definition. A named check leaves `x-astrale-rule` at the positions it constrains.
+ */
+export declare function valueSchemaJsonSchema(): {
+    readonly root: readonly JsonSchema[];
+    readonly definitions: Readonly<Record<string, JsonSchema>>;
+    readonly nodeProperty: JsonSchema;
+};
+export {};