diff --git a/package-lock.json b/package-lock.json
index 6d4995d..addb179 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "recursive-timeout",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "recursive-timeout",
-      "version": "0.0.6",
+      "version": "0.0.7",
       "license": "ISC",
       "devDependencies": {
         "@rollup/plugin-typescript": "12.1.4",
diff --git a/package.json b/package.json
index d0c6910..bfb0ab6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "recursive-timeout",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "author": "Dmytro Parzhytskyi <parzhitsky@gmail.com> (https://parzh.com)",
   "description": "A simple solution to a classic problem: setInterval implemented as recursive setTimeout calls.",
   "license": "MIT",
diff --git a/src/with-callback/clear-recursive-timeout.spec.ts b/src/with-callback/clear-recursive-timeout.spec.ts
index 6395111..70ec945 100644
--- a/src/with-callback/clear-recursive-timeout.spec.ts
+++ b/src/with-callback/clear-recursive-timeout.spec.ts
@@ -10,9 +10,9 @@ describe(clearRecursiveTimeout, () => {
   })
 
   it('should clear the scheduled timeout', async () => {
-    const timeout = createRecursiveTimeout(callback, 100)
+    const recursive = createRecursiveTimeout(callback, 100)
 
-    clearRecursiveTimeout(timeout)
+    clearRecursiveTimeout(recursive)
 
     await delay(150)
 
diff --git a/src/with-callback/clear-recursive-timeout.ts b/src/with-callback/clear-recursive-timeout.ts
index d5d86e0..6e20da8 100644
--- a/src/with-callback/clear-recursive-timeout.ts
+++ b/src/with-callback/clear-recursive-timeout.ts
@@ -1,5 +1,5 @@
 import type { RecursiveTimeout, ArgsShape } from './recursive-timeout'
 
-export function clearRecursiveTimeout(timeout: RecursiveTimeout<ArgsShape>): void {
-  timeout.clear()
+export function clearRecursiveTimeout(recursive: RecursiveTimeout<ArgsShape>): void {
+  recursive.clear()
 }
diff --git a/src/with-callback/create-recursive-timeout.spec.ts b/src/with-callback/create-recursive-timeout.spec.ts
index 33df14c..131cf02 100644
--- a/src/with-callback/create-recursive-timeout.spec.ts
+++ b/src/with-callback/create-recursive-timeout.spec.ts
@@ -4,11 +4,11 @@ import { RecursiveTimeout } from './recursive-timeout'
 
 describe(createRecursiveTimeout, () => {
   it('should create an instance of RecursiveTimeout class', () => {
-    const timeout = createRecursiveTimeout(() => {}, 10_000)
+    const recursive = createRecursiveTimeout(() => {}, 10_000)
 
-    expect(timeout).toBeInstanceOf(RecursiveTimeout)
+    expect(recursive).toBeInstanceOf(RecursiveTimeout)
 
-    timeout.clear()
+    recursive.clear()
   })
 
   it('should schedule next call only after the current call is finished', async () => {
@@ -21,11 +21,11 @@ describe(createRecursiveTimeout, () => {
       return Date.now()
     })
 
-    const timeout = createRecursiveTimeout(longJob, 50)
+    const recursive = createRecursiveTimeout(longJob, 50)
 
     await delay(300) // I can't use fake timers, unfortunately
 
-    timeout.clear()
+    recursive.clear()
 
     expect(longJob).toHaveBeenCalledTimes(2)
 
diff --git a/src/with-callback/recursive-timeout.spec.ts b/src/with-callback/recursive-timeout.spec.ts
index 83e0bf6..eb96b40 100644
--- a/src/with-callback/recursive-timeout.spec.ts
+++ b/src/with-callback/recursive-timeout.spec.ts
@@ -13,12 +13,44 @@ describe(RecursiveTimeout, () => {
     ['clearInterval', clearInterval],
     ['clearTimeout', clearTimeout],
   ])('should be cancellable with %s', async (clearName, clear) => {
-    const timeout = createRecursiveTimeout(callback, 100)
+    const recursive = createRecursiveTimeout(callback, 100)
 
-    clear(timeout)
+    clear(recursive)
 
     await delay(150)
 
     expect(callback).not.toHaveBeenCalled()
   })
+
+  it('should allow delaying the call by refreshing the timeout instance', async () => {
+    const recursive = createRecursiveTimeout(callback, 200)
+
+    for (let i = 0; i < 3; i += 1) {
+      await delay(100)
+
+      recursive.refresh()
+    }
+
+    expect(callback).not.toHaveBeenCalled()
+
+    await delay(200 + 10)
+
+    clearTimeout(recursive)
+
+    expect(callback).toHaveBeenCalledTimes(1)
+  })
+
+  it('should show whether it is ref-ed or not', () => {
+    const recursive = createRecursiveTimeout(callback, 100)
+
+    expect(recursive.hasRef()).toBe(true)
+
+    for (const [methodName, hasRefExpected] of [['unref', false], ['ref', true]] as const) {
+      recursive[methodName]()
+
+      expect(recursive.hasRef()).toBe(hasRefExpected)
+    }
+
+    recursive.unref() // let it all go
+  })
 })
diff --git a/src/with-callback/recursive-timeout.ts b/src/with-callback/recursive-timeout.ts
index 84a362b..7a18738 100644
--- a/src/with-callback/recursive-timeout.ts
+++ b/src/with-callback/recursive-timeout.ts
@@ -29,6 +29,7 @@ export class RecursiveTimeout<Args extends ArgsShape> implements NodeJS.Timeout
       // we're naming the tick function the same as the original callback
       [this.callback.name]: () => {
         this.callback(...this.args)
+        this.clear()
         this.setTimer(tick)
       },
     }
diff --git a/src/with-promises/clear-recursive-timeout.ts b/src/with-promises/clear-recursive-timeout.ts
index d5d86e0..6e20da8 100644
--- a/src/with-promises/clear-recursive-timeout.ts
+++ b/src/with-promises/clear-recursive-timeout.ts
@@ -1,5 +1,5 @@
 import type { RecursiveTimeout, ArgsShape } from './recursive-timeout'
 
-export function clearRecursiveTimeout(timeout: RecursiveTimeout<ArgsShape>): void {
-  timeout.clear()
+export function clearRecursiveTimeout(recursive: RecursiveTimeout<ArgsShape>): void {
+  recursive.clear()
 }