@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.11

package/dist/v1/addressing/revision.js

@@ -0,0 +1,8 @@
+/** Content-address canonical Domain bytes with the one V1 revision algorithm. */
+export function digestRevisionBytes(bytes) {
+    let hexadecimal = '';
+    for (const byte of sha256(bytes))
+        hexadecimal += byte.toString(16).padStart(2, '0');
+    return `sha256:${hexadecimal}`;
+}
+import { sha256 } from '@noble/hashes/sha2.js';

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

@@ -0,0 +1,117 @@
+import type { Value as PortableValue } from '@astrale-os/kernel-dsl/value';
+import type { z } from 'zod';
+import type { FunctionAuth, MethodInheritance } 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 { ValueSchemaInput } from '../class/property.js';
+import type { CoreNode } from '../core/authoring.js';
+import type { Policy, PolicyInput } from '../policy/authoring.js';
+import type { Lazy } from '../schema/lazy.js';
+import type { TypedValueSchema } from '../value/schema.js';
+import type { View } from '../view/authoring.js';
+import { type AUTHORING } from '../schema/handle.js';
+declare const CALLABLE_OUTPUT: unique symbol;
+declare const CALLABLE_PROJECTION: unique symbol;
+declare const CALLABLE_PROJECTION_VALUE: unique symbol;
+export interface CallablePolicyContext {
+    readonly input: Readonly<Record<string, Extract<PolicyCheckObject, {
+        readonly kind: 'input';
+    }>>>;
+    readonly self: Extract<PolicyCheckObject, {
+        readonly kind: 'self';
+    }>;
+    ref(member: PolicyObjectInput): Extract<PolicyCheckObject, {
+        readonly kind: 'ref';
+    }>;
+    check(policy: PolicyInput, object: PolicyCheckObject): PolicyCheckExpression;
+    allOf(first: PolicyCheckExpression, ...rest: readonly PolicyCheckExpression[]): PolicyCheckExpression;
+    anyOf(first: PolicyCheckExpression, ...rest: readonly PolicyCheckExpression[]): PolicyCheckExpression;
+}
+export type CallablePolicyBuilder = (context: CallablePolicyContext) => PolicyCheckExpression;
+export interface StreamOutput<out Item extends ValueSchemaInput = ValueSchemaInput> {
+    readonly mode: 'stream';
+    readonly item: Item;
+    readonly [CALLABLE_OUTPUT]: true;
+}
+export interface BinaryOutput {
+    readonly mode: 'binary';
+    readonly [CALLABLE_OUTPUT]: true;
+}
+export type CallableOutputInput = ValueSchemaInput | StreamOutput | BinaryOutput;
+export interface CallableInputBase {
+    readonly description?: string;
+    readonly input: ValueSchemaInput;
+    readonly output: CallableOutputInput;
+    readonly static?: boolean;
+    readonly inheritance?: MethodInheritance;
+}
+export type CallableInput = CallableInputBase & ({
+    readonly auth: 'anonymous';
+    readonly policy?: never;
+} | {
+    readonly auth: 'authenticated';
+    readonly policy?: never;
+} | {
+    readonly auth: 'authorized';
+    readonly policy?: CallablePolicyBuilder;
+});
+export type FunctionInput = CallableInput & {
+    readonly static?: never;
+    readonly inheritance?: never;
+};
+export type MethodInput = CallableInput;
+export interface CallableProjection<out Input = unknown, out Output = unknown, out Auth extends FunctionAuth = FunctionAuth, out Static extends boolean = boolean, out Inheritance extends MethodInheritance = MethodInheritance> {
+    readonly [CALLABLE_PROJECTION_VALUE]: true;
+    readonly input: Input;
+    readonly output: Output;
+    readonly auth: Auth;
+    readonly static: Static;
+    readonly inheritance: Inheritance;
+}
+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 CallableOutputOf<Input extends CallableOutputInput> = Input extends StreamOutput<infer Item> ? {
+    readonly mode: 'stream';
+    readonly item: ValueOutputOf<Item>;
+} : Input extends BinaryOutput ? {
+    readonly mode: 'binary';
+} : {
+    readonly mode: 'value';
+    readonly value: ValueOutputOf<Input>;
+};
+export interface Function<out Projection = unknown> {
+    readonly [AUTHORING]: 'function';
+    readonly [CALLABLE_PROJECTION]?: () => Projection;
+}
+export interface Method<out Projection = unknown> {
+    readonly [AUTHORING]: 'method';
+    readonly [CALLABLE_PROJECTION]?: () => Projection;
+}
+export type ProjectionOfCallable<Value extends Function | Method> = Value extends Function<infer Projection> ? Projection : Value extends Method<infer Projection> ? Projection : never;
+/** Internal lowering access; Callable authoring handles expose no public configuration object. */
+export declare function callableConfiguration(value: Function | Method): CallableInput;
+export type PolicyObjectAuthoring = Class | Function | Policy | View | CoreNode;
+export type PolicyObjectInput = Lazy<PolicyObjectAuthoring>;
+export declare function func<const Config extends FunctionInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth']>(config: Config): Function<CallableProjection<Input, Output, Auth, false, 'default'>>;
+export declare function method<const Config extends MethodInput, Input = ValueInputOf<Config['input']>, Output = CallableOutputOf<Config['output']>, Auth extends FunctionAuth = Config['auth'], Static extends boolean = Config extends {
+    readonly static: true;
+} ? true : false, Inheritance extends MethodInheritance = Config extends {
+    readonly inheritance: infer Value extends MethodInheritance;
+} ? Value : 'default'>(config: Config): Method<CallableProjection<Input, Output, Auth, Static, Inheritance>>;
+export declare function callableInputField(name: string): Extract<PolicyCheckObject, {
+    readonly kind: 'input';
+}>;
+export declare function callableSelf(): Extract<PolicyCheckObject, {
+    readonly kind: 'self';
+}>;
+export declare function callableRef(ref: PolicyObjectRef): Extract<PolicyCheckObject, {
+    readonly kind: 'ref';
+}>;
+export declare function callablePolicyObject(value: PolicyCheckObject): PolicyCheckObject;
+/** Explicit non-value output contracts. Plain schemas remain value outputs. */
+export declare const output: {
+    readonly stream: <const Item extends ValueSchemaInput>(item: Item) => StreamOutput<Item>;
+    readonly binary: () => BinaryOutput;
+};
+export declare function isCallableOutputAuthoring(value: CallableOutputInput): value is StreamOutput | BinaryOutput;
+export {};

