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

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

@@ -1,10 +1,20 @@
+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 { ResolvedClass } from '../../language/class/resolved.js';
-import type { Method } from '../callable/authoring.js';
+import type { EdgeCount } from '../../language/class/model/edge.js';
+import type { ResolvedClass, ResolvedProperty } from '../../language/class/resolved.js';
+import type { ClassRuleChecks, ClassRuleObject } from '../../language/policy/model/policy.js';
+import type { StateTopology, StateTopologyOf } from '../../language/state/topology.js';
+import type { BlobReceipt, BlobRef, BlobSchema } from '../../language/value/model/blob.js';
+import type { Method, PolicyCheckContext, ProjectionOfCallable } from '../callable/authoring.js';
 import type { Policy } from '../policy/authoring.js';
 import type { Lazy } from '../schema/lazy.js';
+import type { 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;
@@ -14,19 +24,38 @@ export type EdgeClassReferenceInput = Lazy<EdgeClass | ClassRef | ResolvedClass<
 export interface DirectedSourceInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
-    readonly outgoing: import('../../language/class/model/edge.js').EdgeCount;
+    readonly outgoing: EdgeCount;
 }
 export interface DirectedTargetInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
-    readonly incoming: import('../../language/class/model/edge.js').EdgeCount;
+    readonly incoming: EdgeCount;
 }
 export interface IncidentEndpointInput {
     readonly as: string;
     readonly accepts: readonly NodeClassReferenceInput[];
-    readonly incident: import('../../language/class/model/edge.js').EdgeCount;
+    readonly incident: EdgeCount;
 }
 type ExactEndpointInput<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
