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

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

@@ -1,9 +1,12 @@
+import { equalDefinitionRefs } from '../../addressing/definition-ref.js';
 import { Key } from '../../addressing/key.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
 import { coveringEdgeUniqueTuples, coveringNodeUniqueTuples, edgeUniqueKeys, nodeUniqueKeys, } from '../../language/class/unique.js';
+import { checkCoreEdgeSet, checkHeldKeys, coreEndpointsSatisfy, } from '../../language/core/facts.js';
 import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
 import { classSatisfies } from './class.js';
 const formatDefinitionRef = Key.of;
@@ -15,38 +18,27 @@ export function validateCore(environment, analysis, registry) {
     validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics);
     return Object.freeze(diagnostics);
 }
-/**
- * No two Core Nodes hold one key under a tuple covering their Classes, whichever Class or ancestor
- * declares it (DV-NODE-UNIQUE); Activation checks them against stored data.
- */
+/** No two Core Nodes hold one key under a tuple covering their Classes, whichever declares it. */
 function validateCoreNodeKeys(environment, nodesByRef, diagnostics) {
     const resolve = (ref) => environment.resolveAny(ref)?.declaration;
-    const holders = new Map();
-    for (const node of nodesByRef.values()) {
+    checkHeldKeys(nodesByRef.values(), (node) => {
         const declaration = resolve(node.classRef);
         if (declaration === undefined)
-            continue;
-        const pointer = `/core/nodes/${escapePointer(node.slug)}`;
-        const keys = nodeUniqueKeys(coveringNodeUniqueTuples(declaration, resolve), {
+            return [];
+        return nodeUniqueKeys(coveringNodeUniqueTuples(declaration, resolve), {
             props: environment.candidate.core.nodes[node.slug].properties,
         });
-        const previous = keys.map((key) => holders.get(key)).find((at) => at !== undefined);
-        if (previous !== undefined) {
-            diagnostics.push(diagnostic('DV_CORE_NODE_UNIQUE', pointer, `Core Node holds a key the Core Node at ${previous} holds.`));
-        }
-        for (const key of keys)
-            if (!holders.has(key))
-                holders.set(key, pointer);
-    }
+    }, (node, previous) => diagnostics.push(diagnostic('DV_CORE_NODE_UNIQUE', nodePointer(node), `Core Node holds a key the Core Node at ${nodePointer(previous)} holds.`)));
+}
+function nodePointer(node) {
+    return `/core/nodes/${escapePointerToken(node.slug)}`;
 }
 function resolveCoreNodes(environment, analysis, registry, diagnostics) {
     const nodes = new Map();
     for (const [slug, node] of Object.entries(environment.candidate.core.nodes)) {
-        const pointer = `/core/nodes/${escapePointer(slug)}`;
+        const pointer = `/core/nodes/${escapePointerToken(slug)}`;
         const ref = { origin: environment.candidate.origin, kind: 'core', name: slug };
-        if (node.ref.origin !== ref.origin ||
-            node.ref.kind !== ref.kind ||
-            node.ref.name !== ref.name) {
+        if (!equalDefinitionRefs(node.ref, ref)) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Core ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(node.ref)));
         }
         const resolved = environment.resolve(node.class);
@@ -89,13 +81,7 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
         const declaration = resolved.declaration;
         if (source === undefined || target === undefined)
             continue;
-        const endpointsSatisfy = declaration.orientation === 'directed'
-            ? endpointSatisfies(environment, source, declaration.endpoints.source.accepts) &&
-                endpointSatisfies(environment, target, declaration.endpoints.target.accepts)
-            : (endpointSatisfies(environment, source, declaration.endpoints[0].accepts) &&
-                endpointSatisfies(environment, target, declaration.endpoints[1].accepts)) ||
-                (endpointSatisfies(environment, source, declaration.endpoints[1].accepts) &&
-                    endpointSatisfies(environment, target, declaration.endpoints[0].accepts));
+        const endpointsSatisfy = coreEndpointsSatisfy(declaration, source, target, (endpoint, accepts) => endpointSatisfies(environment, endpoint, accepts));
         if (!endpointsSatisfy) {
             diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.`, formatDefinitionRef(edge.class)));
             continue;
@@ -158,185 +144,65 @@ function validateCreationProperties(definition, properties, registry, code, poin
     }
 }
 function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
-    const seen = new Map();
-    const edgeSlices = new Map();
-    for (const [name, candidate] of Object.entries(environment.candidate.classes)) {
-        if (candidate.kind !== 'edge')
-            continue;
-        const ref = {
-            origin: environment.candidate.origin,
-            kind: 'class',
-            name,
-        };
-        const resolved = environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
-            continue;
-        }
-        edgeSlices.set(definitionRefIndex(ref), {
-            declaration: resolved.declaration,
-            edges: [],
-        });
-    }
-    for (const edge of edges) {
-        const classKey = definitionRefIndex(edge.value.class);
-        const [source, target] = edge.declaration.orientation === 'undirected' &&
-            compareUnicode(edge.source.key, edge.target.key) > 0
-            ? [edge.target.key, edge.source.key]
-            : [edge.source.key, edge.target.key];
-        const key = `${classKey}\u0000${source}\u0000${target}`;
-        const previous = seen.get(key);
-        if (previous !== undefined) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_KEY', edge.pointer, `Core Edge duplicates the normalized EdgeKey declared at ${previous}.`));
-        }
-        else {
-            seen.set(key, edge.pointer);
-        }
-        const slice = edgeSlices.get(classKey) ?? {
-            declaration: edge.declaration,
-            edges: [],
-        };
-        slice.edges.push(edge);
-        edgeSlices.set(classKey, slice);
-        if (edge.declaration.constraints.noSelf === true && edge.source.key === edge.target.key) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', edge.pointer, 'Core Edge violates noSelf.'));
-        }
-    }
-    validateCoreEdgeKeys(environment, edges, diagnostics);
-    for (const { declaration, edges: classEdges } of edgeSlices.values()) {
-        if (declaration.constraints.acyclic === true && hasDirectedCycle(classEdges)) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', '/core/edges', 'Core Edge set violates exact-Class acyclicity.'));
-        }
-        validateCardinality(environment, declaration, classEdges, nodesByRef, diagnostics);
-    }
-}
-/**
- * No two Core Edges hold one key under a tuple covering their Classes, whichever Class or ancestor
- * declares it (DV-EDGE-UNIQUE). Core Edges have no slug, so only tuples of endpoints and
- * Properties can bind them; Activation checks them against stored data.
- */
-function validateCoreEdgeKeys(environment, edges, diagnostics) {
+    const { candidate } = environment;
     const resolve = (ref) => environment.resolveAny(ref)?.declaration;
-    const holders = new Map();
-    for (const edge of edges) {
-        const keys = edgeUniqueKeys(coveringEdgeUniqueTuples(edge.declaration, resolve), {
+    checkCoreEdgeSet({
+        edges: edges.map((edge) => ({
+            edge,
+            class: definitionRefIndex(edge.value.class),
+            contract: edge.declaration,
+            source: factEndpoint(edge.source, edge.pointer),
+            target: factEndpoint(edge.target, edge.pointer),
+        })),
+        classes: Object.entries(candidate.classes).flatMap(([name, declaration]) => {
+            if (declaration.kind !== 'edge')
+                return [];
+            const ref = { origin: candidate.origin, kind: 'class', name };
+            const resolved = environment.resolve(ref);
+            if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
+                return [];
+            }
+            return [
+                { key: definitionRefIndex(ref), contract: resolved.declaration },
+            ];
+        }),
+        nodes: [...nodesByRef.values()].map((node) => ({
+            key: node.key,
+            class: node.classRef,
+            pointer: nodePointer(node),
+        })),
+        satisfies: (ref, accepts) => classSatisfies(environment, ref, accepts),
+        keys: ({ edge }) => edgeUniqueKeys(coveringEdgeUniqueTuples(edge.declaration, resolve), {
             source: edge.source.key,
             target: edge.target.key,
             props: edge.value.properties,
-        });
-        const previous = keys.map((key) => holders.get(key)).find((pointer) => pointer !== undefined);
-        if (previous !== undefined) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_UNIQUE', edge.pointer, `Core Edge holds a key the Core Edge at ${previous} holds.`));
-        }
-        for (const key of keys)
-            if (!holders.has(key))
-                holders.set(key, edge.pointer);
+        }),
+        sameIncident: sameIncidentEndpointContract,
+        report: (issue) => diagnostics.push(coreEdgeDiagnostic(issue)),
+    });
+}
+/** A projected member's degree is reported at the Edge that names it. */
+function factEndpoint(endpoint, pointer) {
+    return endpoint.kind === 'member'
+        ? { key: endpoint.key, member: { class: endpoint.classRef, pointer } }
+        : endpoint;
+}
+function coreEdgeDiagnostic(issue) {
+    switch (issue.kind) {
+        case 'identity':
+            return diagnostic('DV_CORE_EDGE_KEY', issue.edge.pointer, `Core Edge duplicates the normalized EdgeKey declared at ${issue.previous.pointer}.`);
+        case 'no-self':
+            return diagnostic('DV_CORE_EDGE_CONSTRAINTS', issue.edge.pointer, 'Core Edge violates noSelf.');
+        case 'key':
+            return diagnostic('DV_CORE_EDGE_UNIQUE', issue.edge.pointer, `Core Edge holds a key the Core Edge at ${issue.previous.pointer} holds.`);
+        case 'acyclic':
+            return diagnostic('DV_CORE_EDGE_CONSTRAINTS', '/core/edges', 'Core Edge set violates exact-Class acyclicity.');
+        case 'degree':
+            return diagnostic('DV_CORE_EDGE_CONSTRAINTS', issue.pointer, `Core degree ${issue.degree} violates ${issue.endpoint.role} Edge count ${issue.count}.`);
     }
 }
-function validateCardinality(environment, declaration, edges, nodesByRef, diagnostics) {
-    const subjects = cardinalitySubjects(edges, nodesByRef);
-    if (declaration.orientation === 'undirected') {
-        const [first, second] = declaration.endpoints;
-        for (const subject of subjects) {
-            const matchesFirst = classSatisfies(environment, subject.classRef, first.accepts);
-            const matchesSecond = classSatisfies(environment, subject.classRef, second.accepts);
-            if (!matchesFirst && !matchesSecond)
-                continue;
-            const degree = edges.filter((edge) => edge.source.key === subject.key || edge.target.key === subject.key).length;
-            if (matchesFirst)
-                checkBound(first, first.incident, degree, subject, diagnostics);
-            if (matchesSecond && !sameIncidentEndpointContract(first, second)) {
-                checkBound(second, second.incident, degree, subject, diagnostics);
-            }
-        }
-        return;
-    }
-    for (const subject of subjects) {
-        if (classSatisfies(environment, subject.classRef, declaration.endpoints.source.accepts)) {
-            const degree = edges.filter((edge) => edge.source.key === subject.key).length;
-            checkBound(declaration.endpoints.source, declaration.endpoints.source.outgoing, degree, subject, diagnostics);
-        }
-        if (classSatisfies(environment, subject.classRef, declaration.endpoints.target.accepts)) {
-            const degree = edges.filter((edge) => edge.target.key === subject.key).length;
-            checkBound(declaration.endpoints.target, declaration.endpoints.target.incoming, degree, subject, diagnostics);
-        }
-    }
-}
-/**
- * Every declared Core Node proves its own complete degree, so both bounds hold. A Definition
- * endpoint is only named by the Edges that reach it: the Domain may also create ordinary Edges of
- * the same Class against it, so a minimum is unprovable here and only the maximum is enforced.
- */
-function cardinalitySubjects(edges, nodesByRef) {
-    const subjects = new Map();
-    for (const node of nodesByRef.values()) {
-        subjects.set(node.key, {
-            key: node.key,
-            classRef: node.classRef,
-            pointer: `/core/nodes/${escapePointer(node.slug)}`,
-            minimum: true,
-        });
-    }
-    for (const edge of edges) {
-        for (const endpoint of [edge.source, edge.target]) {
-            if (endpoint.kind !== 'member' || subjects.has(endpoint.key))
-                continue;
-            subjects.set(endpoint.key, {
-                key: endpoint.key,
-                classRef: endpoint.classRef,
-                pointer: edge.pointer,
-                minimum: false,
-            });
-        }
-    }
-    return Object.freeze([...subjects.values()]);
-}
-function checkBound(endpoint, count, degree, subject, diagnostics) {
-    const [minimum, maximum] = countBounds(count);
-    if (degree <= maximum && (degree >= minimum || !subject.minimum))
-        return;
-    diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', subject.pointer, `Core degree ${degree} violates ${endpoint.role} Edge count ${count}.`));
-}
 function sameIncidentEndpointContract(left, right) {
     return (left.incident === right.incident &&
         left.accepts.length === right.accepts.length &&
         left.accepts.every((ref, index) => definitionRefIndex(ref) === definitionRefIndex(right.accepts[index])));
 }
-function countBounds(value) {
-    switch (value) {
-        case '0..*':
-            return [0, Number.POSITIVE_INFINITY];
-        case '1..*':
-            return [1, Number.POSITIVE_INFINITY];
-        case '0..1':
-            return [0, 1];
-        case '1':
-            return [1, 1];
-    }
-}
-function hasDirectedCycle(edges) {
-    const outgoing = new Map();
-    for (const edge of edges) {
-        const targets = outgoing.get(edge.source.key) ?? [];
-        targets.push(edge.target.key);
-        outgoing.set(edge.source.key, targets);
-    }
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (key) => {
-        if (visiting.has(key))
-            return true;
-        if (visited.has(key))
-            return false;
-        visiting.add(key);
-        for (const target of outgoing.get(key) ?? [])
-            if (visit(target))
-                return true;
-        visiting.delete(key);
-        visited.add(key);
-        return false;
-    };
-    return [...outgoing.keys()].some(visit);
-}
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

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

@@ -1,4 +1,4 @@
-import { compareUnicode } from '../../addressing/ordering.js';
+import { orderAndDeduplicate } from '../../language/validation/diagnostic.js';
 import { analyzeDefinitions } from '../analysis/class.js';
 import { buildDomainResolutionContext } from '../resolution/context.js';
 import { createValueSchemaRegistry } from '../resolution/value.registry.js';
@@ -27,12 +27,3 @@ export function validateDomainSchemaSemantics(schema, lookup) {
         diagnostics: Object.freeze(orderAndDeduplicate(diagnostics)),
     });
 }
-function orderAndDeduplicate(diagnostics) {
-    const unique = new Map();
-    for (const value of diagnostics) {
-        unique.set(`${value.pointer}\u0000${value.code}\u0000${value.ref ?? ''}\u0000${value.message}`, value);
-    }
-    return [...unique.values()].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
-        compareUnicode(left.code, right.code) ||
-        compareUnicode(left.message, right.message));
-}

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

@@ -3,6 +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, } from '../../addressing/patterns.js';
 import { MEDIA_TYPE_PATTERN } from '../../language/class/model/data.js';
 import * as metadata from '../../language/definition/metadata.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { SchemaError, diagnostic } from '../diagnostic.js';
 import { DOMAIN_FORMAT, DOMAIN_VERSION } from '../model/format.js';
 const originSchema = string().min(3).max(253).regex(DOMAIN_ORIGIN_PATTERN);
@@ -498,8 +499,5 @@ function valueAtPath(input, path) {
 function pointer(path) {
     if (path.length === 0)
         return '';
-    return `/${path.map((segment) => escapePointerSegment(String(segment))).join('/')}`;
-}
-function escapePointerSegment(segment) {
-    return segment.replaceAll('~', '~0').replaceAll('/', '~1');
+    return `/${path.map((segment) => escapePointerToken(String(segment))).join('/')}`;
 }

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

@@ -1,19 +1,13 @@
-import { policyObjectOrigin, policyVariableClass } from '../../../language/index.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';
-import { escapePointer } 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, policyMeasurer, } from '../../../language/policy/analysis/budgets.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) {
-    // Measure every distinct composition node once. A node's expanded measure is independent of the
-    // path that reaches it (the only path-sensitive outcome, the back-edge `undefined`, already holds
-    // for every node on or reaching a composition cycle, regardless of entry), so caching the
-    // completed result by node identity turns path enumeration over the composition DAG into work
-    // linear in the number of nodes while preserving the exact measure and PL_BUDGET decision.
-    const measures = new Map();
+    const measurePolicy = policyMeasurer(context.environment.candidate.origin, context.normalized, (ref) => context.isLocalPolicy(ref));
     for (const name of Object.keys(context.environment.candidate.policies)) {
-        const measure = measurePolicy(context, name, new Set(), measures);
+        const measure = measurePolicy(name);
         if (measure === undefined)
             continue;
-        const pointer = `/policies/${escapePointer(name)}`;
+        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}.`);
         }
@@ -29,104 +23,3 @@ export function validatePolicyBudgets(context) {
         }
     }
 }
