@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.40

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

@@ -1,196 +1,206 @@
-import { z } from 'zod';
+import { array, boolean, custom, discriminatedUnion, enum as enumeration, lazy, literal, null as nullSchema, number, record, strictObject, string, tuple, union, } 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';
-const originSchema = z.string().min(3).max(253).regex(DOMAIN_ORIGIN_PATTERN);
-const memberNameSchema = z.string().regex(MEMBER_NAME_PATTERN);
-const propertyKeySchema = z
-    .string()
-    .refine(SemanticPropertyKey.is, 'Expected a canonical PropertyKey.');
-const coreSlugSchema = z.string().min(1).max(100).regex(CORE_SLUG_PATTERN);
-const revisionSchema = z.string().regex(DOMAIN_REVISION_PATTERN);
-const descriptionSchema = z
-    .string()
+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 = string().min(3).max(253).regex(DOMAIN_ORIGIN_PATTERN);
+const memberNameSchema = string().regex(MEMBER_NAME_PATTERN);
+const dependencyAliasSchema = string()
+    .regex(DEPENDENCY_ALIAS_PATTERN)
+    .refine((value) => value !== '__proto__' && value !== 'prototype' && value !== 'constructor', 'Expected a non-reserved dependency alias.');
+const propertyKeySchema = string().refine(SemanticPropertyKey.is, 'Expected a canonical PropertyKey.');
+const coreSlugSchema = string().min(1).max(100).regex(CORE_SLUG_PATTERN);
+const revisionSchema = string().regex(DOMAIN_REVISION_PATTERN);
+const descriptionSchema = string()
     .min(metadata.description.minLength)
     .max(metadata.description.maxLength);
