@typeonce/effect-machine 0.1.0 → 0.3.0

package/dist/Machine.d.ts

@@ -4,6 +4,7 @@
  * @since 4.0.0
  */
 import type * as Cause from "effect/Cause";
+import type * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { type Pipeable } from "effect/Pipeable";
@@ -30,6 +31,8 @@ export type TypeId = "~effect/Machine";
  * @since 4.0.0
  */
 export declare const TypeId: TypeId;
+declare const MachineOutputStatesTypeId: unique symbol;
+declare const MachineTypeId: unique symbol;
 /**
  * Type identifier used for the synthetic event passed to startup lifecycle
  * actions.
@@ -76,26 +79,69 @@ type IsAny<A> = 0 extends (1 & A) ? true : false;
  *
  * **Gotchas**
  *
- * History states, delayed transitions, and declarative first-class guards are
- * not part of the current API. Conditional behavior can be expressed in typed
- * handlers with ordinary TypeScript control flow.
+ * Declarative first-class guards are not part of the current API. Conditional
+ * behavior can be expressed in typed handlers with ordinary TypeScript control
+ * flow. Use `after` for cancellable state-scoped delayed events.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Machine<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], OutputStates extends Machine.StateIdentifier<States> = never> extends Pipeable {
+export interface Machine<States extends Machine.StateSchemas, Events extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events> extends Pipeable {
     readonly [TypeId]: TypeId;
+    /** @internal Stable type-level carrier for machine protocol extraction. */
+    readonly [MachineTypeId]: Machine.TypeCarrier<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>;
+    /** @internal Prevents output implementation evidence from being widened. */
+    readonly [MachineOutputStatesTypeId]: Readonly<Record<OutputStates, true>>;
+    /**
+     * State tree that defines the machine topology and state value schemas.
+     *
+     * @since 4.0.0
+     */
     readonly states: States;
-    readonly events: Events;
+    /**
+     * Events accepted through public machine input boundaries.
+     *
+     * @since 4.0.0
+     */
+    readonly events: InputEvents;
+    /**
+     * Events reserved for invokes, child emissions, and other machine-local work.
+     *
+     * @since 4.0.0
+     */
+    readonly internalEvents: ReadonlyArray<Machine.TaggedSchema>;
+    /**
+     * Events that the machine may emit to its parent or external adapter.
+     *
+     * @since 4.0.0
+     */
     readonly emits: Emits;
+    /**
+     * Optional schema used to decode the machine input before initialization.
+     *
+     * @since 4.0.0
+     */
     readonly input: Input | undefined;
+    /**
+     * Optional stable identity used by runtime and persistence integrations.
+     *
+     * @since 4.0.0
+     */
     readonly id: string | undefined;
     /** @internal */
     readonly stateNodes: Machine.StateNodes;
     /** @internal */
     readonly makeTargetBuilder: <Source extends Machine.StateIdentifier<States>>(source: Source) => Machine.TargetBuilder<States, Source>;
+    /** @internal */
     readonly handlers: Machine.StateConfigs<States, Events, Emits, UnhandledStates, Machine.TagOf<Events[number]>, E, R>;
-    readonly handle: Machine.Handler<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates>;
+    /**
+     * Adds typed state handlers and returns the refined machine definition.
+     * Successive calls implement the remaining unhandled states while retaining
+     * accumulated errors, services, final states, and output evidence.
+     *
+     * @since 4.0.0
+     */
+    readonly handle: Machine.Handler<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents>;
     /** @internal */
     readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>;
 }
@@ -207,7 +253,17 @@ export type ExecutionServices<Requirements> = Exclude<PlanningServices<Requireme
  * @since 4.0.0
  */
 export interface Runtime<in Events, in Emits> {
+    /**
+     * Queues an event for the current machine macrostep.
+     *
+     * @since 4.0.0
+     */
     readonly raise: (event: Events) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
+    /**
+     * Emits an event through the running machine's parent boundary.
+     *
+     * @since 4.0.0
+     */
     readonly sendParent: (event: Emits) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
 }
 /**
@@ -259,22 +315,21 @@ 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 RuntimeCompatibilityErrorTypeId = "~effect/Machine/RuntimeCompatibilityError";
 declare const InvokeTypeId: unique symbol;
-type EnsureCompatibleRuntime<Requirements, Events, Emits> = [IncompatibleRuntime<Requirements, Events, Emits>] extends [
-    never
-] ? unknown : {
-    readonly [RuntimeCompatibilityErrorTypeId]: IncompatibleRuntime<Requirements, Events, Emits>;
-};
 type StateDefinitionError<Message extends string> = {
     readonly "~effect/Machine/DefinitionError": Message;
 };
-type ValidateStateTree<States extends Machine.StateSchemas> = {
-    readonly [Key in keyof States]: ValidateStateNode<States[Key]>;
+type ActiveStateKey<States extends Machine.StateSchemas> = Machine.ActiveStateKey<States>;
+type HistoryStateKey<States extends Machine.StateSchemas> = Machine.HistoryStateKey<States>;
+type ValidateStateTree<States extends Machine.StateSchemas, AllowHistory extends boolean = false> = {
+    readonly [Key in keyof States]: ValidateStateNode<States[Key], AllowHistory>;
 };
-type ValidateStateNode<Node> = Node extends Machine.TaggedSchema ? unknown : Node extends {
+type ValidateStateNode<Node, AllowHistory extends boolean> = Node extends Machine.HistoryStateNodeConfig ? AllowHistory extends true ? ValidateHistoryStateNode<Node> : StateDefinitionError<"History states must be declared below an active parent state"> : Node extends Machine.TaggedSchema ? unknown : Node extends {
     readonly schema: Machine.TaggedSchema;
 } ? ValidateStateNodeConfig<Node> : StateDefinitionError<"State nodes must be tagged schemas or state node configs">;
+type ValidateHistoryStateNode<Node extends Machine.HistoryStateNodeConfig> = [
+    Extract<keyof Node, "schema" | "states" | "initial" | "output">
+] extends [never] ? unknown : StateDefinitionError<"History states cannot declare schemas, children, initial states, or output">;
 type ValidateStateNodeConfig<Node extends {
     readonly schema: Machine.TaggedSchema;
 }> = Node extends {
@@ -290,14 +345,14 @@ type ValidateStateNodeWithChildren<Node extends {
 } ? StateDefinitionError<"Final states cannot declare child states"> : Node extends {
     readonly type: "parallel";
 } ? "initial" extends keyof Node ? StateDefinitionError<"Parallel states cannot declare an initial child"> : {
-    readonly states: ValidateStateTree<Children>;
+    readonly states: ValidateStateTree<Children, true>;
 } & ValidateOutputSchema<Node> : "output" extends keyof Node ? StateDefinitionError<"Only final and parallel states can declare output"> : ValidateCompoundStateNode<Node, Children> : StateDefinitionError<"Child states must be a state tree">;
 type ValidateCompoundStateNode<Node extends {
     readonly schema: Machine.TaggedSchema;
 }, Children extends Machine.StateSchemas> = Node extends {
     readonly initial: infer Initial;
-} ? Initial extends Extract<keyof Children, string> ? {
-    readonly states: ValidateStateTree<Children>;
+} ? Initial extends ActiveStateKey<Children> ? {
+    readonly states: ValidateStateTree<Children, true>;
 } : StateDefinitionError<"Compound initial must be one of its direct child keys"> : StateDefinitionError<"Compound states must declare an initial child">;
 type ValidateStateNodeWithoutChildren<Node extends {
     readonly schema: Machine.TaggedSchema;
@@ -307,7 +362,7 @@ type ValidateStateNodeWithoutChildren<Node extends {
 type DefineStateTreeInput<States extends Machine.StateSchemas> = {
     readonly [Key in keyof States]: DefineStateNodeInput<States[Key]>;
 };
-type DefineStateNodeInput<Node> = Node extends Machine.TaggedSchema ? Node : Node extends {
+type DefineStateNodeInput<Node> = Node extends Machine.TaggedSchema ? Node : Node extends Machine.HistoryStateNodeConfig ? Machine.HistoryStateNodeConfig : Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Omit<Node, "states"> & {
@@ -315,21 +370,60 @@ type DefineStateNodeInput<Node> = Node extends Machine.TaggedSchema ? Node : Nod
 } : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Omit<Node, "initial" | "states"> & {
-    readonly initial: Extract<keyof Children, string>;
+    readonly initial: ActiveStateKey<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>;
+interface DefineStates {
+    <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 EventProtocolError<Message extends string, Tag extends PropertyKey = never> = {
+    readonly "~effect/Machine/EventProtocolError": Message;
+    readonly tag: Tag;
+};
+type DuplicateEventTag<Events extends ReadonlyArray<Machine.TaggedSchema>, Seen extends PropertyKey = never> = number extends Events["length"] ? never : Events extends readonly [
+    infer Head extends Machine.TaggedSchema,
+    ...infer Tail extends ReadonlyArray<Machine.TaggedSchema>
+] ? Machine.TagOf<Head> extends infer Tag extends PropertyKey ? Tag extends Seen ? Tag | DuplicateEventTag<Tail, Seen> : DuplicateEventTag<Tail, Seen | Tag> : never : never;
+type ValidateInputEventProtocol<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, DuplicateInput extends PropertyKey = DuplicateEventTag<InputEvents>> = [DuplicateInput] extends [never] ? unknown : EventProtocolError<"Public event tags must be unique", DuplicateInput>;
+type ValidateInternalEventProtocol<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>, DuplicateInternal extends PropertyKey = DuplicateEventTag<InternalEvents>, Overlap extends PropertyKey = Extract<Machine.TagOf<InputEvents[number]>, Machine.TagOf<InternalEvents[number]>>> = [DuplicateInternal] extends [never] ? [Overlap] extends [never] ? unknown : EventProtocolError<"Public and internal event tags must be disjoint", Overlap> : EventProtocolError<"Internal event tags must be unique", DuplicateInternal>;
 declare const SnapshotBuilderStateTypeId: unique symbol;
-type SnapshotBuilderComplete<Regions> = {
+declare const SnapshotBuilderConstructionTypeId: unique symbol;
+type SnapshotBuilderComplete<Regions, Constructed extends boolean = false> = {
     readonly [SnapshotBuilderStateTypeId]: Regions;
+    readonly [SnapshotBuilderConstructionTypeId]: Constructed;
 };
+type FromCallable<Arguments extends ReadonlyArray<unknown>, Result> = Arguments extends readonly [infer Input, ...infer Rest extends ReadonlyArray<unknown>] ? {} extends Input ? {
+    (...args: Rest): Result;
+    (...args: Arguments): Result;
+} : (...args: Arguments) => Result : (...args: Arguments) => Result;
+type FromMethod<Arguments extends ReadonlyArray<unknown>, Result> = {
+    /**
+     * Constructs the selected state from its schema make input while the
+     * machine plans the resulting configuration. The input may be omitted when
+     * the schema accepts an empty constructor object.
+     *
+     * @since 4.0.0
+     */
+    readonly from: FromCallable<Arguments, Machine.StateConstruction<Result>>;
+};
+type ConstructionResult<Result> = Result | Machine.StateConstruction<Result>;
+type UnwrapConstruction<Result> = Result extends Machine.StateConstruction<infer Value> ? Value : Result;
+type ConstructionSelectorFromCallable<Input, Builder, Result> = {} extends Input ? {
+    <Selected extends ConstructionResult<Result>>(state: (builder: Builder) => Selected): Machine.StateConstruction<UnwrapConstruction<Selected>>;
+    <Selected extends ConstructionResult<Result>>(input: Input, state: (builder: Builder) => Selected): Machine.StateConstruction<UnwrapConstruction<Selected>>;
+} : <Selected extends ConstructionResult<Result>>(input: Input, state: (builder: Builder) => Selected) => Machine.StateConstruction<UnwrapConstruction<Selected>>;
 type InitialSnapshotBuilderWithPrefix<States extends Machine.StateSchemas, Prefix extends string = ""> = {
-    readonly [Key in Extract<keyof States, string>]: InitialSnapshotMethod<States, Key, Prefix>;
+    readonly [Key in ActiveStateKey<States>]: InitialSnapshotMethod<States, Key, Prefix>;
 };
-type InitialSnapshotMethod<States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string> = (...args: InitialSnapshotArguments<States, StateId, Prefix>) => InitialSnapshotResult<States, StateId, Prefix>;
-type InitialSnapshotArguments<States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+type InitialSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = ((...args: InitialSnapshotArguments<States, StateId, Prefix>) => InitialSnapshotResult<States, StateId, Prefix>) & FromMethod<InitialSnapshotFromArguments<States, StateId, Prefix>, InitialSnapshotResult<States, StateId, Prefix>>;
+type InitialSnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
 } ? [
@@ -338,32 +432,50 @@ type InitialSnapshotArguments<States extends Machine.StateSchemas, StateId exten
 ] : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
-    readonly initial: infer Initial extends Extract<keyof Children, string>;
+    readonly initial: infer Initial extends ActiveStateKey<Children>;
 } ? [
     value: Machine.NodeSchema<Node>["Type"],
     state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => InitialSnapshotResult<Children, Initial, Path>
 ] : never : [value: Machine.NodeSchema<Node>["Type"]] : never;
-type InitialSnapshotResult<States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+type InitialSnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+    readonly type: "parallel";
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? [
+    input: Machine.NodeSchema<Node>["~type.make.in"],
+    states: (builder: InitialParallelBuilder<Children, Path>) => SnapshotBuilderComplete<InitialSnapshotRegionsWithPrefix<Children, Path>, boolean>
+] : Node extends {
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? Node extends {
+    readonly initial: infer Initial extends ActiveStateKey<Children>;
+} ? [
+    input: Machine.NodeSchema<Node>["~type.make.in"],
+    state: (builder: Pick<InitialSnapshotBuilderWithPrefix<Children, Path>, Initial>) => ConstructionResult<InitialSnapshotResult<Children, Initial, Path>>
+] : never : [input: Machine.NodeSchema<Node>["~type.make.in"]] : never;
+type InitialSnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Machine.ParallelSnapshot<Path, Machine.NodeSchema<Node>["Type"], InitialSnapshotRegionsWithPrefix<Children, Path>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Node extends {
-    readonly initial: infer Initial extends Extract<keyof Children, string>;
+    readonly initial: infer Initial extends ActiveStateKey<Children>;
 } ? Machine.CompoundSnapshot<Path, Machine.NodeSchema<Node>["Type"], InitialSnapshotResult<Children, Initial, Path>> : never : Machine.AtomicSnapshot<Path, Machine.NodeSchema<Node>["Type"]> : never;
 type InitialSnapshotRegionsWithPrefix<States extends Machine.StateSchemas, Prefix extends string> = {
-    readonly [Key in Extract<keyof States, string>]: InitialSnapshotResult<States, Key, Prefix>;
+    readonly [Key in ActiveStateKey<States>]: InitialSnapshotResult<States, Key, Prefix>;
 };
-type InitialParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Remaining extends Extract<keyof States, string> = Extract<keyof States, string>, Regions = {}> = SnapshotBuilderComplete<Regions> & {
-    readonly [Key in Remaining]: (...args: InitialSnapshotArguments<States, Key, Prefix>) => InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+type InitialParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
+    readonly [Key in Remaining]: ((...args: InitialSnapshotArguments<States, Key, Prefix>) => InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix>;
-    }>;
+    }, Constructed>) & {
+        readonly from: FromCallable<InitialSnapshotFromArguments<States, Key, Prefix>, InitialParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+            readonly [Region in Key]: InitialSnapshotResult<States, Key, Prefix>;
+        }, true>>;
+    };
 };
 type FullSnapshotBuilderWithPrefix<States extends Machine.StateSchemas, Prefix extends string = ""> = {
-    readonly [Key in Extract<keyof States, string>]: FullSnapshotMethod<States, Key, Prefix>;
+    readonly [Key in ActiveStateKey<States>]: FullSnapshotMethod<States, Key, Prefix>;
 };
