@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

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

@@ -0,0 +1,159 @@
+import type { ClassRef } from '../../addressing/index.js';
+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, 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';
+import type { Class, EdgeClass, NodeClass } from './handle.js';
+import type { PropertyRecordInput } from './property.js';
+/** Reference to a Class: an authored handle, a ClassRef or a resolved Class, possibly lazy. */
+export type ClassReferenceInput = Lazy<Class | ClassRef | ResolvedClass<'node'> | ResolvedClass<'edge'>>;
+export type NodeClassReferenceInput = Lazy<NodeClass | ClassRef | ResolvedClass<'node'>>;
+export type EdgeClassReferenceInput = Lazy<EdgeClass | ClassRef | ResolvedClass<'edge'>>;
+/** Source side of a directed Edge Class. */
+export interface DirectedSourceInput {
+    readonly as: string;
+    readonly accepts: readonly NodeClassReferenceInput[];
+    readonly outgoing: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
+}
+/** Target side of a directed Edge Class. */
+export interface DirectedTargetInput {
+    readonly as: string;
+    readonly accepts: readonly NodeClassReferenceInput[];
+    readonly incoming: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
+}
+/** One endpoint of an undirected Edge Class. */
+export interface IncidentEndpointInput {
+    readonly as: string;
+    readonly accepts: readonly NodeClassReferenceInput[];
+    readonly incident: EdgeCount;
+    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
+    readonly onDelete?: EdgeLifetime;
+}
+/**
+ * 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;
+/**
+ * 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 slot: a local Policy, a constant value, or Policy checks. */
+export type NodeClassPolicyInput = ClassPolicyInput | ClassRuleBuilder;
+/**
+ * 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 {
+    readonly abstract?: boolean;
+    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
+    readonly inheritance?: Inheritance;
+    readonly description?: string;
+    readonly extends?: readonly NodeClassReferenceInput[];
+    readonly properties?: PropertyRecordInput;
+    readonly data?: MediaType;
+    readonly methods?: Readonly<Record<string, Method>>;
+    readonly icon?: string;
+    /** 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
+     * Property is present; omitted, none. A descendant is covered without declaring them again.
+     */
+    readonly unique?: readonly NodeUniqueTupleInput[];
+}
+/**
+ * The distinct Properties of one Node key, in any order, each a Property of the Class, own or
+ * inherited, by its name or, when names collide, by its full key.
+ */
+export type NodeUniqueTupleInput = readonly [string, ...string[]];
+/** Members every authored Edge Class shares. */
+export interface EdgeClassCommon {
+    readonly abstract?: boolean;
+    /** Which Classes may extend this one; omitted, those of its own Domain only (`'internal'`). */
+    readonly inheritance?: Inheritance;
+    readonly description?: string;
+    readonly extends?: readonly EdgeClassReferenceInput[];
+    readonly properties?: PropertyRecordInput;
+    /** Local Policies; inherited by no descendant and forbidden on abstract Classes. */
+    readonly policies?: EdgeClassPoliciesInput;
+    readonly constraints?: {
+        readonly noSelf?: true;
+        readonly acyclic?: true;
+    };
+}
+/**
+ * A key field as authored: an endpoint, the slug, or a Property of the Class, own or inherited, by
+ * its name or, when names collide, by its full key.
+ */
+export type EdgeUniqueFieldInput = 'source' | 'target' | 'slug' | {
+    readonly property: string;
+};
+/** The distinct fields of one key, in any order. */
+export type EdgeUniqueTupleInput = readonly [EdgeUniqueFieldInput, ...EdgeUniqueFieldInput[]];
+/** Authored directed Edge Class. */
+export interface DirectedEdgeInput extends EdgeClassCommon {
+    readonly orientation: 'directed';
+    readonly source: DirectedSourceInput;
+    readonly target: DirectedTargetInput;
+    /**
+     * The tuples no two Edges of this Class and of its active concrete descendants share while every
+     * field is present; omitted, none. A descendant is covered without declaring them again.
+     */
+    readonly unique?: readonly EdgeUniqueTupleInput[];
+}
+/** Authored undirected Edge Class. */
+export interface UndirectedEdgeInput extends Omit<EdgeClassCommon, 'constraints'> {
+    readonly orientation: 'undirected';
+    readonly endpoints: readonly [IncidentEndpointInput, IncidentEndpointInput];
+    readonly constraints?: {
+        readonly noSelf?: true;
+    };
+}
+export type EdgeClassInput = DirectedEdgeInput | UndirectedEdgeInput;

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

