@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/v1/schema/validation/json.json-schema.d.ts

@@ -0,0 +1,40 @@
+import type { core as zodCore } from 'zod';
+import type { DiagnosticCode as ValueDiagnosticCode } from '../../language/validation/diagnostic.js';
+import type { SchemaDiagnosticCode } from '../diagnostic.js';
+/** A JSON Schema of the published document, or a part of one. */
+export type JsonSchema = zodCore.JSONSchema.JSONSchema;
+/**
+ * A check JSON Schema cannot state, which the published document names: the code the Kernel
+ * reports, with its value code for a check on value schemas, and the rule in one plain sentence.
+ */
+export interface NamedRuleEntry {
+    readonly code: SchemaDiagnosticCode;
+    readonly valueCode?: ValueDiagnosticCode;
+    readonly statement: string;
+}
+/**
+ * `schema` with the `x-astrale-rule` marker naming the checks of `Rule` it leaves to the Kernel.
+ * `Rule` is given at each call, so that a name outside it does not compile.
+ */
+export declare function named<Rule extends string = never>(schema: JsonSchema, ...rules: [NoInfer<Rule>, ...NoInfer<Rule>[]]): JsonSchema;
+/**
+ * The check that a document is portable JSON, which `schema.decode` and `schema.accept` make first.
+ * JSON Schema reads a parsed value and compares numbers by their value: it states that no string or
+ * member name holds U+0000, and cannot state negative zero, a lone surrogate, a UTF-8 size, a
+ * nesting depth without one definition per level, a count of members, or what the text was.
+ */
+export declare const jsonValueRules: {
+    readonly 'portable-json': {
+        readonly code: 'DV_JSON_VALUE';
+        readonly statement: string;
+    };
+};
+export type JsonValueRule = keyof typeof jsonValueRules;
+/**
+ * Portable JSON in JSON Schema: `root` constrains the whole document, and `definitions` holds every
+ * value it reaches and every string. The named check leaves `x-astrale-rule` on `portable-json`.
+ */
+export declare function jsonValueJsonSchema(): {
+    readonly root: JsonSchema;
+    readonly definitions: Readonly<Record<string, JsonSchema>>;
+};

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

@@ -0,0 +1,46 @@
+import { RULES } from '../rule.js';
+/**
+ * `schema` with the `x-astrale-rule` marker naming the checks of `Rule` it leaves to the Kernel.
+ * `Rule` is given at each call, so that a name outside it does not compile.
+ */
+export function named(schema, ...rules) {
+    return { ...schema, 'x-astrale-rule': rules };
+}
+/**
+ * The check that a document is portable JSON, which `schema.decode` and `schema.accept` make first.
+ * JSON Schema reads a parsed value and compares numbers by their value: it states that no string or
+ * member name holds U+0000, and cannot state negative zero, a lone surrogate, a UTF-8 size, a
+ * nesting depth without one definition per level, a count of members, or what the text was.
+ */
+export const jsonValueRules = {
+    'portable-json': { code: 'DV_JSON_VALUE', statement: RULES.DV_JSON_VALUE.statement },
+};
+const VALUE = '#/$defs/portable-json';
+const TEXT = '#/$defs/portable-string';
+/**
+ * Portable JSON in JSON Schema: `root` constrains the whole document, and `definitions` holds every
+ * value it reaches and every string. The named check leaves `x-astrale-rule` on `portable-json`.
+ */
+export function jsonValueJsonSchema() {
+    return {
+        root: { $ref: VALUE },
+        definitions: {
+            'portable-json': named({
+                anyOf: [
+                    { type: 'null' },
+                    { type: 'boolean' },
+                    { type: 'number' },
+                    { $ref: TEXT },
+                    { type: 'array', items: { $ref: VALUE } },
+                    {
+                        type: 'object',
+                        propertyNames: { $ref: TEXT },
+                        additionalProperties: { $ref: VALUE },
+                    },
+                ],
+            }, 'portable-json'),
+            // The pattern is the character itself, which every regular-expression dialect reads.
+            'portable-string': { type: 'string', not: { pattern: '\u0000' } },
+        },
+    };
+}

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