-type FullSnapshotMethod<States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string> = (...args: FullSnapshotArguments<States, StateId, Prefix>) => FullSnapshotResult<States, StateId, Prefix>;
-type FullSnapshotArguments<States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+type FullSnapshotMethod<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string> = ((...args: FullSnapshotArguments<States, StateId, Prefix>) => FullSnapshotResult<States, StateId, Prefix>) & FromMethod<FullSnapshotFromArguments<States, StateId, Prefix>, FullSnapshotResult<States, StateId, Prefix>>;
+type FullSnapshotArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
     readonly type: "parallel";
     readonly states: infer Children extends Machine.StateSchemas;
 } ? [
@@ -375,11 +487,27 @@ type FullSnapshotArguments<States extends Machine.StateSchemas, StateId extends
     value: Machine.NodeSchema<Node>["Type"],
     state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => Machine.SnapshotWithPrefix<Children, Path>
 ] : [value: Machine.NodeSchema<Node>["Type"]] : never;
-type FullSnapshotResult<States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Machine.SnapshotByIdentifierWithPath<States, StateId, Path>;
-type FullParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Remaining extends Extract<keyof States, string> = Extract<keyof States, string>, Regions = {}> = SnapshotBuilderComplete<Regions> & {
-    readonly [Key in Remaining]: (...args: FullSnapshotArguments<States, Key, Prefix>) => FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+type FullSnapshotFromArguments<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+    readonly type: "parallel";
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? [
+    input: Machine.NodeSchema<Node>["~type.make.in"],
+    states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
+] : Node extends {
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? [
+    input: Machine.NodeSchema<Node>["~type.make.in"],
+    state: (builder: FullSnapshotBuilderWithPrefix<Children, Path>) => ConstructionResult<Machine.SnapshotWithPrefix<Children, Path>>
+] : [input: Machine.NodeSchema<Node>["~type.make.in"]] : never;
+type FullSnapshotResult<States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = Machine.SnapshotByIdentifierWithPath<States, StateId, Path>;
+type FullParallelBuilder<States extends Machine.StateSchemas, Prefix extends string, Remaining extends ActiveStateKey<States> = ActiveStateKey<States>, Regions = {}, Constructed extends boolean = false> = SnapshotBuilderComplete<Regions, Constructed> & {
+    readonly [Key in Remaining]: ((...args: FullSnapshotArguments<States, Key, Prefix>) => FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
         readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
-    }>;
+    }, Constructed>) & {
+        readonly from: FromCallable<FullSnapshotFromArguments<States, Key, Prefix>, FullParallelBuilder<States, Prefix, Exclude<Remaining, Key>, Regions & {
+            readonly [Region in Key]: FullSnapshotResult<States, Key, Prefix>;
+        }, true>>;
+    };
 };
 type ParentPath<Path extends string> = Path extends `${infer Parent}.${infer Child}` ? Child extends `${string}.${string}` ? `${Parent}.${ParentPath<Child>}` : Parent : never;
 type IsCompoundNode<Node> = Node extends {
@@ -392,48 +520,110 @@ type ChildrenOf<States extends Machine.StateSchemas, Path extends Machine.StateI
     readonly states: infer Children extends Machine.StateSchemas;
 } ? Children : never;
 type StateIdentifierFromPath<States extends Machine.StateSchemas, Path extends string> = Extract<Path, Machine.StateIdentifier<States>>;
-type LocalTargetResult<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends {
+type LocalTargetResult<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? LocalTargetResultWithPrefix<AllStates, Children, Path> : Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>;
+} ? States[StateId] extends {
+    readonly type: "parallel";
+} ? Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>> : LocalTargetResultWithPrefix<AllStates, Children, Path> : Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>;
 type LocalTargetResultWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
-    readonly [Key in Extract<keyof States, string>]: LocalTargetResult<AllStates, States, Key, Prefix>;
-}[Extract<keyof States, string>];
-type LocalTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
-    readonly [Key in Extract<keyof States, string>]: LocalTargetMethod<AllStates, States, Key, Prefix>;
+    readonly [Key in ActiveStateKey<States>]: LocalTargetResult<AllStates, States, Key, Prefix>;
+}[ActiveStateKey<States>];
+type LocalTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string, Source extends Machine.StateIdentifier<AllStates>> = {
+    readonly [Key in ActiveStateKey<States>]: LocalTargetMethod<AllStates, States, Key, Prefix, Source>;
 };
-type LocalTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+type LocalTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateIdentifier<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;
-} ? <Result extends LocalTargetResultWithPrefix<AllStates, Children, Path>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: LocalTargetBuilderWithPrefix<AllStates, Children, Path>) => Result) => Result : (value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>> : never;
-type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope extends Machine.StateIdentifier<States>> = ChildrenOf<States, Scope> extends infer Children extends Machine.StateSchemas ? LocalTargetBuilderWithPrefix<States, Children, Scope> & {
+} ? Source extends Path | `${Path}.${string}` ? (<Result extends ConstructionResult<LocalTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
+    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>>;
+} : ((value: Machine.NodeSchema<Node>["Type"], states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
+    input: Machine.NodeSchema<Node>["~type.make.in"],
+    states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
+], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : Node extends {
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? (<Result extends ConstructionResult<LocalTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
+    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], LocalTargetBuilderWithPrefix<AllStates, Children, Path, Source>, LocalTargetResultWithPrefix<AllStates, Children, Path>>;
+} : ((value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
+    input: Machine.NodeSchema<Node>["~type.make.in"]
+], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : never;
+type LocalTargetBuilderForScope<States extends Machine.StateSchemas, Scope extends Machine.StateIdentifier<States>, Source extends Machine.StateIdentifier<States>> = ChildrenOf<States, Scope> extends infer Children extends Machine.StateSchemas ? LocalTargetBuilderWithPrefix<States, Children, Scope, Source> & {
     /**
      * Updates the value of the state containing the local group and moves to
      * one of the states inside it. Values in other active branches are kept.
      *
      * @since 4.0.0
      */
-    readonly with: <Result extends LocalTargetResultWithPrefix<States, Children, Scope>>(value: Machine.StateByIdentifier<States, Scope>, state: (builder: LocalTargetBuilderWithPrefix<States, Children, Scope>) => Result) => Result;
+    readonly with: (<Result extends ConstructionResult<LocalTargetResultWithPrefix<States, Children, Scope>>>(value: Machine.StateByIdentifier<States, Scope>, state: (builder: LocalTargetBuilderWithPrefix<States, Children, Scope, Source>) => Result) => Result) & {
+        readonly from: ConstructionSelectorFromCallable<Machine.SchemaByIdentifier<States, Scope>["~type.make.in"], LocalTargetBuilderWithPrefix<States, Children, Scope, Source>, LocalTargetResultWithPrefix<States, Children, Scope>>;
+    };
 } : {};
-type BranchTargetResult<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends {
+type BranchTargetResult<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? BranchTargetResultWithPrefix<AllStates, Children, Path> : Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>;
+} ? States[StateId] extends {
+    readonly type: "parallel";
+} ? Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>> : BranchTargetResultWithPrefix<AllStates, Children, Path> : Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>;
 type BranchTargetResultWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
-    readonly [Key in Extract<keyof States, string>]: BranchTargetResult<AllStates, States, Key, Prefix>;
-}[Extract<keyof States, string>];
-type BranchTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
-    readonly [Key in Extract<keyof States, string>]: BranchTargetMethod<AllStates, States, Key, Prefix>;
+    readonly [Key in ActiveStateKey<States>]: BranchTargetResult<AllStates, States, Key, Prefix>;
+}[ActiveStateKey<States>];
+type BranchTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string, Source extends Machine.StateIdentifier<AllStates>> = {
+    readonly [Key in ActiveStateKey<States>]: BranchTargetMethod<AllStates, States, Key, Prefix, Source>;
 };
-type BranchTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends Extract<keyof States, string>, Prefix extends string, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+type BranchTargetMethod<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, StateId extends ActiveStateKey<States>, Prefix extends string, Source extends Machine.StateIdentifier<AllStates>, Path extends string = Machine.JoinPath<Prefix, StateId>> = States[StateId] extends infer Node ? Node extends {
+    readonly type: "parallel";
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? Source extends Path | `${Path}.${string}` ? (<Result extends ConstructionResult<BranchTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
+    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>>;
+} & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : ((value: Machine.NodeSchema<Node>["Type"], states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>>) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
+    input: Machine.NodeSchema<Node>["~type.make.in"],
+    states: (builder: FullParallelBuilder<Children, Path>) => SnapshotBuilderComplete<Machine.SnapshotRegionsWithPrefix<Children, Path>, boolean>
+], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : Node extends {
     readonly states: infer Children extends Machine.StateSchemas;
-} ? (<Result extends BranchTargetResultWithPrefix<AllStates, Children, Path>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: BranchTargetBuilderWithPrefix<AllStates, Children, Path>) => Result) => Result) & BranchTargetBuilderWithPrefix<AllStates, Children, Path> : (value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>> : never;
-type BranchTargetBuilderForRoot<States extends Machine.StateSchemas, Root extends Extract<keyof States, string>> = {
-    readonly [Key in Root]: BranchTargetMethod<States, States, Key, "">;
+} ? (<Result extends ConstructionResult<BranchTargetResultWithPrefix<AllStates, Children, Path>>>(value: Machine.NodeSchema<Node>["Type"], state: (builder: BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>) => Result) => Result) & {
+    readonly from: ConstructionSelectorFromCallable<Machine.NodeSchema<Node>["~type.make.in"], BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source>, BranchTargetResultWithPrefix<AllStates, Children, Path>>;
+} & BranchTargetBuilderWithPrefix<AllStates, Children, Path, Source> : ((value: Machine.NodeSchema<Node>["Type"]) => Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>) & FromMethod<[
+    input: Machine.NodeSchema<Node>["~type.make.in"]
+], Machine.Target<AllStates, StateIdentifierFromPath<AllStates, Path>>> : never;
+type BranchTargetBuilderForRoot<States extends Machine.StateSchemas, Root extends ActiveStateKey<States>, Source extends Machine.StateIdentifier<States>> = {
+    readonly [Key in Root]: BranchTargetMethod<States, States, Key, "", Source>;
 };
+type HistoryContainingKey<States extends Machine.StateSchemas> = {
+    readonly [Key in Extract<keyof States, string>]: States[Key] extends Machine.HistoryStateNodeConfig ? Key : States[Key] extends {
+        readonly states: infer Children extends Machine.StateSchemas;
+    } ? [
+        Machine.HistoryIdentifier<Children>
+    ] extends [never] ? never : Key : never;
+}[Extract<keyof States, string>];
+type HistoryTargetBuilderWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
+    readonly [Key in HistoryContainingKey<States>]: States[Key] extends Machine.HistoryStateNodeConfig ? () => Machine.HistoryTarget<AllStates, Extract<Machine.JoinPath<Prefix, Key>, Machine.HistoryIdentifier<AllStates>>> : States[Key] extends {
+        readonly states: infer Children extends Machine.StateSchemas;
+    } ? HistoryTargetBuilderWithPrefix<AllStates, Children, Machine.JoinPath<Prefix, Key>> : never;
+};
+type HasDirectShallowHistory<States extends Machine.StateSchemas> = {
+    readonly [Key in HistoryStateKey<States>]: States[Key] extends {
+        readonly history: "deep";
+    } ? never : Key;
+}[HistoryStateKey<States>] extends never ? false : true;
+type InitializerClosureForNode<AllStates extends Machine.StateSchemas, Node, Path extends string> = Node extends {
+    readonly type: "parallel";
+    readonly states: infer Children extends Machine.StateSchemas;
+} ? Extract<Path, Machine.StateIdentifier<AllStates>> | InitializerClosuresForChildren<AllStates, Children, Path> : Node extends {
+    readonly states: infer Children extends Machine.StateSchemas;
+    readonly initial: infer Initial;
+} ? Extract<Path, Machine.StateIdentifier<AllStates>> | (Initial extends ActiveStateKey<Children> ? InitializerClosureForNode<AllStates, Children[Initial], Machine.JoinPath<Path, Initial>> : 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>];
+type RequiredHistoryInitializersWithPrefix<AllStates extends Machine.StateSchemas, States extends Machine.StateSchemas, Prefix extends string> = {
+    readonly [Key in ActiveStateKey<States>]: States[Key] extends {
+        readonly states: infer Children extends Machine.StateSchemas;
+    } ? (HasDirectShallowHistory<Children> extends true ? InitializerClosuresForChildren<AllStates, Children, Machine.JoinPath<Prefix, Key>> : never) | RequiredHistoryInitializersWithPrefix<AllStates, Children, Machine.JoinPath<Prefix, Key>> : never;
+}[ActiveStateKey<States>];
 type SpawnRequirements<Requirements> = Exclude<Requirements, Scope.Scope>;
 type SpawnIdError<Options extends SpawnOptions> = "id" extends keyof Options ? Options extends {
     readonly id?: infer Id;
 } ? [Id] extends [undefined] ? never : ChildAlreadyExistsError : ChildAlreadyExistsError : never;
 type SpawnError<Options extends SpawnOptions> = SpawnIdError<Options>;
