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

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

@@ -1,116 +1,63 @@
-import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { Array as PortableArray, Object as PortableObject, Value as PortableValue } from '@astrale-os/kernel-dsl/value';
 import type { z } from 'zod';
 import type { ClassRef } from '../../addressing/index.js';
-import type { MethodRecord } from '../../language/callable/model/callable.js';
-import type { ResolvedMethod } from '../../language/callable/resolved.js';
-import type { MediaType } from '../../language/class/model/data.js';
-import type { EdgeCount } from '../../language/class/model/edge.js';
 import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
-import type { ClassRuleChecks, ClassRuleObject } from '../../language/policy/model/policy.js';
-import type { StateTopology, StateTopologyOf } from '../../language/state/topology.js';
-import type { BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
-import type { Method, PolicyCheckContext, ProjectionOfCallable } from '../callable/authoring.js';
-import type { Policy } from '../policy/authoring.js';
-import type { Lazy } from '../schema/lazy.js';
+import type { StateTopologyOf } from '../../language/state/topology.js';
+import type { BLOB_VALUE_KIND, BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
+import type { Method, ProjectionOfCallable } from '../callable/authoring.js';
 import type { ClassProjectionOfResolved } from '../schema/projection.js';
 import type { TypedValueSchema } from '../value/schema.js';
+import type { Class, DirectedEdgeClass, EdgeClass, NodeClass, UndirectedEdgeClass } from './handle.js';
+import type { DirectedEdgeInput, DirectedSourceInput, DirectedTargetInput, IncidentEndpointInput, NodeClassInput, UndirectedEdgeInput } from './input.js';
+import type { AuthoredMethodProjection, AuthoredPropertyProjection, BindMethodOwners, BindPropertyOwners, ClassOwnerProjectionOf, ClassReferenceProjectionOf } from './projection.js';
 import type { AutoProperty, Property, PropertyOptions, PropertyStateMachineOf, ValueSchemaInput } from './property.js';
-import type { PropertyRecordInput } from './property.js';
-import { type AUTHORING } from '../schema/handle.js';
-declare const CLASS_TYPE: unique symbol;
-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'>>;
-export interface DirectedSourceInput {
-    readonly as: string;
-    readonly accepts: readonly NodeClassReferenceInput[];
-    readonly outgoing: EdgeCount;
-}
-export interface DirectedTargetInput {
-    readonly as: string;
-    readonly accepts: readonly NodeClassReferenceInput[];
-    readonly incoming: EdgeCount;
-}
-export interface IncidentEndpointInput {
-    readonly as: string;
-    readonly accepts: readonly NodeClassReferenceInput[];
-    readonly incident: EdgeCount;
-}
 type ExactEndpointInput<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
-/** One observation slot: a local Policy, or its constant value. Absent means `true`. */
-export type ClassPolicyInput = Lazy<Policy> | boolean;
-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.
- */
-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. */
-export type NodeClassPolicyInput = ClassPolicyInput | ClassRuleBuilder;
-export interface NodeClassPoliciesInput {
-    readonly read?: NodeClassPolicyInput;
-    readonly traverse?: NodeClassPolicyInput;
-}
-export interface NodeClassInput {
-    readonly abstract?: boolean;
-    readonly description?: string;
-    readonly extends?: readonly NodeClassReferenceInput[];
-    readonly properties?: PropertyRecordInput;
-    readonly data?: MediaType;
-    readonly methods?: Readonly<Record<string, Method>>;
-    readonly icon?: string;
-    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
-    readonly policies?: NodeClassPoliciesInput;
-}
-export interface EdgeClassOptions {
-    readonly abstract?: boolean;
-    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;
-    readonly constraints?: {
-        readonly noSelf?: true;
-        readonly acyclic?: true;
-    };
-}
-export interface DirectedEdgeInput extends EdgeClassOptions {
-    readonly orientation: 'directed';
-    readonly source: DirectedSourceInput;
-    readonly target: DirectedTargetInput;
-}
-export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints'> {
-    readonly orientation: 'undirected';
-    readonly endpoints: readonly [IncidentEndpointInput, IncidentEndpointInput];
-    readonly constraints?: {
-        readonly noSelf?: true;
-    };
-}
-export type EdgeClassCommon = EdgeClassOptions;
-export type EdgeClassInput = DirectedEdgeInput | UndirectedEdgeInput;
-export type Class = NodeClass | EdgeClass;
-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;
-}
-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;
-}
 type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions, unknown> ? Schema : Field;
 type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options, unknown> ? Options : Record<never, never>;
