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

package/dist/v1/addressing/class-key.js

@@ -10,11 +10,11 @@ export function ClassKey(input) {
 /** Construction, admission, and structural-coordinate operations for exact Class keys. */
 (function (ClassKey) {
     function of(ref) {
-        const admitted = acceptDefinitionRef(ref);
-        if (admitted.kind !== 'class') {
+        const key = Key.of(ref);
+        if (!key.slice(key.indexOf(':') + 1).startsWith('class.')) {
             throw new TypeError(`Invalid ClassKey coordinate: ${JSON.stringify(ref)}.`);
         }
-        return Key.of(admitted);
+        return key;
     }
     ClassKey.of = of;
     function is(input) {

package/dist/v1/addressing/key.d.ts

@@ -12,7 +12,10 @@ export declare namespace Key {
     type Definition<Kind extends DefinitionKind = DefinitionKind, Name extends string = string, Origin extends Key.Origin = Key.Origin> = DefinitionKey<Origin, Kind, Name>;
     type Callable = DefinitionKey<Key.Origin, 'function'> | MethodKey;
     type View = DefinitionKey<Key.Origin, 'view'>;
-    /** Derive a canonical Definition key from its structured coordinate. */
+    /**
+     * Derive a canonical Definition key from its structured coordinate. A frozen coordinate of data
+     * fields cannot change, so its key is derived once and read back for every later call.
+     */
     function of<const Ref extends DefinitionRef>(ref: Ref): DefinitionKey<Ref['origin'], Ref['kind'], Ref['name']>;
     function origin(input: Key): Key.Origin;
     function is(input: unknown): input is Key;

package/dist/v1/addressing/key.js

@@ -3,6 +3,8 @@ import { DOMAIN_ORIGIN_PATTERN } from './patterns.js';
 const DEFINITION_KEY = /^(?:class|function|policy|view)\.([A-Za-z][A-Za-z0-9_]*)$/u;
 const CORE_KEY = /^core\.([a-z][a-z0-9-]{0,99})$/u;
 const MEMBER_KEY = /^class\.([A-Za-z][A-Za-z0-9_]*)\.(property|method)\.([A-Za-z][A-Za-z0-9_]*)$/u;
+/** The keys of frozen Definition coordinates, derived once each. */
+const derived = new WeakMap();
 export function Key(input) {
     if (typeof input !== 'string' || !isCanonicalKey(input)) {
         throw new TypeError(`Invalid Key: ${JSON.stringify(input)}.`);
@@ -11,10 +13,22 @@ export function Key(input) {
 }
 /** Canonical origin-qualified address operations. */
 (function (Key) {
-    /** Derive a canonical Definition key from its structured coordinate. */
+    /**
+     * Derive a canonical Definition key from its structured coordinate. A frozen coordinate of data
+     * fields cannot change, so its key is derived once and read back for every later call.
+     */
     function of(ref) {
+        const object = typeof ref === 'object' && ref !== null;
+        const known = object ? derived.get(ref) : undefined;
+        if (known !== undefined)
+            return known;
+        // Decided before admission reads the fields: only then are the fields read the final ones.
+        const stable = object && immutable(ref);
         const definition = acceptDefinitionRef(ref);
-        return Key(`${definition.origin}:${definition.kind}.${definition.name}`);
+        const key = Key(`${definition.origin}:${definition.kind}.${definition.name}`);
+        if (stable)
+            derived.set(ref, key);
+        return key;
     }
     Key.of = of;
     function origin(input) {
@@ -37,3 +51,8 @@ function isCanonicalKey(input) {
 function isCanonicalCoordinate(input) {
     return DEFINITION_KEY.test(input) || CORE_KEY.test(input) || MEMBER_KEY.test(input);
 }
+/** A frozen object of data fields answers every read alike; a getter may not. */
+function immutable(ref) {
+    return (Object.isFrozen(ref) &&
+        Reflect.ownKeys(ref).every((key) => 'value' in Reflect.getOwnPropertyDescriptor(ref, key)));
+}

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