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

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/analysis/class.js

@@ -3,39 +3,48 @@ import { Key, PropertyKey } from '../../addressing/index.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { composeMethods } from '../../language/callable/composition.js';
 import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
 const formatDefinitionRef = Key.of;
 export function analyzeDefinitions(environment) {
     const diagnostics = [];
     const result = new Map();
     const visiting = new Set();
+    // A dependency was accepted against this same exact closure: a rule breaks here only at a Class
+    // of the candidate, or on an incomplete closure, which the dependency diagnostics report. An
+    // unresolved parent is reported where the candidate names it, by Class validation.
+    const reporter = (owner) => (code, at, message, ref) => {
+        if (owner.origin !== environment.candidate.origin)
+            return;
+        const pointer = `/classes/${escapePointerToken(owner.name)}${at}`;
+        diagnostics.push(diagnostic(code, pointer, message, ref));
+    };
     const analyze = (ref) => {
         const key = definitionRefIndex(ref);
         const cached = result.get(key);
         if (cached !== undefined)
             return cached;
-        if (visiting.has(key)) {
-            diagnostics.push(diagnostic('DV_CLASS_ACYCLIC', '', `Inheritance cycle reaches ${formatDefinitionRef(ref)}.`, formatDefinitionRef(ref)));
-            return undefined;
-        }
         const resolved = environment.resolveAny(ref);
         if (resolved === undefined)
             return undefined;
         visiting.add(key);
+        const report = reporter(ref);
         const declaration = resolved.declaration;
         const parents = declaration.extends;
-        const parentAnalyses = parents.flatMap((parent) => {
+        const parentAnalyses = parents.flatMap((parent, index) => {
             const target = environment.resolveAny(parent);
-            if (target === undefined) {
-                diagnostics.push(diagnostic('DV_REF_RESOLVES', '', `Inheritance ref ${formatDefinitionRef(parent)} does not resolve.`, formatDefinitionRef(parent)));
+            if (target?.ref.kind !== 'class')
+                return [];
+            if (visiting.has(definitionRefIndex(target.ref))) {
+                report('DV_CLASS_ACYCLIC', `/extends/${index}`, `Inheritance cycle reaches ${formatDefinitionRef(parent)}.`, formatDefinitionRef(parent));
                 return [];
             }
-            const analysis = target.ref.kind === 'class' ? analyze(target.ref) : undefined;
+            const analysis = analyze(target.ref);
             return analysis === undefined ? [] : [analysis];
         });
         const properties = mergeFields(parentAnalyses.map((parent) => parent.properties), ownFields(ref, declaration));
-        const data = mergeData(ref, declaration, parentAnalyses, diagnostics);
-        const methods = mergeMethods(ref, declaration, parentAnalyses, diagnostics);
+        const data = mergeData(ref, declaration, parentAnalyses, report);
+        const methods = mergeMethods(ref, declaration, parentAnalyses, report);
         const analysis = {
             ref,
             declaration,
@@ -82,7 +91,7 @@ function mergeFields(inherited, own) {
     }
     return result;
 }
-function mergeData(owner, declaration, parents, diagnostics) {
+function mergeData(owner, declaration, parents, report) {
     let effective;
     for (const parent of parents) {
         if (parent.data === undefined)
@@ -92,14 +101,15 @@ function mergeData(owner, declaration, parents, diagnostics) {
             continue;
         }
         if (effective.identity !== parent.data.identity) {
-            diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data has distinct declaring owners ${formatDefinitionRef(effective.owner)} and ${formatDefinitionRef(parent.data.owner)}.`));
+            const index = declaration.extends.findIndex((ref) => definitionRefIndex(ref) === definitionRefIndex(parent.ref));
+            report('DV_DATA_COMPOSITION', `/extends/${index}`, `Data has distinct declaring owners ${formatDefinitionRef(effective.owner)} and ${formatDefinitionRef(parent.data.owner)}.`);
         }
     }
     const own = 'data' in declaration ? declaration.data : undefined;
     if (own === undefined)
         return effective;
     if (effective !== undefined) {
-        diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data redeclares the inherited contract from ${formatDefinitionRef(effective.owner)}.`));
+        report('DV_DATA_COMPOSITION', '/data', `Data redeclares the inherited contract from ${formatDefinitionRef(effective.owner)}.`);
     }
     return {
         identity: `${definitionRefIndex(owner)}\u0000data`,
@@ -107,12 +117,20 @@ function mergeData(owner, declaration, parents, diagnostics) {
         declaration: own,
     };
 }
-function mergeMethods(owner, declaration, parents, diagnostics) {
+function mergeMethods(owner, declaration, parents, report) {
     const own = new Map(Object.entries('methods' in declaration ? declaration.methods : {}).map(([name, method]) => [
         name,
         { key: `${Key.of(owner)}.method.${name}`, owner, name, declaration: method },
     ]));
-    return composeMethods(parents, own, declaration.abstract, (left, right) => sameMethodSignature(left.declaration, right.declaration), (message) => diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', message, Key.of(owner))));
+    return composeMethods(parents, own, declaration.abstract, (left, right) => sameMethodSignature(left.declaration, right.declaration), 
+    // A changed signature is the local Method's; an ambiguous or missing one needs a local Method.
+    (message, issue) => {
+        const local = issue.kind === 'signature'
+            ? [...own.values()].find(({ key }) => key === issue.local)
+            : undefined;
+        const at = local === undefined ? '/methods' : `/methods/${escapePointerToken(local.name)}`;
+        report('DV_METHOD_COMPOSITION', at, message, Key.of(owner));
+    });
 }
 /** The exact signature required by abstract Method composition. */
 export function sameMethodSignature(left, right) {

package/dist/v1/schema/compatibility/api.d.ts

@@ -1,4 +1,4 @@
 export { compare, compareMeaning, compareStructure } from './compare.js';
 export { closedParents } from './extension.js';
 export { requiredBump } from './versioning/index.js';
-export type { Analysis, Assessment, Bump, Comparison, ComparisonEntry, ComparisonEvidence, ComparisonRequest, ComparisonScope, Facet, Fingerprint, MeaningComparison, Observation, RequiredBump, SchemaIdentity, StructureComparison, Subject, Usage, VersionChange, } from './model.js';
+export type { Analysis, Assessment, Bump, Comparison, ComparisonEntry, ComparisonEvidence, ComparisonRequest, ComparisonScope, DiagnosticCode, Facet, Fingerprint, MeaningComparison, Observation, RequiredBump, SchemaIdentity, StructureComparison, Subject, Usage, VersionChange, } from './model.js';

package/dist/v1/schema/compatibility/coordinate.js

@@ -20,10 +20,10 @@ export function keyForDefinitionRef(ref) {
 /** Interpret one canonical V1 Key as a Definition or a Class member location. */
 export function keyReference(key) {
     const semantic = key.slice(key.indexOf(':') + 1);
+    // A Core slug may hold `.`: the name of a Core key is the whole rest of its coordinate.
+    if (semantic.startsWith('core.'))
+        return { kind: 'core', name: semantic.slice('core.'.length) };
     const parts = semantic.split('.');
-    if (parts[0] === 'core' && parts.length === 2) {
-        return { kind: 'core', name: parts[1] };
-    }
     if (parts.length === 2) {
         return { kind: parts[0], name: parts[1] };
     }

package/dist/v1/schema/compatibility/model.d.ts

@@ -4,6 +4,11 @@ import type { DomainSchema } from '../model/schema.js';
 import type { ReferenceSite } from '../resolution/origins.js';
 import type { MeaningDifference } from './diff.js';
 export type Fingerprint = `sha256:${string}`;
+/**
+ * The codes a comparison request is refused with: the request, not a Schema, is invalid. A
+ * `schema.Error` carries them beside the codes of a refused Schema document.
+ */
+export type DiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DM_MEMBER_ROOT_INVALID';
 /** Inputs carry accepted schemas; a dependency's source is always its retained exact context. */
 export interface ComparisonRequest {
     readonly scope: {

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

@@ -1,11 +1,25 @@
-export type SchemaDiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_ADMISSION' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_INHERITANCE' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_EDGE_UNIQUE' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_NODE_UNIQUE' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_FOREIGN_MINIMUM' | 'DV_EDGE_LIFETIME' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_EDGE_UNIQUE' | 'DV_ENTRYPOINT' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_NODE_UNIQUE' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_IMMUTABLE' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
-export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode = SchemaDiagnosticCode> {
+import type { DiagnosticCode as LanguageDiagnosticCode } from '../language/validation/diagnostic.js';
+import type { Diagnostic as LanguageDiagnostic } from '../language/validation/diagnostic.js';
+import type { DiagnosticCode as CompatibilityDiagnosticCode } from './compatibility/model.js';
+/** The codes a Schema document is refused with, one per rule of `RULES`. */
+export type SchemaDiagnosticCode = 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_ADMISSION' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_INHERITANCE' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_EDGE_UNIQUE' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_NODE_UNIQUE' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_FOREIGN_MINIMUM' | 'DV_EDGE_LIFETIME' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNIQUE' | 'DV_ENTRYPOINT' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_NODE_UNIQUE' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_IMMUTABLE' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_BINARY_INPUT' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DEPENDENCY_ALIAS' | 'STRUCTURE_DOMAIN_NAME' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_BLOB' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_PROPERTY_KEY' | 'STRUCTURE_PROTO_KEY' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_STATE_TRANSITIONS' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
+/**
+ * A Schema refuses a document with its own codes, and a comparison request with the
+ * compatibility codes. `pointer` names the position the refused rule applies to, in the document
+ * or in the request; it is empty, the root, only when text does not parse or the document is not
+ * an object.
+ */
+export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode | CompatibilityDiagnosticCode = SchemaDiagnosticCode | CompatibilityDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;
     readonly message: string;
     readonly ref?: string;
+    /** The code of the value-language refusal the diagnostic carries; its message is the message. */
+    readonly valueCode?: LanguageDiagnosticCode;
 }
-export declare function diagnostic<const Code extends SchemaDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): SchemaDiagnostic<Code>;
+export declare function diagnostic<const Code extends SchemaDiagnosticCode | CompatibilityDiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): SchemaDiagnostic<Code>;
+/** A Schema diagnostic carrying one value-language refusal, at its position and with its code. */
+export declare function valueDiagnostic<const Code extends SchemaDiagnosticCode>(code: Code, refusal: LanguageDiagnostic): SchemaDiagnostic<Code>;
 export declare class SchemaError extends Error {
     readonly diagnostics: readonly SchemaDiagnostic[];
     constructor(diagnostics: readonly SchemaDiagnostic[]);

package/dist/v1/schema/diagnostic.js

@@ -2,6 +2,17 @@ import { formatDiagnostics, orderDiagnostics } from '../language/validation/diag
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
+/** A Schema diagnostic carrying one value-language refusal, at its position and with its code. */
+export function valueDiagnostic(code, refusal) {
+    const { pointer, message, ref } = refusal;
+    return Object.freeze({
+        code,
+        pointer,
+        message,
+        ...(ref === undefined ? {} : { ref }),
+        valueCode: refusal.code,
+    });
+}
 export class SchemaError extends Error {
     diagnostics;
     constructor(diagnostics) {

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

@@ -1,7 +1,7 @@
 /** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
 import type { SourceDomain } from '../domain/index.js';
 import type { DomainSchema } from './model/schema.js';
-export type { DomainSchema, DomainSchemaIR, DomainOfSchema as DomainOf } from './model/schema.js';
+export type { DomainSchema, DomainSchemaIR, DomainSchemaDocument as Document, DomainOfSchema as DomainOf, } from './model/schema.js';
 export type ResolvedDomainOf<Schema extends DomainSchema> = SourceDomain<Schema>;
 export interface Resolve {
     <const Schema extends DomainSchema>(schema: Schema): ResolvedDomainOf<Schema>;
@@ -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';
@@ -20,6 +22,13 @@ export { compile, load } from '../compiled/index.js';
 export type { CompiledSchema, DomainOfCompiled } from '../compiled/index.js';
 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';
@@ -10,5 +11,8 @@ export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
 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/model/schema.d.ts

@@ -1,8 +1,10 @@
-import type { Key } from '../../addressing/index.js';
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { Key, Revision } from '../../addressing/index.js';
 import type { DomainDependencyMap, ViewRef } from '../../addressing/index.js';
 import type { Domain, DomainOfSource, DomainSource } from '../../domain/model/domain.js';
 import type { FunctionDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { PropertyValues } from '../../language/class/property-values.js';
 import type { CoreContent } from '../../language/core/model/core.js';
 import type { PolicyDefinition } from '../../language/policy/model/policy.js';
 import type { ViewDefinition } from '../../language/view/model/view.js';
@@ -21,6 +23,22 @@ export interface DomainSchemaIR {
     readonly views: Readonly<Record<string, ViewDefinition>>;
     readonly core: CoreContent;
 }
+/**
+ * The JSON document of a Domain schema, as tools write and exchange it: `DomainSchemaIR` without
+ * its in-process proofs. The structure the Kernel enforces has this type, which the build checks
+ * (`validation/domain.structure.typecheck.ts`), and the published JSON Schema describes it.
+ */
+export type DomainSchemaDocument = DocumentOf<DomainSchemaIR>;
+/**
+ * The JSON document a model type describes. A `Revision` and `PropertyValues` are in-process
+ * proofs: the document carries them as plain text and plain values.
+ */
+export type DocumentOf<Model> = [JsonValue] extends [Model] ? Model : DocumentOfEach<Model>;
+type DocumentOfEach<Model> = Model extends Revision ? string : Model extends PropertyValues ? {
+    readonly [Key in keyof Model as Key extends string ? Key : never]: DocumentOf<Model[Key]>;
+} : Model extends string | number | boolean | null | undefined ? Model : {
+    readonly [Key in keyof Model]: DocumentOf<Model[Key]>;
+};
 declare const DOMAIN_SCHEMA_BRAND: unique symbol;
 /**
  * Accepted canonical schema carrying its exact resolved Domain projection.

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)
@@ -172,6 +172,7 @@ function canonicalizeProperty(value) {
             ? {}
             : {
                 auto: {
+                    // The distinct events of a non-empty list are a non-empty list.
                     on: [...new Set(value.auto.on)].sort(compareUnicode),
                     set: value.auto.set,
                 },

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

@@ -20,8 +20,9 @@ export function requireDomainClosure(schema) {
     const closure = knownDomainClosure(schema);
     if (closure !== undefined)
         return closure;
+    // What the value lacks is the exact closure of its dependencies, retained only by acceptance.
     throw new SchemaError([
-        diagnostic('DV_ACCEPTANCE_CONTEXT', '', `DomainSchema ${schema.origin} has no retained acceptance context; accept it again against its exact lookup.`),
+        diagnostic('DV_ACCEPTANCE_CONTEXT', '/dependencies', `DomainSchema ${schema.origin} has no retained acceptance context; accept it again against its exact lookup.`),
     ]);
 }
 export function lookupForDomainClosure(schema) {

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}`;
@@ -147,10 +147,12 @@ function loadDependencyClosure(candidate, dependencies, lookup, diagnostics) {
     }
 }
 function validateDependencyUse(candidate, directOrigins, diagnostics) {
+    // Each reference that cannot resolve is reported where it is written; the dependency it lacks
+    // belongs in the dependency map.
     const used = collectUsedForeignOrigins(candidate);
     for (const origin of used) {
         if (!directOrigins.has(origin)) {
-            diagnostics.push(diagnostic('DV_DEPENDENCY_DIRECT', '', `Foreign origin ${origin} is referenced without an exact direct dependency.`));
+            diagnostics.push(diagnostic('DV_DEPENDENCY_DIRECT', '/dependencies', `Foreign origin ${origin} is referenced without an exact direct dependency.`));
         }
     }
 }

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

@@ -0,0 +1,32 @@
+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
+ * environment and refused in another. The environment is what the lookup serves for the pinned
+ * dependencies, their accepted Schemas or their absence, and, for a Schema already accepted, the
+ * closure its acceptance retained.
+ */
+export type SchemaRuleStage = 'structure' | 'rule' | 'context';
+/** The rule one Schema diagnostic code reports. */
+export interface SchemaRule {
+    readonly stage: SchemaRuleStage;
+    /**
+     * The positions the rule constrains, which its diagnostics point at: JSON Pointer templates in
+     * which a `{name}` token stands for one token of the kind it names and a final `{/path*}` for any
+     * further tokens. `{endpoint}` is `source`, `target`, `0` or `1`; `{count}` is `outgoing`,
+     * `incoming` or `incident`; `{operation}` is `read` or `traverse`; `{key}` is a Property key.
+     */
+    readonly positions: readonly [string, ...string[]];
+    /** The rule, in one plain sentence. */
+    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[]];
+}
+/**
+ * Every Schema diagnostic code with the rule it reports. A code added to the DSL does not compile
+ * until it is described here.
+ */
+export declare const RULES: Readonly<Record<SchemaDiagnosticCode, SchemaRule>>;