From 509e547a84c29156298040229126bf9e2f4f26c7 Mon Sep 17 00:00:00 2001
From: ppcvote <risky9763@gmail.com>
Date: Sun, 23 Aug 2026 19:35:42 +0800
Subject: [PATCH 1/2] fix(search): settle bulkPut when an IndexedDB write fails

TableWrapper.bulkPut ran its work inside an async Promise executor with no
reject, so a rejected chunk write settled the executor's own promise rather
than the returned one. The promise never settled at all. SearchService's
cold-cache path waits on it behind `while (!searchServiceIsLoaded)`, so the
parsing spinner stays up for good, and the .catch already written for that
path in index.js could not run because nothing ever rejected.

Signed-off-by: ppcvote <risky9763@gmail.com>
---
 .../__tests__/indexed-db-wrapper.test.js      | 25 ++++++++++++
 attack-search/src/indexed-db-wrapper.js       | 39 +++++++++++--------
 2 files changed, 47 insertions(+), 17 deletions(-)

diff --git a/attack-search/__tests__/indexed-db-wrapper.test.js b/attack-search/__tests__/indexed-db-wrapper.test.js
index 51e4727b3fc..2b379212209 100644
--- a/attack-search/__tests__/indexed-db-wrapper.test.js
+++ b/attack-search/__tests__/indexed-db-wrapper.test.js
@@ -57,4 +57,29 @@ describe('IndexedDBWrapper', () => {
         const count = await contentDb.count();
         expect(count).toEqual(data.length);
     });
+
+    // A failed write must settle the promise. Racing against a sentinel tells a
+    // rejection apart from a promise that never settles at all, which a plain
+    // rejects assertion cannot do: it would time out and look like a slow test.
+    const settle = (promise) => Promise.race([
+        promise.then(() => 'resolved', (error) => `rejected:${error.message}`),
+        new Promise((resolve) => setTimeout(() => resolve('HUNG'), 1000)),
+    ]);
+
+    test('Bulk put rejects when the underlying write fails', async () => {
+        jest.spyOn(contentDb.indexeddb[contentDb.tableName], 'bulkPut')
+            .mockRejectedValue(new Error('QuotaExceededError'));
+
+        await expect(settle(contentDb.bulkPut(data))).resolves.toBe('rejected:QuotaExceededError');
+    });
+
+    test('Bulk put rejects when a later chunk fails', async () => {
+        let calls = 0;
+        jest.spyOn(contentDb.indexeddb[contentDb.tableName], 'bulkPut')
+            .mockImplementation(() => (++calls === 2
+                ? Promise.reject(new Error('DatabaseClosedError'))
+                : Promise.resolve()));
+
+        await expect(settle(contentDb.bulkPut(data, 1))).resolves.toBe('rejected:DatabaseClosedError');
+    });
 });
diff --git a/attack-search/src/indexed-db-wrapper.js b/attack-search/src/indexed-db-wrapper.js
index df24f3ff08b..9ac1400b02a 100644
--- a/attack-search/src/indexed-db-wrapper.js
+++ b/attack-search/src/indexed-db-wrapper.js
@@ -23,7 +23,7 @@ class TableWrapper {
      */
     async bulkPut(data, chunkSize = 100) {
 
-        return new Promise(async (resolve) => {
+        return new Promise((resolve, reject) => {
             /**
              * Schedules work using requestIdleCallback if supported, or setTimeout as a fallback.
              * @param {Function} callback - The function to be executed when the browser is idle or after the specified delay.
@@ -44,23 +44,28 @@ class TableWrapper {
              * @param {number} start - The index of the first item in the data array to be included in the current chunk.
              */
             const putChunk = async (start) => {
-                // If all data has been processed, resolve the promise
-                if (start >= data.length) {
-                    resolve();
-                    return;
+                try {
+                    // If all data has been processed, resolve the promise
+                    if (start >= data.length) {
+                        resolve();
+                        return;
+                    }
+
+                    // Determine the end index for the current chunk
+                    const end = Math.min(start + chunkSize, data.length);
+
+                    // Extract the chunk from the data array
+                    const chunk = data.slice(start, end);
+
+                    // Insert the chunk into the IndexedDB table
+                    await this.indexeddb[this.tableName].bulkPut(chunk);
+
+                    // Schedule the next chunk to be processed
+                    scheduleWork(() => putChunk(end));
+                } catch (error) {
+                    // Nothing else settles this promise, so callers would wait forever.
+                    reject(error);
                 }
-
-                // Determine the end index for the current chunk
-                const end = Math.min(start + chunkSize, data.length);
-
-                // Extract the chunk from the data array
-                const chunk = data.slice(start, end);
-
-                // Insert the chunk into the IndexedDB table
-                await this.indexeddb[this.tableName].bulkPut(chunk);
-
-                // Schedule the next chunk to be processed
-                scheduleWork(() => putChunk(end));
             };
 
             // Start processing the data array by inserting the first chunk

From 7742c5cc78fdd7410c2cdd7a52d63fda96b5cb38 Mon Sep 17 00:00:00 2001
From: ppcvote <risky9763@gmail.com>
Date: Mon, 24 Aug 2026 02:24:50 +0800
Subject: [PATCH 2/2] docs(changelog): note the bulkPut settle fix

Signed-off-by: ppcvote <risky9763@gmail.com>
---
 CHANGELOG.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2039c128b43..d34f790ff57 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Website Changelog
 
+## Unreleased
+
+### Bug Fixes
+
+* Settle the search index write when an IndexedDB write fails, instead of leaving the promise pending and the search spinner up.
+
 ## v5.0.0 (2026-08-06)
 
 * Release ATT&CK content version 19.2.