codex-overleaf-link 2.2.1 → 2.3.0

package/extension/src/content/recentProjects.js

@@ -17,11 +17,13 @@
       sendBackgroundNative,
       PANEL_STATE_BASE_KEY,
       PROJECT_EDITOR_RESERVED_IDS,
-      STATUS_BADGE_CLASS
+      STATUS_BADGE_CLASS,
+      ProjectSessionCleanup, SessionPersistence, SessionState, StorageDb, StorageKeys, StorageMigration
     } = deps;
-    const projectSessionCleanup = window.CodexOverleafProjectSessionCleanup.create({
+    const projectSessionCleanup = ProjectSessionCleanup.create({
       tr, getAccountScopeId: getCachedAccountScopeId, showPluginConfirm, showPluginToast,
-      sendBackgroundNative, mutateProjectPanelState, renderRecentProjectsVariant
+      sendBackgroundNative, mutateProjectPanelState, renderRecentProjectsVariant,
+      SessionState, StorageDb, StorageMigration
     });
 
   // chrome.storage.local cache key (spec §5.6.3). The cache is keyed by
@@ -496,7 +498,6 @@
   }
 
   function sessionRecordDisplayTitle(record) {
-    var SessionState = window.CodexOverleafSessionState;
     if (record && typeof record.title === 'string' && record.title.trim()) {
       return record.title.trim();
     }
@@ -505,12 +506,11 @@
   }
 
   async function loadProjectSessionRecords(projectId) {
-    var StorageDb = window.CodexOverleafStorageDb;
     if (!StorageDb) {
       return [];
     }
     var records = await StorageDb.getAllByIndex('sessions', 'projectId', projectId);
-    var Persistence = window.CodexOverleafSessionPersistence;
+    var Persistence = SessionPersistence;
     var deletedIds = await Persistence.getDeletedSessionIds(projectId);
     var scope = getCachedAccountScopeId();
     return (records || [])
@@ -521,7 +521,6 @@
   }
 
   async function renderProjectSessions(sessionsEl, projectId) {
-    var StorageDb = window.CodexOverleafStorageDb;
     sessionsEl.innerHTML = '';
     var sessionsLoading = document.createElement('div');
     sessionsLoading.className = 'recent-projects-loading';
@@ -544,7 +543,6 @@
   }
 
   function renderProjectSessionRow(sessionsEl, projectId, record) {
-    var StorageDb = window.CodexOverleafStorageDb;
     var running = Boolean(StorageDb)
       && settleDashboardRunStatus(StorageDb.derivePrimaryStatusBadge(record), record.updatedAt || record.lastActivityAt) === 'running';
     var row = document.createElement('div');
@@ -614,17 +612,21 @@
   }
 
   async function activateSessionAndOpenProject(projectId, record) {
-    var Migration = window.CodexOverleafStorageMigration;
+    var Migration = StorageMigration;
     try {
       if (Migration && Migration.loadPrefs && Migration.savePrefs) {
-        var prefs = await Migration.loadPrefs();
+        var accountScopeId = getCachedAccountScopeId();
+        if (!accountScopeId) {
+          throw new Error('Account scope is unavailable.');
+        }
+        var prefs = await Migration.loadPrefs(accountScopeId, projectId);
         prefs = prefs && typeof prefs === 'object' ? prefs : {};
         var map = prefs.activeSessionByProject && typeof prefs.activeSessionByProject === 'object'
           ? prefs.activeSessionByProject
           : {};
         map[projectId] = record.id;
         prefs.activeSessionByProject = map;
-        await Migration.savePrefs(prefs);
+        await Migration.savePrefs(prefs, accountScopeId, projectId);
       }
     } catch (_error) { /* fall through: opening the project still works */ }
     openProjectFromRow(projectId);
@@ -636,7 +638,6 @@
   // panel-state blob is deliberately left alone — an empty projectId would
   // map getProjectStorageKey onto the global legacy key.
   async function cleanupDeadProjectEntry(projectId) {
-    var StorageDb = window.CodexOverleafStorageDb;
     if (!StorageDb) {
       return;
     }
@@ -684,7 +685,6 @@
   }
 
   function projectPanelStateKey(projectId) {
-    var StorageKeys = window.CodexOverleafStorageKeys;
     return StorageKeys.getProjectStorageKey(PANEL_STATE_BASE_KEY, 'https://www.overleaf.com/project/' + projectId);
   }
 
@@ -694,7 +694,6 @@
   // NOTE: if the project is open in another tab, that tab's in-memory state
   // wins on its next save; the IndexedDB record mutation below still holds.
   async function mutateProjectPanelState(projectId, mutate) {
-    var SessionState = window.CodexOverleafSessionState;
     var key = projectPanelStateKey(projectId);
     var stored = await chrome.storage.local.get(key);
     var blob = stored && stored[key];
@@ -709,8 +708,6 @@
   }
 
   async function deleteDashboardSession(sessionsEl, projectId, record) {
-    var StorageDb = window.CodexOverleafStorageDb;
-    var SessionState = window.CodexOverleafSessionState;
     // v1.8.1 P1b: ANY record whose stored badge is 'running' gets the
     // stronger confirm — even one the 30-minute heuristic settled to
     // interrupted. Activity timestamps are only bumped once a minute during
@@ -731,7 +728,7 @@
     if (!approved) {
       return;
     }
-    await window.CodexOverleafSessionPersistence.addTombstones(projectId, [record.id]);
+    await SessionPersistence.addTombstones(projectId, [record.id]);
     try {
       await mutateProjectPanelState(projectId, function (state) {
         return SessionState.deleteSession(state, record.id);
@@ -773,8 +770,6 @@
   }
 
   function beginDashboardSessionRename(sessionsEl, projectId, record, row, titleEl) {
-    var SessionState = window.CodexOverleafSessionState;
-    var StorageDb = window.CodexOverleafStorageDb;
     if (row.querySelector('input')) {
       return;
     }
@@ -816,8 +811,6 @@
   }
 
   async function commitDashboardSessionRename(sessionsEl, projectId, record, rawTitle) {
-    var SessionState = window.CodexOverleafSessionState;
-    var StorageDb = window.CodexOverleafStorageDb;
     if (!SessionState) {
       return;
     }
@@ -963,9 +956,8 @@
     // there really is more than one page of projects.
     var pageLimit = 10;
     try {
-      var StorageDb = window.CodexOverleafStorageDb;
       if (StorageDb) {
-        var deletedSessionIdsByProject = await window.CodexOverleafSessionPersistence.loadTombstones();
+        var deletedSessionIdsByProject = await SessionPersistence.loadTombstones();
         rows = await StorageDb.listRecentProjectsAcrossAccount({
           accountScopeId: accountScopeId,
           limit: showAll ? 500 : pageLimit + 1,

package/extension/src/content/runGuidanceController.js

@@ -47,7 +47,7 @@
     }
 
     function appendToView(event, view) {
-      const text = window.CodexOverleafRunGuidanceView?.getGuidanceText(event);
+      const text = deps.RunGuidanceView?.getGuidanceText(event);
       if (!text) return false;
       const guidance = view.guidance || view.root?.querySelector('[data-run-guidance]');
       const target = view.terminalStatus ? guidance : view.events;

package/extension/src/content/runQueueScheduler.js

@@ -2,7 +2,7 @@
   if (typeof module === 'object' && module.exports) {
     module.exports = factory(require('../shared/runInputQueue'));
   } else {
-    root.CodexOverleafRunQueueScheduler = factory(root.CodexOverleafRunInputQueue);
+    root.CodexOverleafModuleRegistry.define('RunQueueScheduler', ['RunInputQueue'], factory);
   }
 })(typeof window !== 'undefined' ? window : globalThis, function runQueueSchedulerFactory(Queue) {
   'use strict';
@@ -19,18 +19,49 @@
     }
 
     async function afterSettlement({ sessionId, status, queueItemId = '', continueQueue = false } = {}) {
-      let queue = options.getQueue?.(sessionId) || [];
-      if (status === 'completed') {
-        queue = dequeue(queue, queueItemId, { sessionId, reason: 'completed' });
-      } else if (continueQueue) {
-        queue = dequeue(queue, queueItemId, { sessionId, reason: 'continue_queue' });
-      } else if (queue.length) {
-        queue = Queue.pauseAll(queue, status || 'run_did_not_complete');
+      const originalQueue = options.getQueue?.(sessionId) || [];
+      const shouldContinue = status === 'completed' || continueQueue;
+      const shouldRemove = Boolean(queueItemId && shouldContinue);
+      const claimedItem = shouldRemove
+        ? originalQueue.find(item => item?.id === queueItemId)
+        : null;
+      if (shouldRemove) {
+        await options.persist?.({
+          queueMutation: {
+            type: 'remove',
+            sessionId,
+            itemId: queueItemId,
+            claimToken: claimedItem?.claimToken
+          }
+        });
+        const latestQueue = options.getQueue?.(sessionId) || originalQueue;
+        options.setQueue?.(
+          sessionId,
+          dequeue(latestQueue, queueItemId, {
+            sessionId,
+            reason: status === 'completed' ? 'completed' : 'continue_queue'
+          })
+        );
+      } else if (!shouldContinue) {
+        const paused = originalQueue.length
+          ? Queue.pauseAll(originalQueue, status || 'run_did_not_complete')
+          : originalQueue;
+        options.setQueue?.(sessionId, paused);
+        try {
+          await options.persist?.({
+            queueMutation: { type: 'transition', sessionId }
+          });
+        } catch (error) {
+          const latestQueue = options.getQueue?.(sessionId) || paused;
+          options.setQueue?.(
+            sessionId,
+            Queue.pauseAll(latestQueue, status || 'run_did_not_complete')
+          );
+          throw error;
+        }
       }
-      options.setQueue?.(sessionId, queue);
-      await options.persist?.();
       options.onChange?.(sessionId);
-      if (status === 'completed' || continueQueue) {
+      if (shouldContinue) {
         scheduleOne(sessionId);
       }
     }
@@ -39,15 +70,33 @@
       if (scheduling || options.isRunning?.() || options.canStart?.(sessionId) === false) {
         return false;
       }
-      const claimed = Queue.claimNext(options.getQueue?.(sessionId) || [], {
-        randomUUID: options.randomUUID
-      });
-      if (!claimed.ok) {
+      const initialQueue = options.getQueue?.(sessionId) || [];
+      if (!initialQueue.some(item => item?.status === 'queued')) {
         return false;
       }
       scheduling = true;
-      options.setQueue?.(sessionId, claimed.queue);
-      Promise.resolve(options.persist?.())
+      let claimed = null;
+      Promise.resolve(options.prepareClaim?.(sessionId))
+        .then(() => {
+          claimed = Queue.claimNext(options.getQueue?.(sessionId) || initialQueue, {
+            randomUUID: options.randomUUID,
+            resolveExecutionSnapshot: options.resolveExecutionSnapshot
+          });
+          if (!claimed.ok) {
+            const error = new Error(claimed.error?.message || claimed.error?.code || 'queue_claim_failed');
+            error.code = claimed.error?.code || 'queue_claim_failed';
+            throw error;
+          }
+          options.setQueue?.(sessionId, claimed.queue);
+          return options.persist?.({
+            queueMutation: {
+              type: 'claim',
+              sessionId,
+              itemId: claimed.item.id,
+              claimToken: claimed.item.claimToken
+            }
+          });
+        })
         .then(() => {
           options.onChange?.(sessionId);
           scheduling = false;
@@ -55,27 +104,64 @@
         })
         .catch(error => {
           scheduling = false;
-          const paused = Queue.pauseAll(options.getQueue?.(sessionId) || claimed.queue, error?.code || 'start_failed');
+          const paused = Queue.pauseAll(
+            options.getQueue?.(sessionId) || claimed?.queue || initialQueue,
+            error?.code || 'start_failed'
+          );
           options.setQueue?.(sessionId, paused);
           options.onChange?.(sessionId);
-          return options.persist?.();
+          return Promise.resolve(options.persist?.({
+            queueMutation: claimed?.item?.id
+              ? {
+                type: 'release',
+                sessionId,
+                itemId: claimed.item.id,
+                claimToken: claimed.item.claimToken
+              }
+              : { type: 'transition', sessionId }
+          })).catch(() => undefined);
         });
       return true;
     }
 
     async function markExecuting(sessionId, itemId, _runId) {
       const queue = options.getQueue?.(sessionId) || [];
+      const item = queue.find(entry => entry?.id === itemId);
+      try {
+        await options.persist?.({
+          queueMutation: { type: 'remove', sessionId, itemId, claimToken: item?.claimToken }
+        });
+      } catch (error) {
+        const latestQueue = options.getQueue?.(sessionId) || queue;
+        options.setQueue?.(
+          sessionId,
+          Queue.pauseAll(latestQueue, error?.code || 'queue_promotion_persistence_failed')
+        );
+        options.onChange?.(sessionId);
+        try {
+          await options.persist?.({
+            queueMutation: { type: 'restore', sessionId, itemId, claimToken: item?.claimToken }
+          });
+        } catch (recoveryError) {
+          if (error && typeof error === 'object') {
+            error.persistenceRecoveryError = recoveryError?.message || String(recoveryError);
+          }
+        }
+        throw error;
+      }
+      const latestQueue = options.getQueue?.(sessionId) || queue;
       options.setQueue?.(
         sessionId,
-        dequeue(queue, itemId, { sessionId, runId: _runId, reason: 'executing' })
+        dequeue(latestQueue, itemId, { sessionId, runId: _runId, reason: 'executing' })
       );
-      await options.persist?.();
       options.onChange?.(sessionId);
     }
 
     async function resume(sessionId) {
       options.setQueue?.(sessionId, Queue.resumeAll(options.getQueue?.(sessionId) || []));
-      await options.persist?.();
+      await options.persist?.({
+        queueMutation: { type: 'transition', sessionId }
+      });
       options.onChange?.(sessionId);
       scheduleOne(sessionId);
     }
@@ -88,7 +174,7 @@
     const scheduler = create({
       getQueue: sessionId => options.getSession?.(sessionId)?.pendingInputs || [],
       setQueue: (sessionId, pendingInputs) => options.setQueue?.(sessionId, pendingInputs),
-      persist: () => options.save?.(),
+      persist: persistenceOptions => options.save?.(persistenceOptions),
       isRunning: () => Boolean(options.getCurrentRun?.()),
       canStart: sessionId => options.canStart?.(sessionId) !== false,
       start: (item, sessionId) => startQueuedInput(item, sessionId),
@@ -97,6 +183,8 @@
         sessionId: context.sessionId,
         recordId: item.sourceRunId || ''
       }),
+      prepareClaim: options.prepareClaim,
+      resolveExecutionSnapshot: options.resolveExecutionSnapshot,
       randomUUID: options.randomUUID
     });
 
@@ -128,7 +216,9 @@
       // active turn, or until the scheduler promotes it to the next run.
       options.clearTask?.();
       render();
-      options.saveSoon?.();
+      options.saveSoon?.({
+        queueMutation: { type: 'enqueue', sessionId: session.id, itemId: result.item.id }
+      });
     }
 
     async function guide(itemId) {
@@ -142,7 +232,9 @@
       }
       options.setQueue?.(session.id, Queue.markSteering(session.pendingInputs, itemId));
       render();
-      await options.save?.();
+      await options.save?.({
+        queueMutation: { type: 'transition', sessionId: session.id, itemId }
+      });
       try {
         const response = await options.sendSteer?.({
           requestId: run.nativeRequestId,
@@ -174,7 +266,11 @@
           options.toast?.(response?.error?.message || options.tr?.('queuedInputGuideFailed'), 'warning');
         }
         render();
-        await options.save?.();
+        await options.save?.({
+          queueMutation: response?.ok
+            ? { type: 'remove', sessionId: session.id, itemId }
+            : { type: 'transition', sessionId: session.id, itemId }
+        });
       } catch (error) {
         const latest = options.getSession?.(session.id);
         const paused = (latest?.pendingInputs || []).map(entry => entry.id === itemId
@@ -183,7 +279,9 @@
         options.setQueue?.(session.id, Queue.normalizeQueue(paused));
         options.toast?.(error?.message || options.tr?.('queuedInputGuideFailed'), 'warning');
         render();
-        await options.save?.();
+        await options.save?.({
+          queueMutation: { type: 'transition', sessionId: session.id, itemId }
+        });
       }
     }
 
@@ -201,7 +299,9 @@
       }
       options.setQueue?.(session.id, Queue.remove(session.pendingInputs || [], itemId));
       render();
-      options.saveSoon?.();
+      options.saveSoon?.({
+        queueMutation: { type: 'remove', sessionId: session.id, itemId }
+      });
     }
 
     function resume() {
@@ -242,7 +342,7 @@
         error.code = 'queue_session_not_active';
         throw error;
       }
-      options.applyQueuedInput?.(item);
+      await options.applyQueuedInput?.(item);
       await options.run?.(item);
     }
 

package/extension/src/content/runSettlementPersistence.js

@@ -0,0 +1,51 @@
+(function initCodexOverleafRunSettlementPersistence(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafRunSettlementPersistence = api;
+})(typeof window !== 'undefined' ? window : globalThis, function runSettlementPersistenceFactory() {
+  'use strict';
+
+  function create(options = {}) {
+    const Settlement = options.writebackSettlement;
+
+    function findTarget(recordId, sessionId) {
+      return typeof options.findRunRecord === 'function'
+        ? options.findRunRecord(recordId, sessionId)
+        : null;
+    }
+
+    function applyToCurrentRun(settlement) {
+      const view = options.getCurrentRunView?.();
+      if (!settlement || !view?.recordId) return;
+      const record = findTarget(view.recordId, view.sessionId);
+      if (!record) return;
+      Object.assign(record, Settlement.applySettlementTransition(record, settlement));
+    }
+
+    function settleMirrorRefresh(result = {}) {
+      const record = findTarget(result.recordId, result.sessionId);
+      if (!record) return;
+      if (result.runProjectId && result.runProjectId !== options.getCurrentProjectId?.()) return;
+      const existing = record.settlement && typeof record.settlement === 'object'
+        ? record.settlement
+        : record.settlementFacts;
+      if (!existing || typeof existing !== 'object') return;
+      record.settlement = Settlement.compactSettlementFacts({
+        ...existing,
+        evidence: {
+          ...(existing.evidence || {}),
+          mirrored: result.state
+        }
+      });
+      delete record.settlementFacts;
+      options.saveStateSoon?.();
+    }
+
+    return Object.freeze({
+      applyToCurrentRun,
+      settleMirrorRefresh
+    });
+  }
+
+  return Object.freeze({ create });
+});

package/extension/src/content/runTimelineView.js

@@ -1,7 +1,6 @@
 (function initCodexOverleafRunTimelineView() {
   'use strict';
 
-  const RunGuidanceView = window.CodexOverleafRunGuidanceView;
   // Run-timeline view — the timeline render pipeline carved out of
   // contentRuntime.js (v1.4.6 structural-debt phase 2): the scroll engine +
   // jump-to-latest button, the live-elapsed tick and collapsed-header summary,
@@ -13,6 +12,7 @@
   // that owns it.
   function create(deps = {}) {
     const {
+      RunGuidanceView,
       tr,
       tx,
       getLocale,
@@ -40,7 +40,8 @@
       showNativeSetupGuidance,
       openProjectFileForFailure,
       openStorageSettings,
-      trackedChangeInFlight
+      trackedChangeInFlight,
+      projectRunSettlement
     } = deps;
 
   let logAutoFollow = true;
@@ -884,8 +885,8 @@
       return;
     }
 
-    const undoCount = getRunUndoCount(run);
-    if (!undoCount && run.undoStatus !== 'applied') {
+    const projection = projectRunSettlement(run);
+    if (!projection.canUndo && run.undoStatus !== 'applied') {
       button.hidden = true;
       return;
     }
@@ -912,13 +913,14 @@
   // same executable state as `pending`.
   function configureLifecycleUndoButton(button, run) {
     const status = run.trackedChangeStatus || '';
+    const projection = projectRunSettlement(run);
     // §7 settlement matrix: needs_review keeps BOTH controls visible AND
     // actionable. Branch placed before the terminal branches so a
     // needs_review run is never treated as terminal.
     if (status === 'needs_review') {
       const inFlight = trackedChangeInFlight.get(run.id);
       button.hidden = false;
-      button.disabled = inFlight === 'reject' || inFlight === 'accept';
+      button.disabled = !projection.canUndo || inFlight === 'reject' || inFlight === 'accept';
       button.textContent = tr('undoRun');
       button.title = tr('undoRunTitle');
       button.addEventListener('click', event => {
@@ -949,7 +951,7 @@
     }
     const inFlight = trackedChangeInFlight.get(run.id);
     button.hidden = false;
-    button.disabled = inFlight === 'reject' || inFlight === 'accept';
+    button.disabled = !projection.canUndo || inFlight === 'reject' || inFlight === 'accept';
     button.textContent = tr('undoRun');
     button.title = tr('undoRunTitle');
     button.addEventListener('click', event => {
@@ -980,13 +982,14 @@
     }
 
     const status = run.trackedChangeStatus || '';
+    const projection = projectRunSettlement(run);
     // §7 settlement matrix: needs_review keeps BOTH controls visible AND
     // actionable. It remains an internal retryable proof state, while the
     // primary button label stays in the same executable state as `pending`.
     if (status === 'needs_review') {
       const inFlight = trackedChangeInFlight.get(run.id);
       button.hidden = false;
-      button.disabled = inFlight === 'accept' || inFlight === 'reject';
+      button.disabled = !projection.canAccept || inFlight === 'accept' || inFlight === 'reject';
       if (inFlight === 'accept') {
         button.textContent = tr('runAcceptTrackedConfirming');
         button.title = tr('runAcceptTrackedConfirming');
@@ -1020,7 +1023,7 @@
 
     const inFlight = trackedChangeInFlight.get(run.id);
     button.hidden = false;
-    button.disabled = inFlight === 'accept' || inFlight === 'reject';
+    button.disabled = !projection.canAccept || inFlight === 'accept' || inFlight === 'reject';
     if (inFlight === 'accept') {
       button.textContent = tr('runAcceptTrackedConfirming');
       button.title = tr('runAcceptTrackedConfirming');

package/extension/src/content/scopedPersistenceCoordinator.js

@@ -0,0 +1,100 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(
+      require('./scopedPersistencePanelState'),
+      require('./scopedPersistenceDetachedCommit')
+    );
+  } else {
+    root.CodexOverleafModuleRegistry.define(
+      'ScopedPersistenceCoordinator',
+      ['ScopedPersistencePanelState', 'ScopedPersistenceDetachedCommit'],
+      factory
+    );
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (PanelState, DetachedCommit) {
+  'use strict';
+
+  function createController(options) {
+    options = options || {};
+    var Transaction = options.Transaction;
+    if (!Transaction || typeof Transaction.createCoordinator !== 'function') return null;
+    var writerId = getStableWriterId(options.sessionStorage);
+    var coordinator = Transaction.createCoordinator({
+      adapter: Transaction.createBrowserAdapter({ chromeApi: options.chromeApi }),
+      writerId: writerId
+    });
+    var commitDetached = (options.DetachedCommit || DetachedCommit)?.create?.({
+      Transaction: Transaction, chromeApi: options.chromeApi, writerId: writerId
+    });
+    var activeScope = null;
+
+    function scope(projectId) {
+      var accountScopeId = '';
+      try {
+        accountScopeId = typeof options.getAccountScopeId === 'function'
+          ? options.getAccountScopeId() || ''
+          : '';
+      } catch (_error) {
+        accountScopeId = '';
+      }
+      return { accountScopeId: accountScopeId, projectId: projectId };
+    }
+
+    return Object.freeze({
+      async beginHydration(projectId) {
+        var nextScope = scope(projectId);
+        if (!nextScope.accountScopeId) {
+          activeScope = null;
+          return null;
+        }
+        var token = await coordinator.beginHydration(nextScope);
+        if (coordinator.isCurrent(token)) activeScope = nextScope;
+        return token;
+      },
+      isCurrent: coordinator.isCurrent,
+      async commit(projectId, commitOptions, action) {
+        var nextScope = scope(projectId);
+        if (!nextScope.accountScopeId) {
+          return { ok: false, reason: 'account_scope_unavailable' };
+        }
+        if (!activeScope
+          || activeScope.accountScopeId !== nextScope.accountScopeId
+          || activeScope.projectId !== nextScope.projectId) {
+          var hydration = await coordinator.beginHydration(nextScope);
+          if (!coordinator.isCurrent(hydration)) {
+            return { ok: false, reason: 'stale_view' };
+          }
+          activeScope = nextScope;
+        }
+        var view = await coordinator.captureCommitView(nextScope, {
+          detached: Boolean(commitOptions && commitOptions.detached)
+        });
+        return coordinator.commit(view, action, {
+          rebase: !commitOptions || commitOptions.rebase !== false,
+          queueMutation: commitOptions && commitOptions.queueMutation,
+          queueMutations: commitOptions && commitOptions.queueMutations,
+          sessionTombstones: commitOptions && commitOptions.sessionTombstones
+        });
+      },
+      commitDetached: commitDetached
+    });
+  }
+  function getStableWriterId(storage) {
+    var key = 'codex-overleaf-scoped-writer-id';
+    try {
+      var existing = storage?.getItem?.(key);
+      if (existing) return existing;
+      var created = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+        ? crypto.randomUUID()
+        : 'writer-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
+      storage?.setItem?.(key, created);
+      return created;
+    } catch (_error) {
+      return '';
+    }
+  }
+  return Object.freeze({
+    createController: createController,
+    persistPanelState: PanelState?.persistPanelState || null
+  });
+});