+/** One observation slot: a local Policy, or its constant value. Absent means `true`. */
+export type ClassPolicyInput = Lazy<Policy> | boolean;
+export interface ClassPoliciesInput {
+    readonly read?: ClassPolicyInput;
+    readonly traverse?: ClassPolicyInput;
+}
+/**
+ * Policy checks deciding one Node Class observation. `self` is the observed Node; `ref` names one
+ * exact member, the same Node for every observed candidate.
+ */
+export interface ClassRuleContext extends PolicyCheckContext<ClassRuleObject> {
+}
+export type ClassRuleBuilder = (context: ClassRuleContext) => ClassRuleChecks;
+/** One Node Class observation slot: a local Policy, a constant value, or Policy checks. */
+export type NodeClassPolicyInput = ClassPolicyInput | ClassRuleBuilder;
+export interface NodeClassPoliciesInput {
+    readonly read?: NodeClassPolicyInput;
+    readonly traverse?: NodeClassPolicyInput;
+}
 export interface NodeClassInput {
     readonly abstract?: boolean;
     readonly description?: string;
@@ -35,19 +64,16 @@ export interface NodeClassInput {
     readonly data?: MediaType;
     readonly methods?: Readonly<Record<string, Method>>;
     readonly icon?: string;
-    readonly policies?: {
-        readonly read?: Lazy<Policy>;
-        readonly traverse?: Lazy<Policy>;
-    };
+    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
+    readonly policies?: NodeClassPoliciesInput;
 }
 export interface EdgeClassOptions {
     readonly abstract?: boolean;
     readonly description?: string;
     readonly extends?: readonly EdgeClassReferenceInput[];
     readonly properties?: PropertyRecordInput;
-    readonly policies?: {
-        readonly traverse?: Lazy<Policy>;
-    };
+    /** Local observation Policies; inherited by no descendant and forbidden on abstract Classes. */
+    readonly policies?: ClassPoliciesInput;
     readonly constraints?: {
         readonly noSelf?: true;
         readonly acyclic?: true;
@@ -67,35 +93,274 @@ export interface UndirectedEdgeInput extends Omit<EdgeClassOptions, 'constraints
 }
 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 NodeClass<out Config extends NodeClassInput = NodeClassInput> {
+export interface AuthoredPropertyProjection<out Input = unknown, out Output = unknown, out Required extends boolean = boolean, out Name extends string = string, out Owner = 'self', out State extends StateTopology | undefined = StateTopology | undefined> {
+    readonly input: Input;
+    readonly output: Output;
+    readonly required: Required;
+    readonly name: Name;
+    readonly owner: Owner;
+    readonly state?: State;
+}
+export interface AuthoredMethodProjection<out Value extends Method = Method, out Name extends string = string, out Owner = 'self'> {
+    readonly value: Value;
+    readonly name: Name;
+    readonly owner: Owner;
+}
+type PropertySchemaOf<Field> = Field extends AutoProperty<infer Value> ? PropertySchemaOf<Value> : Field extends Property<infer Schema, PropertyOptions, unknown> ? Schema : Field;
+type PropertyOptionsOf<Field> = Field extends AutoProperty<infer Value> ? PropertyOptionsOf<Value> : Field extends Property<ValueSchemaInput, infer Options, unknown> ? Options : Record<never, never>;
+type ValueInputOf<Schema> = Schema extends BlobSchema ? BlobReceipt : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.input<Schema> : PortableValue;
+type ValueOutputOf<Schema> = Schema extends BlobSchema ? BlobRef : Schema extends TypedValueSchema<infer Value> ? Value : Schema extends z.ZodType ? z.output<Schema> : PortableValue;
+type 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 AbstractMethodEntries<Entry> = Entry extends AuthoredMethodProjection<infer Value> ? ProjectionOfCallable<Value> extends {
+    readonly abstract: true;
+} ? Entry : never : Entry extends {
+    readonly abstract: true;
+} ? Entry : never;
+type AbstractMethodsOfReference<Value, Static extends boolean, Seen = never> = Value extends Seen ? never : ResolveCompactLazy<Value> extends infer Resolved ? Resolved extends NodeClass<infer Config> ? Config extends {
+    readonly abstractInstanceMethods: infer InstanceMethods;
+    readonly abstractStaticMethods: infer StaticMethods;
+} ? BindMethodOwners<Static extends true ? StaticMethods : InstanceMethods, ClassOwnerProjectionOf<Resolved>> : never : Resolved extends ResolvedClass<'node'> ? ResolvedAbstractMethods<Resolved, Static, Seen | Value> : never : never;
+type ResolvedOwnAbstractMethods<Value extends ResolvedClass<'node'>, Static extends boolean> = AbstractMethodEntries<Static extends true ? Value['self']['static']['methods']['byKey'][keyof Value['self']['static']['methods']['byKey']] : Value['self']['methods']['byKey'][keyof Value['self']['methods']['byKey']]>;
+type ParentTupleMembers<Parents> = Parents extends readonly [infer Parent, ...infer Rest] ? Parent | ParentTupleMembers<Rest> : never;
+type ResolvedParents<Value> = Value extends {
+    readonly extends: infer Parents;
+} ? ParentTupleMembers<Parents> : never;
+type ResolvedAbstractMethods<Value extends ResolvedClass<'node'>, Static extends boolean, Seen> = ResolvedOwnAbstractMethods<Value, Static> | WithoutMethodNames<AbstractMethodsOfReference<ResolvedParents<Value>, Static, Seen>, MethodNames<ResolvedOwnAbstractMethods<Value, Static>>>;
+type ParentMethodProjectionsOf<Input, Static extends boolean> = Input extends {
+    readonly extends?: readonly (infer Parent)[];
+} ? AbstractMethodsOfReference<Parent, Static> : never;
+type MethodNames<Entry> = Entry extends {
+    readonly name: infer Name;
+} ? Name : never;
+type WithoutMethodNames<Entry, Names> = Entry extends {
+    readonly name: infer Name;
+} ? Name extends Names ? never : Entry : never;
+type AbstractMethodProjectionsOf<Input, Static extends boolean> = AbstractMethodEntries<OwnMethodProjectionsOf<Input, Static>> | WithoutMethodNames<ParentMethodProjectionsOf<Input, Static>, AbstractMethodEntries<OwnMethodProjectionsOf<Input, Static>>['name']>;
+type EffectiveMethodProjectionsOf<Input, Static extends boolean> = OwnMethodProjectionsOf<Input, Static> | WithoutMethodNames<ParentMethodProjectionsOf<Input, Static>, keyof MethodFieldsOf<Input>>;
+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, 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 {
+    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 abstractInstanceMethods: AbstractMethodProjectionsOf<Input, false>;
+    readonly abstractStaticMethods: AbstractMethodProjectionsOf<Input, true>;
+    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;
+    readonly [CLASS_TYPE]: () => Config;
 }
-export interface DirectedEdgeClass<out Input extends Omit<DirectedEdgeInput, 'orientation'> = Omit<DirectedEdgeInput, 'orientation'>> {
+export interface DirectedEdgeClass<out Input = unknown> {
     readonly [AUTHORING]: 'definition';
     readonly kind: 'edge';
     readonly orientation: 'directed';
-    readonly [CLASS_TYPE]?: () => Input;
+    readonly [CLASS_TYPE]: () => Input;
 }
-export interface UndirectedEdgeClass<out Input extends Omit<UndirectedEdgeInput, 'orientation'> = Omit<UndirectedEdgeInput, 'orientation'>> {
+export interface UndirectedEdgeClass<out Input = unknown> {
     readonly [AUTHORING]: 'definition';
     readonly kind: 'edge';
     readonly orientation: 'undirected';
-    readonly [CLASS_TYPE]?: () => Input;
+    readonly [CLASS_TYPE]: () => Input;
 }
 export type EdgeClass = DirectedEdgeClass | UndirectedEdgeClass;
 export declare function defineClass(config: {
@@ -112,17 +377,27 @@ export declare function defineClass(config: {
     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<Config>;
+export declare function nodeClass(): NodeClass<CompactNodeInput<Record<never, never>>>;
+export declare function nodeClass<const Config extends NodeClassInput>(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<Input>;
+    } & 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>];
-    }): UndirectedEdgeClass<Input>;
+    } & WithoutStateProperties<Input>): UndirectedEdgeClass<CompactUndirectedInput<Input>>;
 }>;
-export type ClassAuthoringInput<Value extends Class> = Value extends NodeClass<infer Config> ? Config : Value extends DirectedEdgeClass<infer Input> ? Input : Value extends UndirectedEdgeClass<infer Input> ? Input : never;
-/** Internal lowering access; Class authoring handles expose no public configuration object. */
-export declare function classAuthoringInput<const Value extends Class>(value: Value): ClassAuthoringInput<Value>;
+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

@@ -89,8 +89,7 @@ export const edgeClass = Object.freeze({
         return value;
     },
 });
-/** Internal lowering access; Class authoring handles expose no public configuration object. */
-export function classAuthoringInput(value) {
+export function classConfiguration(value) {
     const input = classInputs.get(value);
     if (input === undefined)
         throw new TypeError('Unknown Class authoring handle.');
@@ -115,7 +114,7 @@ function validateEdgeClassOptions(value) {
         'constraints',
     ]);
     if (value.policies !== undefined)
-        assertKnownKeys(value.policies, ['traverse']);
+        assertKnownKeys(value.policies, ['read', 'traverse']);
     if (value.constraints !== undefined)
         assertKnownKeys(value.constraints, ['noSelf', 'acyclic']);
 }
@@ -129,7 +128,7 @@ function validateUndirectedEdgeClassOptions(value) {
         'constraints',
     ]);
     if (value.policies !== undefined)
-        assertKnownKeys(value.policies, ['traverse']);
+        assertKnownKeys(value.policies, ['read', 'traverse']);
     if (value.constraints !== undefined)
         assertKnownKeys(value.constraints, ['noSelf']);
 }

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

