codex-overleaf-link 2.2.1 → 2.3.1

package/extension/src/shared/runExecutionSnapshot.js

@@ -0,0 +1,187 @@
+(function initCodexOverleafRunExecutionSnapshot(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('./providerProfiles'), require('./runExecutionSnapshotCodec'));
+  } else {
+    root.CodexOverleafModuleRegistry.define('RunExecutionSnapshot', [
+      'ProviderProfiles',
+      'RunExecutionSnapshotCodec'
+    ], factory);
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function runExecutionSnapshotFactory(ProviderProfiles, Codec) {
+  'use strict';
+
+  function create(input = {}) {
+    const providerId = Codec.normalizeText(input.providerId) || 'builtin';
+    return Codec.normalizeSnapshot(input, {
+      source: input.source || 'submitted',
+      requireProviderRevision: providerId !== 'builtin'
+    });
+  }
+
+  function capture(input = {}, options = {}) {
+    return Codec.normalizeSnapshot(input, options);
+  }
+
+  function captureRawQueueTuple(rawQueueItem = {}, fallbackInput = {}) {
+    const rawPayload = rawQueueItem?.payload && typeof rawQueueItem.payload === 'object'
+      ? rawQueueItem.payload
+      : rawQueueItem;
+    const persisted = rawQueueItem?.executionSnapshot || rawPayload?.executionSnapshot;
+    if (persisted && typeof persisted === 'object') {
+      return Codec.normalizeSnapshot(persisted, {
+        source: persisted.source || 'submitted',
+        migrateLegacyConfirm: true
+      });
+    }
+    const raw = rawPayload && typeof rawPayload === 'object' ? rawPayload : {};
+    const fallback = fallbackInput && typeof fallbackInput === 'object' ? fallbackInput : {};
+    const captured = {};
+    let inferred = false;
+    for (const field of Codec.TUPLE_FIELDS) {
+      if (Codec.hasOwn(raw, field)) captured[field] = Codec.cloneValue(raw[field]);
+      else {
+        captured[field] = Codec.cloneValue(fallback[field]);
+        inferred = true;
+      }
+    }
+    const providerId = Codec.normalizeText(captured.providerId) || 'builtin';
+    if (providerId !== 'builtin' && !Codec.normalizeRevision(captured.providerRevision)
+      && (!Codec.hasOwn(raw, 'providerRevision') || captured.providerRevision === '' || captured.providerRevision == null)) {
+      captured.providerRevision = fallback.providerRevision;
+      inferred = true;
+    }
+    return Codec.normalizeSnapshot(captured, {
+      source: inferred ? 'legacy-inferred' : 'legacy-captured',
+      migrateLegacyConfirm: true
+    });
+  }
+
+  function resolveForExecution(value = {}, options = {}) {
+    const persisted = value.executionSnapshot || value;
+    const snapshot = Codec.normalizeSnapshot(persisted, {
+      source: persisted.source || 'submitted',
+      migrateLegacyConfirm: true
+    });
+    if (snapshot.providerId === 'builtin') return Codec.normalizeSnapshot(snapshot, { source: snapshot.source });
+    const catalog = options.catalog || {};
+    const provider = ProviderProfiles?.getProviderById
+      ? ProviderProfiles.getProviderById(catalog, snapshot.providerId)
+      : (catalog.providers || []).find(item => item?.id === snapshot.providerId);
+    if (!provider) throw Codec.snapshotError('provider_not_found', 'The selected provider no longer exists.');
+    const currentRevision = Codec.normalizeRevision(provider.revision);
+    if (!currentRevision) throw Codec.snapshotError('provider_revision_conflict', 'The selected provider has no usable revision.');
+    if (!snapshot.providerRevision) {
+      if (snapshot.source !== 'legacy-inferred') {
+        throw Codec.snapshotError('provider_revision_conflict', 'The selected provider revision was not captured for this run.');
+      }
+      return Codec.normalizeSnapshot({ ...snapshot, providerRevision: currentRevision }, {
+        source: 'legacy-inferred',
+        requireProviderRevision: true
+      });
+    }
+    if (snapshot.providerRevision !== currentRevision) {
+      throw Codec.snapshotError('provider_revision_conflict', 'The selected provider changed after this run was submitted.');
+    }
+    return Codec.normalizeSnapshot(snapshot, { source: snapshot.source, requireProviderRevision: true });
+  }
+
+  function snapshotOf(value = {}) {
+    const persisted = value.executionSnapshot || value;
+    return Codec.normalizeSnapshot(persisted, {
+      source: persisted.source || 'submitted',
+      migrateLegacyConfirm: true
+    });
+  }
+
+  function cloneSnapshot(value = {}) {
+    const snapshot = snapshotOf(value);
+    return { ...snapshot, focusFiles: [...snapshot.focusFiles] };
+  }
+
+  function toLegacyQueueTuple(value = {}) {
+    const snapshot = snapshotOf(value);
+    return {
+      mode: snapshot.mode,
+      providerId: snapshot.providerId,
+      providerRevision: snapshot.providerRevision,
+      model: snapshot.model,
+      reasoningEffort: snapshot.reasoningEffort,
+      speedTier: snapshot.speedTier,
+      autoRecompile: snapshot.autoRecompile,
+      requireReviewing: snapshot.requireReviewing,
+      focusFiles: [...snapshot.focusFiles]
+    };
+  }
+
+  function toQueuePayload(value = {}) {
+    const snapshot = snapshotOf(value);
+    return { executionSnapshot: cloneSnapshot(snapshot), ...toLegacyQueueTuple(snapshot) };
+  }
+
+  function toRunCompatibilityTuple(value = {}) {
+    const snapshot = snapshotOf(value);
+    return {
+      ...toLegacyQueueTuple(snapshot),
+      providerRevision: snapshot.providerId === 'builtin' ? 0 : Number(snapshot.providerRevision),
+      executionSnapshot: cloneSnapshot(snapshot)
+    };
+  }
+
+  function projectForDisplay(value = {}) {
+    const snapshot = snapshotOf(value);
+    return {
+      providerId: snapshot.providerId,
+      model: snapshot.model,
+      reasoningEffort: snapshot.reasoningEffort,
+      speedTier: snapshot.speedTier,
+      mode: snapshot.mode,
+      focusFiles: [...snapshot.focusFiles]
+    };
+  }
+
+  function equalsExecutionConfig(left = {}, right = {}) {
+    const leftTuple = toLegacyQueueTuple(left);
+    const rightTuple = toLegacyQueueTuple(right);
+    return Codec.TUPLE_FIELDS.every(field =>
+      JSON.stringify(leftTuple[field]) === JSON.stringify(rightTuple[field])
+    );
+  }
+
+  function applyToState(state = {}, value = {}) {
+    const snapshot = snapshotOf(value);
+    return {
+      ...state,
+      ...toLegacyQueueTuple(snapshot),
+      providerRevision: snapshot.providerId === 'builtin' ? 0 : Number(snapshot.providerRevision)
+    };
+  }
+
+  function toProviderSelection(value = {}) {
+    const snapshot = snapshotOf(value);
+    return {
+      providerId: snapshot.providerId,
+      providerRevision: snapshot.providerId === 'builtin' ? 0 : Number(snapshot.providerRevision)
+    };
+  }
+
+  return {
+    SCHEMA_VERSION: Codec.SCHEMA_VERSION,
+    TUPLE_FIELDS: Codec.TUPLE_FIELDS,
+    applyToState,
+    capture,
+    captureRawQueueTuple,
+    cloneSnapshot,
+    create,
+    equalsExecutionConfig,
+    fromQueuePayload: captureRawQueueTuple,
+    normalizeRevision: Codec.normalizeRevision,
+    normalizeSnapshot: Codec.normalizeSnapshot,
+    projectForDisplay,
+    resolveForExecution,
+    toLegacyQueueTuple,
+    toProviderSelection,
+    toQueuePayload,
+    toRunCompatibilityTuple,
+    validate: Codec.validate
+  };
+});

