@astrale-os/kernel-dsl 0.2.0-beta.5 → 0.2.0-beta.7

package/dist/v1/schema/{core/validate.js → validation/core.js}

@@ -1,6 +1,8 @@
+import { Key } from '../../addressing/key.js';
+import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
+import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { diagnostic } from '../diagnostic.js';
-import { schemaRefIndex, compareUnicode, formatSchemaRef } from '../reference.js';
-import { validateJsonInstance } from '../value/instance.validate.js';
+const formatDefinitionRef = Key.of;
 export function validateCore(environment, analysis, registry) {
     const diagnostics = [];
     const nodesByRef = resolveCoreNodes(environment, analysis, registry, diagnostics);
@@ -12,20 +14,26 @@ 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 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) {
+            diagnostics.push(diagnostic('DV_REF_RESOLVES', `${pointer}/ref`, `Core ref must be exactly ${formatDefinitionRef(ref)}.`, formatDefinitionRef(node.ref)));
+        }
         const resolved = environment.resolve(node.class);
         if (node.class.origin !== environment.candidate.origin ||
             resolved === undefined ||
             resolved.ref.kind !== 'class' ||
-            resolved.family !== 'node') {
-            diagnostics.push(diagnostic('DV_CORE_NODE_CLASS', `${pointer}/class`, `Core Node Class ${formatSchemaRef(node.class)} must resolve to a local concrete Node Class.`, formatSchemaRef(node.class)));
+            resolved.kind !== 'node' ||
+            resolved.declaration.abstract) {
+            diagnostics.push(diagnostic('DV_CORE_NODE_CLASS', `${pointer}/class`, `Core Node Class ${formatDefinitionRef(node.class)} must resolve to a local concrete Node Class.`, formatDefinitionRef(node.class)));
             continue;
         }
-        const definition = analysis.definitions.get(schemaRefIndex(node.class));
+        const definition = analysis.definitions.get(definitionRefIndex(node.class));
         if (definition === undefined)
             continue;
         validateCreationProperties(definition, node.properties, registry, 'DV_CORE_NODE_PROPERTIES', `${pointer}/properties`, diagnostics);
-        const ref = { origin: environment.candidate.origin, kind: 'core', name: slug };
-        const key = schemaRefIndex(ref);
+        const key = definitionRefIndex(ref);
         nodes.set(key, { kind: 'core', slug, ref, key, classRef: node.class, analysis: definition });
     }
     return nodes;
@@ -40,11 +48,12 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
         if (edge.class.origin !== environment.candidate.origin ||
             resolved === undefined ||
             resolved.ref.kind !== 'class' ||
-            resolved.family !== 'edge') {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', `${pointer}/class`, `Core Edge Class ${formatSchemaRef(edge.class)} must resolve to a local concrete Edge Class.`, formatSchemaRef(edge.class)));
+            resolved.kind !== 'edge' ||
+            resolved.declaration.abstract) {
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', `${pointer}/class`, `Core Edge Class ${formatDefinitionRef(edge.class)} must resolve to a local concrete Edge Class.`, formatDefinitionRef(edge.class)));
             continue;
         }
-        const definition = analysis.definitions.get(schemaRefIndex(edge.class));
+        const definition = analysis.definitions.get(definitionRefIndex(edge.class));
         if (definition === undefined)
             continue;
         validateCreationProperties(definition, edge.properties, registry, 'DV_CORE_EDGE_PROPERTIES', `${pointer}/properties`, diagnostics);