-type ValueInputOf<Schema> = Schema extends BlobSchema ? BlobReceipt : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
-type ValueOutputOf<Schema> = Schema extends BlobSchema ? BlobRef : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type JsonSchemaValueOf<Schema> = 0 extends 1 & Schema ? PortableValue : Schema extends {
+    readonly const: infer Value;
+} ? JsonKnownOf<Value> : Schema extends {
+    readonly enum: readonly (infer Value)[];
+} ? JsonKnownOf<Value> : Schema extends {
+    readonly anyOf: readonly (infer Branch)[];
+} ? JsonSchemaValueOf<Branch> : Schema extends {
+    readonly oneOf: readonly (infer Branch)[];
+} ? JsonSchemaValueOf<Branch> : Schema extends {
+    readonly type: infer Type;
+} ? JsonTypeValueOf<Type, Schema> : PortableValue;
+type JsonKnownOf<Value> = 0 extends 1 & Value ? PortableValue : Value;
+type JsonTypeValueOf<Type, Schema> = Type extends readonly (infer Each)[] ? JsonTypeValueOf<Each, Schema> : Type extends 'string' ? string : Type extends 'number' | 'integer' ? number : Type extends 'boolean' ? boolean : Type extends 'null' ? null : Type extends 'array' ? JsonArrayValueOf<Schema> : Type extends 'object' ? JsonObjectValueOf<Schema> : PortableValue;
+type JsonArrayValueOf<Schema> = 'prefixItems' extends keyof Schema ? PortableArray : Schema extends {
+    readonly items: infer Items;
+} ? readonly JsonSchemaValueOf<Items>[] : PortableArray;
+type JsonObjectValueOf<Schema> = 'patternProperties' extends keyof Schema ? PortableObject : Schema extends {
+    readonly properties: infer Properties extends Readonly<Record<string, unknown>>;
+    readonly additionalProperties: false;
+} ? JsonClosedObjectOf<Properties, Schema extends {
+    readonly required: infer Names;
+} ? Names : readonly []> : Schema extends {
+    readonly additionalProperties: infer Additional extends object;
+} ? JsonListsNoName<Schema> extends true ? Readonly<Record<string, JsonSchemaValueOf<Additional>>> : PortableObject : PortableObject;
+type JsonListsNoName<Schema> = 'properties' extends keyof Schema ? Schema extends {
+    readonly properties: infer Properties;
+} ? [Properties] extends [never] ? false : JsonNoAlternativeNames<Properties> : false : true;
+type JsonNoAlternativeNames<Properties> = Properties extends unknown ? [keyof Properties] extends [never] ? true : false : never;
+type JsonListsName<Names, Name> = [Names] extends [never] ? false : Names extends readonly unknown[] ? number extends Names['length'] ? false : true extends {
+    [At in keyof Names]: JsonNamesExactly<Names[At], Name>;
+}[number] ? true : false : false;
+type JsonNamesExactly<Element, Name> = [Element] extends [never] ? false : 0 extends 1 & Element ? false : [Element] extends [Name] ? true : false;
+type JsonClosedObjectOf<Properties, Names> = [keyof Properties] extends [never] ? Readonly<Record<string, never>> : {
+    readonly [Name in keyof Properties as JsonListsName<Names, Name> extends true ? Name : never]: JsonSchemaValueOf<Properties[Name]>;
+} & {
+    readonly [Name in keyof Properties as JsonListsName<Names, Name> extends true ? never : Name]?: JsonSchemaValueOf<Properties[Name]>;
+} extends infer Value ? {
+    [Name in keyof Value]: Value[Name];
+} : never;
+type BlobMarkedSchema = BlobSchema | {
+    readonly 'x-astrale-value-kind': typeof BLOB_VALUE_KIND;
+};
+type ValueInputOf<Schema> = Schema extends BlobMarkedSchema ? BlobReceipt : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : JsonSchemaValueOf<Schema>;
+type ValueOutputOf<Schema> = Schema extends BlobMarkedSchema ? BlobRef : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : JsonSchemaValueOf<Schema>;
 type PropertyRequiredOf<Field> = PropertyOptionsOf<Field> extends {
     readonly required: infer Required extends boolean;
 } ? Required : undefined extends ValueInputOf<PropertySchemaOf<Field>> ? false : true;