-type SpawnResult<State, Event, Error, Requirements, Output, SpawnError, InitialError = never> = Effect.Effect<MachineRef<State, Event, Error | InitialError, Output>, SpawnError | InitialError, MachineRuntimeRequirement | SpawnRequirements<Requirements>>;
+type SpawnResult<State, Event, Error, Requirements, Output, SpawnError, InitialError = never> = Effect.Effect<MachineRef<State, Event, Error, Output>, SpawnError | InitialError, MachineRuntimeRequirement | SpawnRequirements<Requirements>>;
 /**
  * Represents the active or terminal lifecycle state of a running machine.
  *
@@ -520,17 +710,33 @@ export type RuntimeOutcome<State, Error = never, Output = never> = {
  * @since 4.0.0
  */
 export interface MachineRef<out State, in Event, out Error = never, out Output = never> {
+    /** Stable machine definition id, or a generated fallback when none was declared. */
     readonly id: string;
+    /** Unique identity for this running machine instance. */
     readonly sessionId: string;
+    /** Reads the latest logical state. */
     readonly state: Effect.Effect<State>;
+    /** Reads the latest lifecycle snapshot. */
     readonly snapshot: Effect.Effect<RuntimeSnapshot<State, Error, Output>>;
+    /** Streams lifecycle snapshots published after subscription. */
     readonly changes: Stream.Stream<RuntimeSnapshot<State, Error, Output>>;
+    /** Waits for machine output or fails when execution fails or is stopped. */
     readonly join: Effect.Effect<Output, Error | StoppedError>;
+    /** Stops this machine instance and its owned child processes. */
     readonly stop: Effect.Effect<void>;
+    /** Accepts an event for asynchronous processing by the running machine. */
     readonly send: (event: Event) => Effect.Effect<void, StoppedError>;
-    /** Returns the current directly owned child for a typed descriptor. */
+    /**
+     * Returns the current directly owned child for a typed descriptor.
+     *
+     * @since 4.0.0
+     */
     readonly child: <Child extends ChildMachine.Any>(child: Child) => Effect.Effect<Option.Option<ChildMachine.Ref<Child>>>;
-    /** Streams activation, replacement, and removal of a directly owned child. */
+    /**
+     * Streams activation, replacement, and removal of a directly owned child.
+     *
+     * @since 4.0.0
+     */
     readonly childChanges: <Child extends ChildMachine.Any>(child: Child) => Stream.Stream<Option.Option<ChildMachine.Ref<Child>>>;
 }
 /**
@@ -540,7 +746,9 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
  * @since 4.0.0
  */
 export interface Logic<State, Event, out Error = never, out Requirements = never, out Output = never, out InitialError = never> {
+    /** Creates the initial process state and may spawn scoped child processes. */
     initial(scope: Logic.Scope<Event>): Effect.Effect<State, InitialError, Requirements>;
+    /** Runs the stateful process loop until it produces output or fails. */
     run(context: Logic.Context<State, Event>): Effect.Effect<Output, Error, Requirements>;
 }
 /**
@@ -556,9 +764,13 @@ export declare namespace Logic {
      * @since 4.0.0
      */
     interface Address<in Event> {
+        /** Parent-local address id. */
         readonly id: string;
+        /** Unique identity for this running child instance. */
         readonly sessionId: string;
+        /** Stops the addressed child process. */
         readonly stop: Effect.Effect<void>;
+        /** Sends an event to the addressed child process. */
         readonly send: (event: Event) => Effect.Effect<void, StoppedError>;
     }
     /**
@@ -568,10 +780,8 @@ export declare namespace Logic {
      * @since 4.0.0
      */
     interface Spawn {
-        <ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError = never>(logic: Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>): Effect.Effect<MachineRef<ChildState, ChildEvent, ChildError | ChildInitialError, ChildOutput>, ChildInitialError, Exclude<ChildRequirements, Scope.Scope>>;
-        <ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError = never>(logic: Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, options: {
-            readonly id: string;
-        }): Effect.Effect<MachineRef<ChildState, ChildEvent, ChildError | ChildInitialError, ChildOutput>, ChildAlreadyExistsError | ChildInitialError, Exclude<ChildRequirements, Scope.Scope>>;
+        <ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError = never>(logic: Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>): Effect.Effect<MachineRef<ChildState, ChildEvent, ChildError, ChildOutput>, ChildInitialError, Exclude<ChildRequirements, Scope.Scope>>;
+        <ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, Options extends SpawnOptions, ChildInitialError = never>(logic: Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>, options: Options & ChildAddress.OptionsCompatibility<Options, ChildEvent>): Effect.Effect<MachineRef<ChildState, ChildEvent, ChildError, ChildOutput>, SpawnIdError<Options> | ChildInitialError, Exclude<ChildRequirements, Scope.Scope>>;
     }
     /**
      * Machine-local capabilities available while process logic initializes.
@@ -586,12 +796,18 @@ export declare namespace Logic {
      * @since 4.0.0
      */
     interface Scope<Event> {
+        /** Address of the process being initialized. */
         readonly self: Address<Event>;
+        /** Address of the owning process, when one exists. */
         readonly parent: Address<unknown> | undefined;
+        /** Starts a child process owned by this scope. */
         readonly spawn: Spawn;
+        /** Sends an untyped event to the owning process. */
         readonly sendParent: (event: unknown) => Effect.Effect<void, StoppedError>;
-        readonly sendTo: <Address extends string>(id: Address, event: ChildAddress.Event<Address>) => Effect.Effect<void, StoppedError>;
-        readonly stopChild: (id: string) => Effect.Effect<void>;
+        /** Sends an event through a typed parent-local child address. */
+        readonly sendTo: <Address extends ChildAddress<never>>(id: Address, event: ChildAddress.Event<Address>) => Effect.Effect<void, StoppedError>;
+        /** Stops a child process selected by its parent-local address. */
+        readonly stopChild: <Event>(id: ChildAddress<Event>) => Effect.Effect<void>;
     }
     /**
      * Machine-local capabilities available while stateful process logic runs.
@@ -600,15 +816,22 @@ export declare namespace Logic {
      * @since 4.0.0
      */
     interface Context<State, Event> extends Scope<Event> {
+        /** Waits for the next event delivered to this process. */
         readonly receive: Effect.Effect<Event>;
+        /** Reads the current process state. */
         readonly state: Effect.Effect<State>;
+        /** Replaces the current process state. */
         readonly setState: (state: State) => Effect.Effect<void>;
+        /** Updates the current process state effectfully and atomically. */
         readonly updateState: <E, R>(update: (state: State) => Effect.Effect<State, E, R>) => Effect.Effect<void, E, R>;
     }
 }
 declare const ChildAddressTypeId = "~effect/Machine/ChildAddress";
 declare const ChildAddressCompatibilityErrorTypeId = "~effect/Machine/ChildAddressCompatibilityError";
 declare const ChildMachineTypeId = "~effect/Machine/ChildMachine";
+type InvokeLifecycleId = string & {
+    readonly [ChildAddressTypeId]?: never;
+};
 /**
  * Typed descriptor for a complete machine invoked as a child.
  *
@@ -623,7 +846,9 @@ declare const ChildMachineTypeId = "~effect/Machine/ChildMachine";
  */
 export interface ChildMachine<Id extends string, M extends Machine.Any> {
     readonly [ChildMachineTypeId]: typeof ChildMachineTypeId;
+    /** Parent-local id used to address the invoked child. */
     readonly id: Id;
+    /** Complete machine definition carried by this descriptor. */
     readonly machine: M;
 }
 /**
@@ -645,7 +870,7 @@ export declare namespace ChildMachine {
      * @category utility types
      * @since 4.0.0
      */
-    type Ref<Child> = Child extends ChildMachine<string, infer M> ? M extends Machine<infer States, infer Events, any, any, infer E, infer R, infer InitialE, infer InitialR, any, infer Output, any, any> ? MachineRef<Machine.Snapshot<States>, Machine.EventOf<Events>, E | InitialE | ActionError<R | InitialR> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Output | undefined> : never : never;
+    type Ref<Child> = Child extends ChildMachine<string, infer M> ? MachineRef<Machine.Snapshot<Machine.States<M>>, Machine.InputEvent<M>, Machine.Error<M> | ActionError<Machine.Services<M>> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Machine.Output<M>> : never;
     /**
      * Event accepted by the child selected by a descriptor.
      *
@@ -735,13 +960,170 @@ export interface SpawnIdOptions extends SpawnOptions {
  * @since 4.0.0
  */
 export declare namespace Machine {
+    /**
+     * Stable type-level representation carried by every machine definition.
+     *
+     * @internal
+     */
+    interface TypeCarrier<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<States>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<States>, Output, Emits extends ReadonlyArray<TaggedSchema>, OutputStates extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>> {
+        readonly states: States;
+        readonly events: Events;
+        readonly input: Input;
+        readonly unhandledStates: UnhandledStates;
+        readonly error: E;
+        readonly services: R;
+        readonly initialError: InitialE;
+        readonly initialServices: InitialR;
+        readonly finalStates: FinalStates;
+        readonly output: Output;
+        readonly emits: Emits;
+        readonly outputStates: OutputStates;
+        readonly inputEvents: InputEvents;
+    }
     /**
      * Any schema-first machine.
      *
+     * This is an erased structural view for APIs that store machines without
+     * knowing their protocols. Generic APIs should capture `M extends Any` to
+     * preserve the concrete machine type. The private output-implementation
+     * proof is intentionally omitted so erasing a machine cannot manufacture
+     * that proof on another concrete `Machine` type.
+     *
      * @category models
      * @since 4.0.0
      */
-    type Any = Machine<any, any, any, any, any, any, any, any, any, any, any, any>;
+    interface Any extends Pipeable {
+        readonly [TypeId]: TypeId;
+        /** @internal */
+        readonly [MachineTypeId]: TypeCarrier<any, any, any, any, any, any, any, any, any, any, any, any, any>;
+        readonly states: StateSchemas;
+        readonly events: ReadonlyArray<TaggedSchema>;
+        readonly internalEvents: ReadonlyArray<TaggedSchema>;
+        readonly emits: ReadonlyArray<TaggedSchema>;
+        readonly input: Schema.Top | undefined;
+        readonly id: string | undefined;
+        readonly stateNodes: StateNodes;
+        /** @internal */
+        readonly makeTargetBuilder: any;
+        /** @internal */
+        readonly handlers: any;
+        /** @internal */
+        readonly handle: any;
+        /** @internal */
+        readonly initial: any;
+    }
+    /**
+     * Extracts the state schema tree carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type States<M extends Any> = M[typeof MachineTypeId]["states"];
+    /**
+     * Extracts the complete event schema tuple carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type Events<M extends Any> = M[typeof MachineTypeId]["events"];
+    /**
+     * Extracts the input schema carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type Input<M extends Any> = M[typeof MachineTypeId]["input"];
+    /**
+     * Extracts state paths that do not yet have handlers.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type UnhandledStates<M extends Any> = M[typeof MachineTypeId]["unhandledStates"];
+    /**
+     * Extracts the runtime error channel carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type Error<M extends Any> = M[typeof MachineTypeId]["error"];
+    /**
+     * Extracts runtime service requirements carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type Services<M extends Any> = M[typeof MachineTypeId]["services"];
+    /**
+     * Extracts the startup error channel carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type InitialError<M extends Any> = M[typeof MachineTypeId]["initialError"];
+    /**
+     * Extracts startup service requirements carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type InitialServices<M extends Any> = M[typeof MachineTypeId]["initialServices"];
+    /**
+     * Extracts final state paths carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type FinalStates<M extends Any> = M[typeof MachineTypeId]["finalStates"];
+    /**
+     * Extracts the terminal output channel carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type Output<M extends Any> = M[typeof MachineTypeId]["output"];
+    /**
+     * Extracts the emitted event schema tuple carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type Emits<M extends Any> = M[typeof MachineTypeId]["emits"];
+    /**
+     * Extracts state paths with implemented output handlers.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type OutputStates<M extends Any> = M[typeof MachineTypeId]["outputStates"];
+    /**
+     * Extracts the public input event schema tuple carried by a machine definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"];
+    /**
+     * Extracts the complete event protocol handled inside a machine.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type Event<M extends Any> = EventOf<Events<M>>;
+    /**
+     * Extracts the event protocol accepted by public machine input boundaries.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type InputEvent<M extends Any> = EventOf<InputEvents<M>>;
+    /**
+     * Extracts the event protocol emitted by a machine.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type Emit<M extends Any> = EmitOf<Emits<M>>;
     /**
      * A schema whose decoded value contains a `_tag` discriminator.
      *
@@ -796,13 +1178,27 @@ export declare namespace Machine {
         readonly output?: Schema.Top;
         readonly states: StateTree;
     }
+    /**
+     * Pseudo-state that restores the last active configuration of its parent.
+     *
+     * History nodes are transition targets only. They never become active and
+     * therefore do not declare a state value schema or lifecycle handlers.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface HistoryStateNodeConfig {
+        readonly type: "history";
+        /** Defaults to shallow history. */
+        readonly history?: "shallow" | "deep";
+    }
     /**
      * Configuration accepted for an object state node.
      *
      * @category models
      * @since 4.0.0
      */
-    type StateNodeConfig = AtomicStateNodeConfig | CompoundStateNodeConfig | ParallelStateNodeConfig;
+    type StateNodeConfig = AtomicStateNodeConfig | CompoundStateNodeConfig | ParallelStateNodeConfig | HistoryStateNodeConfig;
     /**
      * Object state tree keyed by state path.
      *
@@ -847,7 +1243,9 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     interface DefinedStates<States extends StateSchemas> {
+        /** Original state tree supplied to {@link defineStates}. */
         readonly states: States;