package/extension/src/shared/runExecutionSnapshotCodec.js

@@ -0,0 +1,171 @@
+(function initCodexOverleafRunExecutionSnapshotCodec(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafRunExecutionSnapshotCodec = factory();
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function runExecutionSnapshotCodecFactory() {
+  'use strict';
+
+  const SCHEMA_VERSION = 1;
+  const VALID_MODES = new Set(['ask', 'auto']);
+  const VALID_SOURCES = new Set(['submitted', 'legacy-captured', 'legacy-inferred']);
+  const TUPLE_FIELDS = Object.freeze([
+    'mode', 'providerId', 'providerRevision', 'model', 'reasoningEffort',
+    'speedTier', 'autoRecompile', 'requireReviewing', 'focusFiles'
+  ]);
+  const SECRET_FIELD_PATTERN = /(?:api.?key|authorization|password|secret|access.?token|refresh.?token)/i;
+
+  function normalizeSnapshot(value = {}, options = {}) {
+    const input = value && typeof value === 'object' ? value : {};
+    assertNoSecretFields(input);
+    if (input.mode === 'confirm' && options.migrateLegacyConfirm !== true) {
+      throw snapshotError('suggest_mode_removed', 'Suggest mode has been removed. Choose Ask or Auto.');
+    }
+    const providerId = normalizeText(input.providerId) || 'builtin';
+    const revision = normalizeRevisionResult(input.providerRevision);
+    if (!revision.ok) throw snapshotError('provider_revision_conflict', revision.error);
+    const snapshot = {
+      schemaVersion: SCHEMA_VERSION,
+      mode: input.mode === 'auto' ? 'auto' : 'ask',
+      providerId,
+      providerRevision: providerId === 'builtin' ? '' : revision.value,
+      model: normalizeText(input.model).slice(0, 160),
+      reasoningEffort: normalizeText(input.reasoningEffort).slice(0, 32),
+      speedTier: input.speedTier === 'fast' ? 'fast' : 'standard',
+      autoRecompile: input.autoRecompile !== false,
+      requireReviewing: input.requireReviewing !== false,
+      focusFiles: normalizePaths(input.focusFiles),
+      capturedAt: normalizeTimestamp(input.capturedAt),
+      source: VALID_SOURCES.has(options.source || input.source)
+        ? (options.source || input.source)
+        : 'submitted'
+    };
+    const result = validate(snapshot, options);
+    if (!result.ok) throw snapshotError(result.errors[0].code, result.errors[0].message);
+    snapshot.focusFiles = Object.freeze([...snapshot.focusFiles]);
+    return Object.freeze(snapshot);
+  }
+
+  function validate(value = {}, options = {}) {
+    const errors = [];
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return fail('invalid_execution_snapshot', 'Execution snapshot must be an object.');
+    }
+    if (value.schemaVersion !== undefined && Number(value.schemaVersion) !== SCHEMA_VERSION) {
+      errors.push(errorItem('invalid_execution_snapshot', `Unsupported execution snapshot schema version: ${value.schemaVersion}`));
+    }
+    if (!VALID_MODES.has(value.mode)) {
+      errors.push(errorItem('invalid_execution_snapshot', 'Execution snapshot mode is invalid.'));
+    }
+    const providerId = normalizeText(value.providerId);
+    if (!providerId) errors.push(errorItem('invalid_execution_snapshot', 'Execution snapshot provider is missing.'));
+    const revision = normalizeRevisionResult(value.providerRevision);
+    if (!revision.ok) {
+      errors.push(errorItem('provider_revision_conflict', revision.error));
+    } else if (providerId === 'builtin' && revision.value) {
+      errors.push(errorItem('provider_revision_conflict', 'Built-in Codex cannot carry a provider revision.'));
+    } else if (providerId !== 'builtin' && options.requireProviderRevision === true && !revision.value) {
+      errors.push(errorItem('provider_revision_conflict', 'The selected provider revision was not available when the run was submitted.'));
+    }
+    if (!Array.isArray(value.focusFiles) || value.focusFiles.length > 100) {
+      errors.push(errorItem('invalid_execution_snapshot', 'Execution snapshot focus files are invalid.'));
+    }
+    try {
+      assertNoSecretFields(value);
+    } catch (error) {
+      errors.push(errorItem(error.code, error.message));
+    }
+    return { ok: errors.length === 0, errors };
+  }
+
+  function normalizeRevision(value) {
+    const result = normalizeRevisionResult(value);
+    return result.ok ? result.value : '';
+  }
+
+  function normalizeRevisionResult(value) {
+    if (value === undefined || value === null || value === '') return { ok: true, value: '' };
+    const text = typeof value === 'string' ? value.trim() : String(value);
+    if (!text) return { ok: true, value: '' };
+    const number = Number(text);
+    return Number.isSafeInteger(number) && number >= 0
+      ? { ok: true, value: String(number) }
+      : { ok: false, value: '', error: 'Provider revision must be a finite non-negative integer.' };
+  }
+
+  function normalizePaths(value) {
+    const seen = new Set();
+    const result = [];
+    for (const raw of Array.isArray(value) ? value : []) {
+      const path = normalizeProjectPath(raw);
+      if (!path || seen.has(path)) continue;
+      seen.add(path);
+      result.push(path);
+      if (result.length >= 100) break;
+    }
+    return result;
+  }
+
+  function normalizeProjectPath(value) {
+    const result = [];
+    for (const segment of String(value || '').replace(/\0/g, '').replace(/\\/g, '/').replace(/^\/+/, '').split('/')) {
+      if (!segment || segment === '.') continue;
+      if (segment === '..') return '';
+      result.push(segment);
+    }
+    return result.join('/').trim();
+  }
+
+  function normalizeTimestamp(value) {
+    if (typeof value === 'string' && value) return value;
+    if (Number.isFinite(Number(value)) && Number(value) > 0) return new Date(Number(value)).toISOString();
+    return new Date().toISOString();
+  }
+
+  function assertNoSecretFields(value) {
+    for (const key of Object.keys(value && typeof value === 'object' ? value : {})) {
+      if (SECRET_FIELD_PATTERN.test(key)) {
+        throw snapshotError('invalid_execution_snapshot', `Execution snapshot cannot contain secret field "${key}".`);
+      }
+    }
+  }
+
+  function cloneValue(value) {
+    return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+  }
+
+  function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+  }
+
+  function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+  }
+
+  function snapshotError(code, message) {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+  }
+
+  function errorItem(code, message) {
+    return { code, message };
+  }
+
+  function fail(code, message) {
+    return { ok: false, errors: [errorItem(code, message)] };
+  }
+
+  return {
+    SCHEMA_VERSION,
+    TUPLE_FIELDS,
+    cloneValue,
+    hasOwn,
+    normalizeRevision,
+    normalizeSnapshot,
+    normalizeText,
+    snapshotError,
+    validate
+  };
+});