@@ -131,7 +78,6 @@ type ParentPropertyProjectionsOf<Input> = Input extends {
 type EffectivePropertyProjectionsOf<Input> = PropertyProjectionEntriesOf<'properties' extends keyof Input ? Input extends {
     readonly properties?: infer Value;
 } ? NonNullable<Value> : never : never> | ParentPropertyProjectionsOf<Input>;
-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;
 type MethodFieldsOf<Input> = 'methods' extends keyof Input ? Input extends {
     readonly methods?: infer Methods extends Readonly<Record<string, Method>>;
 } ? NonNullable<Methods> : Readonly<Record<never, never>> : Readonly<Record<never, never>>;
@@ -141,7 +87,6 @@ type MethodIsStatic<Value extends Method> = ProjectionOfCallable<Value> extends
 type OwnMethodProjectionsOf<Input, Static extends boolean> = {
     [Name in keyof MethodFieldsOf<Input>]: MethodFieldsOf<Input>[Name] extends infer Value extends Method ? MethodIsStatic<Value> extends Static ? AuthoredMethodProjection<Value, Extract<Name, string>> : never : never;
 }[keyof MethodFieldsOf<Input>];
-type BindMethodOwners<Entries, Owner> = Entries extends AuthoredMethodProjection<infer Value, infer Name, infer ExistingOwner> ? AuthoredMethodProjection<Value, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner> : Entries;
 type AbstractMethodEntries<Entry> = Entry extends AuthoredMethodProjection<infer Value> ? ProjectionOfCallable<Value> extends {
     readonly abstract: true;
 } ? Entry : never : Entry extends {
@@ -178,106 +123,46 @@ type Increment<Depth extends number> = number extends Depth ? number : [...Tuple
 type ClassDepthOfInput<Input> = Input extends {
     readonly extends?: infer Parents extends readonly unknown[];
 } ? Parents extends readonly [] ? 0 : Increment<ClassDepthOf<Parents[number]>> : 0;
-export interface ClassIdentityProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown> {
-    readonly kind: Kind;
-    readonly identity: Identity;
-}
-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;
-}
-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;
-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;
-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;
-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;
 type CompactReference<Value> = Value extends () => infer Resolved ? () => CompactReference<Resolved> : Value extends ResolvedClass ? ClassProjectionOfResolved<Value> : Value extends Class ? ClassReferenceProjectionOf<Value> : Value;
 type CompactReferences<Values extends readonly unknown[]> = Values extends readonly [] ? readonly [] : Values extends readonly [infer Value, ...infer Rest] ? readonly [CompactReference<Value>, ...CompactReferences<Rest>] : readonly CompactReference<Values[number]>[];
+/**
+ * A Class an endpoint accepts, as its projection keeps it: the exact ref of a resolved Class, the
+ * mark of an authored one, which the Schema names, or the ref as given. A lazy reference stays lazy.
+ */
+type CompactAccepted<Value> = Value extends () => infer Resolved ? () => CompactAccepted<Resolved> : Value extends ResolvedClass ? ExactClassRefOf<Value> : Value extends NodeClass<infer Config> ? AcceptedClassMark<Config> : Value;
+/**
+ * What tells an authored Node Class from the other Classes of its Schema in an endpoint's type:
+ * its abstractness, its depth and the names of its effective members. Names alone keep the Edge
+ * handle small enough to print in a declaration file; Classes alike in all of these are the same
+ * accepted Class to the types, never to the Schema. `schema/projection/class.ts` names the Classes
+ * of a Schema and of its direct dependencies that bear the mark, since either may own the handle.
+ */
+type AcceptedClassMark<Config> = {
+    readonly kind: 'node';
+    readonly abstract: Config extends {
+        readonly abstract: infer Abstract;
+    } ? Abstract : never;
+    readonly depth: Config extends {
+        readonly depth: infer Depth;
+    } ? Depth : never;
+    readonly properties: Config extends {
+        readonly effectiveProperties: infer Properties;
+    } ? Properties extends {
+        readonly name: infer Name;
+    } ? Name : never : never;
+    readonly methods: Config extends {
+        readonly effectiveInstanceMethods: infer Instance;
+        readonly effectiveStaticMethods: infer Static;
+    } ? Instance | Static extends infer Method ? Method extends {
+        readonly name: infer Name;
+    } ? Name : never : never : never;
+};
+/** The ref of a resolved Class, exact while its key is. */
+type ExactClassRefOf<Value extends ResolvedClass> = Value['key'] extends `${infer Origin}:class.${infer Name}` ? string extends Origin ? ClassRef : string extends Name ? ClassRef : ClassRef<Name> & {
+    readonly origin: Origin;
+} : ClassRef;
+/** The Classes one endpoint accepts, in any order: the runtime list is canonically sorted. */
+type CompactAccepts<Values> = Values extends readonly (infer Value)[] ? readonly CompactAccepted<Value>[] : readonly never[];
 type CompactParentsOf<Input> = Input extends {
     readonly extends?: infer Values extends readonly unknown[];
 } ? 'extends' extends keyof Input ? CompactReferences<Values> : readonly [] : readonly [];
@@ -310,10 +195,12 @@ type CompactDirectedInput<Input extends Omit<DirectedEdgeInput, 'orientation'>>
     } ? NonNullable<Value> : never : never>;
     readonly source: {
         readonly as: Input['source']['as'];
+        readonly accepts: CompactAccepts<Input['source']['accepts']>;
         readonly outgoing: Input['source']['outgoing'];
     };
     readonly target: {
         readonly as: Input['target']['as'];
+        readonly accepts: CompactAccepts<Input['target']['accepts']>;
         readonly incoming: Input['target']['incoming'];
     };
     readonly constraints: Input extends {
@@ -333,10 +220,12 @@ type CompactUndirectedInput<Input extends Omit<UndirectedEdgeInput, 'orientation
     readonly endpoints: readonly [
         {
             readonly as: Input['endpoints'][0]['as'];
+            readonly accepts: CompactAccepts<Input['endpoints'][0]['accepts']>;
             readonly incident: Input['endpoints'][0]['incident'];
         },
         {
             readonly as: Input['endpoints'][1]['as'];
+            readonly accepts: CompactAccepts<Input['endpoints'][1]['accepts']>;
             readonly incident: Input['endpoints'][1]['incident'];
         }
     ];
@@ -345,24 +234,6 @@ type CompactUndirectedInput<Input extends Omit<UndirectedEdgeInput, 'orientation
     } ? NonNullable<Value> : Record<never, never>;
     readonly effectiveProperties: EffectivePropertyProjectionsOf<Input>;
 };
