@typeonce/effect-machine 0.31.1 → 0.32.0

package/dist/Machine.d.ts

@@ -18,6 +18,7 @@ import type { ChildAlreadyExistsError, InfiniteTransitionError, MachineSchemaDec
 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 { ExcludeCompatibleRuntime } from "./internal/machine/requirements.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";
@@ -109,6 +110,8 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
      * @since 0.4.0
      */
     readonly states: States;
+    /** Root descriptor for topology and snapshot access. */
+    readonly root: State<Extract<Omit<States[""], "~effect/Machine/ExplicitInitial">, Machine.StateNodeConfig>>;
     /**
      * Events accepted through public machine input boundaries.
      *
@@ -186,15 +189,15 @@ export interface Definition<States extends Machine.StateSchemas, Events extends
      * **Example**
      *
      * ```ts
-     * const counter = definition.handle({
+     * const counter = definition.handle({ states: {
      *   Count: {
      *     on: {
      *       Increment: (to) =>
-     *         to.full.Count().resolve(({ event, state, target }) =>
+     *         to.branch.Count().resolve(({ event, state, target }) =>
      *           target.decoded(new Count({ value: state.value + event.by })))
      *     }
      *   }
-     * })
+     * } })
      * ```
      *
      * @since 0.4.0
@@ -485,7 +488,6 @@ 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: typeof internal.InvokeTypeId;
 declare const TransitionTypeId: typeof internal.TransitionTypeId;
@@ -552,37 +554,58 @@ type ValidateCompoundStateNode<Node extends Machine.StateNodeConfig, Children ex
 type ValidateStateNodeWithoutChildren<Node extends Machine.StateNodeConfig> = "initial" extends keyof Node ? StateDefinitionError<"Atomic states cannot declare an initial child"> : Node extends {
     readonly type: infer Type;
 } ? Type extends "final" ? ValidateOutputSchema<Node> : Type extends "active" | undefined ? "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown : StateDefinitionError<"State node type must be active, final, or parallel"> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : unknown;
-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 Machine.ChoiceStateNodeConfig ? Machine.ChoiceStateNodeConfig : Node extends {
-    readonly type: "parallel";
-    readonly states: infer Children extends Machine.StateSchemas;
-} ? Omit<Node, "states"> & {
-    readonly states: DefineStateTreeInput<Children>;
-} : Node extends {
-    readonly states: infer Children extends Machine.StateSchemas;
-} ? Omit<Node, "initial" | "states"> & {
-    readonly initial: ActiveStateKey<Children> | ChoiceStateKey<Children>;
-    readonly states: DefineStateTreeInput<Children>;
-} : Node;
-type ValidateDefinedStates<States extends Machine.StateSchemas> = [States] extends [
-    Machine.ValidateStateSchemas<States>
-] ? [] : [validation: Machine.ValidateStateSchemas<States>];
-type InvalidDefinedStateTreeInput<States extends Machine.StateSchemas> = [States] extends [
-    Machine.ValidateStateSchemas<States>
-] ? never : States & Machine.ValidateStateSchemas<States>;
 type ReusableStateNodeConfig = Machine.AtomicStateNodeConfig | Machine.CompoundStateNodeConfig | Machine.ParallelStateNodeConfig;
 type ReusableStateValidation<Node> = Node extends ReusableStateNodeConfig ? ValidateStateNode<Node, false, "state"> : StateDefinitionError<"Reusable states must be active state nodes", "state">;
 type ValidateDefinedState<Node> = [Node] extends [ReusableStateValidation<Node>] ? [] : [validation: ReusableStateValidation<Node>];
-type InvalidDefinedStateInput<Node> = [Node] extends [ReusableStateValidation<Node>] ? never : Node & ReusableStateValidation<Node>;
-interface StateConstructor {
-    <const Node>(node: Node & DefineStateNodeInput<NoInfer<Node>>, ..._validation: ValidateDefinedState<NoInfer<Node>>): Node;
-    <const Node>(node: InvalidDefinedStateInput<Node>): never;
+declare const StateTypeId = "~effect/Machine/State";
+/** An immutable state descriptor, usable as a root or a nested state.
+ * @category models
+ * @since 0.32.0
+ */
+export interface State<Node extends Machine.StateNodeConfig> extends Machine.StateAccessors<{
+    readonly "": Node;
+}> {
+    readonly [StateTypeId]: typeof StateTypeId;
+    readonly node: Node;
 }
-interface StatesConstructor {
-    <const States extends Machine.StateSchemas>(states: States & DefineStateTreeInput<NoInfer<States>>, ..._validation: ValidateDefinedStates<NoInfer<States>>): Machine.DefinedStates<States>;
-    <const States extends Machine.StateSchemas>(states: InvalidDefinedStateTreeInput<States>): never;
+type NormalizeState<Node, Tag extends string = ""> = Node extends {
+    readonly [StateTypeId]: typeof StateTypeId;
+    readonly node: infer Config;
+} ? Config : Node extends Machine.TaggedSchema ? Node : "fields" extends keyof Node ? NormalizeStateFields<Node, Tag> : Node extends {
+    readonly states: infer Children;
+} ? Children extends Readonly<Record<string, Machine.TaggedSchema>> ? Node : NormalizeStateFields<Node, Tag> : Node;
+type NormalizeStateFields<Node, Tag extends string> = {
+    readonly [Key in keyof Node as Key extends "fields" ? "schema" : Key]: Key extends "fields" ? Node[Key] extends Schema.Struct.Fields ? Schema.TaggedStruct<Tag, Node[Key]> : never : Key extends "states" ? {
+        readonly [Child in keyof Node[Key]]: NormalizeState<Node[Key][Child], Extract<Child, string>>;
+    } : Node[Key];
+};
+type NormalizedState<Node> = Extract<NormalizeState<Node>, Machine.StateNodeConfig>;
+type StateFieldsValidation<Node> = Node extends {
+    readonly [StateTypeId]: typeof StateTypeId;
+} | Machine.TaggedSchema ? unknown : (Node extends {
+    readonly fields: infer Fields;
+} ? "schema" extends keyof Node ? StateDefinitionError<"Declare fields or schema, not both", ""> : Fields extends Schema.Struct.Fields ? "_tag" extends keyof Fields ? StateDefinitionError<"State fields cannot declare _tag", ""> : unknown : StateDefinitionError<"State fields must be schema fields", ""> : unknown) & (Node extends {
+    readonly states: infer Children;
+} ? {
+    readonly states: {
+        readonly [Key in keyof Children]: StateFieldsValidation<Children[Key]>;
+    };
+} : unknown);
+interface StateInput {
+    readonly schema?: Machine.TaggedSchema;
+    readonly fields?: Schema.Struct.Fields;
+    readonly type?: "active" | "parallel" | "final" | "history" | "choice";
+    readonly initial?: string;
+    readonly states?: Readonly<Record<string, Machine.TaggedSchema | StateInput | {
+        readonly [StateTypeId]: typeof StateTypeId;
+        readonly node: Machine.StateNodeConfig;
+    }>>;
+    readonly history?: "shallow" | "deep";
+    readonly output?: Schema.Top;
+    readonly annotations?: Machine.SchemaLessStateAnnotations;
+}
+interface StateConstructor {
+    <const Node extends StateInput>(node: Node & StateFieldsValidation<NoInfer<Node>>, ..._validation: ValidateDefinedState<NormalizeState<NoInfer<Node>>>): State<NormalizedState<Node>>;
 }
 type EventProtocolError<Message extends string, Tag extends PropertyKey = never> = {
     readonly "~effect/Machine/EventProtocolError": Message;
@@ -593,7 +616,6 @@ type DuplicateEventTag<Events extends ReadonlyArray<Machine.TaggedSchema>, Seen
     ...infer Tail extends ReadonlyArray<Machine.TaggedSchema>
 ] ? Machine.TagOf<Head> extends infer Tag extends PropertyKey ? Extract<Tag, 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 ValidateEmittedEventProtocol<EmittedEvents extends ReadonlyArray<Machine.TaggedSchema>, DuplicateEmitted extends PropertyKey = DuplicateEventTag<EmittedEvents>> = [DuplicateEmitted] extends [never] ? unknown : EventProtocolError<"Emitted event tags must be unique", DuplicateEmitted>;
 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>;
 type ValidateEventProtocolBuilder<Kind extends Machine.EventProtocolKind, Inputs extends ReadonlyArray<Machine.EventProtocolInput<Kind>>, Schemas extends ReadonlyArray<Machine.TaggedSchema> = Machine.EventProtocolInputSchemasOf<Kind, Inputs>, Duplicate extends PropertyKey = DuplicateEventTag<Schemas>> = [Duplicate] extends [never] ? unknown : EventProtocolError<"Event protocol tags must be unique", Duplicate>;
 declare const SnapshotBuilderStateTypeId: typeof internal.SnapshotBuilderStateTypeId;
@@ -606,7 +628,7 @@ type FromCallable<Arguments extends ReadonlyArray<unknown>, Result> = Arguments
     (...args: Rest): Result;
     (...args: Arguments): Result;
 } : (...args: Arguments) => Result : (...args: Arguments) => Result;
-type FromMethod<Arguments extends ReadonlyArray<unknown>, Result> = {
+type FromMethod<in out Arguments extends ReadonlyArray<unknown>, out Result> = {
     /**
      * Constructs the selected state from its schema make input while the
      * machine plans the resulting configuration. The input may be omitted when
@@ -716,12 +738,14 @@ type InitialParallelBuilder<States extends Machine.StateSchemas, Prefix extends
         readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix>;
     }, true>>;
 };
-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 FullSnapshotBuilderWithPrefix<in out States extends Machine.StateSchemas, in out Prefix extends string = ""> = {
+    readonly [Key in ActiveStateKey<States> | ChoiceStateKey<States>]: Key extends ActiveStateKey<States> ? FullSnapshotMethod<States, Key, Prefix> : () => Machine.ChoiceTargetInstruction<Machine.JoinPath<Prefix, Key>>;
+};
+type FullSnapshotMethod<in out States extends Machine.StateSchemas, in out StateId extends ActiveStateKey<States>, in out Prefix extends string> = {
+    readonly [
+    /** Constructs this node using schema make input or an already decoded value. */
+    Method in Machine.NodeSchema<States[StateId]> extends never ? "from" : "from" | "decoded"]: Method extends "from" ? FromCallable<FullSnapshotFromArguments<States, StateId, Prefix>, Machine.StateConstruction<FullSnapshotResult<States, StateId, Prefix>>> : (...args: FullSnapshotArguments<States, StateId, Prefix>) => FullSnapshotResult<States, StateId, Prefix>;
 };
-type FullSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = Machine.NodeSchema<States[StateId]> extends never ? FromMethod<FullSnapshotFromArguments<States, StateId, Prefix>, FullSnapshotResult<States, StateId, Prefix>> : DecodedMethod<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 {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
@@ -784,18 +808,20 @@ type HistorySnapshotResult<States extends Machine.StateSchemas, StateId extends
 } ? Machine.ParallelSnapshot<Path, NodeValue<Node>, HistorySnapshotRegions<Children, Path, Owner>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Machine.CompoundSnapshot<Path, NodeValue<Node>, HistorySnapshotWithPrefix<Children, Owner, Path>> : never : never;
-type HistorySnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Owner extends string> = Machine.NodeSchema<States[StateId]> extends never ? FromMethod<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>> : DecodedMethod<HistorySnapshotArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>> & FromMethod<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, HistorySnapshotResult<States, StateId, Prefix, Owner>>;
+type HistorySnapshotMethod<in out States extends Machine.StateSchemas, in out StateId extends ActiveStateKey<States>, in out Prefix extends string, in out Owner extends string> = {
+    readonly [Key in Machine.NodeSchema<States[StateId]> extends never ? "from" : "from" | "decoded"]: Key extends "from" ? FromCallable<HistorySnapshotFromArguments<States, StateId, Prefix, Owner>, Machine.StateConstruction<HistorySnapshotResult<States, StateId, Prefix, Owner>>> : (...args: HistorySnapshotArguments<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;
+    readonly [Key in ActiveStateKey<States>]: Owner extends Machine.JoinPath<Prefix, Key> | (Machine.JoinPath<Prefix, Key> extends "" ? string : `${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>;
+    readonly [Key in ActiveStateKey<States> as Owner extends Machine.JoinPath<Prefix, Key> | (Machine.JoinPath<Prefix, Key> extends "" ? string : `${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>;
+    readonly [Key in ActiveStateKey<States>]: Owner extends Machine.JoinPath<Prefix, Key> | (Machine.JoinPath<Prefix, Key> extends "" ? string : `${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}` ? NodeBuilderMethod<States[Key], HistorySnapshotArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
+    readonly [Key in Remaining]: Owner extends Machine.JoinPath<Prefix, Key> | (Machine.JoinPath<Prefix, Key> extends "" ? string : `${Machine.JoinPath<Prefix, Key>}.${string}`) ? NodeBuilderMethod<States[Key], HistorySnapshotArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
     }, Constructed>, HistorySnapshotFromArguments<States, Key, Prefix, Owner>, HistoryParallelBuilder<States, Prefix, Owner, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: HistorySnapshotResult<States, Key, Prefix, Owner>;
@@ -805,7 +831,7 @@ type HistoryParallelBuilder<States extends Machine.StateSchemas, Prefix extends
         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 ParentPath<Path extends string> = Machine.ImmediateParentStateIdentifier<Path>;
 type IsCompoundNode<Node> = Node extends {
     readonly type: "parallel";
 } ? false : Node extends {
@@ -832,7 +858,7 @@ type LocalTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States
 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}` ? NestedTargetMethod<Node, LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>, Path> : NodeMethodWithInitial<Node, WithNodeValue<Node, [
+} ? Source extends Path | (Path extends "" ? string : `${Path}.${string}`) ? NestedTargetMethod<Node, LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>, Path> : NodeMethodWithInitial<Node, WithNodeValue<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
 ]>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
@@ -867,7 +893,7 @@ type BranchTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, State
 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}` ? NestedTargetMethod<Node, BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>, Path> & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : NodeMethodWithInitial<Node, WithNodeValue<Node, [
+} ? Source extends Path | (Path extends "" ? string : `${Path}.${string}`) ? NestedTargetMethod<Node, BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>, Path> & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : NodeMethodWithInitial<Node, WithNodeValue<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>
 ]>, Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>, WithNodeInput<Node, [
     states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
@@ -894,16 +920,19 @@ type HasDirectShallowHistory<States extends Machine.StateSchemas> = {
         readonly history: "deep";
     } ? never : Key;
 }[HistoryStateKey<States>] extends never ? false : true;
-type HasValuedActiveChild<States extends Machine.StateSchemas> = {
-    readonly [Key in ActiveStateKey<States>]: Machine.NodeSchema<States[Key]> extends never ? never : Key;
+type RequiresInitialValue<Node> = Machine.NodeSchema<Node> extends never ? false : {} extends NodeMakeInput<Node> ? false : true;
+type HasRequiredActiveChild<States extends Machine.StateSchemas> = {
+    readonly [Key in ActiveStateKey<States>]: RequiresInitialValue<States[Key]> extends true ? Key : never;
 }[ActiveStateKey<States>] extends never ? false : true;
 type InitializerClosureForNode<AllStates extends Machine.StateSchemas, Node, Path extends string> = Node extends {
+    readonly states: infer Declared extends Machine.StateSchemas;
+} ? string extends keyof Declared ? never : Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
-} ? (HasValuedActiveChild<Children> extends true ? Extract<Path, Machine.StateIdentifier<AllStates>> : never) | InitializerClosuresForChildren<AllStates, Children, Path> : Node extends {
+} ? (HasRequiredActiveChild<Children> extends true ? Extract<Path, Machine.StateIdentifier<AllStates>> : never) | InitializerClosuresForChildren<AllStates, Children, Path> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
     readonly initial: infer Initial;
-} ? (Initial extends ActiveStateKey<Children> ? Machine.NodeSchema<Children[Initial]> extends never ? never : Extract<Path, Machine.StateIdentifier<AllStates>> : never) | (Initial extends ActiveStateKey<Children> ? InitializerClosureForNode<AllStates, Children[Initial], Machine.JoinPath<Path, Initial>> : never) : never;
+} ? (Initial extends ActiveStateKey<Children> ? RequiresInitialValue<Children[Initial]> extends true ? Extract<Path, Machine.StateIdentifier<AllStates>> : never : never) | (Initial extends ActiveStateKey<Children> ? InitializerClosureForNode<AllStates, Children[Initial], Machine.JoinPath<Path, Initial>> : never) : never : never;
 type InitializerClosuresForChildren<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
     readonly [Key in ActiveStateKey<States>]: InitializerClosureForNode<AllStates, States[Key], Machine.JoinPath<Prefix, Key>>;
 }[ActiveStateKey<States>];
@@ -1416,7 +1445,7 @@ export declare namespace ChildMachine {
      * @category utility types
      * @since 0.20.0
      */
-    type StartRequirements<Child extends Any> = Child extends ChildMachine<string, infer M> ? Exclude<ExcludeCompatibleRuntime<Exclude<ExecutionServices<Machine.InitialServices<M> | Machine.Services<M>>, MachineRuntimeRequirement>, Machine.Event<M>, Machine.Emit<M>>, Scope.Scope> : never;
+    type StartRequirements<Child extends Any> = Child extends ChildMachine<string, infer M> ? Exclude<ExcludeCompatibleRuntime<Exclude<ExecutionServices<Machine.InitialServices<M> | Machine.Services<M>>, MachineRuntimeRequirement>, Machine.Event<M>, Machine.EmittedEvent<M>>, Scope.Scope> : never;
     /**
      * Running machine reference selected by a child descriptor.
      *
@@ -1582,6 +1611,7 @@ export declare namespace Machine {
         /** @internal */
         readonly [MachineTypeId]: TypeCarrier<any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
         readonly states: StateSchemas;
+        readonly root: Pick<State<Machine.StateNodeConfig>, typeof StateTypeId | "node">;
         readonly events: EventProtocol.Any<"public">;
         readonly internalEvents: EventProtocol.Any<"internal">;
         readonly emittedEvents: EventProtocol.Any<"emitted">;
@@ -1686,8 +1716,6 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type EmittedEvents<M extends Any> = M[typeof MachineTypeId]["emittedEvents"];
-    /** @deprecated Use {@link EmittedEvents}. */
-    type Emits<M extends Any> = EmittedEvents<M>;
     /**
      * Extracts state paths with implemented output handlers.
      *
@@ -1814,9 +1842,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type EmittedEvent<M extends Any> = EmittedEventOf<Emits<M>>;
-    /** @deprecated Use {@link EmittedEvent}. */
-    type Emit<M extends Any> = EmittedEvent<M>;
+    type EmittedEvent<M extends Any> = EmittedEventOf<EmittedEvents<M>>;
     /**
      * A schema whose decoded value contains a `_tag` discriminator.
      *
@@ -1853,8 +1879,6 @@ export declare namespace Machine {
     }
     /** Descriptive annotations accepted by schema-less active and pseudo-states. */
     type SchemaLessStateAnnotations = Pick<StateNodeAnnotations, "title" | "description" | "documentation">;
-    /** @deprecated Use {@link SchemaLessStateAnnotations}. */
-    type PseudoStateAnnotations = SchemaLessStateAnnotations;
     /**
      * Configuration accepted for an atomic object state node.
      *
@@ -2028,20 +2052,16 @@ export declare namespace Machine {
      */
     type InitialBuilder<States extends StateSchemas> = InitialSnapshotBuilderWithPrefix<States>;
     /**
-     * State definitions and snapshot access helpers returned by `states`.
+     * Typed snapshot access shared by state descriptors.
      *
      * **Details**
      *
-     * The `states` property is the original state tree and can be passed directly
-     * to `make`. The remaining helpers match and read snapshots for the same
-     * state tree.
+     * The helpers match and read snapshots for the same captured topology.
      *
      * @category models
      * @since 0.4.0
      */
-    interface DefinedStates<States extends StateSchemas> {
-        /** Captured state tree supplied to {@link states}. */
-        readonly states: States;
+    interface StateAccessors<States extends StateSchemas> {
         /**
          * Checks and preserves one active state path from this definition.
          *
@@ -2061,7 +2081,7 @@ export declare namespace Machine {
          */
         readonly get: {
             <Path extends ValuedStateIdentifier<States>>(snapshot: Snapshot<States>, path: Path): Option.Option<StateByIdentifier<States, Path>>;
-            <const From extends StateIdentifier<States>, const Path extends ValuedStateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | `${NoInfer<From>}.${string}` ? unknown : never)): Option.Option<StateByIdentifier<States, Path>>;
+            <const From extends StateIdentifier<States>, const Path extends ValuedStateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | (NoInfer<From> extends "" ? string : `${NoInfer<From>}.${string}`) ? unknown : never)): Option.Option<StateByIdentifier<States, Path>>;
         };
         /**
          * Returns the decoded value for an active state path together with all of
@@ -2084,7 +2104,7 @@ export declare namespace Machine {
          */
         readonly getSnapshot: {
             <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path): Option.Option<SnapshotByIdentifier<States, Path>>;
