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

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

@@ -1,11 +1,6 @@
 import { definitionRefIndex } from '../../../addressing/ordering.js';
 import { isMethodExecutable } from '../../../language/callable/executable.js';
-import { policyObjectKey, policyObjectOrigin } from '../../../language/index.js';
-const KERNEL_ORIGIN = 'kernel.astrale.ai';
-const PROJECTION_CLASS = nodeClassRef('Class');
-const PROJECTION_FUNCTION = nodeClassRef('Function');
-const PROJECTION_POLICY = nodeClassRef('Policy');
-const PROJECTION_VIEW = nodeClassRef('View');
+import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../../language/index.js';
 export function referenceContracts(validation, ref, pointer) {
     const candidate = validation.environment.candidate;
     const local = policyObjectOrigin(ref) === candidate.origin;
@@ -21,7 +16,7 @@ export function referenceContracts(validation, ref, pointer) {
         case 'class': {
             const resolved = validation.environment.resolve(ref);
             return resolved?.ref.kind === ref.kind
-                ? [{ kind: 'exact', ref: PROJECTION_CLASS }]
+                ? [{ kind: 'exact', ref: projectedMemberClass(ref) }]
                 : invalidPolicyObjectRef(validation, ref, pointer);
         }
         case 'method': {
@@ -29,20 +24,20 @@ export function referenceContracts(validation, ref, pointer) {
             const method = declaringClass?.kind === 'node' ? declaringClass.methods[ref.name] : undefined;
             return method === undefined || !isMethodExecutable(declaringClass, method)
                 ? invalidPolicyObjectRef(validation, ref, pointer)
-                : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
+                : [{ kind: 'exact', ref: projectedMemberClass(ref) }];
         }
         case 'function':
             return owner.functions[ref.name] === undefined
                 ? invalidPolicyObjectRef(validation, ref, pointer)
-                : [{ kind: 'exact', ref: PROJECTION_FUNCTION }];
+                : [{ kind: 'exact', ref: projectedMemberClass(ref) }];
         case 'policy':
             return owner.policies[ref.name] === undefined
                 ? invalidPolicyObjectRef(validation, ref, pointer)
-                : [{ kind: 'exact', ref: PROJECTION_POLICY }];
+                : [{ kind: 'exact', ref: projectedMemberClass(ref) }];
         case 'view':
             return owner.views[ref.name] === undefined
                 ? invalidPolicyObjectRef(validation, ref, pointer)
-                : [{ kind: 'exact', ref: PROJECTION_VIEW }];
+                : [{ kind: 'exact', ref: projectedMemberClass(ref) }];
         case 'core': {
             const node = owner.core.nodes[ref.name];
             if (node === undefined)
@@ -66,6 +61,3 @@ function invalidPolicyObjectRef(validation, ref, pointer) {
     validation.add('PL_REF', `${pointer}/ref`, `${policyObjectKey(ref)} is not an exact local or direct-dependency projected Policy object.`, policyObjectKey(ref));
     return undefined;
 }
-function nodeClassRef(name) {
-    return { origin: KERNEL_ORIGIN, kind: 'class', name };
-}

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

@@ -1,16 +1,15 @@
+import { equalDefinitionRefs } from '../../../addressing/definition-ref.js';
 import { branchesOf, isConnected, targetMode } from '../../../language/policy/analysis/branches.js';
 import { policyVariableClass } from '../../../language/policy/model/policy.js';
 import { normalizePolicyExpression, normalizePolicyPattern, } from '../../../language/policy/normalization/normalize.js';
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { MAX_REPEAT, MAX_VARIABLES } from './budgets.js';
-import { escapePointer } from './context.js';
 import { referenceContracts } from './objects.js';
 export function validatePolicyReferences(context) {
     for (const [name, declaration] of Object.entries(context.environment.candidate.policies)) {
-        const pointer = `/policies/${escapePointer(name)}`;
+        const pointer = `/policies/${escapePointerToken(name)}`;
         const expected = { origin: context.environment.candidate.origin, kind: 'policy', name };
-        if (declaration.ref.origin !== expected.origin ||
-            declaration.ref.kind !== expected.kind ||
-            declaration.ref.name !== expected.name) {
+        if (!equalDefinitionRefs(declaration.ref, expected)) {
             context.add('DV_REF_RESOLVES', `${pointer}/ref`, `Policy ref must be exactly ${expected.origin}:policy.${expected.name}.`);
         }
         const expression = declaration.expression;
@@ -123,7 +122,7 @@ function validateCycles(context) {
     const visited = new Set();
     const visit = (name, stack) => {
         if (visiting.has(name)) {
-            context.add('PL_COMPOSITION', `/policies/${escapePointer(name)}`, `Named Policy composition cycle: ${[...stack, name].join(' -> ')}.`);
+            context.add('PL_COMPOSITION', `/policies/${escapePointerToken(name)}`, `Named Policy composition cycle: ${[...stack, name].join(' -> ')}.`);
             return;
         }
         if (visited.has(name))

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

@@ -1,21 +1,6 @@
 import type { ClassRef } from '../../../addressing/index.js';
+import type { ObjectContract, PolicyTyping } from '../../../language/policy/analysis/typing.js';
 import type { PolicyValidationContext } from './context.js';
-export type ObjectContract = {
-    readonly kind: 'default';
-} | {
-    readonly kind: 'exact';
-    readonly ref: ClassRef;
-};
-export declare class PolicyTyping {
-    #private;
-    readonly context: PolicyValidationContext;
-    constructor(context: PolicyValidationContext);
-    validatePolicies(): void;
-    policyAccepts(name: string, object: ObjectContract): boolean;
-    /** Whether each normalized branch of the Policy is typed for an object of this contract. */
-    policyBranchTyping(name: string, object: ObjectContract): readonly boolean[] | undefined;
-    policyAcceptsEdge(name: string, source: ObjectContract, target: ObjectContract): boolean;
-    concreteEndpointClasses(accepts: readonly ClassRef[]): readonly ClassRef[];
-    endpointsOverlap(left: readonly ClassRef[], right: readonly ClassRef[]): boolean;
-}
+/** Type every expanded branch of each named Policy at its own default use. */
+export declare function validatePolicyTyping(context: PolicyValidationContext, typing: PolicyTyping): void;
 export declare function contractOfNodeDefinition(ref: ClassRef): ObjectContract;

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

@@ -1,366 +1,32 @@
-import { definitionRefIndex } from '../../../addressing/ordering.js';
-import { branchesOf, branchProduct, capBranches, targetMode, termKey, } from '../../../language/policy/analysis/branches.js';
-import { MAX_REPEAT } from './budgets.js';
-import { escapePointer } from './context.js';
-import { referenceContracts } from './objects.js';
-export class PolicyTyping {
-    context;
-    // Expanded branches of each named Policy, cached by node identity. A Policy's expansion is reused
-    // across every composition path that reaches it (and across every use site and object contract,
-    // none of which the expansion depends on), so a shared-child composition DAG is expanded in work
-    // linear in the number of Policies instead of enumerating every path. The expansion result is
-    // independent of the reaching path up to the opaque term-namespace labels, which only ever
-    // disambiguate variables within one branch and leave targetMode and branch typing unchanged.
-    #expansions = new Map();
-    constructor(context) {
-        this.context = context;
-    }
-    validatePolicies() {
-        for (const name of Object.keys(this.context.environment.candidate.policies)) {
-            const branches = this.#expandedBranches(name, new Set(), `$${name}`);
-            if (branches === undefined)
-                continue;
-            for (const [index, branch] of branches.entries()) {
-                const mode = targetMode(branch);
-                if (mode === undefined) {
-                    if (!('match' in this.context.environment.candidate.policies[name].expression)) {
-                        this.context.add('PL_TARGET', `/policies/${escapePointer(name)}`, `Expanded normalized branch ${index} must use object or at least one of source and target, without mixing target modes.`);
-                    }
-                    continue;
-                }
-                const use = mode === 'object'
-                    ? { kind: 'object', object: { kind: 'default' } }
-                    : {
-                        kind: 'edge',
-                        source: { kind: 'default' },
-                        target: { kind: 'default' },
-                    };
-                if (!this.#branchIsTyped(branch, use)) {
-                    this.context.add('PL_TYPING', `/policies/${escapePointer(name)}`, `Expanded normalized branch ${index} has contradictory endpoint or repeat contracts.`);
+import { targetMode } from '../../../language/policy/analysis/branches.js';
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
+/** Type every expanded branch of each named Policy at its own default use. */
+export function validatePolicyTyping(context, typing) {
+    for (const name of Object.keys(context.environment.candidate.policies)) {
+        const branches = typing.expandedBranches(name, `$${name}`);
+        if (branches === undefined)
+            continue;
+        for (const [index, branch] of branches.entries()) {
+            const mode = targetMode(branch);
+            if (mode === undefined) {
+                if (!('match' in context.environment.candidate.policies[name].expression)) {
+                    context.add('PL_TARGET', `/policies/${escapePointerToken(name)}`, `Expanded normalized branch ${index} must use object or at least one of source and target, without mixing target modes.`);
                 }
-            }
-        }
-    }
-    policyAccepts(name, object) {
-        return this.policyBranchTyping(name, object)?.every(Boolean) ?? false;
-    }
-    /** Whether each normalized branch of the Policy is typed for an object of this contract. */
-    policyBranchTyping(name, object) {
-        const branches = this.#expandedBranches(name, new Set(), `$use:${name}`);
-        const use = { kind: 'object', object };
-        return branches?.map((branch) => this.#branchIsTyped(branch, use));
-    }
-    policyAcceptsEdge(name, source, target) {
-        const branches = this.#expandedBranches(name, new Set(), `$edge-use:${name}`);
-        const use = { kind: 'edge', source, target };
-        return branches !== undefined && branches.every((branch) => this.#branchIsTyped(branch, use));
-    }
-    concreteEndpointClasses(accepts) {
-        return this.context.concreteNodeClasses.filter((candidate) => this.#classSatisfiesEndpoint(candidate, accepts));
-    }
-    endpointsOverlap(left, right) {
-        const seed = [{ kind: 'open', requirements: [] }];
-        const afterLeft = this.#applyEndpoint(seed, left);
-        return this.#applyEndpoint(afterLeft, right).length > 0;
-    }
-    #expandedBranches(name, visiting, namespace) {
-        if (visiting.has(name))
-            return undefined;
-        const cached = this.#expansions.get(name);
-        if (cached !== undefined || this.#expansions.has(name))
-            return cached;
-        const expanded = this.#expandDeclaration(name, visiting, namespace);
-        this.#expansions.set(name, expanded);
-        return expanded;
-    }
-    #expandDeclaration(name, visiting, namespace) {
-        const declaration = this.context.normalized.get(name);
-        if (declaration === undefined)
-            return undefined;
-        if ('match' in declaration)
-            return branchesOf(declaration.match, namespace);
-        const nested = new Set(visiting);
-        nested.add(name);
-        const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
-        const children = [];
-        for (const [index, ref] of refs.entries()) {
-            if (!this.context.isLocalPolicy(ref))
-                return undefined;
-            const expanded = this.#expandedBranches(ref.name, nested, `${namespace}/${index}:${ref.name}`);
-            if (expanded === undefined)
-                return undefined;
-            children.push(expanded);
-        }
-        return 'allOf' in declaration ? branchProduct(children) : capBranches(children.flat());
-    }
-    #branchIsTyped(branch, use) {
-        if (targetMode(branch) !== use.kind)
-            return false;
-        const alternatives = edgeAlternatives(branch.edges, this);
-        return alternatives.some((variants) => this.#constraintsAreSatisfiable(branch, variants, use));
-    }
-    #constraintsAreSatisfiable(branch, variants, use) {
-        const terms = new Set(use.kind === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
-        for (const key of branch.variables.keys())
-            terms.add(key);
-        for (const key of branch.terms.keys())
-            terms.add(key);
-        for (const edge of branch.edges) {
-            terms.add(termKey(edge.pattern.source, edge.namespace));
-            terms.add(termKey(edge.pattern.target, edge.namespace));
-        }
-        const union = new UnionFind(terms);
-        for (const [left, right] of branch.equalities)
-            union.join(left, right);
-        for (const variant of variants) {
-            for (const [left, right] of variant.equalities)
-                union.join(left, right);
-        }
-        const constraints = new Map();
-        for (const variant of variants) {
-            for (const [term, accepts] of variant.constraints) {
-                const root = union.find(term);
-                const values = constraints.get(root) ?? [];
-                values.push(accepts);
-                constraints.set(root, values);
-            }
-        }
-        const groups = new Map();
-        for (const term of terms) {
-            const root = union.find(term);
-            const members = groups.get(root) ?? [];
-            members.push(term);
-            groups.set(root, members);
-        }
-        for (const [root, members] of groups) {
-            const endpointConstraints = constraints.get(root) ?? [];
-            let candidates = [{ kind: 'open', requirements: [] }];
-            for (const member of members) {
-                candidates = this.#applyInitial(candidates, member, branch, use);
-                if (candidates.length === 0)
-                    return false;
-            }
-            for (const endpoint of endpointConstraints) {
-                candidates = this.#applyEndpoint(candidates, endpoint);
-                if (candidates.length === 0)
-                    return false;
-            }
-        }
-        return true;
-    }
-    #applyInitial(candidates, term, branch, use) {
-        if (term === 'subject')
-            return this.#applyAnyNodeClass(candidates);
-        const contract = targetContract(term, use);
-        if (contract !== undefined) {
-            if (contract.kind === 'exact')
-                return this.#applyExact(candidates, contract.ref);
-            if (contract.kind === 'default') {
-                return uniqueCandidates(this.context.allNodeClasses.flatMap((ref) => this.#applyExact(candidates, ref)));
-            }
-            return candidates;
-        }
-        const referenced = branch.terms.get(term);
-        if (referenced?.kind === 'ref') {
-            const contract = referenceContracts(this.context, referenced.ref, '/policies')?.[0];
-            return contract?.kind === 'exact' ? this.#applyExact(candidates, contract.ref) : [];
-        }
-        const selector = branch.variables.get(term);
-        if (selector === undefined)
-            return [];
-        if (selector.kind === 'exact')
-            return this.#applyExact(candidates, selector.class);
-        if (selector.kind === 'any')
-            return candidates;
-        return this.#applyRequirement(candidates, selector.class);
-    }
-    #applyExact(candidates, exact) {
-        const result = [];
-        for (const candidate of candidates) {
-            if (candidate.kind === 'exact') {
-                if (definitionRefIndex(candidate.ref) === definitionRefIndex(exact))
-                    result.push(candidate);
-            }
-            else if (candidate.requirements.every((required) => this.context.classExtends(exact, required))) {
-                result.push({ kind: 'exact', ref: exact });
-            }
-        }
-        return uniqueCandidates(result);
-    }
-    #applyAnyNodeClass(candidates) {
-        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
-            ? [candidate]
-            : this.context.allNodeClasses
-                .filter((ref) => candidate.requirements.every((required) => this.context.classExtends(ref, required)))
-                .map((ref) => ({ kind: 'exact', ref }))));
-    }
-    #applyRequirement(candidates, required) {
-        const result = [];
-        for (const candidate of candidates) {
-            if (candidate.kind === 'exact') {
-                if (this.context.classExtends(candidate.ref, required))
-                    result.push(candidate);
-            }
-            else {
-                result.push({
-                    kind: 'open',
-                    requirements: uniqueClasses([...candidate.requirements, required]),
-                });
-            }
-        }
-        return uniqueCandidates(result);
-    }
-    #applyEndpoint(candidates, accepts) {
-        const result = [];
-        for (const candidate of candidates) {
-            if (candidate.kind === 'exact') {
-                if (this.#classSatisfiesEndpoint(candidate.ref, accepts))
-                    result.push(candidate);
                 continue;
             }
-            for (const accept of accepts) {
-                result.push({
-                    kind: 'open',
-                    requirements: uniqueClasses([...candidate.requirements, accept]),
-                });
+            const use = mode === 'object'
+                ? { kind: 'object', object: { kind: 'default' } }
+                : {
+                    kind: 'edge',
+                    source: { kind: 'default' },
+                    target: { kind: 'default' },
+                };
+            if (!typing.branchIsTyped(branch, use)) {
+                context.add('PL_TYPING', `/policies/${escapePointerToken(name)}`, `Expanded normalized branch ${index} has contradictory endpoint or repeat contracts.`);
             }
         }
-        return uniqueCandidates(result);
     }
-    #classSatisfiesEndpoint(candidate, accepts) {
-        return accepts.some((accept) => this.context.classExtends(candidate, accept));
-    }
-}
-function targetContract(term, use) {
-    if (use.kind === 'object')
-        return term === 'object' ? use.object : undefined;
-    if (term === 'source')
-        return use.source;
-    if (term === 'target')
-        return use.target;
-    return undefined;
 }
 export function contractOfNodeDefinition(ref) {
     return { kind: 'exact', ref };
 }
-function edgeAlternatives(edges, typing) {
-    let result = [[]];
-    for (const edge of edges) {
-        const variants = variantsForEdge(edge, typing);
-        if (variants.length === 0)
-            return [];
-        const next = [];
-        for (const prefix of result) {
-            for (const variant of variants)
-                next.push([...prefix, variant]);
-        }
-        result = next;
-    }
-    return result;
-}
-function variantsForEdge(use, typing) {
-    const edge = use.pattern;
-    const declaration = typing.context.edgeDeclaration(edge.class);
-    if (declaration === undefined)
-        return [];
-    const endpoints = declaration.orientation === 'directed'
-        ? [declaration.endpoints.source, declaration.endpoints.target]
-        : declaration.endpoints;
-    const bounds = edge.repeat ?? { min: 1, max: 1 };
-    if (!Number.isInteger(bounds.min) ||
-        !Number.isInteger(bounds.max) ||
-        bounds.min < 0 ||
-        bounds.max < bounds.min ||
-        bounds.max > MAX_REPEAT) {
-        return [];
-    }
-    const sourceKey = termKey(edge.source, use.namespace);
-    const targetKey = termKey(edge.target, use.namespace);
-    const variants = [];
-    for (let length = bounds.min; length <= bounds.max; length++) {
-        if (length === 0) {
-            variants.push({ constraints: [], equalities: [[sourceKey, targetKey]] });
-            continue;
-        }
-        const orientationCount = declaration.orientation === 'undirected' ? 2 ** length : 1;
-        for (let mask = 0; mask < orientationCount; mask++) {
-            const orientations = Array.from({ length }, (_, index) => declaration.orientation === 'undirected' && (mask & (1 << index)) !== 0);
-            let transitionsValid = true;
-            for (let index = 0; index + 1 < length; index++) {
-                const incoming = endEndpoint(endpoints, orientations[index] ?? false);
-                const outgoing = startEndpoint(endpoints, orientations[index + 1] ?? false);
-                if (!typing.endpointsOverlap(incoming.accepts, outgoing.accepts)) {
-                    transitionsValid = false;
-                    break;
-                }
-            }
-            if (!transitionsValid)
-                continue;
-            const first = startEndpoint(endpoints, orientations[0] ?? false);
-            const last = endEndpoint(endpoints, orientations[length - 1] ?? false);
-            variants.push({
-                constraints: [
-                    [sourceKey, first.accepts],
-                    [targetKey, last.accepts],
-                ],
-                equalities: [],
-            });
-        }
-    }
-    return uniqueEdgeVariants(variants);
-}
-function startEndpoint(endpoints, reversed) {
-    return reversed ? endpoints[1] : endpoints[0];
-}
-function endEndpoint(endpoints, reversed) {
-    return reversed ? endpoints[0] : endpoints[1];
-}
-function uniqueEdgeVariants(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = `${value.constraints
-            .map(([term, accepts]) => `${term}:${accepts.map(definitionRefIndex).sort().join(',')}`)
-            .join('|')}=${value.equalities.map(([left, right]) => `${left}:${right}`).join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
-}
-function uniqueCandidates(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = value.kind === 'exact'
-            ? `exact:${definitionRefIndex(value.ref)}`
-            : `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
-}
-function uniqueClasses(values) {
-    return [...new Map(values.map((value) => [definitionRefIndex(value), value])).values()];
-}
-class UnionFind {
-    #parents = new Map();
-    constructor(values) {
-        for (const value of values)
-            this.add(value);
-    }
-    add(value) {
-        if (!this.#parents.has(value))
-            this.#parents.set(value, value);
-    }
-    find(value) {
-        this.add(value);
-        const parent = this.#parents.get(value);
-        if (parent === value)
-            return value;
-        const root = this.find(parent);
-        this.#parents.set(value, root);
-        return root;
-    }
-    join(left, right) {
-        const a = this.find(left);
-        const b = this.find(right);
-        if (a !== b)
-            this.#parents.set(b, a);
-    }
-}

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

@@ -1,5 +1,5 @@
+import type { PolicyTyping } from '../../../language/policy/analysis/typing.js';
 import type { PolicyValidationContext } from './context.js';
-import { type PolicyTyping } from './typing.js';
 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;

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

@@ -1,12 +1,12 @@
 import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
 import { isBinaryInput } from '../../../language/callable/model/callable.js';
-import { admittedCheckClasses, neverAdmittedClasses, } from '../../../language/policy/analysis/checks.js';
+import { neverAdmittedClasses, } from '../../../language/policy/analysis/checks.js';
 import { checksNameTheCaller, isClassRuleChecks } from '../../../language/policy/model/policy.js';
 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 { escapePointer } from './context.js';
 import { referenceContracts } from './objects.js';
 import { contractOfNodeDefinition } from './typing.js';
 const formatDefinitionRef = Key.of;
@@ -26,7 +26,7 @@ function validateClassPolicyUses(context, typing, operation) {
         const ref = declaration.policies[operation];
         if (typeof ref !== 'object')
             continue;
-        const pointer = `/classes/${escapePointer(name)}/policies/${operation}`;
+        const pointer = `/classes/${escapePointerToken(name)}/policies/${operation}`;
         if (isClassRuleChecks(ref)) {
             // Structure admits Policy checks only on a Node Class: `self` is the observed exact Class.
             validateChecks(context, typing, ref, {
@@ -50,13 +50,7 @@ function validateClassPolicyUses(context, typing, operation) {
             context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every normalized branch of ${operation} Node Class ${name}.`, formatDefinitionRef(ref));
             continue;
         }
-        const endpoints = declaration.orientation === 'directed'
-            ? [declaration.endpoints.source, declaration.endpoints.target]
-            : declaration.endpoints;
-        const sources = typing.concreteEndpointClasses(endpoints[0].accepts);
-        const targets = typing.concreteEndpointClasses(endpoints[1].accepts);
-        const accepted = sources.every((source) => targets.every((target) => typing.policyAcceptsEdge(ref.name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })));
-        if (!accepted) {
+        if (!typing.policyAcceptsEdgeClass(ref.name, declaration)) {
             context.add('PL_USE', pointer, `${formatDefinitionRef(ref)} is not valid for every concrete source/target pair of ${operation} Edge Class ${name}.`, formatDefinitionRef(ref));
         }
     }
@@ -67,7 +61,7 @@ export function validateCallableUses(context, typing) {
             continue;
         validateChecks(context, typing, declaration.policy, {
             site: 'callable',
-            pointer: `/functions/${escapePointer(name)}/policy`,
+            pointer: `/functions/${escapePointerToken(name)}/policy`,
             input: isBinaryInput(declaration.input) ? declaration.input.metadata : declaration.input,
             instanceMethod: false,
         });
@@ -94,7 +88,7 @@ function validateDeclaredMethods(context, typing, namespace, name, methods, rece
             continue;
         validateChecks(context, typing, method.policy, {
             site: 'callable',
-            pointer: `/${namespace}/${escapePointer(name)}/methods/${escapePointer(methodName)}/policy`,
+            pointer: `/${namespace}/${escapePointerToken(name)}/methods/${escapePointerToken(methodName)}/policy`,
             input: method.input,
             receiver,
             instanceMethod: !method.static,
@@ -144,16 +138,12 @@ function visitChecks(validation, typing, expression, context, pointer, leaves) {
                 : referenceContracts(validation, expression.object.ref, objectPointer);
         if (contracts === undefined)
             return;
-        const typings = new Map(contracts.map((contract) => [
-            contractName(contract),
-            typing.policyBranchTyping(expression.check.name, contract),
-        ]));
-        const admitted = admittedCheckClasses(typings);
-        if (admitted === undefined) {
+        const classes = typing.checkLeafClasses(expression.check.name, contracts);
+        if (classes === undefined) {
             validation.add('PL_USE', pointer, `${formatDefinitionRef(expression.check)} is incompatible with ${SITE[context.site].objects}.`, formatDefinitionRef(expression.check));
             return;
         }
-        leaves.set(expression, { accepted: [...typings.keys()], admitted });
+        leaves.set(expression, classes);
         return;
     }
     const { key, values } = checkOperands(expression);
@@ -162,9 +152,6 @@ function visitChecks(validation, typing, expression, context, pointer, leaves) {
     }
     values.forEach((child, index) => visitChecks(validation, typing, child, context, `${pointer}/${key}/${index}`, leaves));
 }
-function contractName(contract) {
-    return contract.kind === 'exact' ? formatDefinitionRef(contract.ref) : 'default';
-}
 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.');

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

@@ -1,7 +1,8 @@
+import { PolicyTyping } from '../../../language/policy/analysis/typing.js';
 import { validatePolicyBudgets } from './budgets.js';
 import { PolicyValidationContext } from './context.js';
 import { validatePolicyReferences } from './references.js';
-import { PolicyTyping } from './typing.js';
+import { validatePolicyTyping } from './typing.js';
 import { validateCallableUses, validateReadUses, validateTraverseUses } from './uses.js';
 /**
  * Validates the closed V1 Policy language after structural parsing.
@@ -15,7 +16,7 @@ export function validatePolicies(environment, analysis) {
     validatePolicyReferences(context);
     validatePolicyBudgets(context);
     const typing = new PolicyTyping(context);
-    typing.validatePolicies();
+    validatePolicyTyping(context, typing);
     validateReadUses(context, typing);
     validateTraverseUses(context, typing);
     validateCallableUses(context, typing);

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

@@ -1,4 +1,5 @@
 /** The exact V1 value-schema grammar embedded in DomainSchema declarations. */
+import type { ValueKind } from '@astrale-os/kernel-dsl/value';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
@@ -13,3 +14,11 @@ export type { OrderingKind } from '../../language/value/ordering.js';
 export declare function validate(owner: DomainSchema, contract: JsonSchema, input: unknown, pointer?: string): readonly Diagnostic[];
 /** Return the one portable scalar ordering domain admitted by a property schema, if any. */
 export declare function classifyOrdering(owner: DomainSchema, contract: JsonSchema): OrderingKind | undefined;
+/** The value kind of a property schema: what a graph language may test on the property (Y4). */
+export declare function classifyValueKind(owner: DomainSchema, contract: JsonSchema): ValueKind;
+/**
+ * A warning for each class property whose value kind is `json` (an ambiguous union, an object, an
+ * array with repetitions): a Query filters it by equality only. Nothing refuses such a property;
+ * the CLI shows the warning to its author.
+ */
+export declare function valueKindWarnings(owner: DomainSchema): readonly Diagnostic<'VS_VALUE_KIND_JSON'>[];