@typeonce/effect-machine 0.32.0 → 0.33.0

package/README.md

@@ -411,8 +411,9 @@ selecting a destination. Concrete destinations stay narrowed inside their
 resolver, and `to.branches({...})` gives the resolver only the declared named
 `select` builders. Builders describe the
 next logical configuration. Shared states exit and enter only when paths
-change; call `.reenter()` for resolver-free reentry or pass `{ reenter: true }`
-to `.resolve(...)` when the source must restart. With `to.none`, reentry
+change; call `.reenter()` before `.from(...)`, `.decoded(...)`, or `.resolve(...)`
+when the source must restart. Default-constructible targets can finish at
+`.reenter()`. With `to.none`, reentry
 restarts the source while retaining its configuration.
 
 Topology-only definition instructions are values: `to.none`, declared
@@ -430,7 +431,7 @@ handler source:
 
 ```ts
 const handlers = {
-  Increment: (to) => to.branch.root.session.update(({ current, owner }) => owner.from({ count: current.count + 1 }))
+  Increment: (to) => to.branch.root.session.update.from(({ current }) => ({ count: current.count + 1 }))
 }
 ```
 
@@ -463,30 +464,28 @@ const handlers = {
   CreatePlan: (to) =>
     to.local.SavingPlan()
       .updating(to.branch.Ready)
-      .resolve(({ current, event, owner, target }) =>
-        target.from({
-          request: { _tag: "Create", input: event.input }
-        }).update(
-          owner.decoded(new Ready({ ...current, notice: null }))
-        )
-      )
+      .from(({ current, event }) => ({
+        target: { request: { _tag: "Create", input: event.input } },
+        update: { ...current, notice: null }
+      }))
 }
 ```
 
 `to.local.SavingPlan()` selects topology. `.updating(to.branch.Ready)` names
-the retained valued owner and makes its replacement mandatory: the resolver
-does not type-check unless destination construction finishes with
-`.update(...)`. `current` is that owner's decoded value from the
-pre-transition snapshot. `target` constructs the destination; `owner`
-constructs the complete replacement owner value.
+the retained valued owner and makes its replacement mandatory. `.from(...)`
+returns `{ target, update }` with constructor inputs for both values;
+`.decoded(...)` returns already decoded values for both. `current` is that
+owner's decoded value from the pre-transition snapshot. Use `.resolve(...)`
+when constructing explicit children, mixing construction methods, or queuing
+commands; its `target` and `owner` builders construct the two values.
 
 The topology change and owner replacement apply atomically in one microstep.
 The owner does not exit or reenter, its work is not restarted, and destination
 entry actions observe the new owner value. Eventless stabilization follows.
 Only one retained owner may be replaced by a combined target. A `full` target,
 or any target that exits the selected owner, does not expose `.updating`.
-Combined updates use a direct resolver in this release; named branches continue
-to support value-only updates.
+Named branches support value-only updates; a combined update declares its
+destination directly.
 
 For a schema-less destination, construction remains explicit:
 
@@ -511,11 +510,13 @@ before lifecycle actions run. Competing transitions that write the same owner
 conflict; document order and hierarchy select one writer rather than applying
 last-write-wins behavior.
 
-The resolver must return `target.decoded(value)` or `target.from(input)`. It
-may return `decline()` only with `{ declinable: true }`. Pass `{ reenter: true }`
-on event or invocation transitions when the handler source should exit and
-enter again. Reentry applies to that source, not to the ancestor whose value
-changed.
+Use `.guard(predicate)` before construction to decline an update without
+constructing values or queuing commands. It is available on standalone and
+combined updates. A false guard allows ancestor fallback. A resolver may also
+return `decline()` with `{ declinable: true }` for decisions during resolution.
+Call `.reenter()` before construction on event or invocation transitions when
+the handler source should exit and enter again. Reentry applies to that source,
+not to the retained ancestor whose value changed.
 
 The selector omits `update` for schema-less scopes, atomic and final states,
 inactive branches, parallel sibling regions, and choice resolvers. Updating a

package/dist/Machine.d.ts

@@ -3052,7 +3052,7 @@ export declare namespace Machine {
      * 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
+     * transition with `.reenter()` when the source should explicitly exit and
      * enter again.
      *
      * @category models
@@ -3831,49 +3831,41 @@ export declare namespace Machine {
             readonly acceptance: Types.Covariant<Acceptance>;
         };
     }
-    type TransitionReenterOption<Reenter extends boolean> = [Reenter] extends [true] ? {
-        /** Forces the source state to exit and enter even when active paths remain unchanged. */
-        readonly reenter?: boolean;
-    } : {
-        readonly reenter?: never;
-    };
-    type TransitionRequiredOptions<Reenter extends boolean> = TransitionReenterOption<Reenter> & {
+    type TransitionRequiredOptions = {
         /** Keeps the transition required. The resolver cannot return `decline()`. */
         readonly declinable?: false;
+        readonly reenter?: never;
     };
-    type TransitionDeclinableOptions<Reenter extends boolean> = TransitionReenterOption<Reenter> & {
+    type TransitionDeclinableOptions = {
         /** Adds `decline()` to the resolver context and permits declining this candidate. */
         readonly declinable: true;
+        readonly reenter?: never;
     };
     type BuiltTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Result, Acceptance extends TransitionAcceptance> = TransitionTyped<States, Events, Emits, StateId, Context, Reenter, Acceptance> & TransitionBuilderEvidence<Result, Acceptance>;
     interface TransitionResolveRequired<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, any>> {
-        (resolve: TransitionResolver<Events, Emits, Context, Selection>, options?: TransitionRequiredOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required">;
+        (resolve: TransitionResolver<Events, Emits, Context, Selection>, options?: TransitionRequiredOptions): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required">;
     }
     interface TransitionResolveDeclinable<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, any>> {
-        (resolve: DeclinableTransitionResolver<Events, Emits, Context, Selection>, options: TransitionDeclinableOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, (SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined) | Declined, "declinable">;
+        (resolve: DeclinableTransitionResolver<Events, Emits, Context, Selection>, options: TransitionDeclinableOptions): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, (SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined) | Declined, "declinable">;
     }
     type ConstructionCallbacks<Context, Builder, Result> = {
         readonly [Method in Extract<keyof Builder, "from" | "decoded"> as Builder[Method] extends (...args: infer Args) => unknown ? Args extends readonly [unknown?] ? Method : never : never]: Builder[Method] extends (...args: infer Args) => unknown ? (value: (context: Context) => Args[0]) => Result : never;
     };
     type GuardedTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, any>> = ConstructionCallbacks<Omit<Context, "target">, SelectionBuilder<Selection>, BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">> & (SelectionSupportsDefaultConstruction<Selection> extends true ? BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable"> : {}) & {
-        readonly resolve: (resolve: TransitionResolver<Events, Emits, Context, Selection>, options?: TransitionRequiredOptions<Reenter>) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">;
+        readonly resolve: (resolve: TransitionResolver<Events, Emits, Context, Selection>, options?: TransitionRequiredOptions) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">;
     };
     /**
      * A selected transition target with target-specific resolver operations.
      *
-     * **Example** (Updating state while reentering)
+     * **Example** (Constructing state while reentering)
      *
      * ```ts
      * Reset: (to) =>