-            <const From extends StateIdentifier<States>, const Path extends StateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | `${NoInfer<From>}.${string}` ? unknown : never)): Option.Option<SnapshotByIdentifier<States, Path>>;
+            <const From extends StateIdentifier<States>, const Path extends StateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | (NoInfer<From> extends "" ? string : `${NoInfer<From>}.${string}`) ? unknown : never)): Option.Option<SnapshotByIdentifier<States, Path>>;
         };
         /**
          * Returns whether a state path is active in the snapshot. The supplied
@@ -2096,7 +2116,7 @@ export declare namespace Machine {
          */
         readonly matches: {
             <Path extends StateIdentifier<States>>(snapshot: Snapshot<States>, path: Path): boolean;
-            <const From extends StateIdentifier<States>, const Path extends StateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | `${NoInfer<From>}.${string}` ? unknown : never)): boolean;
+            <const From extends StateIdentifier<States>, const Path extends StateIdentifier<States>>(snapshot: SnapshotByIdentifier<States, From>, path: Path & (Path extends NoInfer<From> | (NoInfer<From> extends "" ? string : `${NoInfer<From>}.${string}`) ? unknown : never)): boolean;
         };
     }
     /**
@@ -2408,20 +2428,31 @@ export declare namespace Machine {
     /** 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 : {
+    type EnsureChoiceImplementations<States extends StateSchemas, UnhandledStates extends StateIdentifier<States>> = IsAny<States> extends true ? unknown : [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>> = IsAny<States> extends true ? unknown : ([HistoryIdentifier<States>] extends [never] ? unknown : [MissingHistoryImplementations<States, UnhandledStates>] extends [never] ? unknown : {
         readonly "~effect/Machine/MissingHistoryImplementation": MissingHistoryImplementations<States, UnhandledStates>;
     }) & EnsureChoiceImplementations<States, UnhandledStates>;
+    /** Owners whose declared default descendants require supplied values. */
+    type RequiredInitializers<States extends StateSchemas> = string extends keyof States ? never : "" extends keyof States ? States[""] extends {
+        readonly "~effect/Machine/ExplicitInitial": true;
+    } ? never : InitializerClosureForNode<States, States[""], ""> : never;
+    /** Proof that initialization can construct every required default value. */
+    type EnsureInitialImplementations<States extends StateSchemas, UnhandledStates extends StateIdentifier<States>> = [Extract<RequiredInitializers<States>, UnhandledStates>] extends [never] ? unknown : {
+        readonly "~effect/Machine/MissingInitialImplementation": Extract<RequiredInitializers<States>, UnhandledStates>;
+    };
     /**
      * Extracts a state-tree node by state path.
      *
      * @category utility types
      * @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 {
+    type NodeByIdentifier<States extends StateSchemas, StateId extends StateIdentifier<States>> = string extends keyof States ? NodeByNamedIdentifier<States, StateId> : "" extends keyof States ? StateId extends "" ? States[""] : States[""] extends {
+        readonly states: infer Children extends StateSchemas;
+    } ? NodeByIdentifier<Children, Extract<StateId, StateIdentifier<Children>>> : never : NodeByNamedIdentifier<States, StateId>;
+    type NodeByNamedIdentifier<States extends StateSchemas, StateId extends string> = StateId extends `${infer Head}.${infer Rest}` ? Head extends keyof States ? States[Head] extends {
         readonly states: infer Children extends StateSchemas;
     } ? Rest extends StateIdentifier<Children> ? NodeByIdentifier<Children, Rest> : never : never : never : StateId extends keyof States ? States[StateId] : never;
     /**
@@ -2453,8 +2484,6 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type EmittedEventOf<Emits extends ReadonlyArray<TaggedSchema>> = Emits[number]["Type"];
-    /** @deprecated Use {@link EmittedEventOf}. */
-    type EmitOf<Emits extends ReadonlyArray<TaggedSchema>> = EmittedEventOf<Emits>;
     /**
      * Event values received by lifecycle callbacks.
      *
@@ -2475,14 +2504,15 @@ export declare namespace Machine {
      * @category utility types
      * @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;
+    type ParentStateIdentifier<StateId extends string> = StateId extends "" ? never : "" | NamedParentStateIdentifier<StateId>;
+    type NamedParentStateIdentifier<StateId extends string> = StateId extends `${infer Parent}.${infer Child}` ? Parent | (Child extends `${string}.${string}` ? `${Parent}.${NamedParentStateIdentifier<Child>}` : never) : never;
     /**
      * Extracts the nearest parent state path from a state identifier.
      *
      * @category utility types
      * @since 0.4.0
      */