package/dist/v1/builder/{callable.js → callable/authoring.js}

@@ -1,6 +1,14 @@
-import { authoringValue, isAuthoringValue } from './internal/authoring.js';
-import { assertKnownKeys } from './internal/diagnostic.js';
-export function fn(config) {
+import { assertKnownKeys } from '../schema/diagnostic.js';
+import { authoringValue, isAuthoringValue } from '../schema/handle.js';
+const callableInputs = new WeakMap();
+/** Internal lowering access; Callable authoring handles expose no public configuration object. */
+export function callableConfiguration(value) {
+    const input = callableInputs.get(value);
+    if (input === undefined)
+        throw new TypeError('Unknown Callable authoring handle.');
+    return input;
+}
+export function func(config) {
     assertKnownKeys(config, [
         'description',
         'input',
@@ -10,7 +18,23 @@ export function fn(config) {
         'static',
         'inheritance',
     ]);
-    return authoringValue('function', { config: { ...config } });
+    const value = authoringValue('function', {});
+    callableInputs.set(value, { ...config });
+    return value;
+}
+export function method(config) {
+    assertKnownKeys(config, [
+        'description',
+        'input',
+        'output',
+        'auth',
+        'policy',
+        'static',
+        'inheritance',
+    ]);
+    const value = authoringValue('method', {});
+    callableInputs.set(value, { ...config });
+    return value;
 }
 export function callableInputField(name) {
     return Object.freeze({ kind: 'input', field: name });
@@ -41,4 +65,3 @@ export const output = Object.freeze({
 export function isCallableOutputAuthoring(value) {
     return isAuthoringValue(value, 'callable-output');
 }
-//# sourceMappingURL=callable.js.map

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

@@ -0,0 +1,367 @@
+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 { 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, 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 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'> {
+    readonly input: Input;
+    readonly output: Output;
+    readonly required: Required;
+    readonly name: Name;
+    readonly owner: 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;
+}
+type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions> ? Schema : Field;
+type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options> ? 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<ValueInputOf<PropertySchemaOf<Field>>, ValueOutputOf<PropertySchemaOf<Field>>, PropertyRequiredOf<Field>, Name>;
+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> ? AuthoredPropertyProjection<Input, Output, Required, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner> : 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> ? AuthoredPropertyProjection<Input, Output, Required, Name, unknown> : Entry extends ResolvedProperty<infer Value, infer Required> & {
+    readonly name: infer Name;
+    readonly key: infer Key;
+} ? {
+    readonly value: Value;
+    readonly required: Required;
+    readonly name: Name;
+    readonly key: Key;
+} : 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>;
+    }): 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>];
+    }): UndirectedEdgeClass<CompactUndirectedInput<Input>>;
+}>;
+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 };