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

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

@@ -2,6 +2,7 @@ import {} from '@astrale-os/kernel-dsl/value';
 import { Key } from '../../../addressing/index.js';
 import { MEDIA_TYPE_PATTERN } from '../../../language/class/model/data.js';
 import { compareEdgeUniqueTuples, compareNodeUniqueTuples, edgeUniqueTuple, nodeUniqueTuple, } from '../../../language/class/unique.js';
+import { CLASS_OPERATIONS, isClassObservation } from '../../../language/policy/model/policy.js';
 import {} from '../../model/schema.js';
 import { invalid } from '../diagnostic.js';
 import { compiledCallable } from './callable.js';
@@ -63,26 +64,30 @@ export function compiledClass(input, values, path) {
 }
 function classPolicies(input, kind, path) {
     const value = object(input, 'Class Policies', path);
-    exact(value, [], 'Class Policies', path, ['read', 'traverse']);
-    if (value.read !== undefined)
-        classPolicy(value.read, kind, 'Class read Policy', `${path}/read`);
-    if (value.traverse !== undefined)
-        classPolicy(value.traverse, kind, 'Class traverse Policy', `${path}/traverse`);
+    exact(value, [], 'Class Policies', path, CLASS_OPERATIONS);
+    for (const operation of CLASS_OPERATIONS) {
+        const policy = value[operation];
+        if (policy === undefined)
+            continue;
+        const label = `Class ${operation} Policy`;
+        const slot = `${path}/${operation}`;
+        if (isRuleChecks(policy)) {
+            classRuleChecks(policy, slot, kind === 'node' && operation === 'create' ? 'create' : 'class');
+            continue;
+        }
+        // Each slot spells one constant, and a Node create rule has no Node for a named Policy alone.
+        if (policy === !isClassObservation(operation))
+            continue;
+        if (kind === 'node' && operation === 'create')
+            invalid(label, undefined, slot);
+        definitionRef(policy, 'policy', label, slot);
+    }
 }
