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

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

@@ -1,12 +1,14 @@
+import { equalDefinitionRefs } from '../../addressing/definition-ref.js';
 import { Key } from '../../addressing/key.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
-import { classSatisfies as satisfiesClass, isGraphRoot } from '../../language/class/inheritance.js';
+import { classSatisfies as satisfiesClass, edgeContractRefines as refinesEdgeContract, } from '../../language/class/inheritance.js';
 import { lifetimeBreaches, lifetimeScope } from '../../language/class/lifetime.js';
 import { keyableProperty } from '../../language/class/unique.js';
 import { admitStateTopology } from '../../language/state/topology.js';
 import { isBlobValueSchema } from '../../language/value/model/blob.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
 import { createDomainValueSchemaRegistry, createValueSchemaRegistry, } from '../resolution/value.registry.js';
 const formatDefinitionRef = Key.of;
@@ -16,9 +18,9 @@ export function validateDefinitions(environment, analysis) {
     const schema = environment.candidate;
     let scope;
     for (const [name, declaration] of Object.entries(schema.classes)) {
-        const ref = localRef(schema.origin, name);
-        const pointer = `/classes/${escapePointer(name)}`;
-        if (!sameRef(declaration.ref, ref)) {
+        const ref = { origin: schema.origin, kind: 'class', name };
+        const pointer = `/classes/${escapePointerToken(name)}`;
+        if (!equalDefinitionRefs(declaration.ref, ref)) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Class ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(declaration.ref)));
         }
         if (declaration.abstract &&
@@ -40,7 +42,7 @@ export function validateDefinitions(environment, analysis) {
 function validateFacet(environment, declaration, pointer, diagnostics) {
     const valueRegistry = createValueSchemaRegistry(environment);
     for (const [name, property] of Object.entries(declaration.properties)) {
-        const propertyPointer = `${pointer}/properties/${escapePointer(name)}`;
+        const propertyPointer = `${pointer}/properties/${escapePointerToken(name)}`;
         if (isBlobValueSchema(property.schema) &&
             (declaration.kind !== 'node' || property.auto !== undefined || property.state !== undefined)) {
             diagnostics.push(diagnostic('DV_VALUE_SCHEMA', `${propertyPointer}/schema/x-astrale-value-kind`, 'Blob values are allowed only on non-automatic, non-state Node properties.'));
@@ -92,7 +94,7 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
     if (declaration.kind !== 'node')
         return;
     for (const [name, method] of Object.entries(declaration.methods)) {
-        const methodPointer = `${pointer}/methods/${escapePointer(name)}`;
+        const methodPointer = `${pointer}/methods/${escapePointerToken(name)}`;
         if (isMethodExecutable(declaration, method))
             continue;
         if (method.policy !== undefined) {
@@ -107,7 +109,7 @@ function validateFacet(environment, declaration, pointer, diagnostics) {
 function validateParents(environment, owner, ownerKind, parents, diagnostics) {
     for (const [index, parent] of parents.entries()) {
         const target = environment.resolve(parent);
-        const pointer = `/classes/${escapePointer(owner.name)}/extends/${index}`;
+        const pointer = `/classes/${escapePointerToken(owner.name)}/extends/${index}`;
         if (target === undefined) {
             diagnostics.push(diagnostic('DV_REF_RESOLVES', pointer, `Parent ${formatDefinitionRef(parent)} does not resolve exactly.`, formatDefinitionRef(parent)));
             continue;
@@ -244,42 +246,7 @@ function validateEdgeClassComposition(environment, diagnostics) {
 }
 /** Whether `child` safely refines its parent Edge contract `parent`. */
 export function edgeContractRefines(environment, child, parent) {
-    if (isGraphRoot(parent))
-        return true;
-    if (child.orientation !== parent.orientation)
-        return false;
-    if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
-        return false;
-    if (parent.constraints.acyclic === true && child.constraints.acyclic !== true)
-        return false;
-    if (child.orientation === 'directed' && parent.orientation === 'directed') {
-        return (endpointRefines(environment, child.endpoints.source, parent.endpoints.source) &&
-            countRefines(child.endpoints.source.outgoing, parent.endpoints.source.outgoing) &&
-            endpointRefines(environment, child.endpoints.target, parent.endpoints.target) &&
-            countRefines(child.endpoints.target.incoming, parent.endpoints.target.incoming));
-    }
-    if (child.orientation !== 'undirected' || parent.orientation !== 'undirected')
-        return false;
-    const refines = (childIndex, parentIndex) => endpointRefines(environment, child.endpoints[childIndex], parent.endpoints[parentIndex]) &&
-        countRefines(child.endpoints[childIndex].incident, parent.endpoints[parentIndex].incident);
-    const direct = refines(0, 0) && refines(1, 1);
-    if (direct)
-        return true;
-    return refines(0, 1) && refines(1, 0);
-}
-function endpointRefines(environment, child, parent) {
-    return child.accepts.every((accepted) => classSatisfies(environment, accepted, parent.accepts));
-}
-function countRefines(child, parent) {
-    const bounds = {
-        '0..*': [0, Number.POSITIVE_INFINITY],
-        '1..*': [1, Number.POSITIVE_INFINITY],
-        '0..1': [0, 1],
-        '1': [1, 1],
-    };
-    const [childMinimum, childMaximum] = bounds[child];
-    const [parentMinimum, parentMaximum] = bounds[parent];
-    return childMinimum >= parentMinimum && childMaximum <= parentMaximum;
+    return refinesEdgeContract(child, parent, (candidate, accepts) => classSatisfies(environment, candidate, accepts));
 }
 /** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
 export function classSatisfies(environment, candidate, accepts) {
@@ -294,12 +261,3 @@ export function classSatisfies(environment, candidate, accepts) {
         return required !== undefined && satisfiesClass(actual, required, resolve);
     });
 }
-function localRef(origin, name) {
-    return { origin, kind: 'class', name };
-}
-function sameRef(left, right) {
-    return left.origin === right.origin && left.kind === right.kind && left.name === right.name;
-}
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}

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;