@@ -1,4 +1,35 @@
+import type { PolicyExpression } from '../../../language/policy/model/policy.js';
+import type { DomainSchemaIR } from '../../model/schema.js';
 import type { PolicyValidationContext } from './context.js';
-import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks } from '../../../language/policy/analysis/budgets.js';
-export { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, };
+import { type CheckMeasure, type PolicyMeasure } from '../../../language/policy/analysis/budgets.js';
+/** What `PL_BUDGET` compares with `limits.policy` in one document, frozen. */
+export interface PolicyMeasures {
+    /** Each named Policy the DSL can measure, by name. */
+    readonly policies: Readonly<Record<string, PolicyMeasure>>;
+    /**
+     * The named Policies the DSL cannot measure, in document order: a composition that reaches
+     * itself, or that names a Policy the document does not declare or one it cannot measure.
+     */
+    readonly unmeasured: readonly string[];
+    /**
+     * Each check tree by the JSON Pointer of its position: the Policy of a Function or a Method, or
+     * the rule of a Class slot.
+     */
+    readonly checks: Readonly<Record<string, CheckMeasure>>;
+}
+/**
+ * Measure the Policies of a document as `PL_BUDGET` does: it reads the document's structure alone,
+ * so a document the structure admits is measured whatever its other rules decide. Throws
+ * `SchemaError` with the diagnostics of a document that is not portable JSON or that its
+ * structure refuses.
+ */
+export declare function measurePolicies(input: unknown): PolicyMeasures;
+/** The measures of one structured document, from its Policies once normalized. */
+export declare function measureDomainPolicies(schema: DomainSchemaIR, normalized?: ReadonlyMap<string, PolicyExpression>): PolicyMeasures;
+/** `PL_BUDGET`: every measure of the document within `limits.policy`. */
 export declare function validatePolicyBudgets(context: PolicyValidationContext): void;
+/**
+ * `PL_BUDGET` for one check tree at `pointer`, from its measure: the document's trees, and the
+ * checks of a contract a Node carries, which no document holds.
+ */
+export declare function validateCheckBudget(context: PolicyValidationContext, pointer: string, measure: CheckMeasure): void;

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

@@ -1,132 +1,98 @@
-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';
-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();
-    for (const name of Object.keys(context.environment.candidate.policies)) {
-        const measure = measurePolicy(context, name, new Set(), measures);
+import { deepFreeze } from '../../../language/freeze.js';
+import { limits } from '../../../language/limits.js';
+import { exceededLimits, measureChecks, policyMeasurer, } from '../../../language/policy/analysis/budgets.js';
+import { CLASS_OPERATIONS, isClassRuleChecks } from '../../../language/policy/model/policy.js';
+import { normalizePolicyChecks, normalizePolicyExpression, } from '../../../language/policy/normalization/normalize.js';
+import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
+import { structureDomainSchema } from '../domain.route.js';
+import { SITE } from './uses.js';
+/**
+ * Measure the Policies of a document as `PL_BUDGET` does: it reads the document's structure alone,
+ * so a document the structure admits is measured whatever its other rules decide. Throws
+ * `SchemaError` with the diagnostics of a document that is not portable JSON or that its
+ * structure refuses.
+ */
+export function measurePolicies(input) {
+    return measureDomainPolicies(structureDomainSchema(input));
+}
+/** The measures of one structured document, from its Policies once normalized. */
+export function measureDomainPolicies(schema, normalized = normalizedPolicies(schema)) {
+    const measurePolicy = policyMeasurer(schema.origin, normalized, (ref) => ref.origin === schema.origin &&
+        ref.kind === 'policy' &&
+        Object.hasOwn(schema.policies, ref.name));
+    const policies = {};
+    const unmeasured = [];
+    for (const name of Object.keys(schema.policies)) {
+        const measure = measurePolicy(name);
         if (measure === undefined)
-            continue;
-        const pointer = `/policies/${escapePointer(name)}`;
-        if (measure.depth > MAX_PATTERN_DEPTH) {
-            context.add('PL_BUDGET', pointer, `Expanded Pattern depth ${measure.depth} exceeds ${MAX_PATTERN_DEPTH}.`);
-        }
-        if (measure.edgeCounts.length > MAX_BRANCHES) {
-            context.add('PL_BUDGET', pointer, `Expanded Pattern has more than ${MAX_BRANCHES} normalized branches.`);
-        }
-        const edgeMaximum = Math.max(0, ...measure.edgeCounts);
-        if (edgeMaximum > MAX_EDGES) {
-            context.add('PL_BUDGET', pointer, `A normalized branch contains ${edgeMaximum} graph predicates; the maximum is ${MAX_EDGES}.`);
-        }
-        if (measure.domains.size > MAX_DOMAINS) {
-            context.add('PL_BUDGET', pointer, `Expanded Pattern references ${measure.domains.size} Domains; the maximum is ${MAX_DOMAINS}.`);
-        }
+            unmeasured.push(name);
+        else
+            policies[name] = measure;
     }
-}
-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 checks = {};
+    for (const [pointer, expression] of checkTrees(schema)) {
+        checks[pointer] = measureChecks(normalizePolicyChecks(expression));
     }
-    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);
+    return deepFreeze({ policies, unmeasured, checks });
 }
