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

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

@@ -1,7 +1,7 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import { type ZodArray, type ZodType, type core as zodCore } from 'zod';
 import type { PolicyRef } from '../../addressing/index.js';
-import type { FunctionAuth } from '../../language/callable/model/callable.js';
+import type { CallableDefinition, FunctionAuth } from '../../language/callable/model/callable.js';
 import type { PolicyCheckExpression, PolicyPatternExpression } from '../../language/policy/model/policy.js';
 import type { DomainSchemaIR } from '../model/schema.js';
 /**
@@ -3641,16 +3641,16 @@ export declare const domainSchemaStructure: import("zod").ZodObject<{
                 name: string;
             };
         }>, unknown>>]>>;
-        ref: import("zod").ZodObject<{
-            origin: import("zod").ZodString;
-            kind: import("zod").ZodLiteral<"function">;
-            name: import("zod").ZodString;
-        }, zodCore.$strict>;
         input: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
             mode: import("zod").ZodLiteral<"binary">;
             metadata: import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodRecord<import("zod").ZodString, ZodType<JsonValue, unknown, zodCore.$ZodTypeInternals<JsonValue, unknown>>>]>;
             maximumBytes: import("zod").ZodNumber;
         }, zodCore.$strict>, import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodRecord<import("zod").ZodString, ZodType<JsonValue, unknown, zodCore.$ZodTypeInternals<JsonValue, unknown>>>]>]>;
+        ref: import("zod").ZodObject<{
+            origin: import("zod").ZodString;
+            kind: import("zod").ZodLiteral<"function">;
+            name: import("zod").ZodString;
+        }, zodCore.$strict>;
     }, zodCore.$strict> & ZodType<{
         description?: string | undefined;
         output: {
@@ -3706,16 +3706,16 @@ export declare const domainSchemaStructure: import("zod").ZodObject<{
                 name: string;
             };
         }> | undefined;
-        ref: {
-            origin: string;
-            kind: "function";
-            name: string;
-        };
         input: boolean | Record<string, JsonValue> | {
             mode: "binary";
             metadata: boolean | Record<string, JsonValue>;
             maximumBytes: number;
         };
+        ref: {
+            origin: string;
+            kind: "function";
+            name: string;
+        };
     } & AuthorizedPolicy, {
         description?: string | undefined;
         output: {
@@ -3735,16 +3735,16 @@ export declare const domainSchemaStructure: import("zod").ZodObject<{
         } | undefined;
         auth: "anonymous" | "authenticated" | "authorized";
         policy?: unknown;
-        ref: {
-            origin: string;
-            kind: "function";
-            name: string;
-        };
         input: boolean | Record<string, unknown> | {
             mode: "binary";
             metadata: boolean | Record<string, unknown>;
             maximumBytes: number;
         };
+        ref: {
+            origin: string;
+            kind: "function";
+            name: string;
+        };
     }, zodCore.$ZodTypeInternals<{
         description?: string | undefined;
         output: {
@@ -3800,16 +3800,16 @@ export declare const domainSchemaStructure: import("zod").ZodObject<{
                 name: string;
             };
         }> | undefined;
-        ref: {
-            origin: string;
-            kind: "function";
-            name: string;
-        };
         input: boolean | Record<string, JsonValue> | {
             mode: "binary";
             metadata: boolean | Record<string, JsonValue>;
             maximumBytes: number;
         };
+        ref: {
+            origin: string;
+            kind: "function";
+            name: string;
+        };
     } & AuthorizedPolicy, {
         description?: string | undefined;
         output: {
@@ -3829,16 +3829,16 @@ export declare const domainSchemaStructure: import("zod").ZodObject<{
         } | undefined;
         auth: "anonymous" | "authenticated" | "authorized";
         policy?: unknown;
-        ref: {
-            origin: string;
-            kind: "function";
-            name: string;
-        };
         input: boolean | Record<string, unknown> | {
             mode: "binary";
             metadata: boolean | Record<string, unknown>;
             maximumBytes: number;
         };
+        ref: {
+            origin: string;
+            kind: "function";
+            name: string;
+        };
     }>>>;
     policies: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         ref: import("zod").ZodObject<{
@@ -4017,4 +4017,6 @@ export declare const domainSchemaStructure: import("zod").ZodObject<{
     }, zodCore.$strict>;
 }, zodCore.$strict>;
 export declare function parseDomainSchemaStructure(input: unknown): DomainSchemaIR;
+/** Parse the structure of one callable contract: a Function declaration without its ref. */
+export declare function parseCallableContract(input: unknown): CallableDefinition;
 export {};

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