@@ -0,0 +1,129 @@
+import type { ResolvedMethod } from '../../language/callable/resolved.js';
+import type { ResolvedProperty } from '../../language/class/resolved.js';
+import type { StateTopology } from '../../language/state/topology.js';
+import type { Method } from '../callable/authoring.js';
+import type { DirectedEdgeClass, NodeClass, UndirectedEdgeClass } from './handle.js';
+/** Compact type of one authored Property: values, requiredness, name, owner and state. */
+export interface AuthoredPropertyProjection<out Input = unknown, out Output = unknown, out Required extends boolean = boolean, out Name extends string = string, out Owner = 'self', out State extends StateTopology | undefined = StateTopology | undefined> {
+    readonly input: Input;
+    readonly output: Output;
+    readonly required: Required;
+    readonly name: Name;
+    readonly owner: Owner;
+    readonly state?: State;
+}
+/** Compact type of one authored Method with its name and owner. */
+export interface AuthoredMethodProjection<out Value extends Method = Method, out Name extends string = string, out Owner = 'self'> {
+    readonly value: Value;
+    readonly name: Name;
+    readonly owner: Owner;
+}
+/** Give `Owner` to every Property projection still owned by `self`. */
+export type BindPropertyOwners<Entries, Owner> = Entries extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer Name, infer ExistingOwner, infer State> ? AuthoredPropertyProjection<Input, Output, Required, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner, State> : Entries;
+/** Give `Owner` to every Method projection still owned by `self`. */
+export type BindMethodOwners<Entries, Owner> = Entries extends AuthoredMethodProjection<infer Value, infer Name, infer ExistingOwner> ? AuthoredMethodProjection<Value, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner> : Entries;
+/** Kind and structural identity of an authored Class. */
+export interface ClassIdentityProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown> {
+    readonly kind: Kind;
+    readonly identity: Identity;
+}
+/** An authored Class as the owner its Properties and Methods name. */
+export interface ClassOwnerProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown, out Properties = unknown, out InstanceMethods = unknown, out StaticMethods = unknown> extends ClassIdentityProjection<Kind, Identity> {
+    readonly properties: Properties;
+    readonly instanceMethods: InstanceMethods;
+    readonly staticMethods: StaticMethods;
+}
+/** An authored Class as a reference, with its effective Properties and Methods. */
+export interface ClassReferenceProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown, out EffectiveProperties = AuthoredPropertyProjection, out EffectiveInstanceMethods = unknown, out EffectiveStaticMethods = unknown> extends ClassIdentityProjection<Kind, Identity> {
+    readonly effectiveProperties: EffectiveProperties;
+    readonly effectiveInstanceMethods: EffectiveInstanceMethods;
+    readonly effectiveStaticMethods: EffectiveStaticMethods;
+}
+type NodeClassIdentity<Config> = Config extends {
+    readonly abstract: infer Abstract;
+    readonly depth: infer Depth;
+    readonly properties: infer Properties;
+    readonly methods: infer Methods;
+} ? {
+    readonly abstract: Abstract;
+    readonly depth: Depth;
+    readonly properties: Properties;
+    readonly methods: Methods;
+} : never;
+type DirectedEdgeClassIdentity<Config> = Config extends {
+    readonly abstract: infer Abstract;
+    readonly depth: infer Depth;
+    readonly properties: infer Properties;
+    readonly source: infer Source;
+    readonly target: infer Target;
+    readonly constraints: infer Constraints;
+} ? {
+    readonly abstract: Abstract;
+    readonly depth: Depth;
+    readonly properties: Properties;
+    readonly source: Source;
+    readonly target: Target;
+    readonly constraints: Constraints;
+} : never;
+type UndirectedEdgeClassIdentity<Config> = Config extends {
+    readonly abstract: infer Abstract;
+    readonly depth: infer Depth;
+    readonly properties: infer Properties;
+    readonly endpoints: infer Endpoints;
+    readonly constraints: infer Constraints;
+} ? {
+    readonly abstract: Abstract;
+    readonly depth: Depth;
+    readonly properties: Properties;
+    readonly endpoints: Endpoints;
+    readonly constraints: Constraints;
+} : never;
+type OwnerErasedPropertyProjection<Entry> = Entry extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer Name, unknown, infer State> ? AuthoredPropertyProjection<Input, Output, Required, Name, unknown, State> : Entry extends ResolvedProperty<infer Value, infer Required, infer State, infer Input> & {
+    readonly name: infer Name;
+    readonly key: infer Key;
+} ? {
+    readonly value: Value;
+    readonly input: Input;
+    readonly required: Required;
+    readonly name: Name;
+    readonly key: Key;
+    readonly state?: State;
+} : never;
+type OwnerErasedMethodProjection<Entry> = Entry extends AuthoredMethodProjection<infer Value, infer Name, unknown> ? AuthoredMethodProjection<Value, Name, unknown> : Entry extends ResolvedMethod<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer _Policy, infer Key> & {
+    readonly name: infer Name;
+} ? {
+    readonly input: Input;
+    readonly output: Output;
+    readonly static: Static;
+    readonly abstract: Abstract;
+    readonly auth: Auth;
+    readonly name: Name;
+    readonly key: Key;
+} : never;
+/** Identity projection of a Class handle. */
+export type ClassIdentityProjectionOf<Value> = Value extends NodeClass<infer Config> ? ClassIdentityProjection<'node', NodeClassIdentity<Config>> : Value extends DirectedEdgeClass<infer Config> ? ClassIdentityProjection<'edge', DirectedEdgeClassIdentity<Config>> : Value extends UndirectedEdgeClass<infer Config> ? ClassIdentityProjection<'edge', UndirectedEdgeClassIdentity<Config>> : never;
+/** Owner projection of a Class handle. */
+export type ClassOwnerProjectionOf<Value> = Value extends NodeClass<infer Config> ? ClassOwnerProjection<'node', NodeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? OwnerErasedPropertyProjection<Properties> : never, Config extends {
+    readonly effectiveInstanceMethods: infer Methods;
+} ? OwnerErasedMethodProjection<Methods> : never, Config extends {
+    readonly effectiveStaticMethods: infer Methods;
+} ? OwnerErasedMethodProjection<Methods> : never> : Value extends DirectedEdgeClass<infer Config> ? ClassOwnerProjection<'edge', DirectedEdgeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? OwnerErasedPropertyProjection<Properties> : never, never, never> : Value extends UndirectedEdgeClass<infer Config> ? ClassOwnerProjection<'edge', UndirectedEdgeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? OwnerErasedPropertyProjection<Properties> : never, never, never> : never;
+/** Reference projection of a Class handle. */
+export type ClassReferenceProjectionOf<Value> = Value extends NodeClass<infer Config> ? ClassReferenceProjection<'node', NodeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<NodeClass<Config>>> : never, Config extends {
+    readonly effectiveInstanceMethods: infer Methods;
+} ? BindMethodOwners<Methods, ClassOwnerProjectionOf<NodeClass<Config>>> : never, Config extends {
+    readonly effectiveStaticMethods: infer Methods;
+} ? BindMethodOwners<Methods, ClassOwnerProjectionOf<NodeClass<Config>>> : never> : Value extends DirectedEdgeClass<infer Config> ? ClassReferenceProjection<'edge', DirectedEdgeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<DirectedEdgeClass<Config>>> : never, never, never> : Value extends UndirectedEdgeClass<infer Config> ? ClassReferenceProjection<'edge', UndirectedEdgeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<UndirectedEdgeClass<Config>>> : never, never, never> : never;
+export {};

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

