codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/backgroundBootstrapMigration.js

@@ -0,0 +1,181 @@
+(function initBootstrapMigration(root) {
+  'use strict';
+
+  const UPDATE_STATE_KEY = 'codex-overleaf-managed-update-state-v1';
+  const RETRY_ALARM = 'codex-overleaf-bootstrap-migration-retry';
+  const RETRY_MS = 4000;
+  const MAX_WAIT_MS = 2 * 60 * 1000;
+  let readyPromise;
+  let lockedOwner;
+  let setExecutionLocked;
+
+  function init(options) {
+    if (readyPromise) return readyPromise;
+    readyPromise = prepare(options);
+    return readyPromise;
+  }
+
+  async function prepare(options) {
+    let transaction;
+    let reloadProtected = false;
+    let rollbackState = 'bootstrap_pending';
+    const revision = String(root.__CODEX_OVERLEAF_BOOTSTRAP_REVISION__ || '');
+    const request = async (method, params = {}) => {
+      const response = await options.request({ id: crypto.randomUUID(), method,
+        params: { ...params, bootstrapRevision: revision } });
+      if (!response?.ok) throw Object.assign(new Error(response?.error?.message || 'Managed update request failed.'),
+        { code: response?.error?.code || 'update_health_failed' });
+      return response.result || {};
+    };
+    try {
+      const status = await request('update.status');
+      transaction = status.transaction;
+      if (transaction?.state !== 'bootstrap_pending') return { continueInitialization: true };
+      options.setExecutionLocked(true);
+      lockedOwner = { id: transaction.id, targetVersion: transaction.targetVersion, revision };
+      setExecutionLocked = options.setExecutionLocked;
+      if (!transaction.id || transaction.targetVersion !== root.CodexOverleafCompatibility?.BUILD_TARGET_VERSION) {
+        throw codedError('The running update does not match the pending Bootstrap transaction.');
+      }
+      reloadProtected = await options.protectReloadTabs(transaction);
+      if (!reloadProtected) throw codedError('The previous page refresh list could not be protected.');
+      await writeState({ state: 'awaiting_health', transactionId: transaction.id,
+        latestVersion: transaction.targetVersion, code: '', message: '' });
+
+      // The first reload may leave old content contexts alive. Recheck the same
+      // idle/save contract before replacing their loader and reloading again.
+      const deadline = Date.now() + MAX_WAIT_MS;
+      while (true) {
+        const gate = await options.verifySafety({ transactionId: transaction.id, targetVersion: transaction.targetVersion,
+          sourceVersion: transaction.sourceVersion, expectedState: 'bootstrap_pending' });
+        if (gate?.ok) break;
+        if (Date.now() >= deadline) throw codedError('The Bootstrap update did not reach a safe point.');
+        await writeState({ blockers: gate?.error?.blockers || ['busy'] });
+        await waitForRetry();
+        const refreshed = await request('update.status');
+        if (refreshed.transaction?.id !== transaction.id || refreshed.transaction?.state !== 'bootstrap_pending') {
+          throw Object.assign(codedError('The pending Bootstrap transaction changed before activation.'), { restoredStatus: refreshed });
+        }
+      }
+
+      const result = await request('update.bootstrap', { transactionId: transaction.id });
+      if (result.transactionId !== transaction.id || result.targetVersion !== transaction.targetVersion) {
+        throw codedError('The Bootstrap activation result does not match the pending update.');
+      }
+      await writeState({ blockers: [], blocker: '' });
+      if (result.state === 'reload_required') {
+        // Only one reload per worker. Native owns the persistent attempt limit
+        // so a broken target cannot create a loop across worker restarts.
+        chrome.runtime.reload();
+        return { continueInitialization: false, state: result.state };
+      }
+      if (result.state !== 'awaiting_health' || revision !== '3.1' || result.bootstrapRevision !== revision) {
+        throw codedError('The updated Bootstrap did not provide its loaded revision.');
+      }
+      rollbackState = 'awaiting_health';
+      if (!await options.releaseReloadTabs(transaction, 'awaiting_health')) throw codedError('The original page identities could not be confirmed.');
+      return { continueInitialization: true, state: result.state };
+    } catch (error) {
+      if (!transaction || transaction.state !== 'bootstrap_pending') return { continueInitialization: true };
+      if (!reloadProtected) {
+        await writeState({ state: 'failed', recoveryPending: true, code: 'update_recovery_pending' }).catch(() => {});
+        return { continueInitialization: false, state: 'failed' };
+      }
+      const code = /^[a-z0-9_]{1,80}$/.test(error?.code || '') ? error.code : 'update_health_failed';
+      await writeState({ state: 'rolling_back', code }).catch(() => {});
+      let restored = false;
+      try {
+        let status = error.restoredStatus;
+        let rollback = status && { transactionId: status.transaction?.id, state: status.transaction?.state,
+          version: status.activeVersion, restoredPair: status.restoredPair };
+        if (!hasRestoredSource(transaction, rollback, status)) {
+          rollback = await request('update.rollback', { transactionId: transaction.id,
+            expectedState: rollbackState, reasonCode: code });
+          status = await request('update.status');
+        }
+        if (!hasRestoredSource(transaction, rollback, status)) throw codedError('Bootstrap rollback is unconfirmed.');
+        await writeState({ state: 'rolled_back', currentVersion: transaction.sourceVersion,
+          transactionId: transaction.id, recoveryPending: false, blockers: [], blocker: '', code });
+        restored = true;
+        while (true) {
+          try {
+            // A new document must never inherit the old document's refresh
+            // authorization. The source worker sees an empty legacy list;
+            // the guarded evidence remains for a later natural/user refresh.
+            if (await options.hasReplacedReloadDocument(transaction)) break;
+            const gate = await options.verifySafety({ transactionId: transaction.id, targetVersion: transaction.targetVersion,
+              sourceVersion: transaction.sourceVersion, expectedState: 'rolled_back' });
+            if (gate?.ok && await options.releaseReloadTabs(transaction, 'rolled_back')) break;
+          } catch (_) { /* Restored files stay restored while a page probe retries. */ }
+          await waitForRetry();
+        }
+        chrome.runtime.reload();
+        return { continueInitialization: false, state: 'rolled_back' };
+      } catch (_rollbackError) {
+        if (restored) return { continueInitialization: false, state: 'rolled_back' };
+        await writeState({ state: 'failed', recoveryPending: true, transactionId: transaction.id,
+          code: 'update_recovery_pending', message: 'The installed update result has not been confirmed.' }).catch(() => {});
+        return { continueInitialization: false, state: 'failed' };
+      }
+    } finally {
+      await chrome.alarms?.clear?.(RETRY_ALARM).catch?.(() => {});
+    }
+  }
+
+  async function writeState(patch) {
+    const stored = await chrome.storage.local.get(UPDATE_STATE_KEY);
+    const state = root.CodexOverleafManagedUpdateProjection.transition(stored[UPDATE_STATE_KEY] || {}, patch,
+      { currentVersion: chrome.runtime.getManifest().version });
+    await chrome.storage.local.set({ [UPDATE_STATE_KEY]: state });
+  }
+
+  function waitForRetry() {
+    return new Promise(resolve => {
+      let settled = false;
+      let timer;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        chrome.alarms?.onAlarm?.removeListener?.(onAlarm);
+        resolve();
+      };
+      const onAlarm = alarm => { if (alarm?.name === RETRY_ALARM) finish(); };
+      chrome.alarms?.onAlarm?.addListener?.(onAlarm);
+      chrome.alarms?.create?.(RETRY_ALARM, { delayInMinutes: 0.5 });
+      timer = setTimeout(finish, RETRY_MS);
+    });
+  }
+
+  function hasRestoredSource(transaction, rollback, status) {
+    const pair = status?.restoredPair;
+    return rollback?.transactionId === transaction.id && rollback.state === 'rolled_back'
+      && rollback.version === transaction.sourceVersion && status?.transaction?.id === transaction.id
+      && status.transaction.state === 'rolled_back' && status.activeVersion === transaction.sourceVersion
+      && status.installedAligned === true && pair?.extensionVersion === transaction.sourceVersion
+      && pair?.nativeVersion === transaction.sourceVersion
+      && /^[0-9a-f]{64}$/.test(pair.extensionSha256 || '') && /^[0-9a-f]{64}$/.test(pair.nativeSha256 || '')
+      && /^[0-9a-f]{64}$/.test(pair.bootstrapSha256 || '')
+      && ['extensionVersion', 'nativeVersion', 'extensionSha256', 'nativeSha256', 'bootstrapSha256']
+        .every(key => pair[key] === rollback.restoredPair?.[key]);
+  }
+
+  function codedError(message) {
+    return Object.assign(new Error(message), { code: 'update_health_failed' });
+  }
+
+  function observeConfirmation(params, response) {
+    if (!lockedOwner || !response?.ok || response.result?.state !== 'committed'
+      || response.result.version !== lockedOwner.targetVersion || params?.transactionId !== lockedOwner.id
+      || params.extensionVersion !== lockedOwner.targetVersion || params.nativeVersion !== lockedOwner.targetVersion
+      || params.bootstrapRevision !== lockedOwner.revision || lockedOwner.revision !== '3.1') return;
+    lockedOwner = null;
+    setExecutionLocked(false);
+  }
+
+  root.CodexOverleafBootstrapMigration = Object.freeze({
+    init,
+    observeConfirmation,
+    ready: () => readyPromise || Promise.resolve({ continueInitialization: true })
+  });
+})(globalThis);