-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)] : []),
-            ]),
-        };
+/** `PL_BUDGET`: every measure of the document within `limits.policy`. */
+export function validatePolicyBudgets(context) {
+    const measures = measureDomainPolicies(context.environment.candidate, context.normalized);
+    for (const [name, measure] of Object.entries(measures.policies)) {
+        for (const limit of exceededLimits(measure)) {
+            context.add('PL_BUDGET', `/policies/${escapePointerToken(name)}`, REFUSAL[limit](measure));
+        }
     }
-    if ('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];
-                }),
-            ]),
-        };
+    for (const [pointer, measure] of Object.entries(measures.checks)) {
+        validateCheckBudget(context, pointer, measure);
     }
-    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;
+/**
+ * `PL_BUDGET` for one check tree at `pointer`, from its measure: the document's trees, and the
+ * checks of a contract a Node carries, which no document holds.
+ */
+export function validateCheckBudget(context, pointer, measure) {
+    if (exceededLimits(measure).length === 0)
+        return;
+    const { checkDepth, checkBranches, checkLeaves } = limits.policy;
+    // A callable holds its checks at `policy`; a Class rule at `policies/{operation}`.
+    const site = SITE[pointer.endsWith('/policy') ? 'callable' : 'class'];
+    context.add('PL_BUDGET', pointer, `${site.checks} require depth <= ${checkDepth}, branches <= ${checkBranches}, and leaves <= ${checkLeaves}; got ${measure.checkDepth}, ${measure.checkBranches}, ${measure.checkLeaves}.`);
+}
+/** How `PL_BUDGET` explains each limit a named Policy exceeds. */
+const REFUSAL = {
+    patternDepth: (measure) => `Expanded Pattern depth ${measure.patternDepth} exceeds ${limits.policy.patternDepth}.`,
+    normalizedBranches: () => `Expanded Pattern has more than ${limits.policy.normalizedBranches} normalized branches.`,
+    edgePredicates: (measure) => `A normalized branch contains ${measure.edgePredicates} graph predicates; the maximum is ${limits.policy.edgePredicates}.`,
+    referencedDomains: (measure) => `Expanded Pattern references ${measure.referencedDomains} Domains; the maximum is ${limits.policy.referencedDomains}.`,
+};
+function normalizedPolicies(schema) {
+    return new Map(Object.entries(schema.policies).map(([name, declaration]) => [
+        name,
+        normalizePolicyExpression(declaration.expression),
+    ]));
+}
+/** Every check tree of a document with the pointer of its position, in document order. */
+function* checkTrees(schema) {
+    for (const [name, declaration] of Object.entries(schema.classes)) {
+        const owner = `/classes/${escapePointerToken(name)}`;
+        for (const operation of CLASS_OPERATIONS) {
+            const rule = declaration.policies[operation];
+            if (typeof rule === 'object' && isClassRuleChecks(rule)) {
+                yield [`${owner}/policies/${operation}`, rule];
+            }
+        }
+        if (declaration.kind !== 'node')
+            continue;
+        for (const [method, value] of Object.entries(declaration.methods)) {
+            if (typeof value.policy === 'object') {
+                yield [`${owner}/methods/${escapePointerToken(method)}/policy`, value.policy];
             }
-            if (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;
+    for (const [name, declaration] of Object.entries(schema.functions)) {
+        if (typeof declaration.policy === 'object') {
+            yield [`/functions/${escapePointerToken(name)}/policy`, declaration.policy];
+        }
+    }
 }

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

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

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

@@ -1,7 +1,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;
@@ -62,17 +62,14 @@ export class PolicyValidationContext {
         }
         return resolved.declaration;
     }
-    /** Return true when candidate is the required Class or a same-kind descendant. */
-    classExtends(candidate, required) {
-        const resolve = (ref) => this.environment.resolveAny(ref)?.declaration;
-        const actual = resolve(candidate);
-        const target = resolve(required);
-        return actual !== undefined && target !== undefined && classSatisfies(actual, target, resolve);
+    resolveClass(ref) {
+        return this.environment.resolveAny(ref)?.declaration;
+    }
+    /** The contract a Policy pattern reference types, reporting an invalid one under `/policies`. */
+    referenceContract(ref) {
+        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,24 +1,22 @@
+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 { MAX_REPEAT, MAX_VARIABLES } from './budgets.js';
-import { escapePointer } from './context.js';
+import { escapePointerToken } from '../../../language/value/syntax/pointer.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;
         context.normalized.set(name, normalizePolicyExpression(expression));
         if ('match' in expression)
-            validateMatch(context, name, expression.match, pointer);
+            validateMatch(context, name, expression.match, `${pointer}/expression`);
         else
-            validateComposition(context, expression, pointer);
+            validateComposition(context, expression, `${pointer}/expression`);
     }
     validateCycles(context);
 }
@@ -54,22 +52,14 @@ function validatePatternNode(context, pattern, pointer, scope, declarations, use
         context.resolveEdge(pattern.class, `${pointer}/class`);
         validateTerm(context, pattern.source, `${pointer}/source`, scope, uses);
         validateTerm(context, pattern.target, `${pointer}/target`, scope, uses);
-        if (pattern.repeat !== undefined) {
-            const { min, max } = pattern.repeat;
-            if (!Number.isInteger(min) ||
-                !Number.isInteger(max) ||
-                min < 0 ||
-                max < min ||
-                max > MAX_REPEAT) {
-                context.add('PL_REPEAT', `${pointer}/repeat`, `Repeat requires integral bounds 0 <= min <= max <= ${MAX_REPEAT}.`);
-            }
+        // The structure bounds each to an integer from 0 to `limits.policy.repetition`; only their
+        // order is left.
+        if (pattern.repeat !== undefined && pattern.repeat.max < pattern.repeat.min) {
+            context.add('PL_REPEAT', `${pointer}/repeat`, 'Repeat requires min <= max.');
         }
         return;
     }
     if ('exists' in pattern) {
-        if (pattern.exists.nodes.length > MAX_VARIABLES) {
-            context.add('PL_BUDGET', `${pointer}/exists/nodes`, `An exists expression declares ${pattern.exists.nodes.length} variables; the maximum is ${MAX_VARIABLES}.`);
-        }
         const nested = new Set(scope);
         for (const [index, node] of pattern.exists.nodes.entries()) {
             const id = node.variable.id;
@@ -93,9 +83,6 @@ function validatePatternNode(context, pattern, pointer, scope, declarations, use
         return;
     }
     const { key, values } = patternOperands(pattern);
-    if (values.length === 0) {
-        context.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
-    }
     values.forEach((child, index) => validatePatternNode(context, child, `${pointer}/${key}/${index}`, scope, declarations, uses));
 }
 function validateTerm(context, term, pointer, scope, uses) {
@@ -113,9 +100,6 @@ function validateTerm(context, term, pointer, scope, uses) {
 function validateComposition(context, declaration, pointer) {
     const key = 'allOf' in declaration ? 'allOf' : 'anyOf';
     const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
-    if (refs.length === 0) {
-        context.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
-    }
     refs.forEach((ref, index) => context.resolvePolicy(ref, `${pointer}/${key}/${index}`));
 }
 function validateCycles(context) {
@@ -123,7 +107,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;