@typeonce/effect-machine 0.3.0 → 0.5.0

package/dist/Machine.d.ts

@@ -1,34 +1,38 @@
 /**
  * Schema-first machine definitions.
  *
- * @since 4.0.0
+ * @since 0.4.0
  */
 import type * as Cause from "effect/Cause";
 import type * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import { type Pipeable } from "effect/Pipeable";
+import type * as Effect from "effect/Effect";
+import type * as Option from "effect/Option";
+import type { Pipeable } from "effect/Pipeable";
 import type * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
 import type * as Stream from "effect/Stream";
 import type * as Types from "effect/Types";
-import type { ChildAlreadyExistsError, InfiniteTransitionError, MachineSchemaDecodeError, MachineSchemaEncodeError, ProcessLocalError, StartupError, StoppedError } from "./internal/machineErrors.js";
-import * as Model from "./internal/machineModel.js";
-import * as internalPlanner from "./internal/machinePlanner.js";
-import * as internalRuntime from "./internal/machineRuntime.js";
+import type * as Activities from "./internal/machine/activities.js";
+import type { ChildAlreadyExistsError, InfiniteTransitionError, MachineSchemaDecodeError, MachineSchemaEncodeError, StartupError, StoppedError } from "./internal/machine/machine.js";
+import * as internal from "./internal/machine/machine.js";
+import { InitialEventTypeId } from "./internal/machine/machine.js";
+import type { EnsureExecutable } from "./internal/machine/readiness.js";
+import type * as internalRuntime from "./internal/machine/runtime.js";
+import type * as StateDefinition from "./internal/machine/stateDefinition.js";
+import type * as Topology from "./internal/machine/topology.js";
 /**
  * String literal type used as the runtime type identifier for `Machine`
  * values.
  *
  * @category type IDs
- * @since 4.0.0
+ * @since 0.4.0
  */
 export type TypeId = "~effect/Machine";
 /**
  * Runtime type identifier attached to `Machine` values.
  *
  * @category type IDs
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const TypeId: TypeId;
 declare const MachineOutputStatesTypeId: unique symbol;
@@ -38,15 +42,15 @@ declare const MachineTypeId: unique symbol;
  * actions.
  *
  * @category type IDs
- * @since 4.0.0
+ * @since 0.4.0
  */
-export declare const InitialEventTypeId: typeof internalPlanner.InitialEventTypeId;
+export { InitialEventTypeId };
 /**
  * Synthetic event passed to entry, exit, always, invoke, and output callbacks
  * that run while the machine is settling its initial state.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export interface InitialEvent {
     readonly _tag: typeof InitialEventTypeId;
@@ -55,14 +59,14 @@ export interface InitialEvent {
  * Synthetic event value used while the machine settles its initial state.
  *
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const InitialEvent: InitialEvent;
 /**
  * Returns `true` if a value is the synthetic machine initial event.
  *
  * @category guards
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const isInitialEvent: (u: unknown) => u is InitialEvent;
 type IsAny<A> = 0 extends (1 & A) ? true : false;
@@ -84,7 +88,7 @@ type IsAny<A> = 0 extends (1 & A) ? true : false;
  * flow. Use `after` for cancellable state-scoped delayed events.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export interface Machine<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events> extends Pipeable {
     readonly [TypeId]: TypeId;
@@ -95,51 +99,54 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
     /**
      * State tree that defines the machine topology and state value schemas.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly states: States;
     /**
      * Events accepted through public machine input boundaries.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly events: InputEvents;
     /**
      * Events reserved for invokes, child emissions, and other machine-local work.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly internalEvents: ReadonlyArray<Machine.TaggedSchema>;
     /**
      * Events that the machine may emit to its parent or external adapter.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly emits: Emits;
     /**
      * Optional schema used to decode the machine input before initialization.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly input: Input | undefined;
     /**
      * Optional stable identity used by runtime and persistence integrations.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly id: string | undefined;
     /** @internal */
     readonly stateNodes: Machine.StateNodes;
     /** @internal */
-    readonly makeTargetBuilder: <Source extends Machine.StateIdentifier<States>>(source: Source) => Machine.TargetBuilder<States, Source>;
+    readonly makeTargetBuilder: <Source extends Machine.StateNodeIdentifier<States>>(source: Source) => Machine.TargetBuilder<States, Source>;
     /** @internal */
     readonly handlers: Machine.StateConfigs<States, Events, Emits, UnhandledStates, Machine.TagOf<Events[number]>, E, R>;
     /**
      * Adds typed state handlers and returns the refined machine definition.
      * Successive calls implement the remaining unhandled states while retaining
      * accumulated errors, services, final states, and output evidence.
+     * Event dispatch maps and transition descriptors are captured by value, so
+     * later mutation of the objects supplied to this call cannot alter the
+     * resulting machine.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly handle: Machine.Handler<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents>;
     /** @internal */
@@ -151,7 +158,7 @@ export {
  * exists for the current machine.
  *
  * @category errors
- * @since 4.0.0
+ * @since 0.4.0
  */
 ChildAlreadyExistsError, 
 /**
@@ -159,7 +166,7 @@ ChildAlreadyExistsError,
  * number of macrostep iterations.
  *
  * @category errors
- * @since 4.0.0
+ * @since 0.4.0
  */
 InfiniteTransitionError, 
 /**
@@ -167,7 +174,7 @@ InfiniteTransitionError,
  * structural configuration declared for a machine boundary.
  *
  * @category errors
- * @since 4.0.0
+ * @since 0.4.0
  */
 MachineSchemaDecodeError, 
 /**
@@ -175,7 +182,7 @@ MachineSchemaDecodeError,
  * its declared state or output schemas.
  *
  * @category errors
- * @since 4.0.0
+ * @since 0.4.0
  */
 MachineSchemaEncodeError, 
 /**
@@ -183,7 +190,7 @@ MachineSchemaEncodeError,
  * requires a managed machine process.
  *
  * @category errors
- * @since 4.0.0
+ * @since 0.4.0
  */
 ProcessLocalError, 
 /**
@@ -191,7 +198,7 @@ ProcessLocalError,
  * logic after the initial state has been computed.
  *
  * @category errors
- * @since 4.0.0
+ * @since 0.4.0
  */
 StartupError, 
 /**
@@ -199,9 +206,9 @@ StartupError,
  * producing an output.
  *
  * @category errors
- * @since 4.0.0
+ * @since 0.4.0
  */
-StoppedError } from "./internal/machineErrors.js";
+StoppedError } from "./internal/machine/machine.js";
 declare const RuntimeRequirementTypeId = "~effect/Machine/RuntimeRequirement";
 declare const ActionRequirementTypeId = "~effect/Machine/ActionRequirement";
 type MachineRuntimeRequirement = internalRuntime.MachineRuntime;
@@ -210,7 +217,7 @@ type MachineRuntimeRequirement = internalRuntime.MachineRuntime;
  * the Effect that plans a machine step.
  *
  * @category services