+        /** Type-safe builders for constructing valid initial snapshots. */
         readonly initial: InitialBuilder<States>;
         /**
          * Returns the decoded value for an active state path.
@@ -895,9 +1293,10 @@ export declare namespace Machine {
     interface StateNode {
         readonly path: string;
         readonly key: string;
-        readonly schema: TaggedSchema;
+        readonly schema: TaggedSchema | undefined;
         readonly output: Schema.Top | undefined;
-        readonly type: "atomic" | "compound" | "parallel" | "final";
+        readonly type: "atomic" | "compound" | "parallel" | "final" | "history";
+        readonly history: "shallow" | "deep" | undefined;
         readonly parent: string | undefined;
         readonly children: ReadonlyArray<string>;
         readonly initial: string | undefined;
@@ -958,10 +1357,47 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     type StateIdentifierWithPrefix<States extends StateSchemas, Prefix extends string = ""> = {
-        readonly [Key in Extract<keyof States, string>]: States[Key] extends {
+        readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig ? never : States[Key] extends {
             readonly states: infer Children;
         } ? Children extends StateSchemas ? JoinPath<Prefix, Key> | StateIdentifierWithPrefix<Children, JoinPath<Prefix, Key>> : JoinPath<Prefix, Key> : JoinPath<Prefix, Key>;
     }[Extract<keyof States, string>];
+    /**
+     * Extracts the transition-only history pseudo-state paths in a definition.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type HistoryIdentifier<States extends StateSchemas> = HistoryIdentifierWithPrefix<States>;
+    /** @internal */
+    type HistoryIdentifierWithPrefix<States extends StateSchemas, Prefix extends string = ""> = {
+        readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig ? JoinPath<Prefix, Key> : States[Key] extends {
+            readonly states: infer Children extends StateSchemas;
+        } ? HistoryIdentifierWithPrefix<Children, JoinPath<Prefix, Key>> : never;
+    }[Extract<keyof States, string>];
+    /** Active keys directly declared in a state tree. */
+    type ActiveStateKey<States extends StateSchemas> = {
+        readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig ? never : Key;
+    }[Extract<keyof States, string>];
+    /** History pseudo-state keys directly declared in a state tree. */
+    type HistoryStateKey<States extends StateSchemas> = {
+        readonly [Key in Extract<keyof States, string>]: States[Key] extends HistoryStateNodeConfig ? Key : never;
+    }[Extract<keyof States, string>];
+    /**
+     * Active states that must implement implicit initial-value construction for
+     * shallow history restoration.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type RequiredHistoryInitializers<States extends StateSchemas> = [HistoryIdentifier<States>] extends [never] ? never : Extract<RequiredHistoryInitializersWithPrefix<States, States, "">, StateIdentifier<States>>;
+    /** Active parent states that own one or more history pseudo-states. */
+    type HistoryParentIdentifier<States extends StateSchemas> = HistoryIdentifier<States> extends infer HistoryId ? HistoryId extends string ? Extract<ImmediateParentStateIdentifier<HistoryId>, StateIdentifier<States>> : never : never;
+    /** History defaults and implicit initializers that remain unimplemented. */
+    type MissingHistoryImplementations<States extends StateSchemas, UnhandledStates extends StateIdentifier<States>> = Extract<UnhandledStates, HistoryParentIdentifier<States> | RequiredHistoryInitializers<States>>;
+    /** @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 : {
+        readonly "~effect/Machine/MissingHistoryImplementation": MissingHistoryImplementations<States, UnhandledStates>;
+    };
     /**
      * Extracts a state-tree node by state path.
      *
@@ -1028,6 +1464,13 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     type ParentStateIdentifier<StateId extends string> = StateId extends `${infer Parent}.${infer Child}` ? Parent | (Child extends `${string}.${string}` ? `${Parent}.${ParentStateIdentifier<Child>}` : never) : never;
+    /**
+     * Extracts the nearest parent state path from a state identifier.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type ImmediateParentStateIdentifier<StateId extends string> = StateId extends `${infer Head}.${infer Tail}` ? Tail extends `${string}.${string}` ? `${Head}.${ImmediateParentStateIdentifier<Tail>}` : Head : never;
     /**
      * Maps every parent state path of a state identifier to its decoded value.
      *
@@ -1037,6 +1480,13 @@ export declare namespace Machine {
     type ParentStateValues<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? {
         readonly [Parent in Extract<ParentStateIdentifier<StateId>, StateIdentifier<States>>]: StateByIdentifier<States, Parent>;
     } : never;
+    /**
+     * Extracts the nearest parent value, or `undefined` for a root state.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type ParentStateValue<States extends StateSchemas, StateId extends StateIdentifier<States>> = StateId extends StateIdentifier<States> ? Extract<ImmediateParentStateIdentifier<StateId>, StateIdentifier<States>> extends infer Parent ? [Parent] extends [never] ? undefined : Parent extends StateIdentifier<States> ? StateByIdentifier<States, Parent> : undefined : undefined : never;
     /**
      * Represents a decoded state value together with all of its parent values.
      *
@@ -1061,9 +1511,10 @@ export declare namespace Machine {
     type DirectFinalCompletionOutput<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeByIdentifier<States, StateId> extends {
         readonly type: "final";
     } ? OutputByIdentifier<States, StateId> : never;
-    type CompoundCompletionOutput<States extends StateSchemas, Children extends StateSchemas, Prefix extends StateIdentifier<States>> = UndefinedIfNever<{
-        readonly [Key in Extract<keyof Children, string>]: DirectFinalCompletionOutput<States, Extract<JoinPath<Prefix, Key>, StateIdentifier<States>>>;
-    }[Extract<keyof Children, string>]>;
+    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>> = {
+        readonly [Key in ActiveStateKey<Children>]: DirectFinalCompletionOutput<States, Extract<JoinPath<Prefix, Key>, StateIdentifier<States>>>;
+    }[ActiveStateKey<Children>];
     /**
      * Extracts the output passed when a state node completes.
      *
@@ -1077,6 +1528,52 @@ export declare namespace Machine {
     } ? CompoundCompletionOutput<States, Children, StateId> : Node extends {
         readonly type: "final";
     } ? OutputByIdentifier<States, StateId> : undefined : undefined;
+    /**
+     * Extracts the schema-derived union produced by structurally terminal root
+     * states.
+     *
+     * **Details**
+     *
+     * Unlike a planned step's optional `output`, active atomic roots do not add
+     * `undefined` to the union. Output-less final and parallel roots
+     * intentionally contribute `undefined`, because that is their completed
+     * value. Handler-driven reachability can make this structural union
+     * conservative; for example, a root `onDone` handler can transition away
+     * before that root becomes the machine's terminal result.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type TerminalOutput<States extends StateSchemas> = {
+        readonly [Key in Extract<keyof States, string>]: Extract<Key, StateIdentifier<States>> extends infer StateId extends StateIdentifier<States> ? NodeByIdentifier<States, StateId> extends infer Node ? Node extends {
+            readonly type: "parallel" | "final";
+        } ? OutputByIdentifier<States, StateId> : Node extends {
+            readonly states: infer Children extends StateSchemas;
+        } ? CompoundCompletionOutputRaw<States, Children, StateId> : never : never : never;
+    }[Extract<keyof States, string>];
+    /**
+     * Extracts every state path whose definition declares an output schema.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type DeclaredOutputState<States extends StateSchemas> = {
+        readonly [StateId in StateIdentifier<States>]: NodeByIdentifier<States, StateId> extends {
+            readonly output: Schema.Top;
+        } ? StateId : never;
+    }[StateIdentifier<States>] & StateIdentifier<States>;
+    /**
+     * Validates that every declared output schema has a matching handler
+     * implementation before a machine is planned or started.
+     *
+     * @category utility types
+     * @since 4.0.0
+     */
+    type EnsureOutputImplementations<States extends StateSchemas, OutputStates extends StateIdentifier<States>> = [
+        Exclude<DeclaredOutputState<States>, OutputStates>
+    ] extends [never] ? unknown : {
+        readonly "~effect/Machine/MissingOutputImplementation": Exclude<DeclaredOutputState<States>, OutputStates>;
+    };
     type OutputSchema<Node> = Node extends {
         readonly output: infer Output extends Schema.Top;
     } ? Output : never;
@@ -1119,6 +1616,12 @@ export declare namespace Machine {
         readonly path: string;
         readonly output?: unknown;
     }
+    /** Encoded values and paths retained by one history pseudo-state. */
+    interface EncodedSnapshotHistoryEntry {
+        readonly mode: "shallow" | "deep";
+        readonly active: ReadonlyArray<string>;
+        readonly values: Readonly<Record<string, unknown>>;
+    }
     /**
      * Normalized data representation of a machine snapshot.
      *
@@ -1135,6 +1638,7 @@ export declare namespace Machine {
         readonly _tag: "MachineSnapshot";
         readonly active: ReadonlyArray<EncodedSnapshotState>;
         readonly completed?: ReadonlyArray<EncodedSnapshotCompletion>;
+        readonly history?: Readonly<Record<string, EncodedSnapshotHistoryEntry>>;
     }
     /**
      * Completed state path and its resolved output value.
@@ -1146,6 +1650,12 @@ export declare namespace Machine {
         readonly path: string;
         readonly output: unknown;
     }
+    /** Decoded values and paths retained by one history pseudo-state. */
+    interface SnapshotHistoryEntry {
+        readonly mode: "shallow" | "deep";
+        readonly active: ReadonlyArray<string>;
+        readonly values: Readonly<Record<string, unknown>>;
+    }
     /**
      * Carries lifecycle metadata required to resume planning from a cloned
      * snapshot.
@@ -1164,6 +1674,7 @@ export declare namespace Machine {
      */
     interface SnapshotMetadata {
         readonly completed?: ReadonlyArray<SnapshotCompletion>;
+        readonly history?: Readonly<Record<string, SnapshotHistoryEntry>>;
     }
     /**
      * Atomic statechart snapshot carrying path identity separately from the
@@ -1220,8 +1731,8 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     type SnapshotWithPrefix<States extends StateSchemas, Prefix extends string> = {
-        readonly [Key in Extract<keyof States, string>]: SnapshotByIdentifierWithPath<States, Key, JoinPath<Prefix, Key>>;
-    }[Extract<keyof States, string>];
+        readonly [Key in ActiveStateKey<States>]: SnapshotByIdentifierWithPath<States, Key, JoinPath<Prefix, Key>>;
+    }[ActiveStateKey<States>];
     /**
      * Extracts child snapshots under a parallel parent path prefix, keyed by
      * child region.
@@ -1230,7 +1741,7 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     type SnapshotRegionsWithPrefix<States extends StateSchemas, Prefix extends string> = {
-        readonly [Key in Extract<keyof States, string>]: SnapshotByIdentifierWithPath<States, Key, JoinPath<Prefix, Key>>;
+        readonly [Key in ActiveStateKey<States>]: SnapshotByIdentifierWithPath<States, Key, JoinPath<Prefix, Key>>;
     };
     /**
      * Extracts a snapshot for a state node while preserving its full path.
@@ -1238,7 +1749,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 4.0.0
      */