@@ -1,28 +1,32 @@
 import type { z } from 'zod';
-import type { AutoEvent, AutoSet } from '../../language/class/model/property.js';
+import type { AutoEvent, AutoSet, PropertyImmutability } 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 visibility?: 'public' | 'private';
     readonly required?: boolean;
     readonly description?: string;
+    /** `create` freezes the value at creation; `once` admits one write while absent. */
+    readonly immutable?: PropertyImmutability;
 }
 export interface AutoOptions {
     readonly on: AutoEvent | readonly AutoEvent[];
     readonly set: AutoSet;
 }
-export interface Property<out Schema extends ValueSchemaInput = ValueSchemaInput, out Options extends PropertyOptions = PropertyOptions> {
+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> ? Schema : never;
-export type PropertyOptionsOf<Value extends Property> = Value extends Property<ValueSchemaInput, infer Options> ? Options : never;
+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]: {
@@ -33,9 +37,10 @@ export interface AutoProperty<out PropertyValue extends Property = Property> {
         };
     };
 }
-export type PropertyAuthoringInput<Value extends Property> = Value extends Property<infer Schema, infer Options> ? {
+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> ? {
@@ -47,6 +52,9 @@ export declare function autoPropertyAuthoringInput<const Value extends AutoPrope
 } : 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>;
-export declare function auto<const PropertyValue extends Property>(property: PropertyValue, options: AutoOptions): AutoProperty<PropertyValue>;
+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

@@ -10,14 +10,27 @@ export function autoPropertyAuthoringInput(value) {
 }
 export function property(schema, options) {
     const admitted = options ?? {};
-    assertKnownKeys(admitted, ['visibility', 'required', 'description']);
+    assertKnownKeys(admitted, ['required', 'description', 'immutable']);
+    if (admitted.immutable !== undefined &&
+        admitted.immutable !== 'create' &&
+        admitted.immutable !== 'once') {
+        fail('BUILDER_PROPERTY_IMMUTABLE_INVALID', '/immutable', 'immutable is create or once.');
+    }
     return authoringValue('property', {
         [PROPERTY_INPUT]: {
             schema,
-            options: {
-                ...admitted,
-                visibility: admitted.visibility ?? 'public',
-            },
+            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,
         },
     });
 }
@@ -26,6 +39,9 @@ export function auto(property, options) {
         fail('BUILDER_AUTO_NESTED', '', 'auto(...) cannot wrap another auto Property.');
     }
     assertKnownKeys(options, ['on', 'set']);
+    if (propertyAuthoringInput(property).options.immutable !== undefined) {
+        fail('BUILDER_AUTO_IMMUTABLE', '', 'An auto Property cannot be immutable.');
+    }
     const authored = Array.isArray(options.on) ? options.on : [options.on];
     if (authored.length === 0)
         fail('BUILDER_AUTO_EVENT_INVALID', '/on', 'auto(...) requires an event.');

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

@@ -1,29 +1,44 @@
 import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
-import type { CoreRef } from '../../addressing/index.js';
 import type { DomainEndpointRef } from '../../language/core/model/core.js';
+import type { PolicyObjectInput } from '../callable/authoring.js';
 import type { EdgeClass, NodeClass } from '../class/authoring.js';
 import type { AUTHORING } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
-import type { CorePropertyInput } from '../schema/projection.js';
-export interface CoreNode<out Definition extends Lazy<NodeClass> = Lazy<NodeClass>, out Properties extends JsonObject = CorePropertyInput<Definition> & JsonObject> {
+import type { CoreNamedPropertyInput } from '../schema/projection.js';
+interface CoreNodeConfiguration {
+    readonly class: Lazy<NodeClass>;
+    readonly properties: JsonObject;
+}
+interface CoreEdgeConfiguration {
+    readonly source: CoreEndpoint;
+    readonly class: Lazy<EdgeClass>;
+    readonly target: CoreEndpoint;
+    readonly properties: JsonObject;
+}
+export interface CoreNode {
     readonly [AUTHORING]: 'core-node';
-    readonly class: Definition;
-    readonly properties: Properties;
 }
-export type CoreEndpoint = CoreNode | CoreRef | DomainEndpointRef;
-export interface CoreEdge<out Source extends CoreEndpoint = CoreEndpoint, out Definition extends Lazy<EdgeClass> = Lazy<EdgeClass>, out Target extends CoreEndpoint = CoreEndpoint, out Properties extends JsonObject = CorePropertyInput<Definition> & JsonObject> {
+/**
+ * The owning Domain, or any local Definition of it: a Class, Function, Method, Policy, View, or
+ * Core Node, authored as a handle, a lazy handle, or its canonical ref. A lazy handle lets a Core
+ * Edge name a declaration that only exists later in a module cycle.
+ */
+export type CoreEndpoint = PolicyObjectInput | DomainEndpointRef;
+export interface CoreEdge {
     readonly [AUTHORING]: 'core-edge';
-    readonly source: Source;
-    readonly class: Definition;
-    readonly target: Target;
-    readonly properties: Properties;
 }
 export interface CoreInput {
     readonly nodes?: Readonly<Record<string, CoreNode>>;
     readonly edges?: readonly CoreEdge[];
 }
-declare function node<const Definition extends Lazy<NodeClass>, const Properties extends CorePropertyInput<Definition> & JsonObject>(definition: Definition, properties: Properties): CoreNode<Definition, Properties>;
-declare function edge<const Source extends CoreEndpoint, const Definition extends Lazy<EdgeClass>, const Target extends CoreEndpoint, const Properties extends CorePropertyInput<Definition> & JsonObject>(source: Source, definition: Definition, target: Target, properties: Properties): CoreEdge<Source, Definition, Target, Properties>;
+/** Internal lowering access; Core Node handles expose no public configuration object. */
+export declare function coreNodeConfiguration(value: CoreNode): CoreNodeConfiguration;
+/** Internal lowering access; Core Edge handles expose no public configuration object. */
+export declare function coreEdgeConfiguration(value: CoreEdge): CoreEdgeConfiguration;
+declare function node(definition: () => NodeClass, properties: JsonObject): CoreNode;
+declare function node<const Definition extends NodeClass, const Properties extends CoreNamedPropertyInput<Definition> & JsonObject>(definition: Definition, properties: Properties): CoreNode;
+declare function edge(source: CoreEndpoint, definition: () => EdgeClass, target: CoreEndpoint, properties: JsonObject): CoreEdge;
+declare function edge<const Definition extends EdgeClass, const Properties extends CoreNamedPropertyInput<Definition> & JsonObject>(source: CoreEndpoint, definition: Definition, target: CoreEndpoint, properties: Properties): CoreEdge;
 export declare const core: Readonly<{
     node: typeof node;
     edge: typeof edge;