-function measurePolicy(context, name, visiting, measures) {
-    if (visiting.has(name))
-        return undefined;
-    if (measures.has(name))
-        return measures.get(name);
-    const declaration = context.normalized.get(name);
-    if (declaration === undefined)
-        return undefined;
-    const nested = new Set(visiting);
-    nested.add(name);
-    const measure = measureDeclaration(context, declaration, nested, measures);
-    measures.set(name, measure);
-    return measure;
-}
-function measureDeclaration(context, declaration, nested, measures) {
-    if ('match' in declaration) {
-        return measurePattern(declaration.match, context.environment.candidate.origin);
-    }
-    const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
-    const children = refs.flatMap((ref) => {
-        if (!context.isLocalPolicy(ref))
-            return [];
-        const value = measurePolicy(context, ref.name, nested, measures);
-        return value === undefined ? [] : [value];
-    });
-    if (children.length !== refs.length || children.length === 0)
-        return undefined;
-    return combineMeasures('allOf' in declaration ? 'allOf' : 'anyOf', children);
-}
-function measurePattern(pattern, ownOrigin) {
-    if ('sameNode' in pattern)
-        return {
-            depth: 1,
-            edgeCounts: [1],
-            domains: new Set([
-                ownOrigin,
-                ...[pattern.sameNode.left, pattern.sameNode.right].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
-            ]),
-        };
-    if (isEdge(pattern)) {
-        return {
-            depth: 1,
-            edgeCounts: [1],
-            domains: new Set([
-                ownOrigin,
-                pattern.class.origin,
-                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
-            ]),
-        };
-    }
-    if ('exists' in pattern) {
-        const child = measurePattern(pattern.exists.where, ownOrigin);
-        return {
-            depth: child.depth + 1,
-            edgeCounts: child.edgeCounts,
-            domains: new Set([
-                ...child.domains,
-                ...pattern.exists.nodes.flatMap((node) => {
-                    const ref = policyVariableClass(node);
-                    return ref === undefined ? [] : [ref.origin];
-                }),
-            ]),
-        };
-    }
-    const { key, values } = patternOperands(pattern);
-    return combineMeasures(key, values.map((child) => measurePattern(child, ownOrigin)));
-}
-function combineMeasures(key, children) {
-    const depth = 1 + Math.max(0, ...children.map((child) => child.depth));
-    const domains = new Set(children.flatMap((child) => [...child.domains]));
-    if (key === 'anyOf') {
-        return {
-            depth,
-            edgeCounts: children.flatMap((child) => child.edgeCounts).slice(0, BRANCH_OVERFLOW),
-            domains,
-        };
-    }
-    let edgeCounts = [0];
-    for (const child of children) {
-        const next = [];
-        for (const left of edgeCounts) {
-            for (const right of child.edgeCounts) {
-                next.push(left + right);
-                if (next.length >= BRANCH_OVERFLOW)
-                    break;
-            }
-            if (next.length >= BRANCH_OVERFLOW)
-                break;
-        }
-        edgeCounts = next;
-    }
-    return { depth, edgeCounts, domains };
-}
-function patternOperands(value) {
-    return 'allOf' in value
-        ? { key: 'allOf', values: value.allOf }
-        : { key: 'anyOf', values: value.anyOf };
-}
-function isEdge(value) {
-    return 'source' in value;
-}

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

