@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.11

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

@@ -1,11 +1,16 @@
 import { z } from 'zod';
 import { PropertyKey as SemanticPropertyKey } from '../../addressing/index.js';
-import { MEDIA_TYPE_PATTERN } from '../definition/data.js';
-import { DomainSchemaError, diagnostic } from '../diagnostic.js';
-import * as metadata from '../metadata.js';
-import { CORE_SLUG_PATTERN, DOMAIN_FORMAT, DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTERN, DOMAIN_VERSION, MEMBER_NAME_PATTERN, } from '../reference.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 { SchemaError, diagnostic } from '../diagnostic.js';
+import { DOMAIN_FORMAT, DOMAIN_VERSION } from '../model/format.js';
 const originSchema = z.string().min(3).max(253).regex(DOMAIN_ORIGIN_PATTERN);
 const memberNameSchema = z.string().regex(MEMBER_NAME_PATTERN);
+const dependencyAliasSchema = z
+    .string()
+    .regex(DEPENDENCY_ALIAS_PATTERN)
+    .refine((value) => value !== '__proto__' && value !== 'prototype' && value !== 'constructor', 'Expected a non-reserved dependency alias.');
 const propertyKeySchema = z
     .string()
     .refine(SemanticPropertyKey.is, 'Expected a canonical PropertyKey.');
@@ -26,26 +31,26 @@ const jsonValueSchema = z.lazy(() => z.union([
 ]));
 const jsonObjectSchema = z.record(z.string(), jsonValueSchema);
 const jsonSchemaSchema = z.union([z.boolean(), jsonObjectSchema]);
-const propertySchemaRecord = z.record(memberNameSchema, jsonSchemaSchema);
-const requiredPropertyNames = uniqueArray(memberNameSchema);
-const propertyObjectSchema = z.strictObject({
-    type: z.literal('object'),
-    properties: propertySchemaRecord,
-    required: requiredPropertyNames,
-    additionalProperties: z.literal(false),
-});
 const dataDeclarationSchema = z.strictObject({
     mediaType: z.string().regex(MEDIA_TYPE_PATTERN),
 });