@@ -3,7 +3,7 @@ import { PropertyKey as SemanticPropertyKey } from '../../addressing/index.js';
 import { CORE_SLUG_PATTERN, DEPENDENCY_ALIAS_PATTERN, DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTERN, MEMBER_NAME_PATTERN, PROPERTY_KEY_PATTERN, } from '../../addressing/patterns.js';
 import { MEDIA_TYPE_PATTERN } from '../../language/class/model/data.js';
 import * as metadata from '../../language/definition/metadata.js';
-import { MAX_REPEAT, MAX_VARIABLES } from '../../language/policy/analysis/budgets.js';
+import { limits } from '../../language/limits.js';
 import { BLOB_VALUE_KIND, isBlobValueSchema } from '../../language/value/model/blob.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { SchemaError, diagnostic, } from '../diagnostic.js';
@@ -245,8 +245,8 @@ const policyVariableSchema = union([
     strictObject({ variable: policyPatternVariableSchema, selector: policyVariableSelectorSchema }),
 ]).register(documentJsonSchema, { id: 'policy-variable' });
 const policyRepeatSchema = strictObject({
-    min: number().int().min(0).max(MAX_REPEAT),
-    max: number().int().min(0).max(MAX_REPEAT),
+    min: number().int().min(0).max(limits.policy.repetition),
+    max: number().int().min(0).max(limits.policy.repetition),
 }).register(documentJsonSchema, { id: 'policy-repeat' });
 const policyPatternExpressionSchema = lazy(() => union([
     strictObject({
@@ -260,7 +260,7 @@ const policyPatternExpressionSchema = lazy(() => union([
     }),
     strictObject({
         exists: strictObject({
-            nodes: nonEmpty(array(policyVariableSchema).max(MAX_VARIABLES)),
+            nodes: nonEmpty(array(policyVariableSchema).max(limits.policy.variablesPerExists)),
             where: policyPatternExpressionSchema,
         }),
     }),
@@ -428,13 +428,18 @@ const classDeclarationSchema = discriminatedUnion('kind', [
     nodeClassSchema,
     edgeClassSchema,
 ]).register(documentJsonSchema, { id: 'class-definition' });
-const functionDefinitionSchema = strictObject({
-    ref: functionRefSchema,
+const functionContractShape = {
     ...callableShape,
     input: union([binaryInputSchema, valueFunctionInputSchema]),
+};
+const functionDefinitionSchema = strictObject({
+    ref: functionRefSchema,
+    ...functionContractShape,
 })
     .refine((callable) => callable.auth === 'authorized' || callable.policy === undefined, callablePolicyIssue('function'))
     .register(documentJsonSchema, { id: 'function-definition', ...authorizedPolicy });
+// A callable contract has the structure of a Function declaration without its ref, wherever it is.
+const callableContractSchema = strictObject(functionContractShape).refine((callable) => callable.auth === 'authorized' || callable.policy === undefined, callablePolicyIssue('function'));
 const policyExpressionSchema = union([
     strictObject({
         match: policyPatternExpressionSchema,
@@ -516,6 +521,17 @@ function lostProtoKeys(input, parsed, path) {
         ...Object.keys(parsed).flatMap((key) => lostProtoKeys(Reflect.get(input, key), Reflect.get(parsed, key), [...path, key])),
     ];
 }
+/** Parse the structure of one callable contract: a Function declaration without its ref. */
+export function parseCallableContract(input) {
+    const result = callableContractSchema.safeParse(input);
+    if (!result.success) {
+        throw new SchemaError(result.error.issues.flatMap((issue) => diagnosticsForIssue(issue, input)));
+    }
+    const lost = lostProtoKeys(input, result.data, []);
+    if (lost.length > 0)
+        throw new SchemaError(lost);
+    return result.data;
+}
 /**
  * The structure admits the document the model types: this parameter checks one direction, and
  * `domain.structure.typecheck.ts` both. The brands are the model's own proofs from here on.

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

@@ -52,7 +52,8 @@ 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);
-        // The structure bounds each to an integer from 0 to MAX_REPEAT; only their order is left.
+        // 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.');
         }

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)) {
@@ -150,8 +130,8 @@ function visitChecks(validation, typing, expression, context, pointer, leaves) {
     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.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

@@ -7,22 +7,16 @@ export function validateEmbeddedValueSchemas(schema, registry) {
     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);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.14",
+  "version": "1.0.0-beta.15",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {