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

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

package/dist/v1/schema/rule.js

@@ -1,4 +1,5 @@
 import { defaultLimits } from '@astrale-os/kernel-dsl/value';
+import { limits } from '../language/limits.js';
 import { deepFreeze } from './canonical/freeze.js';
 const ANY = ['{/path*}'];
 const CHECKS = [
@@ -8,6 +9,7 @@ const CHECKS = [
 ];
 const DEPENDENCIES = ['/dependencies/{alias}', '/dependencies'];
 const count = (value) => value.toLocaleString('en-US');
+const { dependency, policy } = limits;
 const at = (field) => [
     `/functions/{function}${field}`,
     `/classes/{class}/methods/{method}${field}`,
@@ -68,7 +70,7 @@ export const RULES = deepFreeze({
     DV_CORE_EDGE_CONSTRAINTS: {
         stage: 'context',
         positions: ['/core/edges', '/core/edges/{index}', '/core/nodes/{slug}'],
-        statement: 'The Core Edges of a Schema hold the noSelf and acyclic constraints of their Classes, and every Core Node, and every Definition a Core Edge names, the Edge counts of the endpoints that accept it, a Definition its maximum only.',
+        statement: 'The Core Edges of a Schema hold the noSelf and acyclic constraints of their Classes, and every Core Node, and every Definition a Core Edge names, the Edge counts of the concrete Edge Classes whose endpoints accept it, each over its own Edges, a Definition its maximum only.',
     },
     DV_CORE_EDGE_KEY: {
         stage: 'rule',
@@ -128,7 +130,8 @@ export const RULES = deepFreeze({
     DV_DEPENDENCY_LIMITS: {
         stage: 'context',
         positions: ['/dependencies', '/dependencies/{alias}'],
-        statement: 'A Domain has at most 32 direct dependencies, a closure of at most 256 Domains and a dependency depth of at most 32.',
+        statement: `A Domain has at most ${dependency.direct} direct dependencies, a closure of at most ${dependency.closure} Domains and a dependency depth of at most ${dependency.depth}.`,
+        limits: ['dependency.direct', 'dependency.closure', 'dependency.depth'],
     },
     DV_DEPENDENCY_REVISION_COHERENCE: {
         stage: 'context',
@@ -248,7 +251,16 @@ export const RULES = deepFreeze({
     PL_BUDGET: {
         stage: 'rule',
         positions: ['/policies/{policy}', ...CHECKS],
-        statement: 'A Policy stays within its budgets once expanded: pattern depth 4, 8 normalized branches, 6 Edge predicates a branch and 4 referenced Domains; and checks within depth 4, 8 branches and 8 leaves.',
+        statement: `A Policy stays within its budgets once expanded: pattern depth ${policy.patternDepth}, ${policy.normalizedBranches} normalized branches, ${policy.edgePredicates} Edge predicates a branch and ${policy.referencedDomains} referenced Domains; and checks within depth ${policy.checkDepth}, ${policy.checkBranches} branches and ${policy.checkLeaves} leaves.`,
+        limits: [
+            'policy.patternDepth',
+            'policy.normalizedBranches',
+            'policy.edgePredicates',
+            'policy.referencedDomains',
+            'policy.checkDepth',
+            'policy.checkBranches',
+            'policy.checkLeaves',
+        ],
     },
     PL_COMPOSITION: {
         stage: 'rule',
@@ -351,6 +363,7 @@ export const RULES = deepFreeze({
         stage: 'structure',
         positions: ANY,
         statement: 'A string, list or number is no greater than the bound of its position.',
+        limits: ['policy.variablesPerExists', 'policy.repetition'],
     },
     STRUCTURE_MINIMUM: {
         stage: 'structure',

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

@@ -1,7 +1,37 @@
+import type { ClassRef } from '../../addressing/index.js';
+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';
 /**
- * Validate the ref of every local Function, and the execution modifier and admission age of every
- * local Function and Node Method.
+ * One callable contract a Domain schema declares: where it is written, and the Node Class that
+ * receives its call, which its Policy names `self`. A contract is validated by the same rules
+ * wherever it is: in a Domain schema, at its declaration, or on the Node of a Function instance,
+ * which carries it (`acceptCallable`).
  */
-export declare function validateCallables(schema: DomainSchemaIR): readonly SchemaDiagnostic[];
+export interface DeclaredContract {
+    readonly contract: CallableDefinition;
+    /** Its declaration's JSON Pointer, which its diagnostics point within. */
+    readonly pointer: string;
+    /** The owner of an instance Method; a Function and a static Method have none. */
+    readonly receiver?: ClassRef;
+    /** The Node Class and name of a Method; absent for a Function. */
+    readonly method?: {
+        readonly owner: ClassRef;
+        readonly name: string;
+    };
+}
+/** Every callable contract one Domain schema declares: each Function, then each Node Method. */
+export declare function declaredContracts(schema: DomainSchemaIR): readonly DeclaredContract[];
+/**
+ * Validate the ref of every Function declaration, then the value schemas, execution modifier and
+ * admission age of every declared contract.
+ */
+export declare function validateContracts(schema: DomainSchemaIR, registry: ValueSchemaRegistry): readonly SchemaDiagnostic[];
+/**
+ * Validate one callable contract written at `pointer`, except its Policy (`validateContractPolicy`):
+ * its value schemas against the owner registry, its execution modifier and its admission age.
+ */
+export declare function validateContract(contract: CallableDefinition, pointer: string, registry: ValueSchemaRegistry, diagnostics: SchemaDiagnostic[]): void;
+/** Validate the execution modifier and admission age of one callable contract at `pointer`. */
+export declare function validateCallableModifiers(declaration: CallableDefinition, pointer: string, diagnostics: SchemaDiagnostic[]): void;

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

@@ -4,32 +4,66 @@ import { isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS, } from '../../languag
 import { isBinaryInput } from '../../language/callable/model/callable.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
-/**
- * Validate the ref of every local Function, and the execution modifier and admission age of every
- * local Function and Node Method.
- */
-export function validateCallables(schema) {
-    const diagnostics = [];
+import { validateCallable } from './value.js';
+/** Every callable contract one Domain schema declares: each Function, then each Node Method. */
+export function declaredContracts(schema) {
+    const contracts = [];
     for (const [name, declaration] of Object.entries(schema.functions)) {
-        const pointer = `/functions/${escapePointerToken(name)}`;
-        const ref = { origin: schema.origin, kind: 'function', name };
-        if (!equalDefinitionRefs(declaration.ref, ref)) {
-            diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Function ref must be exactly ${Key.of(ref)}.`, Key.of(declaration.ref)));
-        }
-        validateExecution(declaration, pointer, diagnostics);
-        validateAdmission(declaration, pointer, diagnostics);
+        contracts.push({ contract: declaration, pointer: `/functions/${escapePointerToken(name)}` });
     }
     for (const [name, declaration] of Object.entries(schema.classes)) {
         if (declaration.kind !== 'node')
             continue;
+        const owner = { origin: schema.origin, kind: 'class', name };
         for (const [method, value] of Object.entries(declaration.methods)) {
             const pointer = `/classes/${escapePointerToken(name)}/methods/${escapePointerToken(method)}`;
-            validateExecution(value, pointer, diagnostics);
-            validateAdmission(value, pointer, diagnostics);
+            contracts.push({
+                contract: value,
+                pointer,
+                ...(value.static ? {} : { receiver: owner }),
+                method: { owner, name: method },
+            });
         }
     }
+    return contracts;
+}
+/**
+ * Validate the ref of every Function declaration, then the value schemas, execution modifier and
+ * admission age of every declared contract.
+ */
+export function validateContracts(schema, registry) {
+    const diagnostics = [];
+    for (const [name, declaration] of Object.entries(schema.functions)) {
+        validateFunctionRef(schema.origin, name, declaration.ref, diagnostics);
+    }
+    for (const { contract, pointer } of declaredContracts(schema)) {
+        validateContract(contract, pointer, registry, diagnostics);
+    }
     return Object.freeze(diagnostics);
 }
+/**
+ * A Function declaration names itself by its ref: its own key in its own Domain. The ref belongs to
+ * the declaration, not to its contract, which a Node carries without one.
+ */
+function validateFunctionRef(origin, name, declared, diagnostics) {
+    const ref = { origin, kind: 'function', name };
+    if (equalDefinitionRefs(declared, ref))
+        return;
+    diagnostics.push(diagnostic('DV_REF_RESOLVES', `/functions/${escapePointerToken(name)}/ref`, `Function ref must be exactly ${Key.of(ref)}.`, Key.of(declared)));
+}
+/**
+ * Validate one callable contract written at `pointer`, except its Policy (`validateContractPolicy`):
+ * its value schemas against the owner registry, its execution modifier and its admission age.
+ */
+export function validateContract(contract, pointer, registry, diagnostics) {
+    validateCallable(contract, pointer, registry, diagnostics);
+    validateCallableModifiers(contract, pointer, diagnostics);
+}
+/** Validate the execution modifier and admission age of one callable contract at `pointer`. */
+export function validateCallableModifiers(declaration, pointer, diagnostics) {
+    validateExecution(declaration, pointer, diagnostics);
+    validateAdmission(declaration, pointer, diagnostics);
+}
 /**
  * An admission age is a whole number of seconds within the language ceiling. It has no zero
  * spelling: an absent admission age is the one canonical form of a call admitted afresh.

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

@@ -3,7 +3,7 @@ import { Key } from '../../addressing/key.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
 import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../language/class/unique.js';
-import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, } from '../../language/core/facts.js';
+import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, DOMAIN_ENDPOINT_CLASS, } from '../../language/core/facts.js';
 import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
@@ -83,7 +83,9 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
             continue;
         const endpointsSatisfy = coreEndpointsSatisfy(declaration, source, target, (endpoint, accepts) => endpointSatisfies(environment, endpoint, accepts));
         if (!endpointsSatisfy) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.`, formatDefinitionRef(edge.class)));
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.${source.kind === 'domain' || target.kind === 'domain'
+                ? ` The owning Domain is a ${formatDefinitionRef(DOMAIN_ENDPOINT_CLASS)} Node: the endpoint that names it must accept that Class or one it extends.`
+                : ''}`, formatDefinitionRef(edge.class)));
             continue;
         }
         edges.push({ source, target, declaration, value: edge, pointer });
@@ -92,7 +94,7 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
 }
 function resolveCoreEndpoint(environment, ref, pointer, nodesByRef, diagnostics) {
     if (ref.kind === 'domain')
-        return { kind: 'domain', ref, key: 'domain' };
+        return { kind: 'domain', ref, key: 'domain', classRef: DOMAIN_ENDPOINT_CLASS };
     const undeclared = () => {
         const key = policyObjectKey(ref);
         diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${key} does not name a declared local Definition.`, key));
@@ -122,10 +124,14 @@ function declaresProjectedMember(environment, ref) {
         return Object.hasOwn(candidate.policies, ref.name);
     return Object.hasOwn(candidate.views, ref.name);
 }
+/**
+ * A Core Node is admitted by its own authored Class, a projected member by the Kernel declaration
+ * Class it projects as, and the owning Domain by the Kernel `Domain` Class of its Node: the write
+ * that projects the Edge binds exactly that Node, so an Edge Class that does not accept it can
+ * never be installed (DV-CORE-EDGE-CLASS).
+ */
 function endpointSatisfies(environment, endpoint, accepts) {
-    // The owning Domain is a graph-projection identity, not a Definition declared by this DSL.
-    // Its concrete Class contract is therefore admitted by the projection compiler.
-    return endpoint.kind === 'domain' || classSatisfies(environment, endpoint.classRef, accepts);
+    return classSatisfies(environment, endpoint.classRef, accepts);
 }
 function validateCreationProperties(definition, properties, registry, code, pointer, diagnostics) {
     const schema = {
@@ -181,11 +187,11 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
         report: (issue) => diagnostics.push(coreEdgeDiagnostic(issue)),
     });
 }
-/** A projected member's degree is reported at the Edge that names it. */
+/** A projected member's degree, and the owning Domain's, is reported at the Edge that names it. */
 function factEndpoint(endpoint, pointer) {
-    return endpoint.kind === 'member'
-        ? { key: endpoint.key, member: { class: endpoint.classRef, pointer } }
-        : endpoint;
+    return endpoint.kind === 'core'
+        ? endpoint
+        : { key: endpoint.key, member: { class: endpoint.classRef, pointer } };
 }
 function coreEdgeDiagnostic(issue) {
     switch (issue.kind) {

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

@@ -2,7 +2,7 @@ import { orderAndDeduplicate } from '../../language/validation/diagnostic.js';
 import { analyzeDefinitions } from '../analysis/class.js';
 import { buildDomainResolutionContext } from '../resolution/context.js';
 import { createValueSchemaRegistry } from '../resolution/value.registry.js';
-import { validateCallables } from './callable.js';
+import { validateContracts } from './callable.js';
 import { validateDefinitions } from './class.js';
 import { validateCore } from './core.js';
 import { validatePolicies } from './policy/validate.js';
@@ -16,7 +16,7 @@ export function validateDomainSchemaSemantics(schema, lookup) {
         ...context.diagnostics,
         ...validateEmbeddedValueSchemas(schema, registry),
         ...validateDefinitions(context, analysis),
-        ...validateCallables(schema),
+        ...validateContracts(schema, registry),
         ...validatePolicies(context, analysis),
         ...validateViews(context),
         ...validateCore(context, analysis, registry),

package/dist/v1/schema/validation/domain.route.d.ts

@@ -1,4 +1,9 @@
-import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import { type Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import type { DomainSchemaIR } from '../model/schema.js';
+/**
+ * Read an unknown value as a Domain Schema document of its exact language contract: portable JSON
+ * (`DV_JSON_VALUE`), then the structure of its format and version. Throws `SchemaError`.
+ */
+export declare function structureDomainSchema(input: unknown): DomainSchemaIR;
 /** Select the exact Domain language contract before entering its structural grammar. */
 export declare function routeDomainSchema(input: JsonValue): DomainSchemaIR;

package/dist/v1/schema/validation/domain.route.js

@@ -1,9 +1,27 @@
+import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
 import { SchemaError, diagnostic } from '../diagnostic.js';
 import { DOMAIN_FORMAT, DOMAIN_VERSION } from '../model/format.js';
 import { parseDomainSchemaStructure } from './domain.structure.js';
 const decoders = new Map([
     [DOMAIN_FORMAT, new Map([[DOMAIN_VERSION, parseDomainSchemaStructure]])],
 ]);
+/**
+ * Read an unknown value as a Domain Schema document of its exact language contract: portable JSON
+ * (`DV_JSON_VALUE`), then the structure of its format and version. Throws `SchemaError`.
+ */
+export function structureDomainSchema(input) {
+    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;
+    }
+    return routeDomainSchema(admitted);
+}
 /** Select the exact Domain language contract before entering its structural grammar. */
 export function routeDomainSchema(input) {
     if (!isJsonObject(input))