complete test case for #84

machine-runner/src/runner/runner.ts

@@ -506,16 +506,22 @@ export const createMachineRunnerInternal = <
   // AsyncIterator part
   // ==================
 
-  const nextValueAwaiter = NextValueAwaiter.make<
-    StateOpaque<SwarmProtocolName, MachineName, string, StateUnion>
-  >({
-    topLevelDestruction: internals.destruction,
-    failure: () => internals.failure,
-  })
+  type S = StateOpaque<SwarmProtocolName, MachineName, string, StateUnion>
+  const nextValueAwaiter = (state?: S | undefined) => {
+    const nva = NextValueAwaiter.make<S>({
+      topLevelDestruction: internals.destruction,
+      failure: () => internals.failure,
+      cloneFrom: state,
+    })
+
+    emitter.on('next', nva.push)
+    emitter.on('failure', nva.fail)
+    internals.destruction.addDestroyHook(nva.kill)
+
+    return nva
+  }
 
-  emitter.on('next', nextValueAwaiter.push)
-  emitter.on('failure', nextValueAwaiter.fail)
-  internals.destruction.addDestroyHook(nextValueAwaiter.kill)
+  const defaultNextValueAwaiter = nextValueAwaiter()
 
   // Self API construction
 
@@ -531,7 +537,7 @@ export const createMachineRunnerInternal = <
     isDestroyed: internals.destruction.isDestroyed,
     noAutoDestroy: () =>
       MachineRunnerIterableIterator.make({
-        nextValueAwaiter,
+        nextValueAwaiter: nextValueAwaiter(defaultNextValueAwaiter.state()),
         destruction: (() => {
           const childDestruction = Destruction.make()
 
@@ -548,7 +554,7 @@ export const createMachineRunnerInternal = <
 
   const defaultIterator: MachineRunnerIterableIterator<SwarmProtocolName, MachineName, StateUnion> =
     MachineRunnerIterableIterator.make({
-      nextValueAwaiter,
+      nextValueAwaiter: defaultNextValueAwaiter,
       destruction: internals.destruction,
     })
 
@@ -677,14 +683,17 @@ namespace NextValueAwaiter {
   export const make = <S extends any>({
     topLevelDestruction,
     failure,
+    cloneFrom,
   }: {
     topLevelDestruction: Destruction
     failure: () => MachineRunnerFailure | null
+    cloneFrom?: S
   }) => {
     const Done: IteratorResult<S, null> = { done: true, value: null }
     const wrapAsIteratorResult = (value: S): IteratorResult<S, null> => ({ done: false, value })
 
-    let store: null | { state: S } | RequestedPromisePair<IteratorResult<S, null>> = null
+    let store: null | { state: S } | RequestedPromisePair<IteratorResult<S, null>> =
+      cloneFrom === undefined ? null : { state: cloneFrom }
 
     /**
      * Allows different level of destructions
@@ -743,6 +752,7 @@ namespace NextValueAwaiter {
           store = { state }
         }
       },
+      state: () => (store && 'state' in store ? store.state : undefined),
       generateConsumeAPI,
     }
   }

machine-runner/tests/esm/runner.test.ts

@@ -570,6 +570,24 @@ describe('machine as async generator', () => {
   })
 
   describe('non-destroying cloned async generator', () => {
+    it('should not wait after main generator peek', async () => {
+      const r1 = new Runner(On, { toggleCount: 0 })
+      const machine = r1.machine
+
+      r1.feed([], true)
+
+      const peekResult = (await machine.peekNext()).value
+      const copy = machine.noAutoDestroy()
+      expect(await Promise.race([machine.next(), sleep(1)])).toEqual({
+        done: false,
+        value: peekResult,
+      })
+      for await (const state of copy) {
+        expect(state).toBe(peekResult)
+        break
+      }
+    })
+
     it('should generate the same snapshot as parent', async () => {
       const r = new Runner(On, { toggleCount: 0 })
       const machine = r.machine