package/extension/src/shared/runInputQueue.js

@@ -1,15 +1,16 @@
 (function initCodexOverleafRunInputQueue(root, factory) {
   if (typeof module === 'object' && module.exports) {
-    module.exports = factory();
+    module.exports = factory(require('./runExecutionSnapshot'));
   } else {
-    root.CodexOverleafRunInputQueue = factory();
+    root.CodexOverleafModuleRegistry.define('RunInputQueue', ['RunExecutionSnapshot'], factory);
   }
-})(typeof window !== 'undefined' ? window : globalThis, function runInputQueueFactory() {
+})(typeof window !== 'undefined' ? window : globalThis, function runInputQueueFactory(RunExecutionSnapshot) {
   'use strict';
 
   const MAX_ITEMS = 20;
   const MAX_TEXT_CHARS = 12000;
   const MAX_QUEUE_BYTES = 128 * 1024;
+  const MAX_PERSISTED_QUEUE_BYTES = 512 * 1024;
   const ACTIVE_STATUSES = new Set(['claimed', 'executing', 'steering']);
   const VALID_STATUSES = new Set(['queued', 'paused', ...ACTIVE_STATUSES]);
 
@@ -27,6 +28,7 @@
       if (options.recoverActive === true && ACTIVE_STATUSES.has(status)) {
         status = 'paused';
       }
+      const executionSnapshot = normalizeExecutionSnapshot(raw, options.fallbackInput);
       normalized.push({
         id,
         clientUserMessageId: String(raw.clientUserMessageId || id),
@@ -38,7 +40,8 @@
         linkedRunId: status === 'executing' ? String(raw.linkedRunId || '') : '',
         claimToken: status === 'claimed' || status === 'executing' ? String(raw.claimToken || '') : '',
         pauseReason: status === 'paused' ? String(raw.pauseReason || '') : '',
-        payload: normalizePayload(raw.payload)
+        executionSnapshot: RunExecutionSnapshot.cloneSnapshot(executionSnapshot),
+        payload: RunExecutionSnapshot.toQueuePayload(executionSnapshot)
       });
       if (normalized.length >= MAX_ITEMS) {
         break;
@@ -63,6 +66,7 @@
     const nowFactory = deps.now || (() => new Date().toISOString());
     const id = String(input.id || idFactory());
     const timestamp = String(nowFactory());
+    const executionSnapshot = normalizeExecutionSnapshot(input, input.fallbackInput);
     const item = {
       id,
       clientUserMessageId: String(input.clientUserMessageId || id),
@@ -74,10 +78,11 @@
       linkedRunId: '',
       claimToken: '',
       pauseReason: input.status === 'paused' ? String(input.pauseReason || '') : '',
-      payload: normalizePayload(input.payload)
+      executionSnapshot: RunExecutionSnapshot.cloneSnapshot(executionSnapshot),
+      payload: RunExecutionSnapshot.toQueuePayload(executionSnapshot)
     };
     const next = [...queue, item];
-    if (estimateBytes(next) > MAX_QUEUE_BYTES) {
+    if (estimateLegacyBytes(next) > MAX_QUEUE_BYTES || estimateBytes(next) > MAX_PERSISTED_QUEUE_BYTES) {
       return failure(queue, 'queue_too_large');
     }
     return { ok: true, queue: next, item };
@@ -114,13 +119,37 @@
       return { ok: false, queue, item: null };
     }
     const tokenFactory = deps.randomUUID || (() => 'claim_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8));
-    const item = {
+    let item = {
       ...queue[index],
       status: 'claimed',
       claimToken: String(tokenFactory()),
       updatedAt: new Date().toISOString(),
       pauseReason: ''
     };
+    try {
+      const captured = RunExecutionSnapshot.normalizeSnapshot(
+        item.executionSnapshot || item.payload?.executionSnapshot || item.payload,
+        { source: item.executionSnapshot?.source || item.payload?.executionSnapshot?.source || 'submitted' }
+      );
+      const snapshot = deps.resolveExecutionSnapshot instanceof Function
+        ? deps.resolveExecutionSnapshot(captured)
+        : captured;
+      item = {
+        ...item,
+        executionSnapshot: RunExecutionSnapshot.cloneSnapshot(snapshot),
+        payload: RunExecutionSnapshot.toQueuePayload(snapshot)
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        queue,
+        item: null,
+        error: {
+          code: error?.code || 'provider_revision_conflict',
+          message: error?.message || ''
+        }
+      };
+    }
     queue[index] = item;
     return { ok: true, queue, item };
   }
@@ -160,21 +189,14 @@
     return normalizeQueue(items).map(item => item.id === id ? updater(item) : item);
   }
 
-  function normalizePayload(payload = {}) {
-    return {
-      mode: ['ask', 'confirm', 'auto'].includes(payload.mode) ? payload.mode : 'ask',
-      providerId: String(payload.providerId || 'builtin').slice(0, 160),
-      providerRevision: String(payload.providerRevision || '').slice(0, 160),
-      model: String(payload.model || '').slice(0, 160),
-      reasoningEffort: String(payload.reasoningEffort || '').slice(0, 32),
-      speedTier: payload.speedTier === 'fast' ? 'fast' : 'standard',
-      autoRecompile: payload.autoRecompile !== false,
-      requireReviewing: payload.requireReviewing !== false,
-      focusFiles: (Array.isArray(payload.focusFiles) ? payload.focusFiles : [])
-        .map(path => String(path || '').replace(/\\/g, '/').replace(/^\/+/, '').trim())
-        .filter(Boolean)
-        .slice(0, 100)
-    };
+  function normalizeExecutionSnapshot(raw = {}, fallbackInput = {}) {
+    return RunExecutionSnapshot.captureRawQueueTuple(raw, fallbackInput);
+  }
+
+  function normalizePayload(payload = {}, fallbackInput = {}) {
+    return RunExecutionSnapshot.toQueuePayload(
+      RunExecutionSnapshot.captureRawQueueTuple(payload, fallbackInput)
+    );
   }
 
   function normalizeTimestamp(value) {
@@ -183,7 +205,10 @@
 
   function trimToBudget(items) {
     const queue = items.slice(-MAX_ITEMS);
-    while (queue.length && estimateBytes(queue) > MAX_QUEUE_BYTES) {
+    while (queue.length && (
+      estimateLegacyBytes(queue) > MAX_QUEUE_BYTES
+      || estimateBytes(queue) > MAX_PERSISTED_QUEUE_BYTES
+    )) {
       queue.shift();
     }
     return queue;
@@ -196,6 +221,29 @@
       : text.length * 2;
   }
 
+  function estimateLegacyBytes(items) {
+    return estimateBytes((Array.isArray(items) ? items : []).map(item => {
+      const legacyItem = { ...(item || {}) };
+      delete legacyItem.executionSnapshot;
+      return {
+        ...legacyItem,
+        payload: item?.payload && typeof item.payload === 'object'
+          ? {
+              mode: item.payload.mode,
+              providerId: item.payload.providerId,
+              providerRevision: item.payload.providerRevision,
+              model: item.payload.model,
+              reasoningEffort: item.payload.reasoningEffort,
+              speedTier: item.payload.speedTier,
+              autoRecompile: item.payload.autoRecompile,
+              requireReviewing: item.payload.requireReviewing,
+              focusFiles: item.payload.focusFiles
+            }
+          : {}
+      };
+    }));
+  }
+
   function compactForStorage(items, helpers = {}) {
     const normalizeField = helpers.normalizeField || (value => String(value || ''));
     const normalizeDisplay = helpers.normalizeDisplay || normalizeField;
@@ -204,6 +252,11 @@
       .slice(-MAX_ITEMS)
       .map(item => {
         const payload = item?.payload && typeof item.payload === 'object' ? item.payload : {};
+        const snapshot = RunExecutionSnapshot.captureRawQueueTuple(item, payload);
+        const compactSnapshot = RunExecutionSnapshot.cloneSnapshot({
+          ...snapshot,
+          focusFiles: normalizePaths(snapshot.focusFiles)
+        });
         return {
           id: normalizeField(item?.id, 160),
           clientUserMessageId: normalizeField(item?.clientUserMessageId, 160),
@@ -215,17 +268,8 @@
           linkedRunId: normalizeField(item?.linkedRunId, 160),
           claimToken: normalizeField(item?.claimToken, 160),
           pauseReason: normalizeField(item?.pauseReason, 160),
-          payload: {
-            mode: typeof payload.mode === 'string' ? payload.mode : 'ask',
-            providerId: normalizeField(payload.providerId, 160) || 'builtin',
-            providerRevision: normalizeField(payload.providerRevision, 160),
-            model: normalizeField(payload.model, 160),
-            reasoningEffort: normalizeField(payload.reasoningEffort, 32),
-            speedTier: payload.speedTier === 'fast' ? 'fast' : 'standard',
-            autoRecompile: payload.autoRecompile !== false,
-            requireReviewing: payload.requireReviewing !== false,
-            focusFiles: normalizePaths(payload.focusFiles)
-          }
+          executionSnapshot: compactSnapshot,
+          payload: RunExecutionSnapshot.toQueuePayload(compactSnapshot)
         };
       })
       .filter(item => item.id && item.text);
@@ -238,10 +282,13 @@
   return {
     MAX_ITEMS,
     MAX_QUEUE_BYTES,
+    MAX_PERSISTED_QUEUE_BYTES,
     MAX_TEXT_CHARS,
     claimNext,
     compactForStorage,
     enqueue,
+    estimateBytes,
+    estimateLegacyBytes,
     markExecuting,
     markSteering,
     normalizeQueue,

package/extension/src/shared/scopedPersistenceBrowserAdapter.js

@@ -0,0 +1,79 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('./scopedPersistenceQueuePolicy'));
+  } else {
+    root.CodexOverleafModuleRegistry.define(
+      'ScopedPersistenceBrowserAdapter',
+      ['ScopedPersistenceQueuePolicy'],
+      factory
+    );
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function (QueuePolicy) {
+  'use strict';
+
+  var META_PREFIX = 'codex-overleaf-scoped-persistence-v1:';
+  var fallbackMeta = new Map();
+  var cleanPart = QueuePolicy.cleanPart;
+  var normalizeMeta = QueuePolicy.normalizeMeta;
+
+  function normalizeScope(input) {
+    return Object.freeze({
+      accountScopeId: cleanPart(input && input.accountScopeId),
+      projectId: cleanPart(input && input.projectId)
+    });
+  }
+
+  function scopeKey(scope) {
+    var normalized = normalizeScope(scope);
+    if (!normalized.accountScopeId) {
+      var error = new Error('A stable account scope is required for durable persistence.');
+      error.code = 'account_scope_unavailable';
+      throw error;
+    }
+    return META_PREFIX + encodeURIComponent(normalized.accountScopeId)
+      + ':' + encodeURIComponent(normalized.projectId);
+  }
+
+  function createBrowserAdapter(options) {
+    options = options || {};
+    var chromeApi = options.chromeApi || (typeof chrome !== 'undefined' ? chrome : null);
+    var locksApi = Object.prototype.hasOwnProperty.call(options, 'locksApi')
+      ? options.locksApi
+      : (typeof navigator !== 'undefined' ? navigator.locks : null);
+    return {
+      async read(scope) {
+        var key = scopeKey(scope);
+        if (!chromeApi || !chromeApi.storage || !chromeApi.storage.local) {
+          return normalizeMeta(fallbackMeta.get(key));
+        }
+        var stored = await chromeApi.storage.local.get(key);
+        return normalizeMeta(stored && stored[key]);
+      },
+      async write(scope, meta) {
+        var key = scopeKey(scope);
+        var normalized = normalizeMeta(meta);
+        if (!chromeApi || !chromeApi.storage || !chromeApi.storage.local) {
+          fallbackMeta.set(key, normalized);
+          return normalized;
+        }
+        await chromeApi.storage.local.set({ [key]: normalized });
+        return normalized;
+      },
+      withLock(scope, work) {
+        var key = scopeKey(scope);
+        if (locksApi && typeof locksApi.request === 'function') {
+          return locksApi.request(key, { mode: 'exclusive' }, work);
+        }
+        var error = new Error('A cross-realm browser lock is required for durable persistence.');
+        error.code = 'storage_lock_unavailable';
+        return Promise.reject(error);
+      }
+    };
+  }
+
+  return Object.freeze({
+    createBrowserAdapter: createBrowserAdapter,
+    normalizeScope: normalizeScope,
+    scopeKey: scopeKey
+  });
+});