-     *   to.branch.Ready().resolve(
-     *     ({ target }) => target.from(),
-     *     { reenter: true }
-     *   )
+     *   to.branch.Ready().reenter().from(({ event }) => ({ count: event.count }))
      * ```
      *
      * @inlineType TransitionRequiredOptions
      * @inlineType TransitionDeclinableOptions
-     * @inlineType TransitionReenterOption
      */
     type TransitionTarget<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, any>> = Selection & ("declinable" extends Acceptance ? {
         /** Declines this candidate before construction when the predicate is false. */
@@ -3881,31 +3873,73 @@ export declare namespace Machine {
     } : {}) & ConstructionCallbacks<Omit<Context, "target">, SelectionBuilder<Selection>, BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection>, "required">> & (SelectionSupportsDefaultConstruction<Selection> extends true ? BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required"> : {}) & {
         /** Evaluates state construction after this transition is selected. */
         readonly resolve: TransitionResolveRequired<States, Events, Emits, StateId, Context, Reenter, Selection> & ("declinable" extends Acceptance ? TransitionResolveDeclinable<States, Events, Emits, StateId, Context, Reenter, Selection> : {});
-    } & ([Reenter] extends [true] ? SelectionSupportsDefaultConstruction<Selection> extends true ? {
-        /** Reenters the source using the selected target's default construction. */
-        readonly reenter: () => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectionKind<Selection> extends "none" ? undefined : SelectedTargetResult<Selection> | undefined, "required">;
-    } : {} : {}) & (SelectionKind<Selection> extends "state" ? SelectionScope<Selection> extends "local" | "branch" ? RetainedUpdateOwner<States, StateId, Selection> extends infer Owner extends ValuedStateIdentifier<States> ? [
+    } & ([Reenter] extends [true] ? {
+        /** Forces source exit and entry, preserving subsequent construction and guards. */
+        readonly reenter: () => Omit<TransitionTarget<States, Events, Emits, StateId, Context, Reenter, Acceptance, Selection>, typeof Topology.TargetSelectionTypeId>;
+    } : {}) & (SelectionKind<Selection> extends "state" ? SelectionScope<Selection> extends "local" | "branch" ? RetainedUpdateOwner<States, StateId, Selection> extends infer Owner extends ValuedStateIdentifier<States> ? [
         Owner
     ] extends [never] ? {} : {
         /** Declares one valued owner retained by the selected topology. */
         readonly updating: <SelectedOwner extends Owner>(owner: RetainedOwnerSelector<SelectedOwner>) => UpdatingTransitionTarget<States, Events, Emits, StateId, Context, Reenter, Acceptance, Selection, SelectedOwner>;
     } : {} : {} : {});
-    /** A topology selection that requires one retained owner replacement. */
-    type UpdatingTransitionTarget<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, "state">, Owner extends ValuedStateIdentifier<States>> = Selection & {
+    type UpdatingConstructionCallbacks<Context, Builder, OwnerBuilder, Result> = {
+        readonly [Method in Extract<keyof Builder & keyof OwnerBuilder, "from" | "decoded"> as Builder[Method] extends (...args: infer Args) => unknown ? Args extends readonly [unknown?] ? Method : never : never]: Builder[Method] extends (...args: infer Args) => unknown ? OwnerBuilder[Method] extends (value: infer Update) => unknown ? (construct: (context: Context) => {
+            readonly target: Args[0];
+            readonly update: Update;
+        }) => Result : never : never;
+    };
+    type UpdatingCallbacks<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, "state">, Owner extends ValuedStateIdentifier<States>, Acceptance extends TransitionAcceptance> = UpdatingConstructionCallbacks<Omit<UpdatingTransitionResolveContext<States, Context, Selection, Owner>, "owner" | "target">, SelectionBuilder<Selection>, StateUpdateBuilder<States, Owner>, BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | (Acceptance extends "declinable" ? Declined : never), Acceptance>>;
+    type GuardedUpdatingTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, "state">, Owner extends ValuedStateIdentifier<States>> = UpdatingCallbacks<States, Events, Emits, StateId, Context, Reenter, Selection, Owner, "declinable"> & {
+        readonly resolve: (resolve: (context: UpdatingTransitionResolveContext<States, Context, Selection, Owner>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner>, options?: TransitionRequiredOptions) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | Declined, "declinable">;
+    };
+    /**
+     * A topology selection that requires one retained owner replacement.
+     *
+     * `.from` constructs both values from schema inputs; `.decoded` accepts both
+     * decoded values. Both callbacks return `{ target, update }` and read the same
+     * pre-transition snapshot. Use `.resolve` for explicit child construction,
+     * mixed construction methods, or queued commands.
+     *
+     * **Example** (Guarding an atomic destination and owner update)
+     *
+     * ```ts
+     * Save: (to) => to.local.Saving().updating(to.root)
+     *   .guard(({ current }) => current.draft.length > 0)
+     *   .from(({ current }) => ({
+     *     target: { text: current.draft },
+     *     update: { ...current, attempts: current.attempts + 1 }
+     *   }))
+     * ```
+     */
+    type UpdatingTransitionTarget<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, "state">, Owner extends ValuedStateIdentifier<States>> = Selection & UpdatingCallbacks<States, Events, Emits, StateId, Context, Reenter, Selection, Owner, "required"> & ([Reenter] extends [true] ? {
+        readonly reenter: () => Omit<UpdatingTransitionTarget<States, Events, Emits, StateId, Context, Reenter, Acceptance, Selection, Owner>, typeof Topology.TargetSelectionTypeId>;
+    } : {}) & ("declinable" extends Acceptance ? {
+        /** Declines before either value is constructed or any commands are enqueued. */
+        readonly guard: (predicate: (context: Omit<UpdatingTransitionResolveContext<States, Context, Selection, Owner>, "owner" | "target">) => boolean) => GuardedUpdatingTransition<States, Events, Emits, StateId, Context, Reenter, Selection, Owner>;
+    } : {}) & {
         /** @internal */
         readonly "~effect/Machine/UpdatingTransitionTarget": Owner;
-        readonly resolve: ((resolve: (context: UpdatingTransitionResolveContext<States, Context, Selection, Owner>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner>, options?: TransitionRequiredOptions<Reenter>) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner>, "required">) & ("declinable" extends Acceptance ? (resolve: (context: UpdatingTransitionResolveContext<States, Context, Selection, Owner> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | Declined, options: TransitionDeclinableOptions<Reenter>) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | Declined, "declinable"> : {});
+        readonly resolve: ((resolve: (context: UpdatingTransitionResolveContext<States, Context, Selection, Owner>, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner>, options?: TransitionRequiredOptions) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner>, "required">) & ("declinable" extends Acceptance ? (resolve: (context: UpdatingTransitionResolveContext<States, Context, Selection, Owner> & DeclineCapability, enqueue: Enqueue<EventOf<Events>, EmittedEventOf<Emits>>) => CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | Declined, options: TransitionDeclinableOptions) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, CombinedTarget<UnwrapConstruction<SelectedTargetResult<Selection>>, States, Owner> | Declined, "declinable"> : {});
     };
     /** @internal */
     interface StateUpdateTransitionRequired<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, "update">> {
-        (resolve: StateUpdateResolver<States, Events, Emits, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, options?: TransitionRequiredOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection>, "required">;
+        (resolve: StateUpdateResolver<States, Events, Emits, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, options?: TransitionRequiredOptions): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection>, "required">;
     }
     /** @internal */
     interface StateUpdateTransitionDeclinable<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, "update">> {
-        (resolve: DeclinableStateUpdateResolver<States, Events, Emits, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, options: TransitionDeclinableOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">;
+        (resolve: DeclinableStateUpdateResolver<States, Events, Emits, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, options: TransitionDeclinableOptions): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">;
     }
+    type GuardedStateUpdateTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Selection extends TargetSelection<any, any, "update">> = ConstructionCallbacks<Omit<StateUpdateResolveContext<States, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, "owner">, SelectionBuilder<Selection>, BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">> & {
+        readonly resolve: (resolve: StateUpdateResolver<States, Events, Emits, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, options?: TransitionRequiredOptions) => BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection> | Declined, "declinable">;
+    };
     /** @internal */
-    type StateUpdateTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, "update">> = Selection & ConstructionCallbacks<Omit<StateUpdateResolveContext<States, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, "owner">, SelectionBuilder<Selection>, BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection>, "required">> & {
+    type StateUpdateTransition<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Selection extends TargetSelection<any, any, "update">> = Selection & ([Reenter] extends [true] ? {
+        /** Reenters the source while updating its retained valued ancestor. */
+        readonly reenter: () => Omit<StateUpdateTransition<States, Events, Emits, StateId, Context, Reenter, Acceptance, Selection>, typeof Topology.TargetSelectionTypeId>;
+    } : {}) & ("declinable" extends Acceptance ? {
+        /** Declines before replacing the selected owner value. */
+        readonly guard: (predicate: (context: Omit<StateUpdateResolveContext<States, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, "owner">) => boolean) => GuardedStateUpdateTransition<States, Events, Emits, StateId, Context, Reenter, Selection>;
+    } : {}) & ConstructionCallbacks<Omit<StateUpdateResolveContext<States, Context, Extract<SelectionPath<Selection>, ValuedStateIdentifier<States>>>, "owner">, SelectionBuilder<Selection>, BuiltTransition<States, Events, Emits, StateId, Context, Reenter, SelectedTargetResult<Selection>, "required">> & {
         readonly resolve: StateUpdateTransitionRequired<States, Events, Emits, StateId, Context, Reenter, Selection> & ("declinable" extends Acceptance ? StateUpdateTransitionDeclinable<States, Events, Emits, StateId, Context, Reenter, Selection> : {});
     };
     /** @internal Type evidence retained by a machine initial-entry declaration. */
@@ -3961,21 +3995,24 @@ export declare namespace Machine {
         readonly [Key in keyof Node]: TransitionSelectorNode<States, Events, Emits, StateId, Context, Reenter, Acceptance, Node[Key]>;
     };
     interface TransitionBranchesResolveRequired<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Branches extends Readonly<Record<string, TransitionBranchInput>>> {
-        (resolve: TransitionBranchesResolver<Events, Emits, Context, Branches>, options?: TransitionRequiredOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, BranchSelectionResult<Branches>, "required">;
+        (resolve: TransitionBranchesResolver<Events, Emits, Context, Branches>, options?: TransitionRequiredOptions): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, BranchSelectionResult<Branches>, "required">;
     }
     interface TransitionBranchesResolveDeclinable<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Branches extends Readonly<Record<string, TransitionBranchInput>>> {
-        (resolve: DeclinableTransitionBranchesResolver<Events, Emits, Context, Branches>, options: TransitionDeclinableOptions<Reenter>): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, BranchSelectionResult<Branches> | Declined, "declinable">;
+        (resolve: DeclinableTransitionBranchesResolver<Events, Emits, Context, Branches>, options: TransitionDeclinableOptions): BuiltTransition<States, Events, Emits, StateId, Context, Reenter, BranchSelectionResult<Branches> | Declined, "declinable">;
     }
     type TransitionSelectorTargets<in out States extends StateSchemas, in out Events extends ReadonlyArray<TaggedSchema>, in out Emits extends ReadonlyArray<TaggedSchema>, in out StateId extends StateNodeIdentifier<States>, in out Context, in out Reenter extends boolean, in out Acceptance extends TransitionAcceptance> = {
         readonly [Key in keyof TargetSelector<States, StateId>]: TransitionSelectorNode<States, Events, Emits, StateId, Context, Key extends "self" ? false : Reenter, Acceptance, TargetSelector<States, StateId>[Key]>;
     };
+    type TransitionBranchesTarget<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance, Branches extends Readonly<Record<string, TransitionBranchInput>>> = {
+        /** Resolves exactly one declared branch after this transition is selected. */
+        readonly resolve: TransitionBranchesResolveRequired<States, Events, Emits, StateId, Context, Reenter, Branches> & ("declinable" extends Acceptance ? TransitionBranchesResolveDeclinable<States, Events, Emits, StateId, Context, Reenter, Branches> : {});
+    } & ([Reenter] extends [true] ? {
+        readonly reenter: () => TransitionBranchesTarget<States, Events, Emits, StateId, Context, Reenter, Acceptance, Branches>;
+    } : {});
     /** Selector supplied to inline transition declarations. */
     interface TransitionSelector<in out States extends StateSchemas, in out Events extends ReadonlyArray<TaggedSchema>, in out Emits extends ReadonlyArray<TaggedSchema>, in out StateId extends StateNodeIdentifier<States>, in out Context, in out Reenter extends boolean, in out Acceptance extends TransitionAcceptance> extends TransitionSelectorTargets<States, Events, Emits, StateId, Context, Reenter, Acceptance> {
         /** Declares a closed set of named destinations for one resolver. */
-        readonly branches: <const Branches extends Readonly<Record<string, TransitionBranchInput>>>(branches: Branches & ValidateTransitionBranchRecord<NoInfer<Branches>>) => {
-            /** Resolves exactly one declared branch after this transition is selected. */
-            readonly resolve: TransitionBranchesResolveRequired<States, Events, Emits, StateId, Context, Reenter, Branches> & ("declinable" extends Acceptance ? TransitionBranchesResolveDeclinable<States, Events, Emits, StateId, Context, Reenter, Branches> : {});
-        };
+        readonly branches: <const Branches extends Readonly<Record<string, TransitionBranchInput>>>(branches: Branches & ValidateTransitionBranchRecord<NoInfer<Branches>>) => TransitionBranchesTarget<States, Events, Emits, StateId, Context, Reenter, Acceptance, Branches>;
     }
     /** Inline transition declaration accepted by state and invocation handlers. */
     type TransitionBuilderInput<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateNodeIdentifier<States>, Context, Reenter extends boolean, Acceptance extends TransitionAcceptance> = (to: TransitionSelector<States, Events, Emits, StateId, Context, Reenter, Acceptance>) => TransitionTyped<States, Events, Emits, StateId, Context, Reenter, Acceptance> & TransitionBuilderEvidence<any, Acceptance>;