@astrale-os/kernel-dsl 0.2.0-beta.9 → 0.2.0

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

@@ -2,6 +2,7 @@ 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 { validateCallables } from './callable.js';
 import { validateDefinitions } from './class.js';
 import { validateCore } from './core.js';
 import { validatePolicies } from './policy/validate.js';
@@ -15,6 +16,7 @@ export function validateDomainSchemaSemantics(schema, lookup) {
         ...context.diagnostics,
         ...validateEmbeddedValueSchemas(schema, registry),
         ...validateDefinitions(context, analysis),
+        ...validateCallables(schema),
         ...validatePolicies(context, analysis),
         ...validateViews(context),
         ...validateCore(context, analysis, registry),

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

@@ -1,4 +1,2 @@
-import { z } from 'zod';
 import type { DomainSchemaIR } from '../model/schema.js';
-export declare const domainSchemaStructuralSchema: z.ZodType<DomainSchemaIR>;
 export declare function parseDomainSchemaStructure(input: unknown): DomainSchemaIR;

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

@@ -1,53 +1,58 @@
-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 { 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()
+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 = 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()
+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 domainNameSchema = string()
+    .min(metadata.name.minLength)
+    .max(metadata.name.maxLength)
+    .refine(metadata.isDomainNameText, 'Expected one trimmed line of text.');
+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 dataDeclarationSchema = z.strictObject({
-    mediaType: z.string().regex(MEDIA_TYPE_PATTERN),
+const jsonObjectSchema = record(string(), jsonValueSchema);
+const jsonSchemaSchema = union([boolean(), jsonObjectSchema]);
+const dataDeclarationSchema = strictObject({
+    mediaType: string().regex(MEDIA_TYPE_PATTERN),
 });
-const propertyDefinitionSchema = z.strictObject({
+const stateNameSchema = string().min(1);
+const stateTransitionsSchema = custom(isStateTransitions);
+const stateTopologySchema = strictObject({
+    initial: stateNameSchema,
+    transitions: stateTransitionsSchema,
+});
+const propertyDefinitionSchema = 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(),
+    required: boolean(),
+    auto: strictObject({
+        on: uniqueArray(enumeration(['create', 'update'])).min(1),
+        set: literal('instant'),
+    }).optional(),
+    immutable: enumeration(['create', 'once']).optional(),
     description: descriptionSchema.optional(),
+    state: stateTopologySchema.optional(),
 });
-const propertyRecordSchema = z.record(memberNameSchema, propertyDefinitionSchema);
-const domainDependencySchema = z.strictObject({
+const propertyRecordSchema = record(memberNameSchema, propertyDefinitionSchema);
+const domainDependencySchema = strictObject({
     origin: originSchema,
     revision: revisionSchema,
 });
@@ -55,139 +60,154 @@ 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 policyObjectRefSchema = z.discriminatedUnion('kind', [
+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(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 selfObjectSchema = strictObject({ kind: literal('self') });
+const refObjectSchema = strictObject({ kind: literal('ref'), ref: policyObjectRefSchema });
+const policyCheckObjectSchema = discriminatedUnion('kind', [
+    selfObjectSchema,
+    strictObject({
+        kind: literal('input'),
         field: memberNameSchema,
     }),
-    z.strictObject({
-        kind: z.literal('ref'),
-        ref: policyObjectRefSchema,
-    }),
+    refObjectSchema,
 ]);
-const policyCheckExpressionSchema = z.lazy(() => z.union([
-    z.strictObject({
-        check: policyRefSchema,
-        object: policyCheckObjectSchema,
-    }),
-    z.strictObject({
-        allOf: z.array(policyCheckExpressionSchema).min(1),
-    }),
-    z.strictObject({
-        anyOf: z.array(policyCheckExpressionSchema).min(1),
-    }),
-]));
-const callableOutputSchema = z.discriminatedUnion('mode', [
-    z.strictObject({
-        mode: z.literal('value'),
+/** A Node Class rule checks the observed Node or one exact member: it has no input. */
+const classRuleObjectSchema = discriminatedUnion('kind', [selfObjectSchema, refObjectSchema]);
+/** The recursive Policy check grammar, over the objects one use site admits. */
+function policyChecksSchema(objectSchema) {
+    const checks = lazy(() => union([
+        strictObject({ sameNode: strictObject({ left: objectSchema, right: objectSchema }) }),
+        strictObject({ check: policyRefSchema, object: objectSchema }),
+        strictObject({ allOf: array(checks).min(1) }),
+        strictObject({ anyOf: array(checks).min(1) }),
+    ]));
+    return checks;
+}
+const policyCheckExpressionSchema = policyChecksSchema(policyCheckObjectSchema);
+const classRuleChecksSchema = policyChecksSchema(classRuleObjectSchema);
+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 callableExecutionSchema = strictObject({
+    durable: boolean(),
+});
 const callableShape = {
     description: descriptionSchema.optional(),
     input: jsonSchemaSchema,
     output: callableOutputSchema,
-    auth: z.enum(['anonymous', 'authenticated', 'authorized']),
-    policy: policyCheckExpressionSchema.optional(),
+    execution: callableExecutionSchema.optional(),
+    auth: enumeration(['anonymous', 'authenticated', 'authorized']),
+    policy: union([literal(true), 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',
@@ -197,18 +217,21 @@ const methodDeclarationSchema = z
         });
     }
 });
-const methodRecordSchema = z.record(memberNameSchema, methodDeclarationSchema);
-const nodeClassPoliciesSchema = z.strictObject({
-    read: policyRefSchema.optional(),
-    traverse: policyRefSchema.optional(),
+const methodRecordSchema = record(memberNameSchema, methodDeclarationSchema);
+const classPolicySchema = union([literal(false), policyRefSchema]);
+const nodeClassPolicySchema = union([classPolicySchema, classRuleChecksSchema]);
+const nodeClassPoliciesSchema = strictObject({
+    read: nodeClassPolicySchema.optional(),
+    traverse: nodeClassPolicySchema.optional(),
 });
-const edgeClassPoliciesSchema = z.strictObject({
-    traverse: policyRefSchema.optional(),
+const edgeClassPoliciesSchema = strictObject({
+    read: classPolicySchema.optional(),
+    traverse: classPolicySchema.optional(),
 });
-const nodeClassSchema = z.strictObject({
+const nodeClassSchema = strictObject({
     ref: classRefSchema,
-    kind: z.literal('node'),
-    abstract: z.boolean(),
+    kind: literal('node'),
+    abstract: boolean(),
     description: descriptionSchema.optional(),
     extends: uniqueArray(classRefSchema),
     properties: propertyRecordSchema,
@@ -219,22 +242,20 @@ const nodeClassSchema = z.strictObject({
 });
 const edgeClassShape = {
     ref: classRefSchema,
-    kind: z.literal('edge'),
-    abstract: z.boolean(),
+    kind: literal('edge'),
+    abstract: boolean(),
     description: descriptionSchema.optional(),
     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]),
+    orientation: enumeration(['directed', 'undirected']),
+    endpoints: union([directedEdgeEndpointsSchema, undirectedEdgeEndpointsSchema]),
     policies: edgeClassPoliciesSchema,
-})
-    .superRefine(validateEdgeOrientationShape);
-const classDeclarationSchema = z.discriminatedUnion('kind', [nodeClassSchema, edgeClassSchema]);
+}).superRefine(validateEdgeOrientationShape);
+const classDeclarationSchema = discriminatedUnion('kind', [nodeClassSchema, edgeClassSchema]);
 function validateEdgeOrientationShape(value, context) {
     if ((value.orientation === 'undirected') === Array.isArray(value.endpoints))
         return;
@@ -245,9 +266,11 @@ function validateEdgeOrientationShape(value, context) {
         params: { structureCode: 'STRUCTURE_EDGE_ORIENTATION' },
     });
 }
-const functionDefinitionSchema = z
-    .strictObject({ ref: functionRefSchema, ...callableShape })
-    .superRefine((callable, context) => {
+const functionDefinitionSchema = strictObject({
+    ref: functionRefSchema,
+    ...callableShape,
+    input: union([binaryInputSchema, valueFunctionInputSchema]),
+}).superRefine((callable, context) => {
     if (callable.auth !== 'authorized' && callable.policy !== undefined) {
         context.addIssue({
             code: 'custom',
@@ -257,61 +280,57 @@ const functionDefinitionSchema = z
         });
     }
 });
-const policyExpressionSchema = z.union([
-    z.strictObject({
+const policyExpressionSchema = union([
+    strictObject({
         match: policyPatternExpressionSchema,
     }),
-    z.strictObject({
-        allOf: z.array(policyRefSchema).min(1),
+    strictObject({
+        allOf: array(policyRefSchema).min(1),
     }),
-    z.strictObject({
-        anyOf: z.array(policyRefSchema).min(1),
+    strictObject({
+        anyOf: array(policyRefSchema).min(1),
     }),
 ]);
-const policyDefinitionSchema = z.strictObject({
+const policyDefinitionSchema = 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(classRefSchema).min(1),
-    }),
-]);
-const viewDefinitionSchema = z.strictObject({
+const viewTargetSchema = strictObject({ kind: literal('domain') });
+const viewDefinitionSchema = strictObject({
     ref: viewRefSchema,
     description: descriptionSchema.optional(),
     target: viewTargetSchema,
 });
-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.record(dependencyAliasSchema, domainDependencySchema),
-    classes: z.record(memberNameSchema, classDeclarationSchema),
-    functions: z.record(memberNameSchema, functionDefinitionSchema),
-    policies: z.record(memberNameSchema, policyDefinitionSchema),
-    views: z.record(memberNameSchema, viewDefinitionSchema),
+    name: domainNameSchema,
+    entrypoint: viewRefSchema.optional(),
+    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;
+const domainSchemaStructuralSchema = structuralSchema;
 export function parseDomainSchemaStructure(input) {
     const result = domainSchemaStructuralSchema.safeParse(input);
     if (result.success)
@@ -319,14 +338,38 @@ export function parseDomainSchemaStructure(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);

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

@@ -1,9 +1,16 @@
+import { policyObjectOrigin, policyVariableClass } from '../../../language/index.js';
 import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, } from '../../../language/policy/analysis/budgets.js';
 import { escapePointer } from './context.js';
 export { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, };
 export function validatePolicyBudgets(context) {
+    // Measure every distinct composition node once. A node's expanded measure is independent of the
+    // path that reaches it (the only path-sensitive outcome, the back-edge `undefined`, already holds
+    // for every node on or reaching a composition cycle, regardless of entry), so caching the
+    // completed result by node identity turns path enumeration over the composition DAG into work
+    // linear in the number of nodes while preserving the exact measure and PL_BUDGET decision.
+    const measures = new Map();
     for (const name of Object.keys(context.environment.candidate.policies)) {
-        const measure = measurePolicy(context, name, new Set());
+        const measure = measurePolicy(context, name, new Set(), measures);
         if (measure === undefined)
             continue;
         const pointer = `/policies/${escapePointer(name)}`;
@@ -15,21 +22,28 @@ export function validatePolicyBudgets(context) {
         }
         const edgeMaximum = Math.max(0, ...measure.edgeCounts);
         if (edgeMaximum > MAX_EDGES) {
-            context.add('PL_BUDGET', pointer, `A normalized branch contains ${edgeMaximum} Edge predicates; the maximum is ${MAX_EDGES}.`);
+            context.add('PL_BUDGET', pointer, `A normalized branch contains ${edgeMaximum} graph predicates; the maximum is ${MAX_EDGES}.`);
         }
         if (measure.domains.size > MAX_DOMAINS) {
             context.add('PL_BUDGET', pointer, `Expanded Pattern references ${measure.domains.size} Domains; the maximum is ${MAX_DOMAINS}.`);
         }
     }
 }
-function measurePolicy(context, name, visiting) {
+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);
     }
@@ -37,7 +51,7 @@ function measurePolicy(context, name, visiting) {
     const children = refs.flatMap((ref) => {
         if (!context.isLocalPolicy(ref))
             return [];
-        const value = measurePolicy(context, ref.name, nested);
+        const value = measurePolicy(context, ref.name, nested, measures);
         return value === undefined ? [] : [value];
     });
     if (children.length !== refs.length || children.length === 0)
@@ -45,11 +59,24 @@ function measurePolicy(context, name, visiting) {
     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]),
+            domains: new Set([
+                ownOrigin,
+                pattern.class.origin,
+                ...[pattern.source, pattern.target].flatMap((term) => term.kind === 'ref' ? [policyObjectOrigin(term.ref)] : []),
+            ]),
         };
     }
     if ('exists' in pattern) {
@@ -59,7 +86,10 @@ function measurePattern(pattern, ownOrigin) {
             edgeCounts: child.edgeCounts,
             domains: new Set([
                 ...child.domains,
-                ...pattern.exists.nodes.map((node) => node.class.origin),
+                ...pattern.exists.nodes.flatMap((node) => {
+                    const ref = policyVariableClass(node);
+                    return ref === undefined ? [] : [ref.origin];
+                }),
             ]),
         };
     }