@astrale-os/kernel-dsl 0.2.0-beta.19 → 0.2.0-beta.20

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.2.0-beta.20](https://github.com/astrale-os/kernel/compare/kernel-dsl-v0.2.0-beta.19...kernel-dsl-v0.2.0-beta.20) (2026-08-30)
+
+
+### Bug Fixes
+
+* **dsl:** admit endpoint-selective edge policies ([#557](https://github.com/astrale-os/kernel/issues/557)) ([117e8c8](https://github.com/astrale-os/kernel/commit/117e8c888b3911a44a43ffd29572356a8cb03790))
+
+
+### Performance Improvements
+
+* **core:** make Zod imports tree-shakeable ([#553](https://github.com/astrale-os/kernel/issues/553)) ([9f16257](https://github.com/astrale-os/kernel/commit/9f1625735e06331d67731a70be8f56378cd4c67c))
+
 ## [0.2.0-beta.19](https://github.com/astrale-os/kernel/compare/kernel-dsl-v0.2.0-beta.18...kernel-dsl-v0.2.0-beta.19) (2026-08-29)
 
 

package/dist/v1/builder/lowering/value/compile.js

@@ -1,5 +1,5 @@
 import { accept as acceptJsonValue } from '@astrale-os/kernel-dsl/value';
-import { z } from 'zod';
+import { ZodType } from 'zod';
 import { compareDefinitionRefs } from '../../../addressing/ordering.js';
 import { canonicalizeValueSchema } from '../../../language/value/profile/canonicalize.js';
 import { validateValueSchema } from '../../../language/value/profile/validate.js';
@@ -54,7 +54,7 @@ export class BuilderValueSchemas {
     }
     lower(input, conversionContext, pointer, zodPosition = 'value') {
         let schema;
-        if (input instanceof z.ZodType) {
+        if (input instanceof ZodType) {
             const converted = convertZodToValueSchema(input, conversionContext, this.registry, pointer, {
                 position: zodPosition,
                 validate: false,
@@ -137,7 +137,7 @@ function isAutoProperty(value) {
     return isAuthoringValue(value, 'auto');
 }
 function isRequired(value) {
-    if (!(value instanceof z.ZodType))
+    if (!(value instanceof ZodType))
         return true;
     return !zodObjectPropertyIsOptional(value);
 }

package/dist/v1/builder/lowering/value/zod.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { ZodType } from 'zod';
 import type { JsonSchema, ValueSchemaContext } from '../../../language/value/model/schema.js';
 import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
 import type { BuilderDiagnostic } from '../../schema/diagnostic.js';
@@ -19,7 +19,7 @@ export interface ZodValueSchemaConversionOptions {
     readonly validate?: boolean;
 }
 export interface ZodValueSchemaOverrideContext {
-    readonly zodSchema: z.ZodType;
+    readonly zodSchema: ZodType;
     readonly jsonSchema: Record<string, unknown>;
     readonly path: readonly (string | number)[];
 }
@@ -27,6 +27,6 @@ export interface ZodValueSchemaOverrideContext {
  * Converts only Zod contracts whose JSON-value acceptance is represented
  * without coercion, effects, custom predicates, or format assertions.
  */
-export declare function convertZodToValueSchema(zodSchema: z.ZodType, context: ValueSchemaContext, registry: ValueSchemaRegistry, pointer?: string, options?: ZodValueSchemaConversionOptions): ZodValueSchemaConversion;
+export declare function convertZodToValueSchema(zodSchema: ZodType, context: ValueSchemaContext, registry: ValueSchemaRegistry, pointer?: string, options?: ZodValueSchemaConversionOptions): ZodValueSchemaConversion;
 /** Whether explicit Zod optionality makes a containing object property absent-able. */
-export declare function zodObjectPropertyIsOptional(schema: z.ZodType): boolean;
+export declare function zodObjectPropertyIsOptional(schema: ZodType): boolean;

package/dist/v1/builder/lowering/value/zod.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { ZodObject, ZodType, toJSONSchema } from 'zod';
 import { VALUE_SCHEMA_DIALECT } from '../../../language/value/model/schema.js';
 import { canonicalizeValueSchema } from '../../../language/value/profile/canonicalize.js';
 import { validateValueSchema } from '../../../language/value/profile/validate.js';
@@ -15,19 +15,19 @@ export function convertZodToValueSchema(zodSchema, context, registry, pointer =
         return { ok: false, diagnostics };
     let converted;
     try {
-        const raw = z.toJSONSchema(zodSchema, {
+        const raw = toJSONSchema(zodSchema, {
             target: 'draft-2020-12',
             unrepresentable: 'throw',
             io: 'input',
             cycles: 'ref',
             reused: 'inline',
             override: ({ zodSchema: source, jsonSchema, path }) => {
-                if (source instanceof z.ZodObject) {
+                if (source instanceof ZodObject) {
                     jsonSchema.required = Object.entries(source.shape)
                         .filter(([, property]) => !zodObjectPropertyIsOptional(property))
                         .map(([name]) => name);
                 }
-                if (source instanceof z.ZodType) {
+                if (source instanceof ZodType) {
                     lowerFullMatchChecks(source, jsonSchema);
                     options.override?.({
                         jsonSchema: jsonSchema,
@@ -284,7 +284,7 @@ function getCheckDefinition(value) {
     return isPlainRecord(internals?.def) ? internals.def : undefined;
 }
 function isZodType(value) {
-    return value instanceof z.ZodType;
+    return value instanceof ZodType;
 }
 function escapePointerToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');

package/dist/v1/builder/value/path.d.ts

@@ -1,7 +1,7 @@
-import { z } from 'zod';
+import { type ZodString } from 'zod';
 import type { NodeClassReferenceInput } from '../class/authoring.js';
 declare const PATH_ACCEPTS: unique symbol;
-export type PathAuthoring<Accepts extends readonly NodeClassReferenceInput[] = readonly NodeClassReferenceInput[]> = z.ZodString & {
+export type PathAuthoring<Accepts extends readonly NodeClassReferenceInput[] = readonly NodeClassReferenceInput[]> = ZodString & {
     readonly [PATH_ACCEPTS]: Accepts;
 };
 export declare function path<const Accepts extends readonly NodeClassReferenceInput[]>(...accepts: Accepts): PathAuthoring<Accepts>;

package/dist/v1/builder/value/path.js

@@ -1,11 +1,11 @@
-import { z } from 'zod';
+import { string } from 'zod';
 import { fail } from '../schema/diagnostic.js';
 import { rememberPath } from './path-metadata.js';
 export function path(...accepts) {
     if (accepts.length === 0) {
         fail('BUILDER_PATH_EMPTY', '', 'path(...) requires at least one Node Definition.');
     }
-    const schema = z.string();
+    const schema = string();
     rememberPath(schema, accepts);
     return schema;
 }

package/dist/v1/compiled/admission/semantics.js

@@ -494,10 +494,10 @@ function validatePolicyParity(context, entry, entryIndex, policies) {
         if ('match' in declaration.expression) {
             for (const branch of branchesOf(declaration.expression.match, name)) {
                 if (targetMode(branch) === undefined) {
-                    fail(`${path}/expression/match`, 'A Policy branch must target object or both source and target.');
+                    fail(`${path}/expression/match`, 'A Policy branch must target object or at least one of source and target.');
                 }
                 if (!isConnected(branch)) {
-                    fail(`${path}/expression/match`, 'A Policy branch must connect subject, every target, and every scoped variable.');
+                    fail(`${path}/expression/match`, 'A Policy branch must connect subject, every referenced protected term, and every scoped variable.');
                 }
             }
         }

package/dist/v1/language/policy/analysis/branches.js

@@ -25,7 +25,14 @@ export function isConnected(branch) {
     const mode = targetMode(branch);
     if (mode === undefined)
         return false;
-    const vertices = new Set(mode === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
+    const vertices = new Set(['subject']);
+    for (const edge of branch.edges) {
+        for (const term of [edge.pattern.source, edge.pattern.target]) {
+            if (term.kind === 'object' || term.kind === 'source' || term.kind === 'target') {
+                vertices.add(term.kind);
+            }
+        }
+    }
     for (const variable of branch.requiredVariables)
         vertices.add(variable);
     const union = new UnionFind(vertices);
@@ -52,7 +59,7 @@ export function targetMode(branch) {
     }
     if (object && !source && !target)
         return 'object';
-    if (!object && source && target)
+    if (!object && (source || target))
         return 'edge';
     return undefined;
 }

package/dist/v1/language/state/machine.d.ts

@@ -1,8 +1,8 @@
-import { z } from 'zod';
+import { type ZodType } from 'zod';
 import type { EventName, StateName, StateTopology, TransitionRelation, ValidTransitionRelation } from './topology.js';
 export interface StateMachine<Transitions extends TransitionRelation = any, Initial extends StateName<Transitions> = StateName<Transitions>> extends StateTopology<Transitions, Initial> {
-    readonly stateSchema: z.ZodType<StateName<Transitions>>;
-    readonly eventSchema: z.ZodType<EventName<Transitions>>;
+    readonly stateSchema: ZodType<StateName<Transitions>>;
+    readonly eventSchema: ZodType<EventName<Transitions>>;
     eventsFrom<State extends StateName<Transitions>>(state: State): readonly EventName<Transitions, State>[];
     decide<State extends StateName<Transitions>, Event extends EventName<Transitions>>(state: State, event: Event): TransitionDecision<Transitions, State, Event>;
 }

package/dist/v1/language/state/machine.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { enum as enumeration } from 'zod';
 import { compareUnicode } from '../../addressing/ordering.js';
 import { admitStateTopology } from './topology.js';
 export function stateMachine(input) {
@@ -11,8 +11,8 @@ export function stateMachine(input) {
     const eventSet = new Set(events);
     return Object.freeze({
         ...topology,
-        stateSchema: z.enum(states),
-        eventSchema: z.enum(events),
+        stateSchema: enumeration(states),
+        eventSchema: enumeration(events),
         eventsFrom(state) {
             admitState(state, stateSet);
             return Object.freeze(Object.keys(topology.transitions[state]));

package/dist/v1/language/value/syntax/full-match.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { refine } from 'zod';
 import { compilePattern } from '../regexp/compile.js';
 import { loadPattern } from '../regexp/matcher.js';
 import { isIRegexp } from '../regexp/syntax.js';
@@ -8,7 +8,7 @@ export function fullMatch(source) {
         throw new TypeError('fullMatch(...) requires a complete RFC 9485 I-Regexp source.');
     }
     const matcher = loadPattern(compilePattern(source));
-    const check = z.refine((value) => matcher.matches(value), {
+    const check = refine((value) => matcher.matches(value), {
         error: `String must fully match I-Regexp ${JSON.stringify(source)}.`,
     });
     sources.set(check, source);

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

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

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

@@ -1,59 +1,53 @@
-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 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 stateNameSchema = z.string().min(1);
-const stateTransitionsSchema = z.custom(isStateTransitions);
-const stateTopologySchema = z.strictObject({
+const stateNameSchema = string().min(1);
+const stateTransitionsSchema = custom(isStateTransitions);
+const stateTopologySchema = strictObject({
     initial: stateNameSchema,
     transitions: stateTransitionsSchema,
 });
-const propertyDefinitionSchema = z.strictObject({
+const propertyDefinitionSchema = strictObject({
     schema: jsonSchemaSchema,
-    required: z.boolean(),
-    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(),
     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,
 });
@@ -61,14 +55,14 @@ 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') });
+const coreEndpointRefSchema = discriminatedUnion('kind', [coreRefSchema, domainRefSchema]);
+const policyObjectRefSchema = discriminatedUnion('kind', [
     classRefSchema,
     functionRefSchema,
     policyRefSchema,
@@ -79,113 +73,111 @@ 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,
 ]);
-const policyVariableSchema = z.strictObject({
+const policyVariableSchema = 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 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({
         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({
         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 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) => {
+    static: boolean(),
+    inheritance: enumeration(['abstract', 'default', 'sealed']),
+}).superRefine((method, context) => {
     if (method.inheritance === 'abstract' && method.policy !== undefined) {
         context.addIssue({
             code: 'custom',
@@ -203,19 +195,19 @@ 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 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,
@@ -226,22 +218,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;
@@ -252,9 +242,10 @@ 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,
+}).superRefine((callable, context) => {
     if (callable.auth !== 'authorized' && callable.policy !== undefined) {
         context.addIssue({
             code: 'custom',
@@ -264,58 +255,58 @@ 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'),
+const viewTargetSchema = discriminatedUnion('kind', [
+    strictObject({ kind: literal('domain') }),
+    strictObject({
+        kind: literal('definition'),
         definitions: uniqueArray(classRefSchema).min(1),
     }),
 ]);
-const viewDefinitionSchema = z.strictObject({
+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),
+    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;
@@ -326,9 +317,9 @@ 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,
     });
 }
@@ -357,7 +348,7 @@ 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/references.js

@@ -34,11 +34,11 @@ function validateMatch(context, name, pattern, pointer) {
     for (const [index, branch] of branches.entries()) {
         const mode = targetMode(branch);
         if (mode === undefined) {
-            context.add('PL_TARGET', `${pointer}/match`, `Normalized branch ${index} must use object or both source and target, without mixing target modes.`);
+            context.add('PL_TARGET', `${pointer}/match`, `Normalized branch ${index} must use object or at least one of source and target, without mixing target modes.`);
             continue;
         }
         if (!isConnected(branch)) {
-            context.add('PL_CONNECTIVITY', `${pointer}/match`, `Normalized ${mode} branch ${index} does not connect subject, its target terms, and every scoped term.`);
+            context.add('PL_CONNECTIVITY', `${pointer}/match`, `Normalized ${mode} branch ${index} does not connect subject, every referenced protected term, and every scoped term.`);
         }
     }
 }

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

@@ -16,7 +16,7 @@ export class PolicyTyping {
                 const mode = targetMode(branch);
                 if (mode === undefined) {
                     if (!('match' in this.context.environment.candidate.policies[name].expression)) {
-                        this.context.add('PL_TARGET', `/policies/${escapePointer(name)}`, `Expanded normalized branch ${index} must use object or both source and target, without mixing target modes.`);
+                        this.context.add('PL_TARGET', `/policies/${escapePointer(name)}`, `Expanded normalized branch ${index} must use object or at least one of source and target, without mixing target modes.`);
                     }
                     continue;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.19",
+  "version": "0.2.0-beta.20",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {