@@ -87,12 +87,7 @@ class QueueManagerSingleton {
 
     this.#validateConfig(config)
 
-    for (const [name, adapter] of this.#adapterInstances) {
-      debug('destroying adapter "%s" before reinitialization', name)
-      await adapter.destroy()
-    }
-
-    this.#adapterInstances.clear()
+    await this.#cleanupBeforeReinitialization()
 
     this.#defaultAdapter = config.default
     this.#adapters = config.adapters
@@ -116,6 +111,47 @@ class QueueManagerSingleton {
     return this
   }
 
+  /**
+   * Destroy any materialized adapters from the current configuration before
+   * replacing it with a new one.
+   */
+  async #cleanupBeforeReinitialization() {
+    const destroyedAdapters = new Set<Adapter>()
+
+    await this.#destroyAdapters(this.#adapterInstances, destroyedAdapters)
+
+    if (this.#fakeState) {
+      await this.#destroyAdapter('fake', this.#fakeState.fakeAdapter, destroyedAdapters)
+      await this.#destroyAdapters(this.#fakeState.adapterInstances, destroyedAdapters)
+      this.#fakeState = undefined
+    }
+
+    this.#adapterInstances.clear()
+  }
+
+  /**
+   * Destroy a collection of adapters while avoiding double-destroying the same
+   * instance through multiple references.
+   */
+  async #destroyAdapters(adapters: Iterable<[string, Adapter]>, destroyedAdapters: Set<Adapter>) {
+    for (const [name, adapter] of adapters) {
+      await this.#destroyAdapter(name, adapter, destroyedAdapters)
+    }
+  }
+
+  /**
+   * Destroy a single adapter once for the current cleanup pass.
+   */
+  async #destroyAdapter(name: string, adapter: Adapter, destroyedAdapters: Set<Adapter>) {
+    if (destroyedAdapters.has(adapter)) {
+      return
+    }
+
+    destroyedAdapters.add(adapter)
+    debug('destroying adapter "%s" before reinitialization', name)
+    await adapter.destroy()
+  }
+
   /**
    * Get an adapter instance by name.
    *
 
@@ -238,4 +238,69 @@ test.group('QueueManager', () => {
     assert.strictEqual(secondAdapter, adapters[1])
     assert.equal(destroyedCount, 1)
   })
+
+  test('should reset fake state when reinitializing', async ({ assert, cleanup }) => {
+    type LabeledAdapter = Adapter & { label: string }
+
+    const createAdapter = (label: string): LabeledAdapter => ({
+      label,
+      setWorkerId() {},
+      pop: async () => null,
+      popFrom: async () => null,
+      recoverStalledJobs: async () => 0,
+      completeJob: async () => {},
+      failJob: async () => {},
+      retryJob: async () => {},
+      getJob: async () => null,
+      push: async () => {},
+      pushOn: async () => {},
+      pushLater: async () => {},
+      pushLaterOn: async () => {},
+      pushMany: async () => {},
+      pushManyOn: async () => {},
+      size: async () => 0,
+      sizeOf: async () => 0,
+      destroy: async () => {},
+      upsertSchedule: async () => 'schedule-id',
+      createSchedule: async () => 'schedule-id',
+      getSchedule: async () => null,
+      listSchedules: async () => [],
+      updateSchedule: async () => {},
+      deleteSchedule: async () => {},
+      claimDueSchedule: async () => null,
+    })
+
+    cleanup(async () => {
+      await QueueManager.destroy()
+    })
+
+    await QueueManager.init({
+      default: 'custom',
+      adapters: {
+        custom: () => createAdapter('first'),
+      },
+    })
+
+    const firstAdapter = QueueManager.use() as LabeledAdapter
+    const firstFakeAdapter = QueueManager.fake()
+
+    await QueueManager.init({
+      default: 'custom',
+      adapters: {
+        custom: () => createAdapter('second'),
+      },
+    })
+
+    const secondFakeAdapter = QueueManager.fake()
+
+    assert.notStrictEqual(secondFakeAdapter, firstFakeAdapter)
+    assert.strictEqual(QueueManager.use(), secondFakeAdapter)
+
+    QueueManager.restore()
+
+    const restoredAdapter = QueueManager.use() as LabeledAdapter
+
+    assert.notStrictEqual(restoredAdapter, firstAdapter)
+    assert.equal(restoredAdapter.label, 'second')
+  })
 })