-    type SnapshotByIdentifierWithPath<States extends StateSchemas, StateId extends Extract<keyof States, string>, Path extends string> = States[StateId] extends {
+    type SnapshotByIdentifierWithPath<States extends StateSchemas, StateId extends ActiveStateKey<States>, Path extends string> = States[StateId] extends {
         readonly type: "parallel";
         readonly states: infer Children;
     } ? Children extends StateSchemas ? ParallelSnapshot<Path, NodeSchema<States[StateId]>["Type"], SnapshotRegionsWithPrefix<Children, Path>> : AtomicSnapshot<Path, NodeSchema<States[StateId]>["Type"]> : States[StateId] extends {
@@ -1252,8 +1763,8 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     type Snapshot<States extends StateSchemas> = {
-        readonly [StateId in Extract<keyof States, string>]: SnapshotByIdentifier<States, StateId & StateIdentifier<States>>;
-    }[Extract<keyof States, string>];
+        readonly [StateId in ActiveStateKey<States>]: SnapshotByIdentifier<States, StateId & StateIdentifier<States>>;
+    }[ActiveStateKey<States>];
     /**
      * Extracts the root state identifier from a state path.
      *
@@ -1288,6 +1799,19 @@ export declare namespace Machine {
     type EventByTag<Events extends ReadonlyArray<TaggedSchema>, Tag extends TagOf<Events[number]>> = Extract<EventOf<Events>, {
         readonly _tag: Tag;
     }>;
+    /**
+     * Opaque state construction returned by a builder's `.from` method.
+     *
+     * The machine resolves the instruction through the selected state schema
+     * while planning. Its decoded value is intentionally unavailable until
+     * planning succeeds.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface StateConstruction<Result> {
+        readonly [Model.StateConstructionTypeId]: Result;
+    }
     /**
      * Machine-bound target instruction accepted from transition handlers.
      *
@@ -1296,12 +1820,30 @@ export declare namespace Machine {
      */
     interface Target<States extends StateSchemas, StateId extends StateIdentifier<States>> {
         readonly [Model.TargetTypeId]: typeof Model.TargetTypeId;
+        readonly [Model.TargetSnapshotTypeId]?: SnapshotByIdentifier<States, StateId>;
         readonly path: StateId;
         readonly value: StateByIdentifier<States, StateId>;
         readonly values?: Partial<{
             readonly [AncestorStateId in StateIdentifier<States>]: StateByIdentifier<States, AncestorStateId>;
         }>;
     }
+    /**
+     * Transition instruction that restores a history pseudo-state's parent.
+     *
+     * Unlike ordinary targets, history targets carry no state value. The
+     * planner resolves the remembered concrete configuration, or evaluates the
+     * history node's typed default when no record exists.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface HistoryTarget<States extends StateSchemas, HistoryId extends HistoryIdentifier<States>> {
+        readonly [Model.HistoryTargetTypeId]: typeof Model.HistoryTargetTypeId;
+        readonly path: HistoryId;
+        readonly parent: Extract<ParentPath<HistoryId>, StateIdentifier<States>>;
+    }
+    /** Builder containing only history pseudo-state paths. */
+    type HistoryTargetBuilder<States extends StateSchemas> = HistoryTargetBuilderWithPrefix<States, States, "">;
     /**
      * Builder for complete transition snapshots.
      *
@@ -1325,7 +1867,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 4.0.0
      */
-    type LocalTargetBuilder<States extends StateSchemas, Source extends StateIdentifier<States>> = NearestCompoundScope<States, Source> extends infer Scope ? [Scope] extends [never] ? {} : Scope extends StateIdentifier<States> ? LocalTargetBuilderForScope<States, Scope> : {} : {};
+    type LocalTargetBuilder<States extends StateSchemas, Source extends StateIdentifier<States>> = NearestCompoundScope<States, Source> extends infer Scope ? [Scope] extends [never] ? {} : Scope extends StateIdentifier<States> ? LocalTargetBuilderForScope<States, Scope, Source> : {} : {};
     /**
      * Builder for partial transition targets within the active source root.
      *
@@ -1337,7 +1879,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 4.0.0
      */
-    type BranchTargetBuilder<States extends StateSchemas, Source extends StateIdentifier<States>> = BranchTargetBuilderForRoot<States, Extract<RootStateIdentifier<Source>, Extract<keyof States, string>>>;
+    type BranchTargetBuilder<States extends StateSchemas, Source extends StateIdentifier<States>> = BranchTargetBuilderForRoot<States, Extract<RootStateIdentifier<Source>, ActiveStateKey<States>>, Source>;
     /**
      * Machine-bound target builders available in transition contexts.
      *
@@ -1347,6 +1889,13 @@ export declare namespace Machine {
      * targets descendants of the source root, and `full` builds complete
      * snapshots for any root.
      *
+     * These builders control how the next active configuration is assembled; they
+     * do not directly control state re-entry. Exit and entry paths are derived
+     * from the previous and next active paths. Shared active ancestors remain
+     * entered even when a `full` target supplies their values again. Use an event
+     * transition with `reenter: true` when the source should explicitly exit and
+     * enter again.
+     *
      * @category models
      * @since 4.0.0
      */
@@ -1379,15 +1928,22 @@ export declare namespace Machine {
          * @since 4.0.0
          */
         readonly full: FullTargetBuilder<States>;
+        /** Restores a declared shallow or deep history pseudo-state. */
+        readonly history: HistoryTargetBuilder<States>;
     }
     /**
      * Stages an Effect to run after the current machine step is planned.
      *
+     * The two-argument overload returns `next` after staging the Effect, which is
+     * useful when a handler should stage one action and return a target without
+     * introducing an Effect generator.
+     *
      * @category models
      * @since 4.0.0
      */
     interface Action {
         <E, R>(effect: Effect.Effect<void, E, R>): Effect.Effect<void, never, ActionRequirement<E, R>>;
+        <E, R, Next>(effect: Effect.Effect<void, E, R>, next: Next): Effect.Effect<Next, never, ActionRequirement<E, R>>;
     }
     /**
      * Planning capabilities shared by transition and lifecycle callbacks.
@@ -1396,7 +1952,6 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     interface PlanningCapabilities<Events, Emits> {
-        readonly action: Action;
         readonly raise: (event: Events) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError, Runtime.Requirement<Events, Emits>>;
         readonly emit: (event: Emits) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError, Runtime.Requirement<Events, Emits>>;
     }
@@ -1408,6 +1963,7 @@ export declare namespace Machine {
      */
     interface HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
         readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
         readonly event: EventByTag<Events, EventTag>;
         readonly runtime: RuntimeEffect<Events, Emits>;
@@ -1427,6 +1983,7 @@ export declare namespace Machine {
      */
     interface StateActionContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
         readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
         readonly runtime: RuntimeEffect<Events, Emits>;
@@ -1439,6 +1996,7 @@ export declare namespace Machine {
      */
     interface InvokeContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
         readonly runtime: RuntimeEffect<Events, Emits>;
@@ -1473,6 +2031,7 @@ export declare namespace Machine {
      */
     interface AlwaysContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
         readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
         readonly runtime: RuntimeEffect<Events, Emits>;
@@ -1493,6 +2052,7 @@ export declare namespace Machine {
      */
     interface DoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
         readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
         readonly output: CompletionOutputByIdentifier<States, StateId>;
@@ -1514,6 +2074,7 @@ export declare namespace Machine {
      */
     interface FinalOutputContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
     }
@@ -1527,7 +2088,7 @@ export declare namespace Machine {
         readonly type: "parallel";
         readonly states: infer Children extends StateSchemas;
     } ? {
-        readonly [Key in Extract<keyof Children, string>]: CompletionOutputByIdentifier<States, Extract<JoinPath<StateId, Key>, StateIdentifier<States>>>;
+        readonly [Key in ActiveStateKey<Children>]: CompletionOutputByIdentifier<States, Extract<JoinPath<StateId, Key>, StateIdentifier<States>>>;
     } : never;
     /**
      * Context passed to a parallel state output function.
@@ -1537,6 +2098,7 @@ export declare namespace Machine {
      */
     interface ParallelOutputContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> {
         readonly state: StateByIdentifier<States, StateId>;
+        readonly parent: ParentStateValue<States, StateId>;
         readonly parents: ParentStateValues<States, StateId>;
         readonly event: LifecycleEvent<Events>;
         readonly outputs: ParallelOutputRegions<States, StateId>;
@@ -1554,7 +2116,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 4.0.0
      */
-    type InitialResult<States extends StateSchemas, E, R> = Snapshot<States> | Effect.Effect<Snapshot<States>, E, R>;
+    type InitialResult<States extends StateSchemas, E, R> = Snapshot<States> | StateConstruction<Snapshot<States>> | Effect.Effect<Snapshot<States> | StateConstruction<Snapshot<States>>, E, R>;
     /**
      * Return value accepted from transition handlers.
      *
@@ -1567,7 +2129,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 4.0.0
      */
-    type HandlerResult<States extends StateSchemas, E, R> = Snapshot<States> | Target<States, StateIdentifier<States>> | void | Effect.Effect<Snapshot<States> | Target<States, StateIdentifier<States>> | void, E, R>;
+    type HandlerResult<States extends StateSchemas, E, R> = Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | StateConstruction<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>>> | void | Effect.Effect<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>> | StateConstruction<Snapshot<States> | Target<States, StateIdentifier<States>> | HistoryTarget<States, HistoryIdentifier<States>>> | void, E, R>;
     /**
      * Extracts the union of handler return values from a handler map.
      *
@@ -1603,6 +2165,18 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     type StateActionReturn<Config, Key extends "entry" | "exit"> = Key extends keyof Config ? NonNullable<Config[Key]> extends (...args: any) => infer Ret ? Ret : never : never;
+    /** Extracts the return value from an implicit initial child implementation. */
+    type StateInitialReturn<Config> = Config extends {
+        readonly initial?: infer Initial;
+    } ? NonNullable<Initial> extends (...args: any) => infer Ret ? Ret : never : never;
+    /** Extracts the return values from a state's history defaults. */
+    type HistoryDefaultReturn<Config> = Config extends {
+        readonly history?: infer History;
+    } ? {
+        readonly [Key in keyof NonNullable<History>]: NonNullable<History>[Key] extends {
+            readonly default: (...args: any) => infer Ret;
+        } ? Ret : never;
+    }[keyof NonNullable<History>] : never;
     /**
      * Extracts the return value from an event transition config.
      *
@@ -1754,16 +2328,7 @@ export declare namespace Machine {
      * @category utility types
      * @since 4.0.0
      */
-    type ConfigServices<Config> = Effect.Services<EventHandlerReturn<Config>> | Effect.Services<AlwaysReturn<Config>> | Effect.Services<DoneReturn<Config>> | Effect.Services<StateActionReturn<Config, "entry">> | Effect.Services<StateActionReturn<Config, "exit">> | InvokeRequirements<Config>;
-    /**
-     * Resolves the tag of a state config when it is final.
-     *
-     * @category utility types
-     * @since 4.0.0
-     */
-    type FinalStateFromConfig<Config, StateTag extends PropertyKey> = Config extends {
-        readonly type: "final";
-    } ? StateTag : never;
+    type ConfigServices<Config> = Effect.Services<EventHandlerReturn<Config>> | Effect.Services<AlwaysReturn<Config>> | Effect.Services<DoneReturn<Config>> | Effect.Services<StateActionReturn<Config, "entry">> | Effect.Services<StateActionReturn<Config, "exit">> | Effect.Services<StateInitialReturn<Config>> | Effect.Services<HistoryDefaultReturn<Config>> | InvokeRequirements<Config>;
     /**
      * Configuration for invoking a child process while a state is active.
      *
@@ -1780,10 +2345,17 @@ export declare namespace Machine {
             readonly initialError: Types.Covariant<ChildInitialError>;
         };
         readonly id: string;
+        /**
+         * Optional parent-local address for sending events to this invocation.
+         *
+         * The invocation `id` is only its state-local lifecycle key. Use an
+         * explicit typed address when the parent must communicate with it.
+         */
+        readonly address?: string;
         /** @internal */
-        readonly addressable?: boolean;
+        readonly descriptor?: ChildMachine.Any;
         src(): Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
-        snapshot?(context: InvokeSnapshotContext<ChildState, ChildError | ChildInitialError, ChildOutput>): Event | undefined;
+        snapshot?(context: InvokeSnapshotContext<ChildState, ChildError, ChildOutput>): Event | undefined;
         onDone?(context: InvokeDoneContext<ChildOutput>): DeliveredOutput | undefined;
     }
     /** @internal */
@@ -1797,6 +2369,9 @@ export declare namespace Machine {
             readonly initialError: Types.Covariant<InitialError>;
         };
     }
+    interface InvokeDefinitionValue {
+        readonly [InvokeTypeId]: unknown;
+    }
     /**
      * State-bound configuration for invoked child processes.
      *
@@ -1808,7 +2383,7 @@ export declare namespace Machine {
      * @category models
      * @since 4.0.0
      */
-    type InvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = AnyInvokeConfig<any, any, any, any, any, any> | ReadonlyArray<AnyInvokeConfig<any, any, any, any, any, any>> | ((context: InvokeContext<States, Events, Emits, StateId>) => AnyInvokeConfig<any, any, any, any, any, any> | ReadonlyArray<AnyInvokeConfig<any, any, any, any, any, any>>);
+    type InvokeDefinition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = InvokeDefinitionValue | ReadonlyArray<InvokeDefinitionValue> | ((context: InvokeContext<States, Events, Emits, StateId>) => InvokeDefinitionValue | ReadonlyArray<InvokeDefinitionValue>);
     type OutputHandlerConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Context> = NodeByIdentifier<States, StateId> extends {
         readonly output: Schema.Top;
     } ? {
@@ -1828,7 +2403,6 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     type ActiveStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R> = {
-        readonly type?: "active";
         readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<any, any>;
         readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<any, any>;
         readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>;
@@ -1840,7 +2414,37 @@ export declare namespace Machine {
                 readonly transition: (context: HandlerContext<States, Events, Emits, StateId, EventTag, E, R>) => HandlerResult<States, any, any>;
             };
         };
+        readonly initial?: StateInitialHandler<States, Events, Emits, StateId>;
     } & ActiveOutputHandlerConfig<States, Events, StateId>;
+    /** Values supplied when a statechart implicitly enters a state's initial children. */
+    type StateInitialValue<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeByIdentifier<States, StateId> extends infer Node ? Node extends {
+        readonly type: "parallel";
+        readonly states: infer Children extends StateSchemas;
+    } ? {
+        readonly [Key in ActiveStateKey<Children>]: NodeSchema<Children[Key]>["Type"];
+    } : Node extends {
+        readonly states: infer Children extends StateSchemas;
+        readonly initial: infer Initial;
+    } ? Initial extends ActiveStateKey<Children> ? NodeSchema<Children[Initial]>["Type"] : never : never : never;
+    /** Context passed to an implicit child-state initializer. */
+    type StateInitialContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = StateActionContext<States, Events, Emits, StateId>;
+    /** Initial child value implementation for a compound or parallel state. */
+    type StateInitialHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = (context: StateInitialContext<States, Events, Emits, StateId>) => StateInitialValue<States, StateId> | Effect.Effect<StateInitialValue<States, StateId>, any, any>;
+    /** Context used only when a history node has no previously captured record. */
+    interface HistoryDefaultContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>> extends PlanningCapabilities<EventOf<Events>, EmitOf<Emits>> {
+        readonly event: LifecycleEvent<Events>;
+        readonly runtime: RuntimeEffect<Events, Emits>;
+        readonly target: FullTargetBuilder<States>;
+        readonly parent: ParentId;
+    }
+    /** Typed fallback evaluated when a history node has no record yet. */
+    type HistoryDefaultHandler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>> = (context: HistoryDefaultContext<States, Events, Emits, ParentId>) => SnapshotByIdentifier<States, ParentId> | StateConstruction<SnapshotByIdentifier<States, ParentId>> | Effect.Effect<SnapshotByIdentifier<States, ParentId> | StateConstruction<SnapshotByIdentifier<States, ParentId>>, any, any>;
+    /** Default implementations keyed by direct history child. */
+    type HistoryDefaultConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ParentId extends StateIdentifier<States>, Children extends StateSchemas> = {
+        readonly [Key in HistoryStateKey<Children>]?: {
+            readonly default: HistoryDefaultHandler<States, Events, Emits, ParentId>;
+        };
+    };
     /**
      * Configuration accepted for a final state.
      *
@@ -1848,7 +2452,6 @@ export declare namespace Machine {
      * @since 4.0.0
      */
     type FinalStateConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>> = {
-        readonly type: "final";
         readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<any, any>;
         readonly exit?: never;
         readonly always?: never;
@@ -1861,7 +2464,9 @@ export declare namespace Machine {
      * @category models
      * @since 4.0.0
      */
-    type HandlerConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R> = ActiveStateConfig<States, Events, Emits, StateId, E, R> | FinalStateConfig<States, Events, Emits, StateId>;
+    type HandlerConfig<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, E, R> = NodeByIdentifier<States, StateId> extends {
+        readonly type: "final";
+    } ? FinalStateConfig<States, Events, Emits, StateId> : ActiveStateConfig<States, Events, Emits, StateId, E, R>;
     type HandlerChildren<Node> = Node extends {
         readonly states: infer Children extends StateSchemas;
     } ? Children : never;
@@ -1871,19 +2476,21 @@ export declare namespace Machine {
     };
     type HandlerNode<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, StateId extends StateIdentifier<AllStates>> = HandlerConfig<AllStates, Events, Emits, StateId, E, R> & (HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? {
         readonly states?: never;
+        readonly history?: never;
     } : {
         readonly states?: HandlerTree<AllStates, Children, Events, Emits, E, R, StateId>;
+        readonly history?: HistoryDefaultConfig<AllStates, Events, Emits, StateId, Children>;
     } : {
         readonly states?: never;
+        readonly history?: never;
     });
     type HandlerTree<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, E, R, Prefix extends string> = {
-        readonly [Key in Extract<keyof States, string>]?: HandlerNode<AllStates, States[Key], Events, Emits, E, R, HandlerStateId<AllStates, JoinPath<Prefix, Key>>>;
+        readonly [Key in ActiveStateKey<States>]?: HandlerNode<AllStates, States[Key], Events, Emits, E, R, HandlerStateId<AllStates, JoinPath<Prefix, Key>>>;
     };
-    type HandlerNodeConfigKey = "always" | "entry" | "exit" | "invoke" | "on" | "onDone" | "output" | "states" | "type";
-    type HandlerValidationError<Message extends string> = {
-        readonly "~effect/Machine/HandlerError": Message;
+    type HandlerNodeConfigKey = "always" | "entry" | "exit" | "history" | "initial" | "invoke" | "on" | "onDone" | "output" | "states";
+    type HandlerValidationError<Message extends string, Path extends string, Detail = unknown> = {
+        readonly "~effect/Machine/HandlerError": readonly [message: Message, path: Path, detail: Detail];
     };
-    type HandlerValidationErrors<Validation> = Validation extends HandlerValidationError<any> ? Validation : never;
     type NodeHasDeclaredOutput<States extends StateSchemas, StateId extends StateIdentifier<States>> = NodeByIdentifier<States, StateId> extends {
         readonly output: Schema.Top;
     } ? StateId : never;
@@ -1905,47 +2512,79 @@ 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 UnionToIntersection<Union> = (Union extends unknown ? (argument: Union) => void : never) extends (argument: infer Intersection) => void ? Intersection : never;
-    type HandlerUnknownStateKeyValidation<States extends StateSchemas, Config> = [Exclude<Extract<keyof Config, string>, Extract<keyof States, string>>] extends [never] ? unknown : HandlerValidationError<"Handler tree contains a state key that does not exist">;
-    type HandlerUnknownConfigKeyValidation<Config> = [
-        Exclude<Extract<keyof Config, string>, HandlerNodeConfigKey>
-    ] extends [never] ? unknown : HandlerValidationError<"Handler config contains an unknown key">;
-    type HandlerOnKeyValidation<Events extends ReadonlyArray<TaggedSchema>, Config> = Config extends {
-        readonly on?: infer On;
-    } ? [
-        Exclude<Extract<keyof NonNullable<On>, string>, TagOf<Events[number]>>
-    ] extends [never] ? unknown : HandlerValidationError<"Handler config contains an event key that does not exist"> : unknown;
+    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 : {
+        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 : {
+        readonly [Key in UnknownKeys]: HandlerValidationError<"Handler config contains an unknown key", StateId, Key>;
+    };
+    type HandlerOnKeyValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config, On = Config extends {
+        readonly on?: infer Current;
+    } ? NonNullable<Current> : never, UnknownKeys extends string = Exclude<Extract<keyof On, string>, TagOf<Events[number]>>> = "on" extends keyof Config ? [UnknownKeys] extends [never] ? unknown : {
+        readonly on: {
+            readonly [Key in UnknownKeys]: HandlerValidationError<"Handler config contains an event key that does not exist", StateId, Key>;
+        };
+    } : unknown;
     type HandlerDepth = readonly [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown];
     type HandlerNextDepth<Depth extends ReadonlyArray<unknown>> = Depth extends readonly [unknown, ...infer Rest extends ReadonlyArray<unknown>] ? Rest : readonly [];
-    type HandlerChildrenValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = "states" extends keyof Config ? Depth extends readonly [] ? HandlerValidationError<"Handler nesting exceeds the supported depth"> : Config extends {
+    type HandlerChildrenValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = "states" extends keyof Config ? Depth extends readonly [] ? {
+        readonly states: HandlerValidationError<"Handler nesting exceeds the supported depth", Prefix>;
+    } : Config extends {
         readonly states?: infer ChildrenConfig;
-    } ? HandlerChildren<Node> extends infer Children extends StateSchemas ? [
-        Children
-    ] extends [never] ? HandlerValidationError<"Handler config contains child states for a state that has no children"> : HandlerTreeValidation<AllStates, Children, Events, Prefix, NonNullable<ChildrenConfig>, AvailableOutputStates, HandlerNextDepth<Depth>> : HandlerValidationError<"Handler config contains child states for a state that has no children"> : unknown : unknown;
+    } ? HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? {
+        readonly states: HandlerValidationError<"Handler config contains child states for a state that has no children", Prefix>;
+    } : HandlerTreeValidation<AllStates, Children, Events, Emits, Prefix, NonNullable<ChildrenConfig>, AvailableOutputStates, HandlerNextDepth<Depth>> extends infer Validation ? unknown extends Validation ? unknown : {
+        readonly states: Validation;
+    } : never : {
+        readonly states: HandlerValidationError<"Handler config contains child states for a state that has no children", Prefix>;
+    } : unknown : unknown;
     type HandlerOutputRequirementValidation<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, AvailableOutputStates extends StateIdentifier<AllStates>, Config> = ("onDone" extends keyof Config ? [
         Exclude<RequiredCompletionOutputStates<AllStates, StateId>, AvailableOutputStates>
-    ] extends [never] ? unknown : HandlerValidationError<"Handler config is missing an output implementation required by onDone"> : unknown) & ("output" extends keyof Config ? NodeByIdentifier<AllStates, StateId> extends {
+    ] extends [never] ? unknown : {
+        readonly onDone: HandlerValidationError<"Handler config is missing an output implementation required by onDone", StateId, Exclude<RequiredCompletionOutputStates<AllStates, StateId>, AvailableOutputStates>>;
+    } : unknown) & ("output" extends keyof Config ? NodeByIdentifier<AllStates, StateId> extends {
         readonly type: "parallel";
     } ? [
         Exclude<RequiredParallelOutputStates<AllStates, StateId>, AvailableOutputStates>
-    ] extends [never] ? unknown : HandlerValidationError<"Handler config is missing a region output implementation required by parallel output"> : unknown : unknown);
-    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = HandlerUnknownConfigKeyValidation<Config> & HandlerOnKeyValidation<Events, Config> & HandlerInvokeOutputValidation<Events, Config> & HandlerInvokeEmitsValidation<Events, Config> & HandlerInvokeSnapshotValidation<Events, Config> & HandlerChildrenValidation<AllStates, Node, Events, StateId, Config, AvailableOutputStates, Depth> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config>;
-    type HandlerInvokeOutputValidation<Events extends ReadonlyArray<TaggedSchema>, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeOutput<InvokeReturn<Config>>, EventOf<Events> | void>] extends [never] ? unknown : HandlerValidationError<"Invoked child output must be a machine event or void">;
-    type HandlerInvokeEmitsValidation<Events extends ReadonlyArray<TaggedSchema>, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeEmits<InvokeReturn<Config>>, EventOf<Events>>] extends [never] ? unknown : HandlerValidationError<"Invoked child emits events not accepted by the parent machine">;
-    type HandlerInvokeSnapshotValidation<Events extends ReadonlyArray<TaggedSchema>, Config> = [InvokeReturn<Config>] extends [never] ? unknown : IsAny<InvokeSnapshotEvent<InvokeReturn<Config>>> extends true ? unknown : [Exclude<InvokeSnapshotEvent<InvokeReturn<Config>>, EventOf<Events> | undefined>] extends [never] ? unknown : HandlerValidationError<"Invoked child snapshot mapper must return a machine event or undefined">;
-    type HandlerTreeNodeValidationErrors<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = {
-        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: HandlerValidationErrors<HandlerNodeValidation<AllStates, States[Key], Events, HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], AvailableOutputStates, Depth>>;
-    }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
-    type HandlerTreeNodeValidations<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = HandlerTreeNodeValidationErrors<AllStates, States, Events, Prefix, Config, AvailableOutputStates, Depth> extends infer Errors ? [Errors] extends [never] ? unknown : UnionToIntersection<Errors> : never;
-    type HandlerTreeValidation<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown> = HandlerDepth> = HandlerUnknownStateKeyValidation<States, Config> & HandlerTreeNodeValidations<AllStates, States, Events, Prefix, Config, AvailableOutputStates, Depth>;
+    ] extends [never] ? unknown : {
+        readonly output: HandlerValidationError<"Handler config is missing a region output implementation required by parallel output", StateId, Exclude<RequiredParallelOutputStates<AllStates, StateId>, AvailableOutputStates>>;
+    } : unknown : unknown);
+    type HandlerNodeValidation<AllStates extends StateSchemas, Node, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<AllStates>, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = HandlerUnknownConfigKeyValidation<StateId, Config> & HandlerOnKeyValidation<Events, StateId, Config> & HandlerInvokeOutputValidation<Events, StateId, Config> & HandlerInvokeEmitsValidation<Events, StateId, Config> & HandlerInvokeSnapshotValidation<Events, StateId, Config> & HandlerChildrenValidation<AllStates, Node, Events, Emits, StateId, Config, AvailableOutputStates, Depth> & HandlerOutputRequirementValidation<AllStates, StateId, AvailableOutputStates, Config> & HandlerRuntimeValidation<Events, Emits, StateId, Config>;
+    type HandlerInvokeOutputValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeOutput<InvokeReturn<Config>>, EventOf<Events> | void>] extends [never] ? unknown : {
+        readonly invoke: HandlerValidationError<"Invoked child output must be a machine event or void", StateId, Exclude<InvokeOutput<InvokeReturn<Config>>, EventOf<Events> | void>>;
+    };
+    type HandlerInvokeEmitsValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : [Exclude<InvokeEmits<InvokeReturn<Config>>, EventOf<Events>>] extends [never] ? unknown : {
+        readonly invoke: HandlerValidationError<"Invoked child emits events not accepted by the parent machine", StateId, Exclude<InvokeEmits<InvokeReturn<Config>>, EventOf<Events>>>;
+    };
+    type HandlerInvokeSnapshotValidation<Events extends ReadonlyArray<TaggedSchema>, StateId extends string, Config> = [InvokeReturn<Config>] extends [never] ? unknown : IsAny<InvokeSnapshotEvent<InvokeReturn<Config>>> extends true ? unknown : [Exclude<InvokeSnapshotEvent<InvokeReturn<Config>>, EventOf<Events> | undefined>] extends [never] ? unknown : {
+        readonly invoke: HandlerValidationError<"Invoked child snapshot mapper must return a machine event or undefined", StateId, Exclude<InvokeSnapshotEvent<InvokeReturn<Config>>, EventOf<Events> | undefined>>;
+    };
+    type HandlerRuntimeValidation<Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends string, Config, Incompatible = IncompatibleRuntime<ConfigServices<HandlerConfigPart<Config>>, EventOf<Events>, EmitOf<Emits>>> = [Incompatible] extends [never] ? unknown : HandlerValidationError<"Handler config requires an incompatible machine runtime", StateId, Incompatible>;
+    type HandlerTreeNodeValidationMap<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = {
+        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]?: HandlerNodeValidation<AllStates, States[Key], Events, Emits, HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], AvailableOutputStates, Depth>;
+    };
+    type HandlerTreeNodeValidationErrors<Validations> = {
+        readonly [Key in keyof Validations as unknown extends Validations[Key] ? never : Key]?: Validations[Key];
+    };
+    type HandlerTreeNodeValidations<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown>> = HandlerTreeNodeValidationMap<AllStates, States, Events, Emits, Prefix, Config, AvailableOutputStates, Depth> extends infer Validations ? HandlerTreeNodeValidationErrors<Validations> extends infer Errors ? keyof Errors extends never ? unknown : Errors : never : never;
+    type HandlerTreeValidation<AllStates extends StateSchemas, States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Prefix extends string, Config, AvailableOutputStates extends StateIdentifier<AllStates>, Depth extends ReadonlyArray<unknown> = HandlerDepth> = HandlerUnknownStateKeyValidation<States, Prefix, Config> & HandlerTreeNodeValidations<AllStates, States, Events, Emits, Prefix, Config, AvailableOutputStates, Depth>;
     type HandlerNodeChildrenConfig<Config> = "states" extends keyof Config ? Config extends {
         readonly states?: infer Children;
     } ? NonNullable<Children> : never : never;
     type HandlerTreeStateIds<AllStates extends StateSchemas, States extends StateSchemas, Prefix extends string, Config, Depth extends ReadonlyArray<unknown> = HandlerDepth> = {
-        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: HandlerStateId<AllStates, JoinPath<Prefix, Key>> | HandlerNodeChildStateIds<AllStates, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
+        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: HandlerImplementedStateId<AllStates, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key]> | HandlerNodeChildStateIds<AllStates, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
     }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
