diff --git a/src/libs/generator.ts b/src/libs/generator.ts
index 37988760..31769169 100644
--- a/src/libs/generator.ts
+++ b/src/libs/generator.ts
@@ -1,7 +1,6 @@
 export async function nextOf<T, R>(generator: AsyncGenerator<T, R>) {
   const next = await generator.next()
   if (!next.done) return next.value
-  throw new Error("Generator returned")
 }
 
 export async function returnOf<T, R>(generator: AsyncGenerator<T, R>) {
diff --git a/src/mods/core.ts b/src/mods/core.ts
index ef8a6f1f..e801c18f 100644
--- a/src/mods/core.ts
+++ b/src/mods/core.ts
@@ -131,16 +131,12 @@ export class Core extends Ortho<string, State | undefined> {
       return current
 
     const next: State<D, E, K> = {
-      time: Date.now(),
-      data: current?.data,
-      error: current?.error,
-      cooldown: current?.cooldown,
-      expiration: current?.expiration,
-      aborter: current?.aborter,
-      optimistic: current?.optimistic,
+      ...current,
       ...state
     }
 
+    if (next.time === undefined)
+      next.time = Date.now()
     next.data = await this.normalize(false, next, params)
 
     const {
diff --git a/src/mods/single/helper.ts b/src/mods/single/helper.ts
index ecc8c70f..319a0290 100644
--- a/src/mods/single/helper.ts
+++ b/src/mods/single/helper.ts
@@ -1,4 +1,4 @@
-import { nextOf, returnOf } from "libs/generator";
+import { returnOf } from "libs/generator";
 import { getTimeFromDelay } from "libs/time";
 import { Core } from "mods/core";
 import { AbortError } from "mods/errors";
@@ -139,9 +139,7 @@ export class SingleHelper {
     try {
       const generator = updater(current, { signal })
 
-      {
-        const { data, error } = await nextOf(generator)
-
+      for await (const { data, error } of generator) {
         const optimistic: State<D, E, K> = {}
 
         if (data !== undefined)
@@ -153,46 +151,44 @@ export class SingleHelper {
           params)
       }
 
-      {
-        let result = await returnOf(generator)
-
-        if (result === undefined) {
-          if (fetcher === undefined)
-            throw new Error("Updater returned nothing and undefined fetcher")
-          result = await fetcher(key, { signal, cache: "reload" })
-        }
-
-        const {
-          data,
-          error,
-          time = Date.now(),
-          cooldown = getTimeFromDelay(dcooldown),
-          expiration = getTimeFromDelay(dexpiration)
-        } = result
+      let result = await returnOf(generator)
 
-        if (signal.aborted)
-          throw new AbortError(signal)
-
-        current = await this.core.get(skey, params)
+      if (result === undefined) {
+        if (fetcher === undefined)
+          throw new Error("Updater returned nothing and undefined fetcher")
+        result = await fetcher(key, { signal, cache: "reload" })
+      }
 
-        if (error !== undefined) {
-          if (current?.aborter !== aborter)
-            return current
-          return await this.core.mutate(skey, current,
-            c => ({ time: c?.time, cooldown, expiration, aborter: undefined, optimistic: false, data: c?.data, error }),
-            params)
-        }
+      const {
+        data,
+        error,
+        time = Date.now(),
+        cooldown = getTimeFromDelay(dcooldown),
+        expiration = getTimeFromDelay(dexpiration)
+      } = result
 
-        const state: State<D, E, K> = {}
+      if (signal.aborted)
+        throw new AbortError(signal)
 
-        if (data !== undefined)
-          state.data = data
-        state.error = error
+      current = await this.core.get(skey, params)
 
+      if (error !== undefined) {
+        if (current?.aborter !== aborter)
+          return current
         return await this.core.mutate(skey, current,
-          () => ({ time, cooldown, expiration, aborter: undefined, optimistic: false, ...state }),
+          c => ({ time: c?.time, cooldown, expiration, aborter: undefined, optimistic: false, data: c?.data, error }),
           params)
       }
+
+      const state: State<D, E, K> = {}
+
+      if (data !== undefined)
+        state.data = data
+      state.error = error
+
+      return await this.core.mutate(skey, current,
+        () => ({ time, cooldown, expiration, aborter: undefined, optimistic: false, ...state }),
+        params)
     } catch (error: any) {
       current = await this.core.get(skey, params)