-const propertyMetadataSchema = z.strictObject({
+const propertyDefinitionSchema = z.strictObject({
+    schema: jsonSchemaSchema,
+    required: z.boolean(),
     visibility: z.enum(['public', 'private']),
+    auto: z
+        .strictObject({
+        on: uniqueArray(z.enum(['create', 'update'])).min(1),
+        set: z.literal('instant'),
+    })
+        .optional(),
+    description: descriptionSchema.optional(),
 });
-const propertyMetadataRecordSchema = z.record(memberNameSchema, propertyMetadataSchema);
+const propertyRecordSchema = z.record(memberNameSchema, propertyDefinitionSchema);
 const domainDependencySchema = z.strictObject({
     origin: originSchema,
     revision: revisionSchema,
 });
-const interfaceRefSchema = absoluteRefSchema('interface');
 const classRefSchema = absoluteRefSchema('class');
 const functionRefSchema = absoluteRefSchema('function');
 const policyRefSchema = absoluteRefSchema('policy');
@@ -57,24 +62,27 @@ const coreRefSchema = z.strictObject({
 });
 const domainRefSchema = z.strictObject({ kind: z.literal('domain') });
 const coreEndpointRefSchema = z.discriminatedUnion('kind', [coreRefSchema, domainRefSchema]);
-const definitionRefSchema = z.discriminatedUnion('kind', [interfaceRefSchema, classRefSchema]);
 const policyObjectRefSchema = z.discriminatedUnion('kind', [
-    interfaceRefSchema,
     classRefSchema,
     functionRefSchema,
     policyRefSchema,
     viewRefSchema,
     coreRefSchema,
 ]);
-const edgeEndpointSchema = z.strictObject({
+const edgeEndpointBaseShape = {
     role: memberNameSchema,
-    accepts: uniqueArray(definitionRefSchema).min(1),
-    cardinality: z.enum(['0..*', '1..*', '0..1', '1']),
+    accepts: uniqueArray(classRefSchema).min(1),
+};
+const edgeCountSchema = z.enum(['0..*', '1..*', '0..1', '1']);
+const directedEdgeEndpointsSchema = z.strictObject({
+    source: z.strictObject({ ...edgeEndpointBaseShape, outgoing: edgeCountSchema }),
+    target: z.strictObject({ ...edgeEndpointBaseShape, incoming: edgeCountSchema }),
 });
-const edgeEndpointsSchema = z.strictObject({
-    source: edgeEndpointSchema,
-    target: edgeEndpointSchema,
+const incidentEndpointSchema = z.strictObject({
+    ...edgeEndpointBaseShape,
+    incident: edgeCountSchema,
 });
+const undirectedEdgeEndpointsSchema = z.tuple([incidentEndpointSchema, incidentEndpointSchema]);
 const edgeConstraintsSchema = z.strictObject({
     noSelf: z.literal(true).optional(),
     acyclic: z.literal(true).optional(),
@@ -162,7 +170,7 @@ const callableShape = {
     description: descriptionSchema.optional(),
     input: jsonSchemaSchema,
     output: callableOutputSchema,
-    auth: z.enum(['required', 'optional', 'public']),
+    auth: z.enum(['anonymous', 'authenticated', 'authorized']),
     policy: policyCheckExpressionSchema.optional(),
 };
 const methodDeclarationSchema = z
@@ -180,12 +188,12 @@ const methodDeclarationSchema = z
             params: { structureCode: 'STRUCTURE_ABSTRACT_POLICY' },
         });
     }
-    if (method.auth === 'public' && method.policy !== undefined) {
+    if (method.auth !== 'authorized' && method.policy !== undefined) {
         context.addIssue({
             code: 'custom',
             path: ['policy'],
-            message: 'A public method cannot declare a policy.',
-            params: { structureCode: 'STRUCTURE_PUBLIC_POLICY' },
+            message: 'Only an authorized method may declare a policy.',
+            params: { structureCode: 'STRUCTURE_CALLABLE_POLICY_AUTH' },
         });
     }
 });
@@ -197,97 +205,88 @@ const nodeClassPoliciesSchema = z.strictObject({
 const edgeClassPoliciesSchema = z.strictObject({
     traverse: policyRefSchema.optional(),
 });
-const bothInterfaceSchema = z.strictObject({
-    family: z.literal('both'),
-    description: descriptionSchema.optional(),
-    extends: uniqueArray(interfaceRefSchema),
-    properties: propertyObjectSchema,
-    propertyMetadata: propertyMetadataRecordSchema,
-});
-const nodeInterfaceSchema = z.strictObject({
-    family: z.literal('node'),
-    description: descriptionSchema.optional(),
-    extends: uniqueArray(interfaceRefSchema),
-    properties: propertyObjectSchema,
-    propertyMetadata: propertyMetadataRecordSchema,
-    methods: methodRecordSchema,
-    data: dataDeclarationSchema.optional(),
-});
-const edgeInterfaceSchema = z.strictObject({
-    family: z.literal('edge'),
-    description: descriptionSchema.optional(),
-    extends: uniqueArray(interfaceRefSchema),
-    properties: propertyObjectSchema,
-    propertyMetadata: propertyMetadataRecordSchema,
-    endpoints: edgeEndpointsSchema,
-    orientation: z.enum(['directed', 'undirected']),
-    constraints: edgeConstraintsSchema,
-});
-const interfaceDeclarationSchema = z.discriminatedUnion('family', [
-    bothInterfaceSchema,
-    nodeInterfaceSchema,
-    edgeInterfaceSchema,
-]);
 const nodeClassSchema = z.strictObject({
-    family: z.literal('node'),
+    ref: classRefSchema,
+    kind: z.literal('node'),
+    abstract: z.boolean(),
     description: descriptionSchema.optional(),
-    implements: uniqueArray(interfaceRefSchema),
-    properties: propertyObjectSchema,
-    propertyMetadata: propertyMetadataRecordSchema,
+    extends: uniqueArray(classRefSchema),
+    properties: propertyRecordSchema,
     methods: methodRecordSchema,
     data: dataDeclarationSchema.optional(),
     icon: iconSchema.optional(),
     policies: nodeClassPoliciesSchema,
 });
-const edgeClassSchema = z.strictObject({
-    family: z.literal('edge'),
+const edgeClassShape = {
+    ref: classRefSchema,
+    kind: z.literal('edge'),
+    abstract: z.boolean(),
     description: descriptionSchema.optional(),
-    implements: uniqueArray(interfaceRefSchema),
-    properties: propertyObjectSchema,
-    propertyMetadata: propertyMetadataRecordSchema,
-    endpoints: edgeEndpointsSchema,
+    extends: uniqueArray(classRefSchema),
+    properties: propertyRecordSchema,
+    constraints: edgeConstraintsSchema,
+};
+const edgeClassSchema = z
+    .strictObject({
+    ...edgeClassShape,
     orientation: z.enum(['directed', 'undirected']),
+    endpoints: z.union([directedEdgeEndpointsSchema, undirectedEdgeEndpointsSchema]),
     policies: edgeClassPoliciesSchema,
-    constraints: edgeConstraintsSchema,
-});
-const classDeclarationSchema = z.discriminatedUnion('family', [nodeClassSchema, edgeClassSchema]);
-const functionDeclarationSchema = z.strictObject(callableShape).superRefine((fn, context) => {
-    if (fn.auth === 'public' && fn.policy !== undefined) {
+})
+    .superRefine(validateEdgeOrientationShape);
+const classDeclarationSchema = z.discriminatedUnion('kind', [nodeClassSchema, edgeClassSchema]);
+function validateEdgeOrientationShape(value, context) {
+    if ((value.orientation === 'undirected') === Array.isArray(value.endpoints))
+        return;
+    context.addIssue({
+        code: 'custom',
+        path: ['endpoints'],
+        message: `${value.orientation} Edge endpoints have the wrong structural shape.`,
+        params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
+    });
+}
+const functionDefinitionSchema = z
+    .strictObject({ ref: functionRefSchema, ...callableShape })
+    .superRefine((callable, context) => {
+    if (callable.auth !== 'authorized' && callable.policy !== undefined) {
         context.addIssue({
             code: 'custom',
             path: ['policy'],
-            message: 'A public function cannot declare a policy.',
-            params: { structureCode: 'STRUCTURE_PUBLIC_POLICY' },
+            message: 'Only an authorized function may declare a policy.',
+            params: { structureCode: 'STRUCTURE_CALLABLE_POLICY_AUTH' },
         });
     }
 });
-const policyDeclarationSchema = z.union([
+const policyExpressionSchema = z.union([
     z.strictObject({
-        description: descriptionSchema.optional(),
         match: policyPatternExpressionSchema,
     }),
     z.strictObject({
-        description: descriptionSchema.optional(),
         allOf: z.array(policyRefSchema).min(1),
     }),
     z.strictObject({
-        description: descriptionSchema.optional(),
         anyOf: z.array(policyRefSchema).min(1),
     }),
 ]);
+const policyDefinitionSchema = z.strictObject({
+    ref: policyRefSchema,
+    expression: policyExpressionSchema,
+    description: descriptionSchema.optional(),
+});
 const viewTargetSchema = z.discriminatedUnion('kind', [
     z.strictObject({ kind: z.literal('domain') }),
     z.strictObject({
         kind: z.literal('definition'),
-        definitions: uniqueArray(definitionRefSchema).min(1),
+        definitions: uniqueArray(classRefSchema).min(1),
     }),
 ]);
-const viewDeclarationSchema = z.strictObject({
+const viewDefinitionSchema = z.strictObject({
+    ref: viewRefSchema,
     description: descriptionSchema.optional(),
     target: viewTargetSchema,
-    auth: z.enum(['required', 'optional', 'public']),
 });
 const coreNodeSchema = z.strictObject({
+    ref: coreRefSchema,
     class: classRefSchema,
     properties: z.record(propertyKeySchema, jsonValueSchema),
 });
@@ -305,13 +304,11 @@ const structuralSchema = z.strictObject({
     format: z.literal(DOMAIN_FORMAT),
     version: z.literal(DOMAIN_VERSION),
     origin: originSchema,
-    dependencies: z.array(domainDependencySchema),
-    types: z.record(memberNameSchema, jsonSchemaSchema),
-    interfaces: z.record(memberNameSchema, interfaceDeclarationSchema),
+    dependencies: z.record(dependencyAliasSchema, domainDependencySchema),
     classes: z.record(memberNameSchema, classDeclarationSchema),
-    functions: z.record(memberNameSchema, functionDeclarationSchema),
-    policies: z.record(memberNameSchema, policyDeclarationSchema),
-    views: z.record(memberNameSchema, viewDeclarationSchema),
+    functions: z.record(memberNameSchema, functionDefinitionSchema),
+    policies: z.record(memberNameSchema, policyDefinitionSchema),
+    views: z.record(memberNameSchema, viewDefinitionSchema),
     core: coreSchema,
 });
 export const domainSchemaStructuralSchema = structuralSchema;
@@ -319,7 +316,7 @@ export function parseDomainSchemaStructure(input) {
     const result = domainSchemaStructuralSchema.safeParse(input);
     if (result.success)
         return result.data;
-    throw new DomainSchemaError(result.error.issues.flatMap((issue) => diagnosticsForIssue(issue, input)));
+    throw new SchemaError(result.error.issues.flatMap((issue) => diagnosticsForIssue(issue, input)));
 }
 function absoluteRefSchema(kind) {
     return z.strictObject({
@@ -361,13 +358,22 @@ function diagnosticsForIssue(issue, input) {
     if (issue.code === 'unrecognized_keys') {
         return issue.keys.map((key) => diagnostic('STRUCTURE_UNKNOWN_FIELD', pointer([...issue.path, key]), `Unknown field ${JSON.stringify(key)}.`));
     }
-    const customCode = issue.code === 'custom' && typeof issue.params?.structureCode === 'string'
-        ? issue.params.structureCode
-        : undefined;
+    const customCode = issue.code === 'custom' ? customStructureCode(issue.params?.structureCode) : undefined;
     return [
         diagnostic(customCode ?? structureCode(issue, input), pointer(issue.path), structureMessage(issue, input)),
     ];
 }
+function customStructureCode(input) {
+    switch (input) {
+        case 'STRUCTURE_ABSTRACT_POLICY':
+        case 'STRUCTURE_CALLABLE_POLICY_AUTH':
+        case 'STRUCTURE_DUPLICATE_ITEM':
+        case 'STRUCTURE_EDGE_ORIENTATION':
+            return input;
+        default:
+            return undefined;
+    }
+}
 function structureCode(issue, input) {
     switch (issue.code) {
         case 'invalid_type':
@@ -419,4 +425,3 @@ function pointer(path) {
 function escapePointerSegment(segment) {
     return segment.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=domain.structure.js.map

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

@@ -0,0 +1,4 @@
+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, };
+export declare function validatePolicyBudgets(context: PolicyValidationContext): void;

package/dist/v1/schema/{policy/validation → validation/policy}/budgets.js

@@ -1,13 +1,6 @@
+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 const MAX_PATTERN_DEPTH = 4;
-export const MAX_BRANCHES = 8;
-export const MAX_VARIABLES = 4;
-export const MAX_EDGES = 6;
-export const MAX_REPEAT = 3;
-export const MAX_DOMAINS = 4;
-export const MAX_CHECK_DEPTH = 4;
-export const MAX_CHECK_LEAVES = 8;
-export const BRANCH_OVERFLOW = MAX_BRANCHES + 1;
+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) {
     for (const name of Object.keys(context.environment.candidate.policies)) {
         const measure = measurePolicy(context, name, new Set());
@@ -29,20 +22,6 @@ export function validatePolicyBudgets(context) {
         }
     }
 }
-export function measureChecks(expression) {
-    if ('check' in expression)
-        return { depth: 1, branches: 1, leaves: 1 };
-    const { key, values } = checkOperands(expression);
-    const children = values.map(measureChecks);
-    const branches = key === 'allOf'
-        ? children.reduce((value, child) => saturatingProduct(value, child.branches), 1)
-        : children.reduce((value, child) => Math.min(BRANCH_OVERFLOW, value + child.branches), 0);
-    return {
-        depth: 1 + Math.max(0, ...children.map((child) => child.depth)),
-        branches,
-        leaves: children.reduce((value, child) => value + child.leaves, 0),
-    };
-}
 function measurePolicy(context, name, visiting) {
     if (visiting.has(name))
         return undefined;
@@ -113,20 +92,11 @@ function combineMeasures(key, children) {
     }
     return { depth, edgeCounts, domains };
 }
-function saturatingProduct(left, right) {
-    return Math.min(BRANCH_OVERFLOW, left * right);
-}
 function patternOperands(value) {
     return 'allOf' in value
         ? { key: 'allOf', values: value.allOf }
         : { key: 'anyOf', values: value.anyOf };
 }
-function checkOperands(value) {
-    return 'allOf' in value
-        ? { key: 'allOf', values: value.allOf }
-        : { key: 'anyOf', values: value.anyOf };
-}
 function isEdge(value) {
     return 'source' in value;
 }
-//# sourceMappingURL=budgets.js.map

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

@@ -0,0 +1,28 @@
+import type { ClassDefinition } from '../../../language/class/model/class.js';
+import type { PolicyExpression } 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 {
+    #private;
+    readonly environment: DomainResolutionContext;
+    readonly analysis: DefinitionAnalysisResult;
+    readonly diagnostics: SchemaDiagnostic[];
+    readonly normalized: Map<string, PolicyExpression>;
+    readonly allNodeClasses: readonly ClassRef[];
+    readonly concreteNodeClasses: readonly ClassRef[];
+    constructor(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult);
+    resolveNodeClass(ref: ClassRef, pointer: string): IndexedClassDefinition | undefined;
+    resolveEdge(ref: ClassRef, pointer: string): IndexedClassDefinition | undefined;
+    resolvePolicy(ref: PolicyRef, pointer: string): boolean;
+    isLocalPolicy(ref: PolicyRef): boolean;
+    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;
+    add(code: SchemaDiagnosticCode, pointer: string, message: string, ref?: string): void;
+}
+export declare function escapePointer(value: string): string;

package/dist/v1/schema/{policy/validation → validation/policy}/context.js

@@ -1,37 +1,42 @@
+import { Key } from '../../../addressing/index.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
 import { diagnostic } from '../../diagnostic.js';
-import { schemaRefIndex, formatSchemaRef, } from '../../reference.js';
+const formatDefinitionRef = Key.of;
 export class PolicyValidationContext {
     environment;
     analysis;
     diagnostics = [];
     normalized = new Map();
     allNodeClasses;
+    concreteNodeClasses;
     #invalidPolicyRefs = new Set();
     constructor(environment, analysis) {
         this.environment = environment;
         this.analysis = analysis;
-        this.allNodeClasses = [...environment.definitions.values()]
-            .filter((value) => value.ref.kind === 'class' && value.family === 'node')
+        const nodeClasses = [...environment.definitions.values()].filter((value) => value.ref.kind === 'class' && value.kind === 'node');
+        this.allNodeClasses = nodeClasses.map((value) => value.ref);
+        this.concreteNodeClasses = nodeClasses
+            .filter((value) => !value.declaration.abstract)
             .map((value) => value.ref);
     }
     resolveNodeClass(ref, pointer) {
         const resolved = this.environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'node') {
-            this.add('PL_REF', pointer, `${formatSchemaRef(ref)} does not resolve to an owning/direct-dependency Node Class.`, formatSchemaRef(ref));
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
+            this.add('PL_REF', pointer, `${formatDefinitionRef(ref)} does not resolve to an owning/direct-dependency Node Class.`, formatDefinitionRef(ref));
             return undefined;
         }
         return resolved;
     }
     resolveEdge(ref, pointer) {
         const resolved = this.environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'edge') {
-            this.add('PL_REF', pointer, `${formatSchemaRef(ref)} does not resolve to an owning/direct-dependency Edge Class.`, formatSchemaRef(ref));
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
+            this.add('PL_REF', pointer, `${formatDefinitionRef(ref)} does not resolve to an owning/direct-dependency Edge Class.`, formatDefinitionRef(ref));
             return undefined;
         }
         return resolved;
     }
     resolvePolicy(ref, pointer) {
-        const key = `${pointer}\u0000${schemaRefIndex(ref)}`;
+        const key = `${pointer}\u0000${definitionRefIndex(ref)}`;
         if (this.#invalidPolicyRefs.has(key))
             return false;
         const declaration = this.environment.resolvePolicy(ref);
@@ -39,7 +44,7 @@ export class PolicyValidationContext {
             ref.kind !== 'policy' ||
             declaration === undefined) {
             this.#invalidPolicyRefs.add(key);
-            this.add('PL_REF', pointer, `${formatSchemaRef(ref)} is not an exact local named Policy ref.`, formatSchemaRef(ref));
+            this.add('PL_REF', pointer, `${formatDefinitionRef(ref)} is not an exact local named Policy ref.`, formatDefinitionRef(ref));
             return false;
         }
         return true;
@@ -51,41 +56,27 @@ export class PolicyValidationContext {
     }
     edgeDeclaration(ref) {
         const resolved = this.environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'edge') {
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
             return undefined;
         }
-        const declaration = resolved.declaration;
-        return declaration.family === 'edge' ? declaration : undefined;
+        return resolved.declaration;
     }
-    classImplements(candidate, required) {
-        const resolved = this.environment.resolveAny(candidate);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'node') {
-            return false;
-        }
-        const declaration = resolved.declaration;
-        if (declaration.family !== 'node')
-            return false;
-        return declaration.implements.some((parent) => this.interfaceExtends(parent, required));
-    }
-    interfaceExtends(candidate, required) {
-        if (schemaRefIndex(candidate) === schemaRefIndex(required))
+    /** Return true when candidate is the required Class or a same-kind descendant. */
+    classExtends(candidate, required) {
+        if (definitionRefIndex(candidate) === definitionRefIndex(required))
             return true;
         const visited = new Set();
         const visit = (ref) => {
-            const key = schemaRefIndex(ref);
-            if (key === schemaRefIndex(required))
+            const key = definitionRefIndex(ref);
+            if (key === definitionRefIndex(required))
                 return true;
             if (visited.has(key))
                 return false;
             visited.add(key);
             const resolved = this.environment.resolveAny(ref);
-            if (resolved === undefined ||
-                resolved.ref.kind !== 'interface' ||
-                (resolved.family !== 'node' && resolved.family !== 'both')) {
+            if (resolved === undefined || resolved.ref.kind !== 'class')
                 return false;
-            }
-            const declaration = resolved.declaration;
-            return declaration.extends.some(visit);
+            return resolved.declaration.extends.some(visit);
         };
         return visit(candidate);
     }
@@ -96,4 +87,3 @@ export class PolicyValidationContext {
 export function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=context.js.map

package/dist/v1/schema/{policy/validation → validation/policy}/references.d.ts

@@ -1,3 +1,2 @@
 import type { PolicyValidationContext } from './context.js';
 export declare function validatePolicyReferences(context: PolicyValidationContext): void;
-//# sourceMappingURL=references.d.ts.map

package/dist/v1/schema/{policy/validation → validation/policy}/references.js

@@ -1,15 +1,22 @@
-import { normalizePolicyDeclaration, normalizePolicyPattern } from '../normalize.js';
-import { branchesOf, isConnected, targetMode } from './branches.js';
+import { branchesOf, isConnected, targetMode } from '../../../language/policy/analysis/branches.js';
+import { normalizePolicyExpression, normalizePolicyPattern, } from '../../../language/policy/normalization/normalize.js';
 import { MAX_REPEAT, MAX_VARIABLES } from './budgets.js';
 import { escapePointer } from './context.js';
 export function validatePolicyReferences(context) {
     for (const [name, declaration] of Object.entries(context.environment.candidate.policies)) {
         const pointer = `/policies/${escapePointer(name)}`;
-        context.normalized.set(name, normalizePolicyDeclaration(declaration));
-        if ('match' in declaration)
-            validateMatch(context, name, declaration.match, pointer);
+        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) {
+            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);
         else
-            validateComposition(context, declaration, pointer);
+            validateComposition(context, expression, pointer);
     }
     validateCycles(context);
 }
@@ -111,8 +118,9 @@ function validateCycles(context) {
             return;
         visiting.add(name);
         const declaration = context.environment.candidate.policies[name];
-        if (declaration !== undefined && !('match' in declaration)) {
-            const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
+        const expression = declaration?.expression;
+        if (expression !== undefined && !('match' in expression)) {
+            const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
             for (const ref of refs) {
                 if (ref.origin === context.environment.candidate.origin && ref.kind === 'policy') {
                     visit(ref.name, [...stack, name]);
@@ -133,4 +141,3 @@ function patternOperands(value) {
 function isEdge(value) {
     return 'source' in value;
 }
-//# sourceMappingURL=references.js.map

package/dist/v1/schema/{policy/validation → validation/policy}/typing.d.ts

@@ -1,13 +1,10 @@
+import type { ClassRef } from '../../../addressing/index.js';
 import type { PolicyValidationContext } from './context.js';
-import { type ClassRef, type DefinitionRef, type InterfaceRef } from '../../reference.js';
 export type ObjectContract = {
     readonly kind: 'default';
 } | {
     readonly kind: 'exact';
     readonly ref: ClassRef;
-} | {
-    readonly kind: 'universal-interface';
-    readonly ref: InterfaceRef;
 };
 export declare class PolicyTyping {
     #private;
@@ -16,8 +13,7 @@ export declare class PolicyTyping {
     validatePolicies(): void;
     policyAccepts(name: string, object: ObjectContract): boolean;
     policyAcceptsEdge(name: string, source: ObjectContract, target: ObjectContract): boolean;
-    concreteEndpointClasses(accepts: readonly DefinitionRef[]): readonly ClassRef[];
-    endpointsOverlap(left: readonly DefinitionRef[], right: readonly DefinitionRef[]): boolean;
+    concreteEndpointClasses(accepts: readonly ClassRef[]): readonly ClassRef[];
+    endpointsOverlap(left: readonly ClassRef[], right: readonly ClassRef[]): boolean;
 }
-export declare function contractOfNodeDefinition(ref: DefinitionRef): ObjectContract;
-//# sourceMappingURL=typing.d.ts.map
+export declare function contractOfNodeDefinition(ref: ClassRef): ObjectContract;