+    type HandlerHasRequiredInitial<AllStates extends StateSchemas, StateId extends StateIdentifier<AllStates>, Config> = StateId extends RequiredHistoryInitializers<AllStates> ? "initial" extends keyof Config ? true : false : true;
+    type HandlerHasRequiredHistoryDefaults<Node, Config> = Node extends {
+        readonly states: infer Children extends StateSchemas;
+    } ? [HistoryStateKey<Children>] extends [never] ? true : Config extends {
+        readonly history?: infer HistoryConfig;
+    } ? [
+        Exclude<HistoryStateKey<Children>, Extract<keyof NonNullable<HistoryConfig>, string>>
+    ] extends [never] ? true : false : false : true;
+    type HandlerImplementedStateId<AllStates extends StateSchemas, Node, StateId extends StateIdentifier<AllStates>, Config> = [HistoryIdentifier<AllStates>] extends [never] ? StateId : HandlerHasRequiredInitial<AllStates, StateId, Config> extends true ? HandlerHasRequiredHistoryDefaults<Node, Config> extends true ? StateId : never : never;
     type HandlerNodeChildStateIds<AllStates extends StateSchemas, Node, Prefix extends string, Config, Depth extends ReadonlyArray<unknown>> = Depth extends readonly [] ? never : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? never : HandlerTreeStateIds<AllStates, Children, Prefix, HandlerNodeChildrenConfig<Config>, HandlerNextDepth<Depth>> : never;
-    type HandlerConfigError<Config> = Effect.Error<EventHandlerReturn<Config>> | Effect.Error<AlwaysReturn<Config>> | Effect.Error<DoneReturn<Config>> | Effect.Error<StateActionReturn<Config, "entry">> | Effect.Error<StateActionReturn<Config, "exit">> | InvokeError<Config>;
+    type HandlerConfigError<Config> = Effect.Error<EventHandlerReturn<Config>> | Effect.Error<AlwaysReturn<Config>> | Effect.Error<DoneReturn<Config>> | Effect.Error<StateActionReturn<Config, "entry">> | Effect.Error<StateActionReturn<Config, "exit">> | Effect.Error<StateInitialReturn<Config>> | Effect.Error<HistoryDefaultReturn<Config>> | InvokeError<Config>;
     type HandlerTreeError<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, States extends StateSchemas, Prefix extends string, Config, Depth extends ReadonlyArray<unknown> = HandlerDepth> = {
         readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: HandlerConfigError<HandlerConfigPart<Config[Key]>> | HandlerNodeChildError<AllStates, Events, Emits, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
     }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
@@ -1954,19 +2593,11 @@ export declare namespace Machine {
         readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: ConfigServices<HandlerConfigPart<Config[Key]>> | HandlerNodeChildServices<AllStates, Events, Emits, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
     }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
     type HandlerNodeChildServices<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Node, Prefix extends string, Config, Depth extends ReadonlyArray<unknown>> = Depth extends readonly [] ? never : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? never : HandlerTreeServices<AllStates, Events, Emits, Children, Prefix, HandlerNodeChildrenConfig<Config>, HandlerNextDepth<Depth>> : never;