package/extension/src/backgroundSharedSessions.js

@@ -0,0 +1,440 @@
+(function (root, factory) {
+  const api = factory(typeof module === 'object' && module.exports
+    ? require('./shared/sharedSessionTransfer') : root.CodexOverleafSharedSessionTransfer);
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafSharedSessionsBackground = api;
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (Transfer) {
+  'use strict';
+  const MESSAGE = 'codex-overleaf/shared-sessions-v1';
+  const LOCK_PORT = 'codex-overleaf/shared-session-lock-v1';
+  const REVIEW_LEASE_PREFIX = 'codex-overleaf-review-lease-v1:';
+  const CHANGE_KEY = 'codex-overleaf-shared-sessions-changed-v1';
+  const HOSTS = ['overleaf.com', 'www.overleaf.com', 'cn.overleaf.com'];
+  const META_PREFIX = 'codex-overleaf-scoped-persistence-v1:';
+  const MAX_BYTES = 8 * 1024 * 1024;
+  const own = (value, key) => Object.prototype.hasOwnProperty.call(value || {}, key);
+  const clone = value => value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+  const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  const failure = (code, message) => Object.assign(new Error(message), { code });
+  function part(value) {
+    if (typeof value !== 'string' || !value.trim() || value.length > 256 || /[\0\r\n]/.test(value))
+      throw failure('shared_store_scope_invalid', 'The shared session identity is invalid.');
+    return value;
+  }
+  function scope(input) {
+    return { accountScopeId: part(input?.accountScopeId), projectId: typeof input?.projectId === 'string' ? input.projectId : '', ...(input?.runId ? { runId: part(input.runId) } : {}) };
+  }
+  function keyFor(kind, value) {
+    return kind === 'review' ? 'review:' + JSON.stringify([value.accountScopeId, part(value.projectId), part(value.runId)])
+      : kind === 'preferences' ? 'preferences'
+      : 'state:' + encodeURIComponent(value.accountScopeId);
+  }
+  function metaKey(value) {
+    return META_PREFIX + encodeURIComponent(value.accountScopeId) + ':' + encodeURIComponent(value.projectId);
+  }
+
+  // Three-way merge preserves changes made by another tab to untouched fields.
+  // Conflicting edits fail closed; removed records are never silently revived.
+  function mergeValue(base, current, incoming, field = '') {
+    if (equal(incoming, base)) return clone(current);
+    if (equal(current, base) || equal(current, incoming)) return clone(incoming);
+    if (field === 'updatedAt' || field === 'lastActivityAt')
+      return (Date.parse(current) || 0) >= (Date.parse(incoming) || 0) ? current : incoming;
+    if (Array.isArray(base) && Array.isArray(current) && Array.isArray(incoming)) {
+      if (['runs', 'pendingInputs'].includes(field)
+        && [base, current, incoming].every(items => items.every(item => item && typeof item.id === 'string')
+          && new Set(items.map(item => item.id)).size === items.length)) {
+        const before = new Map(base.map(item => [item.id, item]));
+        const latest = new Map(current.map(item => [item.id, item]));
+        const proposed = new Map(incoming.map(item => [item.id, item]));
+        const ids = [...current.map(item => item.id), ...incoming.map(item => item.id).filter(id => !latest.has(id))];
+        return ids.map(id => mergeValue(before.get(id), latest.get(id), proposed.get(id)))
+          .filter(item => item !== undefined);
+      }
+      const extendsBase = items => items.length >= base.length && base.every((item, i) => equal(item, items[i]));
+      if (extendsBase(current) && extendsBase(incoming)) {
+        const result = clone(current), seen = new Set(result.map(item => JSON.stringify(item)));
+        for (const item of incoming.slice(base.length)) {
+          const key = JSON.stringify(item);
+          if (!seen.has(key)) { result.push(clone(item)); seen.add(key); }
+        }
+        return result;
+      }
+    }
+    if (base && current && incoming && !Array.isArray(base) && !Array.isArray(current) && !Array.isArray(incoming)
+      && [base, current, incoming].every(value => typeof value === 'object')) {
+      const result = {};
+      for (const key of new Set([...Object.keys(base), ...Object.keys(current), ...Object.keys(incoming)])) {
+        if (key === 'sharedRevision') continue;
+        const value = mergeValue(base[key], current[key], incoming[key], key);
+        if (value !== undefined) Object.defineProperty(result, key, { value, enumerable: true, configurable: true, writable: true });
+      }
+      return result;
+    }
+    throw failure('shared_session_conflict', 'The same session was edited in another tab. Refresh its history before retrying; the local draft was kept.');
+  }
+
+  function createService(options = {}) {
+    const chromeApi = options.chromeApi, idb = options.indexedDB, ranges = options.IDBKeyRange;
+    const locks = new Map(), queues = new Map();
+    // Account-wide writes serialize cross-project clears and shared preference saves.
+    // IndexedDB transactions still provide the atomic boundary for session batches.
+    let opening;
+    function openDb() {
+      if (!opening) opening = new Promise((resolve, reject) => {
+        const request = idb.open('codex-overleaf-shared-sessions', 1);
+        request.onupgradeneeded = () => {
+          const db = request.result;
+          const sessions = db.createObjectStore('sessions', { keyPath: ['accountScopeId', 'id'] });
+          sessions.createIndex('account', 'accountScopeId');
+          sessions.createIndex('project', ['accountScopeId', 'projectId']);
+          db.createObjectStore('tombstones', { keyPath: ['accountScopeId', 'id'] });
+          db.createObjectStore('migrations', { keyPath: ['accountScopeId', 'origin'] });
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => { opening = null; reject(request.error); };
+      });
+      return opening;
+    }
+    const readRequest = request => new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+    const finished = tx => new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onabort = tx.onerror = () => reject(tx.error || failure('shared_store_transaction_failed', 'The shared session transaction failed.'));
+    });
+    async function readOne(store, key) {
+      const db = await openDb();
+      return readRequest(db.transaction(store, 'readonly').objectStore(store).get(key));
+    }
+    function senderOrigin(sender) {
+      const url = new URL(sender?.url || sender?.tab?.url || '');
+      if (sender?.id !== chromeApi.runtime.id || !sender.tab || (sender.frameId != null && sender.frameId !== 0)
+        || url.protocol !== 'https:' || !HOSTS.includes(url.hostname) || !/^\/project(?:\/|$)/.test(url.pathname))
+        throw failure('forbidden_sender', 'Shared sessions require an authorized Overleaf project page.');
+      return url.origin;
+    }
+    function ensureLock(message, value, sender) {
+      const held = locks.get(keyFor('state', value));
+      if (!held || held.disconnected || held.token !== message.lockToken || held.tabId !== sender.tab.id)
+        throw failure('storage_lock_lost', 'The shared persistence lock was lost.');
+    }
+    async function notify(value, clientId) {
+      // A missed refresh notification must not turn a committed write into a failure.
+      await chromeApi.storage.local.set({ [CHANGE_KEY]: {
+        accountScopeId: value.accountScopeId, projectId: value.projectId,
+        clientId, nonce: crypto.randomUUID(), at: Date.now()
+      } }).catch(() => {});
+    }
+    async function list(value, after = '') {
+      const db = await openDb();
+      return new Promise((resolve, reject) => {
+        const result = []; let bytes = 0, last = after;
+        const cursor = db.transaction('sessions', 'readonly').objectStore('sessions')
+          .openCursor(ranges.bound([value.accountScopeId, after], [value.accountScopeId, '\uffff'], Boolean(after), false));
+        cursor.onerror = () => reject(cursor.error);
+        cursor.onsuccess = () => {
+          const item = cursor.result;
+          if (!item) { resolve({ records: result, next: '' }); return; }
+          const stored = item.value;
+          if (value.projectId && stored.projectId !== value.projectId) { item.continue(); return; }
+          const record = { ...stored.record, sharedRevision: stored.revision };
+          const size = Transfer.byteLength(JSON.stringify(record));
+          if (result.length && (result.length >= 8 || bytes + size > MAX_BYTES)) {
+            resolve({ records: result, next: last }); return;
+          }
+          result.push(record); bytes += size; last = stored.id; item.continue();
+        };
+      });
+    }
+    async function legacyDeleted(record) {
+      const key = 'codexOverleafSessionTombstone:v2:' + encodeURIComponent(record.projectId) + ':' + encodeURIComponent(record.id);
+      const meta = metaKey(record);
+      const stored = await chromeApi.storage.local.get([key, meta, 'codexOverleafSessionTombstones']);
+      return Boolean(stored[key] || stored[meta]?.sessionTombstones?.[record.id]
+        || stored.codexOverleafSessionTombstones?.[record.projectId]?.includes(record.id));
+    }
+    function recoveryCopy(record, origin) {
+      const suffix = origin.replace(/^https:\/\//, '').replace(/\W/g, '-');
+      return { ...record, id: record.id.slice(0, 200) + ':recovered:' + suffix, codexThreadId: '', pendingInputs: [],
+        titleSource: 'manual', title: (record.title || 'Recovered session') + ' [' + suffix + ']',
+        runs: (record.runs || []).map(run => ({ ...run, forkSnapshot: true, codexThreadId: '',
+          status: run.status === 'running' ? 'interrupted' : run.status,
+          undoOperations: [], undoBaseFiles: [], undoExpectedFiles: [], undoTrackedChanges: [],
+          appliedOperations: [], trackedChangeCaptures: [], undoStatus: '' })) };
+    }
+    async function writeMany(message, value, importing, origin, sender) {
+      // Reject a lost owner before doing any bounded decompression work.
+      ensureLock(message, value, sender);
+      const entries = (await Transfer.decode(message)).map(entry => ({ record: clone(entry.record), base: clone(entry.base) }));
+      for (const { record, base } of entries) {
+        if (!record || record.accountScopeId !== value.accountScopeId || record.projectId !== value.projectId)
+          throw failure('shared_store_scope_mismatch', 'The session does not belong to the captured account and project.');
+        part(record.id); part(record.projectId);
+        delete record.sharedRevision;
+        if (base && (base.id !== record.id || base.accountScopeId !== value.accountScopeId || base.projectId !== value.projectId))
+          throw failure('shared_store_scope_mismatch', 'The session baseline belongs to a different scope.');
+      }
+      if (importing && await legacyDeleted(entries[0].record)) return [];
+      ensureLock(message, value, sender);
+      const db = await openDb();
+      // Recheck after opening the database; a disconnected owner cannot commit.
+      ensureLock(message, value, sender);
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(['sessions', 'tombstones', 'migrations'], 'readwrite');
+        const store = tx.objectStore('sessions'), deleted = tx.objectStore('tombstones');
+        const results = []; let caught;
+        const abort = error => { caught = error; tx.abort(); };
+        tx.oncomplete = () => resolve(results);
+        tx.onabort = tx.onerror = () => reject(caught || tx.error || failure('shared_store_write_failed', 'The session could not be saved.'));
+        const marker = tx.objectStore('migrations').get([value.accountScopeId, '*']);
+        marker.onsuccess = () => {
+          for (const entry of entries) {
+            if (marker.result?.clearedAt && (importing || (Date.parse(entry.record.createdAt) || 0) <= marker.result.clearedAt)) {
+              if (importing) continue;
+              abort(failure('shared_session_deleted', 'This history was cleared and cannot be restored by a stale tab.'));
+              return;
+            }
+            putAt(entry.record, entry.base);
+          }
+        };
+        function appendResult(record, revision) {
+          // Merge may grow beyond either input. Reject inside this transaction,
+          // before returning success or committing any sibling record.
+          Transfer.validateRecord(record);
+          const result = { ...record, sharedRevision: revision };
+          Transfer.validateResponse([...results, result]);
+          results.push(result);
+        }
+        function putAt(candidate, base, copy = false) {
+          const key = [value.accountScopeId, candidate.id];
+          const tombstone = deleted.get(key);
+          tombstone.onsuccess = () => {
+            if (tombstone.result) {
+              if (importing) return;
+              abort(failure('shared_session_deleted', 'This session was deleted in another tab.')); return;
+            }
+            const request = store.get(key);
+            request.onsuccess = () => {
+              try {
+                const existing = request.result;
+                if (existing && existing.projectId !== candidate.projectId)
+                  throw failure('shared_store_scope_mismatch', 'Session identity conflicts with another project.');
+                let next = candidate;
+                if (importing && existing) {
+                  if (equal(existing.record, candidate) || copy) {
+                    appendResult(existing.record, existing.revision); return;
+                  }
+                  putAt(recoveryCopy(candidate, origin), null, true); return;
+                }
+                if (existing) {
+                  if (!base) throw failure('shared_session_conflict', 'Reload the session before updating existing history.');
+                  // Keep the established first-durable-review-decision policy.
+                  const reviewed = options.mergeSessionReviewState?.(candidate, existing.record, message.reviewRunIds || []) || candidate;
+                  next = mergeValue(base, existing.record, reviewed);
+                } else if (base && !importing) {
+                  throw failure('shared_session_deleted', 'The session no longer exists.');
+                }
+                const revision = (existing?.revision || 0) + 1;
+                appendResult(next, revision);
+                store.put({ accountScopeId: value.accountScopeId, projectId: value.projectId,
+                  id: next.id, record: next, revision });
+              } catch (error) { abort(error); }
+            };
+          };
+        }
+      });
+    }
+    async function erase(value, id, all, message, sender) {
+      const db = await openDb();
+      ensureLock(message, value, sender);
+      const tx = db.transaction(['sessions', 'tombstones', 'migrations'], 'readwrite');
+      const done = finished(tx), sessions = tx.objectStore('sessions'), tombstones = tx.objectStore('tombstones');
+      if (id) {
+        const request = sessions.get([value.accountScopeId, id]);
+        request.onsuccess = () => {
+          const existing = request.result;
+          if (existing && value.projectId && existing.projectId !== value.projectId) { tx.abort(); return; }
+          tombstones.put({ accountScopeId: value.accountScopeId, id, deletedAt: Date.now() });
+          sessions.delete([value.accountScopeId, id]);
+        };
+      } else {
+        const cursor = sessions.index('account').openCursor(ranges.only(value.accountScopeId));
+        cursor.onsuccess = () => {
+          const item = cursor.result;
+          if (!item) return;
+          if (all || item.value.projectId === value.projectId) {
+            tombstones.put({ accountScopeId: value.accountScopeId, id: item.value.id, deletedAt: Date.now() });
+            item.delete();
+          }
+          item.continue();
+        };
+        if (all) tx.objectStore('migrations').put({ accountScopeId: value.accountScopeId, origin: '*', clearedAt: Date.now() });
+      }
+      await done;
+    }
+    const reviewLeaseKey = (key, token) => REVIEW_LEASE_PREFIX + key + ':' + token;
+    async function activeReviewLease(key) {
+      const prefix = REVIEW_LEASE_PREFIX + key + ':', records = await chromeApi.storage.local.get(null);
+      const active = [], expired = [];
+      for (const [id, lease] of Object.entries(records)) {
+        if (!id.startsWith(prefix)) continue;
+        const valid = lease && typeof lease.token === 'string' && lease.token.length > 0 && lease.token.length <= 256
+          && id === reviewLeaseKey(key, lease.token) && Number.isSafeInteger(lease.deadlineAt) && lease.deadlineAt > 0;
+        if (!valid) throw failure('review_lease_invalid', 'Undo ownership storage could not be verified.');
+        if (lease.deadlineAt > Date.now()) active.push(lease); else expired.push(id);
+      }
+      // Immutable token rows can only be removed by their exact expired key.
+      await Promise.all(expired.map(id => chromeApi.storage.local.remove(id).catch(() => {})));
+      return active.sort((a, b) => b.deadlineAt - a.deadlineAt)[0];
+    }
+    async function handle(message, sender) {
+      const origin = senderOrigin(sender), value = scope(message.scope);
+      const method = message.method;
+      if (method === 'review-dispatched') {
+        const key = keyFor('review', { ...value, runId: part(message.runId) }), held = locks.get(key);
+        if (!held || held.disconnected || held.token !== message.reviewToken || held.tabId !== sender.tab.id)
+          throw failure('storage_lock_lost', 'The shared Undo owner was lost before dispatch.');
+        const deadlineAt = held.deadlineAt || (held.deadlineAt = Date.now() + 120000);
+        held.inFlight += 1;
+        try {
+          await chromeApi.storage.local.set({ [reviewLeaseKey(key, held.token)]: { token: held.token, deadlineAt } });
+          if (held.disconnected) throw failure('storage_lock_lost', 'The shared Undo owner disconnected before dispatch.');
+          return { deadlineAt };
+        } finally { held.inFlight -= 1; if (held.disconnected && !held.inFlight) held.release(); }
+      }
+      if (method === 'review-owner') {
+        const key = keyFor('review', { ...value, runId: part(message.runId) });
+        const lease = await activeReviewLease(key);
+        return { busy: locks.has(key) || lease?.deadlineAt > Date.now(), deadlineAt: lease?.deadlineAt || 0 };
+      }
+      if (method === 'list') return list(value, typeof message.after === 'string' ? message.after : '');
+      if (method === 'get') {
+        const record = await readOne('sessions', [value.accountScopeId, part(message.id)]);
+        return record && (!value.projectId || value.projectId === record.projectId)
+          ? { ...record.record, sharedRevision: record.revision } : null;
+      }
+      if (method === 'migration-status') {
+        const cleared = await readOne('migrations', [value.accountScopeId, '*']);
+        return cleared?.clearedAt ? { complete: true, clearedAt: cleared.clearedAt }
+          : await readOne('migrations', [value.accountScopeId, origin]) || { complete: false };
+      }
+      if (method === 'migration-complete') {
+        ensureLock(message, value, sender);
+        const db = await openDb(), tx = db.transaction('migrations', 'readwrite'), done = finished(tx);
+        tx.objectStore('migrations').put({ ...value, origin, complete: true, at: Date.now() });
+        await done; return { complete: true };
+      }
+      if (method === 'put' || method === 'put-compressed' || method === 'import') {
+        const result = await writeMany(message, value, method === 'import', origin, sender);
+        if (result.length) await notify(value, message.clientId);
+        return result;
+      }
+      if (method === 'delete' || method === 'clear-project' || method === 'clear-account') {
+        if (method === 'clear-project') part(value.projectId);
+        await erase(value, method === 'delete' ? part(message.id) : '', method === 'clear-account', message, sender);
+        await notify(value, message.clientId); return true;
+      }
+      if (method === 'meta-read' || method === 'meta-write') {
+        const key = metaKey(value);
+        if (method === 'meta-read') return (await chromeApi.storage.local.get(key))[key] || {};
+        const held = locks.get(keyFor('state', value));
+        if (!held || held.token !== message.lockToken || held.tabId !== sender.tab.id)
+          throw failure('storage_lock_lost', 'The shared persistence lock was lost.');
+        await chromeApi.storage.local.set({ [key]: message.meta }); return message.meta;
+      }
+      throw failure('shared_store_method_invalid', 'Unsupported shared session operation.');
+    }
+    function connect(port) {
+      if (port.name !== LOCK_PORT) return;
+      try { senderOrigin(port.sender); } catch (_error) { port.disconnect(); return; }
+      let heldKey = '', job = null, closed = false;
+      function pump(key) {
+        if (locks.has(key)) return;
+        const queue = queues.get(key);
+        while (queue?.length) {
+          const next = queue.shift();
+          if (next.closed()) continue;
+          const token = crypto.randomUUID();
+          const held = { token, tabId: next.tabId, port: next.port, inFlight: 0, disconnected: false,
+            release() {
+              if (locks.get(key) !== held) return;
+              locks.delete(key); pump(key);
+            }
+          };
+          locks.set(key, held);
+          next.grant(token); return;
+        }
+        queues.delete(key);
+      }
+      port.onMessage.addListener(message => {
+        if (message?.type === 'release-review') {
+          const held = locks.get(heldKey);
+          if (held?.port !== port || held.token !== message.token || !heldKey.startsWith('review:')) return;
+          held.inFlight += 1;
+          void chromeApi.storage.local.remove(reviewLeaseKey(heldKey, held.token)).then(() => {
+            held.inFlight -= 1; held.release(); if (!closed) port.postMessage({ type: 'released' });
+          }, () => { held.inFlight -= 1; port.disconnect(); if (held.disconnected && !held.inFlight) held.release(); });
+          return;
+        }
+        if (message?.type === 'ping') { port.postMessage({ type: 'pong' }); return; }
+        if (message?.type !== 'acquire' || job) return;
+        try {
+          const value = scope(message.scope), kind = message.kind === 'review' ? 'review' : message.kind === 'preferences' ? 'preferences' : 'state';
+          heldKey = keyFor(kind, value);
+          if (kind === 'review' && locks.has(heldKey)) { port.postMessage({ type: 'busy' }); return; }
+          job = { port, tabId: port.sender.tab.id, closed: () => closed, grant: token => {
+            if (kind !== 'review') { port.postMessage({ type: 'granted', token }); return; }
+            const held = locks.get(heldKey); held.inFlight += 1;
+            void (async () => {
+              const existing = await activeReviewLease(heldKey);
+              if (existing?.deadlineAt > Date.now()) { locks.get(heldKey)?.release(); if (!closed) port.postMessage({ type: 'busy' }); return; }
+              if (!closed) port.postMessage({ type: 'granted', token });
+            })().catch(() => port.disconnect()).finally(() => { held.inFlight -= 1; if (held.disconnected && !held.inFlight) held.release(); });
+          } };
+          if (!queues.has(heldKey)) queues.set(heldKey, []);
+          queues.get(heldKey).push(job);
+          pump(heldKey);
+        } catch (_error) { port.disconnect(); }
+      });
+      port.onDisconnect.addListener(() => {
+        closed = true;
+        const held = locks.get(heldKey);
+        if (held?.port === port) {
+          held.disconnected = true;
+          if (!held.inFlight) held.release();
+        } else if (heldKey) pump(heldKey);
+      });
+    }
+    function install() {
+      chromeApi.runtime.onConnect.addListener(connect);
+      chromeApi.runtime.onMessage.addListener((message, sender, respond) => {
+        if (message?.type !== MESSAGE) return undefined;
+        let held;
+        try {
+          const candidate = locks.get(keyFor('state', scope(message.scope)));
+          if (candidate?.token === message.lockToken && candidate.tabId === sender?.tab?.id) {
+            held = candidate; held.inFlight += 1;
+          }
+        } catch (_error) { /* The handler returns the scoped validation error. */ }
+        handle(message, sender).then(result => respond({ ok: true, result }),
+          error => respond({ ok: false, error: { code: error.code || 'shared_store_unavailable',
+            message: error.code ? error.message : 'Shared session storage is unavailable.' } }))
+          .finally(() => {
+            if (!held) return;
+            held.inFlight -= 1;
+            if (held.disconnected && !held.inFlight) held.release();
+          });
+        return true;
+      });
+    }
+    return { install, handle };
+  }
+  function installBackground(chromeApi) {
+    const service = createService({ chromeApi, indexedDB, IDBKeyRange,
+      mergeSessionReviewState: globalThis.CodexOverleafStorageRunActions?.mergeSessionReviewState });
+    service.install(); return service;
+  }
+  return { createService, installBackground, mergeValue };
+});