@@ -0,0 +1 @@
+export {};

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

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

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

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

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

@@ -1,7 +1,7 @@
 import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
 import type { DomainEndpointRef } from '../../language/core/model/core.js';
 import type { PolicyObjectInput } from '../callable/authoring.js';
-import type { EdgeClass, NodeClass } from '../class/authoring.js';
+import type { EdgeClass, NodeClass } from '../class/handle.js';
 import type { AUTHORING } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
 import type { CoreNamedPropertyInput } from '../schema/projection.js';

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

@@ -14,10 +14,13 @@ export { BuilderError as Error } from './schema/diagnostic.js';
 export type { BuilderDiagnostic as Diagnostic, BuilderDiagnosticCode as DiagnosticCode, } from './schema/diagnostic.js';
 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 { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
+export type { Class, DirectedEdgeClass, EdgeClass, NodeClass, UndirectedEdgeClass, } from './class/handle.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';
-export type { MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeInput, PolicyExistsContext, PolicyInput, PolicyNodeBinder, PolicyPatternContext, } from './policy/authoring.js';
+export type { EdgeRolesOf, MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeClassInput, PolicyEdgeEnds, PolicyEdgeInput, PolicyEdgeOptions, PolicyEdgeRepeat, PolicyExistsContext, PolicyInput, PolicyNodeBinder, PolicyPatternContext, } from './policy/authoring.js';
 export type { AutoOptions, AutoProperty, Property, PropertyFieldInput as PropertyField, PropertyOptions, ValueSchemaInput, } from './class/property.js';
 export type { CorePropertyInput } from './schema/projection.js';
 export type { ClassProjection, FunctionProjection, MethodProjection, PropertyProjection, } from './schema/projection.js';

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

@@ -42,6 +42,7 @@ export class V1CallableCompiler {
             input,
             output,
             ...(config.execution === undefined ? {} : { execution: config.execution }),
+            ...(config.admission === undefined ? {} : { admission: config.admission }),
         };
         const contract = auth === 'authorized'
             ? { ...base, auth, ...(policy === undefined ? {} : { policy }) }

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

@@ -1,5 +1,5 @@
 import type { ClassDefinition } from '../../language/class/model/class.js';
-import type { Class } from '../class/authoring.js';
+import type { Class } from '../class/handle.js';
 import type { CallableCompiler } from './callable.js';
 import type { PolicyCompiler } from './policy.js';
 import type { BuilderContext } from './schema/context.js';
@@ -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';
@@ -31,6 +31,7 @@ export class V1DefinitionCompiler {
             ref: { origin: this.context.origin, kind: 'class', name },
             kind: 'node',
             abstract: input.abstract ?? false,
+            ...declaredInheritance(input.inheritance),
             ...(input.description === undefined ? {} : { description: input.description }),
             extends: this.parents(input.extends, 'node', `${pointer}/extends`),
             properties: facet,
@@ -38,10 +39,16 @@ export class V1DefinitionCompiler {
             ...(data === undefined ? {} : { data }),
             ...(input.icon === undefined ? {} : { icon: input.icon }),
             policies: this.classPolicies(input, 'node', `${pointer}/policies`),
+            // Property names stay as authored until `canonicalizeUniquePropertyKeys` qualifies them
+            // against the Class's effective Properties, once every Class is lowered.
+            ...(input.unique === undefined
+                ? {}
+                : { unique: input.unique }),
         };
     }
     edgeClass(value, name, pointer) {
         const input = classConfiguration(value);
+        // The authoring types give an Edge no State Property; the structure refuses an erased one.
         const facet = this.values.properties(input.properties, `${pointer}/properties`);
         const contract = (() => {
             if (value.orientation === 'directed') {
@@ -53,6 +60,13 @@ export class V1DefinitionCompiler {
                         target: this.directedTarget(directed.target, `${pointer}/endpoints/target`),
                     },
                     constraints: directedConstraints(directed),
+                    // Property names stay as authored until `canonicalizeUniquePropertyKeys` qualifies them
+                    // against the Class's effective Properties, once every Class is lowered.
+                    ...(directed.unique === undefined
+                        ? {}
+                        : {
+                            unique: directed.unique,
+                        }),
                 };
             }
             const undirected = classConfiguration(value);
@@ -69,47 +83,62 @@ export class V1DefinitionCompiler {
             ref: { origin: this.context.origin, kind: 'class', name },
             kind: 'edge',
             abstract: input.abstract ?? false,
+            ...declaredInheritance(input.inheritance),
             ...(input.description === undefined ? {} : { description: input.description }),
             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);
     }
@@ -120,12 +149,24 @@ 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,
+            // An empty list stays as authored: the structure refuses it when it judges the candidate.
             accepts: value.accepts
                 .map((entry, index) => this.context.resolveNodeClass(entry, `${pointer}/accepts/${index}`))
                 .sort(compareDefinitionRefs),
+            ...(value.onDelete === undefined ? {} : { onDelete: value.onDelete }),
         };
     }
     directedSource(value, pointer) {
@@ -139,7 +180,7 @@ export class V1DefinitionCompiler {
     }
     parents(values, kind, pointer) {
         return (values ?? [])
-            .map((entry, index) => this.context.resolveClass(entry, kind, `${pointer}/${index}`))
+            .map((entry, index) => this.context.resolveParent(entry, kind, `${pointer}/${index}`))
             .sort(compareDefinitionRefs);
     }
     methods(values, abstractOwner, pointer) {
@@ -158,6 +199,10 @@ export class V1DefinitionCompiler {
         }));
     }
 }
