@astrale-os/kernel-dsl 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/v1/addressing/domain-dependency.d.ts

@@ -10,9 +10,3 @@ export type DomainDependency = JsonObject & {
 export type DependencyAlias = string;
 /** Exact direct dependency pins keyed by their authored aliases. */
 export type DomainDependencyMap = Readonly<Record<DependencyAlias, DomainDependency>>;
-/** Representation-neutral admission budgets shared by source and compiled closures. */
-export declare const dependencyLimits: Readonly<{
-    direct: 32;
-    closure: 256;
-    depth: 32;
-}>;

package/dist/v1/addressing/domain-dependency.js

@@ -1,6 +1 @@
-/** Representation-neutral admission budgets shared by source and compiled closures. */
-export const dependencyLimits = Object.freeze({
-    direct: 32,
-    closure: 256,
-    depth: 32,
-});
+export {};

package/dist/v1/addressing/key.js

@@ -1,7 +1,8 @@
 import { acceptDefinitionRef, } from './definition-ref.js';
 import { DOMAIN_ORIGIN_PATTERN } from './patterns.js';
 const DEFINITION_KEY = /^(?:class|function|policy|view)\.([A-Za-z][A-Za-z0-9_]*)$/u;
-const CORE_KEY = /^core\.([a-z][a-z0-9-]{0,99})$/u;
+// The slug is the whole rest of the coordinate, its own `.` included: no member follows a Core key.
+const CORE_KEY = /^core\.((?=.{1,100}$)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*)$/u;
 const MEMBER_KEY = /^class\.([A-Za-z][A-Za-z0-9_]*)\.(property|method)\.([A-Za-z][A-Za-z0-9_]*)$/u;
 /** The keys of frozen Definition coordinates, derived once each. */
 const derived = new WeakMap();

package/dist/v1/addressing/patterns.d.ts

@@ -3,6 +3,7 @@ export type DomainOrigin = string;
 export declare const DOMAIN_ORIGIN_PATTERN: RegExp;
 export declare const MEMBER_NAME_PATTERN: RegExp;
 export declare const DEPENDENCY_ALIAS_PATTERN: RegExp;
+/** Labels of `[a-z][a-z0-9-]*` joined by `.`, 100 code points at most: `graph.reader`. */
 export declare const CORE_SLUG_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_PATTERN: RegExp;
 export declare const PROPERTY_KEY_PATTERN: RegExp;

package/dist/v1/addressing/patterns.js

@@ -1,7 +1,8 @@
 export const DOMAIN_ORIGIN_PATTERN = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
 export const MEMBER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/u;
 export const DEPENDENCY_ALIAS_PATTERN = /^[a-z][A-Za-z0-9]*$/u;
-export const CORE_SLUG_PATTERN = /^[a-z][a-z0-9-]{0,99}$/u;
+/** Labels of `[a-z][a-z0-9-]*` joined by `.`, 100 code points at most: `graph.reader`. */
+export const CORE_SLUG_PATTERN = /^(?=.{1,100}$)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*$/u;
 export const DOMAIN_REVISION_PATTERN = /^sha256:[0-9a-f]{64}$/u;
 const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
 const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';

package/dist/v1/builder/class/authoring.d.ts

@@ -1,5 +1,6 @@
 import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
+import type { ClassRef } from '../../addressing/index.js';
 import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
 import type { StateTopologyOf } from '../../language/state/topology.js';
 import type { BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
@@ -82,6 +83,44 @@ type ClassDepthOfInput<Input> = Input extends {
 } ? Parents extends readonly [] ? 0 : Increment<ClassDepthOf<Parents[number]>> : 0;
 type CompactReference<Value> = Value extends () => infer Resolved ? () => CompactReference<Resolved> : Value extends ResolvedClass ? ClassProjectionOfResolved<Value> : Value extends Class ? ClassReferenceProjectionOf<Value> : Value;
 type CompactReferences<Values extends readonly unknown[]> = Values extends readonly [] ? readonly [] : Values extends readonly [infer Value, ...infer Rest] ? readonly [CompactReference<Value>, ...CompactReferences<Rest>] : readonly CompactReference<Values[number]>[];
+/**
+ * A Class an endpoint accepts, as its projection keeps it: the exact ref of a resolved Class, the
+ * mark of an authored one, which the Schema names, or the ref as given. A lazy reference stays lazy.
+ */
+type CompactAccepted<Value> = Value extends () => infer Resolved ? () => CompactAccepted<Resolved> : Value extends ResolvedClass ? ExactClassRefOf<Value> : Value extends NodeClass<infer Config> ? AcceptedClassMark<Config> : Value;
+/**
+ * What tells an authored Node Class from the other Classes of its Schema in an endpoint's type:
+ * its abstractness, its depth and the names of its effective members. Names alone keep the Edge
+ * handle small enough to print in a declaration file; Classes alike in all of these are the same
+ * accepted Class to the types, never to the Schema. `schema/projection/class.ts` names the Classes
+ * of a Schema and of its direct dependencies that bear the mark, since either may own the handle.
+ */
+type AcceptedClassMark<Config> = {
+    readonly kind: 'node';
+    readonly abstract: Config extends {
+        readonly abstract: infer Abstract;
+    } ? Abstract : never;
+    readonly depth: Config extends {
+        readonly depth: infer Depth;
+    } ? Depth : never;
+    readonly properties: Config extends {
+        readonly effectiveProperties: infer Properties;
+    } ? Properties extends {
+        readonly name: infer Name;
+    } ? Name : never : never;
+    readonly methods: Config extends {
+        readonly effectiveInstanceMethods: infer Instance;
+        readonly effectiveStaticMethods: infer Static;
+    } ? Instance | Static extends infer Method ? Method extends {
+        readonly name: infer Name;
+    } ? Name : never : never : never;
+};
+/** The ref of a resolved Class, exact while its key is. */
+type ExactClassRefOf<Value extends ResolvedClass> = Value['key'] extends `${infer Origin}:class.${infer Name}` ? string extends Origin ? ClassRef : string extends Name ? ClassRef : ClassRef<Name> & {
+    readonly origin: Origin;
+} : ClassRef;
+/** The Classes one endpoint accepts, in any order: the runtime list is canonically sorted. */
+type CompactAccepts<Values> = Values extends readonly (infer Value)[] ? readonly CompactAccepted<Value>[] : readonly never[];
 type CompactParentsOf<Input> = Input extends {
     readonly extends?: infer Values extends readonly unknown[];
 } ? 'extends' extends keyof Input ? CompactReferences<Values> : readonly [] : readonly [];
@@ -114,10 +153,12 @@ type CompactDirectedInput<Input extends Omit<DirectedEdgeInput, 'orientation'>>
     } ? NonNullable<Value> : never : never>;
     readonly source: {
         readonly as: Input['source']['as'];
+        readonly accepts: CompactAccepts<Input['source']['accepts']>;
         readonly outgoing: Input['source']['outgoing'];
     };
     readonly target: {
         readonly as: Input['target']['as'];
+        readonly accepts: CompactAccepts<Input['target']['accepts']>;
         readonly incoming: Input['target']['incoming'];
     };
     readonly constraints: Input extends {
@@ -137,10 +178,12 @@ type CompactUndirectedInput<Input extends Omit<UndirectedEdgeInput, 'orientation
     readonly endpoints: readonly [
         {
             readonly as: Input['endpoints'][0]['as'];
+            readonly accepts: CompactAccepts<Input['endpoints'][0]['accepts']>;
             readonly incident: Input['endpoints'][0]['incident'];
         },
         {
             readonly as: Input['endpoints'][1]['as'];
+            readonly accepts: CompactAccepts<Input['endpoints'][1]['accepts']>;
             readonly incident: Input['endpoints'][1]['incident'];
         }
     ];

package/dist/v1/builder/class/property.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { AutoEvent, AutoSet, PropertyImmutability } from '../../language/class/model/property.js';
+import type { AutoEvent, AutoSet, PropertyAuto, PropertyImmutability } from '../../language/class/model/property.js';
 import type { StateMachine } from '../../language/state/index.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { AUTHORING } from '../schema/handle.js';
@@ -31,10 +31,7 @@ export interface AutoProperty<out PropertyValue extends Property = Property> {
     readonly [AUTHORING]: 'auto';
     readonly [AUTO_INPUT]: {
         readonly property: PropertyValue;
-        readonly options: {
-            readonly on: readonly AutoEvent[];
-            readonly set: AutoSet;
-        };
+        readonly options: PropertyAuto;
     };
 }
 type PropertyAuthoringInput<Value extends Property> = Value extends Property<infer Schema, infer Options, infer Machine> ? {
@@ -45,10 +42,7 @@ type PropertyAuthoringInput<Value extends Property> = Value extends Property<inf
 export declare function propertyAuthoringInput<const Value extends Property>(value: Value): PropertyAuthoringInput<Value>;
 export declare function autoPropertyAuthoringInput<const Value extends AutoProperty>(value: Value): Value extends AutoProperty<infer Property> ? {
     readonly property: Property;
-    readonly options: {
-        readonly on: readonly AutoEvent[];
-        readonly set: AutoSet;
-    };
+    readonly options: PropertyAuto;
 } : never;
 export type PropertyFieldInput = ValueSchemaInput | Property | AutoProperty;
 export type PropertyRecordInput = Readonly<Record<string, PropertyFieldInput>>;

package/dist/v1/builder/class/property.js

@@ -59,6 +59,7 @@ export function auto(property, options) {
     return authoringValue('auto', {
         [AUTO_INPUT]: {
             property,
+            // `events` holds at least the one authored event.
             options: { on: Object.freeze(events), set: options.set },
         },
     });

package/dist/v1/builder/index.d.ts

@@ -19,7 +19,7 @@ export type { ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRule
 export type { AuthoredPropertyProjection, AuthoredMethodProjection, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, } from './class/projection.js';
 export type { PathAuthoring } from './value/path.js';
 export type { Lazy } from './schema/lazy.js';
-export type { MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeInput, PolicyExistsContext, PolicyInput, PolicyNodeBinder, PolicyPatternContext, } from './policy/authoring.js';
+export type { EdgeRolesOf, MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeClassInput, PolicyEdgeEnds, PolicyEdgeInput, PolicyEdgeOptions, PolicyEdgeRepeat, PolicyExistsContext, PolicyInput, PolicyNodeBinder, PolicyPatternContext, } from './policy/authoring.js';
 export type { AutoOptions, AutoProperty, Property, PropertyFieldInput as PropertyField, PropertyOptions, ValueSchemaInput, } from './class/property.js';
 export type { CorePropertyInput } from './schema/projection.js';
 export type { ClassProjection, FunctionProjection, MethodProjection, PropertyProjection, } from './schema/projection.js';

package/dist/v1/builder/lowering/class.js

@@ -48,6 +48,7 @@ export class V1DefinitionCompiler {
     }
     edgeClass(value, name, pointer) {
         const input = classConfiguration(value);
+        // The authoring types give an Edge no State Property; the structure refuses an erased one.
         const facet = this.values.properties(input.properties, `${pointer}/properties`);
         const contract = (() => {
             if (value.orientation === 'directed') {
@@ -63,7 +64,9 @@ export class V1DefinitionCompiler {
                     // against the Class's effective Properties, once every Class is lowered.
                     ...(directed.unique === undefined
                         ? {}
-                        : { unique: directed.unique }),
+                        : {
+                            unique: directed.unique,
+                        }),
                 };
             }
             const undirected = classConfiguration(value);
@@ -135,6 +138,7 @@ export class V1DefinitionCompiler {
     endpointBase(value, pointer) {
         return {
             role: value.as,
+            // An empty list stays as authored: the structure refuses it when it judges the candidate.
             accepts: value.accepts
                 .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/accepts/${index}`))
                 .sort(compareDefinitionRefs),

package/dist/v1/builder/lowering/policy.js

@@ -14,6 +14,7 @@ export class V1PolicyCompiler {
         const input = policyDeclaration(value);
         const ref = { origin: this.context.origin, kind: 'policy', name };
         if ('operator' in input) {
+            // One ref for each Policy of a non-empty composition.
             const refs = input.policies.map((policy, index) => this.context.resolvePolicy(policy, `${pointer}/${input.operator}/${index}`));
             return {
                 ref,
@@ -23,6 +24,7 @@ export class V1PolicyCompiler {
         const match = input.match(createPatternContext({
             resolveObject: (member, refPointer) => this.context.resolvePolicyObject(member, refPointer),
             resolveEdgeClass: (definition, refPointer) => this.context.resolveEdgeClass(definition, refPointer),
+            edgeRoles: (ref) => this.context.edgeRoles(ref),
             resolveNodeClass: (definition, refPointer) => this.context.resolveNodeClass(definition, refPointer),
             pointer,
         }));

package/dist/v1/builder/lowering/schema/context.d.ts

@@ -34,6 +34,11 @@ export declare class BuilderContext {
     resolveParent(input: ClassReferenceInput, kind: ClassKind, pointer: string): ClassRef;
     resolveNodeClass(input: ClassReferenceInput, pointer: string): ClassRef;
     resolveEdgeClass(input: ClassReferenceInput, pointer: string): ClassRef;
+    /**
+     * The roles of a resolved Edge Class's source and target, or of an undirected Class's two
+     * endpoints in their stored order, which is the authored one.
+     */
+    edgeRoles(ref: ClassRef): readonly [source: string, target: string];
     resolvePolicy(input: Lazy<unknown>, pointer: string): PolicyRef;
     resolvePolicyObject(input: PolicyObjectInput | PolicyObjectRef, pointer: string): PolicyObjectRef;
     /** A Core fact belongs to the Domain that declares it, so a dependency endpoint never resolves. */

package/dist/v1/builder/lowering/schema/context.js

@@ -8,6 +8,7 @@ import { escapePointerToken } from '../../../language/value/syntax/pointer.js';
 import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
 import { requireDomainClosure } from '../../../schema/resolution/closure.js';
 import { collectUsedForeignOrigins } from '../../../schema/resolution/origins.js';
+import { classConfiguration } from '../../class/authoring.js';
 import { fail } from '../../schema/diagnostic.js';
 import { resolveLazy } from '../../schema/lazy.js';
 import { OwnershipCapture } from './ownership.js';
@@ -16,6 +17,7 @@ export class BuilderContext {
     ownership = new OwnershipCapture();
     localDefinitions = new Map();
     localClassKinds = new Map();
+    #localClasses = new Map();
     policies = new Map();
     policyObjects = new Map();
     policyObjectRefs = new Set();
@@ -49,6 +51,7 @@ export class BuilderContext {
         }
         this.localDefinitions.set(key, ref);
         this.localClassKinds.set(key, value.kind);
+        this.#localClasses.set(key, value);
         this.ownership.captureDefinition(value, ref, pointer);
         this.capturePolicyObject(value, ref);
     }
@@ -109,6 +112,25 @@ export class BuilderContext {
     resolveEdgeClass(input, pointer) {
         return this.resolveClass(input, 'edge', pointer);
     }
+    /**
+     * The roles of a resolved Edge Class's source and target, or of an undirected Class's two
+     * endpoints in their stored order, which is the authored one.
+     */
+    edgeRoles(ref) {
+        if (ref.origin === this.origin) {
+            const value = this.#localClasses.get(definitionRefIndex(ref));
+            if (value.orientation === 'directed') {
+                const input = classConfiguration(value);
+                return [input.source.as, input.target.as];
+            }
+            const input = classConfiguration(value);
+            return [input.endpoints[0].as, input.endpoints[1].as];
+        }
+        const definition = this.#dependencies.get(ref.origin).schema.classes[ref.name];
+        return definition.orientation === 'directed'
+            ? [definition.endpoints.source.role, definition.endpoints.target.role]
+            : [definition.endpoints[0].role, definition.endpoints[1].role];
+    }
     resolvePolicy(input, pointer) {
         const value = resolveLazy(input, pointer);
         if (typeof value !== 'object' || value === null) {

package/dist/v1/builder/policy/authoring.d.ts

@@ -1,18 +1,79 @@
 import type { ClassRef } from '../../addressing/index.js';
+import type { ResolvedClass } from '../../language/class/resolved.js';
 import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm, PolicyObjectRef } from '../../language/policy/model/policy.js';
 import type { PolicyObjectInput } from '../callable/authoring.js';
+import type { DirectedEdgeClass, EdgeClass, UndirectedEdgeClass } from '../class/handle.js';
 import type { EdgeClassReferenceInput, NodeClassReferenceInput } from '../class/input.js';
 import type { AuthoringValue } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
+import type { ResolveLazy } from '../schema/projection/identity.js';
+/**
+ * @deprecated Name the ends by their roles: `edge(classValue, { [role]: term }, { repeat })`
+ * lowers to this same pattern.
+ */
 export interface PolicyEdgeInput {
     readonly source: CanonicalPolicyPatternTerm;
     readonly class: EdgeClassReferenceInput;
     readonly target: CanonicalPolicyPatternTerm;
-    readonly repeat?: {
-        readonly min: number;
-        readonly max: number;
-    };
+    readonly repeat?: PolicyEdgeRepeat;
+}
+/** How many Edges of the Class a path between the two terms crosses, both bounds included. */
+export interface PolicyEdgeRepeat {
+    readonly min: number;
+    readonly max: number;
+}
+export interface PolicyEdgeOptions {
+    readonly repeat?: PolicyEdgeRepeat;
 }
+/** An Edge Class whose ends a Policy names by role: authored, resolved, or either lazily. */
+export type PolicyEdgeClassInput = Lazy<EdgeClass | ResolvedClass<'edge'>>;
+/**
+ * The roles of an Edge Class's two ends, as literal types: the `as` of an authored Class's ends,
+ * the `role` of a resolved Class's, read through a lazy reference.
+ */
+export type EdgeRolesOf<Value> = ResolveLazy<Value> extends infer Resolved ? Resolved extends DirectedEdgeClass<infer Config> ? Config extends {
+    readonly source: {
+        readonly as: infer Source;
+    };
+    readonly target: {
+        readonly as: infer Target;
+    };
+} ? Source | Target : never : Resolved extends UndirectedEdgeClass<infer Config> ? Config extends {
+    readonly endpoints: readonly [
+        {
+            readonly as: infer First;
+        },
+        {
+            readonly as: infer Second;
+        }
+    ];
+} ? First | Second : never : Resolved extends {
+    readonly kind: 'edge';
+    readonly definition: {
+        readonly endpoints: infer Endpoints;
+    };
+} ? Endpoints extends {
+    readonly source: {
+        readonly role: infer Source;
+    };
+    readonly target: {
+        readonly role: infer Target;
+    };
+} ? Source | Target : Endpoints extends readonly [
+    {
+        readonly role: infer First;
+    },
+    {
+        readonly role: infer Second;
+    }
+] ? First | Second : never : never : never;
+/**
+ * The two ends of an Edge, keyed by exactly the Class's two roles, both required. A Class whose
+ * roles the types do not know names no ends.
+ */
+export type PolicyEdgeEnds<Value> = [EdgeRolesOf<Value>] extends [never] ? never : string extends EdgeRolesOf<Value> ? never : {
+    readonly [Role in EdgeRolesOf<Value> & string]: CanonicalPolicyPatternTerm;
+};
 export interface PolicyNodeBinder {
     (): CanonicalPolicyPatternTerm;
     (definition: NodeClassReferenceInput): CanonicalPolicyPatternTerm;
@@ -36,6 +97,23 @@ export interface PolicyPatternContext {
     readonly object: CanonicalPolicyPatternTerm;
     readonly source: CanonicalPolicyPatternTerm;
     readonly target: CanonicalPolicyPatternTerm;
+    /**
+     * An Edge of `classValue` between two terms, each keyed by the role of its end: `{ [role]: term }`,
+     * the source's role written first by convention. It lowers to the pattern whose source is the
+     * term of the source's role and whose target is the term of the target's role. For an undirected
+     * Class, the first endpoint's role lowers to the source, and the roles only order the two terms:
+     * the pattern still matches an Edge between the two Nodes whichever end each Node holds.
+     *
+     * ```ts
+     * edge(project_owned_by, { owner: subject, project })
+     * edge(() => subtask_of, { child: a, parent: b }, { repeat: { min: 1, max: 3 } })
+     * ```
+     */
+    edge<ClassValue extends PolicyEdgeClassInput>(classValue: ClassValue, ends: PolicyEdgeEnds<ClassValue>, options?: PolicyEdgeOptions): PolicyPatternExpression;
+    /**
+     * @deprecated Name the ends by their roles: `edge(classValue, { [role]: term }, { repeat })`
+     * lowers to this same pattern.
+     */
     edge(input: PolicyEdgeInput): PolicyPatternExpression;
     exists(build: (context: PolicyExistsContext) => PolicyPatternExpression): PolicyPatternExpression;
     allOf(first: PolicyPatternExpression, ...rest: readonly PolicyPatternExpression[]): PolicyPatternExpression;
@@ -63,6 +141,8 @@ export declare const policy: PolicyBuilder;
 export declare function createPatternContext(options: {
     readonly resolveObject: (value: PolicyObjectInput, pointer: string) => PolicyObjectRef;
     readonly resolveEdgeClass: (value: EdgeClassReferenceInput, pointer: string) => ClassRef;
+    /** The roles of an Edge Class's source and target, or of an undirected Class's two endpoints. */
+    readonly edgeRoles: (ref: ClassRef) => readonly [source: string, target: string];
     readonly resolveNodeClass: (value: NodeClassReferenceInput, pointer: string) => ClassRef;
     readonly pointer: string;
 }): PolicyPatternContext;

package/dist/v1/builder/policy/authoring.js

@@ -1,4 +1,4 @@
-import { assertKnownKeys, fail } from '../schema/diagnostic.js';
+import { assertKnownKeys, escapeToken, fail } from '../schema/diagnostic.js';
 import { authoringValue } from '../schema/handle.js';
 const declarations = new WeakMap();
 const compositions = new WeakSet();
@@ -31,6 +31,7 @@ export function createPatternContext(options) {
     const object = Object.freeze({ kind: 'object' });
     const source = Object.freeze({ kind: 'source' });
     const target = Object.freeze({ kind: 'target' });
+    const classRef = (value) => options.resolveEdgeClass(value, `${options.pointer}/match/class`);
     const context = {
         ref: (member) => ({
             kind: 'ref',
@@ -41,17 +42,36 @@ export function createPatternContext(options) {
         object,
         source,
         target,
-        edge(input) {
-            assertKnownKeys(input, ['source', 'class', 'target', 'repeat']);
-            if (input.repeat !== undefined)
-                assertKnownKeys(input.repeat, ['min', 'max']);
-            return {
-                source: input.source,
-                class: options.resolveEdgeClass(input.class, `${options.pointer}/match/class`),
-                target: input.target,
-                ...(input.repeat === undefined ? {} : { repeat: { ...input.repeat } }),
-            };
-        },
+        edge: ((first, ends, edgeOptions) => {
+            const pointer = `${options.pointer}/match/edge`;
+            if (ends === undefined) {
+                if (typeof first === 'function' || first.kind === 'edge') {
+                    fail('BUILDER_POLICY', pointer, 'edge(classValue, ends) names both ends by their roles.');
+                }
+                const input = first;
+                assertKnownKeys(input, ['source', 'class', 'target', 'repeat']);
+                if (input.repeat !== undefined)
+                    assertKnownKeys(input.repeat, ['min', 'max']);
+                return edgePattern(input.source, classRef(input.class), input.target, input.repeat);
+            }
+            const ref = classRef(first);
+            const [sourceRole, targetRole] = options.edgeRoles(ref);
+            if (typeof ends !== 'object' || ends === null) {
+                fail('BUILDER_POLICY', pointer, 'edge(classValue, ends) names both ends by their roles.');
+            }
+            assertKnownKeys(ends, [sourceRole, targetRole], pointer);
+            for (const role of [sourceRole, targetRole]) {
+                if (!Object.hasOwn(ends, role)) {
+                    fail('BUILDER_POLICY', `${pointer}/${escapeToken(role)}`, `edge(...) names both ends of ${ref.origin}:class.${ref.name}: "${sourceRole}" and "${targetRole}".`);
+                }
+            }
+            if (edgeOptions !== undefined)
+                assertKnownKeys(edgeOptions, ['repeat'], pointer);
+            if (edgeOptions?.repeat !== undefined) {
+                assertKnownKeys(edgeOptions.repeat, ['min', 'max'], `${pointer}/repeat`);
+            }
+            return edgePattern(ends[sourceRole], ref, ends[targetRole], edgeOptions?.repeat);
+        }),
         exists(build) {
             const nodes = [];
             const bind = (selector, definition) => {
@@ -86,10 +106,11 @@ export function createPatternContext(options) {
             });
             Object.freeze(node);
             const where = build({ node });
-            if (nodes.length === 0) {
+            const [first, ...rest] = nodes;
+            if (first === undefined) {
                 fail('BUILDER_POLICY_EMPTY_EXISTS', `${options.pointer}/match/exists/nodes`, 'exists(...) must declare at least one variable Node.');
             }
-            return { exists: { nodes, where } };
+            return { exists: { nodes: [first, ...rest], where } };
         },
         allOf(...expressions) {
             nonEmpty(expressions, `${options.pointer}/match/allOf`);
@@ -102,6 +123,15 @@ export function createPatternContext(options) {
     };
     return Object.freeze(context);
 }
+/** One Edge pattern, whichever form named its ends. */
+function edgePattern(source, classRef, target, repeat) {
+    return {
+        source,
+        class: classRef,
+        target,
+        ...(repeat === undefined ? {} : { repeat: { ...repeat } }),
+    };
+}
 function composition(operator, policies) {
     nonEmpty(policies, `/${operator}`);
     const value = {