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

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/context.d.ts

@@ -22,8 +22,7 @@ export declare class PolicyValidationContext implements PolicyTypingScope {
     edgeDeclaration(ref: ClassRef): Extract<ClassDefinition, {
         readonly kind: 'edge';
     }> | undefined;
-    /** Return true when candidate is the required Class or a same-kind descendant. */
-    classExtends(candidate: ClassRef, required: ClassRef): boolean;
+    resolveClass(ref: ClassRef): ClassDefinition | undefined;
     /** The contract a Policy pattern reference types, reporting an invalid one under `/policies`. */
     referenceContract(ref: PolicyObjectRef): ObjectContract | undefined;
     add(code: SchemaDiagnosticCode, pointer: string, message: string, ref?: string): void;

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

@@ -1,6 +1,5 @@
 import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
-import { classSatisfies } from '../../../language/class/inheritance.js';
 import { diagnostic } from '../../diagnostic.js';
 import { referenceContracts } from './objects.js';
 const formatDefinitionRef = Key.of;
@@ -63,12 +62,8 @@ export class PolicyValidationContext {
         }
         return resolved.declaration;
     }
-    /** Return true when candidate is the required Class or a same-kind descendant. */
-    classExtends(candidate, required) {
-        const resolve = (ref) => this.environment.resolveAny(ref)?.declaration;
-        const actual = resolve(candidate);
-        const target = resolve(required);
-        return actual !== undefined && target !== undefined && classSatisfies(actual, target, resolve);
+    resolveClass(ref) {
+        return this.environment.resolveAny(ref)?.declaration;
     }
     /** The contract a Policy pattern reference types, reporting an invalid one under `/policies`. */
     referenceContract(ref) {

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-api.d.ts

@@ -10,6 +10,8 @@ export type { BlobOptions, BlobReceipt, BlobRef, BlobSchema, } from '../../langu
 export type { JsonSchema as Schema, JsonSchemaObject as SchemaObject, PathAnnotation, PropertyObjectSchema as PropertySchema, ValueSchemaContext as Context, } from '../../language/value/model/schema.js';
 export { instant } from '../../language/value/model/instant.js';
 export type { OrderingKind } from '../../language/value/ordering.js';
+export { VALUE_KINDS } from '../../language/value/ordering.js';
+export { GRAPH_NODE_PATH_SCHEMA_ID as NODE_PATH } from '../../language/value/syntax/node-path/schema.js';
 export { DECLARED_VALUE_KINDS as DECLARED_KINDS, FORBIDDEN_KEYWORDS, SUBSCHEMA_KEYWORDS, VALUE_KEYWORDS as KEYWORDS, } from '../../language/value/profile/vocabulary.js';
 export type { DeclaredValueKind as DeclaredKind, ValueKeyword as Keyword, } from '../../language/value/profile/vocabulary.js';
 export { VALUE_RULES as RULES } from '../../language/validation/rule.js';

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

@@ -8,6 +8,8 @@ const registries = new WeakMap();
 export { VALUE_SCHEMA_DIALECT as DIALECT, VALUE_SCHEMA_VOCABULARY as VOCABULARY, } from '../../language/value/model/schema.js';
 export { blob, isBlobValueSchema as isBlob } from '../../language/value/model/blob.js';
 export { instant } from '../../language/value/model/instant.js';
+export { VALUE_KINDS } from '../../language/value/ordering.js';
+export { GRAPH_NODE_PATH_SCHEMA_ID as NODE_PATH } from '../../language/value/syntax/node-path/schema.js';
 export { DECLARED_VALUE_KINDS as DECLARED_KINDS, FORBIDDEN_KEYWORDS, SUBSCHEMA_KEYWORDS, VALUE_KEYWORDS as KEYWORDS, } from '../../language/value/profile/vocabulary.js';
 export { VALUE_RULES as RULES } from '../../language/validation/rule.js';
 /** Validate one complete JSON value under the exact accepted schema that owns the contract. */

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/dist/v1/schema/validation/value.json-schema.d.ts

@@ -13,7 +13,7 @@ export declare const valueSchemaRules: {
     readonly 'value-path': {
         readonly code: 'DV_VALUE_SCHEMA';
         readonly valueCode: 'VS_PATH_EXTENSION';
-        readonly statement: 'x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema, and reads target node, cardinality one and a non-empty set of Node Class refs it accepts.';
+        readonly statement: 'x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema.';
     };
     readonly 'value-recursion': {
         readonly code: 'DV_VALUE_SCHEMA';
@@ -40,8 +40,8 @@ export type ValueSchemaRule = keyof typeof valueSchemaRules;
 /**
  * The value language in JSON Schema, for the document that embeds value schemas: `root` constrains
  * the `value-schema` definition with the published dialect and what the profile adds to it,
- * `definitions` holds the locations it reaches, and `nodeProperty` constrains a Node Property
- * definition. A named check leaves `x-astrale-rule` at the positions it constrains.
+ * `definitions` holds the locations it reaches and the members of the Path annotation, and
+ * `nodeProperty` constrains a Node Property definition. A named check leaves `x-astrale-rule` at the positions it constrains.
  */
 export declare function valueSchemaJsonSchema(): {
     readonly root: readonly JsonSchema[];

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

@@ -10,10 +10,11 @@ export const valueSchemaRules = {
         valueCode: 'VS_VALUE_KIND',
         statement: 'A blob is declared only by the whole schema of a Property, exactly as values.blob writes it.',
     },
+    // Its members are stated (`path-annotation`); where it stands is named.
     'value-path': {
         code: 'DV_VALUE_SCHEMA',
         valueCode: 'VS_PATH_EXTENSION',
-        statement: 'x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema, and reads target node, cardinality one and a non-empty set of Node Class refs it accepts.',
+        statement: 'x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema.',
     },
     'value-recursion': {
         code: 'DV_VALUE_SCHEMA',
@@ -39,11 +40,12 @@ export const valueSchemaRules = {
 const KIND = 'x-astrale-value-kind';
 const LOCATION = '#/$defs/value-location';
 const SUBSCHEMA = '#/$defs/value-subschema';
+const PATH = '#/$defs/path-annotation';
 /**
  * The value language in JSON Schema, for the document that embeds value schemas: `root` constrains
  * the `value-schema` definition with the published dialect and what the profile adds to it,
- * `definitions` holds the locations it reaches, and `nodeProperty` constrains a Node Property
- * definition. A named check leaves `x-astrale-rule` at the positions it constrains.
+ * `definitions` holds the locations it reaches and the members of the Path annotation, and
+ * `nodeProperty` constrains a Node Property definition. A named check leaves `x-astrale-rule` at the positions it constrains.
  */
 export function valueSchemaJsonSchema() {
     return {
@@ -79,7 +81,7 @@ export function valueSchemaJsonSchema() {
                     enum: { type: 'array', uniqueItems: true },
                     fullMatch: { type: 'string', 'x-astrale-rule': 'value-regexp' },
                     pattern: { type: 'string', 'x-astrale-rule': 'value-regexp' },
-                    'x-astrale-path': { type: 'object', 'x-astrale-rule': 'value-path' },
+                    'x-astrale-path': { $ref: PATH, 'x-astrale-rule': 'value-path' },
                     ...Object.fromEntries(SUBSCHEMA_KEYWORDS.single.map((keyword) => [keyword, { $ref: SUBSCHEMA }])),
                     ...Object.fromEntries(SUBSCHEMA_KEYWORDS.array.map((keyword) => [
                         keyword,
@@ -99,6 +101,22 @@ export function valueSchemaJsonSchema() {
                 // oxlint-disable-next-line unicorn/no-thenable -- the JSON Schema keyword
                 then: { required: ['type'], properties: { type: { const: 'string' } } },
             }),
+            // The Path annotation: the one Node a Path field resolves, of a Node Class it accepts.
+            'path-annotation': {
+                type: 'object',
+                properties: {
+                    target: { type: 'string', const: 'node' },
+                    cardinality: { type: 'string', const: 'one' },
+                    accepts: {
+                        type: 'array',
+                        minItems: 1,
+                        uniqueItems: true,
+                        items: { $ref: '#/$defs/class-ref', 'x-astrale-rule': 'value-reference-resolution' },
+                    },
+                },
+                required: ['target', 'cardinality', 'accepts'],
+                additionalProperties: false,
+            },
             // A location below the root: no $schema, and no blob.
             'value-subschema': {
                 allOf: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "1.0.0-beta.14",
+  "version": "1.0.0-beta.16",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -81,6 +81,7 @@
     },
     "./v1/schema/domain-schema.schema.json": "./dist/v1/schema/.spec/schemas/domain-schema.schema.json",
     "./v1/schema/value-schema.schema.json": "./dist/v1/language/.spec/schemas/value-schema.schema.json",
+    "./v1/schema/draft-2020-12.schema.json": "./dist/v1/language/.spec/schemas/draft-2020-12.schema.json",
     "./v1/value/full-match": {
       "types": "./dist/v1/value/full-match.d.ts",
       "import": "./dist/v1/value/full-match.js"