+/** The default `'internal'` is never declared, so a Class that keeps it keeps its revision. */
+function declaredInheritance(inheritance) {
+    return inheritance === undefined || inheritance === 'internal' ? {} : { inheritance };
+}
 function dataDeclaration(mediaType) {
     return mediaType === undefined ? undefined : { mediaType };
 }

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

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

package/dist/v1/builder/lowering/property-keys.d.ts

@@ -0,0 +1,27 @@
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { CoreContent } from '../../language/core/model/core.js';
+import type { DefinitionAnalysis } from '../../schema/analysis/class.js';
+import type { DomainSchemaLookup } from '../../schema/dependency/lookup.js';
+import type { DomainSchemaIR } from '../../schema/model/schema.js';
+import type { UnqualifiedCoreContent } from './core.js';
+type UnqualifiedDomainSchema = Omit<DomainSchemaIR, 'core'> & {
+    readonly core: UnqualifiedCoreContent;
+};
+/** The effective Properties of every Class `candidate` resolves, by `definitionRefIndex`. */
+export type PropertyOwners = ReadonlyMap<string, DefinitionAnalysis>;
+/**
+ * Analyze the already-canonical Definition surface of `candidate` once, so Property shorthand
+ * resolves against each Class's own and inherited Properties. Core values and key tuples take no
+ * part in Class composition, so they are left out of the analysis.
+ */
+export declare function analyzePropertyOwners(candidate: UnqualifiedDomainSchema, lookup: DomainSchemaLookup): PropertyOwners;
+/** Lower rich builder shorthand to the canonical full-key Core representation. */
+export declare function canonicalizeCorePropertyKeys(core: UnqualifiedCoreContent, owners: PropertyOwners): CoreContent;
+/**
+ * Lower each Property a key tuple names by its name to its full key among the Class's own and
+ * inherited Properties; a full key stays as authored. Ambiguity and absence are refused here, so a
+ * tuple never names a Property the author did not mean. A Node tuple names Properties only; an Edge
+ * tuple names them as `{ property }` beside its structural fields.
+ */
+export declare function canonicalizeUniquePropertyKeys(classes: Readonly<Record<string, ClassDefinition>>, origin: string, owners: PropertyOwners): Readonly<Record<string, ClassDefinition>>;
+export {};