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

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

@@ -0,0 +1,24 @@
+import type { core as zodCore } from 'zod';
+type JsonSchema = zodCore.JSONSchema.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>>;
+};
+export {};

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

@@ -0,0 +1,36 @@
+import { RULES } from '../rule.js';
+/**
+ * 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': {
+                anyOf: [
+                    { type: 'null' },
+                    { type: 'boolean' },
+                    { type: 'number' },
+                    { $ref: TEXT },
+                    { type: 'array', items: { $ref: VALUE } },
+                    { type: 'object', propertyNames: { $ref: TEXT }, additionalProperties: { $ref: VALUE } },
+                ],
+                'x-astrale-rule': '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.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,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,13 @@ 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 MAX_REPEAT; 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 +82,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 +99,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 +106,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;