-const iconSchema = z.string().min(metadata.icon.minLength).max(metadata.icon.maxLength);
-const jsonValueSchema = z.lazy(() => z.union([
-    z.null(),
-    z.boolean(),
-    z.number(),
-    z.string(),
-    z.array(jsonValueSchema),
-    z.record(z.string(), jsonValueSchema),
+const iconSchema = string().min(metadata.icon.minLength).max(metadata.icon.maxLength);
+const jsonValueSchema = lazy(() => union([
+    nullSchema(),
+    boolean(),
+    number(),
+    string(),
+    array(jsonValueSchema),
+    record(string(), jsonValueSchema),
 ]));
-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 jsonObjectSchema = record(string(), jsonValueSchema);
+const jsonSchemaSchema = union([boolean(), jsonObjectSchema]);
+const dataDeclarationSchema = strictObject({
+    mediaType: string().regex(MEDIA_TYPE_PATTERN),
 });
-const dataDeclarationSchema = z.strictObject({
-    mediaType: z.string().regex(MEDIA_TYPE_PATTERN),
+const stateNameSchema = string().min(1);
+const stateTransitionsSchema = custom(isStateTransitions);
+const stateTopologySchema = strictObject({
+    initial: stateNameSchema,
+    transitions: stateTransitionsSchema,
 });
-const propertyMetadataSchema = z.strictObject({
-    visibility: z.enum(['public', 'private']),
-    auto: z
-        .strictObject({
-        on: uniqueArray(z.enum(['create', 'update'])).min(1),
-        set: z.literal('instant'),
-    })
-        .optional(),
+const propertyDefinitionSchema = strictObject({
+    schema: jsonSchemaSchema,
+    required: boolean(),
+    auto: strictObject({
+        on: uniqueArray(enumeration(['create', 'update'])).min(1),
+        set: literal('instant'),
+    }).optional(),
+    description: descriptionSchema.optional(),
+    state: stateTopologySchema.optional(),
 });
-const propertyMetadataRecordSchema = z.record(memberNameSchema, propertyMetadataSchema);
-const domainDependencySchema = z.strictObject({
+const propertyRecordSchema = record(memberNameSchema, propertyDefinitionSchema);
+const domainDependencySchema = strictObject({
     origin: originSchema,
     revision: revisionSchema,
 });
-const interfaceRefSchema = absoluteRefSchema('interface');
 const classRefSchema = absoluteRefSchema('class');
 const functionRefSchema = absoluteRefSchema('function');
 const policyRefSchema = absoluteRefSchema('policy');
 const viewRefSchema = absoluteRefSchema('view');
-const coreRefSchema = z.strictObject({
+const coreRefSchema = strictObject({
     origin: originSchema,
-    kind: z.literal('core'),
+    kind: literal('core'),
     name: coreSlugSchema,
 });
-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,
+const domainRefSchema = strictObject({ kind: literal('domain') });
+/** Every Definition whose installed projection resolves through one exact member Path. */
+const projectedMemberRefOptions = [
+    strictObject({ kind: literal('method'), owner: classRefSchema, name: memberNameSchema }),
     classRefSchema,
     functionRefSchema,
     policyRefSchema,
     viewRefSchema,
     coreRefSchema,
+];
+const policyObjectRefSchema = discriminatedUnion('kind', projectedMemberRefOptions);
+const coreEndpointRefSchema = discriminatedUnion('kind', [
+    ...projectedMemberRefOptions,
+    domainRefSchema,
 ]);
 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({
-    source: z.strictObject({ ...edgeEndpointBaseShape, outgoing: edgeCountSchema }),
-    target: z.strictObject({ ...edgeEndpointBaseShape, incoming: edgeCountSchema }),
+const edgeCountSchema = enumeration(['0..*', '1..*', '0..1', '1']);
+const directedEdgeEndpointsSchema = strictObject({
+    source: strictObject({ ...edgeEndpointBaseShape, outgoing: edgeCountSchema }),
+    target: strictObject({ ...edgeEndpointBaseShape, incoming: edgeCountSchema }),
 });
-const incidentEndpointSchema = z.strictObject({
+const incidentEndpointSchema = strictObject({
     ...edgeEndpointBaseShape,
     incident: edgeCountSchema,
 });
-const undirectedEdgeEndpointsSchema = z.tuple([incidentEndpointSchema, incidentEndpointSchema]);
-const edgeConstraintsSchema = z.strictObject({
-    noSelf: z.literal(true).optional(),
-    acyclic: z.literal(true).optional(),
+const undirectedEdgeEndpointsSchema = tuple([incidentEndpointSchema, incidentEndpointSchema]);
+const edgeConstraintsSchema = strictObject({
+    noSelf: literal(true).optional(),
+    acyclic: literal(true).optional(),
 });
-const policyPatternSubjectSchema = z.strictObject({ kind: z.literal('subject') });
-const policyPatternObjectSchema = z.strictObject({ kind: z.literal('object') });
-const policyPatternSourceSchema = z.strictObject({ kind: z.literal('source') });
-const policyPatternTargetSchema = z.strictObject({ kind: z.literal('target') });
-const policyPatternVariableSchema = z.strictObject({
-    kind: z.literal('variable'),
-    id: z.number().int().min(0),
+const policyPatternSubjectSchema = strictObject({ kind: literal('subject') });
+const policyPatternObjectSchema = strictObject({ kind: literal('object') });
+const policyPatternSourceSchema = strictObject({ kind: literal('source') });
+const policyPatternTargetSchema = strictObject({ kind: literal('target') });
+const policyPatternVariableSchema = strictObject({
+    kind: literal('variable'),
+    id: number().int().min(0),
 });
-const policyPatternNodeSchema = z.discriminatedUnion('kind', [
+const policyPatternNodeSchema = discriminatedUnion('kind', [
     policyPatternSubjectSchema,
     policyPatternObjectSchema,
     policyPatternSourceSchema,
     policyPatternTargetSchema,
     policyPatternVariableSchema,
+    strictObject({ kind: literal('ref'), ref: policyObjectRefSchema }),
 ]);
-const policyVariableSchema = z.strictObject({
-    variable: policyPatternVariableSchema,
-    class: classRefSchema,
-});
-const policyRepeatSchema = z.strictObject({
-    min: z.number().int().min(0).max(3),
-    max: z.number().int().min(0).max(3),
+const policyVariableSelectorSchema = discriminatedUnion('kind', [
+    strictObject({ kind: literal('any') }),
+    strictObject({ kind: literal('satisfies'), class: classRefSchema }),
+]);
+const policyVariableSchema = union([
+    strictObject({ variable: policyPatternVariableSchema, class: classRefSchema }),
+    strictObject({ variable: policyPatternVariableSchema, selector: policyVariableSelectorSchema }),
+]);
+const policyRepeatSchema = strictObject({
+    min: number().int().min(0).max(3),
+    max: number().int().min(0).max(3),
 });
-const policyPatternExpressionSchema = z.lazy(() => z.union([
-    z.strictObject({
+const policyPatternExpressionSchema = lazy(() => union([
+    strictObject({
+        sameNode: strictObject({ left: policyPatternNodeSchema, right: policyPatternNodeSchema }),
+    }),
+    strictObject({
         source: policyPatternNodeSchema,
         class: classRefSchema,
         target: policyPatternNodeSchema,
         repeat: policyRepeatSchema.optional(),
     }),
-    z.strictObject({
-        exists: z.strictObject({
-            nodes: z.array(policyVariableSchema).min(1).max(4),
+    strictObject({
+        exists: strictObject({
+            nodes: array(policyVariableSchema).min(1).max(4),
             where: policyPatternExpressionSchema,
         }),
     }),
-    z.strictObject({
-        allOf: z.array(policyPatternExpressionSchema).min(1),
+    strictObject({
+        allOf: array(policyPatternExpressionSchema).min(1),
     }),
-    z.strictObject({
-        anyOf: z.array(policyPatternExpressionSchema).min(1),
+    strictObject({
+        anyOf: array(policyPatternExpressionSchema).min(1),
     }),
 ]));
-const policyCheckObjectSchema = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('self') }),
-    z.strictObject({
-        kind: z.literal('input'),
+const policyCheckObjectSchema = discriminatedUnion('kind', [
+    strictObject({ kind: literal('self') }),
+    strictObject({
+        kind: literal('input'),
         field: memberNameSchema,
     }),
-    z.strictObject({
-        kind: z.literal('ref'),
+    strictObject({
+        kind: literal('ref'),
         ref: policyObjectRefSchema,
     }),
 ]);
-const policyCheckExpressionSchema = z.lazy(() => z.union([
-    z.strictObject({
+const policyCheckExpressionSchema = lazy(() => union([
+    strictObject({
+        sameNode: strictObject({ left: policyCheckObjectSchema, right: policyCheckObjectSchema }),
+    }),
+    strictObject({
         check: policyRefSchema,
         object: policyCheckObjectSchema,
     }),
-    z.strictObject({
-        allOf: z.array(policyCheckExpressionSchema).min(1),
+    strictObject({
+        allOf: array(policyCheckExpressionSchema).min(1),
     }),
-    z.strictObject({
-        anyOf: z.array(policyCheckExpressionSchema).min(1),
+    strictObject({
+        anyOf: array(policyCheckExpressionSchema).min(1),
     }),
 ]));
-const callableOutputSchema = z.discriminatedUnion('mode', [
-    z.strictObject({
-        mode: z.literal('value'),
+const callableOutputSchema = discriminatedUnion('mode', [
+    strictObject({
+        mode: literal('value'),
         schema: jsonSchemaSchema,
     }),
-    z.strictObject({
-        mode: z.literal('stream'),
+    strictObject({
+        mode: literal('stream'),
         item: jsonSchemaSchema,
     }),
-    z.strictObject({
-        mode: z.literal('binary'),
+    strictObject({
+        mode: literal('binary'),
     }),
 ]);
+const binaryInputSchema = strictObject({
+    mode: literal('binary'),
+    metadata: jsonSchemaSchema,
+    maximumBytes: number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+});
+const valueFunctionInputSchema = jsonSchemaSchema.refine((value) => typeof value !== 'object' || value === null || value.mode !== 'binary', 'Binary input must declare metadata and maximumBytes.');
 const callableShape = {
     description: descriptionSchema.optional(),
     input: jsonSchemaSchema,
     output: callableOutputSchema,
-    auth: z.enum(['anonymous', 'authenticated', 'authorized']),
+    auth: enumeration(['anonymous', 'authenticated', 'authorized']),
     policy: policyCheckExpressionSchema.optional(),
 };
-const methodDeclarationSchema = z
-    .strictObject({
+const methodDeclarationSchema = strictObject({
     ...callableShape,
-    static: z.boolean(),
-    inheritance: z.enum(['abstract', 'default', 'sealed']),
-})
-    .superRefine((method, context) => {
-    if (method.inheritance === 'abstract' && method.policy !== undefined) {
-        context.addIssue({
-            code: 'custom',
-            path: ['policy'],
-            message: 'An abstract method cannot declare a policy.',
-            params: { structureCode: 'STRUCTURE_ABSTRACT_POLICY' },
-        });
-    }
+    static: boolean(),
+    abstract: boolean(),
+}).superRefine((method, context) => {
     if (method.auth !== 'authorized' && method.policy !== undefined) {
         context.addIssue({
             code: 'custom',
@@ -200,78 +210,43 @@ const methodDeclarationSchema = z
         });
     }
 });
-const methodRecordSchema = z.record(memberNameSchema, methodDeclarationSchema);
-const nodeClassPoliciesSchema = z.strictObject({
+const methodRecordSchema = record(memberNameSchema, methodDeclarationSchema);
+const nodeClassPoliciesSchema = strictObject({
     read: policyRefSchema.optional(),
     traverse: policyRefSchema.optional(),
 });
-const edgeClassPoliciesSchema = z.strictObject({
+const edgeClassPoliciesSchema = strictObject({
+    read: policyRefSchema.optional(),
     traverse: policyRefSchema.optional(),
 });
-const bothInterfaceSchema = z.strictObject({
-    family: z.literal('both'),
+const nodeClassSchema = strictObject({
+    ref: classRefSchema,
+    kind: literal('node'),
+    abstract: boolean(),
     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'),
-    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: literal('edge'),
+    abstract: boolean(),
     description: descriptionSchema.optional(),
-    implements: uniqueArray(interfaceRefSchema),
-    properties: propertyObjectSchema,
-    propertyMetadata: propertyMetadataRecordSchema,
-    policies: edgeClassPoliciesSchema,
+    extends: uniqueArray(classRefSchema),
+    properties: propertyRecordSchema,
     constraints: edgeConstraintsSchema,
 };
-const edgeClassSchema = z
-    .strictObject({
+const edgeClassSchema = strictObject({
     ...edgeClassShape,
-    orientation: z.enum(['directed', 'undirected']),
-    endpoints: z.union([directedEdgeEndpointsSchema, undirectedEdgeEndpointsSchema]),
-})
-    .superRefine(validateEdgeOrientationShape);
-const classDeclarationSchema = z.discriminatedUnion('family', [nodeClassSchema, edgeClassSchema]);
+    orientation: enumeration(['directed', 'undirected']),
+    endpoints: union([directedEdgeEndpointsSchema, undirectedEdgeEndpointsSchema]),
+    policies: edgeClassPoliciesSchema,
+}).superRefine(validateEdgeOrientationShape);
+const classDeclarationSchema = discriminatedUnion('kind', [nodeClassSchema, edgeClassSchema]);
 function validateEdgeOrientationShape(value, context) {
     if ((value.orientation === 'undirected') === Array.isArray(value.endpoints))
         return;
@@ -282,8 +257,12 @@ 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 = strictObject({
+    ref: functionRefSchema,
+    ...callableShape,
+    input: union([binaryInputSchema, valueFunctionInputSchema]),
+}).superRefine((callable, context) => {
+    if (callable.auth !== 'authorized' && callable.policy !== undefined) {
         context.addIssue({
             code: 'custom',
             path: ['policy'],
@@ -292,57 +271,58 @@ const functionDeclarationSchema = z.strictObject(callableShape).superRefine((fn,
         });
     }
 });
-const policyDeclarationSchema = z.union([
-    z.strictObject({
-        description: descriptionSchema.optional(),
+const policyExpressionSchema = union([
+    strictObject({
         match: policyPatternExpressionSchema,
     }),
-    z.strictObject({
-        description: descriptionSchema.optional(),
-        allOf: z.array(policyRefSchema).min(1),
+    strictObject({
+        allOf: array(policyRefSchema).min(1),
     }),
-    z.strictObject({
-        description: descriptionSchema.optional(),
-        anyOf: z.array(policyRefSchema).min(1),
+    strictObject({
+        anyOf: array(policyRefSchema).min(1),
     }),
 ]);
-const viewTargetSchema = z.discriminatedUnion('kind', [
-    z.strictObject({ kind: z.literal('domain') }),
-    z.strictObject({
-        kind: z.literal('definition'),
-        definitions: uniqueArray(definitionRefSchema).min(1),
+const policyDefinitionSchema = strictObject({
+    ref: policyRefSchema,
+    expression: policyExpressionSchema,
+    description: descriptionSchema.optional(),
+});
+const viewTargetSchema = discriminatedUnion('kind', [
+    strictObject({ kind: literal('domain') }),
+    strictObject({
+        kind: literal('definition'),
+        definitions: uniqueArray(classRefSchema).min(1),
     }),
 ]);
-const viewDeclarationSchema = z.strictObject({
+const viewDefinitionSchema = strictObject({
+    ref: viewRefSchema,
     description: descriptionSchema.optional(),
     target: viewTargetSchema,
-    auth: z.enum(['required', 'optional', 'public']),
 });
-const coreNodeSchema = z.strictObject({
+const coreNodeSchema = strictObject({
+    ref: coreRefSchema,
     class: classRefSchema,
-    properties: z.record(propertyKeySchema, jsonValueSchema),
+    properties: record(propertyKeySchema, jsonValueSchema),
 });
-const coreEdgeSchema = z.strictObject({
+const coreEdgeSchema = strictObject({
     class: classRefSchema,
     source: coreEndpointRefSchema,
     target: coreEndpointRefSchema,
-    properties: z.record(propertyKeySchema, jsonValueSchema),
+    properties: record(propertyKeySchema, jsonValueSchema),
 });
-const coreSchema = z.strictObject({
-    nodes: z.record(coreSlugSchema, coreNodeSchema),
-    edges: z.array(coreEdgeSchema),
+const coreSchema = strictObject({
+    nodes: record(coreSlugSchema, coreNodeSchema),
+    edges: array(coreEdgeSchema),
 });
-const structuralSchema = z.strictObject({
-    format: z.literal(DOMAIN_FORMAT),
-    version: z.literal(DOMAIN_VERSION),
+const structuralSchema = strictObject({
+    format: literal(DOMAIN_FORMAT),
+    version: 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),
+    dependencies: record(dependencyAliasSchema, domainDependencySchema),
+    classes: record(memberNameSchema, classDeclarationSchema),
+    functions: record(memberNameSchema, functionDefinitionSchema),
+    policies: record(memberNameSchema, policyDefinitionSchema),
+    views: record(memberNameSchema, viewDefinitionSchema),
     core: coreSchema,
 });
 export const domainSchemaStructuralSchema = structuralSchema;
@@ -350,17 +330,41 @@ 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({
+    return strictObject({
         origin: originSchema,
-        kind: z.literal(kind),
+        kind: literal(kind),
         name: memberNameSchema,
     });
 }
+function isStateTransitions(input) {
+    if (!isRecord(input))
+        return false;
+    for (const state of Reflect.ownKeys(input)) {
+        if (typeof state !== 'string' || state.length === 0)
+            return false;
+        const outgoing = Reflect.get(input, state);
+        if (!isRecord(outgoing))
+            return false;
+        for (const event of Reflect.ownKeys(outgoing)) {
+            const target = Reflect.get(outgoing, event);
+            if (typeof event !== 'string' ||
+                event.length === 0 ||
+                typeof target !== 'string' ||
+                target.length === 0) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function isRecord(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input);
+}
 function uniqueArray(element) {
-    return z.array(element).superRefine((values, context) => {
+    return array(element).superRefine((values, context) => {
         const firstIndexByValue = new Map();
         values.forEach((value, index) => {
             const key = canonicalJson(value);
@@ -392,13 +396,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':
@@ -450,4 +463,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;