@astrale-os/kernel-dsl 1.0.0-beta.11 → 1.0.0-beta.12

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

@@ -3,7 +3,7 @@ import type { z } from 'zod';
 import type { PolicyRef } from '../../addressing/index.js';
 import type { BinaryInputProjection, CallableAdmission, CallableExecution, FunctionAuth } from '../../language/callable/model/callable.js';
 import type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef } from '../../language/policy/model/policy.js';
-import type { Class } from '../class/authoring.js';
+import type { Class } from '../class/handle.js';
 import type { ValueSchemaInput } from '../class/property.js';
 import type { CoreNode } from '../core/authoring.js';
 import type { Policy, PolicyInput } from '../policy/authoring.js';

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

@@ -1,147 +1,16 @@
 import type { 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 { 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, 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 { 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 { 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;
-    /** What deleting a Node at this endpoint does to the Edge; derived when omitted. */
-    readonly onDelete?: EdgeLifetime;
-}
-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;
-}
-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;
-}
 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;
-    /** 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 observation 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[]];
-export interface EdgeClassOptions {
-    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 observation Policies; inherited by no descendant and forbidden on abstract Classes. */
-    readonly policies?: ClassPoliciesInput;
-    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[]];
-export interface DirectedEdgeInput extends EdgeClassOptions {
-    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[];
-}
-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;
@@ -166,7 +35,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>>;
@@ -176,7 +44,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 {
@@ -213,104 +80,6 @@ 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]>[];
 type CompactParentsOf<Input> = Input extends {
@@ -380,24 +149,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;
@@ -430,9 +181,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/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';

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

@@ -0,0 +1,129 @@
+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 } 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 observation slot: a local Policy, or its constant value. Absent means `true`. */
+export type ClassPolicyInput = Lazy<Policy> | boolean;
+/** Local observation Policies of a Class. */
+export interface ClassPoliciesInput {
+    readonly read?: ClassPolicyInput;
+    readonly traverse?: ClassPolicyInput;
+}
+/**
+ * Policy checks deciding one Node Class observation. `self` is the observed Node; `ref` names one
+ * exact member, the same Node for every observed candidate.
+ */
+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;
+/** Local observation Policies of a Node Class. */
+export interface NodeClassPoliciesInput {
+    readonly read?: NodeClassPolicyInput;
+    readonly traverse?: NodeClassPolicyInput;
+}
+/** 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 observation 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 EdgeClassOptions {
+    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 observation Policies; inherited by no descendant and forbidden on abstract Classes. */
+    readonly policies?: ClassPoliciesInput;
+    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 EdgeClassOptions {
+    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<EdgeClassOptions, 'constraints'> {
+    readonly orientation: 'undirected';
+    readonly endpoints: readonly [IncidentEndpointInput, IncidentEndpointInput];
+    readonly constraints?: {
+        readonly noSelf?: true;
+    };
+}
+export type EdgeClassCommon = EdgeClassOptions;
+export type EdgeClassInput = DirectedEdgeInput | UndirectedEdgeInput;

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

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

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/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,7 +14,9 @@ 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, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
+export type { Class, DirectedEdgeClass, EdgeClass, NodeClass, UndirectedEdgeClass, } from './class/handle.js';
+export type { ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClassReferenceInput as EdgeClassReference, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, } from './class/input.js';
+export type { 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';

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';