- * @since 4.0.0
+ * @since 0.4.0
  */
 export interface ActionRequirement<Error, Requirements> {
     readonly [ActionRequirementTypeId]: {
@@ -222,61 +229,100 @@ export interface ActionRequirement<Error, Requirements> {
  * Extracts the typed error channel of staged machine actions.
  *
  * @category utility types
- * @since 4.0.0
+ * @since 0.4.0
  */
 export type ActionError<Requirements> = Requirements extends ActionRequirement<infer Error, any> ? Error : never;
 /**
  * Extracts the service requirements of staged machine actions.
  *
  * @category utility types
- * @since 4.0.0
+ * @since 0.4.0
  */
 export type ActionServices<Requirements> = Requirements extends ActionRequirement<any, infer Services> ? Services : never;
 /**
  * Removes staged action requirements from machine planning services.
  *
  * @category utility types
- * @since 4.0.0
+ * @since 0.4.0
  */
 export type PlanningServices<Requirements> = Exclude<Requirements, ActionRequirement<any, any>>;
 /**
  * Resolves all services needed to execute a machine at runtime.
  *
  * @category utility types
- * @since 4.0.0
+ * @since 0.4.0
  */
 export type ExecutionServices<Requirements> = Exclude<PlanningServices<Requirements>, MachineRuntimeRequirement> | Exclude<ActionServices<Requirements>, MachineRuntimeRequirement>;
 /**
- * Runtime capability available to machine actions.
+ * Managed runtime capability used to deliver raised and emitted events.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export interface Runtime<in Events, in Emits> {
     /**
      * Queues an event for the current machine macrostep.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly raise: (event: Events) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
     /**
      * Emits an event through the running machine's parent boundary.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly sendParent: (event: Emits) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
 }
+/**
+ * Synchronous commands available while a machine transition is being
+ * selected. Enqueuing only records statechart and actor operations; it never
+ * executes an Effect.
+ *
+ * @category models
+ * @since 0.4.0
+ */
+export interface Enqueue<in Events, in Emits> {
+    /** Raises an event inside the current macrostep. */
+    readonly raise: (event: Events) => void;
+    /** Emits an event through the machine's parent boundary. */
+    readonly emit: (event: Emits) => void;
+    /** Sends an event to an invoked child after the transition is selected. */
+    readonly sendTo: {
+        <Child extends ChildMachine.Any>(child: Child, event: ChildMachine.Event<Child>): void;
+        <Address extends ChildAddress<never>>(child: Address, event: ChildAddress.Event<Address>): void;
+    };
+    /** Stops an invoked child after the transition is selected. */
+    readonly stop: {
+        <Child extends ChildMachine.Any>(child: Child): void;
+        <Event>(child: ChildAddress<Event>): void;
+    };
+}
+/**
+ * A closed actor command recorded by a synchronous machine transition.
+ *
+ * @category models
+ * @since 0.4.0
+ */
+export type Command = {
+    readonly _tag: "SendTo";
+    readonly child: ChildMachine.Any | ChildAddress<never>;
+    readonly event: unknown;
+} | {
+    readonly _tag: "Stop";
+    readonly child: ChildMachine.Any | ChildAddress<never>;
+};
 /**
  * Namespace containing type-level members associated with `Runtime`.
  *
- * @since 4.0.0
+ * @category models
+ * @since 0.4.0
  */
 export declare namespace Runtime {
     /**
-     * Protocol annotation accepted by {@link runtime}.
+     * Protocol annotation for managed event delivery.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Protocol {
         readonly events?: unknown;
@@ -286,7 +332,7 @@ export declare namespace Runtime {
      * Extracts the events required by a runtime protocol annotation.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Events<Protocol> = Protocol extends {
         readonly events: infer Events;
@@ -295,7 +341,7 @@ export declare namespace Runtime {
      * Extracts the emitted events required by a runtime protocol annotation.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Emits<Protocol> = Protocol extends {
         readonly emits: infer Emits;
@@ -304,7 +350,7 @@ export declare namespace Runtime {
      * Opaque service requirement for a machine runtime capability.
      *
      * @category services
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Requirement<Events, Emits> {
         readonly [RuntimeRequirementTypeId]: {
@@ -315,44 +361,66 @@ export declare namespace Runtime {
 }
 type ExcludeCompatibleRuntime<Requirements, Events, Emits> = Requirements extends Runtime.Requirement<infer RequiredEvents, infer RequiredEmits> ? IsAny<Requirements> extends true ? Requirements : [RequiredEvents] extends [Events] ? [RequiredEmits] extends [Emits] ? never : Requirements : Requirements : Requirements;
 type IncompatibleRuntime<Requirements, Events, Emits> = Requirements extends Runtime.Requirement<infer RequiredEvents, infer RequiredEmits> ? IsAny<Requirements> extends true ? never : [RequiredEvents] extends [Events] ? [RequiredEmits] extends [Emits] ? never : Requirements : Requirements : never;
-declare const InvokeTypeId: unique symbol;
-type StateDefinitionError<Message extends string> = {
+declare const InvokeTypeId: typeof internal.InvokeTypeId;
+type StateDefinitionError<Message extends string, Path extends PropertyKey = never, Details extends PropertyKey = never> = {
     readonly "~effect/Machine/DefinitionError": Message;
+    readonly path: Path;
+    readonly details: Details;
 };
 type ActiveStateKey<States extends Machine.StateSchemas> = Machine.ActiveStateKey<States>;
 type HistoryStateKey<States extends Machine.StateSchemas> = Machine.HistoryStateKey<States>;
-type ValidateStateTree<States extends Machine.StateSchemas, AllowHistory extends boolean = false> = {
-    readonly [Key in keyof States]: ValidateStateNode<States[Key], AllowHistory>;
+type ChoiceStateKey<States extends Machine.StateSchemas> = Machine.ChoiceStateKey<States>;
+type StateDefinitionPath<Prefix extends string, Key extends PropertyKey> = Key extends string ? Key extends "" ? Prefix extends "" ? "<empty>" : `${Prefix}.<empty>` : Prefix extends "" ? Key : `${Prefix}.${Key}` : Key extends number ? Prefix extends "" ? `${Key}` : `${Prefix}.${Key}` : Prefix extends "" ? "<symbol>" : `${Prefix}.<symbol>`;
+type ValidateStateKey<Key extends PropertyKey, Prefix extends string> = Key extends symbol ? StateDefinitionError<"State keys must be strings, not symbols", StateDefinitionPath<Prefix, Key>, Key> : Key extends number ? StateDefinitionError<"State keys cannot use numeric forms", StateDefinitionPath<Prefix, Key>, Key> : Key extends "" ? StateDefinitionError<"State keys cannot be empty", StateDefinitionPath<Prefix, Key>, Key> : Key extends "__proto__" ? StateDefinitionError<"The state key \"__proto__\" is not allowed", StateDefinitionPath<Prefix, Key>, Key> : Key extends `${string}.${string}` ? StateDefinitionError<"State keys cannot contain \".\"", StateDefinitionPath<Prefix, Key>, Key> : Key extends `${number}` ? StateDefinitionError<"State keys cannot use numeric forms", StateDefinitionPath<Prefix, Key>, Key> : unknown;
+type ValidateStateTree<States extends Machine.StateSchemas, AllowHistory extends boolean = false, Prefix extends string = ""> = {
+    readonly [Key in keyof States]: ValidateStateKey<Key, Prefix> & ValidateStateNode<States[Key], AllowHistory, StateDefinitionPath<Prefix, Key>>;
 };
-type ValidateStateNode<Node, AllowHistory extends boolean> = Node extends Machine.HistoryStateNodeConfig ? AllowHistory extends true ? ValidateHistoryStateNode<Node> : StateDefinitionError<"History states must be declared below an active parent state"> : Node extends Machine.TaggedSchema ? unknown : Node extends {
+type UnknownStateNodeProperty<Node, Kind extends StateDefinition.StateNodeKind> = Exclude<keyof Node, StateDefinition.AllowedStateNodeProperty<Kind>>;
+type ValidateExactStateNodeProperties<Node, Kind extends StateDefinition.StateNodeKind, Path extends PropertyKey> = [UnknownStateNodeProperty<Node, Kind>] extends [never] ? unknown : StateDefinitionError<"State nodes cannot declare properties outside their state kind", Path, Extract<UnknownStateNodeProperty<Node, Kind>, PropertyKey>>;
+type UnknownPseudoAnnotationProperty<Node> = Node extends {
+    readonly annotations: infer Annotations;
+} ? Exclude<keyof Annotations, StateDefinition.AllowedPseudoStateAnnotationProperty> : never;
+type ValidatePseudoStateAnnotations<Node, Path extends PropertyKey> = [UnknownPseudoAnnotationProperty<Node>] extends [
+    never
+] ? unknown : StateDefinitionError<"Pseudo-state annotations contain unknown properties", Path, Extract<UnknownPseudoAnnotationProperty<Node>, PropertyKey>>;
+type ValidateStateNode<Node, AllowHistory extends boolean, Path extends PropertyKey> = Node extends Machine.TaggedSchema ? unknown : Node extends Machine.HistoryStateNodeConfig ? ValidateExactStateNodeProperties<Node, "history", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateHistoryStateNode<Node> : StateDefinitionError<"History states must be declared below an active parent state", Path>) : Node extends Machine.ChoiceStateNodeConfig ? ValidateExactStateNodeProperties<Node, "choice", Path> & ValidatePseudoStateAnnotations<Node, Path> & (AllowHistory extends true ? ValidateChoiceStateNode<Node> : StateDefinitionError<"Choice states must be declared below an active parent state", Path>) : Node extends {
     readonly schema: Machine.TaggedSchema;
-} ? ValidateStateNodeConfig<Node> : StateDefinitionError<"State nodes must be tagged schemas or state node configs">;
+} ? ValidateStateNodeConfig<Node, Path> : StateDefinitionError<"State nodes must be tagged schemas or state node configs", Path>;
 type ValidateHistoryStateNode<Node extends Machine.HistoryStateNodeConfig> = [
-    Extract<keyof Node, "schema" | "states" | "initial" | "output">
+    Extract<keyof Node, "schema" | "states" | "initial" | "output" | "choice">
 ] extends [never] ? unknown : StateDefinitionError<"History states cannot declare schemas, children, initial states, or output">;
+type ValidateChoiceStateNode<Node extends Machine.ChoiceStateNodeConfig> = [
+    Extract<keyof Node, "schema" | "states" | "initial" | "output" | "history">
+] extends [never] ? unknown : StateDefinitionError<"Choice states cannot declare schemas, children, initial states, output, or history">;
 type ValidateStateNodeConfig<Node extends {
     readonly schema: Machine.TaggedSchema;
-}> = Node extends {
+}, Path extends PropertyKey> = Node extends {
+    readonly type: "parallel";
+} ? ValidateExactStateNodeProperties<Node, "parallel", Path> & ValidateStateNodeWithChildren<Node, Node extends {
+    readonly states: infer Children;
+} ? Children : never, Path> : Node extends {
+    readonly type: "final";
+} ? ValidateExactStateNodeProperties<Node, "final", Path> & ValidateStateNodeWithoutChildren<Node> : Node extends {
     readonly states: infer Children;
-} ? ValidateStateNodeWithChildren<Node, Children> : ValidateStateNodeWithoutChildren<Node>;
+} ? ValidateExactStateNodeProperties<Node, "compound", Path> & ValidateStateNodeWithChildren<Node, Children, Path> : ValidateExactStateNodeProperties<Node, "atomic", Path> & ValidateStateNodeWithoutChildren<Node>;
 type ValidateOutputSchema<Node> = "output" extends keyof Node ? Node extends {
     readonly output: Schema.Top;
 } ? unknown : StateDefinitionError<"State output must be a schema"> : unknown;
 type ValidateStateNodeWithChildren<Node extends {
     readonly schema: Machine.TaggedSchema;
-}, Children> = Children extends Machine.StateSchemas ? Node extends {
+}, Children, Path extends PropertyKey> = Children extends Machine.StateSchemas ? Node extends {
     readonly type: "final";
 } ? StateDefinitionError<"Final states cannot declare child states"> : Node extends {
     readonly type: "parallel";
 } ? "initial" extends keyof Node ? StateDefinitionError<"Parallel states cannot declare an initial child"> : {
-    readonly states: ValidateStateTree<Children, true>;
-} & ValidateOutputSchema<Node> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : ValidateCompoundStateNode<Node, Children> : StateDefinitionError<"Child states must be a state tree">;
+    readonly states: ValidateStateTree<Children, true, Extract<Path, string>>;
+} & ValidateOutputSchema<Node> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : ValidateCompoundStateNode<Node, Children, Path> : StateDefinitionError<"Child states must be a state tree">;
 type ValidateCompoundStateNode<Node extends {
     readonly schema: Machine.TaggedSchema;
-}, Children extends Machine.StateSchemas> = Node extends {
+}, Children extends Machine.StateSchemas, Path extends PropertyKey> = Node extends {
     readonly initial: infer Initial;
-} ? Initial extends ActiveStateKey<Children> ? {
-    readonly states: ValidateStateTree<Children, true>;
+} ? Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children> ? {
+    readonly states: ValidateStateTree<Children, true, Extract<Path, string>>;
 } : StateDefinitionError<"Compound initial must be one of its direct child keys"> : StateDefinitionError<"Compound states must declare an initial child">;
 type ValidateStateNodeWithoutChildren<Node extends {
     readonly schema: Machine.TaggedSchema;
@@ -362,7 +430,7 @@ type ValidateStateNodeWithoutChildren<Node extends {
 type DefineStateTreeInput<States extends Machine.StateSchemas> = {
     readonly [Key in keyof States]: DefineStateNodeInput<States[Key]>;
 };
-type DefineStateNodeInput<Node> = Node extends Machine.TaggedSchema ? Node : Node extends Machine.HistoryStateNodeConfig ? Machine.HistoryStateNodeConfig : Node extends {
+type DefineStateNodeInput<Node> = Node extends Machine.TaggedSchema ? Node : Node extends Machine.HistoryStateNodeConfig ? Machine.HistoryStateNodeConfig : Node extends Machine.ChoiceStateNodeConfig ? Machine.ChoiceStateNodeConfig : Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Omit<Node, "states"> & {
@@ -370,7 +438,7 @@ type DefineStateNodeInput<Node> = Node extends Machine.TaggedSchema ? Node : Nod
 } : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Omit<Node, "initial" | "states"> & {
-    readonly initial: ActiveStateKey<Children>;
+    readonly initial: ActiveStateKey<Children> | ChoiceStateKey<Children>;
     readonly states: DefineStateTreeInput<Children>;
 } : Node;
 type ValidateDefinedStates<States extends Machine.StateSchemas> = [States] extends [
@@ -393,7 +461,7 @@ type DuplicateEventTag<Events extends ReadonlyArray<Machine.TaggedSchema>, Seen
 ] ? Machine.TagOf<Head> extends infer Tag extends PropertyKey ? Tag extends Seen ? Tag | DuplicateEventTag<Tail, Seen> : DuplicateEventTag<Tail, Seen | Tag> : never : never;
 type ValidateInputEventProtocol<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, DuplicateInput extends PropertyKey = DuplicateEventTag<InputEvents>> = [DuplicateInput] extends [never] ? unknown : EventProtocolError<"Public event tags must be unique", DuplicateInput>;
 type ValidateInternalEventProtocol<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, DuplicateInternal extends PropertyKey = DuplicateEventTag<InternalEvents>, Overlap extends PropertyKey = Extract<Machine.TagOf<InputEvents[number]>, Machine.TagOf<InternalEvents[number]>>> = [DuplicateInternal] extends [never] ? [Overlap] extends [never] ? unknown : EventProtocolError<"Public and internal event tags must be disjoint", Overlap> : EventProtocolError<"Internal event tags must be unique", DuplicateInternal>;
-declare const SnapshotBuilderStateTypeId: unique symbol;
+declare const SnapshotBuilderStateTypeId: typeof internal.SnapshotBuilderStateTypeId;
 declare const SnapshotBuilderConstructionTypeId: unique symbol;
 type SnapshotBuilderComplete<Regions, Constructed extends boolean = false> = {
     readonly [SnapshotBuilderStateTypeId]: Regions;
@@ -409,7 +477,7 @@ type FromMethod<Arguments extends ReadonlyArray<unknown>, Result> = {
      * machine plans the resulting configuration. The input may be omitted when
      * the schema accepts an empty constructor object.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly from: FromCallable<Arguments, Machine.StateConstruction<Result>>;
 };
@@ -421,6 +489,8 @@ type ConstructionSelectorFromCallable<Input, Builder, Result> = {} extends Input
 } : <Selected extends ConstructionResult<Result>>(input: Input, state: (builder: Builder) => Selected) => Machine.StateConstruction<UnwrapConstruction<Selected>>;
 type InitialSnapshotBuilderWithPrefix<States extends Machine.StateSchemas, Prefix extends string = ""> = {
     readonly [Key in ActiveStateKey<States>]: InitialSnapshotMethod<States, Key, Prefix>;
+} & {
+    readonly [Key in ChoiceStateKey<States>]: () => Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, Key>>;
 };
 type InitialSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = ((...args: InitialSnapshotArguments<States, StateId, Prefix>) => InitialSnapshotResult<States, StateId, Prefix>) & FromMethod<InitialSnapshotFromArguments<States, StateId, Prefix>, InitialSnapshotResult<States, StateId, Prefix>>;
 type InitialSnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
@@ -432,10 +502,10 @@ type InitialSnapshotArguments<States extends Machine.StateSchemas, StateId exten
 ] : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
-    readonly initial: infer Initial extends ActiveStateKey<Children>;
+    readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children>;
 } ? [
     value: Machine.NodeSchema<Node>["Type"],
-    state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => InitialSnapshotResult<Children, Initial, Path>
+    state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => InitialSelectableResult<Children, Initial, Path>
 ] : never : [value: Machine.NodeSchema<Node>["Type"]] : never;
 type InitialSnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
@@ -446,10 +516,10 @@ type InitialSnapshotFromArguments<States extends Machine.StateSchemas, StateId e
 ] : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
-    readonly initial: infer Initial extends ActiveStateKey<Children>;
+    readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children>;
 } ? [
     input: Machine.NodeSchema<Node>["~type.make.in"],
-    state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => ConstructionResult<InitialSnapshotResult<Children, Initial, Path>>
+    state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => ConstructionResult<InitialSelectableResult<Children, Initial, Path>>
 ] : never : [input: Machine.NodeSchema<Node>["~type.make.in"]] : never;
 type InitialSnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
@@ -457,8 +527,9 @@ type InitialSnapshotResult<States extends Machine.StateSchemas, StateId extends
 } ? Machine.ParallelSnapshot<Path, Machine.NodeSchema<Node>["Type"], InitialSnapshotRegionsWithPrefix<Children, Path>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
-    readonly initial: infer Initial extends ActiveStateKey<Children>;
-} ? Machine.CompoundSnapshot<Path, Machine.NodeSchema<Node>["Type"], InitialSnapshotResult<Children, Initial, Path>> : never : Machine.AtomicSnapshot<Path, Machine.NodeSchema<Node>["Type"]> : never;
+    readonly initial: infer Initial extends ActiveStateKey<Children> | ChoiceStateKey<Children>;
+} ? Machine.CompoundSnapshot<Path, Machine.NodeSchema<Node>["Type"], InitialSelectableResult<Children, Initial, Path>> : never : Machine.AtomicSnapshot<Path, Machine.NodeSchema<Node>["Type"]> : never;
+type InitialSelectableResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States> | ChoiceStateKey<States>, Prefix extends string> = StateId extends ChoiceStateKey<States> ? Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, StateId>> : StateId extends ActiveStateKey<States> ? InitialSnapshotResult<States, StateId, Prefix> : never;
 type InitialSnapshotRegionsWithPrefix<States extends Machine.StateSchemas, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: InitialSnapshotResult<States, Key, Prefix>;
 };
@@ -473,6 +544,8 @@ type InitialParallelBuilder<States extends Machine.StateSchemas, Prefix extends
 };
 type FullSnapshotBuilderWithPrefix<States extends Machine.StateSchemas, Prefix extends string = ""> = {
     readonly [Key in ActiveStateKey<States>]: FullSnapshotMethod<States, Key, Prefix>;
+} & {
+    readonly [Key in ChoiceStateKey<States>]: () => Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, Key>>;
 };
 type FullSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = ((...args: FullSnapshotArguments<States, StateId, Prefix>) => FullSnapshotResult<States, StateId, Prefix>) & FromMethod<FullSnapshotFromArguments<States, StateId, Prefix>, FullSnapshotResult<States, StateId, Prefix>>;
 type FullSnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
@@ -485,7 +558,7 @@ type FullSnapshotArguments<States extends Machine.StateSchemas, StateId extends
     readonly states: infer Children extends Machine.StateSchemas;
 } ? [
     value: Machine.NodeSchema<Node>["Type"],
-    state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => Machine.SnapshotWithPrefix<Children, Path>
+    state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => Machine.SnapshotWithPrefix<Children, Path> | Machine.ChoiceTargetInstruction<Machine.ChoiceIdentifierWithPrefix<Children, Path>>
 ] : [value: Machine.NodeSchema<Node>["Type"]] : never;
 type FullSnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
@@ -497,7 +570,7 @@ type FullSnapshotFromArguments<States extends Machine.StateSchemas, StateId exte
     readonly states: infer Children extends Machine.StateSchemas;
 } ? [
     input: Machine.NodeSchema<Node>["~type.make.in"],
-    state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => ConstructionResult<Machine.SnapshotWithPrefix<Children, Path>>
+    state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => ConstructionResult<Machine.SnapshotWithPrefix<Children, Path> | Machine.ChoiceTargetInstruction<Machine.ChoiceIdentifierWithPrefix<Children, Path>>>
 ] : [input: Machine.NodeSchema<Node>["~type.make.in"]] : never;
 type FullSnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Machine.SnapshotByIdentifierWithPath<States, StateId, Path>;
 type FullParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
@@ -509,13 +582,68 @@ type FullParallelBuilder<States extends Machine.StateSchemas, Prefix extends str
         }, true>>;
     };
 };
+type HistorySnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Path extends Owner ? FullSnapshotArguments<States, StateId, Prefix> : States[StateId] extends infer Node ? Node extends {
+    readonly type: "parallel";
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? [
+    value: Machine.NodeSchema<Node>["Type"],
+    states: (builder: HistoryParallelBuilder<Children, Path, Owner>) => SnapshotBuilderComplete<HistorySnapshotRegions<Children, Path, Owner>>
+] : Node extends {
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? [
+    value: Machine.NodeSchema<Node>["Type"],
+    state: (builder: HistorySnapshotBuilderWithPrefix<Children, Owner, Path>) => ConstructionResult<HistorySnapshotWithPrefix<Children, Owner, Path>>
+] : never : never;
+type HistorySnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Path extends Owner ? FullSnapshotFromArguments<States, StateId, Prefix> : States[StateId] extends infer Node ? Node extends {
+    readonly type: "parallel";
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? [
+    input: Machine.NodeSchema<Node>["~type.make.in"],
+    states: (builder: HistoryParallelBuilder<Children, Path, Owner>) => SnapshotBuilderComplete<HistorySnapshotRegions<Children, Path, Owner>, boolean>
+] : Node extends {
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? [
+    input: Machine.NodeSchema<Node>["~type.make.in"],
+    state: (builder: HistorySnapshotBuilderWithPrefix<Children, Owner, Path>) => ConstructionResult<HistorySnapshotWithPrefix<Children, Owner, Path>>
+] : never : never;
+type HistorySnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Path extends Owner ? FullSnapshotResult<States, StateId, Prefix> : States[StateId] extends infer Node ? Node extends {
+    readonly type: "parallel";
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? Machine.ParallelSnapshot<Path, Machine.NodeSchema<Node>["Type"], HistorySnapshotRegions<Children, Path, Owner>> : Node extends {
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? Machine.CompoundSnapshot<Path, Machine.NodeSchema<Node>["Type"], HistorySnapshotWithPrefix<Children, Owner, Path>> : never : never;
+type HistorySnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string> = ((...args: HistorySnapshotArguments<States, StateId, Prefix, Owner>) => HistorySnapshotResult<States, StateId, Prefix, Owner>) & FromMethod<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>>;
+type HistorySnapshotWithPrefix<States extends Machine.StateSchemas, Owner extends string, Prefix extends string> = {
+    readonly [Key in ActiveStateKey<States>]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? HistorySnapshotResult<States, Key, Prefix, Owner> : never;
+}[ActiveStateKey<States>];
+type HistorySnapshotBuilderWithPrefix<States extends Machine.StateSchemas, Owner extends string, Prefix extends string = ""> = {
+    readonly [Key in ActiveStateKey<States> as Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? Key : never]: HistorySnapshotMethod<States, Key, Prefix, Owner>;
+};
+type HistorySnapshotRegions<States extends Machine.StateSchemas, Prefix extends string, Owner extends string> = {
+    readonly [Key in ActiveStateKey<States>]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? HistorySnapshotResult<States, Key, Prefix, Owner> : FullSnapshotResult<States, Key, Prefix>;
+};
+type HistoryParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Owner extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
+    readonly [Key in Remaining]: Owner extends Machine.JoinPath<Prefix, Key> | `${Machine.JoinPath<Prefix, Key>}.${string}` ? ((...args: HistorySnapshotArguments<States, Key, Prefix, Owner>) => HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
+    }, Constructed>) & {
+        readonly from: FromCallable<HistorySnapshotFromArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+            readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
+        }, true>>;
+    } : ((...args: FullSnapshotArguments<States, Key, Prefix>) => HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+        readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
+    }, Constructed>) & {
+        readonly from: FromCallable<FullSnapshotFromArguments<States, Key, Prefix>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+            readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
+        }, true>>;
+    };
+};
 type ParentPath<Path extends string> = Path extends `${infer Parent}.${infer Child}` ? Child extends `${string}.${string}` ? `${Parent}.${ParentPath<Child>}` : Parent : never;
 type IsCompoundNode<Node> = Node extends {
     readonly type: "parallel";
 } ? false : Node extends {
     readonly states: Machine.StateSchemas;
 } ? true : false;
-type NearestCompoundScope<States extends Machine.StateSchemas, Source extends Machine.StateIdentifier<States>> = IsCompoundNode<Machine.NodeByIdentifier<States, Source>> extends true ? Source : ParentPath<Source> extends infer Parent extends Machine.StateIdentifier<States> ? NearestCompoundScope<States, Parent> : never;
+type NearestCompoundScope<States extends Machine.StateSchemas, Source extends Machine.StateNodeIdentifier<States>> = Source extends Machine.StateIdentifier<States> ? IsCompoundNode<Machine.NodeByIdentifier<States, Source>> extends true ? Source : ParentPath<Source> extends infer Parent extends Machine.StateIdentifier<States> ? NearestCompoundScope<States, Parent> : never : ParentPath<Source> extends infer Parent extends Machine.StateIdentifier<States> ? NearestCompoundScope<States, Parent> : never;
 type ChildrenOf<States extends Machine.StateSchemas, Path extends Machine.StateIdentifier<States>> = Machine.NodeByIdentifier<States, Path> extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Children : never;
@@ -527,11 +655,13 @@ type LocalTargetResult<AllStates extends Machine.StateSchemas, States extends Ma
 } ? Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>> : LocalTargetResultWithPrefix<AllStates, Children, Path> : Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>;
 type LocalTargetResultWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: LocalTargetResult<AllStates, States, Key, Prefix>;
-}[ActiveStateKey<States>];
-type LocalTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string, Source extends Machine.StateIdentifier<AllStates>> = {
+}[ActiveStateKey<States>] | Machine.ChoiceTarget<AllStates, Extract<Machine.JoinPath<Prefix, ChoiceStateKey<States>>, Machine.ChoiceIdentifier<AllStates>>>;
+type LocalTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string, Source extends Machine.StateNodeIdentifier<AllStates>> = {
     readonly [Key in ActiveStateKey<States>]: LocalTargetMethod<AllStates, States, Key, Prefix, Source>;
+} & {
+    readonly [Key in ChoiceStateKey<States>]: () => Machine.ChoiceTarget<AllStates, Extract<Machine.JoinPath<Prefix, Key>, Machine.ChoiceIdentifier<AllStates>>>;
 };
-type LocalTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateIdentifier<AllStates>, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+type LocalTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateNodeIdentifier<AllStates>, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Source extends Path | `${Path}.${string}` ? (<Result extends ConstructionResult<LocalTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
@@ -546,12 +676,12 @@ type LocalTargetMethod<AllStates extends Machine.StateSchemas, States extends Ma
 } : ((value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
     input: Machine.NodeSchema<Node>["~type.make.in"]
 ], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : never;
-type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope extends Machine.StateIdentifier<States>, Source extends Machine.StateIdentifier<States>> = ChildrenOf<States, Scope> extends infer Children extends Machine.StateSchemas ? LocalTargetBuilderWithPrefix<States, Children, Scope, Source> & {
+type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope extends Machine.StateIdentifier<States>, Source extends Machine.StateNodeIdentifier<States>> = ChildrenOf<States, Scope> extends infer Children extends Machine.StateSchemas ? LocalTargetBuilderWithPrefix<States, Children, Scope, Source> & {
     /**
      * Updates the value of the state containing the local group and moves to
      * one of the states inside it. Values in other active branches are kept.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly with: (<Result extends ConstructionResult<LocalTargetResultWithPrefix<States, Children, Scope>>>(value: Machine.StateByIdentifier<States, Scope>, state: (builder: LocalTargetBuilderWithPrefix<States, Children, Scope, Source>) => Result) => Result) & {
         readonly from: ConstructionSelectorFromCallable<Machine.SchemaByIdentifier<States, Scope>["~type.make.in"], LocalTargetBuilderWithPrefix<States, Children, Scope, Source>, LocalTargetResultWithPrefix<States, Children, Scope>>;
@@ -564,11 +694,13 @@ type BranchTargetResult<AllStates extends Machine.StateSchemas, States extends M
 } ? Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>> : BranchTargetResultWithPrefix<AllStates, Children, Path> : Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>;
 type BranchTargetResultWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: BranchTargetResult<AllStates, States, Key, Prefix>;
-}[ActiveStateKey<States>];
-type BranchTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string, Source extends Machine.StateIdentifier<AllStates>> = {
+}[ActiveStateKey<States>] | Machine.ChoiceTarget<AllStates, Extract<Machine.JoinPath<Prefix, ChoiceStateKey<States>>, Machine.ChoiceIdentifier<AllStates>>>;
+type BranchTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string, Source extends Machine.StateNodeIdentifier<AllStates>> = {
     readonly [Key in ActiveStateKey<States>]: BranchTargetMethod<AllStates, States, Key, Prefix, Source>;
+} & {
+    readonly [Key in ChoiceStateKey<States>]: () => Machine.ChoiceTarget<AllStates, Extract<Machine.JoinPath<Prefix, Key>, Machine.ChoiceIdentifier<AllStates>>>;
 };
-type BranchTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateIdentifier<AllStates>, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+type BranchTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateNodeIdentifier<AllStates>, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Source extends Path | `${Path}.${string}` ? (<Result extends ConstructionResult<BranchTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
@@ -583,7 +715,7 @@ type BranchTargetMethod<AllStates extends Machine.StateSchemas, States extends M
 } & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : ((value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
     input: Machine.NodeSchema<Node>["~type.make.in"]
 ], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : never;
-type BranchTargetBuilderForRoot<States extends Machine.StateSchemas, Root extends ActiveStateKey<States>, Source extends Machine.StateIdentifier<States>> = {
+type BranchTargetBuilderForRoot<States extends Machine.StateSchemas, Root extends ActiveStateKey<States>, Source extends Machine.StateNodeIdentifier<States>> = {
     readonly [Key in Root]: BranchTargetMethod<States, States, Key, "", Source>;
 };
 type HistoryContainingKey<States extends Machine.StateSchemas> = {
@@ -634,7 +766,7 @@ type SpawnResult<State, Event, Error, Requirements, Output, SpawnError, InitialE
  * with output or fail while processing an event.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export type RuntimeSnapshot<State, Error = never, Output = never> = {
     readonly status: "active";
@@ -655,7 +787,7 @@ export type RuntimeSnapshot<State, Error = never, Output = never> = {
  * Represents a classified terminal outcome derived from a runtime snapshot.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export type RuntimeOutcome<State, Error = never, Output = never> = {
     readonly _tag: "Done";
@@ -707,7 +839,7 @@ export type RuntimeOutcome<State, Error = never, Output = never> = {
  * `StoppedError`.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export interface MachineRef<out State, in Event, out Error = never, out Output = never> {
     /** Stable machine definition id, or a generated fallback when none was declared. */
@@ -729,13 +861,13 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
     /**
      * Returns the current directly owned child for a typed descriptor.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly child: <Child extends ChildMachine.Any>(child: Child) => Effect.Effect<Option.Option<ChildMachine.Ref<Child>>>;
     /**
      * Streams activation, replacement, and removal of a directly owned child.
      *
-     * @since 4.0.0
+     * @since 0.4.0
      */
     readonly childChanges: <Child extends ChildMachine.Any>(child: Child) => Stream.Stream<Option.Option<ChildMachine.Ref<Child>>>;
 }
@@ -743,7 +875,7 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
  * Machine-specific process logic used by `spawn` and `invoke`.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export interface Logic<State, Event, out Error = never, out Requirements = never, out Output = never, out InitialError = never> {
     /** Creates the initial process state and may spawn scoped child processes. */
@@ -754,14 +886,15 @@ export interface Logic<State, Event, out Error = never, out Requirements = never
 /**
  * Public types used by advanced machine process logic.
  *
- * @since 4.0.0
+ * @category models
+ * @since 0.4.0
  */
 export declare namespace Logic {
     /**
      * Machine-local endpoint that can receive events and be stopped.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Address<in Event> {
         /** Parent-local address id. */
@@ -777,7 +910,7 @@ export declare namespace Logic {
      * Starts child process logic owned by the current machine process.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Spawn {
         <ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError = never>(logic: Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>): Effect.Effect<MachineRef<ChildState, ChildEvent, ChildError, ChildOutput>, ChildInitialError, Exclude<ChildRequirements, Scope.Scope>>;
@@ -793,7 +926,7 @@ export declare namespace Logic {
      * invoke snapshot mapper when either can represent the communication.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Scope<Event> {
         /** Address of the process being initialized. */
@@ -813,7 +946,7 @@ export declare namespace Logic {
      * Machine-local capabilities available while stateful process logic runs.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Context<State, Event> extends Scope<Event> {
         /** Waits for the next event delivered to this process. */
@@ -842,7 +975,7 @@ type InvokeLifecycleId = string & {
  * event, error, and output types are inferred without separate annotations.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export interface ChildMachine<Id extends string, M extends Machine.Any> {
     readonly [ChildMachineTypeId]: typeof ChildMachineTypeId;
@@ -854,28 +987,29 @@ export interface ChildMachine<Id extends string, M extends Machine.Any> {
 /**
  * Namespace containing type-level members associated with `ChildMachine`.
  *
- * @since 4.0.0
+ * @category models
+ * @since 0.4.0
  */
 export declare namespace ChildMachine {
     /**
      * Any typed child machine descriptor.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Any = ChildMachine<string, Machine.Any>;
     /**
      * Running machine reference selected by a child descriptor.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Ref<Child> = Child extends ChildMachine<string, infer M> ? MachineRef<Machine.Snapshot<Machine.States<M>>, Machine.InputEvent<M>, Machine.Error<M> | ActionError<Machine.Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Machine.Output<M>> : never;
     /**
      * Event accepted by the child selected by a descriptor.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Event<Child> = Ref<Child> extends MachineRef<any, infer Event, any, any> ? Event : never;
 }
@@ -883,20 +1017,21 @@ export declare namespace ChildMachine {
  * Parent-local address for a child process that can receive events.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export type ChildAddress<Event> = string & ChildAddress.Variance<Event>;
 /**
  * Namespace containing type-level members associated with `ChildAddress`.
  *
- * @since 4.0.0
+ * @category models
+ * @since 0.4.0
  */
 export declare namespace ChildAddress {
     /**
      * Variance marker carried by a typed child process address.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Variance<in Event> {
         readonly [ChildAddressTypeId]: {
@@ -907,7 +1042,7 @@ export declare namespace ChildAddress {
      * Extracts the event protocol accepted by a child address.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Event<Address> = Address extends ChildAddress<infer Event> ? Event : unknown;
     /**
@@ -915,7 +1050,7 @@ export declare namespace ChildAddress {
      * protocol.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Compatibility<Address, Event> = [Address] extends [ChildAddress<infer AddressEvent>] ? [
         AddressEvent
@@ -930,7 +1065,7 @@ export declare namespace ChildAddress {
      * child process event protocol.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type OptionsCompatibility<Options, Event> = "id" extends keyof Options ? Options extends {
         readonly id?: infer Address;
@@ -940,7 +1075,7 @@ export declare namespace ChildAddress {
  * Options for spawning child processes.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export interface SpawnOptions {
     readonly id?: string;
@@ -949,7 +1084,7 @@ export interface SpawnOptions {
  * Options for spawning child processes with a parent-local id.
  *
  * @category models
- * @since 4.0.0
+ * @since 0.4.0
  */
 export interface SpawnIdOptions extends SpawnOptions {
     readonly id: string;
@@ -957,7 +1092,8 @@ export interface SpawnIdOptions extends SpawnOptions {
 /**
  * Namespace containing type-level members associated with `Machine`.
  *
- * @since 4.0.0
+ * @category models
+ * @since 0.4.0
  */
 export declare namespace Machine {
     /**
@@ -990,7 +1126,7 @@ export declare namespace Machine {
      * that proof on another concrete `Machine` type.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Any extends Pipeable {
         readonly [TypeId]: TypeId;
@@ -1002,6 +1138,7 @@ export declare namespace Machine {
         readonly emits: ReadonlyArray<TaggedSchema>;
         readonly input: Schema.Top | undefined;
         readonly id: string | undefined;
+        /** @internal */
         readonly stateNodes: StateNodes;
         /** @internal */
         readonly makeTargetBuilder: any;
@@ -1016,112 +1153,112 @@ export declare namespace Machine {
      * Extracts the state schema tree carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type States<M extends Any> = M[typeof MachineTypeId]["states"];
     /**
      * Extracts the complete event schema tuple carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Events<M extends Any> = M[typeof MachineTypeId]["events"];
     /**
      * Extracts the input schema carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Input<M extends Any> = M[typeof MachineTypeId]["input"];
     /**
      * Extracts state paths that do not yet have handlers.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type UnhandledStates<M extends Any> = M[typeof MachineTypeId]["unhandledStates"];
     /**
      * Extracts the runtime error channel carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Error<M extends Any> = M[typeof MachineTypeId]["error"];
     /**
      * Extracts runtime service requirements carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Services<M extends Any> = M[typeof MachineTypeId]["services"];
     /**
      * Extracts the startup error channel carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InitialError<M extends Any> = M[typeof MachineTypeId]["initialError"];
     /**
      * Extracts startup service requirements carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InitialServices<M extends Any> = M[typeof MachineTypeId]["initialServices"];
     /**
      * Extracts final state paths carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type FinalStates<M extends Any> = M[typeof MachineTypeId]["finalStates"];
     /**
      * Extracts the terminal output channel carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Output<M extends Any> = M[typeof MachineTypeId]["output"];
     /**
      * Extracts the emitted event schema tuple carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Emits<M extends Any> = M[typeof MachineTypeId]["emits"];
     /**
      * Extracts state paths with implemented output handlers.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type OutputStates<M extends Any> = M[typeof MachineTypeId]["outputStates"];
     /**
      * Extracts the public input event schema tuple carried by a machine definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"];
     /**
      * Extracts the complete event protocol handled inside a machine.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Event<M extends Any> = EventOf<Events<M>>;
     /**
      * Extracts the event protocol accepted by public machine input boundaries.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InputEvent<M extends Any> = EventOf<InputEvents<M>>;
     /**
      * Extracts the event protocol emitted by a machine.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Emit<M extends Any> = EmitOf<Emits<M>>;
     /**
@@ -1132,18 +1269,35 @@ export declare namespace Machine {
      * This mirrors the tagged-schema constraint used by `Schema.toTaggedUnion`.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type TaggedSchema = Schema.Top & {
         readonly Type: {
             readonly _tag: PropertyKey;
         };
     };
+    /**
+     * Descriptive annotations exposed for compiled state nodes.
+     *
+     * Schema-backed states resolve their complete Effect Schema annotation map.
+     * Pseudo-states accept only the descriptive fields below. Annotations never
+     * affect state identity, targeting, or runtime behavior.
+     *
+     * @category models
+     * @since 0.4.0
+     */
+    interface StateNodeAnnotations extends Schema.Annotations.Annotations {
+        readonly title?: string | undefined;
+        readonly description?: string | undefined;
+        readonly documentation?: string | undefined;
+    }
+    /** Descriptive annotations accepted by schema-less pseudo-states. */
+    type PseudoStateAnnotations = Pick<StateNodeAnnotations, "title" | "description" | "documentation">;
     /**
      * Configuration accepted for an atomic object state node.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type AtomicStateNodeConfig = {
         readonly schema: TaggedSchema;
@@ -1158,7 +1312,7 @@ export declare namespace Machine {
      * Configuration accepted for a compound object state node.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface CompoundStateNodeConfig {
         readonly schema: TaggedSchema;
@@ -1170,7 +1324,7 @@ export declare namespace Machine {
      * Configuration accepted for a parallel object state node.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface ParallelStateNodeConfig {
         readonly schema: TaggedSchema;
@@ -1183,34 +1337,55 @@ export declare namespace Machine {
      *
      * History nodes are transition targets only. They never become active and
      * therefore do not declare a state value schema or lifecycle handlers.
+     * Both recorded history and a first-use default can rebuild inactive
+     * ancestors. A default is a complete root configuration containing the
+     * history owner, so its validity is independent of the transition source.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface HistoryStateNodeConfig {
         readonly type: "history";
         /** Defaults to shallow history. */
         readonly history?: "shallow" | "deep";
+        readonly annotations?: PseudoStateAnnotations;
+    }
+    /**
+     * Transient decision pseudo-state resolved immediately when targeted.
+     *
+     * Choice nodes have no value and never belong to an active configuration.
+     * Their required `choice` implementation uses ordinary TypeScript or an
+     * Effect to select a typed target.
+     *
+     * @category models
+     * @since 0.4.0
+     */
+    interface ChoiceStateNodeConfig {
+        readonly type: "choice";
+        readonly annotations?: PseudoStateAnnotations;
     }
     /**
      * Configuration accepted for an object state node.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type StateNodeConfig = AtomicStateNodeConfig | CompoundStateNodeConfig | ParallelStateNodeConfig | HistoryStateNodeConfig;
+    type StateNodeConfig = AtomicStateNodeConfig | CompoundStateNodeConfig | ParallelStateNodeConfig | HistoryStateNodeConfig | ChoiceStateNodeConfig;
     /**
      * Object state tree keyed by state path.
      *
+     * Keys must be non-empty, non-numeric strings without `.`. The
+     * prototype-mutating key `__proto__` and symbol keys are not accepted.
+     *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type StateTree = Readonly<Record<string, TaggedSchema | StateNodeConfig>>;
     /**
      * State schema definitions accepted by `make`.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type StateSchemas = StateTree;
     /**
@@ -1227,7 +1402,7 @@ export declare namespace Machine {
      * require every direct region for parallel states.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InitialBuilder<States extends StateSchemas> = InitialSnapshotBuilderWithPrefix<States>;
     /**
@@ -1240,7 +1415,7 @@ export declare namespace Machine {
      * state tree.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface DefinedStates<States extends StateSchemas> {
         /** Original state tree supplied to {@link defineStates}. */
@@ -1250,7 +1425,7 @@ export declare namespace Machine {
         /**
          * Returns the decoded value for an active state path.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly get: <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => Option.Option<StateByIdentifier<States, Path>>;
         /**
@@ -1261,19 +1436,19 @@ export declare namespace Machine {
          *
          * Parent values are keyed by their full state paths.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly getWithParents: <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => Option.Option<StateWithParents<States, Path>>;
         /**
          * Returns the snapshot for an active state path.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly getSnapshot: <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => Option.Option<SnapshotByIdentifier<States, Path>>;
         /**
          * Returns whether a state path is active in the snapshot.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly matches: <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path) => boolean;
     }
@@ -1281,56 +1456,194 @@ export declare namespace Machine {
      * Validates the nested shape of state schema definitions.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type ValidateStateSchemas<States extends StateSchemas> = ValidateStateTree<States>;
+    /** Properties shared by every compiled state-node variant. */
+    interface StateNodeBase<Path extends string = string> {
+        readonly path: Path;
+        readonly key: string;
+        /** Resolved Effect Schema annotations, or descriptive pseudo-state annotations. */
+        readonly annotations: Readonly<StateNodeAnnotations> | undefined;
+        readonly order: number;
+    }
+    /** Runtime metadata for a compiled atomic state. */
+    interface AtomicStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath> extends StateNodeBase<OwnPath> {
+        readonly type: "atomic";
+        readonly schema: TaggedSchema;
+        readonly output: undefined;
+        readonly history: undefined;
+        readonly parent: ActivePath | undefined;
+        readonly children: readonly [];
+        readonly initial: undefined;
+    }
+    /** Runtime metadata for a compiled compound state. */
+    interface CompoundStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath, ChoicePath extends string = ActivePath> extends StateNodeBase<OwnPath> {
+        readonly type: "compound";
+        readonly schema: TaggedSchema;
+        readonly output: undefined;
+        readonly history: undefined;
+        readonly parent: ActivePath | undefined;
+        /** Active child paths. Pseudo-states are available through their `parent` relationship. */
+        readonly children: ReadonlyArray<ActivePath>;
+        readonly initial: ActivePath | ChoicePath;
+    }
+    /** Runtime metadata for a compiled parallel state. */
+    interface ParallelStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath> extends StateNodeBase<OwnPath> {
+        readonly type: "parallel";
+        readonly schema: TaggedSchema;
+        readonly output: Schema.Top | undefined;
+        readonly history: undefined;
+        readonly parent: ActivePath | undefined;
+        /** Active child paths. Pseudo-states are available through their `parent` relationship. */
+        readonly children: ReadonlyArray<ActivePath>;
+        readonly initial: undefined;
+    }
+    /** Runtime metadata for a compiled final state. */
+    interface FinalStateNode<OwnPath extends string = string, ActivePath extends string = OwnPath> extends StateNodeBase<OwnPath> {
+        readonly type: "final";
+        readonly schema: TaggedSchema;
+        readonly output: Schema.Top | undefined;
+        readonly history: undefined;
+        readonly parent: ActivePath | undefined;
+        readonly children: readonly [];
+        readonly initial: undefined;
+    }
+    /** Runtime metadata for a compiled history pseudo-state. */
+    interface HistoryStateNode<OwnPath extends string = string, ActivePath extends string = string> extends StateNodeBase<OwnPath> {
+        readonly type: "history";
+        readonly schema: undefined;
+        readonly output: undefined;
+        readonly history: "shallow" | "deep";
+        readonly parent: ActivePath;
+        readonly children: readonly [];
+        readonly initial: undefined;
+    }
+    /** Runtime metadata for a compiled choice pseudo-state. */
+    interface ChoiceStateNode<OwnPath extends string = string, ActivePath extends string = string> extends StateNodeBase<OwnPath> {
+        readonly type: "choice";
+        readonly schema: undefined;
+        readonly output: undefined;
+        readonly history: undefined;
+        readonly parent: ActivePath;
+        readonly children: readonly [];
+        readonly initial: undefined;
+    }
     /**
      * Runtime metadata for a compiled state node.
      *
+     * The `type` discriminator narrows every kind-specific topology and schema
+     * property while preserving a uniform inspection shape.
+     *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    interface StateNode {
-        readonly path: string;
-        readonly key: string;
-        readonly schema: TaggedSchema | undefined;
-        readonly output: Schema.Top | undefined;
-        readonly type: "atomic" | "compound" | "parallel" | "final" | "history";
-        readonly history: "shallow" | "deep" | undefined;
-        readonly parent: string | undefined;
-        readonly children: ReadonlyArray<string>;
-        readonly initial: string | undefined;
-        readonly order: number;
-    }
+    type ActiveStateNode<ActivePath extends string = string, ChoicePath extends string = ActivePath> = AtomicStateNode<ActivePath, ActivePath> | CompoundStateNode<ActivePath, ActivePath, ChoicePath> | ParallelStateNode<ActivePath, ActivePath> | FinalStateNode<ActivePath, ActivePath>;
+    type StateNode<ActivePath extends string = string, HistoryPath extends string = ActivePath, ChoicePath extends string = ActivePath> = ActiveStateNode<ActivePath, ChoicePath> | HistoryStateNode<HistoryPath, ActivePath> | ChoiceStateNode<ChoicePath, ActivePath>;
     /**
      * Runtime lookup table for state nodes.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
+     */
+    interface StateNodes<ActivePath extends string = string, HistoryPath extends string = ActivePath, ChoicePath extends string = ActivePath> {
+        readonly byPath: ReadonlyMap<ActivePath | HistoryPath | ChoicePath, StateNode<ActivePath, HistoryPath, ChoicePath>>;
+        readonly roots: ReadonlyArray<ActivePath>;
+    }
+    /**
+     * Trigger that selects a registered transition handler.
+     *
+     * @category models
+     * @since 0.4.0
+     */
+    type TransitionTrigger<EventTag extends PropertyKey = PropertyKey> = {
+        readonly type: "event";
+        readonly event: EventTag;
+    } | {
+        readonly type: "always";
+    } | {
+        readonly type: "done";
+    } | {
+        readonly type: "choice";
+    };
+    /**
+     * Statically inspectable destination paths for a transition handler.
+     * A declared parent path covers every descendant below that state.
+     *
+     * @category models
+     * @since 0.4.0
+     */
+    type TransitionTargets<Path extends string = string> = {
+        readonly type: "dynamic";
+    } | {
+        readonly type: "declared";
+        readonly paths: ReadonlyArray<Path>;
+    };
+    /**
+     * Inspectable registration for a transition handler.
+     *
+     * **Details**
+     *
+     * Event, eventless, and completion handlers may declare an upper bound of
+     * possible target paths. A handler without that declaration is explicitly
+     * reported as dynamic. The source, trigger, and reentry behavior are
+     * available without executing the handler.
+     *
+     * @category models
+     * @since 0.4.0
      */
-    interface StateNodes {
-        readonly byPath: ReadonlyMap<string, StateNode>;
-        readonly roots: ReadonlyArray<string>;
+    interface TransitionDefinition<SourcePath extends string = string, EventTag extends PropertyKey = PropertyKey, TargetPath extends string = SourcePath> {
+        readonly source: SourcePath;
+        readonly trigger: TransitionTrigger<EventTag>;
+        readonly reenter: boolean;
+        readonly targets: TransitionTargets<TargetPath>;
+    }
+    /**
+     * Serializable description of state-owned work.
+     *
+     * Static invoke descriptors expose their lifecycle id and kind without
+     * retaining Effects, closures, services, or child runtimes. A function-valued
+     * invoke factory is reported as dynamic and is never evaluated by inspection.
+     *
+     * @category models
+     * @since 0.4.0
+     */
+    type ActivityDefinition<SourcePath extends string = string> = Activities.ActivityDefinition<SourcePath>;
+    /**
+     * Transition retained after hierarchy precedence and conflict resolution for
+     * one planned microstep.
+     *
+     * @category models
+     * @since 0.4.0
+     */
+    interface RetainedTransition<SourcePath extends string = string, EventTag extends PropertyKey = PropertyKey, TargetPath extends string = SourcePath> {
+        readonly source: SourcePath;
+        readonly trigger: TransitionTrigger<EventTag>;
+        readonly reenter: boolean;
+        /** Path returned by the handler, including a history pseudo-state. */
+        readonly target: TargetPath | undefined;
+        /** Concrete path used after resolving history, otherwise equal to `target`. */
+        readonly resolvedTarget: TargetPath | undefined;
     }
     /**
      * Constructor arguments for a machine initial state function.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InputArgs<Input extends Schema.Top> = Input extends typeof Schema.Void ? [] : [input: Input["Type"]];
     /**
      * Extracts the discriminator value represented by a tagged schema.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type TagOf<S extends TaggedSchema> = S["Type"]["_tag"];
     /**
      * Extracts the schema from a state tree node definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type NodeSchema<Node> = Node extends TaggedSchema ? Node : Node extends {
         readonly schema: infer Schema extends TaggedSchema;
@@ -1339,14 +1652,14 @@ export declare namespace Machine {
      * Prefixes a state path with its parent path.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type JoinPath<Parent extends string, Child extends string> = Parent extends "" ? Child : `${Parent}.${Child}`;
     /**
      * Extracts the state path values represented by a state definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type StateIdentifier<States extends StateSchemas> = StateIdentifierWithPrefix<States>;
     /**
@@ -1354,10 +1667,10 @@ export declare namespace Machine {
      * parent path prefix.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type StateIdentifierWithPrefix<States extends StateSchemas, Prefix extends string = ""> = {
-        readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig ? never : States[Key] extends {
+        readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig | ChoiceStateNodeConfig ? never : States[Key] extends {
             readonly states: infer Children;
         } ? Children extends StateSchemas ? JoinPath<Prefix, Key> | StateIdentifierWithPrefix<Children, JoinPath<Prefix, Key>> : JoinPath<Prefix, Key> : JoinPath<Prefix, Key>;
     }[Extract<keyof States, string>];
@@ -1365,44 +1678,71 @@ export declare namespace Machine {
      * Extracts the transition-only history pseudo-state paths in a definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type HistoryIdentifier<States extends StateSchemas> = HistoryIdentifierWithPrefix<States>;
+    /** Extracts the transition-only choice pseudo-state paths. */
+    type ChoiceIdentifier<States extends StateSchemas> = ChoiceIdentifierWithPrefix<States>;
+    /**
+     * Extracts every compiled state-node path, including history pseudo-states.
+     *
+     * @category utility types
+     * @since 0.4.0
+     */
+    type StateNodeIdentifier<States extends StateSchemas> = StateIdentifier<States> | HistoryIdentifier<States> | ChoiceIdentifier<States>;
     /** @internal */
     type HistoryIdentifierWithPrefix<States extends StateSchemas, Prefix extends string = ""> = {
         readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig ? JoinPath<Prefix, Key> : States[Key] extends {
             readonly states: infer Children extends StateSchemas;
         } ? HistoryIdentifierWithPrefix<Children, JoinPath<Prefix, Key>> : never;
     }[Extract<keyof States, string>];
+    /** @internal */
+    type ChoiceIdentifierWithPrefix<States extends StateSchemas, Prefix extends string = ""> = {
+        readonly [Key in Extract<keyof States, string>]: States[Key] extends ChoiceStateNodeConfig ? JoinPath<Prefix, Key> : States[Key] extends {
+            readonly states: infer Children extends StateSchemas;
+        } ? ChoiceIdentifierWithPrefix<Children, JoinPath<Prefix, Key>> : never;
+    }[Extract<keyof States, string>];
     /** Active keys directly declared in a state tree. */
     type ActiveStateKey<States extends StateSchemas> = {
-        readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig ? never : Key;
+        readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig | ChoiceStateNodeConfig ? never : Key;
     }[Extract<keyof States, string>];
     /** History pseudo-state keys directly declared in a state tree. */
     type HistoryStateKey<States extends StateSchemas> = {
         readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig ? Key : never;
     }[Extract<keyof States, string>];
+    /** Choice pseudo-state keys directly declared in a state tree. */
+    type ChoiceStateKey<States extends StateSchemas> = {
+        readonly [Key in Extract<keyof States, string>]: States[Key] extends ChoiceStateNodeConfig ? Key : never;
+    }[Extract<keyof States, string>];
     /**
      * Active states that must implement implicit initial-value construction for
      * shallow history restoration.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type RequiredHistoryInitializers<States extends StateSchemas> = [HistoryIdentifier<States>] extends [never] ? never : Extract<RequiredHistoryInitializersWithPrefix<States, States, "">, StateIdentifier<States>>;
     /** Active parent states that own one or more history pseudo-states. */
     type HistoryParentIdentifier<States extends StateSchemas> = HistoryIdentifier<States> extends infer HistoryId ? HistoryId extends string ? Extract<ImmediateParentStateIdentifier<HistoryId>, StateIdentifier<States>> : never : never;
+    /** Active parent states that own one or more choice pseudo-states. */
+    type ChoiceParentIdentifier<States extends StateSchemas> = ChoiceIdentifier<States> extends infer ChoiceId ? ChoiceId extends string ? Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>> : never : never;
     /** History defaults and implicit initializers that remain unimplemented. */
     type MissingHistoryImplementations<States extends StateSchemas, UnhandledStates extends StateIdentifier<States>> = Extract<UnhandledStates, HistoryParentIdentifier<States> | RequiredHistoryInitializers<States>>;
+    /** Choice-owning active parents that remain unimplemented. */
+    type MissingChoiceImplementations<States extends StateSchemas, UnhandledStates extends StateIdentifier<States>> = Extract<UnhandledStates, ChoiceParentIdentifier<States>>;
+    /** @internal Readiness proof for required choice resolvers. */
+    type EnsureChoiceImplementations<States extends StateSchemas, UnhandledStates extends StateIdentifier<States>> = [ChoiceIdentifier<States>] extends [never] ? unknown : [MissingChoiceImplementations<States, UnhandledStates>] extends [never] ? unknown : {
+        readonly "~effect/Machine/MissingChoiceImplementation": MissingChoiceImplementations<States, UnhandledStates>;
+    };
     /** @internal Readiness proof required by planning and managed execution. */
-    type EnsureHistoryImplementations<States extends StateSchemas, UnhandledStates extends StateIdentifier<States>> = [HistoryIdentifier<States>] extends [never] ? unknown : [MissingHistoryImplementations<States, UnhandledStates>] extends [never] ? unknown : {
+    type EnsureHistoryImplementations<States extends StateSchemas, UnhandledStates extends StateIdentifier<States>> = ([HistoryIdentifier<States>] extends [never] ? unknown : [MissingHistoryImplementations<States, UnhandledStates>] extends [never] ? unknown : {
         readonly "~effect/Machine/MissingHistoryImplementation": MissingHistoryImplementations<States, UnhandledStates>;
-    };
+    }) & EnsureChoiceImplementations<States, UnhandledStates>;
     /**
      * Extracts a state-tree node by state path.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type NodeByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends `${infer Head}.${infer Rest}` ? Head extends keyof States ? States[Head] extends {
         readonly states: infer Children extends StateSchemas;
@@ -1411,21 +1751,21 @@ export declare namespace Machine {
      * Extracts a schema from a state definition by state identifier.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type SchemaByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeSchema<NodeByIdentifier<States, StateId>>;
     /**
      * Extracts the union of state values represented by a state definition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type StateOf<States extends StateSchemas> = StateIdentifier<States> extends infer StateId ? StateId extends StateIdentifier<States> ? SchemaByIdentifier<States, StateId>["Type"] : never : never;
     /**
      * Extracts the union of event values represented by an event schema list.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type EventOf<Events extends ReadonlyArray<TaggedSchema>> = Events[number]["Type"];
     /**
@@ -1433,49 +1773,42 @@ export declare namespace Machine {
      * schema list.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type EmitOf<Emits extends ReadonlyArray<TaggedSchema>> = Emits[number]["Type"];
     /**
      * Event values received by lifecycle callbacks.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type LifecycleEvent<Events extends ReadonlyArray<TaggedSchema>> = EventOf<Events> | InitialEvent;
-    /**
-     * Runtime capability specialized to a machine's event protocols.
-     *
-     * @category utility types
-     * @since 4.0.0
-     */
-    type RuntimeEffect<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>> = Effect.Effect<Runtime<EventOf<Events>, EmitOf<Emits>>, never, Runtime.Requirement<EventOf<Events>, EmitOf<Emits>>>;
     /**
      * Extracts a state value from a state definition by identifier.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type StateByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = Extract<StateOf<States>, SchemaByIdentifier<States, StateId>["Type"]>;
     /**
      * Extracts every parent state path from a state identifier.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type ParentStateIdentifier<StateId extends string> = StateId extends `${infer Parent}.${infer Child}` ? Parent | (Child extends `${string}.${string}` ? `${Parent}.${ParentStateIdentifier<Child>}` : never) : never;
     /**
      * Extracts the nearest parent state path from a state identifier.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type ImmediateParentStateIdentifier<StateId extends string> = StateId extends `${infer Head}.${infer Tail}` ? Tail extends `${string}.${string}` ? `${Head}.${ImmediateParentStateIdentifier<Tail>}` : Head : never;
     /**
      * Maps every parent state path of a state identifier to its decoded value.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type ParentStateValues<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? {
         readonly [Parent in Extract<ParentStateIdentifier<StateId>, StateIdentifier<States>>]: StateByIdentifier<States, Parent>;
@@ -1484,14 +1817,14 @@ export declare namespace Machine {
      * Extracts the nearest parent value, or `undefined` for a root state.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type ParentStateValue<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? Extract<ImmediateParentStateIdentifier<StateId>, StateIdentifier<States>> extends infer Parent ? [Parent] extends [never] ? undefined : Parent extends StateIdentifier<States> ? StateByIdentifier<States, Parent> : undefined : undefined : never;
     /**
      * Represents a decoded state value together with all of its parent values.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type StateWithParents<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? {
         readonly value: StateByIdentifier<States, StateId>;
@@ -1505,7 +1838,7 @@ export declare namespace Machine {
      * Extracts the declared output type for a state node.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type OutputByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeOutput<NodeByIdentifier<States, StateId>>;
     type DirectFinalCompletionOutput<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeByIdentifier<States, StateId> extends {
@@ -1519,7 +1852,7 @@ export declare namespace Machine {
      * Extracts the output passed when a state node completes.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type CompletionOutputByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeByIdentifier<States, StateId> extends infer Node ? Node extends {
         readonly type: "parallel";
@@ -1542,7 +1875,7 @@ export declare namespace Machine {
      * before that root becomes the machine's terminal result.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type TerminalOutput<States extends StateSchemas> = {
         readonly [Key in Extract<keyof States, string>]: Extract<Key, StateIdentifier<States>> extends infer StateId extends StateIdentifier<States> ? NodeByIdentifier<States, StateId> extends infer Node ? Node extends {
@@ -1555,7 +1888,7 @@ export declare namespace Machine {
      * Extracts every state path whose definition declares an output schema.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type DeclaredOutputState<States extends StateSchemas> = {
         readonly [StateId in StateIdentifier<States>]: NodeByIdentifier<States, StateId> extends {
@@ -1567,7 +1900,7 @@ export declare namespace Machine {
      * implementation before a machine is planned or started.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type EnsureOutputImplementations<States extends StateSchemas, OutputStates extends StateIdentifier<States>> = [
         Exclude<DeclaredOutputState<States>, OutputStates>
@@ -1584,7 +1917,7 @@ export declare namespace Machine {
      * machine snapshot.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type SnapshotDecodingServices<States extends StateSchemas> = StateIdentifier<States> extends infer StateId ? StateId extends StateIdentifier<States> ? DecodingServices<SchemaByIdentifier<States, StateId>> | DecodingServices<OutputSchema<NodeByIdentifier<States, StateId>>> : never : never;
     /**
@@ -1592,14 +1925,14 @@ export declare namespace Machine {
      * machine snapshot.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type SnapshotEncodingServices<States extends StateSchemas> = StateIdentifier<States> extends infer StateId ? StateId extends StateIdentifier<States> ? EncodingServices<SchemaByIdentifier<States, StateId>> | EncodingServices<OutputSchema<NodeByIdentifier<States, StateId>>> : never : never;
     /**
      * Encoded value for one active state path in a normalized machine snapshot.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface EncodedSnapshotState {
         readonly path: string;
@@ -1610,7 +1943,7 @@ export declare namespace Machine {
      * snapshot. An omitted output represents `undefined`.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface EncodedSnapshotCompletion {
         readonly path: string;
@@ -1632,7 +1965,7 @@ export declare namespace Machine {
      * scopes, queues, and subscriptions is not included.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface EncodedSnapshot {
         readonly _tag: "MachineSnapshot";
@@ -1644,7 +1977,7 @@ export declare namespace Machine {
      * Completed state path and its resolved output value.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface SnapshotCompletion {
         readonly path: string;
@@ -1670,7 +2003,7 @@ export declare namespace Machine {
      * or transport boundary.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface SnapshotMetadata {
         readonly completed?: ReadonlyArray<SnapshotCompletion>;
@@ -1681,7 +2014,7 @@ export declare namespace Machine {
      * decoded state value.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface AtomicSnapshot<Path extends string, Value> extends SnapshotMetadata {
         readonly path: Path;
@@ -1692,7 +2025,7 @@ export declare namespace Machine {
      * snapshot.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface CompoundSnapshot<Path extends string, Value, Child> extends SnapshotMetadata {
         readonly path: Path;
@@ -1704,7 +2037,7 @@ export declare namespace Machine {
      * per child region.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface ParallelSnapshot<Path extends string, Value, Regions> extends SnapshotMetadata {
         readonly path: Path;
@@ -1716,7 +2049,7 @@ export declare namespace Machine {
      * identifier.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type SnapshotByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeByIdentifier<States, StateId> extends infer Node ? Node extends {
         readonly type: "parallel";
@@ -1728,7 +2061,7 @@ export declare namespace Machine {
      * Extracts child snapshots under a parent path prefix.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type SnapshotWithPrefix<States extends StateSchemas, Prefix extends string> = {
         readonly [Key in ActiveStateKey<States>]: SnapshotByIdentifierWithPath<States, Key, JoinPath<Prefix, Key>>;
@@ -1738,7 +2071,7 @@ export declare namespace Machine {
      * child region.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type SnapshotRegionsWithPrefix<States extends StateSchemas, Prefix extends string> = {
         readonly [Key in ActiveStateKey<States>]: SnapshotByIdentifierWithPath<States, Key, JoinPath<Prefix, Key>>;
@@ -1747,7 +2080,7 @@ export declare namespace Machine {
      * Extracts a snapshot for a state node while preserving its full path.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type SnapshotByIdentifierWithPath<States extends StateSchemas, StateId extends ActiveStateKey<States>, Path extends string> = States[StateId] extends {
         readonly type: "parallel";
@@ -1755,12 +2088,23 @@ export declare namespace Machine {
     } ? Children extends StateSchemas ? ParallelSnapshot<Path, NodeSchema<States[StateId]>["Type"], SnapshotRegionsWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]> : States[StateId] extends {
         readonly states: infer Children;
     } ? Children extends StateSchemas ? CompoundSnapshot<Path, NodeSchema<States[StateId]>["Type"], SnapshotWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]>;
+    /**
+     * Extracts a complete root snapshot whose selected configuration contains a
+     * particular active state.
+     *
+     * Parallel ancestors still require every region, while compound ancestors
+     * are narrowed to the branch leading to `Owner`.
+     *
+     * @category utility types
+     * @since 0.4.0
+     */
+    type CompleteSnapshotContaining<States extends StateSchemas, Owner extends StateIdentifier<States>> = HistorySnapshotWithPrefix<States, Owner, "">;
     /**
      * Extracts the union of statechart snapshots represented by a state
      * definition.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type Snapshot<States extends StateSchemas> = {
         readonly [StateId in ActiveStateKey<States>]: SnapshotByIdentifier<States, StateId & StateIdentifier<States>>;
@@ -1769,21 +2113,21 @@ export declare namespace Machine {
      * Extracts the root state identifier from a state path.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type RootStateIdentifier<StateId extends string> = StateId extends `${infer Root}.${string}` ? Root : StateId;
     /**
      * Extracts the public snapshot shape that contains a final state path.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type SnapshotContainingFinal<States extends StateSchemas, FinalStates extends StateIdentifier<States>> = FinalStates extends StateIdentifier<States> ? RootStateIdentifier<FinalStates> extends infer Root extends StateIdentifier<States> ? SnapshotByIdentifier<States, Root> : never : never;
     /**
      * Extracts state identifiers whose state-tree definition marks them final.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type FinalStateFromDefinition<States extends StateSchemas> = {
         readonly [StateId in StateIdentifier<States>]: NodeByIdentifier<States, StateId> extends {
@@ -1794,11 +2138,15 @@ export declare namespace Machine {
      * Extracts an event value from an event schema list by tag.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type EventByTag<Events extends ReadonlyArray<TaggedSchema>, Tag extends TagOf<Events[number]>> = Extract<EventOf<Events>, {
         readonly _tag: Tag;
-    }>;
+    }> | (EventOf<Events> extends infer Event ? Event extends {
+        readonly _tag: infer EventTag extends PropertyKey;
+    } ? [EventTag] extends [Tag] ? never : [Tag] extends [EventTag] ? Omit<Event, "_tag"> & {
+        readonly _tag: Tag;
+    } : never : never : never);
     /**
      * Opaque state construction returned by a builder's `.from` method.
      *
@@ -1807,20 +2155,20 @@ export declare namespace Machine {
      * planning succeeds.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface StateConstruction<Result> {
-        readonly [Model.StateConstructionTypeId]: Result;
+        readonly [Topology.StateConstructionTypeId]: Result;
     }
     /**
      * Machine-bound target instruction accepted from transition handlers.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Target<States extends StateSchemas, StateId extends StateIdentifier<States>> {
-        readonly [Model.TargetTypeId]: typeof Model.TargetTypeId;
-        readonly [Model.TargetSnapshotTypeId]?: SnapshotByIdentifier<States, StateId>;
+        readonly [Topology.TargetTypeId]: typeof Topology.TargetTypeId;
+        readonly [Topology.TargetSnapshotTypeId]?: SnapshotByIdentifier<States, StateId>;
         readonly path: StateId;
         readonly value: StateByIdentifier<States, StateId>;
         readonly values?: Partial<{
@@ -1835,13 +2183,24 @@ export declare namespace Machine {
      * history node's typed default when no record exists.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface HistoryTarget<States extends StateSchemas, HistoryId extends HistoryIdentifier<States>> {
-        readonly [Model.HistoryTargetTypeId]: typeof Model.HistoryTargetTypeId;
+        readonly [Topology.HistoryTargetTypeId]: typeof Topology.HistoryTargetTypeId;
         readonly path: HistoryId;
         readonly parent: Extract<ParentPath<HistoryId>, StateIdentifier<States>>;
     }
+    /** Branded transient target instruction used while constructing initial states. */
+    interface ChoiceTargetInstruction<ChoiceId extends string = string> {
+        readonly [Topology.ChoiceTargetTypeId]: typeof Topology.ChoiceTargetTypeId;
+        readonly path: ChoiceId;
+        readonly parent: ParentPath<ChoiceId>;
+        readonly values?: Readonly<Record<string, unknown>>;
+    }
+    /** Transition instruction that enters a transient choice pseudo-state. */
+    interface ChoiceTarget<States extends StateSchemas, ChoiceId extends ChoiceIdentifier<States>> extends ChoiceTargetInstruction<ChoiceId> {
+        readonly parent: Extract<ParentPath<ChoiceId>, StateIdentifier<States>>;
+    }
     /** Builder containing only history pseudo-state paths. */
     type HistoryTargetBuilder<States extends StateSchemas> = HistoryTargetBuilderWithPrefix<States, States, "">;
     /**
@@ -1853,9 +2212,16 @@ export declare namespace Machine {
      * every active child below the selected root.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type FullTargetBuilder<States extends StateSchemas> = FullSnapshotBuilderWithPrefix<States>;
+    /**
+     * Builder for a complete fallback configuration containing a history owner.
+     *
+     * @category utility types
+     * @since 0.4.0
+     */
+    type HistoryDefaultTargetBuilder<States extends StateSchemas, Owner extends StateIdentifier<States>> = HistorySnapshotBuilderWithPrefix<States, Owner>;
     /**
      * Builder for source-local transition targets.
      *
@@ -1865,9 +2231,9 @@ export declare namespace Machine {
      * the source state and should preserve active ancestor and sibling values.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type LocalTargetBuilder<States extends StateSchemas, Source extends StateIdentifier<States>> = NearestCompoundScope<States, Source> extends infer Scope ? [Scope] extends [never] ? {} : Scope extends StateIdentifier<States> ? LocalTargetBuilderForScope<States, Scope, Source> : {} : {};
+    type LocalTargetBuilder<States extends StateSchemas, Source extends StateNodeIdentifier<States>> = NearestCompoundScope<States, Source> extends infer Scope ? [Scope] extends [never] ? {} : Scope extends StateIdentifier<States> ? LocalTargetBuilderForScope<States, Scope, Source> : {} : {};
     /**
      * Builder for partial transition targets within the active source root.
      *
@@ -1877,9 +2243,9 @@ export declare namespace Machine {
      * root while preserving unmentioned active ancestors or parallel regions.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type BranchTargetBuilder<States extends StateSchemas, Source extends StateIdentifier<States>> = BranchTargetBuilderForRoot<States, Extract<RootStateIdentifier<Source>, ActiveStateKey<States>>, Source>;
+    type BranchTargetBuilder<States extends StateSchemas, Source extends StateNodeIdentifier<States>> = BranchTargetBuilderForRoot<States, Extract<RootStateIdentifier<Source>, ActiveStateKey<States>>, Source>;
     /**
      * Machine-bound target builders available in transition contexts.
      *
@@ -1897,14 +2263,14 @@ export declare namespace Machine {
      * enter again.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    interface TargetBuilder<States extends StateSchemas, Source extends StateIdentifier<States>> {
+    interface TargetBuilder<States extends StateSchemas, Source extends StateNodeIdentifier<States>> {
         /**
          * Moves to another state in the same local group. The value of the state
          * containing that group, and values in other active branches, are kept.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly local: LocalTargetBuilder<States, Source>;
         /**
@@ -1912,7 +2278,7 @@ export declare namespace Machine {
          * values change only when their builder methods are explicitly called;
          * other active branches are kept.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly branch: BranchTargetBuilder<States, Source>;
         /**
@@ -1925,53 +2291,30 @@ export declare namespace Machine {
          * When it contains parallel states, an active state must be provided for
          * every region.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly full: FullTargetBuilder<States>;
         /** Restores a declared shallow or deep history pseudo-state. */
         readonly history: HistoryTargetBuilder<States>;
     }
-    /**
-     * Stages an Effect to run after the current machine step is planned.
-     *
-     * The two-argument overload returns `next` after staging the Effect, which is
-     * useful when a handler should stage one action and return a target without
-     * introducing an Effect generator.
-     *
-     * @category models
-     * @since 4.0.0
-     */
-    interface Action {
-        <E, R>(effect: Effect.Effect<void, E, R>): Effect.Effect<void, never, ActionRequirement<E, R>>;
-        <E, R, Next>(effect: Effect.Effect<void, E, R>, next: Next): Effect.Effect<Next, never, ActionRequirement<E, R>>;
-    }
-    /**
-     * Planning capabilities shared by transition and lifecycle callbacks.
-     *
-     * @category models
-     * @since 4.0.0
-     */
-    interface PlanningCapabilities<Events, Emits> {
-        readonly raise: (event: Events) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError, Runtime.Requirement<Events, Emits>>;
-        readonly emit: (event: Emits) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError, Runtime.Requirement<Events, Emits>>;
-    }
     /**
      * Context passed to a state/event handler.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    interface HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
+    interface HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
+        /** Complete logical configuration captured at the start of this microstep. */
+        readonly snapshot: Snapshot<States>;
         readonly event: EventByTag<Events, EventTag>;
-        readonly runtime: RuntimeEffect<Events, Emits>;
         /**
          * Provides typed builders for choosing the next active state from this
          * handler. Each builder documents which existing state values it keeps.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly target: TargetBuilder<States, StateId>;
     }
@@ -1979,33 +2322,31 @@ export declare namespace Machine {
      * Context passed to an entry or exit state handler.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    interface StateActionContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
+    interface StateActionContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
-        readonly runtime: RuntimeEffect<Events, Emits>;
     }
     /**
      * Context passed to an invoked child process source.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface InvokeContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
-        readonly runtime: RuntimeEffect<Events, Emits>;
     }
     /**
      * Context passed to an invoked child process active snapshot mapper.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface InvokeSnapshotContext<State, Error, Output> {
         readonly id: string;
@@ -2017,7 +2358,7 @@ export declare namespace Machine {
      * Context passed to an invoked machine terminal output mapper.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface InvokeDoneContext<Output> {
         readonly id: string;
@@ -2027,20 +2368,21 @@ export declare namespace Machine {
      * Context passed to an eventless transition handler.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    interface AlwaysContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
+    interface AlwaysContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
+        /** Complete logical configuration captured at the start of this microstep. */
+        readonly snapshot: Snapshot<States>;
         readonly event: LifecycleEvent<Events>;
-        readonly runtime: RuntimeEffect<Events, Emits>;
         /**
          * Provides typed builders for choosing the next active state from this
          * eventless handler. Each builder documents which existing state values it
          * keeps.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly target: TargetBuilder<States, StateId>;
     }
@@ -2048,29 +2390,39 @@ export declare namespace Machine {
      * Context passed to a state completion transition handler.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    interface DoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
+    interface DoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
+        /** Complete logical configuration captured at the start of this microstep. */
+        readonly snapshot: Snapshot<States>;
         readonly event: LifecycleEvent<Events>;
         readonly output: CompletionOutputByIdentifier<States, StateId>;
-        readonly runtime: RuntimeEffect<Events, Emits>;
         /**
          * Provides typed builders for choosing the next active state after this
          * state completes. Each builder documents which existing state values it
          * keeps.
          *
-         * @since 4.0.0
+         * @since 0.4.0
          */
         readonly target: TargetBuilder<States, StateId>;
     }
+    /** Context passed to a transient choice resolver. There is no `state` value. */
+    interface ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>> {
+        readonly parent: StateByIdentifier<States, Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>>;
+        readonly parents: {
+            readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, StateIdentifier<States>>]: StateByIdentifier<States, Parent>;
+        };
+        readonly event: LifecycleEvent<Events>;
+        readonly target: TargetBuilder<States, ChoiceId>;
+    }
     /**
      * Context passed to a final state output function.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface FinalOutputContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
@@ -2082,7 +2434,7 @@ export declare namespace Machine {
      * Extracts region outputs for a completed parallel state.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type ParallelOutputRegions<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeByIdentifier<States, StateId> extends {
         readonly type: "parallel";
@@ -2094,7 +2446,7 @@ export declare namespace Machine {
      * Context passed to a parallel state output function.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface ParallelOutputContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
@@ -2107,16 +2459,20 @@ export declare namespace Machine {
      * Return value accepted from entry and exit state actions.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type StateActionResult<E, R> = void | Effect.Effect<void, E, R>;
+    type StateActionResult<E, R> = undefined;
     /**
      * Return value accepted from a machine initial state function.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type InitialResult<States extends StateSchemas, E, R> = Snapshot<States> | StateConstruction<Snapshot<States>> | Effect.Effect<Snapshot<States> | StateConstruction<Snapshot<States>>, E, R>;
+    type InitialResult<States extends StateSchemas, E, R> = Snapshot<States> | InitialSnapshot<States> | StateConstruction<Snapshot<States> | InitialSnapshot<States>>;
+    /** Initial snapshots may transiently terminate in a declared choice node. */
+    type InitialSnapshot<States extends StateSchemas> = {
+        readonly [StateId in ActiveStateKey<States>]: InitialSnapshotResult<States, StateId, "">;
+    }[ActiveStateKey<States>];
     /**
      * Return value accepted from transition handlers.
      *
@@ -2127,42 +2483,44 @@ export declare namespace Machine {
      * accepted at transition boundaries.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type HandlerResult<States extends StateSchemas, E, R> = Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | StateConstruction<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>>> | void | Effect.Effect<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | StateConstruction<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>>> | void, E, R>;
+    type HandlerResult<States extends StateSchemas, E, R> = Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>> | StateConstruction<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>>> | void;
+    /** A choice resolver must always select a typed target synchronously. */
+    type ChoiceResult<States extends StateSchemas, E, R> = Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>> | StateConstruction<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | ChoiceTarget<States, ChoiceIdentifier<States>>>;
     /**
      * Extracts the union of handler return values from a handler map.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type HandlerEffect<Handlers> = Handlers[keyof Handlers];
     /**
      * Extracts the error type from a handler return value.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type HandlerError<Handlers> = Effect.Error<HandlerEffect<Handlers>>;
     /**
      * Extracts the service requirements from a handler return value.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type HandlerServices<Handlers> = Effect.Services<HandlerEffect<Handlers>>;
     /**
      * Extracts the return value from an initial state function.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InitialReturn<Initial> = Initial extends (...args: any) => infer Ret ? Ret : never;
     /**
      * Extracts the return value from an entry or exit action.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type StateActionReturn<Config, Key extends "entry" | "exit"> = Key extends keyof Config ? NonNullable<Config[Key]> extends (...args: any) => infer Ret ? Ret : never : never;
     /** Extracts the return value from an implicit initial child implementation. */
@@ -2177,11 +2535,17 @@ export declare namespace Machine {
             readonly default: (...args: any) => infer Ret;
         } ? Ret : never;
     }[keyof NonNullable<History>] : never;
+    /** Extracts the return value from a choice resolver. */
+    type ChoiceReturn<Config> = Config extends {
+        readonly choice: {
+            readonly transition: (...args: any) => infer Ret;
+        };
+    } ? Ret : never;
     /**
      * Extracts the return value from an event transition config.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type EventTransitionReturn<Transition> = Transition extends (...args: any) => infer Ret ? Ret : Transition extends {
         readonly transition: (...args: any) => infer Ret;
@@ -2190,7 +2554,7 @@ export declare namespace Machine {
      * Extracts the return value from a state's event handlers.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type EventHandlerReturn<Config> = Config extends {
         readonly on?: infer On;
@@ -2201,7 +2565,7 @@ export declare namespace Machine {
      * Extracts the invoke config or configs from a state config.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeReturn<Config> = "invoke" extends keyof Config ? Config extends {
         readonly invoke?: infer Invoke;
@@ -2210,7 +2574,7 @@ export declare namespace Machine {
      * Extracts the child process logic returned by an invoke source.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeLogic<Invoke> = Invoke extends {
         readonly src: (...args: any) => infer Logic;
@@ -2219,7 +2583,7 @@ export declare namespace Machine {
      * Extracts the startup error from an invoke source child process logic.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeInitialError<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
@@ -2230,7 +2594,7 @@ export declare namespace Machine {
      * Extracts the runtime error from an invoked child process.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeRuntimeError<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
@@ -2241,7 +2605,7 @@ export declare namespace Machine {
      * Extracts the output from an invoked child process.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeOutput<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
@@ -2252,7 +2616,7 @@ export declare namespace Machine {
      * Extracts the service requirements from an invoke source child process logic.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeServices<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
@@ -2263,7 +2627,7 @@ export declare namespace Machine {
      * Extracts events emitted directly by an invoked child.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeEmits<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
@@ -2274,7 +2638,7 @@ export declare namespace Machine {
      * Extracts events returned by an invoked child snapshot mapper.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeSnapshotEvent<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
@@ -2285,39 +2649,39 @@ export declare namespace Machine {
      * Extracts the parent transition error contribution from invoked children.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeError<Config> = [InvokeReturn<Config>] extends [never] ? never : ChildAlreadyExistsError | InvokeInitialError<InvokeReturn<Config>> | InvokeRuntimeError<InvokeReturn<Config>>;
     /**
      * Extracts the parent service requirement contribution from invoked children.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeRequirements<Config> = [InvokeReturn<Config>] extends [never] ? never : MachineRuntimeRequirement | InvokeServices<InvokeReturn<Config>>;
     /**
      * Extracts the return value from an eventless transition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type AlwaysReturn<Config> = Config extends {
         readonly always?: infer Always;
-    } ? NonNullable<Always> extends (...args: any) => infer Ret ? Ret : never : never;
+    } ? EventTransitionReturn<NonNullable<Always>> : never;
     /**
      * Extracts the return value from a state completion transition.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type DoneReturn<Config> = Config extends {
         readonly onDone?: infer OnDone;
-    } ? NonNullable<OnDone> extends (...args: any) => infer Ret ? Ret : never : never;
+    } ? EventTransitionReturn<NonNullable<OnDone>> : never;
     /**
      * Extracts the return value from a final state output function.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type FinalOutputReturn<Config> = Config extends {
         readonly output?: infer Output;
@@ -2326,14 +2690,14 @@ export declare namespace Machine {
      * Extracts all service requirements contributed by a state handler config.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type ConfigServices<Config> = Effect.Services<EventHandlerReturn<Config>> | Effect.Services<AlwaysReturn<Config>> | Effect.Services<DoneReturn<Config>> | Effect.Services<StateActionReturn<Config, "entry">> | Effect.Services<StateActionReturn<Config, "exit">> | Effect.Services<StateInitialReturn<Config>> | Effect.Services<HistoryDefaultReturn<Config>> | InvokeRequirements<Config>;
+    type ConfigServices<Config> = Effect.Services<EventHandlerReturn<Config>> | Effect.Services<AlwaysReturn<Config>> | Effect.Services<DoneReturn<Config>> | Effect.Services<StateActionReturn<Config, "entry">> | Effect.Services<StateActionReturn<Config, "exit">> | Effect.Services<StateInitialReturn<Config>> | Effect.Services<HistoryDefaultReturn<Config>> | Effect.Services<ChoiceReturn<Config>> | InvokeRequirements<Config>;
     /**
      * Configuration for invoking a child process while a state is active.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface InvokeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Event, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError, ChildEmits = never, DeliveredOutput = ChildOutput> {
         readonly [InvokeTypeId]: {
@@ -2344,6 +2708,8 @@ export declare namespace Machine {
             readonly requirements: Types.Covariant<ChildRequirements>;
             readonly initialError: Types.Covariant<ChildInitialError>;
         };
+        /** @internal Serializable descriptor metadata used by inspection. */
+        readonly [Activities.ActivityMetadataTypeId]?: Activities.StaticActivityMetadata;
         readonly id: string;
         /**
          * Optional parent-local address for sending events to this invocation.
@@ -2381,7 +2747,7 @@ export declare namespace Machine {
      * event before constructing one or more invoke configurations.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type InvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeDefinitionValue | ReadonlyArray<InvokeDefinitionValue> | ((context: InvokeContext<States, Events, Emits, StateId>) => InvokeDefinitionValue | ReadonlyArray<InvokeDefinitionValue>);
     type OutputHandlerConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Context> = NodeByIdentifier<States, StateId> extends {
@@ -2400,18 +2766,32 @@ export declare namespace Machine {
      * Configuration accepted for a non-final state.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type ActiveStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R> = {
-        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<any, any>;
-        readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<any, any>;
+        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
+        readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
         readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>;
-        readonly always?: (context: AlwaysContext<States, Events, Emits, StateId>) => HandlerResult<States, any, any>;
-        readonly onDone?: (context: DoneContext<States, Events, Emits, StateId>) => HandlerResult<States, any, any>;
+        readonly always?: ((context: AlwaysContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
+            /** Statically declared upper bound of possible target paths. */
+            readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
+            readonly transition: (context: AlwaysContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
+        };
+        readonly onDone?: ((context: DoneContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
+            /** Statically declared upper bound of possible target paths. */
+            readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
+            readonly transition: (context: DoneContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
+        };
         readonly on?: {
-            readonly [EventTag in TagOf<Events[number]>]?: ((context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>) => HandlerResult<States, any, any>) | {
+            readonly [EventTag in TagOf<Events[number]>]?: ((context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>) | {
                 readonly reenter?: boolean;
-                readonly transition: (context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>) => HandlerResult<States, any, any>;
+                /**
+                 * Upper bound of state or history paths this handler may target.
+                 * Returning `void` is always permitted. Declaring a parent state also
+                 * permits concrete descendant targets below it.
+                 */
+                readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
+                readonly transition: (context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, any, any>;
             };
         };
         readonly initial?: StateInitialHandler<States, Events, Emits, StateId>;
@@ -2429,30 +2809,51 @@ export declare namespace Machine {
     /** Context passed to an implicit child-state initializer. */
     type StateInitialContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = StateActionContext<States, Events, Emits, StateId>;
     /** Initial child value implementation for a compound or parallel state. */
-    type StateInitialHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = (context: StateInitialContext<States, Events, Emits, StateId>) => StateInitialValue<States, StateId> | Effect.Effect<StateInitialValue<States, StateId>, any, any>;
+    type StateInitialHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = (context: StateInitialContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateInitialValue<States, StateId>;
     /** Context used only when a history node has no previously captured record. */
-    interface HistoryDefaultContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
+    interface HistoryDefaultContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>> {
         readonly event: LifecycleEvent<Events>;
-        readonly runtime: RuntimeEffect<Events, Emits>;
-        readonly target: FullTargetBuilder<States>;
+        readonly target: HistoryDefaultTargetBuilder<States, ParentId>;
         readonly parent: ParentId;
     }
-    /** Typed fallback evaluated when a history node has no record yet. */
-    type HistoryDefaultHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>> = (context: HistoryDefaultContext<States, Events, Emits, ParentId>) => SnapshotByIdentifier<States, ParentId> | StateConstruction<SnapshotByIdentifier<States, ParentId>> | Effect.Effect<SnapshotByIdentifier<States, ParentId> | StateConstruction<SnapshotByIdentifier<States, ParentId>>, any, any>;
+    /**
+     * Typed fallback evaluated when a history node has no record yet.
+     *
+     * The fallback constructs a complete root configuration containing the
+     * history owner. This makes the default independent of the transition source
+     * and provides every inactive ancestor and required parallel region.
+     */
+    type HistoryDefaultHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>> = (context: HistoryDefaultContext<States, Events, Emits, ParentId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => CompleteSnapshotContaining<States, ParentId> | StateConstruction<CompleteSnapshotContaining<States, ParentId>>;
     /** Default implementations keyed by direct history child. */
     type HistoryDefaultConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>, Children extends StateSchemas> = {
         readonly [Key in HistoryStateKey<Children>]?: {
             readonly default: HistoryDefaultHandler<States, Events, Emits, ParentId>;
         };
     };
+    /** Required implementation for a choice pseudo-state. */
+    interface ChoiceStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>> {
+        readonly choice: {
+            /** Statically inspectable upper bound of every possible target. */
+            readonly targets: readonly [StateNodeIdentifier<States>, ...ReadonlyArray<StateNodeIdentifier<States>>];
+            readonly transition: (context: ChoiceContext<States, Events, Emits, ChoiceId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => ChoiceResult<States, any, any>;
+        };
+        readonly entry?: never;
+        readonly exit?: never;
+        readonly invoke?: never;
+        readonly always?: never;
+        readonly on?: never;
+        readonly onDone?: never;
+        readonly output?: never;
+        readonly initial?: never;
+    }
     /**
      * Configuration accepted for a final state.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type FinalStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = {
-        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<any, any>;
+        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
         readonly exit?: never;
         readonly always?: never;
         readonly onDone?: never;
@@ -2462,32 +2863,50 @@ export declare namespace Machine {
      * Configuration accepted by `handle` for a state tag.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     type HandlerConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R> = NodeByIdentifier<States, StateId> extends {
         readonly type: "final";
     } ? FinalStateConfig<States, Events, Emits, StateId> : ActiveStateConfig<States, Events, Emits, StateId, E, R>;
+    type HandlerNodeConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Path extends StateNodeIdentifier<States>, E, R> = Path extends ChoiceIdentifier<States> ? ChoiceStateConfig<States, Events, Emits, Path> : Path extends StateIdentifier<States> ? HandlerConfig<States, Events, Emits, Path, E, R> : never;
     type HandlerChildren<Node> = Node extends {
         readonly states: infer Children extends StateSchemas;
     } ? Children : never;
-    type HandlerStateId<States extends StateSchemas, Path extends string> = StateIdentifierFromPath<States, Path>;
+    type HandlerNodeId<States extends StateSchemas, Path extends string> = Extract<Path, StateNodeIdentifier<States>>;
     type HandlerConfigPart<Config> = {
         readonly [Key in keyof Config as Key extends "states" ? never : Key]: Config[Key];
     };
-    type HandlerNode<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, StateId extends StateIdentifier<AllStates>> = HandlerConfig<AllStates, Events, Emits, StateId, E, R> & (HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? {
+    type HandlerNodeChildrenConfig<Config> = "states" extends keyof Config ? Config extends {
+        readonly states?: infer Children;
+    } ? NonNullable<Children> : never : never;
+    type HandlerNodeByPath<States extends StateSchemas, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof States ? States[Head] extends {
+        readonly states: infer Children extends StateSchemas;
+    } ? HandlerNodeByPath<Children, Rest> : never : never : Path extends keyof States ? States[Path] : never;
+    type HandlerConfigAtPath<Config, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Config ? HandlerConfigAtPath<HandlerNodeChildrenConfig<Config[Head]>, Rest> : never : Path extends keyof Config ? Config[Path] : never;
+    type HandlerValidationAtPath<Path extends string, Validation> = Path extends `${infer Head}.${infer Rest}` ? {
+        readonly [Key in Head]?: {
+            readonly states: HandlerValidationAtPath<Rest, Validation>;
+        };
+    } : {
+        readonly [Key in Path]?: Validation;
+    };
+    type HandlerNode<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, StateId extends StateNodeIdentifier<AllStates>> = HandlerNodeConfig<AllStates, Events, Emits, StateId, E, R> & (StateId extends ChoiceIdentifier<AllStates> ? {
+        readonly states?: never;
+        readonly history?: never;
+    } : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? {
         readonly states?: never;
         readonly history?: never;
     } : {
-        readonly states?: HandlerTree<AllStates, Children, Events, Emits, E, R, StateId>;
-        readonly history?: HistoryDefaultConfig<AllStates, Events, Emits, StateId, Children>;
+        readonly states?: HandlerTree<AllStates, Children, Events, Emits, E, R, Extract<StateId, StateIdentifier<AllStates>>>;
+        readonly history?: HistoryDefaultConfig<AllStates, Events, Emits, Extract<StateId, StateIdentifier<AllStates>>, Children>;
     } : {
         readonly states?: never;
         readonly history?: never;
     });
     type HandlerTree<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, Prefix extends string> = {
-        readonly [Key in ActiveStateKey<States>]?: HandlerNode<AllStates, States[Key], Events, Emits, E, R, HandlerStateId<AllStates, JoinPath<Prefix, Key>>>;
+        readonly [Key in ActiveStateKey<States> | ChoiceStateKey<States>]?: HandlerNode<AllStates, States[Key], Events, Emits, E, R, HandlerNodeId<AllStates, JoinPath<Prefix, Key>>>;
     };
-    type HandlerNodeConfigKey = "always" | "entry" | "exit" | "history" | "initial" | "invoke" | "on" | "onDone" | "output" | "states";
+    type HandlerNodeConfigKey = "always" | "choice" | "entry" | "exit" | "history" | "initial" | "invoke" | "on" | "onDone" | "output" | "states";
     type HandlerValidationError<Message extends string, Path extends string, Detail = unknown> = {
         readonly "~effect/Machine/HandlerError": readonly [message: Message, path: Path, detail: Detail];
     };
@@ -2525,19 +2944,36 @@ export declare namespace Machine {
             readonly [Key in UnknownKeys]: HandlerValidationError<"Handler config contains an event key that does not exist", StateId, Key>;
         };
     } : unknown;
-    type HandlerDepth = readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown];
-    type HandlerNextDepth<Depth extends ReadonlyArray<unknown>> = Depth extends readonly [unknown, ...infer Rest extends ReadonlyArray<unknown>] ? Rest : readonly [];
-    type HandlerChildrenValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = "states" extends keyof Config ? Depth extends readonly [] ? {
-        readonly states: HandlerValidationError<"Handler nesting exceeds the supported depth", Prefix>;
-    } : Config extends {
+    type TransitionResultTargetPath<Result> = IsAny<Result> extends true ? never : Result extends Effect.Effect<infer Success, any, any> ? TransitionResultTargetPath<Success> : Result extends StateConstruction<infer Constructed> ? TransitionResultTargetPath<Constructed> : Result extends {
+        readonly path: infer Path extends string;
+    } ? Path : never;
+    type DeclaredTransitionTarget<Transition> = Transition extends {
+        readonly targets: infer Targets extends ReadonlyArray<string>;
+    } ? Targets[number] : never;
+    type ExcludeDeclaredTransitionTarget<Returned, Declared extends string> = Returned extends string ? Returned extends Declared | `${Declared}.${string}` ? never : Returned : never;
+    type UndeclaredTransitionTarget<Transition> = "targets" extends keyof Transition ? ExcludeDeclaredTransitionTarget<TransitionResultTargetPath<EventTransitionReturn<Transition>>, DeclaredTransitionTarget<Transition>> : never;
+    type HandlerOnTargetValidationErrors<StateId extends string, On> = {
+        readonly [EventTag in keyof On as [UndeclaredTransitionTarget<On[EventTag]>] extends [never] ? never : EventTag]: HandlerValidationError<"Transition returns a target not listed in targets", StateId, readonly [event: EventTag, target: UndeclaredTransitionTarget<On[EventTag]>]>;
+    };
+    type HandlerOnTargetValidation<StateId extends string, Config> = "on" extends keyof Config ? Config extends {
+        readonly on?: infer On;
+    } ? HandlerOnTargetValidationErrors<StateId, NonNullable<On>> extends infer Errors ? keyof Errors extends never ? unknown : {
+        readonly on: Errors;
+    } : never : unknown : unknown;
+    type HandlerDirectTargetValidation<StateId extends string, Config, Trigger extends "always" | "onDone", Transition = Config extends {
+        readonly [Key in Trigger]?: infer Value;
+    } ? NonNullable<Value> : never, Undeclared extends string = UndeclaredTransitionTarget<Transition>> = Trigger extends keyof Config ? [Undeclared] extends [never] ? unknown : {
+        readonly [Key in Trigger]: HandlerValidationError<"Transition returns a target not listed in targets", StateId, readonly [trigger: Trigger, target: Undeclared]>;
+    } : unknown;
+    type HandlerChildrenValidation<Node, Prefix extends string, Config> = "states" extends keyof Config ? Config extends {
         readonly states?: infer ChildrenConfig;
     } ? HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? {
         readonly states: HandlerValidationError<"Handler config contains child states for a state that has no children", Prefix>;
-    } : HandlerTreeValidation<AllStates, Children, Events, Emits, Prefix, NonNullable<ChildrenConfig>, AvailableOutputStates, HandlerNextDepth<Depth>> extends infer Validation ? unknown extends Validation ? unknown : {
+    } : HandlerUnknownStateKeyValidation<Children, Prefix, NonNullable<ChildrenConfig>> extends infer Validation ? unknown extends Validation ? unknown : {
         readonly states: Validation;
-    } : never : {
+    } : never : never : {
         readonly states: HandlerValidationError<"Handler config contains child states for a state that has no children", Prefix>;
-    } : unknown : unknown;
+    } : unknown;
     type HandlerOutputRequirementValidation<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, AvailableOutputStates extends StateIdentifier<AllStates>, Config> = ("onDone" extends keyof Config ? [
         Exclude<RequiredCompletionOutputStates<AllStates, StateId>, AvailableOutputStates>
     ] extends [never] ? unknown : {
@@ -2549,7 +2985,15 @@ export declare namespace Machine {
     ] extends [never] ? unknown : {
         readonly output: HandlerValidationError<"Handler config is missing a region output implementation required by parallel output", StateId, Exclude<RequiredParallelOutputStates<AllStates, StateId>, AvailableOutputStates>>;
     } : unknown : unknown);
-    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerInvokeOutputValidation<Events, StateId, Config> & HandlerInvokeEmitsValidation<Events, StateId, Config> & HandlerInvokeSnapshotValidation<Events, StateId, Config> & HandlerChildrenValidation<AllStates, Node, Events, Emits, StateId, Config, AvailableOutputStates, Depth> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config>;
+    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = StateId extends ChoiceIdentifier<AllStates> ? HandlerChoiceUnknownConfigKeyValidation<StateId, Config> & HandlerChoiceTargetValidation<StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : StateId extends StateIdentifier<AllStates> ? HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerOnTargetValidation<StateId, Config> & HandlerDirectTargetValidation<StateId, Config, "always"> & HandlerDirectTargetValidation<StateId, Config, "onDone"> & HandlerInvokeOutputValidation<Events, StateId, Config> & HandlerInvokeEmitsValidation<Events, StateId, Config> & HandlerInvokeSnapshotValidation<Events, StateId, Config> & HandlerChildrenValidation<Node, StateId, Config> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : unknown;
+    type HandlerChoiceUnknownConfigKeyValidation<StateId extends string, Config, UnknownKeys extends string = Exclude<Extract<keyof Config, string>, "choice">> = [UnknownKeys] extends [never] ? unknown : {
+        readonly [Key in UnknownKeys]: HandlerValidationError<"Choice handler config contains an invalid key", StateId, Key>;
+    };
+    type HandlerChoiceTargetValidation<StateId extends string, Config> = Config extends {
+        readonly choice: infer Choice;
+    } ? [UndeclaredTransitionTarget<Choice>] extends [never] ? unknown : {
+        readonly choice: HandlerValidationError<"Choice resolver returns a target not listed in targets", StateId, UndeclaredTransitionTarget<Choice>>;
+    } : unknown;
     type HandlerInvokeOutputValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeOutput<InvokeReturn<Config>>, EventOf<Events> | void>] extends [never] ? unknown : {
         readonly invoke: HandlerValidationError<"Invoked child output must be a machine event or void", StateId, Exclude<InvokeOutput<InvokeReturn<Config>>, EventOf<Events> | void>>;
     };
@@ -2560,20 +3004,9 @@ export declare namespace Machine {
         readonly invoke: HandlerValidationError<"Invoked child snapshot mapper must return a machine event or undefined", StateId, Exclude<InvokeSnapshotEvent<InvokeReturn<Config>>, EventOf<Events> | undefined>>;
     };
     type HandlerRuntimeValidation<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends string, Config, Incompatible = IncompatibleRuntime<ConfigServices<HandlerConfigPart<Config>>, EventOf<Events>, EmitOf<Emits>>> = [Incompatible] extends [never] ? unknown : HandlerValidationError<"Handler config requires an incompatible machine runtime", StateId, Incompatible>;
-    type HandlerTreeNodeValidationMap<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = {
-        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]?: HandlerNodeValidation<AllStates, States[Key], Events, Emits, HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], AvailableOutputStates, Depth>;
-    };
-    type HandlerTreeNodeValidationErrors<Validations> = {
-        readonly [Key in keyof Validations as unknown extends Validations[Key] ? never : Key]?: Validations[Key];
-    };
-    type HandlerTreeNodeValidations<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = HandlerTreeNodeValidationMap<AllStates, States, Events, Emits, Prefix, Config, AvailableOutputStates, Depth> extends infer Validations ? HandlerTreeNodeValidationErrors<Validations> extends infer Errors ? keyof Errors extends never ? unknown : Errors : never : never;
-    type HandlerTreeValidation<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown> = HandlerDepth> = HandlerUnknownStateKeyValidation<States, Prefix, Config> & HandlerTreeNodeValidations<AllStates, States, Events, Emits, Prefix, Config, AvailableOutputStates, Depth>;
-    type HandlerNodeChildrenConfig<Config> = "states" extends keyof Config ? Config extends {
-        readonly states?: infer Children;
-    } ? NonNullable<Children> : never : never;
-    type HandlerTreeStateIds<AllStates extends StateSchemas, States extends StateSchemas, Prefix extends string, Config, Depth extends ReadonlyArray<unknown> = HandlerDepth> = {
-        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: HandlerImplementedStateId<AllStates, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key]> | HandlerNodeChildStateIds<AllStates, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
-    }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
+    type HandlerNodeValidationAtPath<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>, StateId extends StateNodeIdentifier<AllStates>, NodeConfig = HandlerConfigAtPath<Config, StateId>> = [NodeConfig] extends [never] ? never : HandlerNodeValidation<AllStates, HandlerNodeByPath<AllStates, StateId>, Events, Emits, StateId, NodeConfig, AvailableOutputStates> extends infer Validation ? unknown extends Validation ? never : HandlerValidationAtPath<StateId, Validation> : never;
+    type HandlerTreeNodeValidations<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = Types.UnionToIntersection<StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerNodeValidationAtPath<AllStates, Events, Emits, Config, AvailableOutputStates, StateId> : never : never>;
+    type HandlerTreeValidation<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = HandlerUnknownStateKeyValidation<AllStates, "", Config> & HandlerTreeNodeValidations<AllStates, Events, Emits, Config, AvailableOutputStates>;
     type HandlerHasRequiredInitial<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, Config> = StateId extends RequiredHistoryInitializers<AllStates> ? "initial" extends keyof Config ? true : false : true;
     type HandlerHasRequiredHistoryDefaults<Node, Config> = Node extends {
         readonly states: infer Children extends StateSchemas;
@@ -2582,66 +3015,69 @@ export declare namespace Machine {
     } ? [
         Exclude<HistoryStateKey<Children>, Extract<keyof NonNullable<HistoryConfig>, string>>
     ] extends [never] ? true : false : false : true;
-    type HandlerImplementedStateId<AllStates extends StateSchemas, Node, StateId extends StateIdentifier<AllStates>, Config> = [HistoryIdentifier<AllStates>] extends [never] ? StateId : HandlerHasRequiredInitial<AllStates, StateId, Config> extends true ? HandlerHasRequiredHistoryDefaults<Node, Config> extends true ? StateId : never : never;
-    type HandlerNodeChildStateIds<AllStates extends StateSchemas, Node, Prefix extends string, Config, Depth extends ReadonlyArray<unknown>> = Depth extends readonly [] ? never : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? never : HandlerTreeStateIds<AllStates, Children, Prefix, HandlerNodeChildrenConfig<Config>, HandlerNextDepth<Depth>> : never;
-    type HandlerConfigError<Config> = Effect.Error<EventHandlerReturn<Config>> | Effect.Error<AlwaysReturn<Config>> | Effect.Error<DoneReturn<Config>> | Effect.Error<StateActionReturn<Config, "entry">> | Effect.Error<StateActionReturn<Config, "exit">> | Effect.Error<StateInitialReturn<Config>> | Effect.Error<HistoryDefaultReturn<Config>> | InvokeError<Config>;
-    type HandlerTreeError<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, States extends StateSchemas, Prefix extends string, Config, Depth extends ReadonlyArray<unknown> = HandlerDepth> = {
-        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: HandlerConfigError<HandlerConfigPart<Config[Key]>> | HandlerNodeChildError<AllStates, Events, Emits, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
-    }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
-    type HandlerNodeChildError<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Node, Prefix extends string, Config, Depth extends ReadonlyArray<unknown>> = Depth extends readonly [] ? never : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? never : HandlerTreeError<AllStates, Events, Emits, Children, Prefix, HandlerNodeChildrenConfig<Config>, HandlerNextDepth<Depth>> : never;
-    type HandlerTreeServices<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, States extends StateSchemas, Prefix extends string, Config, Depth extends ReadonlyArray<unknown> = HandlerDepth> = {
-        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: ConfigServices<HandlerConfigPart<Config[Key]>> | HandlerNodeChildServices<AllStates, Events, Emits, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
-    }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
-    type HandlerNodeChildServices<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Node, Prefix extends string, Config, Depth extends ReadonlyArray<unknown>> = Depth extends readonly [] ? never : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? never : HandlerTreeServices<AllStates, Events, Emits, Children, Prefix, HandlerNodeChildrenConfig<Config>, HandlerNextDepth<Depth>> : never;
-    type HandlerTreeOutputStates<AllStates extends StateSchemas, States extends StateSchemas, Prefix extends string, Config, Depth extends ReadonlyArray<unknown> = HandlerDepth> = {
-        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: HandlerOutputStates<AllStates, HandlerStateId<AllStates, JoinPath<Prefix, Key>>, HandlerConfigPart<Config[Key]>> | HandlerNodeChildOutputStates<AllStates, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
-    }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
-    type HandlerNodeChildOutputStates<AllStates extends StateSchemas, Node, Prefix extends string, Config, Depth extends ReadonlyArray<unknown>> = Depth extends readonly [] ? never : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? never : HandlerTreeOutputStates<AllStates, Children, Prefix, HandlerNodeChildrenConfig<Config>, HandlerNextDepth<Depth>> : never;
-    type HandleTreeResult<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<AllStates>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<AllStates>, Output, OutputStates extends StateIdentifier<AllStates>, InputEvents extends ReadonlyArray<TaggedSchema>, Config> = Machine<AllStates, Events, Input, Exclude<UnhandledStates, HandlerTreeStateIds<AllStates, AllStates, "", Config>>, E | HandlerTreeError<AllStates, Events, Emits, AllStates, "", Config>, ExcludeCompatibleRuntime<R | HandlerTreeServices<AllStates, Events, Emits, AllStates, "", Config>, EventOf<Events>, EmitOf<Emits>>, InitialE, InitialR, FinalStates, Output, Emits, OutputStates | Extract<HandlerTreeOutputStates<AllStates, AllStates, "", Config>, StateIdentifier<AllStates>>, InputEvents>;
+    type HandlerHasRequiredChoices<Node, Config> = Node extends {
+        readonly states: infer Children extends StateSchemas;
+    } ? [ChoiceStateKey<Children>] extends [never] ? true : Config extends {
+        readonly states?: infer ChildrenConfig;
+    } ? [
+        Exclude<ChoiceStateKey<Children>, Extract<keyof NonNullable<ChildrenConfig>, string>>
+    ] extends [never] ? true : false : false : true;
+    type HandlerImplementedStateId<AllStates extends StateSchemas, Node, StateId extends StateIdentifier<AllStates>, Config> = [HistoryIdentifier<AllStates> | ChoiceIdentifier<AllStates>] extends [never] ? StateId : HandlerHasRequiredInitial<AllStates, StateId, Config> extends true ? HandlerHasRequiredHistoryDefaults<Node, Config> extends true ? HandlerHasRequiredChoices<Node, Config> extends true ? StateId : never : never : never;
+    type HandlerConfigError<Config> = Effect.Error<EventHandlerReturn<Config>> | Effect.Error<AlwaysReturn<Config>> | Effect.Error<DoneReturn<Config>> | Effect.Error<StateActionReturn<Config, "entry">> | Effect.Error<StateActionReturn<Config, "exit">> | Effect.Error<StateInitialReturn<Config>> | Effect.Error<HistoryDefaultReturn<Config>> | Effect.Error<ChoiceReturn<Config>> | InvokeError<Config>;
+    type HandlerNodeEvidence<AllStates extends StateSchemas, Config, StateId extends StateNodeIdentifier<AllStates>, NodeConfig = HandlerConfigAtPath<Config, StateId>> = [NodeConfig] extends [never] ? never : {
+        readonly stateId: StateId extends StateIdentifier<AllStates> ? HandlerImplementedStateId<AllStates, HandlerNodeByPath<AllStates, StateId>, StateId, NodeConfig> : never;
+        readonly error: HandlerConfigError<HandlerConfigPart<NodeConfig>>;
+        readonly services: ConfigServices<HandlerConfigPart<NodeConfig>>;
+        readonly outputState: StateId extends StateIdentifier<AllStates> ? HandlerOutputStates<AllStates, StateId, HandlerConfigPart<NodeConfig>> : never;
+    };
+    type HandlerTreeEvidence<AllStates extends StateSchemas, Config> = StateNodeIdentifier<AllStates> extends infer StateId extends StateNodeIdentifier<AllStates> ? StateId extends StateNodeIdentifier<AllStates> ? HandlerNodeEvidence<AllStates, Config, StateId> : never : never;
+    type HandleTreeResult<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<AllStates>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<AllStates>, Output, OutputStates extends StateIdentifier<AllStates>, InputEvents extends ReadonlyArray<TaggedSchema>, Config> = Machine<AllStates, Events, Input, Exclude<UnhandledStates, HandlerTreeEvidence<AllStates, Config>["stateId"]>, E | HandlerTreeEvidence<AllStates, Config>["error"], ExcludeCompatibleRuntime<R | HandlerTreeEvidence<AllStates, Config>["services"], EventOf<Events>, EmitOf<Emits>>, InitialE, InitialR, FinalStates, Output, Emits, OutputStates | Extract<HandlerTreeEvidence<AllStates, Config>["outputState"], StateIdentifier<AllStates>>, InputEvents>;
     /**
      * Adds state handlers from a root state object.
      *
-     * **Gotchas**
-     *
-     * Type inference traverses up to eight nested child-state objects. Deeper
-     * handler trees are rejected explicitly instead of silently dropping their
-     * error, service, final-state, or output channels.
-     *
      * @category combinators
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface Handler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<States>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<States>, Output, OutputStates extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>> {
-        <const Config extends HandlerTree<States, States, Events, Emits, E, R, "">>(config: Config & HandlerTreeValidation<States, States, Events, Emits, "", NoInfer<Config>, OutputStates | Extract<HandlerTreeOutputStates<States, States, "", NoInfer<Config>>, StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, Config>;
+        <const Config extends HandlerTree<States, States, Events, Emits, E, R, "">>(config: Config & HandlerTreeValidation<States, Events, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, Config>;
     }
     /**
      * Any state config.
      *
      * @category utility types
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type AnyStateConfig = StateConfig<any, any, any, any, any, any, any>;
+    type AnyStateConfig = StateConfig<any, any, any, any, any, any, any> | ChoiceStateConfig<any, any, any, any>;
     /**
      * Runtime event-handler map stored for a single state tag.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type EventHandlerMap<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, ((context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>) => HandlerResult<States, E, R>) | {
+    type EventHandlerMap<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, ((context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>) | {
         readonly reenter?: boolean;
-        readonly transition: (context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>) => HandlerResult<States, E, R>;
+        /** Statically declared upper bound of possible target paths. */
+        readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
+        readonly transition: (context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>;
     }>>;
     /**
      * Runtime state config stored for a single state tag.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
     interface StateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> {
-        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<E, R>;
-        readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<E, R>;
+        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<E, R>;
+        readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<E, R>;
         readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>;
-        readonly always?: (context: AlwaysContext<States, Events, Emits, StateId>) => HandlerResult<States, E, R>;
-        readonly onDone?: (context: DoneContext<States, Events, Emits, StateId>) => HandlerResult<States, E, R>;
+        readonly always?: ((context: AlwaysContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>) | {
+            readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
+            readonly transition: (context: AlwaysContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>;
+        };
+        readonly onDone?: ((context: DoneContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>) | {
+            readonly targets?: ReadonlyArray<StateNodeIdentifier<States>>;
+            readonly transition: (context: DoneContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => HandlerResult<States, E, R>;
+        };
         readonly output?: ((context: FinalOutputContext<States, Events, StateId>) => unknown) | ((context: ParallelOutputContext<States, Events, StateId>) => unknown);
         readonly on?: EventHandlerMap<States, Events, Emits, StateId, EventTag, E, R>;
     }
@@ -2649,22 +3085,22 @@ export declare namespace Machine {
      * Runtime handler table stored on a machine.
      *
      * @category models
-     * @since 4.0.0
+     * @since 0.4.0
      */
-    type StateConfigs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, StateConfig<States, Events, Emits, StateId, EventTag, E, R>>>;
+    type StateConfigs<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> = Readonly<Record<PropertyKey, StateConfig<States, Events, Emits, StateId, EventTag, E, R> | ChoiceStateConfig<States, Events, Emits, ChoiceIdentifier<States>>>>;
 }
 /**
  * Returns `true` if a value is a `Machine`.
  *
  * @category guards
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const isMachine: (u: unknown) => u is Machine.Any;
 /**
  * Returns `true` if a state snapshot is final for a machine.
  *
  * @category guards
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const isFinal: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, state: Machine.Snapshot<States>) => state is Machine.SnapshotContainingFinal<States, FinalStates>;
 /**
@@ -2699,7 +3135,7 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  * ```
  *
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const defineStates: DefineStates;
 type MakeConfig<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>> = {
@@ -2766,9 +3202,52 @@ interface Make {
  *
  * @see {@link defineStates} for typed initial snapshot builders.
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const make: Make;
+type EventConstructorArgs<EventSchema extends Machine.TaggedSchema> = {} extends EventSchema["~type.make.in"] ? [
+    input?: EventSchema["~type.make.in"]
+] : [input: EventSchema["~type.make.in"]];
+/**
+ * Constructs an event from a schema owned by a machine's protocol.
+ *
+ * **Details**
+ *
+ * The schema constructor runs exactly once. The resulting decoded event is
+ * trusted by this machine and definitions derived from it with `handle`, so
+ * repeated delivery does not decode the same already-constructed value again.
+ * Events supplied through ordinary `send` and `plan` calls remain untrusted
+ * and continue through full runtime schema validation.
+ * Treat the returned event as immutable after construction.
+ *
+ * The schema must be one of the machine's configured public or internal event
+ * schemas, or a case schema belonging to a configured `Schema.TaggedUnion`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
+ * class Increment extends Schema.TaggedClass<Increment>("Increment")("Increment", {
+ *   by: Schema.Number
+ * }) {}
+ *
+ * const States = Machine.defineStates({ Idle })
+ * const counter = Machine.make({
+ *   states: States.states,
+ *   events: [Increment],
+ *   initial: () => States.initial.Idle.from()
+ * }).handle({ Idle: { on: { Increment: () => States.initial.Idle.from() } } })
+ *
+ * const increment = Machine.event(counter, Increment, { by: 1 })
+ * ```
+ *
+ * @category constructors
+ * @since 0.4.0
+ */
+export declare const event: <const M extends Machine.Any, const EventSchema extends Machine.TaggedSchema>(machine: M, schema: EventSchema & ([EventSchema["Type"]] extends [Machine.Event<M>] ? unknown : never), ...args: EventConstructorArgs<EventSchema>) => EventSchema["Type"];
 /**
  * Encodes a decoded machine snapshot into a normalized data representation.
  *
@@ -2792,9 +3271,29 @@ export declare const make: Make;
  * guarantee JSON-compatible values; schemas used with JSON-backed storage must
  * have JSON-compatible encoded representations.
  *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
+ * const States = Machine.defineStates({ Idle })
+ * const machine = Machine.make({
+ *   states: States.states,
+ *   events: [],
+ *   initial: () => States.initial.Idle.from()
+ * }).handle({ Idle: {} })
+ *
+ * const encoded = Effect.gen(function*() {
+ *   const initial = yield* Machine.planInitial(machine)
+ *   return yield* Machine.encodeSnapshot(machine, initial.state)
+ * })
+ * ```
+ *
  * @see {@link decodeSnapshot} for restoring an encoded snapshot.
  * @category encoding
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const encodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, snapshot: Machine.Snapshot<States>) => Effect.Effect<Machine.EncodedSnapshot, MachineSchemaEncodeError, Machine.SnapshotEncodingServices<States>>;
 /**
@@ -2816,9 +3315,30 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * Decoding restores logical statechart data only. It does not restart invoked
  * processes, recreate spawned children, or restore a previous `MachineRef`.
  *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
+ * const States = Machine.defineStates({ Idle })
+ * const machine = Machine.make({
+ *   states: States.states,
+ *   events: [],
+ *   initial: () => States.initial.Idle.from()
+ * }).handle({ Idle: {} })
+ *
+ * const roundTrip = Effect.gen(function*() {
+ *   const initial = yield* Machine.planInitial(machine)
+ *   const encoded = yield* Machine.encodeSnapshot(machine, initial.state)
+ *   return yield* Machine.decodeSnapshot(machine, encoded)
+ * })
+ * ```
+ *
  * @see {@link encodeSnapshot} for creating the normalized representation.
  * @category decoding
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const decodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>;
 /**
@@ -2862,7 +3382,7 @@ export declare const decodeSnapshot: <const States extends Machine.StateSchemas,
  * @see {@link effect} for one-shot child effects.
  * @see {@link spawn} for children whose lifetime is controlled by actions.
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const invoke: <ChildState, ChildEvent, ChildError = never, ChildRequirements = never, ChildOutput = never, ChildInitialError = never, Event = never, Address extends ChildAddress<never> | undefined = undefined>(config: {
     readonly id: InvokeLifecycleId;
@@ -2897,10 +3417,27 @@ type InvokeEffectConfig<Fx extends Effect.Effect<any, any, any>, SuccessEvent, F
  * Declare mapped outcomes in `internalEvents` unless they are also legitimate
  * public commands.
  *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
+ *   value: Schema.String
+ * }) {}
+ *
+ * const load = Machine.invokeEffect({
+ *   id: "load",
+ *   effect: Effect.succeed("ready"),
+ *   onSuccess: (value) => new Loaded({ value })
+ * })
+ * ```
+ *
  * @see {@link invoke} for arbitrary child process logic.
  * @see {@link after} for a state-scoped delayed event.
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const invokeEffect: <const Fx extends Effect.Effect<any, any, any>, SuccessEvent, FailureEvent = never>(config: InvokeEffectConfig<Fx, SuccessEvent, FailureEvent>) => InvokeEffectResult<Effect.Services<Fx>, SuccessEvent | (InvokeEffectIsInfallible<Fx> extends true ? never : FailureEvent)>;
 /**
@@ -2910,8 +3447,19 @@ export declare const invokeEffect: <const Fx extends Effect.Effect<any, any, any
  * that state exits. The delayed value should normally be declared in
  * `internalEvents`.
  *
+ * **Example**
+ *
+ * ```ts
+ * import { Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class TimedOut extends Schema.TaggedClass<TimedOut>("TimedOut")("TimedOut", {}) {}
+ *
+ * const timeout = Machine.after("5 seconds", new TimedOut({}))
+ * ```
+ *
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const after: <Event extends {
     readonly _tag: PropertyKey;
@@ -2947,7 +3495,7 @@ type RetagArgs<Target extends Machine.TaggedSchema, Source> = [
  * remains authoritative at runtime.
  *
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const retag: <const Target extends Machine.TaggedSchema, const Source extends {
     readonly _tag: PropertyKey;
@@ -2980,61 +3528,150 @@ type InvokeMachineInput<Input extends Schema.Top> = Input extends typeof Schema.
  * @see {@link invoke} for invoking lower-level process logic.
  * @see {@link sendTo} for sending events to the invoked machine.
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const invokeMachine: {
     <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, SnapshotEvent = never, DoneEvent = never, Id extends string = string, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(config: {
-        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>>;
+        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>>;
         readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
         readonly onDone: (context: Machine.InvokeDoneContext<Output>) => DoneEvent | undefined;
     } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>, DoneEvent>;
     <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, SnapshotEvent = never, Id extends string = string, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(config: {
-        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>>;
+        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>>;
         readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
         readonly onDone?: never;
     } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>>;
 };
 /**
- * Plans the initial state for a machine without running deferred actions.
+ * Plans the initial state for a machine without executing actor commands.
  *
  * **Details**
  *
- * The returned plan contains the settled initial snapshot, staged actions,
- * emitted events, and optional final output. Planning may evaluate transition
- * logic and follow completion, eventless, and raised-event steps, but it does
- * not execute effects passed to `action`.
+ * The returned plan contains the settled initial snapshot, actor commands,
+ * emitted events, optional final output, and every startup microstep. Planning
+ * may evaluate transition logic and follow completion, eventless, and
+ * raised-event steps. Transition callbacks are evaluated synchronously.
+ * `startingState` and `initialEntryPaths` describe the normalized
+ * configuration before entry callbacks and settlement begin.
  *
  * **Gotchas**
  *
- * Callers that execute a plan manually must run actions sequentially before
- * publishing its state or delivering its emitted events. `start` performs this
- * protocol automatically.
+ * `start` executes the closed command list as part of the managed actor commit
+ * protocol. Manual planners may inspect commands but need a running actor scope
+ * to execute child-addressed operations.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
+ * const States = Machine.defineStates({ Idle })
+ * const machine = Machine.make({
+ *   states: States.states,
+ *   events: [],
+ *   initial: () => States.initial.Idle.from()
+ * }).handle({ Idle: {} })
+ *
+ * const initialState = Effect.map(Machine.planInitial(machine), (plan) => plan.state)
+ * ```
  *
  * @see {@link plan} for planning a received event.
  * @see {@link start} for the managed runtime protocol.
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
-export declare const planInitial: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<{
+export declare const planInitial: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<{
+    readonly startingState: Machine.Snapshot<States>;
+    readonly initialEntryPaths: ReadonlyArray<Machine.StateIdentifier<States>>;
     readonly state: Machine.Snapshot<States>;
-    readonly actions: ReadonlyArray<Effect.Effect<void, ActionError<InitialR | R>, ActionServices<InitialR | R>>>;
+    readonly commands: ReadonlyArray<Command>;
     readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
+    readonly microsteps: ReadonlyArray<{
+        readonly next: Machine.Snapshot<States>;
+        readonly event: Machine.EventOf<Events> | InitialEvent;
+        readonly transitions: ReadonlyArray<Machine.RetainedTransition<Machine.StateNodeIdentifier<States>, Machine.TagOf<Events[number]>, Machine.StateNodeIdentifier<States>>>;
+        readonly commands: ReadonlyArray<Command>;
+        readonly raisedEvents: ReadonlyArray<Machine.EventOf<Events>>;
+        readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
+        readonly exitPaths: ReadonlyArray<string>;
+        readonly entryPaths: ReadonlyArray<string>;
+        readonly changed: boolean;
+    }>;
 } & ({
     readonly done: true;
     readonly output: Output;
 } | {
     readonly done: false;
     readonly output: undefined;
-}), InitialE | E | InfiniteTransitionError | MachineSchemaDecodeError | StartupError, ExcludeCompatibleRuntime<PlanningServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+}), InitialE | E | InfiniteTransitionError | MachineSchemaDecodeError | StartupError, never>;
+/**
+ * Returns every compiled state node in definition order.
+ *
+ * **Details**
+ *
+ * The result includes atomic, compound, parallel, final, history, and choice
+ * nodes together with their resolved descriptive annotations. Use each node's
+ * `parent` property to reconstruct the complete hierarchy. Pseudo-states are
+ * intentionally omitted from `children` because they can never appear in an
+ * active configuration.
+ *
+ * @category getters
+ * @since 0.4.0
+ */
+export declare const stateNodes: <M extends Machine.Any>(machine: M) => ReadonlyArray<Machine.StateNode<Machine.StateIdentifier<Machine.States<M>>, Machine.HistoryIdentifier<Machine.States<M>>, Machine.ChoiceIdentifier<Machine.States<M>>>>;
+/**
+ * Returns every registered transition handler in state definition order.
+ *
+ * **Details**
+ *
+ * Event handlers retain their handler-key order within each source state and
+ * are followed by eventless and completion handlers. This function does not
+ * execute handlers. Object-form event, eventless, and completion handlers with
+ * a `targets` declaration expose those possible paths; handlers without one
+ * remain dynamic.
+ *
+ * @category getters
+ * @since 0.4.0
+ */
+export declare const transitionDefinitions: <M extends Machine.Any>(machine: M) => ReadonlyArray<Machine.TransitionDefinition<Machine.StateNodeIdentifier<Machine.States<M>>, Machine.TagOf<Machine.Events<M>[number]>, Machine.StateNodeIdentifier<Machine.States<M>>>>;
+/**
+ * Returns serializable descriptions of every state-owned activity.
+ *
+ * **Details**
+ *
+ * Static `invoke`, `invokeEffect`, `after`, and `invokeMachine` descriptors
+ * expose stable ownership and lifecycle metadata without serializing runtime
+ * values. Function-valued invoke factories are represented as dynamic and are
+ * never evaluated during inspection.
+ *
+ * @category getters
+ * @since 0.4.0
+ */
+export declare const activityDefinitions: <M extends Machine.Any>(machine: M) => ReadonlyArray<Machine.ActivityDefinition<Machine.StateIdentifier<Machine.States<M>>>>;
+/**
+ * Returns every state node active in a decoded snapshot, in definition order.
+ *
+ * **Details**
+ *
+ * Active compound ancestors and parallel regions are included together with
+ * their active descendants. History and choice pseudo-states are never active
+ * and are not returned.
+ *
+ * @category getters
+ * @since 0.4.0
+ */
+export declare const configuration: <M extends Machine.Any>(machine: M, state: Machine.Snapshot<Machine.States<M>>) => ReadonlyArray<Machine.ActiveStateNode<Machine.StateIdentifier<Machine.States<M>>, Machine.ChoiceIdentifier<Machine.States<M>>>>;
 /**
  * Returns the event tags handled by the current state snapshot.
  *
  * @category getters
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const enabled: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, state: Machine.Snapshot<States>) => ReadonlyArray<Machine.TagOf<Events[number]>>;
 /**
- * Plans the next state snapshot without running deferred actions.
+ * Plans the next state snapshot synchronously.
  *
  * **Details**
  *
@@ -3045,25 +3682,47 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  *
  * **Gotchas**
  *
- * `plan` returns data; it does not implement the runtime commit protocol. Run
- * actions sequentially, publish `next` only after they succeed, and then
- * deliver `emittedEvents`. A failed action must retain the previously
- * published state and suppress emissions. Events with no enabled transition
- * are ignored and produce an unchanged plan.
+ * `plan` returns data; it does not implement the actor commit protocol.
+ * `start` executes child commands, publishes `next`, and then delivers
+ * `emittedEvents`. Events with no enabled transition are ignored and produce
+ * an unchanged plan.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Off extends Schema.TaggedClass<Off>("Off")("Off", {}) {}
+ * class On extends Schema.TaggedClass<On>("On")("On", {}) {}
+ * class Toggle extends Schema.TaggedClass<Toggle>("Toggle")("Toggle", {}) {}
+ * const States = Machine.defineStates({ Off, On })
+ * const machine = Machine.make({
+ *   states: States.states,
+ *   events: [Toggle],
+ *   initial: () => States.initial.Off.from()
+ * }).handle({ Off: { on: { Toggle: () => States.initial.On.from() } }, On: {} })
+ *
+ * const nextState = Effect.gen(function*() {
+ *   const initial = yield* Machine.planInitial(machine)
+ *   return (yield* Machine.plan(machine, initial.state, new Toggle({}))).next
+ * })
+ * ```
  *
  * @see {@link planInitial} for planning machine startup.
  * @see {@link start} for managed execution and lifecycle observation.
  * @category combinators
- * @since 4.0.0
+ * @since 0.4.0
  */
-export declare const plan: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>, state: Machine.Snapshot<States>, event: Machine.EventOf<InputEvents>) => Effect.Effect<{
+export declare const plan: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, state: Machine.Snapshot<States>, event: Machine.EventOf<InputEvents>) => Effect.Effect<{
     readonly next: Machine.Snapshot<States>;
-    readonly actions: ReadonlyArray<Effect.Effect<void, ActionError<R>, ActionServices<R>>>;
+    readonly commands: ReadonlyArray<Command>;
     readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
     readonly microsteps: ReadonlyArray<{
         readonly next: Machine.Snapshot<States>;
         readonly event: Machine.EventOf<Events> | InitialEvent;
-        readonly actions: ReadonlyArray<Effect.Effect<void, ActionError<R>, ActionServices<R>>>;
+        readonly transitions: ReadonlyArray<Machine.RetainedTransition<Machine.StateNodeIdentifier<States>, Machine.TagOf<Events[number]>, Machine.StateNodeIdentifier<States>>>;
+        readonly commands: ReadonlyArray<Command>;
         readonly raisedEvents: ReadonlyArray<Machine.EventOf<Events>>;
         readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
         readonly exitPaths: ReadonlyArray<string>;
@@ -3076,67 +3735,7 @@ export declare const plan: <const States extends Machine.StateSchemas, const Eve
 } | {
     readonly done: false;
     readonly output: undefined;
-}), E | InfiniteTransitionError | MachineSchemaDecodeError, ExcludeCompatibleRuntime<PlanningServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
-/**
- * Defers an effectful action until the current machine step is planned.
- *
- * **Details**
- *
- * The action's error and service requirements are retained in the machine
- * type without becoming requirements of `plan` or `planInitial`. The managed
- * runtime executes staged actions sequentially before publishing the planned
- * state. Pass a second argument when the planning Effect should return that
- * value after staging.
- *
- * **Example** (Typed staged action)
- *
- * ```ts
- * import { Context, Effect } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Audit extends Context.Service<Audit, {
- *   readonly write: Effect.Effect<void, "AuditError">
- * }>()("example/Audit") {}
- *
- * const writeAudit = Machine.action(
- *   Effect.flatMap(Audit, (audit) => audit.write)
- * )
- * ```
- *
- * @see {@link plan} for inspecting staged actions without executing them.
- * @category combinators
- * @since 4.0.0
- */
-export declare const action: Machine.Action;
-/**
- * Runs staged machine actions sequentially with the supplied runtime.
- *
- * **When to use**
- *
- * Use when you implement a commit protocol around `plan` or `planInitial` and
- * need to execute their staged actions before publishing the planned snapshot.
- *
- * **Gotchas**
- *
- * This function only runs actions. The caller remains responsible for
- * publishing the planned state and delivering planned emitted events after all
- * actions succeed. Process-local operations such as `spawn`, `sendTo`, and
- * `stopChild` fail with `ProcessLocalError` because no managed machine process
- * owns the actions.
- *
- * @see {@link plan} for creating a transition plan.
- * @see {@link planInitial} for creating an initial plan.
- * @category running
- * @since 4.0.0
- */
-export declare const runActions: <E, R, Events, Emits>(actions: Iterable<Effect.Effect<void, E, R>>, runtime: Runtime<Events, Emits>) => Effect.Effect<void, E | ProcessLocalError, Exclude<ExcludeCompatibleRuntime<R, Events, Emits>, MachineRuntimeRequirement>>;
-/**
- * Returns the typed runtime capability for the current machine.
- *
- * @category combinators
- * @since 4.0.0
- */
-export declare const runtime: <const Protocol extends Runtime.Protocol = {}>() => Effect.Effect<Runtime<Runtime.Events<Protocol>, Runtime.Emits<Protocol>>, never, Runtime.Requirement<Runtime.Events<Protocol>, Runtime.Emits<Protocol>>>;
+}), E | InfiniteTransitionError | MachineSchemaDecodeError, never>;
 /**
  * Creates a one-shot child process from an Effect.
  *
@@ -3177,7 +3776,7 @@ export declare const runtime: <const Protocol extends Runtime.Protocol = {}>() =
  * @see {@link transition} for event-driven state.
  * @see {@link logic} for direct control over intermediate snapshots.
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const effect: <Output, Error = never, Requirements = never>(effect: Effect.Effect<Output, Error, Requirements>) => Logic<void, never, Error, Requirements, Output>;
 /**
@@ -3206,7 +3805,7 @@ export declare const effect: <Output, Error = never, Requirements = never>(effec
  * @see {@link effect} for one-shot work.
  * @see {@link transition} for event-driven state.
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const logic: <State, Event = never, Output = void, Error = never, Requirements = never, InitialError = never, InitialRequirements = never>(options: {
     readonly initial: State | ((scope: Logic.Scope<Event>) => Effect.Effect<State, InitialError, InitialRequirements>);
@@ -3225,10 +3824,22 @@ export declare const logic: <State, Event = never, Output = void, Error = never,
  * Each received event runs the transition Effect against the latest state. The
  * resulting state is published before the next queued event is processed.
  *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * const counter = Machine.transition(
+ *   0,
+ *   (count, event: { readonly by: number }) => Effect.succeed(count + event.by)
+ * )
+ * ```
+ *
  * @see {@link effect} for one-shot work.
  * @see {@link logic} for direct process lifecycle control.
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const transition: <State, Event, Error = never, Requirements = never>(initial: State, transition: (state: State, event: Event) => Effect.Effect<State, Error, Requirements>) => Logic<State, Event, Error, Requirements, never>;
 /**
@@ -3238,7 +3849,7 @@ export declare const transition: <State, Event, Error = never, Requirements = ne
  * constructed descriptors for the same pair address the same invoked child.
  *
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const child: <const Id extends string, M extends Machine.Any>(id: Id, machine: M) => ChildMachine<Id, M>;
 /**
@@ -3248,7 +3859,7 @@ export declare const child: <const Id extends string, M extends Machine.Any>(id:
  * the address with `spawn`, `invoke`, or `sendTo`.
  *
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const childAddress: <Event = never>(id: string) => ChildAddress<Event>;
 /**
@@ -3256,20 +3867,19 @@ export declare const childAddress: <Event = never>(id: string) => ChildAddress<E
  *
  * **When to use**
  *
- * Use to create child processes from machine actions when the child
- * should be addressed or stopped by the owning machine instead of tied to a
- * single state's `invoke` lifecycle.
+ * Use from lower-level process logic to create children that should be
+ * addressed or stopped by the owning process instead of tied to a single
+ * state's `invoke` lifecycle.
  *
  * **Gotchas**
  *
- * This effect requires the machine runtime, so it only runs from machine
- * actions. A named child id must be unique for the current parent machine until
- * that child stops.
+ * This Effect requires a managed process runtime. A named child id must be
+ * unique for the current parent until that child stops.
  *
  * @see {@link invoke} for children that start and stop with a state.
  * @see {@link sendTo} for sending events to named children.
  * @category runtime
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const spawn: {
     <ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError = never>(logic: Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>): SpawnResult<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, never, ChildInitialError>;
@@ -3279,7 +3889,7 @@ export declare const spawn: {
  * Sends an event to a named child process of the running machine.
  *
  * @category runtime
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const sendTo: {
     <Child extends ChildMachine.Any>(child: Child, event: ChildMachine.Event<Child>): Effect.Effect<void, StoppedError, MachineRuntimeRequirement>;
@@ -3289,7 +3899,7 @@ export declare const sendTo: {
  * Stops a named child process of the running machine.
  *
  * @category runtime
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const stopChild: {
     <Event>(child: ChildAddress<Event>): Effect.Effect<void, never, MachineRuntimeRequirement>;
@@ -3299,7 +3909,7 @@ export declare const stopChild: {
  * Returns a stream of terminal lifecycle outcomes for a running machine.
  *
  * @category combinators
- * @since 4.0.0
+ * @since 0.4.0
  */
 export declare const watch: <State, Event, Error = never, Output = never>(ref: MachineRef<State, Event, Error, Output>) => Stream.Stream<RuntimeOutcome<State, Error, Output>>;
 /**
@@ -3312,11 +3922,10 @@ export declare const watch: <State, Event, Error = never, Output = never>(ref: M
  *
  * **Details**
  *
- * For each accepted event the runtime plans the complete macrostep, runs staged
- * actions sequentially, stops invokes for exited states, publishes the new
- * state, delivers emitted events, and then starts invokes for entered states.
- * If an action fails, the previous published state is retained and emissions
- * from that plan are suppressed.
+ * For each accepted event the runtime plans the complete synchronous
+ * macrostep, executes closed actor commands, stops invokes for exited states,
+ * publishes the new state, delivers emitted events, and then starts invokes
+ * for entered states.
  *
  * **Gotchas**
  *
@@ -3325,10 +3934,82 @@ export declare const watch: <State, Event, Error = never, Output = never>(ref: M
  * rather than being returned by `send`. Sending after the machine reaches any
  * terminal state fails immediately with `StoppedError`.
  *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
+ * const States = Machine.defineStates({ Idle })
+ * const machine = Machine.make({
+ *   states: States.states,
+ *   events: [],
+ *   initial: () => States.initial.Idle.from()
+ * }).handle({ Idle: {} })
+ *
+ * const state = Effect.gen(function*() {
+ *   const ref = yield* Machine.start(machine)
+ *   return yield* ref.state
+ * })
+ * ```
+ *
  * @see {@link plan} for inspecting the same transition plan without executing it.
  * @see {@link watch} for classified terminal outcomes.
  * @category constructors
- * @since 4.0.0
+ * @since 0.4.0
+ */
+export declare const start: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+/**
+ * Starts a fresh managed runtime from a decoded logical snapshot.
+ *
+ * **Details**
+ *
+ * `resume` validates and normalizes the supplied snapshot before publishing it
+ * as the first state. It does not call the machine's initial function, replay
+ * entry or transition actions, re-deliver raised or emitted events, or
+ * re-evaluate historical completion and eventless transitions. Active-state
+ * invokes start once in ancestor and document order with {@link InitialEvent};
+ * delayed invokes restart their complete duration and invoked machines start
+ * from their own initial state.
+ *
+ * Only logical state, completion, and history metadata are resumed. Queues,
+ * scopes, subscriptions, fibers, spawned children, invoke progress, and prior
+ * runtime status are process-local and are not restored. A final snapshot
+ * immediately produces a completed ref with its current-machine output.
+ *
+ * Decode encoded data explicitly with {@link decodeSnapshot} before calling
+ * this function. Stable snapshots are hosted as supplied; newly enabled
+ * eventless or completion transitions in a changed machine definition are not
+ * evaluated merely because the runtime was resumed; only ordinary subsequent
+ * transition planning can enter and stabilize states.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Schema } from "effect"
+ * import { Machine } from "@typeonce/effect-machine"
+ *
+ * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
+ * const States = Machine.defineStates({ Idle })
+ * const machine = Machine.make({
+ *   states: States.states,
+ *   events: [],
+ *   initial: () => States.initial.Idle.from()
+ * }).handle({ Idle: {} })
+ *
+ * const resumed = Effect.gen(function*() {
+ *   const initial = yield* Machine.planInitial(machine)
+ *   const encoded = yield* Machine.encodeSnapshot(machine, initial.state)
+ *   const snapshot = yield* Machine.decodeSnapshot(machine, encoded)
+ *   return yield* Machine.resume(machine, snapshot)
+ * })
+ * ```
+ *
+ * @see {@link decodeSnapshot} for the schema and transport boundary.
+ * @see {@link start} for ordinary initial startup.
+ * @category constructors
+ * @since 0.4.0
  */
-export declare const start: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+export declare const resume: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & EnsureExecutable<States, UnhandledStates, OutputStates>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
 //# sourceMappingURL=Machine.d.ts.map