@astrale-os/kernel-dsl 0.2.0-beta.2 → 0.2.0-beta.21

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

@@ -0,0 +1,378 @@
+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 { 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 { StateTopology, StateTopologyOf } from '../../language/state/topology.js';
+import type { Method, ProjectionOfCallable } from '../callable/authoring.js';
+import type { Policy } from '../policy/authoring.js';
+import type { Lazy } from '../schema/lazy.js';
+import type { ClassProjectionOfResolved } from '../schema/projection.js';
+import type { TypedValueSchema } from '../value/schema.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>;
+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;
+    readonly policies?: {
+        readonly read?: Lazy<Policy>;
+        readonly traverse?: Lazy<Policy>;
+    };
+}
+export interface EdgeClassOptions {
+    readonly abstract?: boolean;
+    readonly description?: string;
+    readonly extends?: readonly EdgeClassReferenceInput[];
+    readonly properties?: PropertyRecordInput;
+    readonly policies?: {
+        readonly read?: Lazy<Policy>;
+        readonly traverse?: Lazy<Policy>;
+    };
+    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 ClassInput = ({
+    readonly kind: 'node';
+    readonly abstract: boolean;
+} & NodeClassInput) | ({
+    readonly kind: 'edge';
+    readonly orientation: 'directed';
+    readonly abstract: boolean;
+} & Omit<DirectedEdgeInput, 'orientation'>) | ({
+    readonly kind: 'edge';
+    readonly orientation: 'undirected';
+    readonly abstract: boolean;
+} & Omit<UndirectedEdgeInput, 'orientation'>);
+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 TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
+type ValueOutputOf<Schema> = Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type PropertyRequiredOf<Field> = PropertyOptionsOf<Field> extends {
+    readonly required: infer Required extends boolean;
+} ? Required : undefined extends ValueInputOf<PropertySchemaOf<Field>> ? false : true;
+type PropertyProjectionOf<Name extends string, Field> = AuthoredPropertyProjection<Field extends AutoProperty ? never : ValueInputOf<PropertySchemaOf<Field>>, ValueOutputOf<PropertySchemaOf<Field>>, PropertyRequiredOf<Field>, Name, 'self', Field extends Property ? StateTopologyOf<PropertyStateMachineOf<Field>> : undefined>;
+type PropertyProjectionsOf<Input> = Input extends Readonly<Record<string, unknown>> ? {
+    readonly [Name in keyof Input]: PropertyProjectionOf<Extract<Name, string>, Input[Name]>;
+} : Readonly<Record<never, never>>;
+type PropertyProjectionEntriesOf<Input> = PropertyProjectionsOf<Input>[keyof PropertyProjectionsOf<Input>];
+type ResolveCompactLazy<Value, Depth extends readonly unknown[] = []> = Depth['length'] extends 32 ? Value : Value extends () => infer Resolved ? ResolveCompactLazy<Resolved, readonly [...Depth, unknown]> : Value;
+type EffectivePropertiesOfReference<Value> = ResolveCompactLazy<Value> extends infer Resolved ? Resolved extends NodeClass<infer Config> ? Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<Resolved>> : never : Resolved extends DirectedEdgeClass<infer Config> | UndirectedEdgeClass<infer Config> ? Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<Resolved>> : never : Resolved extends ResolvedClass ? Resolved['properties']['byKey'][keyof Resolved['properties']['byKey']] extends infer Entry ? Entry extends ResolvedProperty ? Entry : never : never : never : never;
+type ParentPropertyProjectionsOf<Input> = Input extends {
+    readonly extends?: readonly (infer Parent)[];
+} ? EffectivePropertiesOfReference<Parent> : never;
+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>>;
+type MethodIsStatic<Value extends Method> = ProjectionOfCallable<Value> extends {
+    readonly static: true;
+} ? true : false;
+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 EffectiveMethodsOfReference<Value, Static extends boolean> = ResolveCompactLazy<Value> extends infer Resolved ? Resolved extends NodeClass<infer Config> ? Config extends {
+    readonly effectiveInstanceMethods: infer InstanceMethods;
+    readonly effectiveStaticMethods: infer StaticMethods;
+} ? BindMethodOwners<Static extends true ? StaticMethods : InstanceMethods, ClassOwnerProjectionOf<Resolved>> : never : Resolved extends ResolvedClass<'node'> ? Static extends true ? Resolved['static']['methods']['byKey'][keyof Resolved['static']['methods']['byKey']] : Resolved['methods']['byKey'][keyof Resolved['methods']['byKey']] : never : never;
+type ParentMethodProjectionsOf<Input, Static extends boolean> = Input extends {
+    readonly extends?: readonly (infer Parent)[];
+} ? EffectiveMethodsOfReference<Parent, Static> : never;
+type EffectiveMethodProjectionsOf<Input, Static extends boolean> = OwnMethodProjectionsOf<Input, Static> | (ParentMethodProjectionsOf<Input, Static> extends infer Entry ? Entry extends {
+    readonly name: infer Name;
+} ? Name extends OwnMethodProjectionsOf<Input, Static>['name'] ? never : Entry : never : never);
+type ClassDepthOf<Value> = ResolveCompactLazy<Value> extends infer Resolved ? Resolved extends NodeClass<infer Config> ? Config extends {
+    readonly depth: infer Depth extends number;
+} ? Depth : 0 : Resolved extends DirectedEdgeClass<infer Config> | UndirectedEdgeClass<infer Config> ? Config extends {
+    readonly depth: infer Depth extends number;
+} ? Depth : 0 : 0 : 0;
+type TupleOfLength<Length extends number, Values extends readonly unknown[] = []> = number extends Length ? readonly unknown[] : Values['length'] extends Length ? Values : TupleOfLength<Length, readonly [...Values, unknown]>;
+type Increment<Depth extends number> = number extends Depth ? number : [...TupleOfLength<Depth>, unknown]['length'] & number;
+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> & {
+    readonly name: infer Name;
+    readonly key: infer Key;
+} ? {
+    readonly value: Value;
+    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 Inheritance, infer Auth, infer _Policy, infer Key> & {
+    readonly name: infer Name;
+} ? {
+    readonly input: Input;
+    readonly output: Output;
+    readonly static: Static;
+    readonly inheritance: Inheritance;
+    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 {
+    readonly extends?: infer Values extends readonly unknown[];
+} ? 'extends' extends keyof Input ? CompactReferences<Values> : readonly [] : readonly [];
+type CompactNodeInput<Input extends NodeClassInput> = {
+    readonly depth: ClassDepthOfInput<Input>;
+    readonly abstract: Input extends {
+        readonly abstract: infer Value extends boolean;
+    } ? Value : false;
+    readonly extends: CompactParentsOf<Input>;
+    readonly properties: PropertyProjectionsOf<'properties' extends keyof Input ? Input extends {
+        readonly properties?: infer Value;
+    } ? NonNullable<Value> : never : never>;
+    readonly methods: 'methods' extends keyof Input ? Input extends {
+        readonly methods?: infer Value;
+    } ? NonNullable<Value> : Readonly<Record<never, never>> : Readonly<Record<never, never>>;
+    readonly effectiveProperties: EffectivePropertyProjectionsOf<Input>;
+    readonly effectiveInstanceMethods: EffectiveMethodProjectionsOf<Input, false>;
+    readonly effectiveStaticMethods: EffectiveMethodProjectionsOf<Input, true>;
+};
+type CompactDirectedInput<Input extends Omit<DirectedEdgeInput, 'orientation'>> = {
+    readonly depth: ClassDepthOfInput<Input>;
+    readonly abstract: Input extends {
+        readonly abstract: infer Value extends boolean;
+    } ? Value : false;
+    readonly extends: CompactParentsOf<Input>;
+    readonly properties: PropertyProjectionsOf<'properties' extends keyof Input ? Input extends {
+        readonly properties?: infer Value;
+    } ? NonNullable<Value> : never : never>;
+    readonly source: {
+        readonly as: Input['source']['as'];
+        readonly outgoing: Input['source']['outgoing'];
+    };
+    readonly target: {
+        readonly as: Input['target']['as'];
+        readonly incoming: Input['target']['incoming'];
+    };
+    readonly constraints: Input extends {
+        readonly constraints?: infer Value;
+    } ? NonNullable<Value> : Record<never, never>;
+    readonly effectiveProperties: EffectivePropertyProjectionsOf<Input>;
+};
+type CompactUndirectedInput<Input extends Omit<UndirectedEdgeInput, 'orientation'>> = {
+    readonly depth: ClassDepthOfInput<Input>;
+    readonly abstract: Input extends {
+        readonly abstract: infer Value extends boolean;
+    } ? Value : false;
+    readonly extends: CompactParentsOf<Input>;
+    readonly properties: PropertyProjectionsOf<'properties' extends keyof Input ? Input extends {
+        readonly properties?: infer Value;
+    } ? NonNullable<Value> : never : never>;
+    readonly endpoints: readonly [
+        {
+            readonly as: Input['endpoints'][0]['as'];
+            readonly incident: Input['endpoints'][0]['incident'];
+        },
+        {
+            readonly as: Input['endpoints'][1]['as'];
+            readonly incident: Input['endpoints'][1]['incident'];
+        }
+    ];
+    readonly constraints: Input extends {
+        readonly constraints?: infer Value;
+    } ? 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;
+} & NodeClassInput): NodeClass;
+export declare function defineClass(config: {
+    readonly kind: 'edge';
+    readonly orientation: 'directed';
+    readonly abstract: boolean;
+} & Omit<DirectedEdgeInput, 'orientation'>): DirectedEdgeClass;
+export declare function defineClass(config: {
+    readonly kind: 'edge';
+    readonly orientation: 'undirected';
+    readonly abstract: boolean;
+} & Omit<UndirectedEdgeInput, 'orientation'>): UndirectedEdgeClass;
+export declare function nodeClass<const Config extends NodeClassInput = Record<never, never>>(config?: Config & Record<Exclude<keyof Config, keyof NodeClassInput>, never>): NodeClass<CompactNodeInput<Config>>;
+export declare const edgeClass: Readonly<{
+    directed<const Input extends Omit<DirectedEdgeInput, 'orientation'>>(input: Input & {
+        readonly source: ExactEndpointInput<Input['source'], DirectedSourceInput>;
+        readonly target: ExactEndpointInput<Input['target'], DirectedTargetInput>;
+    } & WithoutStateProperties<Input>): DirectedEdgeClass<CompactDirectedInput<Input>>;
+    undirected<const Input extends Omit<UndirectedEdgeInput, 'orientation'>>(input: Input & {
+        readonly endpoints: readonly [ExactEndpointInput<Input['endpoints'][0], IncidentEndpointInput>, ExactEndpointInput<Input['endpoints'][1], IncidentEndpointInput>];
+    } & WithoutStateProperties<Input>): UndirectedEdgeClass<CompactUndirectedInput<Input>>;
+}>;
+type WithoutStateProperties<Input> = Input extends {
+    readonly properties?: infer Properties extends Readonly<Record<string, unknown>>;
+} ? {
+    readonly properties?: {
+        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 };

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

@@ -0,0 +1,134 @@
+import { assertKnownKeys } from '../schema/diagnostic.js';
+import { authoringValue } from '../schema/handle.js';
+const classInputs = new WeakMap();
+export function defineClass(config) {
+    if (config.kind === 'node') {
+        const { kind: _, ...input } = config;
+        return nodeClass(input);
+    }
+    if (config.orientation === 'directed') {
+        const { kind: _, orientation: __, ...input } = config;
+        return edgeClass.directed(input);
+    }
+    const { kind: _, orientation: __, ...input } = config;
+    return edgeClass.undirected(input);
+}
+export function nodeClass(config) {
+    const admitted = config ?? {};
+    assertKnownKeys(admitted, [
+        'abstract',
+        'description',
+        'extends',
+        'properties',
+        'data',
+        'methods',
+        'icon',
+        'policies',
+    ]);
+    if (admitted.policies !== undefined)
+        assertKnownKeys(admitted.policies, ['read', 'traverse']);
+    const value = authoringValue('definition', {
+        kind: 'node',
+    });
+    classInputs.set(value, { ...admitted, abstract: admitted.abstract ?? false });
+    return value;
+}
+export const edgeClass = Object.freeze({
+    directed(input) {
+        assertKnownKeys(input, [
+            'source',
+            'target',
+            'abstract',
+            'description',
+            'extends',
+            'properties',
+            'policies',
+            'constraints',
+        ]);
+        validateDirectedSourceInput(input.source);
+        validateDirectedTargetInput(input.target);
+        const { source, target, ...options } = input;
+        validateEdgeClassOptions(options);
+        const value = authoringValue('definition', {
+            kind: 'edge',
+            orientation: 'directed',
+        });
+        classInputs.set(value, {
+            source: { ...source },
+            target: { ...target },
+            ...options,
+            abstract: options.abstract ?? false,
+        });
+        return value;
+    },
+    undirected(input) {
+        assertKnownKeys(input, [
+            'endpoints',
+            'abstract',
+            'description',
+            'extends',
+            'properties',
+            'policies',
+            'constraints',
+        ]);
+        if (input.endpoints.length !== 2)
+            throw new TypeError('Undirected Edge Classes require exactly two endpoints.');
+        validateIncidentEndpointInput(input.endpoints[0]);
+        validateIncidentEndpointInput(input.endpoints[1]);
+        const { endpoints, ...options } = input;
+        validateUndirectedEdgeClassOptions(options);
+        const value = authoringValue('definition', {
+            kind: 'edge',
+            orientation: 'undirected',
+        });
+        classInputs.set(value, {
+            endpoints: [{ ...endpoints[0] }, { ...endpoints[1] }],
+            ...options,
+            abstract: options.abstract ?? false,
+        });
+        return value;
+    },
+});
+export function classConfiguration(value) {
+    const input = classInputs.get(value);
+    if (input === undefined)
+        throw new TypeError('Unknown Class authoring handle.');
+    return input;
+}
+function validateDirectedSourceInput(value) {
+    assertKnownKeys(value, ['as', 'accepts', 'outgoing']);
+}
+function validateDirectedTargetInput(value) {
+    assertKnownKeys(value, ['as', 'accepts', 'incoming']);
+}
+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']);
+}
+function validateUndirectedEdgeClassOptions(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']);
+}

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

@@ -0,0 +1,58 @@
+import type { z } from 'zod';
+import type { AutoEvent, AutoSet } from '../../language/class/model/property.js';
+import type { StateMachine } from '../../language/state/index.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { AUTHORING } from '../schema/handle.js';
+declare const PROPERTY_INPUT: unique symbol;
+declare const AUTO_INPUT: unique symbol;
+export type ValueSchemaInput = z.ZodType | JsonSchema;
+export interface PropertyOptions {
+    readonly required?: boolean;
+    readonly description?: string;
+}
+export interface AutoOptions {
+    readonly on: AutoEvent | readonly AutoEvent[];
+    readonly set: AutoSet;
+}
+export interface Property<out Schema extends ValueSchemaInput = ValueSchemaInput, out Options extends PropertyOptions = PropertyOptions, out Machine = unknown> {
+    readonly [AUTHORING]: 'property';
+    readonly [PROPERTY_INPUT]: {
+        readonly schema: Schema;
+        readonly options: Options;
+        readonly machine?: Machine;
+    };
+}
+export type PropertySchemaOf<Value extends Property> = Value extends Property<infer Schema, PropertyOptions, unknown> ? Schema : never;
+export type PropertyOptionsOf<Value extends Property> = Value extends Property<ValueSchemaInput, infer Options, unknown> ? Options : never;
+export type PropertyStateMachineOf<Value extends Property> = Value extends Property<ValueSchemaInput, PropertyOptions, infer Machine> ? Machine : never;
+export interface AutoProperty<out PropertyValue extends Property = Property> {
+    readonly [AUTHORING]: 'auto';
+    readonly [AUTO_INPUT]: {
+        readonly property: PropertyValue;
+        readonly options: {
+            readonly on: readonly AutoEvent[];
+            readonly set: AutoSet;
+        };
+    };
+}
+export type PropertyAuthoringInput<Value extends Property> = Value extends Property<infer Schema, infer Options, infer Machine> ? {
+    readonly schema: Schema;
+    readonly options: Options;
+    readonly machine?: Machine;
+} : never;
+export declare function propertyAuthoringInput<const Value extends Property>(value: Value): PropertyAuthoringInput<Value>;
+export declare function autoPropertyAuthoringInput<const Value extends AutoProperty>(value: Value): Value extends AutoProperty<infer Property> ? {
+    readonly property: Property;
+    readonly options: {
+        readonly on: readonly AutoEvent[];
+        readonly set: AutoSet;
+    };
+} : never;
+export type PropertyFieldInput = ValueSchemaInput | Property | AutoProperty;
+export type PropertyRecordInput = Readonly<Record<string, PropertyFieldInput>>;
+export declare function property<const Schema extends ValueSchemaInput, const Options extends PropertyOptions = Record<never, never>>(schema: Schema, options?: Options): Property<Schema, Options, never>;
+export declare function stateProperty<const Machine extends StateMachine, const Options extends Omit<PropertyOptions, 'required'> = Record<never, never>>(machine: Machine, options?: Options & Record<Exclude<keyof Options, 'description'>, never>): Property<Machine['stateSchema'], Readonly<Options & {
+    readonly required: true;
+}>, Machine>;
+export declare function auto<const PropertyValue extends Property>(property: [PropertyStateMachineOf<PropertyValue>] extends [never] ? PropertyValue : never, options: AutoOptions): AutoProperty<PropertyValue>;
+export {};

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

@@ -0,0 +1,57 @@
+import { assertKnownKeys, fail } from '../schema/diagnostic.js';
+import { authoringValue, isAuthoringValue } from '../schema/handle.js';
+const PROPERTY_INPUT = Symbol('astrale.v1.property-input');
+const AUTO_INPUT = Symbol('astrale.v1.auto-property-input');
+export function propertyAuthoringInput(value) {
+    return value[PROPERTY_INPUT];
+}
+export function autoPropertyAuthoringInput(value) {
+    return value[AUTO_INPUT];
+}
+export function property(schema, options) {
+    const admitted = options ?? {};
+    assertKnownKeys(admitted, ['required', 'description']);
+    return authoringValue('property', {
+        [PROPERTY_INPUT]: {
+            schema,
+            options: admitted,
+        },
+    });
+}
+export function stateProperty(machine, options) {
+    const admitted = options ?? {};
+    assertKnownKeys(admitted, ['description']);
+    return authoringValue('property', {
+        [PROPERTY_INPUT]: {
+            schema: machine.stateSchema,
+            options: { ...admitted, required: true },
+            machine,
+        },
+    });
+}
+export function auto(property, options) {
+    if (isAuthoringValue(property, 'auto')) {
+        fail('BUILDER_AUTO_NESTED', '', 'auto(...) cannot wrap another auto Property.');
+    }
+    assertKnownKeys(options, ['on', 'set']);
+    const authored = Array.isArray(options.on) ? options.on : [options.on];
+    if (authored.length === 0)
+        fail('BUILDER_AUTO_EVENT_INVALID', '/on', 'auto(...) requires an event.');
+    const events = [...new Set(authored)];
+    if (events.some((event) => event !== 'create' && event !== 'update')) {
+        fail('BUILDER_AUTO_EVENT_INVALID', '/on', 'Automatic events are create or update.');
+    }
+    if (options.set !== 'instant') {
+        fail('BUILDER_AUTO_SET_INVALID', '/set', 'The auto setter must be instant.');
+    }
+    events.sort((left, right) => (left === right ? 0 : left === 'create' ? -1 : 1));
+    if (propertyAuthoringInput(property).options.required === true && !events.includes('create')) {
+        fail('BUILDER_AUTO_EVENT_INVALID', '/on', 'A required auto Property must run on create.');
+    }
+    return authoringValue('auto', {
+        [AUTO_INPUT]: {
+            property,
+            options: { on: Object.freeze(events), set: options.set },
+        },
+    });
+}