@astrale-os/sdk 0.5.0-beta.78 → 0.5.0-beta.79

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.5.0-beta.79](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.78...sdk-v0.5.0-beta.79) (2026-08-29)
+
+
+### Features
+
+* **state:** consume portable DSL topology ([#333](https://github.com/astrale-os/sdk/issues/333)) ([7f8e255](https://github.com/astrale-os/sdk/commit/7f8e25574f3409baa03ae6fa015ee906572a2aee))
+
+
+### Bug Fixes
+
+* **release:** require publishable public changes ([#335](https://github.com/astrale-os/sdk/issues/335)) ([46755ee](https://github.com/astrale-os/sdk/commit/46755ee9124ab01a9e72158da0126e96c9410774))
+
 ## [0.5.0-beta.78](https://github.com/astrale-os/sdk/compare/sdk-v0.5.0-beta.77...sdk-v0.5.0-beta.78) (2026-08-29)
 
 

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

@@ -1,12 +1,11 @@
 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 { Domain, ResolvedClass } from '../../../platform/schema/index.js';
-import type { EventOf, StateOf } from '../../state/machine.js';
+import type { ResolvedClass } from '@astrale-os/kernel-dsl/v1';
 import type { CreatedNode, ExistingEndpoint, MutationEndpoint } from './endpoint.js';
 import type { QueryPrecondition } from './precondition.js';
 import type { RichPropertyConditions, RichPropertyDelta, RichPropertyInput } from './properties.js';
-import { type StateMachineOf, type StatePropertyName, type StateTransitionInput } from './transition.js';
+import { type EventOfTopology, type StatePropertyName, type StatePropertyTopology, type StateOfTopology, type StateTransitionInput } from './transition.js';
 export interface RichMutationBuilder {
     readonly expect: {
         node<Class extends ResolvedClass<'node'>>(input: {
@@ -30,7 +29,7 @@ export interface RichMutationBuilder {
         readonly class: Class;
         readonly props: RichPropertyDelta<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;
+    transition<Class extends ResolvedClass<'node'>, Property extends StatePropertyName<Class>, From extends StateOfTopology<StatePropertyTopology<Class, Property>>, Event extends EventOfTopology<StatePropertyTopology<Class, Property>, From>>(input: StateTransitionInput<Class, Property, From, Event>): this;
     deleteNode<Class extends ResolvedClass<'node'>>(input: {
         readonly node: ExistingEndpoint;
         readonly class: Class;
@@ -53,4 +52,4 @@ export interface EdgeSelector<Class extends ResolvedClass<'edge'>> {
     readonly target: ExistingEndpoint;
     readonly class: Class;
 }
-export declare function richMutationBuilder(core: MutationBuilder, domain: Domain): RichMutationBuilder;
+export declare function richMutationBuilder(core: MutationBuilder): RichMutationBuilder;

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

@@ -4,7 +4,7 @@ import { endpoint, existingEndpoint } from './endpoint.js';
 import { precondition } from './precondition.js';
 import { conditions, delta, properties } from './properties.js';
 import { authorStateTransition, } from './transition.js';
-export function richMutationBuilder(core, domain) {
+export function richMutationBuilder(core) {
     const expectation = Object.freeze({
         node(input) {
             core.expect.node({
@@ -48,7 +48,7 @@ export function richMutationBuilder(core, domain) {
             return rich;
         },
         transition(input) {
-            authorStateTransition(core, domain, input);
+            authorStateTransition(core, input);
             return rich;
         },
         deleteNode(input) {

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

@@ -1,7 +1,7 @@
 import type { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
 import type { NodeId } from '@astrale-os/kernel-core/graph/node';
 import type { NodeTarget } from '@astrale-os/kernel-core/path';
-import type { ResolvedClass } from '../../../platform/schema/index.js';
+import type { ResolvedClass } from '@astrale-os/kernel-dsl/v1';
 export interface CreatedNode<Class extends ResolvedClass<'node'> = ResolvedClass<'node'>> {
     readonly created: LocalBinding;
     readonly class: Class;

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

@@ -1,5 +1,5 @@
 import type { MutationPropsInput } from '@astrale-os/kernel-core/graph/mutate';
-import type { PropertyInputOf, ResolvedClass, ResolvedProperty } from '../../../platform/schema/index.js';
+import type { PropertyInputOf, ResolvedClass, ResolvedProperty } from '@astrale-os/kernel-dsl/v1';
 export type RichPropertyInput<Class> = PropertyInputOf<Class>;
 export type RichPropertyName<Class> = Extract<keyof PropertyInputOf<Class>, string>;
 export interface RichPropertyConditions<Class> {
@@ -12,11 +12,11 @@ export interface RichPropertyDelta<Class> {
 }
 export declare function properties<Class extends ResolvedClass>(selected: Class, input: RichPropertyInput<Class>): MutationPropsInput;
 export declare function conditions<Class extends ResolvedClass>(selected: Class, input: RichPropertyConditions<Class>): Readonly<{
-    equals?: Readonly<Record<`${string}:class.${string}.property.${string}`, import("../../../platform/schema/index.js").Value>> | undefined;
+    equals?: Readonly<Record<`${string}:class.${string}.property.${string}`, import("@astrale-os/kernel-dsl/value").Value>> | undefined;
     absent?: readonly `${string}:class.${string}.property.${string}`[] | undefined;
 }>;
 export declare function delta<Class extends ResolvedClass>(selected: Class, input: RichPropertyDelta<Class>): Readonly<{
-    set: Readonly<Record<`${string}:class.${string}.property.${string}`, import("../../../platform/schema/index.js").Value>>;
+    set: Readonly<Record<`${string}:class.${string}.property.${string}`, import("@astrale-os/kernel-dsl/value").Value>>;
     unset: readonly `${string}:class.${string}.property.${string}`[];
 }>;
 export declare function resolvedProperty<Class extends ResolvedClass>(selected: Class, name: RichPropertyName<Class>): ResolvedProperty;

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

@@ -1,12 +1,18 @@
 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 { ResolvedClass, ResolvedProperty } from '@astrale-os/kernel-dsl/v1';
+import type { StateTopology } from '@astrale-os/kernel-dsl/v1/language/state';
 import type { ExistingEndpoint } from './endpoint.js';
 import type { RichPropertyConditions, RichPropertyDelta, 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>> {
+type PropertyEntry<Class extends ResolvedClass<'node'>> = Class['properties']['byKey'][keyof Class['properties']['byKey']];
+type TopologyOfProperty<Property> = Property extends ResolvedProperty<unknown, boolean, infer Topology extends StateTopology | undefined> ? Extract<Topology, StateTopology> : never;
+type StatePropertyEntry<Property> = Property extends ResolvedProperty ? [TopologyOfProperty<Property>] extends [never] ? never : Property : never;
+export type StatePropertyName<Class extends ResolvedClass<'node'>> = Extract<StatePropertyEntry<PropertyEntry<Class>>['name'], RichPropertyName<Class>>;
+export type StatePropertyTopology<Class extends ResolvedClass<'node'>, Property extends StatePropertyName<Class>> = TopologyOfProperty<Extract<StatePropertyEntry<PropertyEntry<Class>>, {
+    readonly name: Property;
+}>>;
+export type StateOfTopology<Topology extends StateTopology> = Extract<keyof Topology['transitions'], string>;
+export type EventOfTopology<Topology extends StateTopology, State extends StateOfTopology<Topology>> = State extends StateOfTopology<Topology> ? Extract<keyof Topology['transitions'][State], string> : never;
+export interface StateTransitionInput<Class extends ResolvedClass<'node'>, Property extends StatePropertyName<Class>, From extends StateOfTopology<StatePropertyTopology<Class, Property>>, Event extends EventOfTopology<StatePropertyTopology<Class, Property>, From>> {
     readonly node: ExistingEndpoint;
     readonly class: Class;
     readonly property: Property;
@@ -16,4 +22,5 @@ export interface StateTransitionInput<Class extends ResolvedClass<'node'>, Prope
     /** Auxiliary property changes committed in the same compare-and-set as the state transition. */
     readonly update?: RichPropertyDelta<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;
+export declare function authorStateTransition<Class extends ResolvedClass<'node'>, Property extends StatePropertyName<Class>, From extends StateOfTopology<StatePropertyTopology<Class, Property>>, Event extends EventOfTopology<StatePropertyTopology<Class, Property>, From>>(core: MutationBuilder, input: StateTransitionInput<Class, Property, From, Event>): void;
+export {};

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

@@ -1,9 +1,8 @@
 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) {
+export function authorStateTransition(core, input) {
     const node = existingEndpoint(input.node);
     const selectedClass = input.class;
     const property = input.property;
@@ -21,15 +20,22 @@ export function authorStateTransition(core, domain, input) {
     const suppliedUnset = unset === undefined ? undefined : [...unset];
     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 topology = selected.definition.state;
+    if (topology === undefined) {
+        throw new TypeError(`State transition requires StateProperty ${selectedClassKey}.${String(property)} on the selected Class.`);
     }
-    const decision = machine.decide(fromState, event);
-    if (decision.kind === 'rejected')
-        throw stateTransitionFailure(decision.from, decision.event);
+    if (typeof fromState !== 'string' || !Object.hasOwn(topology.transitions, fromState)) {
+        throw new TypeError(`State machine does not declare state "${String(fromState)}".`);
+    }
+    if (typeof event !== 'string' ||
+        !Object.values(topology.transitions).some((events) => Object.hasOwn(events, event))) {
+        throw new TypeError(`State machine does not declare event "${String(event)}".`);
+    }
+    const target = topology.transitions[fromState]?.[event];
+    if (target === undefined)
+        throw stateTransitionFailure(fromState, event);
     const from = { [property]: fromState };
-    const to = { [property]: decision.transition.to };
+    const to = { [property]: target };
     if ((suppliedEquals !== undefined &&
         Object.hasOwn(suppliedEquals, property) &&
         suppliedEquals[property] !== fromState) ||

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

@@ -1,9 +1,8 @@
 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>;
+type AuthoringDomainOf<Schema extends schema.DomainSchema> = ResolvedDomainOf<Schema>;
 interface MutationProjector<Schema extends schema.DomainSchema> {
     <Input, Output = MutationResult>(project: (domain: AuthoringDomainOf<Schema>) => MutationDefinition<Input, Output>): Mutation<ResolvedDomainOf<Schema>, Input, Output>;
 }

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, domain)));
+        const ast = MutationAST.build((builder) => operation.build(input, richMutationBuilder(builder)));
         return projectMutation(operation, await client.mutate(ast, { expected: domain.closure }), input);
     }
     catch (cause) {

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

@@ -1,2 +1,2 @@
-export { stateMachine } from './define.js';
-export type { EventOf, InitialStateOf, NextStateOf, StateMachine, StateOf, TerminalStateOf, TransitionDecision, TransitionOf, } from './machine.js';
+export { stateMachine } from '@astrale-os/kernel-dsl/v1/language/state';
+export type { StateMachine, StateTopology, StateOf, EventOf, } from '@astrale-os/kernel-dsl/v1/language/state';

package/dist/application/state/index.js

@@ -1 +1 @@
-export { stateMachine } from './define.js';
+export { stateMachine } from '@astrale-os/kernel-dsl/v1/language/state';

package/dist/deployment/build/material.d.ts

@@ -1,6 +1,5 @@
 import type { DomainSchema } from '@astrale-os/kernel-dsl/v1/schema';
 import type { Runtime } from '../../application/runtime/index.js';
-import type { StatePropertyMaterial } from '../../platform/schema/state-property/material.js';
 import type { Build } from './build.js';
 import type { FrontendCompilation } from './frontend/index.js';
 export interface BuildMaterial {
@@ -14,7 +13,6 @@ export interface BuildMaterial {
         };
     };
     readonly callables: Build['callables'];
-    readonly stateProperties: readonly StatePropertyMaterial[];
     readonly requirements: Build['requirements'];
     readonly routes: Build['routes'];
     readonly frontend?: FrontendCompilation;

package/dist/deployment/build/material.js

@@ -8,18 +8,13 @@ import { BUNDLE_MEDIA_TYPE } from '@astrale-os/kernel-protocol/publication/bundl
 import { admitRequirements, validateRequirements, } from '@astrale-os/kernel-protocol/publication/requirements';
 import * as routes from '@astrale-os/kernel-protocol/routes';
 import { admitRuntimeRegistry, isRuntime } from '../../application/runtime/index.js';
-import { restoreStatePropertyMaterial, statePropertyMaterial, } from '../../platform/schema/state-property/material.js';
 import { admitBuild, isBuild } from './admission.js';
-import { evidenceOf } from './admission.js';
-const runtimeStateProperties = new WeakMap();
 /** Detach the provider-neutral, runtime-free material embedded into generated execution code. */
 export function material(build) {
     if (!isBuild(build))
         throw new TypeError('Build material requires an admitted Build.');
     if (!isRuntime(build.runtime))
         throw new TypeError('Build Runtime is not admitted.');
-    const stateProperties = statePropertyMaterial(evidenceOf(build).domain);
-    bindRuntimeStateProperties(build.runtime, build.schema.bundle.ref.digest, stateProperties);
     return Object.freeze({
         format: 'astrale.sdk.build-material',
         version: 1,
@@ -31,7 +26,6 @@ export function material(build) {
             }),
         }),
         callables: build.callables,
-        stateProperties,
         requirements: build.requirements,
         routes: build.routes,
         ...(build.frontend === undefined ? {} : { frontend: build.frontend }),
@@ -61,9 +55,6 @@ export function restoreBuild(input, runtime) {
         revision(decoded.root) !== input.schema.compiled.root.revision) {
         invalid();
     }
-    const stateProperties = snapshotStateProperties(input.stateProperties);
-    assertRuntimeStateProperties(runtime, input.schema.bundle.ref.digest, stateProperties);
-    restoreStatePropertyMaterial(domain, stateProperties);
     const registry = bindRuntime(domain, runtime, input.callables);
     const requirements = admitRequirements(input.requirements);
     validateRequirements(decoded.root, decoded.closure, requirements);
@@ -99,9 +90,6 @@ export function restoreGeneratedBuild(input, runtime) {
     const generated = acceptGeneratedMaterial(input, runtime);
     const material = generated.material;
     const domain = loadGeneratedSchema(material.schema.compiled);
-    const stateProperties = snapshotStateProperties(material.stateProperties);
-    restoreStatePropertyMaterial(domain, stateProperties);
-    bindRuntimeStateProperties(runtime, material.schema.bundle.ref.digest, stateProperties);
     const registry = bindRuntime(domain, runtime, material.callables);
     const detached = Uint8Array.from(material.schema.bundle.bytes);
     const build = Object.freeze({
@@ -148,43 +136,6 @@ function digestOf(input) {
         invalid();
     }
 }
-function bindRuntimeStateProperties(runtime, bundleDigest, stateProperties) {
-    const digest = statePropertyDigest(stateProperties);
-    const bindings = runtimeStateProperties.get(runtime) ?? new Map();
-    const existing = bindings.get(bundleDigest);
-    if (existing !== undefined && existing !== digest) {
-        throw new TypeError('Runtime has conflicting StateProperty authority for Build material.');
-    }
-    bindings.set(bundleDigest, digest);
-    runtimeStateProperties.set(runtime, bindings);
-}
-function assertRuntimeStateProperties(runtime, bundleDigest, stateProperties) {
-    const expected = runtimeStateProperties.get(runtime)?.get(bundleDigest);
-    if (expected === undefined) {
-        if (stateProperties.length === 0)
-            return;
-        throw new TypeError('Build StateProperty authority is not bound to its exact Runtime.');
-    }
-    if (statePropertyDigest(stateProperties) !== expected) {
-        throw new TypeError('Build StateProperty authority differs from its exact Runtime.');
-    }
-}
-function statePropertyDigest(input) {
-    try {
-        return artifact.identify(new TextEncoder().encode(JSON.stringify(input)), 'application/vnd.astrale.sdk.state-properties+json').digest;
-    }
-    catch {
-        invalid();
-    }
-}
-function snapshotStateProperties(input) {
-    try {
-        return deepFreeze(JSON.parse(JSON.stringify(input)));
-    }
-    catch {
-        invalid();
-    }
-}
 function assertMaterialEnvelope(input, runtime) {
     if (!isRuntime(runtime))
         throw new TypeError('Build Runtime is not admitted.');
@@ -197,7 +148,6 @@ function assertMaterialEnvelope(input, runtime) {
             key !== 'version' &&
             key !== 'schema' &&
             key !== 'callables' &&
-            key !== 'stateProperties' &&
             key !== 'requirements' &&
             key !== 'routes' &&
             key !== 'frontend')) {

package/dist/index.d.ts

@@ -11,8 +11,6 @@ export { defineCollectionQuery, defineCompositeQuery, defineQuery, executeQuery,
 export type { CollectionQueryDefinition, QueryDefinition, QueryFailure, } from './application/query/index.js';
 export { defineRuntime } from './application/runtime/index.js';
 export type { Runtime } from './application/runtime/index.js';
-export { stateMachine } from './application/state/index.js';
-export type { EventOf, StateMachine, StateOf, TransitionOf } from './application/state/index.js';
 export { defineWorkflow } from './application/workflow/index.js';
 export type { Workflow, WorkflowContext } from './application/workflow/index.js';
 export { compile, deploy, runtime } from './deployment/index.js';

package/dist/index.js

@@ -5,7 +5,6 @@ export { defineIntegration, defineProvider } from './application/integration/ind
 export { defineMutation, executeMutation } from './application/mutation/index.js';
 export { defineCollectionQuery, defineCompositeQuery, defineQuery, executeQuery, } from './application/query/index.js';
 export { defineRuntime } from './application/runtime/index.js';
-export { stateMachine } from './application/state/index.js';
 export { defineWorkflow } from './application/workflow/index.js';
 export { compile, deploy, runtime } from './deployment/index.js';
 export { serve } from './execution/index.js';

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

@@ -1,6 +1,4 @@
 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,7 +1,6 @@
 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/tooling/linter/implementations/source/state-machine.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import { resolveImportedSymbol, resolveProjectImport, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
-const STATE_MODULES = new Set(['@astrale-os/sdk', '@astrale-os/sdk/state']);
+const STATE_MODULES = new Set(['@astrale-os/sdk/state']);
 const SCHEMA_MODULES = new Set([
     '@astrale-os/sdk',
     '@astrale-os/sdk/schema',

package/dist/tooling/linter/implementations/source/states.js

@@ -2,7 +2,7 @@ import ts from 'typescript';
 import { resolveImportedSymbol, resolveProjectImport, staticText, unwrap, visit, } from '../../adapters/typescript/index.js';
 import { ambiguity, forbiddenIoImport, hasForbiddenGlobalCall, production, violation, } from './shared.js';
 import { machineExportStatus, stateMachineConstructorOrigin } from './state-machine.js';
-const STATE_MODULES = new Set(['@astrale-os/sdk', '@astrale-os/sdk/state']);
+const STATE_MODULES = new Set(['@astrale-os/sdk/state']);
 const FORBIDDEN_LAYERS = new Set([
     'actions',
     'integrations',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/sdk",
-  "version": "0.5.0-beta.78",
+  "version": "0.5.0-beta.79",
   "description": "Schema-first SDK for defining, composing, and deploying Astrale domains",
   "keywords": [
     "astrale",
@@ -217,11 +217,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/kernel-client": "0.6.0-beta.30",
-    "@astrale-os/kernel-core": "0.9.0-beta.23",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.17",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.24",
-    "@astrale-os/kernel-server": "0.5.0-beta.26",
+    "@astrale-os/kernel-client": "0.6.0-beta.32",
+    "@astrale-os/kernel-core": "0.9.0-beta.25",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.18",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.26",
+    "@astrale-os/kernel-server": "0.5.0-beta.28",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "hono": "^4.13.2",
     "jose": "^6.2.9",

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

@@ -1,3 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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.d.ts

@@ -1,6 +0,0 @@
-import type { StateMachine } from './machine.js';
-import type { StateName, TransitionRelation, ValidTransitionRelation } from './relation.js';
-export declare function stateMachine<const Transitions extends TransitionRelation, const Initial extends StateName<Transitions>>(input: Readonly<{
-    initial: Initial;
-    transitions: Transitions & ValidTransitionRelation<Transitions>;
-}>): StateMachine<Transitions, Initial>;

package/dist/application/state/define.js

@@ -1,54 +0,0 @@
-import { z } from 'zod';
-import { rememberStateMachine } from './authority.js';
-import { relation } from './relation.js';
-export function stateMachine(input) {
-    const admitted = relation(input);
-    const states = admitted.states;
-    const events = admitted.events;
-    const transitions = states.flatMap((from) => Object.entries(admitted.transitions[from]).map(([event, to]) => Object.freeze({ from, event, to })));
-    const terminalStates = states.filter((state) => Object.keys(admitted.transitions[state]).length === 0);
-    const stateSchema = z.enum(states);
-    const eventSchema = z.enum(events);
-    const stateSet = new Set(states);
-    const eventSet = new Set(events);
-    const machine = Object.freeze({
-        initial: admitted.initial,
-        stateSchema,
-        eventSchema,
-        states: Object.freeze(states),
-        events: Object.freeze(events),
-        terminalStates: Object.freeze(terminalStates),
-        transitions: Object.freeze(transitions),
-        eventsFrom(state) {
-            admitState(state, stateSet);
-            return Object.freeze(Object.keys(admitted.transitions[state]));
-        },
-        decide(state, event) {
-            admitState(state, stateSet);
-            admitEvent(event, eventSet);
-            const target = admitted.transitions[state][event];
-            if (target === undefined) {
-                return Object.freeze({
-                    kind: 'rejected',
-                    code: 'STATE_TRANSITION_ILLEGAL',
-                    from: state,
-                    event,
-                });
-            }
-            return Object.freeze({
-                kind: 'allowed',
-                transition: Object.freeze({ from: state, event, to: target }),
-            });
-        },
-    });
-    rememberStateMachine(machine);
-    return machine;
-}
-function admitState(state, states) {
-    if (!states.has(state))
-        throw new TypeError(`State machine does not declare state "${state}".`);
-}
-function admitEvent(event, events) {
-    if (!events.has(event))
-        throw new TypeError(`State machine does not declare event "${event}".`);
-}

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

@@ -1,55 +0,0 @@
-import type { z } from 'zod';
-import type { EventName, StateName, TransitionRelation } from './relation.js';
-import type { TransitionDecisionFor, TransitionWitness } from './transition.js';
-declare const stateMachineAuthority: unique symbol;
-export interface StateMachine<Transitions extends TransitionRelation = any, Initial extends StateName<Transitions> = StateName<Transitions>> extends StateMachineShape {
-    /** Constructor provenance; not a runtime or portable field. */
-    readonly [stateMachineAuthority]: void;
-    readonly initial: Initial;
-    readonly stateSchema: z.ZodType<StateName<Transitions>>;
-    readonly eventSchema: z.ZodType<EventName<Transitions>>;
-    readonly states: readonly StateName<Transitions>[];
-    readonly events: readonly EventName<Transitions>[];
-    readonly terminalStates: readonly TerminalState<Transitions>[];
-    readonly transitions: readonly TransitionWitness<Transitions>[];
-    eventsFrom<State extends StateName<Transitions>>(state: State): readonly EventName<Transitions, State>[];
-    decide<State extends StateName<Transitions>, Event extends EventName<Transitions>>(state: State, event: Event): TransitionDecisionFor<Transitions, State, Event>;
-}
-interface StateMachineShape {
-    readonly initial: string;
-    readonly states: readonly string[];
-    readonly events: readonly string[];
-    readonly terminalStates: readonly string[];
-    readonly transitions: readonly Readonly<{
-        from: string;
-        event: string;
-        to: string;
-    }>[];
-}
-export type StateOf<Machine extends StateMachine> = Machine['states'][number];
-export type EventOf<Machine extends StateMachine, State extends StateOf<Machine> = StateOf<Machine>> = Extract<TransitionOf<Machine>, {
-    readonly from: State;
-}>['event'];
-export type NextStateOf<Machine extends StateMachine, State extends StateOf<Machine>, Event extends EventOf<Machine, State>> = Extract<TransitionOf<Machine>, {
-    readonly from: State;
-    readonly event: Event;
-}>['to'];
-export type InitialStateOf<Machine extends StateMachine> = Machine['initial'];
-export type TerminalStateOf<Machine extends StateMachine> = Machine['terminalStates'][number];
-export type TransitionOf<Machine extends StateMachine> = Machine['transitions'][number];
-export type TransitionDecision<Machine extends StateMachine, State extends StateOf<Machine>, Event extends Machine['events'][number]> = State extends StateOf<Machine> ? Event extends Machine['events'][number] ? Extract<TransitionOf<Machine>, {
-    readonly from: State;
-    readonly event: Event;
-}> extends infer Transition ? [Transition] extends [never] ? Readonly<{
-    kind: 'rejected';
-    code: 'STATE_TRANSITION_ILLEGAL';
-    from: State;
-    event: Event;
-}> : Readonly<{
-    kind: 'allowed';
-    transition: Transition;
-}> : never : never : never;
-type TerminalState<Transitions extends TransitionRelation> = {
-    [State in StateName<Transitions>]: EventName<Transitions, State> extends never ? State : never;
-}[StateName<Transitions>];
-export {};

package/dist/application/state/machine.js

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

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

@@ -1,15 +0,0 @@
-export type TransitionRelation = Readonly<Record<string, Readonly<Record<string, string>>>>;
-export type StateName<Transitions extends TransitionRelation> = Extract<keyof Transitions, string>;
-export type EventName<Transitions extends TransitionRelation, State extends StateName<Transitions> = StateName<Transitions>> = State extends StateName<Transitions> ? Extract<keyof Transitions[State], string> : never;
-export type ValidTransitionRelation<Transitions extends TransitionRelation> = Readonly<{
-    [State in StateName<Transitions>]: Readonly<{
-        [Event in keyof Transitions[State]]: Exclude<StateName<Transitions>, State>;
-    }>;
-}>;
-export interface StateRelation {
-    readonly initial: string;
-    readonly transitions: Readonly<Record<string, Readonly<Record<string, string>>>>;
-    readonly states: readonly string[];
-    readonly events: readonly string[];
-}
-export declare function relation(input: unknown): StateRelation;

package/dist/application/state/relation.js

@@ -1,82 +0,0 @@
-export function relation(input) {
-    if (!isRecord(input) || !exactKeys(input, ['initial', 'transitions']))
-        invalidInput();
-    const initial = input.initial;
-    const authored = input.transitions;
-    if (typeof initial !== 'string' || initial.length === 0 || !isRecord(authored))
-        invalidInput();
-    const states = Object.keys(authored);
-    if (states.length === 0) {
-        throw new TypeError('State machine requires at least one state.');
-    }
-    if (states.includes('')) {
-        throw new TypeError('State machine has an empty state name.');
-    }
-    if (!states.includes(initial)) {
-        throw new TypeError(`State machine initial state "${initial}" is not declared.`);
-    }
-    const stateSet = new Set(states);
-    const events = new Set();
-    const transitions = Object.create(null);
-    let transitionCount = 0;
-    for (const state of states) {
-        const outgoing = authored[state];
-        if (!isRecord(outgoing)) {
-            throw new TypeError(`State "${state}" transitions must be an object.`);
-        }
-        const accepted = Object.create(null);
-        for (const [event, target] of Object.entries(outgoing)) {
-            if (event.length === 0) {
-                throw new TypeError(`State "${state}" has an empty event name.`);
-            }
-            if (typeof target !== 'string' || !stateSet.has(target)) {
-                throw new TypeError(`State "${state}" event "${event}" targets undeclared state "${String(target)}".`);
-            }
-            if (target === state) {
-                throw new TypeError(`State "${state}" event "${event}" is a self-transition.`);
-            }
-            events.add(event);
-            accepted[event] = target;
-            transitionCount += 1;
-        }
-        transitions[state] = Object.freeze(accepted);
-    }
-    if (transitionCount === 0) {
-        throw new TypeError('State machine requires at least one transition event.');
-    }
-    const reachable = new Set([initial]);
-    const pending = [initial];
-    while (pending.length > 0) {
-        const state = pending.shift();
-        for (const target of Object.values(transitions[state])) {
-            if (reachable.has(target))
-                continue;
-            reachable.add(target);
-            pending.push(target);
-        }
-    }
-    for (const state of states) {
-        if (!reachable.has(state)) {
-            throw new TypeError(`State "${state}" is unreachable from initial "${initial}".`);
-        }
-    }
-    return Object.freeze({
-        initial,
-        transitions: Object.freeze(transitions),
-        states: Object.freeze(states),
-        events: Object.freeze([...events].sort(compareText)),
-    });
-}
-function invalidInput() {
-    throw new TypeError('State machine input must contain exactly initial and transitions.');
-}
-function isRecord(input) {
-    return input !== null && typeof input === 'object' && !Array.isArray(input);
-}
-function exactKeys(input, expected) {
-    const keys = Reflect.ownKeys(input);
-    return keys.length === expected.length && keys.every((key) => expected.includes(String(key)));
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

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

@@ -1,22 +0,0 @@
-import type { EventName, StateName, TransitionRelation } from './relation.js';
-export type TransitionWitness<Transitions extends TransitionRelation> = {
-    [State in StateName<Transitions>]: {
-        [Event in EventName<Transitions, State>]: Readonly<{
-            from: State;
-            event: Event;
-            to: Extract<Transitions[State][Event], StateName<Transitions>>;
-        }>;
-    }[EventName<Transitions, State>];
-}[StateName<Transitions>];
-export type TransitionDecisionFor<Transitions extends TransitionRelation, State extends StateName<Transitions>, Event extends EventName<Transitions>> = State extends StateName<Transitions> ? Event extends EventName<Transitions> ? Extract<TransitionWitness<Transitions>, {
-    readonly from: State;
-    readonly event: Event;
-}> extends infer Transition ? [Transition] extends [never] ? Readonly<{
-    kind: 'rejected';
-    code: 'STATE_TRANSITION_ILLEGAL';
-    from: State;
-    event: Event;
-}> : Readonly<{
-    kind: 'allowed';
-    transition: Transition;
-}> : never : never : never;

package/dist/application/state/transition.js

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

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

@@ -1,14 +0,0 @@
-import type { DefinedSchema, NodeClassInput, 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 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

@@ -1,49 +0,0 @@
-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 !== 'description'))) {
-        throw new TypeError('stateProperty options are 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

@@ -1,16 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

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

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

@@ -1,16 +0,0 @@
-import type { Domain } from '@astrale-os/kernel-dsl/v1';
-import type { PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
-export interface StatePropertyMaterial {
-    readonly property: PropertyKey;
-    readonly initial: string;
-    readonly states: readonly string[];
-    readonly transitions: readonly Readonly<{
-        from: string;
-        event: string;
-        to: string;
-    }>[];
-}
-/** Capture only the portable StateProperty authority required by generated execution. */
-export declare function statePropertyMaterial(domain: Domain): readonly StatePropertyMaterial[];
-/** Restore portable StateProperty authority onto an exact compiled Domain. */
-export declare function restoreStatePropertyMaterial(domain: Domain, input: unknown): void;

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

@@ -1,118 +0,0 @@
-import { stateMachine } from '../../../application/state/define.js';
-import { rememberResolvedStateProperties, stateMachineFor } from './registry.js';
-/** Capture only the portable StateProperty authority required by generated execution. */
-export function statePropertyMaterial(domain) {
-    const material = [];
-    for (const property of ownProperties(domain)) {
-        const machine = stateMachineFor(domain, property);
-        if (machine === undefined)
-            continue;
-        material.push(Object.freeze({
-            property: property.key,
-            initial: machine.initial,
-            states: Object.freeze([...machine.states]),
-            transitions: Object.freeze(machine.transitions.map((transition) => Object.freeze({ ...transition }))),
-        }));
-    }
-    return Object.freeze(material.sort((left, right) => compareText(left.property, right.property)));
-}
-/** Restore portable StateProperty authority onto an exact compiled Domain. */
-export function restoreStatePropertyMaterial(domain, input) {
-    if (!Array.isArray(input))
-        invalid();
-    const byKey = new Map();
-    const properties = new Map(ownProperties(domain).map((property) => [property.key, property]));
-    for (const candidate of input) {
-        if (!isRecord(candidate) ||
-            !exactKeys(candidate, ['property', 'initial', 'states', 'transitions'])) {
-            invalid();
-        }
-        const propertyKey = candidate.property;
-        const initial = candidate.initial;
-        const states = candidate.states;
-        const transitions = candidate.transitions;
-        if (typeof propertyKey !== 'string' ||
-            typeof initial !== 'string' ||
-            !Array.isArray(states) ||
-            states.some((state) => typeof state !== 'string') ||
-            !Array.isArray(transitions)) {
-            invalid();
-        }
-        const property = properties.get(propertyKey);
-        if (property === undefined || byKey.has(property.key))
-            invalid();
-        assertStateProperty(property, states);
-        const relation = Object.create(null);
-        for (const state of states)
-            relation[state] = Object.create(null);
-        for (const transition of transitions) {
-            if (!isRecord(transition) || !exactKeys(transition, ['from', 'event', 'to']))
-                invalid();
-            const { from, event, to } = transition;
-            if (typeof from !== 'string' ||
-                typeof event !== 'string' ||
-                typeof to !== 'string' ||
-                relation[from] === undefined ||
-                Object.hasOwn(relation[from], event)) {
-                invalid();
-            }
-            relation[from][event] = to;
-        }
-        const machine = Reflect.apply(stateMachine, undefined, [
-            { initial, transitions: relation },
-        ]);
-        if (!sameStrings(machine.states, states))
-            invalid();
-        byKey.set(property.key, machine);
-    }
-    rememberResolvedStateProperties(domain, byKey);
-}
-function ownProperties(domain) {
-    const properties = [];
-    const seen = new Set();
-    const visit = (selected) => {
-        if (seen.has(selected))
-            return;
-        seen.add(selected);
-        for (const definition of selected.definitions('class')) {
-            properties.push(...definition.self.properties);
-        }
-        for (const dependency of Object.values(selected.dependencies))
-            visit(dependency);
-    };
-    visit(domain);
-    return properties;
-}
-function assertStateProperty(property, states) {
-    const schema = property.definition.schema;
-    if (property.owner.kind !== 'node' ||
-        property.definition.required !== true ||
-        !isRecord(schema) ||
-        schema.type !== 'string' ||
-        !Array.isArray(schema.enum) ||
-        schema.enum.some((state) => typeof state !== 'string') ||
-        !sameStringSet(schema.enum, states)) {
-        invalid();
-    }
-}
-function sameStrings(left, right) {
-    return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-function sameStringSet(left, right) {
-    if (new Set(left).size !== left.length || new Set(right).size !== right.length)
-        return false;
-    return sameStrings([...left].sort(compareText), [...right].sort(compareText));
-}
-function isRecord(input) {
-    return input !== null && typeof input === 'object' && !Array.isArray(input);
-}
-function exactKeys(input, expected) {
-    const keys = Reflect.ownKeys(input);
-    return keys.length === expected.length && keys.every((key) => expected.includes(String(key)));
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function invalid() {
-    throw new TypeError('StateProperty material is invalid.');
-}

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

@@ -1,49 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-import type { Domain, ResolvedProperty } from '@astrale-os/kernel-dsl/v1';
-import type { PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
-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;
-/** Internal restoration seam for generated execution material. */
-export declare function rememberResolvedStateProperties(domain: Domain, byKey: ReadonlyMap<PropertyKey, StateMachine>): void;

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

@@ -1,85 +0,0 @@
-const propertyMachines = new WeakMap();
-const classProperties = new WeakMap();
-const schemaProperties = new WeakMap();
-const domainProperties = 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 });
-    domainProperties.set(domain, byProperty);
-}
-export function stateMachineFor(domain, selected) {
-    const retained = domainProperties.get(domain)?.get(selected);
-    if (retained !== undefined)
-        return retained;
-    const source = Reflect.get(domain, 'source');
-    if (typeof source !== 'object' || source === null)
-        return undefined;
-    return schemaProperties.get(source)?.byProperty.get(selected);
-}
-/** Internal restoration seam for generated execution material. */
-export function rememberResolvedStateProperties(domain, byKey) {
-    const byProperty = new WeakMap();
-    bindDomainProperties(domain, byKey, byProperty, new Set());
-    domainProperties.set(domain, byProperty);
-}
-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);
-    }
-}