-    type ImmediateParentStateIdentifier<StateId extends string> = StateId extends `${infer Head}.${infer Tail}` ? Tail extends `${string}.${string}` ? `${Head}.${ImmediateParentStateIdentifier<Tail>}` : Head : never;
+    type ImmediateParentStateIdentifier<StateId extends string> = StateId extends `${infer Head}.${infer Tail}` ? Tail extends `${string}.${string}` ? `${Head}.${ImmediateParentStateIdentifier<Tail>}` : Head : StateId extends "" ? never : "";
     /**
      * Maps every parent state path of a state identifier to its decoded value.
      *
@@ -2524,7 +2554,7 @@ export declare namespace Machine {
         readonly type: "final";
     } ? OutputByIdentifier<States, StateId> : never;
     type CompoundCompletionOutput<States extends StateSchemas, Children extends StateSchemas, Prefix extends StateIdentifier<States>> = UndefinedIfNever<CompoundCompletionOutputRaw<States, Children, Prefix>>;
-    type CompoundCompletionOutputRaw<States extends StateSchemas, Children extends StateSchemas, Prefix extends StateIdentifier<States>> = {
+    type CompoundCompletionOutputRaw<States extends StateSchemas, Children extends StateSchemas, Prefix extends StateIdentifier<States>> = Prefix extends "" ? TerminalOutput<Children> : {
         readonly [Key in ActiveStateKey<Children>]: DirectFinalCompletionOutput<States, Extract<JoinPath<Prefix, Key>, StateIdentifier<States>>>;
     }[ActiveStateKey<Children>];
     /**
@@ -2650,6 +2680,7 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     interface EncodedSnapshot {
+        readonly version: 2;
         readonly _tag: "MachineSnapshot";
         readonly active: ReadonlyArray<EncodedSnapshotState>;
         readonly completed?: ReadonlyArray<EncodedSnapshotCompletion>;
@@ -2797,7 +2828,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type RootStateIdentifier<StateId extends string> = StateId extends `${infer Root}.${string}` ? Root : StateId;
+    type RootStateIdentifier<StateId extends string> = StateId extends string ? "" : never;
     /**
      * Extracts the public snapshot shape that contains a final state path.
      *
@@ -2839,7 +2870,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface StateConstruction<Result> {
+    interface StateConstruction<out Result> {
         readonly [Topology.StateConstructionTypeId]: Result;
     }
     /**
@@ -2979,7 +3010,11 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type HistoryDefaultTargetBuilder<States extends StateSchemas, Owner extends StateIdentifier<States>> = HistorySnapshotBuilderWithPrefix<States, Owner>;
+    type HistoryDefaultTargetBuilder<States extends StateSchemas, Owner extends StateIdentifier<States>> = HistorySnapshotMethod<{
+        readonly "": Extract<Omit<States[""], "~effect/Machine/ExplicitInitial">, StateNodeConfig>;
+    }, "" & ActiveStateKey<{
+        readonly "": Extract<Omit<States[""], "~effect/Machine/ExplicitInitial">, StateNodeConfig>;
+    }>, "", Owner>;
     /**
      * Builder for source-local transition targets.
      *
@@ -3003,7 +3038,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 0.4.0
      */