-/**
- * Check one observation slot: `false`, the rule no caller satisfies, a named Policy, or, on a Node
- * Class only, Policy checks over the observed Node.
- */
-function classPolicy(input, kind, label, path) {
-    if (kind === 'node' &&
-        input !== null &&
+/** Policy checks, as opposed to a constant or a named Policy. */
+function isRuleChecks(input) {
+    return (input !== null &&
         typeof input === 'object' &&
-        ['check', 'sameNode', 'allOf', 'anyOf'].some((key) => Object.hasOwn(input, key))) {
-        classRuleChecks(input, path);
-        return;
-    }
-    if (input !== false)
-        definitionRef(input, 'policy', label, path);
+        ['check', 'sameNode', 'allOf', 'anyOf'].some((key) => Object.hasOwn(input, key)));
 }
 function edgeContract(value, path) {
     const constraintsPath = `${path}/constraints`;

package/dist/v1/compiled/admission/wire/policy.d.ts

@@ -4,7 +4,8 @@ export declare function compiledPolicy(input: JsonValue, path: string): never;
 /** Check one callable's caller rule: `true`, the rule every caller satisfies, or Policy checks. */
 export declare function callablePolicy(input: JsonValue | undefined, path: string): void;
 /**
- * Check one Node Class rule: Policy checks over `self` and `ref` objects only, in their one
- * spelling. A lone check of `self` is spelled as the Policy reference itself.
+ * Check one Class rule: Policy checks over `self` and `ref` objects only, or, in a Node create
+ * rule, `ref` objects only, in their one spelling. A lone check of `self` is spelled as the Policy
+ * reference itself.
  */
-export declare function classRuleChecks(input: JsonValue, path: string): void;
+export declare function classRuleChecks(input: JsonValue, path: string, site: 'class' | 'create'): void;

package/dist/v1/compiled/admission/wire/policy.js

@@ -130,17 +130,18 @@ export function callablePolicy(input, path) {
         policyCheck(input, 0, path);
 }
 /**
- * Check one Node Class rule: Policy checks over `self` and `ref` objects only, in their one
- * spelling. A lone check of `self` is spelled as the Policy reference itself.
+ * Check one Class rule: Policy checks over `self` and `ref` objects only, or, in a Node create
+ * rule, `ref` objects only, in their one spelling. A lone check of `self` is spelled as the Policy
+ * reference itself.
  */
-export function classRuleChecks(input, path) {
-    policyCheck(input, 0, path, 'class');
+export function classRuleChecks(input, path, site) {
+    policyCheck(input, 0, path, site);
     const rule = input;
     if (json.serialize(normalizeClassRule(rule)) !== json.serialize(rule))
         invalid('Class rule spelling', undefined, path);
 }
 /** What a site calls its checks in a refusal. */
-const SITE = { callable: 'Callable Policy', class: 'Class rule' };
+const SITE = { callable: 'Callable Policy', class: 'Class rule', create: 'Create rule' };
 /** Check the recursive Policy check wire grammar of one use site. */
 function policyCheck(input, depth, path, site = 'callable') {
     const name = SITE[site];
@@ -148,7 +149,7 @@ function policyCheck(input, depth, path, site = 'callable') {
         invalid(`${name} depth`, undefined, path);
     const value = object(input, name, path);
     if (Object.hasOwn(value, 'sameNode')) {
-        const equality = site === 'class' ? 'Class rule equality' : 'Callable equality';
+        const equality = site === 'callable' ? 'Callable equality' : `${name} equality`;
         exact(value, ['sameNode'], equality, path);
         const pair = object(value.sameNode, equality, `${path}/sameNode`);
         exact(pair, ['left', 'right'], `${equality} operands`, `${path}/sameNode`);
@@ -174,7 +175,7 @@ function policyCheck(input, depth, path, site = 'callable') {
 function policyCheckObject(input, objectPath, site) {
     const name = SITE[site];
     const target = object(input, `${name} object`, objectPath);
-    if (target.kind === 'self')
+    if (target.kind === 'self' && site !== 'create')
         exact(target, ['kind'], `${name} self`, objectPath);
     else if (target.kind === 'input' && site === 'callable') {
         exact(target, ['kind', 'field'], `${name} input`, objectPath);

package/dist/v1/compiled/loader/load.js

@@ -107,7 +107,7 @@ function programValidation(programs, properties, propertyOrdering, callables) {
             ...(callable.fields === undefined
                 ? {}
                 : { fields: Object.freeze(Object.keys(callable.fields)) }),
-            validateInput: (value) => validateValueProgram(input, value),
+            validateInput: (value, options) => validateValueProgram(input, value, [input.root], options),
             validateInputField(field, value) {
                 const nodes = callable.fields?.[field];
                 return nodes === undefined

package/dist/v1/domain/create.js

@@ -136,7 +136,7 @@ function createDefinitions(declarations, classesByKey, input) {
                 policy: definition.policy,
                 ...(inputFields === undefined ? {} : { inputFields }),
                 definition,
-                validateInput: (value) => input.validation.callableInput(key, value),
+                validateInput: (value, options) => input.validation.callableInput(key, value, options),
                 validateInputField: (field, value) => input.validation.callableInputField(key, field, value),
                 validateOutput: (value) => input.validation.callableOutput(key, value),
             });

package/dist/v1/domain/model/input.d.ts

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { Key as AddressKey, PropertyKey, Revision } from '../../addressing/index.js';
 import type { DomainDependency, DomainDependencyMap } from '../../addressing/index.js';
 import type { CoreEdge } from '../../language/core/model/core.js';
@@ -27,7 +28,7 @@ export interface DomainValidation {
     propertyProgram(key: PropertyKey): ValueProgram;
     propertyOrdering(key: PropertyKey): OrderingKind | undefined;
     callableExists(key: AddressKey.Callable): boolean;
-    callableInput(key: AddressKey.Callable, input: unknown): readonly Diagnostic[];
+    callableInput(key: AddressKey.Callable, input: unknown, options?: Options): readonly Diagnostic[];
     callableFields(key: AddressKey.Callable): readonly string[] | undefined;
     callableInputField(key: AddressKey.Callable, field: string, input: unknown): readonly Diagnostic[];
     callableOutput(key: AddressKey.Callable, output: unknown): readonly Diagnostic[];

package/dist/v1/domain/projection/classes.js

@@ -80,7 +80,7 @@ export function createClasses(definitions, validation) {
                     executable: isMethodExecutable(definition, methodDefinition),
                     ...(inputFields === undefined ? {} : { inputFields }),
                     definition: methodDefinition,
-                    validateInput: (input) => validation.callableInput(methodKey, input),
+                    validateInput: (input, options) => validation.callableInput(methodKey, input, options),
                     validateInputField: (field, input) => validation.callableInputField(methodKey, field, input),
                     validateOutput: (output) => validation.callableOutput(methodKey, output),
                 });

package/dist/v1/domain/validation/create.d.ts

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { Key, PropertyKey } from '../../addressing/index.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
 import type { ValueProgram } from '../../language/value/compile/model.js';
@@ -10,7 +11,7 @@ export interface PropertyValidation {
 }
 export interface CallableValidation {
     readonly fields?: readonly string[];
-    validateInput(input: unknown): readonly Diagnostic[];
+    validateInput(input: unknown, options?: Options): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
 }

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

@@ -21,7 +21,7 @@ export function createDomainValidation(properties, callables) {
         propertyProgram: (key) => propertyOf(key).program(),
         propertyOrdering: (key) => properties.get(key)?.ordering,
         callableExists: (key) => callables.has(key),
-        callableInput: (key, input) => callableOf(key).validateInput(input),
+        callableInput: (key, input, options) => callableOf(key).validateInput(input, options),
         callableFields: (key) => callables.get(key)?.fields,
         callableInputField: (key, field, input) => callableOf(key).validateInputField(field, input),
         callableOutput: (key, output) => callableOf(key).validateOutput(output),

package/dist/v1/index.d.ts

@@ -5,7 +5,7 @@ export { isBinaryInput } from './language/callable/model/callable.js';
 export type { EventOf, StateMachine, StateOf } from './language/state/index.js';
 export { PropertyValues } from './language/index.js';
 export * as metadata from './language/definition/metadata.js';
-export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, Inheritance, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, CallablePolicy, ClassPolicy, ClassRuleChecks, ClassRuleObject, NodeClassPolicy, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
+export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableInputModeOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, Inheritance, BinaryInput, BinaryInputProjection, CallableInputContract, MethodDefinition, MethodOwnerKeyOf, CallablePolicy, ClassPolicy, ClassRuleChecks, ClassRuleObject, ClassWritePolicy, CreateRuleChecks, EdgeClassPolicy, EdgeClassWritePolicy, EdgeRuleChecks, NodeClassCreatePolicy, NodeClassPolicy, NodeClassWritePolicy, PolicyCheckExpression, PolicyDefinition, PropertyImmutability, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
 export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodAddress, PolicyRef, Revision, ViewRef, } from './addressing/index.js';
 export type { Definition } from './language/index.js';

package/dist/v1/language/callable/resolved.d.ts

@@ -1,3 +1,4 @@
+import type { Options } from '@astrale-os/kernel-dsl/value';
 import type { DefinitionKey, FunctionRef, Key, MethodKey } from '../../addressing/index.js';
 import type { ResolvedClass } from '../class/resolved.js';
 import type { CallablePolicy } from '../policy/model/policy.js';
@@ -36,7 +37,11 @@ export interface ResolvedMethod<out Input = unknown, out Output = unknown, out S
         readonly static: Static;
         readonly abstract: Abstract;
     };
-    validateInput(input: unknown): readonly Diagnostic[];
+    /**
+     * The issues of `input` against the callable's input schema, `options` overriding the portable
+     * limits it is admitted under: those it crossed the wire under, for a call's input.
+     */
+    validateInput(input: unknown, options?: Options): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
     readonly __input?: Input;
@@ -62,7 +67,11 @@ export interface ResolvedFunction<out Input = unknown, out Output = unknown, out
     /** Present only when the callable input is a safely enumerable closed object. */
     readonly inputFields?: readonly string[];
     readonly definition: CallableDefinitionOf<FunctionDefinition, Auth, Policy>;
-    validateInput(input: unknown): readonly Diagnostic[];
+    /**
+     * The issues of `input` against the callable's input schema, `options` overriding the portable
+     * limits it is admitted under: those it crossed the wire under, for a call's input.
+     */
+    validateInput(input: unknown, options?: Options): readonly Diagnostic[];
     validateInputField(field: string, input: unknown): readonly Diagnostic[];
     validateOutput(output: unknown): readonly Diagnostic[];
     readonly __input?: Input;

package/dist/v1/language/class/model/class.d.ts

@@ -1,6 +1,6 @@
 import type { ClassRef, DefinitionBase, PropertyKey } from '../../../addressing/index.js';
 import type { MethodRecord } from '../../callable/model/callable.js';
-import type { ClassPolicy, NodeClassPolicy } from '../../policy/model/policy.js';
+import type { EdgeClassPolicy, EdgeClassWritePolicy, NodeClassCreatePolicy, NodeClassPolicy, NodeClassWritePolicy } from '../../policy/model/policy.js';
 import type { DataFacet } from './data.js';
 import type { EdgeContract } from './edge.js';
 import type { EdgePropertyDefinition, NodePropertyDefinition, PropertyFacet } from './property.js';
@@ -10,15 +10,27 @@ export type ClassKind = 'node' | 'edge';
  * on that Domain; `'internal'`, those of its Domain only; `'final'`, none.
  */
 export type Inheritance = 'open' | 'internal' | 'final';
-/** An absent observation rule admits every caller; a delegation is still scoped by its ceiling. */
+/**
+ * An absent observation rule admits every caller; a delegation is still scoped by its ceiling. An
+ * absent write rule admits only the Domain that declares the Class.
+ */
 export interface NodeClassPolicies {
     readonly read?: NodeClassPolicy;
     readonly traverse?: NodeClassPolicy;
+    readonly create?: NodeClassCreatePolicy;
+    readonly update?: NodeClassWritePolicy;
+    readonly delete?: NodeClassWritePolicy;
 }
-/** An absent observation rule admits every caller; a delegation is still scoped by its ceiling. */
+/**
+ * An absent observation rule admits every caller; a delegation is still scoped by its ceiling. An
+ * absent write rule admits only the Domain that declares the Class.
+ */
 export interface EdgeClassPolicies {
-    readonly read?: ClassPolicy;
-    readonly traverse?: ClassPolicy;
+    readonly read?: EdgeClassPolicy;
+    readonly traverse?: EdgeClassPolicy;
+    readonly create?: EdgeClassWritePolicy;
+    readonly update?: EdgeClassWritePolicy;
+    readonly delete?: EdgeClassWritePolicy;
 }
 /**
  * The Properties one key of a Node Class names, own or inherited, which no two Nodes of the Classes

package/dist/v1/language/freeze.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Freeze `value` and every object it reaches, in place. An object already frozen is taken as frozen
+ * through, so a value built from frozen parts is frozen without walking them again.
+ */
+export declare function deepFreeze<T>(value: T): Readonly<T>;

package/dist/v1/{schema/canonical → language}/freeze.js

@@ -1,3 +1,7 @@
+/**
+ * Freeze `value` and every object it reaches, in place. An object already frozen is taken as frozen
+ * through, so a value built from frozen parts is frozen without walking them again.
+ */
 export function deepFreeze(value) {
     if (value === null || typeof value !== 'object' || Object.isFrozen(value)) {
         return value;

package/dist/v1/language/policy/analysis/typing.d.ts

@@ -21,6 +21,7 @@ export type PolicyUseContract = {
 /** What Policy typing reads of the closure it types against: source or compiled admission. */
 export interface PolicyTypingScope {
     readonly normalized: ReadonlyMap<string, PolicyExpression>;
+    /** Each resolves, through `resolveClass`, to a Node Class. */
     readonly allNodeClasses: readonly ClassRef[];
     /** The concrete Classes of `allNodeClasses`, in its order. */
     readonly concreteNodeClasses: readonly ClassRef[];

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

@@ -16,9 +16,7 @@ export class PolicyTyping {
     // paths; for that to merge distinct variables, the Policy expands deeper than
     // `limits.policy.patternDepth`.
     #expansions = new Map();
-    #nodeClasses;
-    #concreteClasses;
-    #satisfaction;
+    #index;
     constructor(scope) {
         this.scope = scope;
     }
@@ -31,9 +29,7 @@ export class PolicyTyping {
     }
     /** Whether the Policy accepts every concrete source and target pair the Edge Class accepts. */
     policyAcceptsEdgeClass(name, declaration) {
-        const endpoints = declaration.orientation === 'directed'
-            ? [declaration.endpoints.source, declaration.endpoints.target]
-            : declaration.endpoints;
+        const endpoints = endpointPair(declaration);
         const sources = this.#concreteEndpointClasses(endpoints[0].accepts);
         const targets = this.#concreteEndpointClasses(endpoints[1].accepts);
         return sources.every((source) => targets.every((target) => this.#policyAcceptsEdge(name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })));
@@ -73,10 +69,13 @@ export class PolicyTyping {
         return branches !== undefined && branches.every((branch) => this.branchIsTyped(branch, use));
     }
     #concreteEndpointClasses(accepts) {
-        this.#concreteClasses ??= new Set(this.scope.concreteNodeClasses.map(definitionRefIndex));
-        const concrete = this.#concreteClasses;
+        const { concrete } = this.#nodeClassIndex();
         return this.#satisfyingOneOf(accepts).filter((ref) => concrete.has(definitionRefIndex(ref)));
     }
+    #nodeClassIndex() {
+        this.#index ??= nodeClassIndex(this.scope);
+        return this.#index;
+    }
     #expandedBranches(name, visiting, namespace) {
         if (visiting.has(name))
             return undefined;
@@ -164,11 +163,7 @@ export class PolicyTyping {
             if (contract.kind === 'exact')
                 return this.#applyExact(candidates, contract.ref);
             if (contract.kind === 'default') {
-                return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
-                    ? this.#isNodeClass(candidate.ref)
-                        ? [candidate]
-                        : []
-                    : this.#nodeCandidates(candidate)));
+                return this.#applyAnyNodeClass(candidates).filter((candidate) => candidate.kind !== 'exact' || this.#isNodeClass(candidate.ref));
             }
             return candidates;
         }
@@ -202,10 +197,10 @@ export class PolicyTyping {
                 result.push({ kind: 'exact', ref: exact });
             }
         }
-        return uniqueCandidates(result);
+        return uniqueBy(result, candidateKey);
     }
     #applyAnyNodeClass(candidates) {
-        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact' ? [candidate] : this.#nodeCandidates(candidate)));
+        return uniqueBy(candidates.flatMap((candidate) => candidate.kind === 'exact' ? [candidate] : this.#nodeCandidates(candidate)), candidateKey);
     }
     #applyRequirement(candidates, required) {
         const result = [];
@@ -220,11 +215,11 @@ export class PolicyTyping {
             else {
                 result.push({
                     kind: 'open',
-                    requirements: uniqueClasses([...candidate.requirements, required]),
+                    requirements: uniqueBy([...candidate.requirements, required], definitionRefIndex),
                 });
             }
         }
-        return uniqueCandidates(result);
+        return uniqueBy(result, candidateKey);
     }
     #applyEndpoint(candidates, accepts) {
         const result = [];
@@ -242,11 +237,11 @@ export class PolicyTyping {
             for (const accept of accepts) {
                 result.push({
                     kind: 'open',
-                    requirements: uniqueClasses([...candidate.requirements, accept]),
+                    requirements: uniqueBy([...candidate.requirements, accept], definitionRefIndex),
                 });
             }
         }
-        return uniqueCandidates(result);
+        return uniqueBy(result, candidateKey);
     }
     #classSatisfiesEndpoint(candidate, accepts) {
         return accepts.some((accept) => this.#classExtends(candidate, accept));
@@ -263,7 +258,7 @@ export class PolicyTyping {
      * `#classSatisfiesEndpoint` accepts, read from the index rather than tested one by one.
      */
     #satisfyingOneOf(accepts) {
-        const index = (this.#satisfaction ??= satisfactionIndex(this.scope));
+        const index = this.#nodeClassIndex();
         const positions = new Set();
         for (const accept of accepts) {
             const required = this.scope.resolveClass(accept);
@@ -271,7 +266,7 @@ export class PolicyTyping {
                 continue;
             if (isGraphRoot(required))
                 return index.nodeClasses;
-            for (const position of index.satisfying.get(ancestryKey(required.ref)) ?? []) {
+            for (const position of index.satisfying.get(definitionRefIndex(required.ref)) ?? []) {
                 positions.add(position);
             }
         }
@@ -281,8 +276,7 @@ export class PolicyTyping {
         return lists.every((accepts) => this.#classSatisfiesEndpoint(ref, accepts));
     }
     #isNodeClass(ref) {
-        this.#nodeClasses ??= new Set(this.scope.allNodeClasses.map(definitionRefIndex));
-        return this.#nodeClasses.has(definitionRefIndex(ref));
+        return this.#nodeClassIndex().nodes.has(definitionRefIndex(ref));
     }
     /** The Node Classes an open or `node` candidate can be. */
     #nodeCandidates(candidate) {
@@ -307,16 +301,14 @@ export class PolicyTyping {
         return inhabited ? [{ kind: 'node', lists }] : [];
     }
 }
-/** Classes are satisfied by origin and name, as `classSatisfies` compares them. */
-function ancestryKey(ref) {
-    return `${ref.origin}\u0000${ref.name}`;
-}
 /**
  * Index each Node Class of the closure under every Class its ancestry reaches, walked as
  * `classSatisfies` walks it: the Class itself, then each declared parent that resolves to a Node
  * Class. A Class then satisfies a non-root Node Class exactly when it is indexed under it.
+ * `classSatisfies` compares origin and name; every ClassRef has kind `class`, so the definition
+ * index of a ref keys it as that comparison does.
  */
-function satisfactionIndex(scope) {
+function nodeClassIndex(scope) {
     const nodeClasses = [];
     const satisfying = new Map();
     for (const ref of scope.allNodeClasses) {
@@ -324,30 +316,38 @@ function satisfactionIndex(scope) {
         if (actual?.kind !== 'node')
             continue;
         const position = nodeClasses.push(ref) - 1;
-        const seen = new Set();
-        const keys = new Set();
-        const pending = [actual];
-        for (let value = pending.pop(); value !== undefined; value = pending.pop()) {
-            if (seen.has(value))
-                continue;
-            seen.add(value);
-            const key = ancestryKey(value.ref);
-            if (!keys.has(key)) {
-                keys.add(key);
-                const positions = satisfying.get(key);
-                if (positions === undefined)
-                    satisfying.set(key, [position]);
-                else
-                    positions.push(position);
-            }
-            for (const parent of value.extends) {
-                const resolved = scope.resolveClass(parent);
-                if (resolved?.kind === 'node')
-                    pending.push(resolved);
-            }
+        for (const key of ancestryKeys(actual, scope)) {
+            const positions = satisfying.get(key);
+            if (positions === undefined)
+                satisfying.set(key, [position]);
+            else
+                positions.push(position);
+        }
+    }
+    return {
+        nodeClasses,
+        nodes: new Set(nodeClasses.map(definitionRefIndex)),
+        concrete: new Set(scope.concreteNodeClasses.map(definitionRefIndex)),
+        satisfying,
+    };
+}
+/** The keys of the Node Classes a Node Class's ancestry reaches, itself included. */
+function ancestryKeys(actual, scope) {
+    const seen = new Set();
+    const keys = new Set();
+    const pending = [actual];
+    for (let value = pending.pop(); value !== undefined; value = pending.pop()) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        keys.add(definitionRefIndex(value.ref));
+        for (const parent of value.extends) {
+            const resolved = scope.resolveClass(parent);
+            if (resolved?.kind === 'node')
+                pending.push(resolved);
         }
     }
-    return { nodeClasses, satisfying };
+    return keys;
 }
 function targetContract(term, use) {
     if (use.kind === 'object')
@@ -378,9 +378,7 @@ function variantsForEdge(use, typing) {
     const declaration = typing.scope.edgeDeclaration(edge.class);
     if (declaration === undefined)
         return [];
-    const endpoints = declaration.orientation === 'directed'
-        ? [declaration.endpoints.source, declaration.endpoints.target]
-        : declaration.endpoints;
+    const endpoints = endpointPair(declaration);
     const bounds = edge.repeat ?? { min: 1, max: 1 };
     if (!Number.isInteger(bounds.min) ||
         !Number.isInteger(bounds.max) ||
@@ -422,7 +420,13 @@ function variantsForEdge(use, typing) {
             });
         }
     }
-    return uniqueEdgeVariants(variants);
+    return uniqueBy(variants, edgeVariantKey);
+}
+/** The two endpoints of an Edge Class, a directed one's as source then target. */
+function endpointPair(declaration) {
+    return declaration.orientation === 'directed'
+        ? [declaration.endpoints.source, declaration.endpoints.target]
+        : declaration.endpoints;
 }
 function startEndpoint(endpoints, reversed) {
     return reversed ? endpoints[1] : endpoints[0];
@@ -430,31 +434,22 @@ function startEndpoint(endpoints, reversed) {
 function endEndpoint(endpoints, reversed) {
     return reversed ? endpoints[0] : endpoints[1];
 }
-function uniqueEdgeVariants(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = `${value.constraints
-            .map(([term, accepts]) => `${term}:${accepts.map(definitionRefIndex).sort().join(',')}`)
-            .join('|')}=${value.equalities.map(([left, right]) => `${left}:${right}`).join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
+/** The values with distinct keys, each at its key's first position and holding its last value. */
+function uniqueBy(values, key) {
+    return [...new Map(values.map((value) => [key(value), value])).values()];
 }
-function uniqueCandidates(values) {
-    const result = new Map();
-    for (const value of values) {
-        const key = value.kind === 'exact'
-            ? `exact:${definitionRefIndex(value.ref)}`
-            : value.kind === 'open'
-                ? `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`
-                : `node:${value.lists
-                    .map((accepts) => accepts.map(definitionRefIndex).sort().join(','))
-                    .sort()
-                    .join('|')}`;
-        result.set(key, value);
-    }
-    return [...result.values()];
+function edgeVariantKey(variant) {
+    const constraints = variant.constraints.map(([term, accepts]) => `${term}:${classSetKey(accepts)}`);
+    const equalities = variant.equalities.map(([left, right]) => `${left}:${right}`);
+    return `${constraints.join('|')}=${equalities.join('|')}`;
+}
+function candidateKey(candidate) {
+    if (candidate.kind === 'exact')
+        return `exact:${definitionRefIndex(candidate.ref)}`;
+    if (candidate.kind === 'open')
+        return `open:${classSetKey(candidate.requirements)}`;
+    return `node:${candidate.lists.map(classSetKey).sort().join('|')}`;
 }
-function uniqueClasses(values) {
-    return [...new Map(values.map((value) => [definitionRefIndex(value), value])).values()];
+function classSetKey(refs) {
+    return refs.map(definitionRefIndex).sort().join(',');
 }

package/dist/v1/language/policy/model/policy.d.ts

@@ -90,23 +90,63 @@ export type PolicyObjectRef = ClassRef | FunctionRef | PolicyRef | ViewRef | Cor
 export declare function policyObjectKey(ref: PolicyObjectRef): string;
 export declare function policyObjectOrigin(ref: PolicyObjectRef): string;
 export declare function projectedMemberClass(ref: Exclude<PolicyObjectRef, CoreRef>): ClassRef;
+export type ClassObservation = 'read' | 'traverse';
+export type ClassWrite = 'create' | 'update' | 'delete';
+export type ClassOperation = ClassObservation | ClassWrite;
+/**
+ * Every Class slot: the observations, which admit every caller when absent, then the writes, which
+ * admit only the Domain that declares the Class when absent.
+ */
+export declare const CLASS_OPERATIONS: readonly ClassOperation[];
+export declare function isClassObservation(operation: ClassOperation): operation is ClassObservation;
 /**
  * One Class observation slot: a named Policy, or `false`, the rule no caller satisfies. Its other
  * value has no spelling there: an absent observation Policy already means `true`.
  */
 export type ClassPolicy = PolicyRef | false;
-/** What a Node Class rule may check: the observed Node, or one exact projected member. */
+/**
+ * One Class write slot: a named Policy, or `true`, the rule every Identity satisfies. Its other
+ * value has no spelling there: an absent write Policy already means the owning Domain only.
+ */
+export type ClassWritePolicy = PolicyRef | true;
+/** What a Class rule may check: the observed or written instance, or one exact projected member. */
 export type ClassRuleObject = Extract<PolicyCheckObject, {
     readonly kind: 'self' | 'ref';
 }>;
 /**
- * Policy checks deciding one Node Class observation. `self` is the observed Node; a `ref` object
- * is the same Node for every candidate. A lone check of `self` is spelled as its Policy reference.
+ * Policy checks deciding one Node Class slot. `self` is the observed or written Node; a `ref`
+ * object is the same Node for every candidate. A lone check of `self` is spelled as its Policy
+ * reference.
  */
 export type ClassRuleChecks = PolicyCheckExpression<PolicyRef, ClassRuleObject>;
+/**
+ * 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; a `ref` object is one exact member, the same
+ * Node for every candidate. A lone check of `self` is spelled as its Policy reference.
+ */
+export type EdgeRuleChecks = ClassRuleChecks;
+/** What a Node create rule may check: one exact projected member, since the Node is not yet. */
+export type CreateRuleObject = Extract<PolicyCheckObject, {
+    readonly kind: 'ref';
+}>;
+/** Policy checks deciding the creation of a Node: every object is a `ref` member. */
+export type CreateRuleChecks = PolicyCheckExpression<PolicyRef, CreateRuleObject>;
 /** One Node Class observation slot: a Class Policy, or Policy checks over the observed Node. */
 export type NodeClassPolicy = ClassPolicy | ClassRuleChecks;
-export declare function isClassRuleChecks(value: ClassPolicy | ClassRuleChecks | undefined): value is ClassRuleChecks;
+/** One Node Class update or delete slot: a write Policy, or Policy checks over the written Node. */
+export type NodeClassWritePolicy = ClassWritePolicy | ClassRuleChecks;
+/**
+ * The Node Class create slot: `true`, or Policy checks over members. A named Policy alone has no
+ * object there, so it has no spelling.
+ */
+export type NodeClassCreatePolicy = true | CreateRuleChecks;
+/** One Edge Class observation slot: a Class Policy, or Policy checks over the observed Edge. */
+export type EdgeClassPolicy = ClassPolicy | EdgeRuleChecks;
+/** One Edge Class write slot: a write Policy, or Policy checks over the written Edge. */
+export type EdgeClassWritePolicy = ClassWritePolicy | EdgeRuleChecks;
+/** The value of any Class slot. */
+export type ClassSlotPolicy = PolicyRef | boolean | ClassRuleChecks;
+export declare function isClassRuleChecks(value: ClassSlotPolicy | undefined): value is ClassRuleChecks;
 /**
  * Whether every way Policy checks can hold passes through a check, so that the caller decides each
  * admission. `sameNode` compares two objects and names no caller.