@astrale-os/kernel-dsl 1.0.0-beta.16 → 1.0.0-beta.18

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

@@ -1,9 +1,9 @@
-import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { Array as PortableArray, Object as PortableObject, 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';
+import type { BLOB_VALUE_KIND, BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
 import type { Method, ProjectionOfCallable } from '../callable/authoring.js';
 import type { ClassProjectionOfResolved } from '../schema/projection.js';
 import type { TypedValueSchema } from '../value/schema.js';
@@ -14,8 +14,44 @@ import type { AutoProperty, Property, PropertyOptions, PropertyStateMachineOf, V
 type ExactEndpointInput<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
 type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions, unknown> ? Schema : Field;
 type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options, unknown> ? Options : Record<never, never>;
-type ValueInputOf<Schema> = Schema extends BlobSchema ? BlobReceipt : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
-type ValueOutputOf<Schema> = Schema extends BlobSchema ? BlobRef : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type JsonSchemaValueOf<Schema> = 0 extends 1 & Schema ? PortableValue : Schema extends {
+    readonly const: infer Value;
+} ? JsonKnownOf<Value> : Schema extends {
+    readonly enum: readonly (infer Value)[];
+} ? JsonKnownOf<Value> : Schema extends {
+    readonly anyOf: readonly (infer Branch)[];
+} ? JsonSchemaValueOf<Branch> : Schema extends {
+    readonly oneOf: readonly (infer Branch)[];
+} ? JsonSchemaValueOf<Branch> : Schema extends {
+    readonly type: infer Type;
+} ? JsonTypeValueOf<Type, Schema> : PortableValue;
+type JsonKnownOf<Value> = 0 extends 1 & Value ? PortableValue : Value;
+type JsonTypeValueOf<Type, Schema> = Type extends readonly (infer Each)[] ? JsonTypeValueOf<Each, Schema> : Type extends 'string' ? string : Type extends 'number' | 'integer' ? number : Type extends 'boolean' ? boolean : Type extends 'null' ? null : Type extends 'array' ? JsonArrayValueOf<Schema> : Type extends 'object' ? JsonObjectValueOf<Schema> : PortableValue;
+type JsonArrayValueOf<Schema> = 'prefixItems' extends keyof Schema ? PortableArray : Schema extends {
+    readonly items: infer Items;
+} ? readonly JsonSchemaValueOf<Items>[] : PortableArray;
+type JsonObjectValueOf<Schema> = 'patternProperties' extends keyof Schema ? PortableObject : Schema extends {
+    readonly properties: infer Properties extends Readonly<Record<string, unknown>>;
+    readonly additionalProperties: false;
+} ? JsonClosedObjectOf<Properties, Schema extends {
+    readonly required: infer Names;
+} ? Names : readonly []> : PortableObject;
+type JsonListsName<Names, Name> = [Names] extends [never] ? false : Names extends readonly unknown[] ? number extends Names['length'] ? false : true extends {
+    [At in keyof Names]: JsonNamesExactly<Names[At], Name>;
+}[number] ? true : false : false;
+type JsonNamesExactly<Element, Name> = [Element] extends [never] ? false : 0 extends 1 & Element ? false : [Element] extends [Name] ? true : false;
+type JsonClosedObjectOf<Properties, Names> = [keyof Properties] extends [never] ? Readonly<Record<string, never>> : {
+    readonly [Name in keyof Properties as JsonListsName<Names, Name> extends true ? Name : never]: JsonSchemaValueOf<Properties[Name]>;
+} & {
+    readonly [Name in keyof Properties as JsonListsName<Names, Name> extends true ? never : Name]?: JsonSchemaValueOf<Properties[Name]>;
+} extends infer Value ? {
+    [Name in keyof Value]: Value[Name];
+} : never;
+type BlobMarkedSchema = BlobSchema | {
+    readonly 'x-astrale-value-kind': typeof BLOB_VALUE_KIND;
+};
+type ValueInputOf<Schema> = Schema extends BlobMarkedSchema ? BlobReceipt : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : JsonSchemaValueOf<Schema>;
+type ValueOutputOf<Schema> = Schema extends BlobMarkedSchema ? BlobRef : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : JsonSchemaValueOf<Schema>;
 type PropertyRequiredOf<Field> = PropertyOptionsOf<Field> extends {
     readonly required: infer Required extends boolean;
 } ? Required : undefined extends ValueInputOf<PropertySchemaOf<Field>> ? false : true;

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

@@ -1,3 +1,4 @@
+import { CLASS_OPERATIONS } from '../../language/policy/model/policy.js';
 import { assertKnownKeys } from '../schema/diagnostic.js';
 import { authoringValue } from '../schema/handle.js';
 const classInputs = new WeakMap();
@@ -28,7 +29,7 @@ export function nodeClass(config) {
         'unique',
     ]);
     if (admitted.policies !== undefined)
-        assertKnownKeys(admitted.policies, ['read', 'traverse']);
+        assertKnownKeys(admitted.policies, CLASS_OPERATIONS);
     const value = authoringValue('definition', {
         kind: 'node',
     });
@@ -125,7 +126,7 @@ function validateIncidentEndpointInput(value) {
 /** Check the nested Edge Class options; the caller has checked the option keys themselves. */
 function validateEdgeClassOptions(value, constraints) {
     if (value.policies !== undefined)
-        assertKnownKeys(value.policies, ['read', 'traverse']);
+        assertKnownKeys(value.policies, CLASS_OPERATIONS);
     if (value.constraints !== undefined)
         assertKnownKeys(value.constraints, constraints);
 }

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

@@ -3,7 +3,7 @@ import type { Inheritance } from '../../language/class/model/class.js';
 import type { MediaType } from '../../language/class/model/data.js';
 import type { EdgeCount, EdgeLifetime } from '../../language/class/model/edge.js';
 import type { ResolvedClass } from '../../language/class/resolved.js';
-import type { ClassRuleChecks, ClassRuleObject } from '../../language/policy/model/policy.js';
+import type { ClassRuleChecks, ClassRuleObject, CreateRuleChecks, CreateRuleObject, EdgeRuleChecks } from '../../language/policy/model/policy.js';
 import type { Method, PolicyCheckContext } from '../callable/authoring.js';
 import type { Policy } from '../policy/authoring.js';
 import type { Lazy } from '../schema/lazy.js';
@@ -37,26 +37,57 @@ export interface IncidentEndpointInput {
     /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
     readonly onDelete?: EdgeLifetime;
 }
-/** One observation slot: a local Policy, or its constant value. Absent means `true`. */
+/**
+ * One Class slot: a local Policy, or its constant value. An omitted observation admits every
+ * caller, as `true` does; an omitted write admits only the owning Domain, as `false` does.
+ */
 export type ClassPolicyInput = Lazy<Policy> | boolean;
-/** Local observation Policies of a Class. */
-export interface ClassPoliciesInput {
-    readonly read?: ClassPolicyInput;
-    readonly traverse?: ClassPolicyInput;
-}
 /**
- * Policy checks deciding one Node Class observation. `self` is the observed Node; `ref` names one
- * exact member, the same Node for every observed candidate.
+ * Policy checks deciding one Node Class slot. `self` is the observed or written Node; `ref` names
+ * one exact member, the same Node for every candidate.
  */
 export interface ClassRuleContext extends PolicyCheckContext<ClassRuleObject> {
 }
 export type ClassRuleBuilder = (context: ClassRuleContext) => ClassRuleChecks;
-/** One Node Class observation slot: a local Policy, a constant value, or Policy checks. */
+/** One Node Class slot: a local Policy, a constant value, or Policy checks. */
 export type NodeClassPolicyInput = ClassPolicyInput | ClassRuleBuilder;
-/** Local observation Policies of a Node Class. */
+/**
+ * Policy checks deciding the creation of a Node. The Node is not yet, so it has no `self`: `ref`
+ * names each object, one exact member.
+ */
+export interface CreateRuleContext extends Omit<PolicyCheckContext<CreateRuleObject>, 'self'> {
+}
+export type CreateRuleBuilder = (context: CreateRuleContext) => CreateRuleChecks;
+/**
+ * The Node Class create slot: a constant value, or Policy checks over members. A Policy alone
+ * would have no object there.
+ */
+export type NodeClassCreatePolicyInput = boolean | CreateRuleBuilder;
+/** Local Policies of a Node Class. */
 export interface NodeClassPoliciesInput {
     readonly read?: NodeClassPolicyInput;
     readonly traverse?: NodeClassPolicyInput;
+    readonly create?: NodeClassCreatePolicyInput;
+    readonly update?: NodeClassPolicyInput;
+    readonly delete?: NodeClassPolicyInput;
+}
+/**
+ * Policy checks deciding one Edge Class slot. `self` is the observed or written Edge, checked by a
+ * Policy whose `source` and `target` are its endpoints; `ref` names one exact member, the same Node
+ * for every candidate.
+ */
+export interface EdgeRuleContext extends PolicyCheckContext<ClassRuleObject> {
+}
+export type EdgeRuleBuilder = (context: EdgeRuleContext) => EdgeRuleChecks;
+/** One Edge Class slot: a local Policy, a constant value, or Policy checks. */
+export type EdgeClassPolicyInput = ClassPolicyInput | EdgeRuleBuilder;
+/** Local Policies of an Edge Class. */
+export interface EdgeClassPoliciesInput {
+    readonly read?: EdgeClassPolicyInput;
+    readonly traverse?: EdgeClassPolicyInput;
+    readonly create?: EdgeClassPolicyInput;
+    readonly update?: EdgeClassPolicyInput;
+    readonly delete?: EdgeClassPolicyInput;
 }
 /** Authored Node Class. */
 export interface NodeClassInput {
@@ -69,7 +100,7 @@ export interface NodeClassInput {
     readonly data?: MediaType;
     readonly methods?: Readonly<Record<string, Method>>;
     readonly icon?: string;
-    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
+    /** Local Policies; inherited by no descendant and forbidden on abstract Classes. */
     readonly policies?: NodeClassPoliciesInput;
     /**
      * The tuples no two Nodes of this Class and of its active concrete descendants share while every
@@ -90,8 +121,8 @@ export interface EdgeClassOptions {
     readonly description?: string;
     readonly extends?: readonly EdgeClassReferenceInput[];
     readonly properties?: PropertyRecordInput;
-    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
-    readonly policies?: ClassPoliciesInput;
+    /** Local Policies; inherited by no descendant and forbidden on abstract Classes. */
+    readonly policies?: EdgeClassPoliciesInput;
     readonly constraints?: {
         readonly noSelf?: true;
         readonly acyclic?: true;

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

@@ -15,7 +15,8 @@ export type { BuilderDiagnostic as Diagnostic, BuilderDiagnosticCode as Diagnost
 export type { CallableInputBase, CallableInput, BinaryInputAuthoring, CallableOutputInput, CallableProjection, CallablePolicyBuilder, CallablePolicyContext, PolicyCheckContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
 export type { CoreEdge, CoreEndpoint, CoreInput, CoreNode } from './core/authoring.js';
 export type { Class, DirectedEdgeClass, EdgeClass, NodeClass, UndirectedEdgeClass, } from './class/handle.js';
-export type { ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClassReferenceInput as EdgeClassReference, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, } from './class/input.js';
+export type { ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, CreateRuleBuilder, CreateRuleContext, DirectedEdgeInput, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClassPoliciesInput, EdgeClassPolicyInput, EdgeClassReferenceInput as EdgeClassReference, EdgeRuleBuilder, EdgeRuleContext, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClassCreatePolicyInput, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, } from './class/input.js';
+export type { ClassRuleChecks, CreateRuleChecks, EdgeRuleChecks, } from '../language/policy/model/policy.js';
 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';

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

@@ -13,13 +13,21 @@ export declare class V1DefinitionCompiler {
     compileClass(value: Class, name: string, pointer: string): ClassDefinition;
     private nodeClass;
     private edgeClass;
+    /**
+     * An omitted observation, like `true`, lowers to the absent slot a Schema reads as every caller
+     * (A18 defers X1). A write slot has the converse spelling: `false` and an omitted slot lower to
+     * the absent slot, owner only.
+     */
     private classPolicies;
     /**
      * A lazy Policy ignores the context it is called with; a rule builder returns Policy checks. Both
      * are functions, so the result tells them apart.
      */
     private classPolicy;
+    /** A Node create rule checks members only: the Node it creates is not yet. */
+    private createRule;
     private classRuleContext;
+    private createRuleContext;
     private endpointBase;
     private directedSource;
     private directedTarget;

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

@@ -1,6 +1,6 @@
 import { compareDefinitionRefs } from '../../addressing/ordering.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
-import { isClassRuleChecks } from '../../language/policy/model/policy.js';
+import { CLASS_OPERATIONS, isClassObservation, isClassRuleChecks, } from '../../language/policy/model/policy.js';
 import { normalizeClassRule } from '../../language/policy/normalization/normalize.js';
 import { callableConfiguration } from '../callable/authoring.js';
 import { classConfiguration } from '../class/authoring.js';
@@ -88,43 +88,57 @@ export class V1DefinitionCompiler {
             extends: this.parents(input.extends, 'edge', `${pointer}/extends`),
             properties: facet,
             ...contract,
-            // classPolicy refuses Policy checks on an Edge Class, so only Class Policies remain.
             policies: this.classPolicies(input, 'edge', `${pointer}/policies`),
         };
     }
+    /**
+     * An omitted observation, like `true`, lowers to the absent slot a Schema reads as every caller
+     * (A18 defers X1). A write slot has the converse spelling: `false` and an omitted slot lower to
+     * the absent slot, owner only.
+     */
     classPolicies(input, kind, pointer) {
         const slot = (operation) => {
             const value = input.policies?.[operation];
+            const observation = isClassObservation(operation);
             if (value === undefined)
                 return undefined;
             if (typeof value !== 'boolean')
-                return this.classPolicy(value, kind, `${pointer}/${operation}`);
-            // `true` on an abstract Class would otherwise lower to nothing and pass unnoticed.
+                return this.classPolicy(value, kind, operation, `${pointer}/${operation}`);
+            // A constant on an abstract Class would otherwise lower to nothing and pass unnoticed.
             if (input.abstract === true) {
-                fail('BUILDER_ABSTRACT_POLICY', `${pointer}/${operation}`, 'Abstract Classes cannot declare observation Policies.');
+                fail('BUILDER_ABSTRACT_POLICY', `${pointer}/${operation}`, 'Abstract Classes cannot declare Class Policies.');
             }
-            // `true` is the meaning of an absent observation Policy, so it lowers to none.
-            return value ? undefined : false;
-        };
-        const read = slot('read');
-        const traverse = slot('traverse');
-        return {
-            ...(read === undefined ? {} : { read }),
-            ...(traverse === undefined ? {} : { traverse }),
+            // Each slot spells only the constant its absence does not mean.
+            if (observation)
+                return value ? undefined : false;
+            return value ? true : undefined;
         };
+        return Object.fromEntries(CLASS_OPERATIONS.flatMap((operation) => {
+            const policy = slot(operation);
+            return policy === undefined ? [] : [[operation, policy]];
+        }));
     }
     /**
      * A lazy Policy ignores the context it is called with; a rule builder returns Policy checks. Both
      * are functions, so the result tells them apart.
      */
-    classPolicy(value, kind, pointer) {
+    classPolicy(value, kind, operation, pointer) {
+        if (kind === 'node' && operation === 'create')
+            return this.createRule(value, pointer);
         if (typeof value !== 'function')
             return this.policies.ref(value, pointer);
         const result = value(this.classRuleContext(pointer));
         if (!isClassRuleResult(result))
             return this.policies.ref(result, pointer);
-        if (kind === 'edge') {
-            fail('BUILDER_POLICY', pointer, 'An Edge Class observation names one Policy, true or false.');
+        return normalizeClassRule(result);
+    }
+    /** A Node create rule checks members only: the Node it creates is not yet. */
+    createRule(value, pointer) {
+        const result = typeof value === 'function'
+            ? value(this.createRuleContext(pointer))
+            : undefined;
+        if (!isClassRuleResult(result)) {
+            fail('BUILDER_POLICY', pointer, 'A Node create rule checks Policies of ref(...) members: a Policy alone has no object there.');
         }
         return normalizeClassRule(result);
     }
@@ -135,6 +149,16 @@ export class V1DefinitionCompiler {
             fail('BUILDER_POLICY_INPUT', pointer, 'A Class rule checks self or one ref(...) member.');
         });
     }
+    createRuleContext(pointer) {
+        return policyCheckContext(this.context, pointer, (object) => {
+            if (object?.kind === 'ref')
+                return object;
+            if (object?.kind === 'self') {
+                fail('BUILDER_POLICY', pointer, 'A Node create rule has no self: the Node is not yet.');
+            }
+            fail('BUILDER_POLICY_INPUT', pointer, 'A Node create rule checks one ref(...) member.');
+        });
+    }
     endpointBase(value, pointer) {
         return {
             role: value.as,

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

@@ -1,7 +1,7 @@
+import { deepFreeze } from '../../../language/freeze.js';
 import { acceptDomainSchema } from '../../../schema/admission/accept.js';
-import { canonicalizeDomainSchema } from '../../../schema/canonical/domain.js';
-import { deepFreeze } from '../../../schema/canonical/freeze.js';
 import { MemoryDomainSchemaLookup } from '../../../schema/dependency/lookup.js';
+import { normalizeDomainSchema } from '../../../schema/normalization/domain.js';
 import { lookupEntriesForDependencies } from '../../../schema/resolution/closure.js';
 import { parseDomainSchemaStructure } from '../../../schema/validation/domain.structure.js';
 import { assertKnownKeys, escapeToken } from '../../schema/diagnostic.js';
@@ -90,7 +90,7 @@ function assembleDomainSchema(origin, input, lookup) {
         dependencies: context.dependencies(),
     };
     const structured = parseDomainSchemaStructure(candidate);
-    const canonical = parseDomainSchemaStructure(canonicalizeDomainSchema(structured));
+    const canonical = parseDomainSchemaStructure(normalizeDomainSchema(structured));
     return deepFreeze(canonical);
 }
 function mapRecord(record, map) {

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

@@ -21,97 +21,24 @@ function createPolicy(input) {
     declarations.set(value, input);
     return value;
 }
-export const policy = Object.freeze(Object.assign(createPolicy, {
-    allOf: (first, ...rest) => createPolicy(composition('allOf', first === undefined ? [] : [first, ...rest])),
-    anyOf: (first, ...rest) => createPolicy(composition('anyOf', first === undefined ? [] : [first, ...rest])),
-}));
+export const policy = Object.freeze(Object.assign(createPolicy, { allOf: composer('allOf'), anyOf: composer('anyOf') }));
+function composer(operator) {
+    return (first, ...rest) => createPolicy(composition(operator, first === undefined ? [] : [first, ...rest]));
+}
 export function createPatternContext(options) {
-    let nextVariable = 0;
-    const subject = Object.freeze({ kind: 'subject' });
-    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 nextVariable = variableIds();
     const context = {
         ref: (member) => ({
             kind: 'ref',
             ref: options.resolveObject(member, `${options.pointer}/match/ref`),
         }),
         sameNode: (left, right) => ({ sameNode: { left, right } }),
-        subject,
-        object,
-        source,
-        target,
-        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) => {
-                const variable = Object.freeze({ kind: 'variable', id: nextVariable++ });
-                if (selector === 'any') {
-                    nodes.push({ variable, selector: Object.freeze({ kind: 'any' }) });
-                }
-                else {
-                    const classRef = options.resolveNodeClass(definition, `${options.pointer}/match/exists/nodes`);
-                    nodes.push(selector === 'exact'
-                        ? { variable, class: classRef }
-                        : { variable, selector: Object.freeze({ kind: 'satisfies', class: classRef }) });
-                }
-                return variable;
-            };
-            const node = function (...args) {
-                if (args.length > 1 || (args.length === 1 && args[0] === undefined)) {
-                    fail('BUILDER_POLICY', `${options.pointer}/match/exists/nodes`, 'node(...) accepts either no arguments or one Node Class.');
-                }
-                return args.length === 0
-                    ? bind('any')
-                    : bind('satisfies', args[0]);
-            };
-            Object.defineProperty(node, 'exact', {
-                enumerable: true,
-                value(definition) {
-                    if (arguments.length !== 1 || definition === undefined) {
-                        fail('BUILDER_POLICY', `${options.pointer}/match/exists/nodes`, 'node.exact(...) requires exactly one Node Class.');
-                    }
-                    return bind('exact', definition);
-                },
-            });
-            Object.freeze(node);
-            const where = build({ node });
-            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: [first, ...rest], where } };
-        },
+        subject: Object.freeze({ kind: 'subject' }),
+        object: Object.freeze({ kind: 'object' }),
+        source: Object.freeze({ kind: 'source' }),
+        target: Object.freeze({ kind: 'target' }),
+        edge: (...args) => edge(options, args),
+        exists: (build) => exists(options, nextVariable, build),
         allOf(...expressions) {
             nonEmpty(expressions, `${options.pointer}/match/allOf`);
             return { allOf: expressions };
@@ -123,6 +50,50 @@ export function createPatternContext(options) {
     };
     return Object.freeze(context);
 }
+/** Variable ids, unique across every `exists(...)` of one pattern. */
+function variableIds() {
+    let next = 0;
+    return () => next++;
+}
+function edge(options, args) {
+    const pointer = `${options.pointer}/match/edge`;
+    if (args[1] === undefined)
+        return legacyEdge(options, args[0], pointer);
+    const [classValue, ends, edgeOptions] = args;
+    const ref = options.resolveEdgeClass(classValue, `${options.pointer}/match/class`);
+    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);
+    const missing = `edge(...) names both ends of ${ref.origin}:class.${ref.name}: "${sourceRole}" and "${targetRole}".`;
+    const sourceTerm = endTerm(ends, sourceRole, pointer, missing);
+    const targetTerm = endTerm(ends, targetRole, pointer, missing);
+    if (edgeOptions !== undefined)
+        assertKnownKeys(edgeOptions, ['repeat'], pointer);
+    if (edgeOptions?.repeat !== undefined) {
+        assertKnownKeys(edgeOptions.repeat, ['min', 'max'], `${pointer}/repeat`);
+    }
+    return edgePattern(sourceTerm, ref, targetTerm, edgeOptions?.repeat);
+}
+function legacyEdge(options, input, pointer) {
+    // Typed callers cannot pass an Edge Class without ends; untyped ones can, and `kind` is read
+    // without `in` so a primitive still reaches `assertKnownKeys`.
+    if (typeof input === 'function' || input.kind === 'edge') {
+        fail('BUILDER_POLICY', pointer, 'edge(classValue, ends) names both ends by their roles.');
+    }
+    assertKnownKeys(input, ['source', 'class', 'target', 'repeat']);
+    if (input.repeat !== undefined)
+        assertKnownKeys(input.repeat, ['min', 'max']);
+    const ref = options.resolveEdgeClass(input.class, `${options.pointer}/match/class`);
+    return edgePattern(input.source, ref, input.target, input.repeat);
+}
+/** The term of one role. An own key holding `undefined` passes through, as it always has. */
+function endTerm(ends, role, pointer, missing) {
+    if (!Object.hasOwn(ends, role))
+        fail('BUILDER_POLICY', `${pointer}/${escapeToken(role)}`, missing);
+    return ends[role];
+}
 /** One Edge pattern, whichever form named its ends. */
 function edgePattern(source, classRef, target, repeat) {
     return {
@@ -132,12 +103,50 @@ function edgePattern(source, classRef, target, repeat) {
         ...(repeat === undefined ? {} : { repeat: { ...repeat } }),
     };
 }
+function exists(options, nextVariable, build) {
+    const pointer = `${options.pointer}/match/exists/nodes`;
+    const nodes = [];
+    const bind = (selector) => {
+        const variable = Object.freeze({ kind: 'variable', id: nextVariable() });
+        nodes.push(nodeVariable(options, variable, selector, pointer));
+        return variable;
+    };
+    const where = build({ node: nodeBinder(bind, pointer) });
+    const [first, ...rest] = nodes;
+    if (first === undefined) {
+        fail('BUILDER_POLICY_EMPTY_EXISTS', pointer, 'exists(...) must declare at least one variable Node.');
+    }
+    return { exists: { nodes: [first, ...rest], where } };
+}
+function nodeVariable(options, variable, selector, pointer) {
+    if (selector.kind === 'any')
+        return { variable, selector: Object.freeze({ kind: 'any' }) };
+    const classRef = options.resolveNodeClass(selector.definition, pointer);
+    if (selector.kind === 'exact')
+        return { variable, class: classRef };
+    return { variable, selector: Object.freeze({ kind: 'satisfies', class: classRef }) };
+}
+function nodeBinder(bind, pointer) {
+    function node(...args) {
+        const definition = args[0];
+        if (args.length > 1 || (args.length === 1 && definition === undefined)) {
+            fail('BUILDER_POLICY', pointer, 'node(...) accepts either no arguments or one Node Class.');
+        }
+        return definition === undefined
+            ? bind({ kind: 'any' })
+            : bind({ kind: 'satisfies', definition });
+    }
+    function exact(definition) {
+        if (arguments.length !== 1 || definition === undefined) {
+            fail('BUILDER_POLICY', pointer, 'node.exact(...) requires exactly one Node Class.');
+        }
+        return bind({ kind: 'exact', definition });
+    }
+    return Object.freeze(Object.assign(node, { exact }));
+}
 function composition(operator, policies) {
     nonEmpty(policies, `/${operator}`);
-    const value = {
-        operator,
-        policies: [...policies],
-    };
+    const value = { operator, policies: [...policies] };
     compositions.add(value);
     return value;
 }

package/dist/v1/bundle/model.js

@@ -1,4 +1,4 @@
-import { deepFreeze } from '../schema/canonical/freeze.js';
+import { deepFreeze } from '../language/freeze.js';
 export const DOMAIN_BUNDLE_FORMAT = 'astrale.dsl.bundle';
 export const DOMAIN_BUNDLE_VERSION = 'v1';
 export function asDomainSchemaBundle(root, closure) {

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

@@ -1,4 +1,5 @@
 import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
+import { deepFreeze } from '../../language/freeze.js';
 import { limits } from '../../language/limits.js';
 import {} from '../model/schema.js';
 import { validateClosure } from './closure.js';
@@ -69,10 +70,3 @@ export function acceptCompiledSchema(input) {
     validateCompiledSemantics(candidate);
     return deepFreeze(candidate);
 }
-function deepFreeze(input) {
-    if (input === null || typeof input !== 'object' || Object.isFrozen(input))
-        return input;
-    for (const value of Object.values(input))
-        deepFreeze(value);
-    return Object.freeze(input);
-}

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

@@ -90,9 +90,8 @@ function programKey(entry, value) {
 /** Check automatic Properties, immutability and abstract Class obligations. */
 export function validateClassFacets(context) {
     for (const located of context.classes.values()) {
-        if (located.value.abstract &&
-            (located.value.policies.read !== undefined || located.value.policies.traverse !== undefined)) {
-            fail(`${located.pointer}/policies`, 'Abstract Classes cannot declare observation Policies.');
+        if (located.value.abstract && Object.keys(located.value.policies).length > 0) {
+            fail(`${located.pointer}/policies`, 'Abstract Classes cannot declare Class Policies.');
         }
         for (const [index, property] of located.value.properties.entries()) {
             const path = `${located.pointer}/properties/${index}`;