-    type BranchTargetBuilder<States extends StateSchemas, Source extends StateNodeIdentifier<States>> = BranchTargetBuilderForRoot<States, Extract<RootStateIdentifier<Source>, ActiveStateKey<States>>, Source>;
+    type BranchTargetBuilder<States extends StateSchemas, Source extends StateNodeIdentifier<States>> = BranchTargetBuilderForRoot<States, Extract<"" extends keyof States ? "" : RootStateIdentifier<Source>, ActiveStateKey<States>>, Source>;
     /**
      * Machine-bound target builders available in transition contexts.
      *
@@ -3023,7 +3058,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface TargetBuilder<States extends StateSchemas, Source extends StateNodeIdentifier<States>> {
+    interface TargetBuilder<in out States extends StateSchemas, in out Source extends StateNodeIdentifier<States>> {
         /**
          * Selects an explicitly targetless transition.
          *
@@ -3095,10 +3130,10 @@ export declare namespace Machine {
     } ? SelectionMethod<Builder, Path, "state", Scope> & InitialSelectionMethod<Builder, Path, Scope> & SelectionTreeWithPrefix<AllStates, Children, Path, Scope, Builder> : SelectionMethod<Builder, Path, "state", Scope>;
     /** @internal */
     type StateUpdateSelectionForNode<AllStates extends StateSchemas, Node, Path extends string, Scope extends "local" | "branch"> = Node extends {
-        readonly states: StateSchemas;
-    } ? NodeSchema<Node> extends never ? {} : {
+        readonly type: "final";
+    } ? {} : NodeSchema<Node> extends never ? {} : {
         readonly update: SelectionValue<StateUpdateBuilder<AllStates, Extract<Path, ValuedStateIdentifier<AllStates>>>, Path, "update", Scope>;
-    } : {};
+    };
     /** @internal */
     type BranchUpdateSelectionPath<AllStates extends StateSchemas, Node, Path extends string, Rest extends string, Scope extends "local" | "branch" = "branch"> = StateUpdateSelectionForNode<AllStates, Node, Path, Scope> & (Node extends {
         readonly states: infer Children extends StateSchemas;
@@ -3110,12 +3145,13 @@ export declare namespace Machine {
     type FullSelectionNode<AllStates extends StateSchemas, Node, Path extends StateIdentifier<AllStates>, Builder> = Node extends {
         readonly states: StateSchemas;
     } ? SelectionMethod<Builder, Path, "state", "full"> & InitialSelectionMethod<Builder, Path, "full"> : SelectionMethod<Builder, Path, "state", "full">;
-    type FullTargetSelector<States extends StateSchemas> = {
-        readonly [Key in Extract<ActiveStateKey<States>, keyof FullTargetBuilder<States>>]: FullSelectionNode<States, States[Key], Extract<Key, StateIdentifier<States>>, FullTargetBuilder<States>[Key]>;
-    };
-    type BranchTargetSelector<States extends StateSchemas, Source extends StateNodeIdentifier<States>, Root extends string = Source extends `${infer Head}.${string}` ? Head : Source> = Root extends ActiveStateKey<States> ? Root extends keyof BranchTargetBuilder<States, Source> ? {
-        readonly [Key in Root]: SelectionNode<States, States[Key], Key, "branch", BranchTargetBuilder<States, Source>[Key]> & (Source extends ChoiceIdentifier<States> ? {} : Source extends `${Key}.${infer Rest}` ? BranchUpdateSelectionPath<States, States[Key], Key, Rest> : StateUpdateSelectionForNode<States, States[Key], Key, "branch">);
-    } : {} : {};
+    type RootBuilder<Builder> = Builder extends {
+        readonly "": infer Root;
+    } ? Root : never;
+    type FullTargetSelector<States extends StateSchemas> = SelectionValue<RootBuilder<FullTargetBuilder<States>>, "", "state", "full"> & InitialSelectionMethod<RootBuilder<FullTargetBuilder<States>>, "", "full">;
+    type BranchTargetSelector<States extends StateSchemas, Source extends StateNodeIdentifier<States>> = States[""] extends {
+        readonly states: infer Children extends StateSchemas;
+    } ? SelectionTreeWithPrefix<States, Children, "", "branch", RootBuilder<BranchTargetBuilder<States, Source>>> & (Source extends ChoiceIdentifier<States> ? {} : Omit<BranchUpdateSelectionPath<States, States[""], "", Source>, "update">) : {};
     type LocalTargetSelector<States extends StateSchemas, Source extends StateNodeIdentifier<States>> = NearestCompoundScope<States, Source> extends infer Scope ? [Scope] extends [never] ? {} : Scope extends StateIdentifier<States> ? ChildrenOf<States, Scope> extends infer Children extends StateSchemas ? LocalTargetBuilder<States, Source> extends infer Builder ? SelectionTreeWithPrefix<States, Children, Scope, "local", Builder> & ("with" extends keyof Builder ? {
         readonly with: SelectionValue<Builder["with"], Scope, "state", "local">;
     } : {}) & (Source extends ChoiceIdentifier<States> ? {} : Scope extends ValuedStateIdentifier<States> ? {
@@ -3136,6 +3172,13 @@ export declare namespace Machine {
      * target-specific resolver APIs retain exact inference.
      */
     interface TargetSelector<States extends StateSchemas, Source extends StateNodeIdentifier<States>> {
+        /** Replaces this handler owner's value without reentry. */
+        /** Selects the current handler owner for a value update without reentry. */
+        readonly self: Source extends ValuedStateIdentifier<States> ? StateUpdateSelectionForNode<States, NodeByIdentifier<States, Source>, Source, "branch"> : {};
+        /** Addresses the root and its retained value from any active descendant. */
+        readonly root: "" extends ActiveStateKey<States> ? SelectionNode<States, States[""], "", "branch", (BranchTargetBuilder<States, Source> extends {
+            readonly "": infer Builder;
+        } ? Builder : never)> & StateUpdateSelectionForNode<States, States[""], "", "branch"> : never;
         /** Handles the trigger without selecting a destination. */
         readonly none: SelectionValue<TargetBuilder<States, Source>["none"], never, "none", "local">;
         /** Selects a destination or updates the nearest active compound scope. */
@@ -3145,7 +3188,9 @@ export declare namespace Machine {
         /** Selects a complete destination under any top-level state. */
         readonly full: FullTargetSelector<States>;
         /** Restores a shallow or deep history pseudo-state. */
-        readonly history: HistorySelectionTree<States, States, "", HistoryTargetBuilder<States>>;
+        readonly history: States[""] extends {
+            readonly states: infer Children extends StateSchemas;
+        } ? HistorySelectionTree<States, Children, "", RootBuilder<HistoryTargetBuilder<States>>> : {};
     }
     /** Definition-time selector that can choose only a valid top-level initial entry. */
     type InitialTargetSelector<States extends StateSchemas> = {
@@ -3430,8 +3475,9 @@ export declare namespace Machine {
      *
      * Handlers return snapshots for complete state replacement, target builder
      * results for path-safe partial transitions, state-value updates, or
-     * `target.none()` for an explicitly targetless transition. Raw decoded state
-     * values and `void` are not accepted at transition boundaries.
+     * an explicit targetless result. In a machine definition, select `to.none`;
+     * its optional resolver returns `undefined`. Raw decoded state values are
+     * not accepted as transition targets.
      *
      * @category utility types
      * @since 0.4.0
@@ -3527,7 +3573,7 @@ export declare namespace Machine {
      */
     type InvokeResolvedSource<Source> = Source extends (...args: any) => infer Resolved ? Resolved : Source;
     type InvokeFactoryResult<Source> = Source extends (...args: any) => infer Resolved ? Resolved : never;
-    type ChildMachineLogic<Child> = Child extends ChildMachine<string, infer M> ? Logic<Snapshot<States<M>>, EventInput<InputEvent<M>>, Error<M> | ActionError<Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialServices<M> | Services<M>>, internalRuntime.MachineRuntime>, Event<M>, Emit<M>>, Output<M>, InitialError<M> | Error<M> | ActionError<InitialServices<M> | Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError> : never;
+    type ChildMachineLogic<Child> = Child extends ChildMachine<string, infer M> ? Logic<Snapshot<States<M>>, EventInput<InputEvent<M>>, Error<M> | ActionError<Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialServices<M> | Services<M>>, internalRuntime.MachineRuntime>, Event<M>, EmittedEvent<M>>, Output<M>, InitialError<M> | Error<M> | ActionError<InitialServices<M> | Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError> : never;
     type InvokeLogic<Invoke> = Invoke extends {
         readonly effect: infer Source;
     } ? InvokeFactoryResult<Source> extends infer Fx extends Effect.Effect<any, any, any> ? Logic<void, never, Effect.Error<Fx>, Effect.Services<Fx>, Effect.Success<Fx>> : never : Invoke extends {
@@ -3595,7 +3641,7 @@ export declare namespace Machine {
         };
     } ? Emitted : Invoke extends {
         readonly child: ChildMachine<string, infer M>;
-    } ? Emit<M> : never;
+    } ? EmittedEvent<M> : never;
     /** Public parent inputs required by an invoked child machine. */
     type InvokeParentEvents<Invoke> = Invoke extends {
         readonly [InvokeTypeId]: {
@@ -3735,12 +3781,12 @@ export declare namespace Machine {
         /** Declines this candidate and continues hierarchical transition selection. */
         readonly decline: () => Declined;
     }
-    type TransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection> = (context: TransitionResolveContext<Context, Selection>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined;
-    type DeclinableTransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection> = (context: TransitionResolveContext<Context, Selection> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => (SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined) | Declined;
+    type TransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection> = (context: TransitionResolveContext<Context, Selection>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined;
+    type DeclinableTransitionResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Selection> = (context: TransitionResolveContext<Context, Selection> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => (SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined) | Declined;
     /** @internal */
-    type StateUpdateResolver<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Owner extends ValuedStateIdentifier<States>> = (context: StateUpdateResolveContext<States, Context, Owner>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateUpdate<States, Owner>;
+    type StateUpdateResolver<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Owner extends ValuedStateIdentifier<States>> = (context: StateUpdateResolveContext<States, Context, Owner>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => StateUpdate<States, Owner>;
     /** @internal */
-    type DeclinableStateUpdateResolver<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Owner extends ValuedStateIdentifier<States>> = (context: StateUpdateResolveContext<States, Context, Owner> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateUpdate<States, Owner> | Declined;
+    type DeclinableStateUpdateResolver<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Owner extends ValuedStateIdentifier<States>> = (context: StateUpdateResolveContext<States, Context, Owner> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => StateUpdate<States, Owner> | Declined;
     /** One named destination declared by a branching transition. */
     interface TransitionBranchInput<Selection extends TargetSelection<any, any, any> = TargetSelection<any, any, any>> {
         /** Exact topology destination available to the branching resolver. */
@@ -3776,8 +3822,8 @@ export declare namespace Machine {
     type TransitionBranchesResolveContext<Context, Branches extends Readonly<Record<string, TransitionBranchInput>>> = Omit<Context, "target"> & {
         readonly select: BranchSelectors<Branches>;
     };
-    type TransitionBranchesResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Branches extends Readonly<Record<string, TransitionBranchInput>>> = (context: TransitionBranchesResolveContext<Context, Branches>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => BranchSelectionResult<Branches>;
-    type DeclinableTransitionBranchesResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Branches extends Readonly<Record<string, TransitionBranchInput>>> = (context: TransitionBranchesResolveContext<Context, Branches> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => BranchSelectionResult<Branches> | Declined;
+    type TransitionBranchesResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Branches extends Readonly<Record<string, TransitionBranchInput>>> = (context: TransitionBranchesResolveContext<Context, Branches>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => BranchSelectionResult<Branches>;
+    type DeclinableTransitionBranchesResolver<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Context, Branches extends Readonly<Record<string, TransitionBranchInput>>> = (context: TransitionBranchesResolveContext<Context, Branches> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => BranchSelectionResult<Branches> | Declined;
     /** @internal Type evidence retained by a transition authored through its bound selector. */
     interface TransitionBuilderEvidence<out Result, out Acceptance extends TransitionAcceptance> {
         readonly [TransitionBuilderTypeId]: {
@@ -3806,6 +3852,12 @@ export declare namespace Machine {
     interface TransitionResolveDeclinable<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, any>> {
         (resolve: DeclinableTransitionResolver<Events, Emits, Context, Selection>, options: TransitionDeclinableOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, (SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined) | Declined, "declinable">;
     }
+    type ConstructionCallbacks<Context, Builder, Result> = {
+        readonly [Method in Extract<keyof Builder, "from" | "decoded"> as Builder[Method] extends (...args: infer Args) => unknown ? Args extends readonly [unknown?] ? Method : never : never]: Builder[Method] extends (...args: infer Args) => unknown ? (value: (context: Context) => Args[0]) => Result : never;
+    };
+    type GuardedTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, any>> = ConstructionCallbacks<Omit<Context, "target">, SelectionBuilder<Selection>, BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">> & (SelectionSupportsDefaultConstruction<Selection> extends true ? BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable"> : {}) & {
+        readonly resolve: (resolve: TransitionResolver<Events, Emits, Context, Selection>, options?: TransitionRequiredOptions<Reenter>) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">;
+    };
     /**
      * A selected transition target with target-specific resolver operations.
      *
@@ -3813,7 +3865,7 @@ export declare namespace Machine {
      *
      * ```ts
      * Reset: (to) =>
-     *   to.full.Ready().resolve(
+     *   to.branch.Ready().resolve(
      *     ({ target }) => target.from(),
      *     { reenter: true }
      *   )
@@ -3823,7 +3875,10 @@ export declare namespace Machine {
      * @inlineType TransitionDeclinableOptions
      * @inlineType TransitionReenterOption
      */
-    type TransitionTarget<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, any>> = Selection & (SelectionSupportsDefaultConstruction<Selection> extends true ? BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required"> : {}) & {
+    type TransitionTarget<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, any>> = Selection & ("declinable" extends Acceptance ? {
+        /** Declines this candidate before construction when the predicate is false. */
+        readonly guard: (predicate: (context: Omit<Context, "target">) => boolean) => GuardedTransition<States, Events, Emits, StateId, Context, Reenter, Selection>;
+    } : {}) & ConstructionCallbacks<Omit<Context, "target">, SelectionBuilder<Selection>, BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection>, "required">> & (SelectionSupportsDefaultConstruction<Selection> extends true ? BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required"> : {}) & {
         /** Evaluates state construction after this transition is selected. */
         readonly resolve: TransitionResolveRequired<States, Events, Emits, StateId, Context, Reenter, Selection> & ("declinable" extends Acceptance ? TransitionResolveDeclinable<States, Events, Emits, StateId, Context, Reenter, Selection> : {});
     } & ([Reenter] extends [true] ? SelectionSupportsDefaultConstruction<Selection> extends true ? {
@@ -3839,7 +3894,7 @@ export declare namespace Machine {
     type UpdatingTransitionTarget<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, "state">, Owner extends ValuedStateIdentifier<States>> = Selection & {
         /** @internal */
         readonly "~effect/Machine/UpdatingTransitionTarget": Owner;
-        readonly resolve: ((resolve: (context: UpdatingTransitionResolveContext<States, Context, Selection, Owner>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner>, options?: TransitionRequiredOptions<Reenter>) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner>, "required">) & ("declinable" extends Acceptance ? (resolve: (context: UpdatingTransitionResolveContext<States, Context, Selection, Owner> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | Declined, options: TransitionDeclinableOptions<Reenter>) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | Declined, "declinable"> : {});
+        readonly resolve: ((resolve: (context: UpdatingTransitionResolveContext<States, Context, Selection, Owner>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner>, options?: TransitionRequiredOptions<Reenter>) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner>, "required">) & ("declinable" extends Acceptance ? (resolve: (context: UpdatingTransitionResolveContext<States, Context, Selection, Owner> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | Declined, options: TransitionDeclinableOptions<Reenter>) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | Declined, "declinable"> : {});
     };
     /** @internal */
     interface StateUpdateTransitionRequired<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, "update">> {
@@ -3850,13 +3905,20 @@ export declare namespace Machine {
         (resolve: DeclinableStateUpdateResolver<States, Events, Emits, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, options: TransitionDeclinableOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">;
     }
     /** @internal */
-    type StateUpdateTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, "update">> = Selection & StateUpdateTransitionRequired<States, Events, Emits, StateId, Context, Reenter, Selection> & ("declinable" extends Acceptance ? StateUpdateTransitionDeclinable<States, Events, Emits, StateId, Context, Reenter, Selection> : {});
+    type StateUpdateTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, "update">> = Selection & ConstructionCallbacks<Omit<StateUpdateResolveContext<States, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, "owner">, SelectionBuilder<Selection>, BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection>, "required">> & {
+        readonly resolve: StateUpdateTransitionRequired<States, Events, Emits, StateId, Context, Reenter, Selection> & ("declinable" extends Acceptance ? StateUpdateTransitionDeclinable<States, Events, Emits, StateId, Context, Reenter, Selection> : {});
+    };
     /** @internal Type evidence retained by a machine initial-entry declaration. */
     interface InitialBuilderEvidence<out Selection> {
         readonly [InitialBuilderTypeId]: Types.Covariant<Selection>;
     }
+    /** Decoded input shared by initial construction callbacks. */
+    interface InitialContext<Input> {
+        /** Decoded value supplied when the machine is started. */
+        readonly input: Input;
+    }
     /** A selected machine initial entry with its exact resolver target. */
-    type InitialTransitionTarget<Input, Selection extends TargetSelection<any, any, any>> = Selection & (SelectionSupportsDefaultConstruction<Selection> extends true ? InitialBuilderEvidence<Selection> : {}) & {
+    type InitialTransitionTarget<Input, Selection extends TargetSelection<any, any, any>> = Selection & ConstructionCallbacks<InitialContext<Input>, SelectionBuilder<Selection>, InitialBuilderEvidence<Selection>> & (SelectionSupportsDefaultConstruction<Selection> extends true ? InitialBuilderEvidence<Selection> : {}) & {
         /** Lazily constructs the selected initial state from decoded machine input. */
         readonly resolve: (resolve: (context: {
             /** Decoded value supplied when the machine is started. */
@@ -3874,6 +3936,25 @@ export declare namespace Machine {
     type InitialSelector<States extends StateSchemas, Input = void> = InitialSelectorNode<Input, InitialTargetSelector<States>>;
     /** Target-first initial-entry declaration accepted by {@link make}. */
     type InitialBuilderInput<States extends StateSchemas, Input> = (to: InitialSelector<States, Input>) => InitialBuilderEvidence<TargetSelection<any, any, any>>;
+    /** Initializes the root and its declared default descendants. */
+    type RootInitialBuilderInput<Root extends StateNodeConfig, Input> = (root: InitialTransitionTarget<Input, SelectionValue<InitialTargetFactory<Root, "">, "", "initial", "initial">>) => InitialBuilderEvidence<TargetSelection<any, any, any>>;
+    interface RootConfigurationSelection<in out Root extends StateNodeConfig> extends TargetSelection<FullSnapshotMethod<{
+        readonly "": Root;
+    }, "" & ActiveStateKey<{
+        readonly "": Root;
+    }>, "">, "", "state", "initial"> {
+    }
+    /** Explicitly constructs a complete starting configuration. */
+    type RootConfigurationBuilderInput<Root extends StateNodeConfig, Input> = (root: ConstructionCallbacks<InitialContext<Input>, SelectionBuilder<RootConfigurationSelection<Root>>, InitialBuilderEvidence<RootConfigurationSelection<Root>>> & {
+        readonly resolve: (resolve: (context: {
+            /** Decoded startup input. */
+            readonly input: Input;
+            /** Builder for the complete root configuration. */
+            readonly target: SelectionBuilder<RootConfigurationSelection<Root>>;
+        }) => ConstructionResult<Snapshot<{
+            readonly "": Root;
+        }>>) => InitialBuilderEvidence<RootConfigurationSelection<Root>>;
+    }) => InitialBuilderEvidence<TargetSelection<any, any, any>>;
     type TransitionSelectorNode<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Node> = Node extends TargetSelection<any, any, "update"> ? StateUpdateTransition<States, Events, Emits, StateId, Context, Reenter, Acceptance, Node> : Node extends (...args: infer Args) => infer Selection ? Selection extends TargetSelection<any, any, any> ? ((...args: Args) => TransitionTarget<States, Events, Emits, StateId, Context, Reenter, Acceptance, Selection>) & {
         readonly [Key in keyof Node]: TransitionSelectorNode<States, Events, Emits, StateId, Context, Reenter, Acceptance, Node[Key]>;
     } : never : Node extends TargetSelection<any, any, any> ? TransitionTarget<States, Events, Emits, StateId, Context, Reenter, Acceptance, Node> : {
@@ -3885,14 +3966,17 @@ export declare namespace Machine {
     interface TransitionBranchesResolveDeclinable<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Branches extends Readonly<Record<string, TransitionBranchInput>>> {
         (resolve: DeclinableTransitionBranchesResolver<Events, Emits, Context, Branches>, options: TransitionDeclinableOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, BranchSelectionResult<Branches> | Declined, "declinable">;
     }
+    type TransitionSelectorTargets<in out States extends StateSchemas, in out Events extends ReadonlyArray<TaggedSchema>, in out Emits extends ReadonlyArray<TaggedSchema>, in out StateId extends StateNodeIdentifier<States>, in out Context, in out Reenter extends boolean, in out Acceptance extends TransitionAcceptance> = {
+        readonly [Key in keyof TargetSelector<States, StateId>]: TransitionSelectorNode<States, Events, Emits, StateId, Context, Key extends "self" ? false : Reenter, Acceptance, TargetSelector<States, StateId>[Key]>;
+    };
     /** Selector supplied to inline transition declarations. */
-    type TransitionSelector<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance> = TransitionSelectorNode<States, Events, Emits, StateId, Context, Reenter, Acceptance, TargetSelector<States, StateId>> & {
+    interface TransitionSelector<in out States extends StateSchemas, in out Events extends ReadonlyArray<TaggedSchema>, in out Emits extends ReadonlyArray<TaggedSchema>, in out StateId extends StateNodeIdentifier<States>, in out Context, in out Reenter extends boolean, in out Acceptance extends TransitionAcceptance> extends TransitionSelectorTargets<States, Events, Emits, StateId, Context, Reenter, Acceptance> {
         /** Declares a closed set of named destinations for one resolver. */
         readonly branches: <const Branches extends Readonly<Record<string, TransitionBranchInput>>>(branches: Branches & ValidateTransitionBranchRecord<NoInfer<Branches>>) => {
             /** Resolves exactly one declared branch after this transition is selected. */
             readonly resolve: TransitionBranchesResolveRequired<States, Events, Emits, StateId, Context, Reenter, Branches> & ("declinable" extends Acceptance ? TransitionBranchesResolveDeclinable<States, Events, Emits, StateId, Context, Reenter, Branches> : {});
         };
-    };
+    }
     /** Inline transition declaration accepted by state and invocation handlers. */
     type TransitionBuilderInput<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance> = (to: TransitionSelector<States, Events, Emits, StateId, Context, Reenter, Acceptance>) => TransitionTyped<States, Events, Emits, StateId, Context, Reenter, Acceptance> & TransitionBuilderEvidence<any, Acceptance>;
     type InvokeTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context> = TransitionConfig<States, Events, Emits, StateId, Context, true, TransitionAcceptance>;
@@ -4011,7 +4095,7 @@ export declare namespace Machine {
     type EffectInvokeBuilder<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Source extends (...args: ReadonlyArray<any>) => Effect.Effect<any, any, any>> = InvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, Effect.Success<ReturnType<Source>>, Effect.Error<ReturnType<Source>>, Effect.Services<ReturnType<Source>>, never, never, never, never, RequiredInvokeChannel<Effect.Success<ReturnType<Source>>, "done"> | RequiredInvokeChannel<Effect.Error<ReturnType<Source>>, "failure">, never>;
     type StreamInvokeBuilder<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Source extends (...args: ReadonlyArray<any>) => Stream.Stream<any, any, any>> = InvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, void, Stream.Error<ReturnType<Source>>, Stream.Services<ReturnType<Source>>, never, never, never, Stream.Success<ReturnType<Source>>, "done" | RequiredInvokeChannel<Stream.Success<ReturnType<Source>>, "element"> | RequiredInvokeChannel<Stream.Error<ReturnType<Source>>, "failure">, never>;
     type LogicInvokeBuilder<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, ChildLogic> = InvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, LogicOutputOf<ChildLogic>, LogicErrorOf<ChildLogic>, LogicServicesOf<ChildLogic>, LogicInitialErrorOf<ChildLogic>, never, never, never, RequiredInvokeChannel<LogicOutputOf<ChildLogic>, "done"> | RequiredInvokeChannel<LogicErrorOf<ChildLogic>, "failure">, InvokeTransition<States, Events, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, LogicStateOf<ChildLogic>, LogicErrorOf<ChildLogic>, LogicOutputOf<ChildLogic>, InputEvents, ParentEvents>>>;
-    type ChildInvokeBuilder<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Child extends ChildMachine.Any, ChildDefinition extends Machine.Any = Child["machine"]> = InvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, Output<ChildDefinition>, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, Services<ChildDefinition>, InitialError<ChildDefinition>, Emit<ChildDefinition>, EventOf<Machine.ParentEvents<ChildDefinition>>, never, RequiredInvokeChannel<Output<ChildDefinition>, "done"> | RequiredInvokeChannel<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, "failure">, InvokeTransition<States, Events, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>>;
+    type ChildInvokeBuilder<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>, ParentEvents extends ReadonlyArray<TaggedSchema>, Child extends ChildMachine.Any, ChildDefinition extends Machine.Any = Child["machine"]> = InvokeBuilder<States, Events, Emits, StateId, InputEvents, ParentEvents, Output<ChildDefinition>, Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, Services<ChildDefinition>, InitialError<ChildDefinition>, EmittedEvent<ChildDefinition>, EventOf<Machine.ParentEvents<ChildDefinition>>, never, RequiredInvokeChannel<Output<ChildDefinition>, "done"> | RequiredInvokeChannel<Error<ChildDefinition> | ActionError<Services<ChildDefinition>>, "failure">, InvokeTransition<States, Events, Emits, StateId, InvokeSnapshotContext<States, Events, Emits, StateId, Snapshot<Machine.States<ChildDefinition>>, Error<ChildDefinition>, Output<ChildDefinition>, InputEvents, ParentEvents>>>;
     /**
      * Selects state-owned work and begins its lifecycle-handler chain.
      *
@@ -4024,9 +4108,9 @@ export declare namespace Machine {
      * ```ts
      * invoke: (from) =>
      *   from.effect("load-user", () => loadUser).onDone((to) =>
-     *     to.full.Ready().resolve(({ output, target }) => target.from({ user: output }))
+     *     to.branch.Ready().resolve(({ output, target }) => target.from({ user: output }))
      *   ).onFailure((to) =>
-     *     to.full.Failed().resolve(({ error, target }) => target.from({ error }))
+     *     to.branch.Failed().resolve(({ error, target }) => target.from({ error }))
      *   )
      * ```
      *
@@ -4141,14 +4225,14 @@ export declare namespace Machine {
      * **Example** (State actions, events, and invocation)
      *
      * ```ts
-     * machine.handle({
+     * machine.handle({ states: {
      *   Loading: {
      *     entry: (_, enqueue) => enqueue.emit({ _tag: "Started" }),
      *     invoke: (from) =>
-     *       from.effect("load", () => load).onDone((to) => to.full.Ready()),
-     *     on: { Cancel: (to) => to.full.Idle() }
+     *       from.effect("load", () => load).onDone((to) => to.branch.Ready()),
+     *     on: { Cancel: (to) => to.branch.Idle() }
      *   }
-     * })
+     * } })
      * ```
      *
      * @inlineType ActiveOutputHandlerConfig
@@ -4159,9 +4243,9 @@ export declare namespace Machine {
      */
     type ActiveStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
         /** Runs synchronously when the state is entered and may enqueue commands. */
-        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
+        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => StateActionResult<any, any>;
         /** Runs synchronously before the state is exited and may enqueue commands. */
-        readonly exit?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
+        readonly exit?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => StateActionResult<any, any>;
         /** Starts state-owned Effect, Stream, timer, logic, or child lifecycles. */
         readonly invoke?: InvokeBuilderInput<States, Events, Emits, StateId, InputEvents, ParentEvents>;
         /** Eventless transition evaluated after the state becomes stable. */
@@ -4235,9 +4319,9 @@ export declare namespace Machine {
      * @category models
      * @since 0.13.0
      */
-    type StateInitializeHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = (context: StateInitializeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => SnapshotBuilderComplete<StateInitializeValue<States, StateId>, boolean>;
+    type StateInitializeHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = (context: StateInitializeContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => SnapshotBuilderComplete<StateInitializeValue<States, StateId>, boolean>;
     /** 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>> {
+    interface HistoryDefaultContext<in out States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, in out ParentId extends StateIdentifier<States>> {
         /** Lifecycle event that attempted to restore this history node. */
         readonly event: LifecycleEvent<Events>;
         /** Complete target builder rooted at the history owner. */
@@ -4252,7 +4336,7 @@ export declare namespace Machine {
      * 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>>;
+    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>, EmittedEventOf<Emits>>) => CompleteSnapshotContaining<States, ParentId> | StateConstruction<CompleteSnapshotContaining<States, ParentId>>;
     /**
      * Fallback implementation for one direct history pseudo-state.
      *
@@ -4293,7 +4377,7 @@ export declare namespace Machine {
      */
     type FinalStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> = {
         /** Runs synchronously when the final state is entered and may enqueue commands. */
-        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmitOf<Emits>>) => StateActionResult<any, any>;
+        readonly entry?: (context: StateActionContext<States, Events, Emits, StateId, InputEvents, ParentEvents>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => StateActionResult<any, any>;
         readonly exit?: never;
         readonly always?: never;
         readonly onDone?: never;
@@ -4319,10 +4403,12 @@ export declare namespace Machine {
     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 {
+    type HandlerNodeByPath<States extends StateSchemas, Path extends string> = "" extends keyof States ? Path extends "" ? States[""] : States[""] extends {
+        readonly states: infer Children extends StateSchemas;
+    } ? HandlerNodeByPath<Children, Path> : never : 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 HandlerConfigAtPath<Config, Path extends string> = [Config] extends [never] ? never : "" extends keyof Config ? Path extends "" ? Config[""] : HandlerConfigAtPath<HandlerNodeChildrenConfig<Config[""]>, Path> : 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>;
@@ -4374,7 +4460,7 @@ export declare namespace Machine {
         readonly [Key in Extract<keyof Children, string>]: RequiredCompletionOutputStates<States, Extract<JoinPath<StateId, Key>, StateIdentifier<States>>>;
     }[Extract<keyof Children, string>] : never;
     type HandlerOutputStates<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, Config> = "output" extends keyof Config ? StateId : never;
-    type HandlerUnknownStateKeyValidation<States extends StateSchemas, Prefix extends string, Config, UnknownKeys extends string = Exclude<Extract<keyof Config, string>, Extract<keyof States, string>>> = [UnknownKeys] extends [never] ? unknown : {
+    type HandlerUnknownStateKeyValidation<States extends StateSchemas, Prefix extends string, Config, UnknownKeys extends string = Exclude<Extract<keyof Config, string>, ActiveStateKey<States> | ChoiceStateKey<States>>> = [UnknownKeys] extends [never] ? unknown : {
         readonly [Key in UnknownKeys]: HandlerValidationError<"Handler tree contains a state key that does not exist", JoinPath<Prefix, Key>, Key>;
     };
     type HandlerUnknownConfigKeyValidation<StateId extends string, Config, UnknownKeys extends string = Exclude<Extract<keyof Config, string>, HandlerNodeConfigKey>> = [UnknownKeys] extends [never] ? unknown : {
@@ -4427,7 +4513,7 @@ 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 HandlerRequiredHistoryInitializeValidation<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, Config> = [HistoryIdentifier<AllStates>] extends [never] ? unknown : StateId extends RequiredHistoryInitializers<AllStates> ? "initialize" extends keyof Config ? unknown : {
+    type HandlerRequiredHistoryInitializeValidation<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, Config> = [HistoryIdentifier<AllStates>] extends [never] ? unknown : StateId extends RequiredHistoryInitializers<AllStates> | RequiredInitializers<AllStates> ? "initialize" extends keyof Config ? unknown : {
         readonly initialize: HandlerValidationError<"State requires initialize for shallow history restoration", StateId>;
     } : unknown;
     type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = StateId extends ChoiceIdentifier<AllStates> ? HandlerChoiceUnknownConfigKeyValidation<StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : StateId extends StateIdentifier<AllStates> ? HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerInvokeParentEventsValidation<InputEvents, StateId, Config> & HandlerChildrenValidation<Node, StateId, Config> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRequiredHistoryInitializeValidation<AllStates, StateId, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config> : unknown;
@@ -4437,11 +4523,38 @@ export declare namespace Machine {
     type HandlerInvokeParentEventsValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeParentEvents<InvokeReturn<Config>>, EventOf<Events>>] extends [never] ? unknown : {
         readonly invoke: HandlerValidationError<"Invoked child expects parent events not accepted by this machine", StateId, Exclude<InvokeParentEvents<InvokeReturn<Config>>, EventOf<Events>>>;
     };
-    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 HandlerNodeValidationAtPath<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, InputEvents 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, InputEvents, Emits, StateId, NodeConfig, AvailableOutputStates> extends infer Validation ? unknown extends Validation ? never : HandlerValidationAtPath<StateId, Validation> : never;
+    type HandlerRuntimeValidation<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends string, Config, Incompatible = keyof Config extends never ? never : IncompatibleRuntime<ConfigServices<HandlerConfigPart<Config>>, EventOf<Events>, EmittedEventOf<Emits>>> = [Incompatible] extends [never] ? unknown : HandlerValidationError<"Handler config requires an incompatible machine runtime", StateId, Incompatible>;
+    type HandlerNodeValidationAtPath<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, InputEvents 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, InputEvents, Emits, StateId, NodeConfig, AvailableOutputStates> extends infer Validation ? unknown extends Validation ? never : "" extends keyof AllStates ? StateId extends "" ? {
+        readonly ""?: Validation;
+    } : {
+        readonly ""?: {
+            readonly states: HandlerValidationAtPath<StateId, Validation>;
+        };
+    } : HandlerValidationAtPath<StateId, Validation> : never;
     type HandlerTreeNodeValidations<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, InputEvents 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, InputEvents, Emits, Config, AvailableOutputStates, StateId> : never : never>;
     type HandlerTreeValidation<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, AvailableOutputStates extends StateIdentifier<AllStates>> = HandlerUnknownStateKeyValidation<AllStates, "", Config> & HandlerTreeNodeValidations<AllStates, Events, InputEvents, Emits, Config, AvailableOutputStates>;
-    type HandlerHasRequiredInitial<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, Config> = StateId extends RequiredHistoryInitializers<AllStates> ? "initialize" extends keyof Config ? true : false : true;
+    type RootInitialTargetValidation<States extends StateSchemas, Config> = RequiredInitializersForTargetPath<States, HandlerTreeInitialTargetPath<{
+        readonly "": Config;
+    }>> extends infer Required ? Types.UnionToIntersection<Required extends string ? HandlerConfigAtPath<{
+        readonly "": Config;
+    }, Required> extends infer NodeConfig ? [
+        NodeConfig
+    ] extends [never] ? RootInitializeError<Required> : "initialize" extends keyof NodeConfig ? never : RootInitializeError<Required> : never : unknown> : unknown;
+    type RootInitializeError<Path extends string> = Path extends "" ? {
+        readonly initialize: HandlerValidationError<"State requires initialize because a transition enters its declared initial configuration", Path>;
+    } : {
+        readonly states: HandlerValidationAtPath<Path, {
+            readonly initialize: HandlerValidationError<"State requires initialize because a transition enters its declared initial configuration", Path>;
+        }>;
+    };
+    type RootHandlerValidation<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Config, OutputStates extends StateIdentifier<States>> = HandlerNodeValidation<States, States[""], Events, InputEvents, Emits, Extract<"", StateNodeIdentifier<States>>, Config, OutputStates> & RootInitialTargetValidation<States, Config> & Types.UnionToIntersection<Exclude<StateNodeIdentifier<States>, ""> extends infer Path ? Path extends StateNodeIdentifier<States> ? HandlerConfigAtPath<{
+        readonly "": Config;
+    }, Path> extends infer NodeConfig ? [
+        NodeConfig
+    ] extends [never] ? never : HandlerNodeValidation<States, HandlerNodeByPath<States, Path>, Events, InputEvents, Emits, Path, NodeConfig, OutputStates> extends infer Validation ? unknown extends Validation ? never : {
+        readonly states: HandlerValidationAtPath<Path, Validation>;
+    } : never : never : never : never>;
+    type HandlerHasRequiredInitial<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, Config> = StateId extends RequiredHistoryInitializers<AllStates> | RequiredInitializers<AllStates> ? "initialize" extends keyof Config ? true : false : true;
     type HandlerHasRequiredHistoryDefaults<Node, Config> = Node extends {
         readonly states: infer Children extends StateSchemas;
     } ? [HistoryStateKey<Children>] extends [never] ? true : Config extends {
@@ -4456,7 +4569,7 @@ export declare namespace Machine {
     } ? [
         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 HandlerImplementedStateId<AllStates extends StateSchemas, Node, StateId extends StateIdentifier<AllStates>, Config> = [HistoryIdentifier<AllStates> | ChoiceIdentifier<AllStates> | RequiredInitializers<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<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;
@@ -4465,7 +4578,7 @@ export declare namespace Machine {
         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>, ParentEvents 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, ParentEvents>;
+    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>, ParentEvents 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>, EmittedEventOf<Emits>>, InitialE, InitialR, FinalStates, Output, Emits, OutputStates | Extract<HandlerTreeEvidence<AllStates, Config>["outputState"], StateIdentifier<AllStates>>, InputEvents, ParentEvents>;
     /**
      * Adds state handlers from a root state object.
      *
@@ -4473,7 +4586,11 @@ export declare namespace Machine {
      * @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>, ParentEvents extends ReadonlyArray<TaggedSchema>> {
-        <const Config extends HandlerTree<States, States, Events, Emits, E, R, InputEvents, ParentEvents, "">>(config: Config & HandlerTreeValidation<States, Events, InputEvents, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, NoInfer<Config>>["outputState"], StateIdentifier<States>>> & ([StateIdentifier<States>] extends [UnhandledStates] ? HandlerInitialTargetValidation<States, NoInfer<Config>> : unknown)): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, ParentEvents, Config>;
+        <const Config>(config: Config & (Config extends (...args: never[]) => unknown ? never : unknown) & HandlerNode<States, States[""], Events, Emits, E, R, InputEvents, ParentEvents, Extract<"", StateNodeIdentifier<States>>> & RootHandlerValidation<States, Events, InputEvents, Emits, NoInfer<Config>, OutputStates | Extract<HandlerTreeEvidence<States, {
+            readonly "": NoInfer<Config>;
+        }>["outputState"], StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, ParentEvents, {
+            readonly "": Config;
+        }>;
     }
     /**
      * Any state config.
@@ -4496,8 +4613,8 @@ export declare namespace Machine {
      * @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>, 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 entry?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => StateActionResult<E, R>;
+        readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => StateActionResult<E, R>;
         readonly invoke?: StoredInvokeDefinition<States, Events, Emits, StateId>;
         readonly always?: TransitionConfig<States, Events, Emits, StateId, AlwaysContext<States, Events, Emits, StateId>, false, TransitionAcceptance>;
         readonly onDone?: TransitionConfig<States, Events, Emits, StateId, DoneContext<States, Events, Emits, StateId>, false, TransitionAcceptance>;
@@ -4512,8 +4629,10 @@ export declare namespace Machine {
      */
     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>>>>;
 }
-type StateSource = Machine.DefinedStates<any> | Machine.Any;
-type StateSchemasOf<Source extends StateSource> = Source extends Machine.DefinedStates<infer States> ? States : Source extends Machine.Any ? Machine.States<Source> : never;
+type StateSource = State<any> | Machine.Any;
+type StateSchemasOf<Source extends StateSource> = Source extends State<infer Node> ? {
+    readonly "": Node;
+} : Source extends Machine.Any ? Machine.States<Source> : never;
 /**
  * Extracts the complete logical snapshot represented by a state definition or
  * machine.
@@ -4522,6 +4641,30 @@ type StateSchemasOf<Source extends StateSource> = Source extends Machine.Defined
  * @since 0.15.0
  */
 export type Snapshot<Source extends StateSource> = Machine.Snapshot<StateSchemasOf<Source>>;
+/** Type utilities for logical snapshots, including snapshots carried by atom bridges. */
+/** Typed traversal of root and child logical snapshots.
+ * @category utility types
+ * @since 0.32.0
+ */
+export declare namespace Snapshot {
+    /** Every active node represented by a logical snapshot type. */
+    type Node<State> = State extends {
+        readonly path: string;
+        readonly value: unknown;
+    } ? State | (State extends {
+        readonly state: infer Child;
+    } ? Node<Child> : State extends {
+        readonly states: infer Regions;
+    } ? Node<Regions[keyof Regions]> : never) : never;
+    /** Every valid absolute path in a logical snapshot type. */
+    type Path<State> = Node<State> extends infer Current ? Current extends {
+        readonly path: infer Path extends string;
+    } ? Path : never : never;
+    /** The node at one absolute path. Runtime access can still be inactive. */
+    type At<State, Path extends Snapshot.Path<State>> = Node<State> extends infer Current ? Current extends {
+        readonly path: Path;
+    } ? Current : never : never;
+}
 /**
  * Extracts the decoded value owned by a schema-backed state path.
  *
@@ -4537,7 +4680,7 @@ export type Value<Source extends StateSource, Path extends Machine.ValuedStateId
  *
  * The source may be the object returned by {@link states} or a machine
  * definition. This is the type-level counterpart of
- * `DefinedStates.getSnapshot`.
+ * `State.getSnapshot`.
  *
  * @category utility types
  * @since 0.18.0
@@ -4583,59 +4726,24 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  *   }
  * })
  *
- * const States = Machine.states({
+ * const States = Machine.state({ initial: "slot1", states: {
  *   slot1: TradingSlot,
  *   slot2: TradingSlot
- * })
+ * } })
  * ```
  *
  * @category constructors
  * @since 0.15.0
  */
 export declare const state: StateConstructor;
-/**
- * Defines the complete state tree while preserving literal state paths.
- *
- * **When to use**
- *
- * Use when you want to pass a state tree to `make` and also get typed
- * snapshot matching and access helpers.
- *
- * **Details**
- *
- * The returned `states` property is an immutable structural capture of the
- * supplied tree.
- * `Machine.make` derives its initial target selector from that tree and
- * enforces compound and parallel initial-state rules. Active nodes may omit
- * `schema` when they own no value and still participate fully in targeting,
- * matching, and snapshots.
- *
- * **Example** (Atomic initial snapshot)
- *
- * ```ts
- * import { Schema } from "effect"
- * import { Machine } from "@typeonce/effect-machine"
- *
- * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- *
- * const States = Machine.states({ idle: Idle })
- *
- * Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: (to) => to.idle().resolve(({ target }) => target.from())
- * })
- * ```
- *
- * @category constructors
- * @since 0.4.0
- */
-export declare const states: StatesConstructor;
-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>, ParentDeclaration extends Parent.Any | undefined> = {
+type MakeConfig<Root extends Machine.StateNodeConfig, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentDeclaration extends Parent.Any | undefined> = {
     /** Stable definition identifier used by inspection and visualization. */
     readonly id?: string;
-    /** State topology and value schemas, normally supplied by `Machine.states`. */
-    readonly states: States & DefineStateTreeInput<NoInfer<States>>;
+    /** State topology and value schemas, captured by a `Machine.state` descriptor. */
+    readonly root: {
+        readonly [StateTypeId]: typeof StateTypeId;
+        readonly node: Root;
+    };
     /** Public events accepted by independently running machine references. */
     readonly events: Machine.EventProtocol<"public", InputEvents> & ValidateInputEventProtocol<NoInfer<InputEvents>>;
     /** Machine-local events used by raised events and other internal deliveries. */
@@ -4646,20 +4754,38 @@ type MakeConfig<States extends Machine.StateSchemas, InputEvents extends Readonl
     readonly parent?: ParentDeclaration;
     /** Schema used to decode input before initial-state construction. */
     readonly input?: Input;
-    /** Target-first declaration that constructs the initial active configuration. */
-    readonly initial: unknown;
 };
-type MakeResult<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>, ParentDeclaration extends Parent.Any | undefined> = Definition<States, readonly [...InputEvents, ...InternalEvents], Input, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, InputEvents, Machine.ParentEventsOf<ParentDeclaration>>;
+type MakeResult<Root extends Machine.StateNodeConfig, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentDeclaration extends Parent.Any | undefined> = Definition<{
+    readonly "": Root;
+}, readonly [...InputEvents, ...InternalEvents], Input, InitialE, InitialR, Machine.FinalStateFromDefinition<{
+    readonly "": Root;
+}>, Machine.TerminalOutput<{
+    readonly "": Root;
+}>, Emits, InputEvents, Machine.ParentEventsOf<ParentDeclaration>>;
+type RootInitialization<Root extends Machine.StateNodeConfig, Input> = {
+    readonly initialConfiguration?: never;
+} & (Machine.NodeSchema<Root> extends never ? {
+    readonly initial?: Machine.RootInitialBuilderInput<Root, Input>;
+} : {} extends NodeMakeInput<Root> ? {
+    readonly initial?: Machine.RootInitialBuilderInput<Root, Input>;
+} : {
+    readonly initial: Machine.RootInitialBuilderInput<Root, Input>;
+});
 /** @inline */
 interface Make {
+    /** @param config Complete starting configuration, including root and descendant values. */
+    <const Root extends Machine.StateNodeConfig, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentDeclaration extends Parent.Any | undefined = undefined>(config: MakeConfig<Root, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration> & {
+        /** Mutually exclusive with a complete initial configuration. */
+        readonly initial?: never;
+        /** Constructs the complete initial root configuration, overriding child defaults. */
+        readonly initialConfiguration: Machine.RootConfigurationBuilderInput<NoInfer<Root>, Input["Type"]>;
+    }): MakeResult<Root & {
+        readonly "~effect/Machine/ExplicitInitial": true;
+    }, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>;
     /** @param config Complete schema-first machine definition. */
-    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentDeclaration extends Parent.Any | undefined = undefined>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>, "initial"> & {
-        readonly initial: Machine.InitialBuilderInput<States, Input["Type"]>;
-    }, ..._validation: ValidateDefinedStates<NoInfer<States>>): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>;
-    /** @param config Invalid state tree retained only to report its validation error at the call site. */
-    <const States extends Machine.StateSchemas, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentDeclaration extends Parent.Any | undefined = undefined>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>, "states"> & {
-        readonly states: InvalidDefinedStateTreeInput<States>;
-    }): never;
+    <const Root extends Machine.StateNodeConfig, const InputEvents extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, InitialE = never, InitialR = never, const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const ParentDeclaration extends Parent.Any | undefined = undefined>(config: MakeConfig<Root, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration> & Exclude<RootInitialization<NoInfer<Root>, Input["Type"]>, {
+        readonly initialConfiguration: unknown;
+    }>): MakeResult<Root, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentDeclaration>;
 }
 /**
  * Creates a schema-first machine definition.
@@ -4700,25 +4826,25 @@ interface Make {
  *   by: Schema.Number
  * }) {}
  *
- * const States = Machine.states({ Count })
- * const Events = Machine.events(Increment)
+ * const States = Machine.state({ initial: "Count", states: { Count } })
+ * const Events = Machine.eventsFromSchemas(Increment)
  *
  * const counter = Machine.make({
- *   states: States.states,
+ *   root: States,
  *   events: Events,
- *   initial: (to) => to.Count().resolve(({ target }) => target.decoded(new Count({ value: 0 })))
- * }).handle({
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(to => to.Count.decoded(new Count({ value: 0 }))))
+ * }).handle({ states: {
  *   Count: {
  *     on: {
  *       Increment: (to) =>
- *         to.full.Count().resolve(({ event, state, target }) =>
+ *         to.branch.Count().resolve(({ event, state, target }) =>
  *           target.decoded(new Count({ value: state.value + event.by })))
  *     }
  *   }
- * })
+ * } })
  * ```
  *
- * @see {@link states} for typed state-tree helpers.
+ * @see {@link state} for typed state-tree helpers.
  * @inlineType MakeConfig
  * @category constructors
  * @since 0.4.0
@@ -4743,7 +4869,7 @@ export type EventOf<Protocol extends Machine.EventProtocol.Any> = Machine.EventO
  * **Example**
  *
  * ```ts
- * export const Event = Machine.events(
+ * export const Event = Machine.eventsFromSchemas(
  *   Schema.TaggedUnion({
  *     Increment: { by: Schema.Number },
  *     Reset: {}
@@ -4756,8 +4882,32 @@ export type EventOf<Protocol extends Machine.EventProtocol.Any> = Machine.EventO
  * @category constructors
  * @since 0.10.0
  */
-export declare const events: {
-    <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(...schemas: Schemas & ValidateInputEventProtocol<NoInfer<Schemas>>): Machine.EventProtocol<"public", readonly [...Schemas]>;
+type EventFieldsSchemas<Cases extends Readonly<Record<string, Schema.Struct.Fields>>> = keyof Cases extends never ? readonly [] : readonly [
+    Extract<Schema.TaggedUnion<{
+        readonly [Tag in keyof Cases & string]: Schema.TaggedStruct<Tag, Cases[Tag]>;
+    }>, Machine.TaggedSchema>
+];
+type ValidateEventFields<Cases> = {
+    readonly [Tag in keyof Cases]: "_tag" extends keyof Cases[Tag] ? EventProtocolError<"Event fields cannot declare _tag", Extract<Tag, PropertyKey>> : unknown;
+};
+/** Defines a public event protocol from tagged field records.
+ *
+ * ```ts
+ * const Events = Machine.events({ Increment: { by: Schema.Number }, Reset: {} })
+ * const increment = Events.Increment({ by: 1 })
+ * ```
+ *
+ * Constructors defer schema validation until delivery. Use eventsFromSchemas
+ * when importing existing tagged schemas or protocol descriptors.
+ * @category constructors
+ * @since 0.32.0
+ */
+export declare const events: <const Cases extends Readonly<Record<string, Schema.Struct.Fields>>>(cases: Cases & ValidateEventFields<NoInfer<Cases>> & ValidateEventProtocolBuilder<"public", EventFieldsSchemas<Cases>>) => Machine.EventProtocol<"public", EventFieldsSchemas<Cases>>;
+/** Imports existing schemas and protocols without rebuilding their contracts.
+ * @category constructors
+ * @since 0.32.0
+ */
+export declare const eventsFromSchemas: {
     <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"public">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"public", Inputs>): Machine.EventProtocol<"public", Machine.EventProtocolInputSchemasOf<"public", Inputs>>;
 };
 /**
@@ -4792,7 +4942,7 @@ export declare const optionalParent: <const Events extends ReadonlyArray<Machine
  * **Example**
  *
  * ```ts
- * const Internal = Machine.internalEvents(
+ * const Internal = Machine.internalEventsFromSchemas(
  *   Schema.TaggedUnion({
  *     Loaded: { value: Schema.String },
  *     Failed: { message: Schema.String }
@@ -4807,8 +4957,12 @@ export declare const optionalParent: <const Events extends ReadonlyArray<Machine
  * @category constructors
  * @since 0.10.0
  */
-export declare const internalEvents: {
-    <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(...schemas: Schemas & ValidateInternalEventProtocol<readonly [], NoInfer<Schemas>>): Machine.EventProtocol<"internal", readonly [...Schemas]>;
+export declare const internalEvents: <const Cases extends Readonly<Record<string, Schema.Struct.Fields>>>(cases: Cases & ValidateEventFields<NoInfer<Cases>> & ValidateEventProtocolBuilder<"internal", EventFieldsSchemas<Cases>>) => Machine.EventProtocol<"internal", EventFieldsSchemas<Cases>>;
+/** Imports existing schemas and protocols without rebuilding their contracts.
+ * @category constructors
+ * @since 0.32.0
+ */
+export declare const internalEventsFromSchemas: {
     <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"internal">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"internal", Inputs>): Machine.EventProtocol<"internal", Machine.EventProtocolInputSchemasOf<"internal", Inputs>>;
 };
 /**
@@ -4820,7 +4974,7 @@ export declare const internalEvents: {
  * **Example**
  *
  * ```ts
- * const Emitted = Machine.emittedEvents(
+ * const Emitted = Machine.emittedEventsFromSchemas(
  *   Schema.TaggedUnion({
  *     Saved: { id: Schema.String }
  *   })
@@ -4831,8 +4985,12 @@ export declare const internalEvents: {
  * @category constructors
  * @since 0.10.0
  */
-export declare const emittedEvents: {
-    <const Schemas extends ReadonlyArray<Machine.TaggedSchema>>(...schemas: Schemas & ValidateEmittedEventProtocol<NoInfer<Schemas>>): Machine.EventProtocol<"emitted", readonly [...Schemas]>;
+export declare const emittedEvents: <const Cases extends Readonly<Record<string, Schema.Struct.Fields>>>(cases: Cases & ValidateEventFields<NoInfer<Cases>> & ValidateEventProtocolBuilder<"emitted", EventFieldsSchemas<Cases>>) => Machine.EventProtocol<"emitted", EventFieldsSchemas<Cases>>;
+/** Imports existing schemas and protocols without rebuilding their contracts.
+ * @category constructors
+ * @since 0.32.0
+ */
+export declare const emittedEventsFromSchemas: {
     <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"emitted">>>(...inputs: Inputs & ValidateEventProtocolBuilder<"emitted", Inputs>): Machine.EventProtocol<"emitted", Machine.EventProtocolInputSchemasOf<"emitted", Inputs>>;
 };
 /**
@@ -4868,12 +5026,12 @@ export declare const emittedEvents: {
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
- * }).handle({ Idle: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(to => to.Idle.from()))
+ * }).handle({ states: { Idle: {} } })
  *
  * const encoded = Effect.gen(function*() {
  *   const initial = yield* Machine.planInitial(machine)
@@ -4912,12 +5070,12 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
- * }).handle({ Idle: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(to => to.Idle.from()))
+ * }).handle({ states: { Idle: {} } })
  *
  * const roundTrip = Effect.gen(function*() {
  *   const initial = yield* Machine.planInitial(machine)
@@ -4971,12 +5129,12 @@ type ValidateTransitionBranchRecord<Branches> = [keyof Branches] extends [never]
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
- * }).handle({ Idle: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(to => to.Idle.from()))
+ * }).handle({ states: { Idle: {} } })
  *
  * const initialState = Effect.map(Machine.planInitial(machine), (plan) => plan.state)
  * ```
@@ -4991,14 +5149,14 @@ export declare const planInitial: <const States extends Machine.StateSchemas, co
     readonly initialEntryPaths: ReadonlyArray<Machine.StateIdentifier<States>>;
     readonly state: Machine.Snapshot<States>;
     readonly commands: ReadonlyArray<Command>;
-    readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
+    readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<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 emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>;
         readonly exitPaths: ReadonlyArray<string>;
         readonly entryPaths: ReadonlyArray<string>;
         readonly changed: boolean;
@@ -5115,23 +5273,38 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * they accept the event. Any commands, emissions, or raised events collected
  * during that check are discarded.
  *
- * Event input is decoded through the machine's public event protocol. Invalid
- * input fails with `MachineSchemaDecodeError`. Final snapshots and valid events
+ * Event input is decoded through the machine's public and internal event protocols.
+ * Invalid input fails with `MachineSchemaDecodeError`. Final snapshots and valid events
  * with no accepting handler return `false`.
  *
  * **Gotchas**
  *
  * This query does not execute transitions or stabilize the resulting machine.
  * It does not run entry, exit, always, completion, child lifecycle, or command
- * effects. A `true` result therefore describes event acceptance only.
+ * effects. A `true` result therefore describes event acceptance only, for this
+ * snapshot. It does not guarantee acceptance after the machine advances.
+ *
+ * This Effect can also be used by machine effects to query internal events.
+ * Synchronous transition resolvers cannot execute it. Querying an internal event
+ * does not make that event available to `MachineRef.send`.
  *
  * **Example**
  *
  * ```ts
- * const canCheckout = Machine.can(checkoutMachine)
+ * import { Machine } from "@typeonce/effect-machine"
+ * import { Effect, Schema } from "effect"
+ *
+ * const internalEvents = Machine.internalEventsFromSchemas(Schema.TaggedStruct("Loaded", {}))
+ * const machine = Machine.make({
+ *   root: Machine.state({ initial: "Idle", states: { Idle: {} } }),
+ *   events: Machine.eventsFromSchemas(),
+ *   internalEvents,
+ *   initialConfiguration: (root) => root.resolve(({ target }) => target.from((to) => to.Idle.from()))
+ * }).handle({ states: { Idle: { on: { Loaded: (to) => to.none } } } })
  *
- * const canSubmit = yield* canCheckout(snapshot, {
- *   _tag: "SubmitOrder"
+ * export const canLoad = Effect.gen(function*() {
+ *   const initial = yield* Machine.planInitial(machine)
+ *   return yield* Machine.can(machine, initial.state, internalEvents.Loaded())
  * })
  * ```
  *
@@ -5139,11 +5312,11 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * @since 0.30.0
  */
 export declare const can: {
-    <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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>): (state: Machine.Snapshot<States>, event: Machine.EventInputOf<InputEvents>) => Effect.Effect<boolean, MachineSchemaDecodeError>;
-    <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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, state: Machine.Snapshot<States>, event: Machine.EventInputOf<InputEvents>): Effect.Effect<boolean, MachineSchemaDecodeError>;
+    <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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>): (state: Machine.Snapshot<States>, event: Machine.EventInputOf<Events>) => Effect.Effect<boolean, MachineSchemaDecodeError>;
+    <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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, state: Machine.Snapshot<States>, event: Machine.EventInputOf<Events>): Effect.Effect<boolean, MachineSchemaDecodeError>;
 };
 /**
- * Plans the next state snapshot synchronously.
+ * Returns an Effect that plans the next state snapshot without running command effects.
  *
  * **Details**
  *
@@ -5168,20 +5341,20 @@ export declare const can: {
  * 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.states({ Off, On })
+ * const States = Machine.state({ initial: "Off", states: { Off, On } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(Toggle),
- *   initial: (to) => to.Off().resolve(({ target }) => target.from())
- * }).handle({
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(Toggle),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(to => to.Off.from()))
+ * }).handle({ states: {
  *   Off: {
  *     on: {
  *       Toggle: (to) =>
- *         to.full.On().resolve(({ target }) => target.from())
+ *         to.branch.On().resolve(({ target }) => target.from())
  *     }
  *   },
  *   On: {}
- * })
+ * } })
  *
  * const nextState = Effect.gen(function*() {
  *   const initial = yield* Machine.planInitial(machine)
@@ -5195,16 +5368,17 @@ export declare const can: {
  * @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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, state: Machine.Snapshot<States>, event: Machine.EventInputOf<InputEvents>) => Effect.Effect<{
+    readonly event: Machine.EventOf<InputEvents>;
     readonly next: Machine.Snapshot<States>;
     readonly commands: ReadonlyArray<Command>;
-    readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
+    readonly emittedEvents: ReadonlyArray<Machine.EmittedEventOf<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 emittedEvents: ReadonlyArray<Machine.EmittedEventOf<Emits>>;
         readonly exitPaths: ReadonlyArray<string>;
         readonly entryPaths: ReadonlyArray<string>;
         readonly changed: boolean;
@@ -5351,7 +5525,7 @@ export declare const watch: <State, Event, Error = never, Output = never>(ref: M
  * @category constructors
  * @since 0.11.0
  */
-export declare const prepare: <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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<Prepared<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>>;
+export declare const prepare: <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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<Prepared<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmittedEventOf<Emits>>>>;
 /**
  * Starts a machine.
  *
@@ -5381,12 +5555,12 @@ export declare const prepare: <const States extends Machine.StateSchemas, const
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
- * }).handle({ Idle: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(to => to.Idle.from()))
+ * }).handle({ states: { Idle: {} } })
  *
  * const state = Effect.gen(function*() {
  *   const ref = yield* Machine.start(machine)
@@ -5399,7 +5573,7 @@ export declare const prepare: <const States extends Machine.StateSchemas, const
  * @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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmittedEventOf<Emits>>>;
 /**
  * Starts a fresh managed runtime from a decoded logical snapshot.
  *
@@ -5431,12 +5605,12 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
- * const States = Machine.states({ Idle })
+ * const States = Machine.state({ initial: "Idle", states: { Idle } })
  * const machine = Machine.make({
- *   states: States.states,
- *   events: Machine.events(),
- *   initial: (to) => to.Idle().resolve(({ target }) => target.from())
- * }).handle({ Idle: {} })
+ *   root: States,
+ *   events: Machine.eventsFromSchemas(),
+ *   initialConfiguration: root => root.resolve(({ target }) => target.from(to => to.Idle.from()))
+ * }).handle({ states: { Idle: {} } })
  *
  * const resumed = Effect.gen(function*() {
  *   const initial = yield* Machine.planInitial(machine)
@@ -5451,5 +5625,5 @@ export declare const start: <const States extends Machine.StateSchemas, const Ev
  * @category constructors
  * @since 0.4.0
  */
-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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<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, ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents, ParentEvents> & EnsureExecutable<States, UnhandledStates, OutputStates> & Machine.RootCompatible<ParentEvents>, snapshot: Machine.Snapshot<States>) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventInputOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output, Machine.EmittedEventOf<Emits>>, MachineSchemaDecodeError, ExcludeCompatibleRuntime<ExecutionServices<R>, Machine.EventOf<Events>, Machine.EmittedEventOf<Emits>>>;
 //# sourceMappingURL=Machine.d.ts.map