@@ -1,11 +1,12 @@
 import type { ClassDefinition } from '../../../language/class/model/class.js';
-import type { PolicyExpression } from '../../../language/policy/model/policy.js';
+import type { ObjectContract, PolicyTypingScope } from '../../../language/policy/analysis/typing.js';
+import type { PolicyExpression, PolicyObjectRef } from '../../../language/policy/model/policy.js';
 import type { DefinitionAnalysisResult } from '../../analysis/class.js';
 import type { SchemaDiagnostic, SchemaDiagnosticCode } from '../../diagnostic.js';
 import type { DomainResolutionContext } from '../../resolution/context.js';
 import type { IndexedClassDefinition } from '../../resolution/definition.index.js';
 import { type ClassRef, type PolicyRef } from '../../../addressing/index.js';
-export declare class PolicyValidationContext {
+export declare class PolicyValidationContext implements PolicyTypingScope {
     #private;
     readonly environment: DomainResolutionContext;
     readonly analysis: DefinitionAnalysisResult;
@@ -23,6 +24,7 @@ export declare class PolicyValidationContext {
     }> | undefined;
     /** Return true when candidate is the required Class or a same-kind descendant. */
     classExtends(candidate: ClassRef, required: ClassRef): boolean;
+    /** 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;
 }
-export declare function escapePointer(value: string): string;

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

@@ -2,6 +2,7 @@ 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;
 export class PolicyValidationContext {
     environment;
@@ -69,10 +70,11 @@ export class PolicyValidationContext {
         const target = resolve(required);
         return actual !== undefined && target !== undefined && classSatisfies(actual, target, resolve);
     }
+    /** The contract a Policy pattern reference types, reporting an invalid one under `/policies`. */
+    referenceContract(ref) {
+        return referenceContracts(this, ref, '/policies')?.[0];
+    }
     add(code, pointer, message, ref) {
         this.diagnostics.push(diagnostic(code, pointer, message, ref));
     }
 }
-export function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

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

@@ -1,4 +1,4 @@
 import type { PolicyObjectRef } from '../../../language/index.js';
+import type { ObjectContract } from '../../../language/policy/analysis/typing.js';
 import type { PolicyValidationContext } from './context.js';
-import type { ObjectContract } from './typing.js';
 export declare function referenceContracts(validation: PolicyValidationContext, ref: PolicyObjectRef, pointer: string): readonly ObjectContract[] | undefined;

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;