WORKSPACES-INIT (factory iter 2): clear _initPromise in try/finally so cache-reset triggers a real reload

bg/workspaces.js _init() guarded the cold-start race via _initPromise
but only cleared it on FAILURE (in the .catch handler). After a
successful init, _initPromise retained a resolved-promise reference
forever. Two concrete issues:

  1. Memory: one orphan resolved-promise per WorkspaceManager instance
     across the SW lifetime. Cosmetic.
  2. Functional: a subsequent `this._cache = null` (factory reset,
     test isolation) intends to force a fresh load on the next _init.
     Pre-fix, the next _init hit `if (!this._initPromise) ...`,
     found the stale resolved promise still cached, awaited it
     (no-op since it was already settled), and returned WITHOUT
     re-reading from chrome.storage.local. The cache stayed null —
     subsequent reads crashed via `this._cache!.list`.

Fix: mirror the modules/storage.js init pattern — wrap the await in
try/finally that clears _initPromise on both success and failure.

  async _init() {
    if (this._cache !== null) return;
    if (!this._initPromise) {
      this._initPromise = (async () => { ... })();
    }
    try {
      return await this._initPromise;
    } finally {
      this._initPromise = null;
    }
  }

3 new regression cases in tests/workspaces.test.js:
  - clears _initPromise after successful init
  - clears _initPromise after failed init
  - null-ing _cache forces a real storage reload on the next _init
    (would have failed on the pre-fix implementation)

45 test files, 769 cases green, tsc strict clean.

Author: SysAdminDoc

bg/workspaces.js

@@ -8,19 +8,25 @@ const WorkspaceManager = {
   async _init() {
     if (this._cache !== null) return;
     // Serialize concurrent cold-start callers so a late-resolving get()
-    // can't clobber mutations already applied to _cache by an earlier caller.
+    // can't clobber mutations already applied to _cache by an earlier
+    // caller. WORKSPACES-INIT — clear _initPromise in a try/finally on
+    // BOTH success and failure (mirrors modules/storage.js init pattern).
+    // Without the success-side clear, a test or factory-reset that nulls
+    // _cache to force a reload would see the stale resolved promise and
+    // no-op without re-loading from storage.
     if (!this._initPromise) {
       this._initPromise = (async () => {
         const data = await chrome.storage.local.get('workspaces');
         if (this._cache === null) {
           this._cache = data.workspaces || { active: null, list: [] };
         }
-      })().catch(e => {
-        this._initPromise = null;
-        throw e;
-      });
+      })();
+    }
+    try {
+      return await this._initPromise;
+    } finally {
+      this._initPromise = null;
     }
-    return this._initPromise;
   },
 
   async _save() {

tests/workspaces.test.js

@@ -188,4 +188,40 @@ describe('WorkspaceManager', () => {
 
     expect((await WorkspaceManager.getAll()).list[0].snapshot.s1).toBe(true);
   });
+
+  // WORKSPACES-INIT — _initPromise must clear on BOTH success and failure
+  // so a subsequent _cache null-out (factory reset, test isolation) gets a
+  // fresh storage load. Pre-fix the resolved promise stuck around forever,
+  // and any caller after `_cache = null` saw the stale promise and no-op'd.
+  describe('WORKSPACES-INIT — _initPromise lifecycle', () => {
+    it('clears _initPromise after successful init', async () => {
+      await WorkspaceManager.getAll();  // triggers _init
+      expect(WorkspaceManager._initPromise).toBeNull();
+    });
+
+    it('clears _initPromise after failed init', async () => {
+      chrome.storage.local.get.mockRejectedValueOnce(new Error('STORAGE_FAIL'));
+      await expect(WorkspaceManager.getAll()).rejects.toThrow('STORAGE_FAIL');
+      expect(WorkspaceManager._initPromise).toBeNull();
+    });
+
+    it('null-ing _cache forces a real storage reload on the next _init', async () => {
+      // Seed storage; cache populates from it.
+      chrome.storage.local.set({ workspaces: { active: null, list: [{ id: 'ws1', name: 'First' }] } });
+      const r1 = await WorkspaceManager.getAll();
+      expect(r1.list).toHaveLength(1);
+      expect(r1.list[0].name).toBe('First');
+
+      // Mutate storage out-of-band, null the cache to force a reload.
+      chrome.storage.local.set({ workspaces: { active: null, list: [{ id: 'ws2', name: 'Second' }] } });
+      WorkspaceManager._cache = null;
+
+      // Pre-fix: this would return the OLD cached value because
+      // _initPromise still pointed at a resolved (now stale) promise
+      // and short-circuited the storage re-read.
+      const r2 = await WorkspaceManager.getAll();
+      expect(r2.list).toHaveLength(1);
+      expect(r2.list[0].name).toBe('Second');
+    });
+  });
 });