@typeonce/effect-machine 0.21.0 → 0.22.0

package/src/internal/machine/executionPlan.ts

@@ -47,7 +47,15 @@ import {
   validateDeclaredTransitionTarget
 } from "./planner.js"
 import { decodeEmitSync, decodeEventSync, decodeInputSync, decodeStateValueSync } from "./protocol.js"
-import { isInitialTarget, isNoTarget, isSnapshot, isStateUpdate, isTarget, TargetSnapshotTypeId } from "./topology.js"
+import {
+  isCombinedTarget,
+  isInitialTarget,
+  isNoTarget,
+  isSnapshot,
+  isStateUpdate,
+  isTarget,
+  TargetSnapshotTypeId
+} from "./topology.js"
 
 interface IndexedExecutionDescriptor {
   readonly flat: boolean
@@ -548,25 +556,28 @@ const collectIndexedEvaluatedTransition = (
     selection.context,
     selection.transition.evaluate
   )
-  const update = isStateUpdate(transitionResult.state)
+  const combined = isCombinedTarget(transitionResult.state) ? transitionResult.state : undefined
+  const transitionState = combined?.target ?? transitionResult.state
+  const stateUpdate = combined?.update ?? (isStateUpdate(transitionState) ? transitionState : undefined)
+  const update = stateUpdate !== undefined
     ? (() => {
-      const index = descriptor.indexByPath.get(transitionResult.state.path)
+      const index = descriptor.indexByPath.get(stateUpdate.path)
       const node = index === undefined ? undefined : descriptor.nodes[index]
       if (
         index === undefined || node === undefined || state.active[index] !== 1 || node.schema === undefined ||
         (node.type !== "compound" && node.type !== "parallel")
       ) {
         throw new Error(
-          `Machine state update owner "${transitionResult.state.path}" must be an active valued compound or parallel state`
+          `Machine state update owner "${stateUpdate.path}" must be an active valued compound or parallel state`
         )
       }
       return {
         path: node.path,
-        value: decodeStateValueSync(machine, node, transitionResult.state.value)
+        value: decodeStateValueSync(machine, node, stateUpdate.value)
       }
     })()
     : undefined
-  const unresolvedTarget = update === undefined ? transitionResult.state : undefined
+  const unresolvedTarget = transitionState === undefined || isStateUpdate(transitionState) ? undefined : transitionState
   validateDeclaredTransitionTarget(
     selection.sourcePath,
     selection.trigger,
@@ -585,13 +596,22 @@ const collectIndexedEvaluatedTransition = (
   if (target !== undefined && !isTarget(target) && !isSnapshot(target)) {
     throw new Error("Machine expected indexed transition target to be a snapshot or target builder result")
   }
-  const next = target === undefined
+  let next = target === undefined
     ? update === undefined ? state : (() => {
       const next = copyOwnedIndexedState(state)
       next.values[descriptor.indexByPath.get(update.path)!] = update.value
       return next
     })()
     : normalizeIndexedTargetStateSync(machine, descriptor, state, target as any, selection.leafIndex)
+  if (combined !== undefined && update !== undefined) {
+    const ownerIndex = descriptor.indexByPath.get(update.path)!
+    if (next.active[ownerIndex] !== 1) {
+      throw new Error(`Machine combined target exited its updating owner "${update.path}"`)
+    }
+    const values = next.values.slice()
+    values[ownerIndex] = update.value
+    next = { ...next, values }
+  }
   const changed = selection.transition.reenter || !hasSameIndexedActive(state, next)
   const stabilize = changed || update !== undefined
   if (!changed) {
@@ -656,7 +676,8 @@ const indexedMicrostep = (
     branchIndex: transition.branchIndex,
     branchKey: transition.branchKey,
     target: transition.unresolvedTarget === undefined ? undefined : getTargetNodePath(transition.unresolvedTarget),
-    resolvedTarget: transition.target === undefined ? undefined : getTargetNodePath(transition.target)
+    resolvedTarget: transition.target === undefined ? undefined : getTargetNodePath(transition.target),
+    updates: transition.update === undefined ? [] : [transition.update.path]
   })
   if (selections.length === 1) {
     const transition = collectIndexedEvaluatedTransition(machine, descriptor, state, selections[0]!)
@@ -849,7 +870,8 @@ const planIndexedFlatState = (
               branchIndex: transitionResult.branchIndex,
               branchKey: transitionResult.branchKey,
               target: target === undefined ? undefined : getTargetNodePath(target as any),
-              resolvedTarget: target === undefined ? undefined : getTargetNodePath(target as any)
+              resolvedTarget: target === undefined ? undefined : getTargetNodePath(target as any),
+              updates: []
             }]
           }
           : undefined),

package/src/internal/machine/initialization.ts

@@ -14,11 +14,19 @@ const getNode = (machine: Machine.Any, path: string): Machine.StateNode => {
 }
 
 const withFrom = <Method extends (value: unknown) => unknown>(method: Method) => {
-  Object.defineProperty(method, "from", {
+  const builder = {}
+  Object.defineProperty(builder, "decoded", {
+    value: method,
+    enumerable: false
+  })
+  Object.defineProperty(builder, "from", {
     value: (...args: ReadonlyArray<unknown>) => method(Topology.makeStateInput(args.length === 0 ? {} : args[0])),
     enumerable: false
   })
-  return method as Method & { readonly from: (...args: ReadonlyArray<unknown>) => unknown }
+  return builder as {
+    readonly decoded: Method
+    readonly from: (...args: ReadonlyArray<unknown>) => unknown
+  }
 }
 
 const makeCompletion = (values: Readonly<Record<string, unknown>>): object => {

package/src/internal/machine/machine.ts

@@ -191,7 +191,7 @@ type InitialBuilderDescriptor = {
 const plainTargetSelection = (selection: Topology.TargetSelection): Topology.TargetSelection =>
   selection.kind === "none"
     ? Topology.noneTargetSelection
-    : Topology.makeTargetSelection(selection.kind, selection.path, selection.scope)
+    : Topology.makeTargetSelection(selection.kind, selection.path, selection.scope, selection.updatePath)
 
 const transitionOptions = (options: unknown): { readonly reenter: boolean; readonly declinable: boolean } => {
   const configuration = typeof options === "object" && options !== null
@@ -224,7 +224,22 @@ const decorateTransitionSelection = (selection: Topology.TargetSelection): Topol
     ...selection,
     resolve: (resolve: (context: any, enqueue: unknown) => unknown, options?: unknown) =>
       makeDirectTransitionDescriptor(selection, resolve, options),
-    reenter: () => makeDirectTransitionDescriptor(selection, undefined, { reenter: true })
+    reenter: () => makeDirectTransitionDescriptor(selection, undefined, { reenter: true }),
+    updating: (owner: unknown) => {
+      if (typeof owner !== "function") {
+        throw new Error("Machine updating owner must be a state selector")
+      }
+      const ownerSelection = owner()
+      if (
+        !Topology.isTargetSelection(ownerSelection) || ownerSelection.kind !== "state" ||
+        ownerSelection.scope !== "branch"
+      ) {
+        throw new Error("Machine updating owner must be addressed by one branch state selector")
+      }
+      return decorateTransitionSelection(
+        Topology.makeTargetSelection(selection.kind, selection.path, selection.scope, ownerSelection.path)
+      )
+    }
   })
 
 const decorateStateUpdateSelection = (selection: Topology.TargetSelection): Topology.TargetSelection => {
@@ -360,6 +375,11 @@ const transitionTargetSelection = (
     scope: selection.scope
   })
 
+const selectionUpdates = (selection: Topology.TargetSelection): ReadonlyArray<string> =>
+  selection.updatePath === undefined ?
+    selection.kind === "update" && selection.path !== undefined ? [selection.path] : []
+    : [selection.updatePath]
+
 const makeSelectionMethod = (
   kind: Topology.TargetSelectionKind,
   path: string | undefined,
@@ -476,6 +496,7 @@ const makeTargetSelector = (
 const captureDefinitionBranch = (
   branch: unknown,
   selector: unknown,
+  stateNodes: Machine.StateNodes,
   path: string,
   trigger: PropertyKey
 ): CapturedBranch => {
@@ -489,9 +510,58 @@ const captureDefinitionBranch = (
   if (!Topology.isTargetSelection(selection)) {
     throw new Error(`Machine transition for state "${path}" on "${String(trigger)}" must select exactly one target`)
   }
+  if (selection.updatePath !== undefined) {
+    const owner = stateNodes.byPath.get(selection.updatePath)
+    if (
+      selection.kind !== "state" || (selection.scope !== "local" && selection.scope !== "branch") ||
+      selection.path === undefined || owner === undefined || owner.schema === undefined ||
+      (owner.type !== "compound" && owner.type !== "parallel") ||
+      !Configuration.isDescendantOf(path, owner.path) ||
+      !Configuration.isDescendantOf(selection.path, owner.path)
+    ) {
+      throw new Error(
+        `Machine updating owner "${selection.updatePath}" must be a valued ancestor retained by source "${path}" and target "${selection.path}"`
+      )
+    }
+  }
   return { ...(branch as DefinitionBranch), selection }
 }
 
+const makeUpdatingConstruction = (
+  target: unknown,
+  ownerPath: string
+): { readonly update: (update: unknown) => Topology.CombinedTarget } =>
+  Object.freeze({
+    update: (update: unknown) => {
+      if (!Topology.isStateUpdate(update) || update.path !== ownerPath) {
+        throw new Error(`Machine combined target must update its declared owner "${ownerPath}"`)
+      }
+      return Topology.makeCombinedTarget(target, update)
+    }
+  })
+
+const makeUpdatingTargetBuilder = (
+  builder: unknown,
+  ownerPath: string
+): unknown => {
+  if (typeof builder !== "object" || builder === null) {
+    throw new Error("Machine combined target requires a state construction builder")
+  }
+  const updating: Record<PropertyKey, unknown> = {}
+  for (const property of Reflect.ownKeys(builder)) {
+    const descriptor = Object.getOwnPropertyDescriptor(builder, property)
+    if (descriptor === undefined) continue
+    if (
+      (property === "from" || property === "decoded") && "value" in descriptor && typeof descriptor.value === "function"
+    ) {
+      const construct = descriptor.value
+      descriptor.value = (...args: ReadonlyArray<unknown>) => makeUpdatingConstruction(construct(...args), ownerPath)
+    }
+    Object.defineProperty(updating, property, descriptor)
+  }
+  return Object.freeze(updating)
+}
+
 const getSelectionBuilder = (
   target: Record<string, any>,
   selection: Topology.TargetSelection,
@@ -534,7 +604,7 @@ const getSelectionBuilder = (
   ) {
     throw new Error(`Machine could not construct selected transition target "${selection.path}"`)
   }
-  return builder
+  return selection.updatePath === undefined ? builder : makeUpdatingTargetBuilder(builder, selection.updatePath)
 }
 
 const constructSelectedTarget = (builder: any): unknown =>
@@ -557,10 +627,18 @@ const validateResolvedSelection = (
     }
     return
   }
+  if (selection.updatePath !== undefined) {
+    if (!Topology.isCombinedTarget(result) || result.update.path !== selection.updatePath) {
+      throw new Error(`Machine target updating "${selection.updatePath}" must return target construction .update(...)`)
+    }
+  } else if (Topology.isCombinedTarget(result)) {
+    throw new Error("Machine combined target requires an updating owner declaration")
+  }
   if (result === undefined) return
-  const resultPath = typeof result === "object" && result !== null && hasProperty(result, "path") &&
-      typeof result.path === "string"
-    ? result.path
+  const target = Topology.isCombinedTarget(result) ? result.target : result
+  const resultPath = typeof target === "object" && target !== null && hasProperty(target, "path") &&
+      typeof target.path === "string"
+    ? target.path
     : undefined
   const selectedNode = selection.path === undefined ? undefined : stateNodes.byPath.get(selection.path)
   const acceptsDescendant = (selection.scope === "local" || selection.scope === "branch") &&
@@ -587,6 +665,26 @@ const runCapturedBranch = (
   const resolverContext = { ...context }
   if (branch.selection.kind === "none") delete resolverContext.target
   else resolverContext.target = selectedTarget
+  if (branch.selection.kind === "update") {
+    const ownerPath = branch.selection.path!
+    delete resolverContext.target
+    resolverContext.current = context.ancestors[ownerPath] ?? context.state
+    resolverContext.owner = getSelectionBuilder(
+      context.target,
+      makeStateUpdateSelection(ownerPath, branch.selection.scope === "local" ? "local" : "branch"),
+      stateNodes,
+      source
+    )
+  } else if (branch.selection.updatePath !== undefined) {
+    const ownerPath = branch.selection.updatePath
+    resolverContext.current = context.ancestors[ownerPath]
+    resolverContext.owner = getSelectionBuilder(
+      context.target,
+      makeStateUpdateSelection(ownerPath, "branch"),
+      stateNodes,
+      source
+    )
+  }
   if (branch.declinable === true) resolverContext.decline = Topology.makeDeclined
   const resolved = branch.resolve(resolverContext, enqueue)
   if (Topology.isDeclined(resolved)) {
@@ -636,6 +734,9 @@ const captureNamedBranches = (
     if (!Topology.isTargetSelection(target)) {
       throw new Error(`Machine transition branch "${key}" must select exactly one target`)
     }
+    if (target.updatePath !== undefined) {
+      throw new Error(`Machine transition branch "${key}" cannot declare an updating target`)
+    }
     if (title !== undefined && (typeof title !== "string" || title.length === 0)) {
       throw new Error(`Machine transition branch "${key}" title must be a non-empty string`)
     }
@@ -795,14 +896,15 @@ const captureTransition = (
           key: branch.key,
           title: branch.title,
           target: topologyTargetPath(branch.selection),
-          selection: transitionTargetSelection(branch.selection)
+          selection: transitionTargetSelection(branch.selection),
+          updates: selectionUpdates(branch.selection)
         })
       ),
       evaluate,
       transition: (context: Record<string, any>, enqueue: unknown) => evaluate(context, enqueue).result
     }
   }
-  const branch = captureDefinitionBranch(transition, selector, path, trigger)
+  const branch = captureDefinitionBranch(transition, selector, stateNodes, path, trigger)
   const evaluate = (context: Record<string, any>, enqueue: unknown) => ({
     result: runCapturedBranch(branch, context, enqueue, stateNodes, path),
     branchIndex: 0,
@@ -815,7 +917,8 @@ const captureTransition = (
     branches: [{
       type: "direct" as const,
       target: topologyTargetPath(branch.selection),
-      selection: transitionTargetSelection(branch.selection)
+      selection: transitionTargetSelection(branch.selection),
+      updates: selectionUpdates(branch.selection)
     }],
     evaluate,
     transition: (context: Record<string, any>, enqueue: unknown) => evaluate(context, enqueue).result
@@ -1022,8 +1125,18 @@ const withFrom = <Method extends (value: unknown, ...args: ReadonlyArray<any>) =
   method: Method,
   kind: FromMethodKind,
   valued: boolean
-): Method & { readonly from: (...args: ReadonlyArray<any>) => unknown } => {
-  Object.defineProperty(method, "from", {
+): {
+  readonly decoded?: Method
+  readonly from: (...args: ReadonlyArray<any>) => unknown
+} => {
+  const builder: Record<string, unknown> = {}
+  if (valued) {
+    Object.defineProperty(builder, "decoded", {
+      value: method,
+      enumerable: false
+    })
+  }
+  Object.defineProperty(builder, "from", {
     value: (...args: ReadonlyArray<any>) => {
       if (!valued) {
         return method(undefined, ...args)
@@ -1035,7 +1148,10 @@ const withFrom = <Method extends (value: unknown, ...args: ReadonlyArray<any>) =
     },
     enumerable: false
   })
-  return method as Method & { readonly from: (...args: ReadonlyArray<any>) => unknown }
+  return builder as {
+    readonly decoded?: Method
+    readonly from: (...args: ReadonlyArray<any>) => unknown
+  }
 }
 
 const withInitial = <Builder extends object>(
@@ -1518,13 +1634,13 @@ const makeInitialSelector = (stateNodes: Machine.StateNodes): unknown => {
 const getInitialSelectionBuilder = (
   initialBuilder: Record<string, any>,
   selection: Topology.TargetSelection
-): (...args: ReadonlyArray<any>) => unknown => {
+): Record<string, any> => {
   const path = selection.path
   if (path === undefined || path.includes(".")) {
     throw new Error("Machine initial target must select one top-level state")
   }
   const builder = initialBuilder[path]
-  if (typeof builder !== "function") {
+  if (typeof builder !== "object" || builder === null || typeof builder.from !== "function") {
     throw new Error(`Machine could not construct selected initial state "${path}"`)
   }
   return builder
@@ -1537,7 +1653,7 @@ const captureInitialBranch = (
 ): {
   readonly selection: Topology.TargetSelection
   readonly resolve?: (context: any) => unknown
-  readonly builder: (...args: ReadonlyArray<any>) => unknown
+  readonly builder: Record<string, any>
 } => {
   if (typeof definition !== "function") {
     throw new Error("Machine initial definition must be a target-first callback")

package/src/internal/machine/planner.ts

@@ -47,6 +47,7 @@ import {
   getNode,
   type InitialTarget as InitialTargetInstruction,
   isChoiceTarget,
+  isCombinedTarget,
   isDeclined,
   isHistoryTarget,
   isInitialTarget,
@@ -70,6 +71,7 @@ export type MicrostepPlan<State, Event, E, R> = {
     readonly branchKey: string | undefined
     readonly target: string | undefined
     readonly resolvedTarget: string | undefined
+    readonly updates: ReadonlyArray<string>
   }>
   readonly commands: ReadonlyArray<RuntimeCommand>
   readonly raisedEvents: ReadonlyArray<Event>
@@ -605,6 +607,7 @@ export type EvaluatedTransition<States extends Machine.StateSchemas, Event, E, R
     readonly branchKey: string | undefined
     readonly target: string
     readonly resolvedTarget: string
+    readonly updates: ReadonlyArray<string>
   }>
 }
 
@@ -1234,6 +1237,7 @@ interface ResolvedChoiceTransition {
   readonly branchKey: string | undefined
   readonly target: string
   readonly resolvedTarget: string
+  readonly updates: ReadonlyArray<string>
 }
 
 function resolveChoiceTarget(
@@ -1312,7 +1316,8 @@ function resolveChoiceTarget(
         branchIndex: collected.branchIndex,
         branchKey: collected.branchKey,
         target: returnedPath,
-        resolvedTarget: nested?.target.path ?? returnedPath
+        resolvedTarget: nested?.target.path ?? returnedPath,
+        updates: []
       })
       commands.push(...collected.commands)
       raisedEvents.push(...collected.raisedEvents)
@@ -1356,10 +1361,12 @@ const collectEvaluatedTransition = <
   if (transitionResult.declined) {
     throw new Error("Machine transition returned decline without declaring declinable: true")
   }
-  const unresolvedTarget = transitionResult.state === undefined
-      || isStateUpdate(transitionResult.state)
+  const combined = isCombinedTarget(transitionResult.state) ? transitionResult.state : undefined
+  const transitionState = combined?.target ?? transitionResult.state
+  const unresolvedTarget = transitionState === undefined
+      || isStateUpdate(transitionState)
     ? undefined
-    : transitionResult.state as
+    : transitionState as
       | Machine.Snapshot<States>
       | Machine.Target<States, Machine.StateIdentifier<States>>
       | Machine.HistoryTarget<States, Machine.HistoryIdentifier<States>>
@@ -1370,9 +1377,10 @@ const collectEvaluatedTransition = <
     selection.transition.targets,
     unresolvedTarget
   )
-  const update = isStateUpdate(transitionResult.state)
+  const stateUpdate = combined?.update ?? (isStateUpdate(transitionState) ? transitionState : undefined)
+  const update = stateUpdate !== undefined
     ? (() => {
-      const node = getNode(machine, transitionResult.state.path)
+      const node = getNode(machine, stateUpdate.path)
       if (
         !state.active.has(node.path) || node.schema === undefined ||
         (node.type !== "compound" && node.type !== "parallel")
@@ -1381,7 +1389,7 @@ const collectEvaluatedTransition = <
       }
       return {
         path: node.path,
-        value: decodeStateValueSync(machine, node, transitionResult.state.value)
+        value: decodeStateValueSync(machine, node, stateUpdate.value)
       }
     })()
     : undefined
@@ -1497,6 +1505,15 @@ const collectEvaluatedTransition = <
       additionalTarget
     )
   }
+  if (combined !== undefined && update !== undefined && !stateAfterTransition.active.has(update.path)) {
+    throw new Error(`Machine combined target exited its updating owner "${update.path}"`)
+  }
+  if (update !== undefined) {
+    stateAfterTransition = {
+      ...stateAfterTransition,
+      values: new Map(stateAfterTransition.values).set(update.path, update.value)
+    }
+  }
   const changed = selection.transition.reenter || !hasSameActivePaths(state, stateAfterTransition)
   const stabilize = changed || update !== undefined
 
@@ -1915,7 +1932,8 @@ const microstep = <
       branchIndex: transition.branchIndex,
       branchKey: transition.branchKey,
       target: transition.unresolvedTarget === undefined ? undefined : getTargetNodePath(transition.unresolvedTarget),
-      resolvedTarget: transition.target === undefined ? undefined : getTargetNodePath(transition.target)
+      resolvedTarget: transition.target === undefined ? undefined : getTargetNodePath(transition.target),
+      updates: transition.update === undefined ? [] : [transition.update.path]
     },
     ...transition.choiceTransitions
   ])

package/src/internal/machine/topology.ts

@@ -31,6 +31,8 @@ export const TargetSelectionTypeId: unique symbol = Symbol("effect/Machine/Targe
 
 export const StateUpdateTypeId: unique symbol = Symbol("effect/Machine/StateUpdate")
 
+export const CombinedTargetTypeId: unique symbol = Symbol("effect/Machine/CombinedTarget")
+
 export const SelectedBranchTypeId: unique symbol = Symbol("effect/Machine/SelectedBranch")
 
 interface StateInput {
@@ -85,6 +87,7 @@ export interface TargetSelection {
   readonly kind: TargetSelectionKind
   readonly scope: TargetSelectionScope | undefined
   readonly path: string | undefined
+  readonly updatePath?: string
 }
 
 /** One branch selection returned by a compiled branching transition. */
@@ -99,13 +102,15 @@ export interface SelectedBranch {
 export const makeTargetSelection = (
   kind: TargetSelectionKind,
   path?: string,
-  scope?: TargetSelectionScope
+  scope?: TargetSelectionScope,
+  updatePath?: string
 ): TargetSelection =>
   Object.freeze({
     [TargetSelectionTypeId]: TargetSelectionTypeId as typeof TargetSelectionTypeId,
     kind,
     scope,
-    path
+    path,
+    ...(updatePath === undefined ? {} : { updatePath })
   })
 
 /** Source-independent definition-time selection for an explicitly targetless transition. */
@@ -128,6 +133,21 @@ export const makeStateUpdate = (path: string, value: unknown): StateUpdate =>
 
 export const isStateUpdate = (u: unknown): u is StateUpdate => hasProperty(u, StateUpdateTypeId)
 
+export interface CombinedTarget {
+  readonly [CombinedTargetTypeId]: typeof CombinedTargetTypeId
+  readonly target: unknown
+  readonly update: StateUpdate
+}
+
+export const makeCombinedTarget = (target: unknown, update: StateUpdate): CombinedTarget =>
+  Object.freeze({
+    [CombinedTargetTypeId]: CombinedTargetTypeId,
+    target,
+    update
+  })
+
+export const isCombinedTarget = (u: unknown): u is CombinedTarget => hasProperty(u, CombinedTargetTypeId)
+
 export const makeSelectedBranch = (
   owner: object,
   branchIndex: number,

package/src/internal/testing/machine/finiteModel.ts

@@ -1234,7 +1234,10 @@ const selectSnapshot = (
   if (state.node._tag === "Choice") {
     return (builder[state.node.key] as () => unknown)()
   }
-  const method = builder[state.node.key] as (value: unknown, selector?: (builder: any) => unknown) => unknown
+  const method = builder[state.node.key].decoded as (
+    value: unknown,
+    selector?: (builder: any) => unknown
+  ) => unknown
   const value = stateValue(state, path === requestedParts?.join(".") ? requestedValue : undefined)
   if (state.node._tag === "Atomic" || state.node._tag === "Final") return method(value)
 
@@ -1473,14 +1476,15 @@ const makeHandlers = (
           ...(Object.keys(history).length === 0 ? {} : { history }),
           ...(node._tag === "Compound"
             ? {
-              initialize: ({ builder }: any) => builder(stateValue(byPath.get(`${path}.${node.initial}`)!))
+              initialize: ({ builder }: any) => builder.decoded(stateValue(byPath.get(`${path}.${node.initial}`)!))
             }
             : {
               initialize: ({ builder }: any) =>
                 node.states
                   .filter((child) => child._tag !== "History" && child._tag !== "Choice")
                   .reduce(
-                    (current: any, child) => current[child.key](stateValue(byPath.get(`${path}.${child.key}`)!)),
+                    (current: any, child) =>
+                      current[child.key].decoded(stateValue(byPath.get(`${path}.${child.key}`)!)),
                     builder
                   )
             }),

package/src/internal/testing/machine/verification.ts

@@ -564,7 +564,6 @@ export const coverage = <M extends AnyMachine>(
   const exitHits = new Set<number>()
 
   const transitionCoverage = makeTransitionCoverageCollector(machine)
-  const transitionDefinitions = Machine.transitionDefinitions(machine)
 
   const declaredEvents = publicEventTags(machine)
   const declaredEventTags = declaredEvents.tags
@@ -632,13 +631,8 @@ export const coverage = <M extends AnyMachine>(
     hitPaths(microstep.exitPaths, exitHits)
     observeSnapshot(microstep.next)
     for (const retained of microstep.transitions) {
-      const definition = transitionDefinitions.find((candidate) =>
-        candidate.source === retained.source && candidate.reenter === retained.reenter &&
-        sameTransitionTrigger(candidate.trigger, retained.trigger)
-      )
-      const branch = definition?.branches[retained.branchIndex]
-      if (branch?.selection.kind === "update") stateUpdates += 1
-      else if (retained.target === undefined) targetlessTransitions += 1
+      stateUpdates += retained.updates.length
+      if (retained.target === undefined && retained.updates.length === 0) targetlessTransitions += 1
       if (retained.trigger.type === "event") eventTriggered += 1
       else if (retained.trigger.type === "always") alwaysTriggered += 1
       else if (retained.trigger.type === "done") doneTriggered += 1
@@ -1549,6 +1543,18 @@ export const verify = <M extends AnyMachine>(
         transition.target === undefined ? transition.source : String(transition.target)
       )
     }
+    if (
+      transition.updates.length !== branch.updates.length ||
+      transition.updates.some((path, index) => path !== branch.updates[index])
+    ) {
+      add(
+        "definitions.selection",
+        location,
+        `transition branch ${transition.branchIndex} from "${transition.source}" reported retained owner updates ` +
+          `${JSON.stringify(transition.updates)} instead of ${JSON.stringify(branch.updates)}`,
+        transition.source
+      )
+    }
     return branch
   }
 
@@ -1607,8 +1613,10 @@ export const verify = <M extends AnyMachine>(
       const resolvedTarget = transition.resolvedTarget === undefined ? undefined : String(transition.resolvedTarget)
       const targetNode = target === undefined ? undefined : byPath.get(target)
       let expected = target
-      let explanation = branches[index]?.selection.kind === "update"
-        ? `update owner "${String(branches[index]?.selection.path)}"`
+      let explanation = transition.updates.length > 0
+        ? target === undefined
+          ? `update owner "${transition.updates.join("\", \"")}"`
+          : `target "${target}" and update owner "${transition.updates.join("\", \"")}"`
         : target === undefined
         ? "an unresolved targetless transition"
         : `target "${target}"`

package/src/testing/MachineTest.ts

@@ -1109,7 +1109,7 @@ export const Invariant: {
  *   events: Machine.events(),
  *   initial: {
  *     target: (to) => to.Count(),
- *     resolve: ({ target }) => target(new Count({ value: 0 }))
+ *     resolve: ({ target }) => target.decoded(new Count({ value: 0 }))
  *   }
  * }).handle({ Count: {} })
  *
@@ -1444,14 +1444,14 @@ export type ExploreOptions<M extends AnyMachine, Key extends ExplorationKey = Ex
  *   events: Machine.events(Increment),
  *   initial: {
  *     target: (to) => to.Count(),
- *     resolve: ({ target }) => target(new Count({ value: 0 }))
+ *     resolve: ({ target }) => target.decoded(new Count({ value: 0 }))
  *   }
  * }).handle({
  *   Count: {
  *     on: {
  *       Increment: (to) =>
  *         to.full.Count().resolve(({ state, target }) =>
- *           target(new Count({ value: state.value + 1 })))
+ *           target.decoded(new Count({ value: state.value + 1 })))
  *     }
  *   }
  * })

package/src/unstable/reactivity/AtomMachine.ts

@@ -374,7 +374,7 @@ type ChildState<Child extends Machine.ChildMachine.Any> = RefState<Machine.Child
  *   events: Machine.events(),
  *   initial: {
  *     target: (to) => to.Count(),
- *     resolve: ({ target }) => target(new Count({ value: 0 }))
+ *     resolve: ({ target }) => target.decoded(new Count({ value: 0 }))
  *   }
  * }).handle({ Count: {} })
  * const machineAtom = AtomMachine.make(machine)