fix: prevent header toggle race condition causing DNR rules desync

Author: Kirill Lebedenko

src/entities/is-paused/model.ts

@@ -19,7 +19,10 @@ export const $isPaused = createStore<boolean>(false)
   .on(toggleIsPaused, state => !state)
   .on(loadIsPausedFromStorageFx.doneData, (_, isPaused) => Boolean(isPaused));
 
+// Save isPaused only on explicit user action (toggleIsPaused), not on initial load from storage.
+// This prevents a save→onChanged→apply cycle when loading from storage.
 sample({
+  clock: toggleIsPaused,
   source: $isPaused,
   target: saveIsPausedToStorageFx,
 });

src/entities/request-profile/model/selected-request-profile.ts

@@ -14,6 +14,13 @@ export const $selectedRequestProfile = createStore<string>('').on(
 
 const loadSelectedProfileFromStorageFx = createEffect(loadSelectedProfileFromStorageApi);
 
-sample({ source: $selectedRequestProfile, target: saveSelectedProfileToBrowserFx });
+// Save selected profile only on explicit user action, not on initial load from storage.
+// This prevents a save→onChanged→apply cycle when loading from storage.
+sample({
+  clock: selectedRequestProfileIdChanged,
+  source: $selectedRequestProfile,
+  target: saveSelectedProfileToBrowserFx,
+});
+
 sample({ clock: loadSelectedProfileFromStorage, target: loadSelectedProfileFromStorageFx });
 sample({ clock: loadSelectedProfileFromStorageFx.doneData, target: $selectedRequestProfile });

src/shared/utils/headersConfigMeta.ts

@@ -29,25 +29,47 @@ function normalizeMeta(value: unknown): HeadersConfigMeta {
   return { seq: 0, updatedAt: 0 };
 }
 
-export async function bumpHeadersConfigMeta(): Promise<HeadersConfigMeta> {
+/**
+ * Queue to serialize storage writes and prevent race conditions.
+ * Without this queue, rapid toggles can cause:
+ * 1. Multiple concurrent reads of the same `seq` value
+ * 2. Multiple writes with the same incremented `seq`
+ * 3. Background script skipping updates because `isNewerMeta` returns false
+ */
+let writeQueue: Promise<void> = Promise.resolve();
+
+async function bumpHeadersConfigMeta(): Promise<HeadersConfigMeta> {
   const current = await browser.storage.local.get([BrowserStorageKey.HeadersConfigMeta]);
   const prev = normalizeMeta(current[BrowserStorageKey.HeadersConfigMeta]);
 
   // Ensure monotonicity even if system clock moves backwards or updates are very close.
   const now = Date.now();
   const nextUpdatedAt = Math.max(now, prev.updatedAt + 1);
 
-  // Best-effort monotonic seq. It can race across concurrent writers; updatedAt remains authoritative.
+  // Monotonic seq - now guaranteed by queue serialization.
   const nextSeq = prev.seq + 1;
 
   return { seq: nextSeq, updatedAt: nextUpdatedAt };
 }
 
 export async function setWithBumpedHeadersConfigMeta(patch: Record<string, unknown>) {
-  const meta = await bumpHeadersConfigMeta();
-  await browser.storage.local.set({
-    ...patch,
-    [BrowserStorageKey.HeadersConfigMeta]: meta,
+  // Chain this write operation onto the queue to ensure serialization.
+  // This prevents race conditions where concurrent calls read the same `seq`
+  // and write the same incremented value.
+  const result = writeQueue.then(async () => {
+    const meta = await bumpHeadersConfigMeta();
+    await browser.storage.local.set({
+      ...patch,
+      [BrowserStorageKey.HeadersConfigMeta]: meta,
+    });
+    return meta;
   });
-  return meta;
+
+  // Update queue to wait for this operation (ignore errors for queue chaining)
+  writeQueue = result.then(
+    () => {},
+    () => {},
+  );
+
+  return result;
 }