@@ -59,7 +68,7 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
                 (endpointSatisfies(environment, source, declaration.endpoints[1].accepts) &&
                     endpointSatisfies(environment, target, declaration.endpoints[0].accepts));
         if (!endpointsSatisfy) {
-            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatSchemaRef(edge.class)}.`, formatSchemaRef(edge.class)));
+            diagnostics.push(diagnostic('DV_CORE_EDGE_CLASS', pointer, `Core Edge endpoints do not satisfy ${formatDefinitionRef(edge.class)}.`, formatDefinitionRef(edge.class)));
             continue;
         }
         edges.push({ source, target, declaration, value: edge, pointer });
@@ -69,9 +78,9 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
 function resolveCoreEndpoint(ref, pointer, nodesByRef, diagnostics) {
     if (ref.kind === 'domain')
         return { kind: 'domain', ref, key: 'domain' };
-    const node = nodesByRef.get(schemaRefIndex(ref));
+    const node = nodesByRef.get(definitionRefIndex(ref));
     if (node === undefined) {
-        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${formatSchemaRef(ref)} does not name a declared local Core Node.`, formatSchemaRef(ref)));
+        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${formatDefinitionRef(ref)} does not name a declared local Core Node.`, formatDefinitionRef(ref)));
     }
     return node;
 }
@@ -98,7 +107,7 @@ 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.family !== 'edge')
+        if (candidate.kind !== 'edge')
             continue;
         const ref = {
             origin: environment.candidate.origin,
@@ -106,16 +115,16 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
             name,
         };
         const resolved = environment.resolve(ref);
-        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'edge') {
+        if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'edge') {
             continue;
         }
-        edgeSlices.set(schemaRefIndex(ref), {
+        edgeSlices.set(definitionRefIndex(ref), {
             declaration: resolved.declaration,
             edges: [],
         });
     }
     for (const edge of edges) {
-        const classKey = schemaRefIndex(edge.value.class);
+        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]
@@ -185,7 +194,7 @@ function checkIncidentBound(endpoint, degree, node, diagnostics) {
 function sameIncidentEndpointContract(left, right) {
     return (left.incident === right.incident &&
         left.accepts.length === right.accepts.length &&
-        left.accepts.every((ref, index) => schemaRefIndex(ref) === schemaRefIndex(right.accepts[index])));
+        left.accepts.every((ref, index) => definitionRefIndex(ref) === definitionRefIndex(right.accepts[index])));
 }
 function countBounds(value) {
     switch (value) {
@@ -224,18 +233,18 @@ function hasDirectedCycle(edges) {
     return [...outgoing.keys()].some(visit);
 }
 function classSatisfies(environment, classRef, accepts) {
-    if (accepts.some((ref) => schemaRefIndex(ref) === schemaRefIndex(classRef)))
+    if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(classRef)))
         return true;
     const resolved = environment.resolveAny(classRef);
-    if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.family !== 'node') {
+    if (resolved === undefined || resolved.ref.kind !== 'class' || resolved.kind !== 'node') {
         return false;
     }
-    return classImplementsAny(environment, resolved.declaration.implements, accepts, new Set());
+    return classExtendsAny(environment, resolved.declaration.extends, accepts, new Set());
 }
-function classImplementsAny(environment, parents, accepts, visited) {
-    const accepted = new Set(accepts.map(schemaRefIndex));
+function classExtendsAny(environment, parents, accepts, visited) {
+    const accepted = new Set(accepts.map(definitionRefIndex));
     for (const parent of parents) {
-        const key = schemaRefIndex(parent);
+        const key = definitionRefIndex(parent);
         if (accepted.has(key))
             return true;
         if (visited.has(key))
@@ -243,9 +252,8 @@ function classImplementsAny(environment, parents, accepts, visited) {
         visited.add(key);
         const resolved = environment.resolveAny(parent);
         if (resolved !== undefined &&
-            resolved.ref.kind === 'interface' &&
-            (resolved.family === 'node' || resolved.family === 'both') &&
-            classImplementsAny(environment, resolved.declaration.extends, accepts, visited)) {
+            resolved.ref.kind === 'class' &&
+            classExtendsAny(environment, resolved.declaration.extends, accepts, visited)) {
             return true;
         }
     }
@@ -254,4 +262,3 @@ function classImplementsAny(environment, parents, accepts, visited) {
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=validate.js.map

package/dist/v1/schema/validation/domain.d.ts

@@ -0,0 +1,11 @@
+import type { DefinitionAnalysisResult } from '../analysis/class.js';
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+import type { DomainResolutionContext } from '../resolution/context.js';
+export interface DomainSchemaValidation {
+    readonly context: DomainResolutionContext;
+    readonly analysis: DefinitionAnalysisResult;
+    readonly diagnostics: readonly SchemaDiagnostic[];
+}
+export declare function validateDomainSchemaSemantics(schema: DomainSchemaIR, lookup: DomainSchemaLookup): DomainSchemaValidation;

package/dist/v1/schema/{domain.validate.js → validation/domain.js}

@@ -1,11 +1,12 @@
-import { validateCore } from './core/validate.js';
-import { analyzeDefinitions } from './definition/analysis.js';
-import { validateDefinitions } from './definition/validate.js';
-import { validatePolicies } from './policy/validation/validate.js';
-import { buildDomainResolutionContext } from './resolution/context.js';
-import { createValueSchemaRegistry } from './resolution/value.registry.js';
-import { validateEmbeddedValueSchemas } from './validation/value.js';
-import { validateViews } from './view/validate.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { analyzeDefinitions } from '../analysis/class.js';
+import { buildDomainResolutionContext } from '../resolution/context.js';
+import { createValueSchemaRegistry } from '../resolution/value.registry.js';
+import { validateDefinitions } from './class.js';
+import { validateCore } from './core.js';
+import { validatePolicies } from './policy/validate.js';
+import { validateEmbeddedValueSchemas } from './value.js';
+import { validateViews } from './view.js';
 export function validateDomainSchemaSemantics(schema, lookup) {
     const context = buildDomainResolutionContext(schema, lookup);
     const analysis = analyzeDefinitions(context);
@@ -29,8 +30,7 @@ function orderAndDeduplicate(diagnostics) {
     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) => left.pointer.localeCompare(right.pointer) ||
-        left.code.localeCompare(right.code) ||
-        left.message.localeCompare(right.message));
+    return [...unique.values()].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
+        compareUnicode(left.code, right.code) ||
+        compareUnicode(left.message, right.message));
 }
-//# sourceMappingURL=domain.validate.js.map

package/dist/v1/schema/validation/domain.route.d.ts

@@ -1,5 +1,4 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { DomainSchemaIR } from '../domain.ir.js';
+import type { DomainSchemaIR } from '../model/schema.js';
 /** Select the exact Domain language contract before entering its structural grammar. */
 export declare function routeDomainSchema(input: JsonValue): DomainSchemaIR;
-//# sourceMappingURL=domain.route.d.ts.map

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

@@ -1,5 +1,5 @@
-import { DomainSchemaError, diagnostic } from '../diagnostic.js';
-import { DOMAIN_FORMAT, DOMAIN_VERSION } from '../reference.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { DOMAIN_FORMAT, DOMAIN_VERSION } from '../model/format.js';
 import { parseDomainSchemaStructure } from './domain.structure.js';
 const decoders = new Map([
     [DOMAIN_FORMAT, new Map([[DOMAIN_VERSION, parseDomainSchemaStructure]])],
@@ -28,6 +28,5 @@ function describe(value) {
     return value === undefined ? '(missing)' : JSON.stringify(value);
 }
 function unsupported(code, pointer, message) {
-    throw new DomainSchemaError([diagnostic(code, pointer, message)]);
+    throw new SchemaError([diagnostic(code, pointer, message)]);
 }
-//# sourceMappingURL=domain.route.js.map

package/dist/v1/schema/validation/domain.structure.d.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import type { DomainSchemaIR } from '../domain.ir.js';
+import type { DomainSchemaIR } from '../model/schema.js';
 export declare const domainSchemaStructuralSchema: z.ZodType<DomainSchemaIR>;
 export declare function parseDomainSchemaStructure(input: unknown): DomainSchemaIR;
-//# sourceMappingURL=domain.structure.d.ts.map

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

@@ -1,9 +1,10 @@
 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, 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 propertyKeySchema = z
@@ -26,18 +27,12 @@ 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({
@@ -45,13 +40,13 @@ const propertyMetadataSchema = z.strictObject({
         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');
@@ -63,9 +58,7 @@ 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,
@@ -74,7 +67,7 @@ const policyObjectRefSchema = z.discriminatedUnion('kind', [
 ]);
 const edgeEndpointBaseShape = {
     role: memberNameSchema,
-    accepts: uniqueArray(definitionRefSchema).min(1),
+    accepts: uniqueArray(classRefSchema).min(1),
 };
 const edgeCountSchema = z.enum(['0..*', '1..*', '0..1', '1']);
 const directedEdgeEndpointsSchema = z.strictObject({
@@ -208,60 +201,25 @@ 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 edgeInterfaceShape = {
-    family: z.literal('edge'),
-    description: descriptionSchema.optional(),
-    extends: uniqueArray(interfaceRefSchema),
-    properties: propertyObjectSchema,
-    propertyMetadata: propertyMetadataRecordSchema,
-    constraints: edgeConstraintsSchema,
-};
-const edgeInterfaceSchema = z
-    .strictObject({
-    ...edgeInterfaceShape,
-    orientation: z.enum(['directed', 'undirected']),
-    endpoints: z.union([directedEdgeEndpointsSchema, undirectedEdgeEndpointsSchema]),
-})
-    .superRefine(validateEdgeOrientationShape);
-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 edgeClassShape = {
-    family: z.literal('edge'),
+    ref: classRefSchema,
+    kind: z.literal('edge'),
+    abstract: z.boolean(),
     description: descriptionSchema.optional(),
-    implements: uniqueArray(interfaceRefSchema),
-    properties: propertyObjectSchema,
-    propertyMetadata: propertyMetadataRecordSchema,
-    policies: edgeClassPoliciesSchema,
+    extends: uniqueArray(classRefSchema),
+    properties: propertyRecordSchema,
     constraints: edgeConstraintsSchema,
 };
 const edgeClassSchema = z
@@ -269,9 +227,10 @@ const edgeClassSchema = z
     ...edgeClassShape,
     orientation: z.enum(['directed', 'undirected']),
     endpoints: z.union([directedEdgeEndpointsSchema, undirectedEdgeEndpointsSchema]),
+    policies: edgeClassPoliciesSchema,
 })
     .superRefine(validateEdgeOrientationShape);
-const classDeclarationSchema = z.discriminatedUnion('family', [nodeClassSchema, edgeClassSchema]);
+const classDeclarationSchema = z.discriminatedUnion('kind', [nodeClassSchema, edgeClassSchema]);
 function validateEdgeOrientationShape(value, context) {
     if ((value.orientation === 'undirected') === Array.isArray(value.endpoints))
         return;
@@ -282,8 +241,10 @@ function validateEdgeOrientationShape(value, context) {
         params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
     });
 }
-const functionDeclarationSchema = z.strictObject(callableShape).superRefine((fn, context) => {
-    if (fn.auth !== 'authorized' && fn.policy !== undefined) {
+const functionDefinitionSchema = z
+    .strictObject({ ref: functionRefSchema, ...callableShape })
+    .superRefine((callable, context) => {
+    if (callable.auth !== 'authorized' && callable.policy !== undefined) {
         context.addIssue({
             code: 'custom',
             path: ['policy'],
@@ -292,32 +253,36 @@ const functionDeclarationSchema = z.strictObject(callableShape).superRefine((fn,
         });
     }
 });
-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,
 });
 const coreNodeSchema = z.strictObject({
+    ref: coreRefSchema,
     class: classRefSchema,
     properties: z.record(propertyKeySchema, jsonValueSchema),
 });
@@ -336,12 +301,10 @@ const structuralSchema = z.strictObject({
     version: z.literal(DOMAIN_VERSION),
     origin: originSchema,
     dependencies: z.array(domainDependencySchema),
-    types: z.record(memberNameSchema, jsonSchemaSchema),
-    interfaces: z.record(memberNameSchema, interfaceDeclarationSchema),
     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;
@@ -349,7 +312,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({
@@ -391,13 +354,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':
@@ -449,4 +421,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;