-export interface NodeClass<out Config = unknown> {
-    readonly [AUTHORING]: 'definition';
-    readonly kind: 'node';
-    readonly [CLASS_TYPE]: () => Config;
-}
-export interface DirectedEdgeClass<out Input = unknown> {
-    readonly [AUTHORING]: 'definition';
-    readonly kind: 'edge';
-    readonly orientation: 'directed';
-    readonly [CLASS_TYPE]: () => Input;
-}
-export interface UndirectedEdgeClass<out Input = unknown> {
-    readonly [AUTHORING]: 'definition';
-    readonly kind: 'edge';
-    readonly orientation: 'undirected';
-    readonly [CLASS_TYPE]: () => Input;
-}
-export type EdgeClass = DirectedEdgeClass | UndirectedEdgeClass;
 export declare function defineClass(config: {
     readonly kind: 'node';
     readonly abstract: boolean;
@@ -395,9 +266,8 @@ type WithoutStateProperties<Input> = Input extends {
         readonly [Name in keyof Properties]: Properties[Name] extends Property ? [PropertyStateMachineOf<Properties[Name]>] extends [never] ? Properties[Name] : never : Properties[Name];
     };
 } : unknown;
-export type ProjectionOfClass<Value extends Class> = Value extends NodeClass<infer Config> ? Config : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
 export declare function classConfiguration(value: NodeClass): NodeClassInput;
 export declare function classConfiguration(value: DirectedEdgeClass): Omit<DirectedEdgeInput, 'orientation'>;
 export declare function classConfiguration(value: UndirectedEdgeClass): Omit<UndirectedEdgeInput, 'orientation'>;
 export declare function classConfiguration(value: EdgeClass): Omit<DirectedEdgeInput, 'orientation'> | Omit<UndirectedEdgeInput, 'orientation'>;
-export type { MethodRecord };
+export {};

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();
@@ -17,6 +18,7 @@ export function nodeClass(config) {
     const admitted = config ?? {};
     assertKnownKeys(admitted, [
         'abstract',
+        'inheritance',
         'description',
         'extends',
         'properties',
@@ -24,13 +26,21 @@ export function nodeClass(config) {
         'methods',
         'icon',
         'policies',
+        'unique',
     ]);
     if (admitted.policies !== undefined)
-        assertKnownKeys(admitted.policies, ['read', 'traverse']);
+        assertKnownKeys(admitted.policies, CLASS_OPERATIONS);
     const value = authoringValue('definition', {
         kind: 'node',
     });
-    classInputs.set(value, { ...admitted, abstract: admitted.abstract ?? false });
+    classInputs.set(value, {
+        ...admitted,
+        // Copied, so the declaration does not follow later changes to the author's arrays.
+        ...(admitted.unique === undefined
+            ? {}
+            : { unique: admitted.unique.map((tuple) => [...tuple]) }),
+        abstract: admitted.abstract ?? false,
+    });
     return value;
 }
 export const edgeClass = Object.freeze({
@@ -39,16 +49,18 @@ export const edgeClass = Object.freeze({
             'source',
             'target',
             'abstract',
+            'inheritance',
             'description',
             'extends',
             'properties',
             'policies',
             'constraints',
+            'unique',
         ]);
         validateDirectedSourceInput(input.source);
         validateDirectedTargetInput(input.target);
-        const { source, target, ...options } = input;
-        validateEdgeClassOptions(options);
+        const { source, target, unique, ...options } = input;
+        validateEdgeClassOptions(options, ['noSelf', 'acyclic']);
         const value = authoringValue('definition', {
             kind: 'edge',
             orientation: 'directed',
@@ -56,6 +68,12 @@ export const edgeClass = Object.freeze({
         classInputs.set(value, {
             source: { ...source },
             target: { ...target },
+            // Copied, so the declaration does not follow later changes to the author's arrays.
+            ...(unique === undefined
+                ? {}
+                : {
+                    unique: unique.map((tuple) => tuple.map((field) => typeof field === 'string' ? field : { property: field.property })),
+                }),
             ...options,
             abstract: options.abstract ?? false,
         });
@@ -65,6 +83,7 @@ export const edgeClass = Object.freeze({
         assertKnownKeys(input, [
             'endpoints',
             'abstract',
+            'inheritance',
             'description',
             'extends',
             'properties',
@@ -76,7 +95,7 @@ export const edgeClass = Object.freeze({
         validateIncidentEndpointInput(input.endpoints[0]);
         validateIncidentEndpointInput(input.endpoints[1]);
         const { endpoints, ...options } = input;
-        validateUndirectedEdgeClassOptions(options);
+        validateEdgeClassOptions(options, ['noSelf']);
         const value = authoringValue('definition', {
             kind: 'edge',
             orientation: 'undirected',
@@ -96,39 +115,18 @@ export function classConfiguration(value) {
     return input;
 }
 function validateDirectedSourceInput(value) {
-    assertKnownKeys(value, ['as', 'accepts', 'outgoing']);
+    assertKnownKeys(value, ['as', 'accepts', 'outgoing', 'onDelete']);
 }
 function validateDirectedTargetInput(value) {
-    assertKnownKeys(value, ['as', 'accepts', 'incoming']);
+    assertKnownKeys(value, ['as', 'accepts', 'incoming', 'onDelete']);
 }
 function validateIncidentEndpointInput(value) {
-    assertKnownKeys(value, ['as', 'accepts', 'incident']);
-}
-function validateEdgeClassOptions(value) {
-    assertKnownKeys(value, [
-        'abstract',
-        'description',
-        'extends',
-        'properties',
-        'policies',
-        'constraints',
-    ]);
-    if (value.policies !== undefined)
-        assertKnownKeys(value.policies, ['read', 'traverse']);
-    if (value.constraints !== undefined)
-        assertKnownKeys(value.constraints, ['noSelf', 'acyclic']);
+    assertKnownKeys(value, ['as', 'accepts', 'incident', 'onDelete']);
 }
-function validateUndirectedEdgeClassOptions(value) {
-    assertKnownKeys(value, [
-        'abstract',
-        'description',
-        'extends',
-        'properties',
-        'policies',
-        'constraints',
-    ]);
+/** 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, ['noSelf']);
+        assertKnownKeys(value.constraints, constraints);
 }

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

@@ -0,0 +1,27 @@
+import { type AUTHORING } from '../schema/handle.js';
+declare const CLASS_TYPE: unique symbol;
+/** Authored Node Class handle; its type carries the compact projection of its input. */
+export interface NodeClass<out Config = unknown> {
+    readonly [AUTHORING]: 'definition';
+    readonly kind: 'node';
+    readonly [CLASS_TYPE]: () => Config;
+}
+/** Authored directed Edge Class handle; its type carries the compact projection of its input. */
+export interface DirectedEdgeClass<out Input = unknown> {
+    readonly [AUTHORING]: 'definition';
+    readonly kind: 'edge';
+    readonly orientation: 'directed';
+    readonly [CLASS_TYPE]: () => Input;
+}
+/** Authored undirected Edge Class handle; its type carries the compact projection of its input. */
+export interface UndirectedEdgeClass<out Input = unknown> {
+    readonly [AUTHORING]: 'definition';
+    readonly kind: 'edge';
+    readonly orientation: 'undirected';
+    readonly [CLASS_TYPE]: () => Input;
+}
+export type EdgeClass = DirectedEdgeClass | UndirectedEdgeClass;
+export type Class = NodeClass | EdgeClass;
+/** The compact projection a Class handle carries. */
+export type ProjectionOfClass<Value extends Class> = Value extends NodeClass<infer Config> ? Config : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
+export {};

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

@@ -0,0 +1 @@
+import {} from '../schema/handle.js';