@astrale-os/sdk 0.5.0-beta.65 → 0.5.0-beta.67

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.5.0-beta.67](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.66...sdk-v0.5.0-beta.67) (2026-08-28)
+
+
+### Features
+
+* make StateProperty transitions intrinsic ([#306](https://github.com/astrale-os/sdk/issues/306)) ([a2b2575](https://github.com/astrale-os/sdk/commit/a2b2575cf19c585c26539839c4777c0c2d413275))
+
+
+### Documentation
+
+* **state:** ratify intrinsic property transitions ([#303](https://github.com/astrale-os/sdk/issues/303)) ([d484e58](https://github.com/astrale-os/sdk/commit/d484e58bc47f80c2571886b5c85d91d91da52b25))
+
+## [0.5.0-beta.66](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.65...sdk-v0.5.0-beta.66) (2026-08-27)
+
+
+### Features
+
+* **state:** use machine transition authority ([#301](https://github.com/astrale-os/sdk/issues/301)) ([6424217](https://github.com/astrale-os/sdk/commit/642421784d391863d33e90e85c0a1c11b1a6ed7b))
+
 ## [0.5.0-beta.65](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.64...sdk-v0.5.0-beta.65) (2026-08-27)
 
 

package/dist/application/mutation/authoring/builder.d.ts

@@ -1,11 +1,12 @@
 import type { EdgeSlug } from '@astrale-os/kernel-core/graph/edge';
 import type { MutationBuilder } from '@astrale-os/kernel-core/graph/mutate';
 import type { QueryEdgeAST, QueryNodeAST } from '@astrale-os/kernel-core/graph/query';
-import type { ResolvedClass } from '../../../platform/schema/index.js';
-import type { StateMachine, StateOf, TransitionOf } from '../../state/machine.js';
+import type { Domain, ResolvedClass } from '../../../platform/schema/index.js';
+import type { EventOf, StateOf } from '../../state/machine.js';
 import type { CreatedNode, ExistingEndpoint, MutationEndpoint } from './endpoint.js';
 import type { QueryPrecondition } from './precondition.js';
-import type { RichPropertyConditions, RichPropertyDelta, RichPropertyInput, RichPropertyName } from './properties.js';
+import type { RichPropertyConditions, RichPropertyDelta, RichPropertyInput } from './properties.js';
+import { type StateMachineOf, type StatePropertyName, type StateTransitionInput } from './transition.js';
 export interface RichMutationBuilder {
     readonly expect: {
         node<Class extends ResolvedClass<'node'>>(input: {
@@ -29,14 +30,7 @@ export interface RichMutationBuilder {
         readonly class: Class;
         readonly props: RichPropertyDelta<Class>;
     }): this;
-    transition<Machine extends StateMachine, Class extends ResolvedClass<'node'>, Property extends LifecyclePropertyName<Class, Machine>>(input: {
-        readonly lifecycle: Machine;
-        readonly node: ExistingEndpoint;
-        readonly class: Class;
-        readonly property: Property;
-        readonly decision: AllowedTransitionDecision<Machine>;
-        readonly props?: RichPropertyConditions<Class>;
-    }): this;
+    transition<Class extends ResolvedClass<'node'>, Property extends StatePropertyName<Class>, Machine extends StateMachineOf<Class, Property>, From extends StateOf<Machine>, Event extends EventOf<Machine, From>>(input: StateTransitionInput<Class, Property, Machine, From, Event>): this;
     deleteNode<Class extends ResolvedClass<'node'>>(input: {
         readonly node: ExistingEndpoint;
         readonly class: Class;
@@ -59,13 +53,4 @@ export interface EdgeSelector<Class extends ResolvedClass<'edge'>> {
     readonly target: ExistingEndpoint;
     readonly class: Class;
 }
-export declare function richMutationBuilder(core: MutationBuilder): RichMutationBuilder;
-type LifecyclePropertyName<Class extends ResolvedClass<'node'>, Machine extends StateMachine> = {
-    [Name in RichPropertyName<Class>]: IsExact<Exclude<RichPropertyInput<Class>[Name], undefined>, StateOf<Machine>> extends true ? Name : never;
-}[RichPropertyName<Class>];
-type AllowedTransitionDecision<Machine extends StateMachine> = Readonly<{
-    kind: 'allowed';
-    transition: TransitionOf<Machine>;
-}>;
-type IsExact<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;
-export {};
+export declare function richMutationBuilder(core: MutationBuilder, domain: Domain): RichMutationBuilder;

package/dist/application/mutation/authoring/builder.js

@@ -2,8 +2,9 @@ import { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
 import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import { endpoint, existingEndpoint } from './endpoint.js';
 import { precondition } from './precondition.js';
-import { conditions, delta, properties, resolvedProperty } from './properties.js';
-export function richMutationBuilder(core) {
+import { conditions, delta, properties } from './properties.js';
+import { authorStateTransition, } from './transition.js';
+export function richMutationBuilder(core, domain) {
     const expectation = Object.freeze({
         node(input) {
             core.expect.node({
@@ -47,55 +48,7 @@ export function richMutationBuilder(core) {
             return rich;
         },
         transition(input) {
-            const submitted = input.decision;
-            if (submitted.kind !== 'allowed' ||
-                submitted.transition === undefined ||
-                submitted.transition === null ||
-                typeof submitted.transition !== 'object' ||
-                typeof submitted.transition.from !== 'string' ||
-                typeof submitted.transition.event !== 'string' ||
-                typeof submitted.transition.to !== 'string') {
-                throw new TypeError('Lifecycle transition decision must be allowed.');
-            }
-            const transition = submitted.transition;
-            let decision;
-            try {
-                decision = input.lifecycle.decide(transition.from, transition.event);
-            }
-            catch {
-                invalidTransition(transition);
-            }
-            if (decision.kind !== 'allowed' || decision.transition.to !== transition.to) {
-                invalidTransition(transition);
-            }
-            const selected = resolvedProperty(input.class, input.property);
-            for (const state of [transition.from, transition.to]) {
-                if (selected.validate(state).length > 0) {
-                    throw new TypeError(`Lifecycle property ${String(input.property)} does not admit state ${state}.`);
-                }
-            }
-            const from = { [input.property]: transition.from };
-            const to = { [input.property]: transition.to };
-            const suppliedEquals = input.props?.equals;
-            if ((suppliedEquals !== undefined &&
-                Object.hasOwn(suppliedEquals, input.property) &&
-                suppliedEquals[input.property] !== transition.from) ||
-                input.props?.absent?.includes(input.property) === true) {
-                throw new TypeError(`Lifecycle transition conditions conflict with property ${String(input.property)}.`);
-            }
-            core.expect.node({
-                node: existingEndpoint(input.node),
-                class: classKey(input.class),
-                props: conditions(input.class, {
-                    ...input.props,
-                    equals: { ...suppliedEquals, ...from },
-                }),
-            });
-            core.updateNode({
-                node: existingEndpoint(input.node),
-                class: classKey(input.class),
-                props: delta(input.class, { set: to }),
-            });
+            authorStateTransition(core, domain, input);
             return rich;
         },
         deleteNode(input) {
@@ -147,6 +100,3 @@ export function richMutationBuilder(core) {
 function classKey(selected) {
     return ClassKey(selected.key);
 }
-function invalidTransition(transition) {
-    throw new TypeError(`Lifecycle transition witness is not legal: ${transition.from} + ${transition.event} -> ${transition.to}.`);
-}

package/dist/application/mutation/authoring/transition.d.ts

@@ -0,0 +1,17 @@
+import type { MutationBuilder } from '@astrale-os/kernel-core/graph/mutate';
+import type { Domain, ResolvedClass } from '../../../platform/schema/index.js';
+import type { StatePropertiesOfClass } from '../../../platform/schema/state-property/index.js';
+import type { EventOf, StateMachine, StateOf } from '../../state/machine.js';
+import type { ExistingEndpoint } from './endpoint.js';
+import type { RichPropertyConditions, RichPropertyName } from './properties.js';
+export type StatePropertyName<Class extends ResolvedClass<'node'>> = Extract<keyof StatePropertiesOfClass<Class>, RichPropertyName<Class>>;
+export type StateMachineOf<Class extends ResolvedClass<'node'>, Property extends StatePropertyName<Class>> = Extract<StatePropertiesOfClass<Class>[Property], StateMachine>;
+export interface StateTransitionInput<Class extends ResolvedClass<'node'>, Property extends StatePropertyName<Class>, Machine extends StateMachineOf<Class, Property>, From extends StateOf<Machine>, Event extends EventOf<Machine, From>> {
+    readonly node: ExistingEndpoint;
+    readonly class: Class;
+    readonly property: Property;
+    readonly from: From;
+    readonly event: Event;
+    readonly props?: RichPropertyConditions<Class>;
+}
+export declare function authorStateTransition<Class extends ResolvedClass<'node'>, Property extends StatePropertyName<Class>, Machine extends StateMachineOf<Class, Property>, From extends StateOf<Machine>, Event extends EventOf<Machine, From>>(core: MutationBuilder, domain: Domain, input: StateTransitionInput<Class, Property, Machine, From, Event>): void;

package/dist/application/mutation/authoring/transition.js

@@ -0,0 +1,47 @@
+import { ClassKey } from '@astrale-os/kernel-dsl/v1/addressing';
+import { stateMachineFor } from '../../../platform/schema/state-property/registry.js';
+import { stateTransitionFailure } from '../failure.js';
+import { existingEndpoint } from './endpoint.js';
+import { conditions, delta, resolvedProperty } from './properties.js';
+export function authorStateTransition(core, domain, input) {
+    const node = existingEndpoint(input.node);
+    const selectedClass = input.class;
+    const property = input.property;
+    const fromState = input.from;
+    const event = input.event;
+    const suppliedProps = input.props;
+    const equals = suppliedProps?.equals;
+    const absent = suppliedProps?.absent;
+    const suppliedEquals = equals === undefined ? undefined : { ...equals };
+    const suppliedAbsent = absent === undefined ? undefined : [...absent];
+    const selected = resolvedProperty(selectedClass, property);
+    const selectedClassKey = ClassKey(selectedClass.key);
+    const machine = stateMachineFor(domain, selected);
+    if (machine === undefined) {
+        throw new TypeError(`State transition requires StateProperty ${selectedClassKey}.${String(property)} in the selected Domain.`);
+    }
+    const decision = machine.decide(fromState, event);
+    if (decision.kind === 'rejected')
+        throw stateTransitionFailure(decision.from, decision.event);
+    const from = { [property]: fromState };
+    const to = { [property]: decision.transition.to };
+    if ((suppliedEquals !== undefined &&
+        Object.hasOwn(suppliedEquals, property) &&
+        suppliedEquals[property] !== fromState) ||
+        suppliedAbsent?.includes(property) === true) {
+        throw new TypeError(`StateMachine transition conditions conflict with property ${String(property)}.`);
+    }
+    core.expect.node({
+        node,
+        class: selectedClassKey,
+        props: conditions(selectedClass, {
+            ...(suppliedAbsent === undefined ? {} : { absent: suppliedAbsent }),
+            equals: { ...suppliedEquals, ...from },
+        }),
+    });
+    core.updateNode({
+        node,
+        class: selectedClassKey,
+        props: delta(selectedClass, { set: to }),
+    });
+}

package/dist/application/mutation/define.d.ts

@@ -1,9 +1,11 @@
 import type { MutationResult } from '@astrale-os/kernel-core/graph/mutate';
 import type { Domain, schema } from '../../platform/schema/index.js';
+import type { StatefulDomainOf } from '../../platform/schema/state-property/index.js';
 import type { Mutation, MutationDefinition } from './mutation.js';
 type ResolvedDomainOf<Schema extends schema.DomainSchema> = Extract<schema.DomainOf<Schema>, Domain>;
+type AuthoringDomainOf<Schema extends schema.DomainSchema> = StatefulDomainOf<Schema>;
 interface MutationProjector<Schema extends schema.DomainSchema> {
-    <Input, Output = MutationResult>(project: (domain: ResolvedDomainOf<Schema>) => MutationDefinition<Input, Output>): Mutation<ResolvedDomainOf<Schema>, Input, Output>;
+    <Input, Output = MutationResult>(project: (domain: AuthoringDomainOf<Schema>) => MutationDefinition<Input, Output>): Mutation<ResolvedDomainOf<Schema>, Input, Output>;
 }
 /** Define one inert Mutation recipe projected from its exact loaded Domain. */
 export declare function defineMutation<Schema extends schema.DomainSchema>(): MutationProjector<Schema>;

package/dist/application/mutation/execution/execute.js

@@ -9,7 +9,7 @@ export async function executeMutation(client, domain, definition, input) {
     }
     const operation = realizeMutation(definition, domain);
     try {
-        const ast = MutationAST.build((builder) => operation.build(input, richMutationBuilder(builder)));
+        const ast = MutationAST.build((builder) => operation.build(input, richMutationBuilder(builder, domain)));
         return projectMutation(operation, await client.mutate(ast, { expected: domain.closure }), input);
     }
     catch (cause) {

package/dist/application/mutation/failure.d.ts

@@ -1,5 +1,13 @@
-export interface MutationFailure extends Error {
-    readonly code: string;
+export interface KernelMutationFailure extends Error {
+    readonly code: `MUTATION_${string}`;
     readonly outcomeKnown: boolean;
 }
+export interface StateTransitionFailure extends Error {
+    readonly code: 'STATE_TRANSITION_ILLEGAL';
+    readonly outcomeKnown: true;
+    readonly from: string;
+    readonly event: string;
+}
+export type MutationFailure = KernelMutationFailure | StateTransitionFailure;
+export declare function stateTransitionFailure(from: string, event: string): StateTransitionFailure;
 export declare function mutationFailure(input: unknown): MutationFailure | undefined;

package/dist/application/mutation/failure.js

@@ -1,4 +1,15 @@
 const UNKNOWN_OUTCOME_CODES = new Set(['MUTATION_OUTCOME_UNKNOWN']);
+const localStateTransitionFailures = new WeakSet();
+export function stateTransitionFailure(from, event) {
+    const failure = Object.assign(new Error(`State transition is illegal: ${from} + ${event}.`), {
+        code: 'STATE_TRANSITION_ILLEGAL',
+        outcomeKnown: true,
+        from,
+        event,
+    });
+    localStateTransitionFailures.add(failure);
+    return failure;
+}
 export function mutationFailure(input) {
     if (!(input instanceof Error))
         return undefined;
@@ -8,6 +19,15 @@ export function mutationFailure(input) {
     const explicit = input.outcomeKnown;
     if (explicit !== undefined && typeof explicit !== 'boolean')
         return undefined;
+    if (code === 'STATE_TRANSITION_ILLEGAL') {
+        if (!localStateTransitionFailures.has(input))
+            return undefined;
+        const from = Reflect.get(input, 'from');
+        const event = Reflect.get(input, 'event');
+        if (typeof from !== 'string' || typeof event !== 'string' || explicit === false)
+            return undefined;
+        return Object.assign(input, { code, outcomeKnown: true, from, event });
+    }
     return Object.assign(input, {
         code,
         outcomeKnown: explicit !== false && !UNKNOWN_OUTCOME_CODES.has(code),
@@ -15,9 +35,12 @@ export function mutationFailure(input) {
 }
 function mutationCode(input) {
     const value = input;
+    if (value.code === 'STATE_TRANSITION_ILLEGAL')
+        return value.code;
     for (const candidate of [value.code, nestedCode(value.reason), nestedCode(value.data)]) {
-        if (typeof candidate === 'string' && candidate.startsWith('MUTATION_'))
+        if (typeof candidate === 'string' && candidate.startsWith('MUTATION_')) {
             return candidate;
+        }
     }
     return undefined;
 }

package/dist/application/state/authority.d.ts

@@ -0,0 +1,3 @@
+import type { StateMachine } from './machine.js';
+export declare function rememberStateMachine(machine: StateMachine): void;
+export declare function isStateMachine(input: unknown): input is StateMachine;

package/dist/application/state/authority.js

@@ -0,0 +1,7 @@
+const machines = new WeakSet();
+export function rememberStateMachine(machine) {
+    machines.add(machine);
+}
+export function isStateMachine(input) {
+    return typeof input === 'object' && input !== null && machines.has(input);
+}

package/dist/application/state/define.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { rememberStateMachine } from './authority.js';
 import { relation } from './relation.js';
 export function stateMachine(input) {
     const admitted = relation(input);
@@ -10,7 +11,7 @@ export function stateMachine(input) {
     const eventSchema = z.enum(events);
     const stateSet = new Set(states);
     const eventSet = new Set(events);
-    return Object.freeze({
+    const machine = Object.freeze({
         initial: admitted.initial,
         stateSchema,
         eventSchema,
@@ -40,6 +41,8 @@ export function stateMachine(input) {
             });
         },
     });
+    rememberStateMachine(machine);
+    return machine;
 }
 function admitState(state, states) {
     if (!states.has(state))

package/dist/platform/schema/index.d.ts

@@ -1,4 +1,6 @@
 import { KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema';
+export { defineSchema, edgeClass, nodeClass, stateProperty } from './state-property/index.js';
+export type { StateClass, StateProperty, StateSchema } from './state-property/index.js';
 export * from '@astrale-os/kernel-dsl/v1';
 export { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 export type { CallablePolicyBuilder, CallablePolicyContext, CallableProjection, AuthoredMethodProjection, AuthoredPropertyProjection, ClassIdentityProjection, ClassOwnerProjection, CoreEdge, CoreEndpoint, CoreNode, DefinedSchema, DirectedEdgeClass, ClassReferenceProjection, ClassProjection, FunctionProjection, EdgeClass, Function, Method, MethodProjection, Lazy, NodeClass, Policy, Property, PropertyProjection, ResolvedDomainOfInput, View, } from '@astrale-os/kernel-dsl/v1/builder';

package/dist/platform/schema/index.js

@@ -1,6 +1,7 @@
 import { KernelSchema as CoreKernelSchema } from '@astrale-os/kernel-core/schema';
 /** Canonical Schema authoring, compilation, loading, and resolved Domain surface. */
 import { schema as language } from '@astrale-os/kernel-dsl/v1';
+export { defineSchema, edgeClass, nodeClass, stateProperty } from './state-property/index.js';
 export * from '@astrale-os/kernel-dsl/v1';
 export { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 /** Kernel-owned Schema values used by authored product Schemas and graph operations. */

package/dist/platform/schema/state-property/authoring.d.ts

@@ -0,0 +1,15 @@
+import type { DefinedSchema, NodeClassInput, PropertyOptions, ResolvedDomainOfInput, SchemaInput as DomainSchemaInput } from '@astrale-os/kernel-dsl/v1/builder';
+import { nodeClass as languageNodeClass } from '@astrale-os/kernel-dsl/v1';
+import type { StateMachine } from '../../../application/state/machine.js';
+import type { StateClass, StateClassesOfInput, StateDependenciesOfInput, StatePropertiesOfConfig, StateProperty, StateSchema } from './model.js';
+interface StatePropertyOptions {
+    readonly visibility?: PropertyOptions['visibility'];
+    readonly description?: string;
+}
+type RequiredStatePropertyOptions<Options extends StatePropertyOptions> = Readonly<Options & {
+    readonly required: true;
+}>;
+export declare function stateProperty<const Machine extends StateMachine, const Options extends StatePropertyOptions = Record<never, never>>(machine: Machine, options?: Options & Record<Exclude<keyof Options, keyof StatePropertyOptions>, never>): StateProperty<Machine, RequiredStatePropertyOptions<Options>>;
+export declare function nodeClass<const Config extends NodeClassInput = Record<never, never>>(config?: Config & Record<Exclude<keyof Config, keyof NodeClassInput>, never>): ReturnType<typeof languageNodeClass<Config>> & StateClass<StatePropertiesOfConfig<Config>>;
+export declare function defineSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DefinedSchema<Origin, ResolvedDomainOfInput<Origin, Input>> & StateSchema<StateClassesOfInput<Input>, StateDependenciesOfInput<Input>>;
+export {};

package/dist/platform/schema/state-property/authoring.js

@@ -0,0 +1,49 @@
+import { defineSchema as defineLanguageSchema, nodeClass as languageNodeClass, property, schema, } from '@astrale-os/kernel-dsl/v1';
+import { isStateMachine } from '../../../application/state/authority.js';
+import { rememberStateClass, rememberStateProperty, rememberStateSchema } from './registry.js';
+export function stateProperty(machine, options) {
+    if (!isStateMachine(machine))
+        throw new TypeError('stateProperty requires an SDK StateMachine.');
+    if (options !== undefined &&
+        (typeof options !== 'object' ||
+            options === null ||
+            Array.isArray(options) ||
+            Reflect.ownKeys(options).some((key) => key !== 'visibility' && key !== 'description'))) {
+        throw new TypeError('stateProperty options are visibility and description only.');
+    }
+    const value = property(machine.stateSchema, {
+        ...options,
+        required: true,
+    });
+    rememberStateProperty(value, machine);
+    return value;
+}
+export function nodeClass(config) {
+    const captured = captureNodeClassInput(config);
+    const value = languageNodeClass(captured);
+    rememberStateClass(value, captured?.properties);
+    return value;
+}
+export function defineSchema(origin, input) {
+    const captured = captureSchemaInput(input);
+    const source = defineLanguageSchema(origin, captured);
+    rememberStateSchema(source, captured, schema.resolve(source));
+    return source;
+}
+function captureNodeClassInput(config) {
+    if (config === undefined)
+        return undefined;
+    const captured = { ...config };
+    return {
+        ...captured,
+        ...(captured.properties === undefined ? {} : { properties: { ...captured.properties } }),
+    };
+}
+function captureSchemaInput(input) {
+    const captured = { ...input };
+    return {
+        ...captured,
+        ...(captured.dependencies === undefined ? {} : { dependencies: { ...captured.dependencies } }),
+        ...(captured.classes === undefined ? {} : { classes: { ...captured.classes } }),
+    };
+}

package/dist/platform/schema/state-property/edge.d.ts

@@ -0,0 +1,16 @@
+import type { DirectedEdgeInput, UndirectedEdgeInput } from '@astrale-os/kernel-dsl/v1/builder';
+import { edgeClass as languageEdgeClass } from '@astrale-os/kernel-dsl/v1';
+import type { StateProperty } from './model.js';
+interface EdgeClassAuthoring {
+    directed<const Input extends Omit<DirectedEdgeInput, 'orientation'>>(input: Parameters<typeof languageEdgeClass.directed<Input>>[0] & WithoutStateProperties<Input>): ReturnType<typeof languageEdgeClass.directed<Input>>;
+    undirected<const Input extends Omit<UndirectedEdgeInput, 'orientation'>>(input: Parameters<typeof languageEdgeClass.undirected<Input>>[0] & WithoutStateProperties<Input>): ReturnType<typeof languageEdgeClass.undirected<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 StateProperty ? never : Properties[Name];
+    };
+} : unknown;
+export declare const edgeClass: Readonly<EdgeClassAuthoring>;
+export {};

package/dist/platform/schema/state-property/edge.js

@@ -0,0 +1,21 @@
+import { edgeClass as languageEdgeClass } from '@astrale-os/kernel-dsl/v1';
+import { isStateProperty } from './registry.js';
+export const edgeClass = Object.freeze({
+    directed(input) {
+        return languageEdgeClass.directed(captureEdgeInput(input));
+    },
+    undirected(input) {
+        return languageEdgeClass.undirected(captureEdgeInput(input));
+    },
+});
+function captureEdgeInput(input) {
+    const captured = { ...input };
+    const properties = captured.properties === undefined ? undefined : { ...captured.properties };
+    if (Object.values(properties ?? {}).some(isStateProperty)) {
+        throw new TypeError('StateProperty is supported only on Node Classes.');
+    }
+    return {
+        ...captured,
+        ...(properties === undefined ? {} : { properties }),
+    };
+}

package/dist/platform/schema/state-property/index.d.ts

@@ -0,0 +1,4 @@
+export { defineSchema, nodeClass, stateProperty } from './authoring.js';
+export { edgeClass } from './edge.js';
+export type { StateClass, StatePropertiesOfClass, StateProperty, StateSchema, StatefulDomainOf, } from './model.js';
+export { stateMachineFor } from './registry.js';

package/dist/platform/schema/state-property/index.js

@@ -0,0 +1,3 @@
+export { defineSchema, nodeClass, stateProperty } from './authoring.js';
+export { edgeClass } from './edge.js';
+export { stateMachineFor } from './registry.js';

package/dist/platform/schema/state-property/model.d.ts

@@ -0,0 +1,49 @@
+import type { Domain, ResolvedClass } from '@astrale-os/kernel-dsl/v1';
+import type { NodeClassInput, Property, PropertyOptions, SchemaInput as DomainSchemaInput } from '@astrale-os/kernel-dsl/v1/builder';
+import type * as languageSchema from '@astrale-os/kernel-dsl/v1/schema';
+import type { StateMachine } from '../../../application/state/machine.js';
+declare const STATE_PROPERTY_MACHINE: unique symbol;
+declare const STATE_CLASS_PROPERTIES: unique symbol;
+declare const STATE_SCHEMA_CLASSES: unique symbol;
+export interface StateProperty<Machine extends StateMachine = StateMachine, Options extends PropertyOptions = PropertyOptions> extends Property<Machine['stateSchema'], Options> {
+    readonly [STATE_PROPERTY_MACHINE]: Machine;
+}
+export interface StateClass<Properties extends Readonly<Record<string, StateMachine>>> {
+    readonly [STATE_CLASS_PROPERTIES]: Properties;
+}
+export interface StateSchema<Classes extends Readonly<Record<string, Readonly<Record<string, StateMachine>>>>, Dependencies extends Readonly<Record<string, languageSchema.DomainSchema>> = Readonly<Record<never, never>>> {
+    readonly [STATE_SCHEMA_CLASSES]: {
+        readonly classes: Classes;
+        readonly dependencies: Dependencies;
+    };
+}
+export type StatePropertiesOfConfig<Config extends NodeClassInput> = Merge<ParentStateProperties<Config>, OwnStateProperties<Config>>;
+export type StateClassesOfInput<Input extends DomainSchemaInput> = Input extends {
+    readonly classes?: infer Classes extends Readonly<Record<string, unknown>>;
+} ? {
+    readonly [Name in keyof Classes]: Classes[Name] extends StateClass<infer Properties> ? Properties : Readonly<Record<never, never>>;
+} : Readonly<Record<never, never>>;
+export type StateDependenciesOfInput<Input extends DomainSchemaInput> = Input extends {
+    readonly dependencies?: infer Dependencies extends Readonly<Record<string, languageSchema.DomainSchema>>;
+} ? Dependencies : Readonly<Record<never, never>>;
+export type StatefulDomainOf<Schema extends languageSchema.DomainSchema> = Schema extends StateSchema<infer Classes, infer Dependencies> ? Extract<languageSchema.DomainOf<Schema>, Domain> extends infer DomainValue extends Domain ? DomainValue & {
+    readonly classes: {
+        readonly [Name in keyof DomainValue['classes']]: DomainValue['classes'][Name] & StateClass<Name extends keyof Classes ? Extract<Classes[Name], Readonly<Record<string, StateMachine>>> : Readonly<Record<never, never>>>;
+    };
+    readonly dependencies: {
+        readonly [Name in keyof DomainValue['dependencies']]: Name extends keyof Dependencies ? Dependencies[Name] extends languageSchema.DomainSchema ? StatefulDomainOf<Dependencies[Name]> : DomainValue['dependencies'][Name] : DomainValue['dependencies'][Name];
+    };
+} : never : Extract<languageSchema.DomainOf<Schema>, Domain>;
+export type StatePropertiesOfClass<Class extends ResolvedClass<'node'>> = Class extends StateClass<infer Properties> ? Properties : Readonly<Record<never, never>>;
+type OwnStateProperties<Config extends NodeClassInput> = Config extends {
+    readonly properties?: infer Properties extends Readonly<Record<string, unknown>>;
+} ? {
+    readonly [Name in keyof Properties as Properties[Name] extends StateProperty ? Name : never]: Properties[Name] extends StateProperty<infer Machine> ? Machine : never;
+} : Readonly<Record<never, never>>;
+type ParentStateProperties<Config extends NodeClassInput> = Config extends {
+    readonly extends?: readonly (infer Parent)[];
+} ? UnionToIntersection<StatePropertiesOfReference<Parent>> : Readonly<Record<never, never>>;
+type StatePropertiesOfReference<Value, Depth extends readonly unknown[] = []> = Depth['length'] extends 32 ? Readonly<Record<never, never>> : Value extends () => infer Resolved ? StatePropertiesOfReference<Resolved, readonly [...Depth, unknown]> : Value extends StateClass<infer Properties> ? Properties : Readonly<Record<never, never>>;
+type UnionToIntersection<Value> = (Value extends unknown ? (input: Value) => void : never) extends (input: infer Intersection) => void ? Intersection : never;
+type Merge<Parent, Own> = Readonly<Omit<Parent, keyof Own> & Own>;
+export {};

package/dist/platform/schema/state-property/model.js

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

package/dist/platform/schema/state-property/registry.d.ts

@@ -0,0 +1,9 @@
+import type { Domain, ResolvedProperty } from '@astrale-os/kernel-dsl/v1';
+import type { Property, SchemaInput as DomainSchemaInput } from '@astrale-os/kernel-dsl/v1/builder';
+import type * as languageSchema from '@astrale-os/kernel-dsl/v1/schema';
+import type { StateMachine } from '../../../application/state/machine.js';
+export declare function rememberStateProperty(property: Property, machine: StateMachine): void;
+export declare function isStateProperty(value: unknown): boolean;
+export declare function rememberStateClass(selected: object, properties?: Readonly<Record<string, unknown>>): void;
+export declare function rememberStateSchema(source: languageSchema.DomainSchema, input: DomainSchemaInput, domain: Domain): void;
+export declare function stateMachineFor(domain: Domain, selected: ResolvedProperty<unknown>): StateMachine | undefined;

package/dist/platform/schema/state-property/registry.js

@@ -0,0 +1,74 @@
+const propertyMachines = new WeakMap();
+const classProperties = new WeakMap();
+const schemaProperties = new WeakMap();
+export function rememberStateProperty(property, machine) {
+    propertyMachines.set(property, machine);
+}
+export function isStateProperty(value) {
+    return typeof value === 'object' && value !== null && propertyMachines.has(value);
+}
+export function rememberStateClass(selected, properties) {
+    const machines = new Map();
+    for (const [name, property] of Object.entries(properties ?? {})) {
+        if (typeof property !== 'object' || property === null)
+            continue;
+        const machine = propertyMachines.get(property);
+        if (machine !== undefined)
+            machines.set(name, machine);
+    }
+    classProperties.set(selected, machines);
+}
+export function rememberStateSchema(source, input, domain) {
+    const byKey = new Map();
+    for (const dependency of Object.values(input.dependencies ?? {})) {
+        const associated = schemaProperties.get(dependency);
+        if (associated === undefined)
+            continue;
+        for (const [key, machine] of associated.byKey)
+            bindKey(byKey, key, machine);
+    }
+    for (const [className, authored] of Object.entries(input.classes ?? {})) {
+        const machines = classProperties.get(authored);
+        if (machines === undefined || machines.size === 0)
+            continue;
+        const resolved = Reflect.get(domain.classes, className);
+        if (resolved === undefined)
+            continue;
+        for (const [propertyName, machine] of machines) {
+            const property = Reflect.get(resolved.self.properties, propertyName);
+            if (property !== undefined)
+                bindKey(byKey, property.key, machine);
+        }
+    }
+    const byProperty = new WeakMap();
+    bindDomainProperties(domain, byKey, byProperty, new Set());
+    schemaProperties.set(source, { byKey, byProperty });
+}
+export function stateMachineFor(domain, selected) {
+    const source = Reflect.get(domain, 'source');
+    if (typeof source !== 'object' || source === null)
+        return undefined;
+    return schemaProperties.get(source)?.byProperty.get(selected);
+}
+function bindKey(byKey, key, machine) {
+    const existing = byKey.get(key);
+    if (existing !== undefined && existing !== machine) {
+        throw new TypeError(`StateProperty ${key} has more than one StateMachine authority.`);
+    }
+    byKey.set(key, machine);
+}
+function bindDomainProperties(domain, byKey, byProperty, seen) {
+    if (seen.has(domain))
+        return;
+    seen.add(domain);
+    for (const definition of domain.definitions('class')) {
+        for (const property of definition.self.properties) {
+            const machine = byKey.get(property.key);
+            if (machine !== undefined)
+                byProperty.set(property, machine);
+        }
+    }
+    for (const dependency of Object.values(domain.dependencies)) {
+        bindDomainProperties(dependency, byKey, byProperty, seen);
+    }
+}