-    type HandlerTreeFinalStates<AllStates extends StateSchemas, States extends StateSchemas, Prefix extends string, Config, Depth extends ReadonlyArray<unknown> = HandlerDepth> = {
-        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: Extract<FinalStateFromConfig<HandlerConfigPart<Config[Key]>, HandlerStateId<AllStates, JoinPath<Prefix, Key>>>, StateIdentifier<AllStates>> | HandlerNodeChildFinalStates<AllStates, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
-    }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
-    type HandlerNodeChildFinalStates<AllStates extends StateSchemas, Node, Prefix extends string, Config, Depth extends ReadonlyArray<unknown>> = Depth extends readonly [] ? never : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? never : HandlerTreeFinalStates<AllStates, Children, Prefix, HandlerNodeChildrenConfig<Config>, HandlerNextDepth<Depth>> : never;
-    type HandlerTreeOutput<AllStates extends StateSchemas, States extends StateSchemas, Prefix extends string, Config, Depth extends ReadonlyArray<unknown> = HandlerDepth> = {
-        readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: ("output" extends keyof HandlerConfigPart<Config[Key]> ? OutputByIdentifier<AllStates, HandlerStateId<AllStates, JoinPath<Prefix, Key>>> : never) | HandlerNodeChildOutput<AllStates, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
-    }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
-    type HandlerNodeChildOutput<AllStates extends StateSchemas, Node, Prefix extends string, Config, Depth extends ReadonlyArray<unknown>> = Depth extends readonly [] ? never : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? never : HandlerTreeOutput<AllStates, Children, Prefix, HandlerNodeChildrenConfig<Config>, HandlerNextDepth<Depth>> : never;
     type HandlerTreeOutputStates<AllStates extends StateSchemas, States extends StateSchemas, Prefix extends string, Config, Depth extends ReadonlyArray<unknown> = HandlerDepth> = {
         readonly [Key in Extract<Extract<keyof Config, string>, Extract<keyof States, string>>]: HandlerOutputStates<AllStates, HandlerStateId<AllStates, JoinPath<Prefix, Key>>, HandlerConfigPart<Config[Key]>> | HandlerNodeChildOutputStates<AllStates, States[Key], HandlerStateId<AllStates, JoinPath<Prefix, Key>>, Config[Key], Depth>;
     }[Extract<Extract<keyof Config, string>, Extract<keyof States, string>>];
     type HandlerNodeChildOutputStates<AllStates extends StateSchemas, Node, Prefix extends string, Config, Depth extends ReadonlyArray<unknown>> = Depth extends readonly [] ? never : HandlerChildren<Node> extends infer Children extends StateSchemas ? [Children] extends [never] ? never : HandlerTreeOutputStates<AllStates, Children, Prefix, HandlerNodeChildrenConfig<Config>, HandlerNextDepth<Depth>> : never;
-    type HandleTreeResult<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<AllStates>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<AllStates>, Output, OutputStates extends StateIdentifier<AllStates>, Config> = Machine<AllStates, Events, Input, Exclude<UnhandledStates, HandlerTreeStateIds<AllStates, AllStates, "", Config>>, E | HandlerTreeError<AllStates, Events, Emits, AllStates, "", Config>, ExcludeCompatibleRuntime<R | HandlerTreeServices<AllStates, Events, Emits, AllStates, "", Config>, EventOf<Events>, EmitOf<Emits>>, InitialE, InitialR, FinalStates | Extract<HandlerTreeFinalStates<AllStates, AllStates, "", Config>, StateIdentifier<AllStates>>, Output | HandlerTreeOutput<AllStates, AllStates, "", Config>, Emits, OutputStates | Extract<HandlerTreeOutputStates<AllStates, AllStates, "", Config>, StateIdentifier<AllStates>>>;
+    type HandleTreeResult<AllStates extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<AllStates>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<AllStates>, Output, OutputStates extends StateIdentifier<AllStates>, InputEvents extends ReadonlyArray<TaggedSchema>, Config> = Machine<AllStates, Events, Input, Exclude<UnhandledStates, HandlerTreeStateIds<AllStates, AllStates, "", Config>>, E | HandlerTreeError<AllStates, Events, Emits, AllStates, "", Config>, ExcludeCompatibleRuntime<R | HandlerTreeServices<AllStates, Events, Emits, AllStates, "", Config>, EventOf<Events>, EmitOf<Emits>>, InitialE, InitialR, FinalStates, Output, Emits, OutputStates | Extract<HandlerTreeOutputStates<AllStates, AllStates, "", Config>, StateIdentifier<AllStates>>, InputEvents>;
     /**
      * Adds state handlers from a root state object.
      *
@@ -1979,8 +2610,8 @@ export declare namespace Machine {
      * @category combinators
      * @since 4.0.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>> {
-        <const Config extends HandlerTree<States, States, Events, Emits, E, R, "">>(config: Config & HandlerTreeValidation<States, States, Events, "", Config, OutputStates | Extract<HandlerTreeOutputStates<States, States, "", Config>, StateIdentifier<States>>> & EnsureCompatibleRuntime<HandlerTreeServices<States, Events, Emits, States, "", Config>, EventOf<Events>, EmitOf<Emits>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, Config>;
+    interface Handler<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, Input extends Schema.Top, UnhandledStates extends StateIdentifier<States>, E, R, InitialE, InitialR, FinalStates extends StateIdentifier<States>, Output, OutputStates extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema>> {
+        <const Config extends HandlerTree<States, States, Events, Emits, E, R, "">>(config: Config & HandlerTreeValidation<States, States, Events, Emits, "", NoInfer<Config>, OutputStates | Extract<HandlerTreeOutputStates<States, States, "", NoInfer<Config>>, StateIdentifier<States>>>): HandleTreeResult<States, Events, Emits, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, OutputStates, InputEvents, Config>;
     }
     /**
      * Any state config.
@@ -2006,13 +2637,12 @@ export declare namespace Machine {
      * @since 4.0.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 type?: "final" | "active";
         readonly entry?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<E, R>;
         readonly exit?: (context: StateActionContext<States, Events, Emits, StateId>) => StateActionResult<E, R>;
         readonly invoke?: InvokeDefinition<States, Events, Emits, StateId>;
         readonly always?: (context: AlwaysContext<States, Events, Emits, StateId>) => HandlerResult<States, E, R>;
         readonly onDone?: (context: DoneContext<States, Events, Emits, StateId>) => HandlerResult<States, E, R>;
-        readonly output?: ((context: FinalOutputContext<States, Events, StateId>) => any) | ((context: ParallelOutputContext<States, Events, StateId>) => any);
+        readonly output?: ((context: FinalOutputContext<States, Events, StateId>) => unknown) | ((context: ParallelOutputContext<States, Events, StateId>) => unknown);
         readonly on?: EventHandlerMap<States, Events, Emits, StateId, EventTag, E, R>;
     }
     /**
@@ -2036,7 +2666,7 @@ export declare const isMachine: (u: unknown) => u is Machine.Any;
  * @category guards
  * @since 4.0.0
  */
-export declare const isFinal: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates>, state: Machine.Snapshot<States>) => state is Machine.SnapshotContainingFinal<States, FinalStates>;
+export declare const isFinal: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, state: Machine.Snapshot<States>) => state is Machine.SnapshotContainingFinal<States, FinalStates>;
 /**
  * Defines a state tree while preserving literal state paths.
  *
@@ -2055,7 +2685,7 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  *
  * ```ts
  * import { Schema } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class Idle extends Schema.TaggedClass<Idle>("Idle")("Idle", {}) {}
  *
@@ -2064,14 +2694,30 @@ export declare const isFinal: <const States extends Machine.StateSchemas, const
  * Machine.make({
  *   states: States.states,
  *   events: [],
- *   initial: () => States.initial.idle(new Idle({}))
+ *   initial: () => States.initial.idle.from()
  * })
  * ```
  *
  * @category constructors
  * @since 4.0.0
  */
-export declare const defineStates: <const States extends Machine.StateSchemas>(states: States & DefineStateTreeInput<NoInfer<States>>, ..._validation: ValidateDefinedStates<NoInfer<States>>) => Machine.DefinedStates<States>;
+export declare const defineStates: DefineStates;
+type MakeConfig<States extends Machine.StateSchemas, InputEvents extends ReadonlyArray<Machine.TaggedSchema>, Emits extends ReadonlyArray<Machine.TaggedSchema>, Input extends Schema.Top, InitialE, InitialR, InternalEvents extends ReadonlyArray<Machine.TaggedSchema>> = {
+    readonly id?: string;
+    readonly states: States & DefineStateTreeInput<NoInfer<States>>;
+    readonly events: InputEvents & ValidateInputEventProtocol<NoInfer<InputEvents>>;
+    readonly internalEvents?: InternalEvents & ValidateInternalEventProtocol<NoInfer<InputEvents>, NoInfer<InternalEvents>>;
+    readonly emits?: Emits;
+    readonly input?: Input;
+    readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>;
+};
+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>> = Machine<States, readonly [...InputEvents, ...InternalEvents], Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, Machine.TerminalOutput<States>, Emits, never, InputEvents>;
+interface Make {
+    <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 []>(config: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>, ..._validation: ValidateDefinedStates<NoInfer<States>>): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>;
+    <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 []>(config: Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>, "states"> & {
+        readonly states: InvalidDefinedStateTreeInput<States>;
+    }): never;
+}
 /**
  * Creates a schema-first machine definition.
  *
@@ -2083,11 +2729,16 @@ export declare const defineStates: <const States extends Machine.StateSchemas>(s
  * `defineStates` or is passed inline. Call `handle` on the returned definition
  * to implement state behavior with ordinary TypeScript control flow.
  *
+ * Schemas in `events` define the public input protocol. Schemas in
+ * `internalEvents` are added to the complete handler protocol for invoke
+ * results, child emissions, and other machine-local deliveries. Their tags
+ * must be disjoint.
+ *
  * **Example** (Typed counter machine)
  *
  * ```ts
  * import { Schema } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class Count extends Schema.TaggedClass<Count>("Count")("Count", {
  *   value: Schema.Number
@@ -2117,14 +2768,7 @@ export declare const defineStates: <const States extends Machine.StateSchemas>(s
  * @category constructors
  * @since 4.0.0
  */
-export declare const make: <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, InitialE = never, InitialR = never>(config: {
-    readonly id?: string;
-    readonly states: States & DefineStateTreeInput<NoInfer<States>>;
-    readonly events: Events;
-    readonly emits?: Emits;
-    readonly input?: Input;
-    readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>;
-}, ..._validation: ValidateDefinedStates<NoInfer<States>>) => Machine<States, Events, Input, Machine.StateIdentifier<States>, never, never, InitialE, InitialR, Machine.FinalStateFromDefinition<States>, never, Emits>;
+export declare const make: Make;
 /**
  * Encodes a decoded machine snapshot into a normalized data representation.
  *
@@ -2152,7 +2796,7 @@ export declare const make: <const States extends Machine.StateSchemas, const Eve
  * @category encoding
  * @since 4.0.0
  */
-export declare const encodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>, snapshot: Machine.Snapshot<States>) => Effect.Effect<Machine.EncodedSnapshot, MachineSchemaEncodeError, Machine.SnapshotEncodingServices<States>>;
+export declare const encodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, snapshot: Machine.Snapshot<States>) => Effect.Effect<Machine.EncodedSnapshot, MachineSchemaEncodeError, Machine.SnapshotEncodingServices<States>>;
 /**
  * Decodes a normalized data representation into a validated machine snapshot.
  *
@@ -2176,7 +2820,7 @@ export declare const encodeSnapshot: <const States extends Machine.StateSchemas,
  * @category decoding
  * @since 4.0.0
  */
-export declare const decodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>;
+export declare const decodeSnapshot: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, encoded: unknown) => Effect.Effect<Machine.Snapshot<States>, MachineSchemaDecodeError, Machine.SnapshotDecodingServices<States>>;
 /**
  * Creates an invoked child process configuration for an active state.
  *
@@ -2192,6 +2836,8 @@ export declare const decodeSnapshot: <const States extends Machine.StateSchemas,
  * Invoked child processes run while their owning state is active and are
  * stopped before the state exits. An unrecovered child failure fails the owning
  * machine; recover inside the child Effect when failure should become an event.
+ * The `id` is a state-local lifecycle key, not a communication address. To
+ * send events to the invocation, pass a typed `childAddress` as `address`.
  * The `src` callback is intentionally independent from its parent state. When
  * construction depends on the typed state, lifecycle event, or runtime, use
  * the state config factory form `invoke: (context) => Machine.invoke(...)` and
@@ -2201,7 +2847,7 @@ export declare const decodeSnapshot: <const States extends Machine.StateSchemas,
  *
  * ```ts
  * import { Effect, Schema } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class Loaded extends Schema.TaggedClass<Loaded>("Loaded")("Loaded", {
  *   value: Schema.String
@@ -2218,11 +2864,94 @@ export declare const decodeSnapshot: <const States extends Machine.StateSchemas,
  * @category constructors
  * @since 4.0.0
  */
