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

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}`;

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

@@ -1,13 +1,13 @@
-import {} from '../../../../addressing/index.js';
+import { Key } from '../../../../addressing/index.js';
 import { branchesOf, targetMode, isConnected, } from '../../../../language/policy/analysis/branches.js';
 import { exceededLimits, measureChecks, policyMeasurer, } from '../../../../language/policy/analysis/budgets.js';
 import { neverAdmittedClasses, } from '../../../../language/policy/analysis/checks.js';
 import {} from '../../../../language/policy/analysis/typing.js';
-import { checksNameTheCaller, isClassRuleChecks, } from '../../../../language/policy/model/policy.js';
+import { CLASS_OPERATIONS, checksNameTheCaller, isClassRuleChecks, } from '../../../../language/policy/model/policy.js';
 import { normalizePolicyExpression } from '../../../../language/policy/normalization/normalize.js';
 import {} from '../../../model/schema.js';
 import { fail } from '../../diagnostic.js';
-import { isCompiledEdge } from '../context.js';
+import { isCompiledEdge, } from '../context.js';
 import { callableObjectContracts } from './contracts.js';
 import { compiledPolicyTyping } from './typing.js';
 /** Check Policy typing and expansion budgets against the entry’s own closure. */
@@ -46,26 +46,25 @@ export function validatePolicyParity(context, entry, entryIndex, policies, origi
         }
     }
     for (const [classIndex, definition] of entry.definitions.classes.entries()) {
-        for (const operation of ['read', 'traverse']) {
+        const edge = isCompiledEdge(definition) ? definition : undefined;
+        for (const operation of CLASS_OPERATIONS) {
             const policy = definition.policies[operation];
             if (typeof policy !== 'object')
                 continue;
             const path = `/closure/${entryIndex}/definitions/classes/${classIndex}/policies/${operation}`;
             if (isClassRuleChecks(policy)) {
-                // The wire admits rules only on a Node Class and only over `self` and `ref` objects.
-                validatePolicyChecks(context, typing, entry, policy, -1, definition.ref, path, 'class');
+                // The wire admits rules only over `self` and `ref` objects, and `ref` alone to create a Node.
+                validatePolicyChecks(context, typing, entry, policy, -1, definition.ref, path, 'class', edge);
                 continue;
             }
-            const label = operation === 'read' ? 'Read' : 'Traverse';
+            const label = `${operation[0].toUpperCase()}${operation.slice(1)}`;
             if (definition.kind === 'node') {
                 if (!typing.policyAccepts(policy.name, { kind: 'exact', ref: definition.ref })) {
                     fail(path, `${label} Policy is incompatible with its protected Node Class.`);
                 }
             }
-            else if (isCompiledEdge(definition)) {
-                if (!typing.policyAcceptsEdgeClass(policy.name, definition)) {
-                    fail(path, `${label} Policy is incompatible with an accepted Edge endpoint pair.`);
-                }
+            else if (edge !== undefined && !typing.policyAcceptsEdgeClass(policy.name, edge)) {
+                fail(path, `${label} Policy is incompatible with an accepted Edge endpoint pair.`);
             }
         }
         if (definition.kind === 'node') {
@@ -90,7 +89,7 @@ const SITE = {
     callable: { checks: 'Callable Policy checks', objects: 'the callable object contract' },
     class: { checks: 'Class rule checks', objects: 'the Class rule object contract' },
 };
-function validatePolicyChecks(context, typing, entry, expression, input, receiver, path, site) {
+function validatePolicyChecks(context, typing, entry, expression, input, receiver, path, site, edge) {
     if (!checksNameTheCaller(expression)) {
         fail(path, `${SITE[site].checks} must check a Policy on every branch: sameNode alone names no caller.`);
     }
@@ -99,13 +98,26 @@ function validatePolicyChecks(context, typing, entry, expression, input, receive
     }
     const leaves = new Map();
     const visit = (value, pointer) => {
-        if ('sameNode' in value)
+        if ('sameNode' in value) {
+            // `self` is an Edge in an Edge Class rule, and sameNode compares Nodes.
+            if (edge !== undefined &&
+                (value.sameNode.left.kind === 'self' || value.sameNode.right.kind === 'self'))
+                fail(pointer, 'sameNode compares Nodes: self is an Edge here.');
             return;
+        }
         if (!('check' in value)) {
             const children = 'allOf' in value ? value.allOf : value.anyOf;
             children.forEach((child, index) => visit(child, `${pointer}/${index}`));
             return;
         }
+        if (edge !== undefined && value.object.kind === 'self') {
+            // An Edge is checked as an Edge Class Policy is: over every concrete endpoint pair.
+            if (!typing.policyAcceptsEdgeClass(value.check.name, edge))
+                fail(pointer, 'Named Policy is incompatible with an accepted Edge endpoint pair.');
+            const name = Key.of(edge.ref);
+            leaves.set(value, { accepted: [name], admitted: new Set([name]) });
+            return;
+        }
         const contracts = callableObjectContracts(context, entry, input, receiver, value.object);
         if (contracts === undefined)
             return;

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

@@ -2,7 +2,7 @@ import { Key } from '../../../../addressing/index.js';
 import { PolicyTyping } from '../../../../language/policy/analysis/typing.js';
 import {} from '../../../../language/policy/model/policy.js';
 import {} from '../../../model/schema.js';
-import { classSatisfiesAny, isCompiledEdge } from '../context.js';
+import { isCompiledEdge } from '../context.js';
 import { referenceContract } from './contracts.js';
 /** Types one entry's Policies against the Node Classes of its own closure, as source admission. */
 export function compiledPolicyTyping(context, entry, normalized, origins) {
@@ -14,7 +14,7 @@ export function compiledPolicyTyping(context, entry, normalized, origins) {
         allNodeClasses: nodeClasses.map((value) => value.ref),
         concreteNodeClasses: nodeClasses.filter((value) => !value.abstract).map((value) => value.ref),
         isLocalPolicy: (ref) => ref.origin === entry.origin && ref.kind === 'policy',
-        classExtends: (candidate, required) => classSatisfiesAny(context, candidate, [required]),
+        resolveClass: (ref) => context.classes.get(Key.of(ref))?.value,
         edgeDeclaration: (ref) => {
             const value = context.classes.get(Key.of(ref))?.value;
             return value !== undefined && isCompiledEdge(value) ? value : undefined;