-export declare const invoke: <ChildState, ChildEvent, ChildError = never, ChildRequirements = never, ChildOutput = never, ChildInitialError = never, Event = never, Id extends string = string>(config: {
-    readonly id: Id;
+export declare const invoke: <ChildState, ChildEvent, ChildError = never, ChildRequirements = never, ChildOutput = never, ChildInitialError = never, Event = never, Address extends ChildAddress<never> | undefined = undefined>(config: {
+    readonly id: InvokeLifecycleId;
     readonly src: () => Logic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
-    readonly snapshot?: (context: Machine.InvokeSnapshotContext<ChildState, ChildError | ChildInitialError, ChildOutput>) => Event | undefined;
-} & ChildAddress.Compatibility<Id, ChildEvent>) => Machine.InvokeConfig<any, any, any, any, Event, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
+    readonly snapshot?: (context: Machine.InvokeSnapshotContext<ChildState, ChildError, ChildOutput>) => Event | undefined;
+} & ([Address] extends [undefined] ? {
+    readonly address?: never;
+} : {
+    readonly address: Exclude<Address, undefined>;
+} & ChildAddress.Compatibility<Exclude<Address, undefined>, NoInfer<ChildEvent>>)) => Machine.InvokeConfig<any, any, any, any, Event, ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>;
+type InvokeEffectResult<Requirements, Event> = Machine.InvokeConfig<any, any, any, any, never, void, never, never, Requirements, Event | void, never>;
+type InvokeEffectIsInfallible<Fx extends Effect.Effect<any, any, any>> = IsAny<Effect.Error<Fx>> extends true ? false : [Effect.Error<Fx>] extends [never] ? true : false;
+type InvokeEffectConfig<Fx extends Effect.Effect<any, any, any>, SuccessEvent, FailureEvent> = {
+    readonly id: InvokeLifecycleId;
+    readonly effect: Fx;
+    readonly onSuccess: (value: NoInfer<Effect.Success<Fx>>) => SuccessEvent | void;
+} & (InvokeEffectIsInfallible<Fx> extends true ? {
+    readonly onFailure?: never;
+} : {
+    readonly onFailure: (error: NoInfer<Effect.Error<Fx>>) => FailureEvent | void;
+});
+/**
+ * Invokes one Effect and maps its typed outcome into machine-local events.
+ *
+ * **Details**
+ *
+ * This is the high-level one-shot counterpart to `invoke`. Success and typed
+ * failure values are mapped independently, so callers do not need to recover
+ * an Effect into a common event union by hand. Defects and interruption remain
+ * failures of the owning machine.
+ *
+ * Declare mapped outcomes in `internalEvents` unless they are also legitimate
+ * public commands.
+ *
+ * @see {@link invoke} for arbitrary child process logic.
+ * @see {@link after} for a state-scoped delayed event.
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const invokeEffect: <const Fx extends Effect.Effect<any, any, any>, SuccessEvent, FailureEvent = never>(config: InvokeEffectConfig<Fx, SuccessEvent, FailureEvent>) => InvokeEffectResult<Effect.Services<Fx>, SuccessEvent | (InvokeEffectIsInfallible<Fx> extends true ? never : FailureEvent)>;
+/**
+ * Creates a cancellable state-scoped delayed event.
+ *
+ * The timer starts when its owning state is entered and is interrupted when
+ * that state exits. The delayed value should normally be declared in
+ * `internalEvents`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const after: <Event extends {
+    readonly _tag: PropertyKey;
+}>(duration: Duration.Input, event: Event, options?: {
+    readonly id?: InvokeLifecycleId;
+}) => InvokeEffectResult<never, Event>;
+type RetagFields<Target extends Machine.TaggedSchema> = Omit<Target["~type.make.in"], "_tag">;
+type RetagTargetCompatibility<Target extends Machine.TaggedSchema> = Target extends {
+    readonly fields: Schema.Struct.Fields;
+} ? "_tag" extends keyof Target["~type.make.in"] ? {} extends Pick<Target["~type.make.in"], "_tag"> ? unknown : {
+    readonly "~effect/Machine/RetagTargetError": "Target schema must supply its discriminator when make is called";
+} : unknown : {
+    readonly "~effect/Machine/RetagTargetError": "Target schema must be one tagged struct or tagged class";
+};
+type RequiredKeys<A> = {
+    readonly [Key in keyof A]-?: {} extends Pick<A, Key> ? never : Key;
+}[keyof A];
+type CompatibleSourceKeys<Fields, Source> = {
+    readonly [Key in Extract<keyof Fields, keyof Source>]: Source[Key] extends Fields[Key] ? Key : never;
+}[Extract<keyof Fields, keyof Source>];
+type RetagPatch<Target extends Machine.TaggedSchema, Source> = Partial<RetagFields<Target>> & Pick<RetagFields<Target>, Exclude<RequiredKeys<RetagFields<Target>>, CompatibleSourceKeys<RetagFields<Target>, Source>>>;
+type RetagArgs<Target extends Machine.TaggedSchema, Source> = [
+    Exclude<RequiredKeys<RetagFields<Target>>, CompatibleSourceKeys<RetagFields<Target>, Source>>
+] extends [never] ? [patch?: RetagPatch<Target, Source>] : [patch: RetagPatch<Target, Source>];
+/**
+ * Constructs another tagged case from compatible source fields.
+ *
+ * The target must be one tagged struct or tagged class whose discriminator is
+ * supplied by its constructor. Union wrappers are rejected because their
+ * `make` operation cannot select a member after the source discriminator has
+ * been discarded. Missing or incompatible required target fields must be
+ * supplied by the patch, and the target schema's normal `make` validation
+ * remains authoritative at runtime.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const retag: <const Target extends Machine.TaggedSchema, const Source extends {
+    readonly _tag: PropertyKey;
+}>(target: Target & RetagTargetCompatibility<Target>, source: Source, ...args: RetagArgs<Target, Source>) => Target["Type"];
 type InvokeMachineInput<Input extends Schema.Top> = Input extends typeof Schema.Void ? {
     readonly input?: never;
 } : {
@@ -2254,16 +2983,16 @@ type InvokeMachineInput<Input extends Schema.Top> = Input extends typeof Schema.
  * @since 4.0.0
  */
 export declare const invokeMachine: {
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, SnapshotEvent = never, DoneEvent = never, Id extends string = string>(config: {
-        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>>;
-        readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | InitialE | ActionError<R | InitialR> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Output | undefined>) => SnapshotEvent | undefined;
-        readonly onDone: (context: Machine.InvokeDoneContext<Output | undefined>) => DoneEvent | undefined;
-    } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<Events>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output | undefined, InitialE | ActionError<InitialR | R> | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>, DoneEvent>;
-    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, SnapshotEvent = never, Id extends string = string>(config: {
-        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>>;
-        readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | InitialE | ActionError<R | InitialR> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Output | undefined>) => SnapshotEvent | undefined;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, SnapshotEvent = never, DoneEvent = never, Id extends string = string, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(config: {
+        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>>;
+        readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
+        readonly onDone: (context: Machine.InvokeDoneContext<Output>) => DoneEvent | undefined;
+    } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>, DoneEvent>;
+    <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, SnapshotEvent = never, Id extends string = string, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(config: {
+        readonly child: ChildMachine<Id, Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>>;
+        readonly snapshot?: (context: Machine.InvokeSnapshotContext<Machine.Snapshot<States>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>) => SnapshotEvent | undefined;
         readonly onDone?: never;
-    } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<Events>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output | undefined, InitialE | ActionError<InitialR | R> | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>>;
+    } & InvokeMachineInput<Input>): Machine.InvokeConfig<any, any, any, any, SnapshotEvent, Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, ExcludeCompatibleRuntime<Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>, Output, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Machine.EmitOf<Emits>>;
 };
 /**
  * Plans the initial state for a machine without running deferred actions.
@@ -2286,19 +3015,24 @@ export declare const invokeMachine: {
  * @category constructors
  * @since 4.0.0
  */
-export declare const planInitial: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<{
+export declare const planInitial: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<{
     readonly state: Machine.Snapshot<States>;
     readonly actions: ReadonlyArray<Effect.Effect<void, ActionError<InitialR | R>, ActionServices<InitialR | R>>>;
     readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
-    readonly output: Output | undefined;
-}, InitialE | MachineSchemaDecodeError | StartupError, ExcludeCompatibleRuntime<PlanningServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+} & ({
+    readonly done: true;
+    readonly output: Output;
+} | {
+    readonly done: false;
+    readonly output: undefined;
+}), InitialE | E | InfiniteTransitionError | MachineSchemaDecodeError | StartupError, ExcludeCompatibleRuntime<PlanningServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
 /**
  * Returns the event tags handled by the current state snapshot.
  *
  * @category getters
  * @since 4.0.0
  */
-export declare const enabled: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates>, state: Machine.Snapshot<States>) => ReadonlyArray<Machine.TagOf<Events[number]>>;
+export declare const enabled: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents>, state: Machine.Snapshot<States>) => ReadonlyArray<Machine.TagOf<Events[number]>>;
 /**
  * Plans the next state snapshot without running deferred actions.
  *
@@ -2322,7 +3056,7 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  * @category combinators
  * @since 4.0.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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>, state: Machine.Snapshot<States>, event: Machine.EventOf<Events>) => Effect.Effect<{
+export declare const plan: <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [], const Input extends Schema.Top = typeof Schema.Void, UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>, E = never, R = never, InitialE = never, InitialR = never, FinalStates extends Machine.StateIdentifier<States> = never, Output = never, OutputStates extends Machine.StateIdentifier<States> = never, InputEvents extends ReadonlyArray<Machine.TaggedSchema> = Events>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>, state: Machine.Snapshot<States>, event: Machine.EventOf<InputEvents>) => Effect.Effect<{
     readonly next: Machine.Snapshot<States>;
     readonly actions: ReadonlyArray<Effect.Effect<void, ActionError<R>, ActionServices<R>>>;
     readonly emittedEvents: ReadonlyArray<Machine.EmitOf<Emits>>;
@@ -2336,8 +3070,13 @@ export declare const plan: <const States extends Machine.StateSchemas, const Eve
         readonly entryPaths: ReadonlyArray<string>;
         readonly changed: boolean;
     }>;
-    readonly output: Output | undefined;
-}, E | InfiniteTransitionError | MachineSchemaDecodeError, ExcludeCompatibleRuntime<PlanningServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
+} & ({
+    readonly done: true;
+    readonly output: Output;
+} | {
+    readonly done: false;
+    readonly output: undefined;
+}), E | InfiniteTransitionError | MachineSchemaDecodeError, ExcludeCompatibleRuntime<PlanningServices<R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
 /**
  * Defers an effectful action until the current machine step is planned.
  *
@@ -2346,13 +3085,14 @@ export declare const plan: <const States extends Machine.StateSchemas, const Eve
  * The action's error and service requirements are retained in the machine
  * type without becoming requirements of `plan` or `planInitial`. The managed
  * runtime executes staged actions sequentially before publishing the planned
- * state.
+ * state. Pass a second argument when the planning Effect should return that
+ * value after staging.
  *
  * **Example** (Typed staged action)
  *
  * ```ts
  * import { Context, Effect } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class Audit extends Context.Service<Audit, {
  *   readonly write: Effect.Effect<void, "AuditError">
@@ -2367,7 +3107,7 @@ export declare const plan: <const States extends Machine.StateSchemas, const Eve
  * @category combinators
  * @since 4.0.0
  */
-export declare const action: <E, R>(effect: Effect.Effect<void, E, R>) => Effect.Effect<void, never, ActionRequirement<E, R>>;
+export declare const action: Machine.Action;
 /**
  * Runs staged machine actions sequentially with the supplied runtime.
  *
@@ -2421,7 +3161,7 @@ export declare const runtime: <const Protocol extends Runtime.Protocol = {}>() =
  *
  * ```ts
  * import { Effect, Schema } from "effect"
- * import { Machine } from "effect/unstable/machine"
+ * import { Machine } from "@typeonce/effect-machine"
  *
  * class LoadFailed extends Schema.TaggedClass<LoadFailed>("LoadFailed")("LoadFailed", {
  *   reason: Schema.String
@@ -2468,7 +3208,7 @@ export declare const effect: <Output, Error = never, Requirements = never>(effec
  * @category constructors
  * @since 4.0.0
  */
-export declare const logic: <State, Event = any, Output = void, Error = never, Requirements = never, InitialError = never, InitialRequirements = never>(options: {
+export declare const logic: <State, Event = never, Output = void, Error = never, Requirements = never, InitialError = never, InitialRequirements = never>(options: {
     readonly initial: State | ((scope: Logic.Scope<Event>) => Effect.Effect<State, InitialError, InitialRequirements>);
     readonly run: (context: Logic.Context<State, Event>) => Effect.Effect<Output, Error, Requirements>;
 }) => Logic<State, Event, Error, Requirements | InitialRequirements, Output, InitialError>;
@@ -2492,21 +3232,25 @@ export declare const logic: <State, Event = any, Output = void, Error = never, R
  */
 export declare const transition: <State, Event, Error = never, Requirements = never>(initial: State, transition: (state: State, event: Event) => Effect.Effect<State, Error, Requirements>) => Logic<State, Event, Error, Requirements, never>;
 /**
- * Creates a typed parent-local child address or complete machine descriptor.
+ * Creates a typed descriptor for a complete child machine.
  *
- * **When to use**
+ * Descriptors identify a child by id and machine identity, so independently
+ * constructed descriptors for the same pair address the same invoked child.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const child: <const Id extends string, M extends Machine.Any>(id: Id, machine: M) => ChildMachine<Id, M>;
+/**
+ * Creates a typed parent-local address for lower-level child process logic.
  *
- * Use with a complete machine to create the descriptor shared by
- * `invokeMachine`, `sendTo`, and child lookup APIs. The one-argument form
- * creates an event-only address for lower-level process logic.
+ * The default event protocol is `never`; provide an event type before using
+ * the address with `spawn`, `invoke`, or `sendTo`.
  *
  * @category constructors
  * @since 4.0.0
  */
-export declare const child: {
-    <const Id extends string, M extends Machine.Any>(id: Id, machine: M): ChildMachine<Id, M>;
-    <Event>(id: string): ChildAddress<Event>;
-};
+export declare const childAddress: <Event = never>(id: string) => ChildAddress<Event>;
 /**
  * Spawns a child process owned by the currently running machine.
  *
@@ -2539,7 +3283,7 @@ export declare const spawn: {
  */
 export declare const sendTo: {
     <Child extends ChildMachine.Any>(child: Child, event: ChildMachine.Event<Child>): Effect.Effect<void, StoppedError, MachineRuntimeRequirement>;
-    <Address extends string>(id: Address, event: ChildAddress.Event<Address>): Effect.Effect<void, StoppedError, MachineRuntimeRequirement>;
+    <Address extends ChildAddress<never>>(id: Address, event: ChildAddress.Event<Address>): Effect.Effect<void, StoppedError, MachineRuntimeRequirement>;
 };
 /**
  * Stops a named child process of the running machine.
@@ -2547,7 +3291,10 @@ export declare const sendTo: {
  * @category runtime
  * @since 4.0.0
  */
-export declare const stopChild: (child: string | ChildMachine.Any) => Effect.Effect<void, never, MachineRuntimeRequirement>;
+export declare const stopChild: {
+    <Event>(child: ChildAddress<Event>): Effect.Effect<void, never, MachineRuntimeRequirement>;
+    <Child extends ChildMachine.Any>(child: Child): Effect.Effect<void, never, MachineRuntimeRequirement>;
+};
 /**
  * Returns a stream of terminal lifecycle outcomes for a running machine.
  *
@@ -2583,5 +3330,5 @@ export declare const watch: <State, Event, Error = never, Output = never>(ref: M
  * @category constructors
  * @since 4.0.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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<Events>, E | InitialE | ActionError<R | InitialR> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, Output | undefined>, InitialE | ActionError<InitialR | R> | 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>(machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits, OutputStates, InputEvents> & Machine.EnsureOutputImplementations<States, OutputStates> & Machine.EnsureHistoryImplementations<States, UnhandledStates>, ...args: [...Machine.InputArgs<Input>]) => Effect.Effect<MachineRef<Machine.Snapshot<States>, Machine.EventOf<InputEvents>, E | ActionError<R> | InfiniteTransitionError | MachineSchemaDecodeError | StoppedError, Output>, InitialE | E | ActionError<InitialR | R> | InfiniteTransitionError | MachineSchemaDecodeError | StartupError | StoppedError, ExcludeCompatibleRuntime<ExecutionServices<InitialR | R>, Machine.EventOf<Events>, Machine.EmitOf<Emits>>>;
 //# sourceMappingURL=Machine.d.ts.map