codex-overleaf-link 2.2.1 → 2.3.1

package/extension/src/content/generated/content.bundle.meta.json

@@ -0,0 +1,103 @@
+{
+  "schemaVersion": 1,
+  "entry": "extension/entries/content-entry.mjs",
+  "output": "extension/src/content/generated/content.bundle.js",
+  "sourceDigest": "ddbc07ac8d34d864aa3648c53211c5858e0312a73df815a0392bc52ec5eac1cc",
+  "outputDigest": "42051c8624bdfca3094c8bef2430094e55b7e1ec49d475ac27f6df14629bf313",
+  "byteLength": 2285557,
+  "inputs": [
+    "extension/entries/content-entry.mjs",
+    "extension/src/content/activeTurnControl.js",
+    "extension/src/content/applyResultFormatters.js",
+    "extension/src/content/composerAttachments.js",
+    "extension/src/content/composerPanel.js",
+    "extension/src/content/contentRuntime.js",
+    "extension/src/content/contextTray.js",
+    "extension/src/content/diagnosticsController.js",
+    "extension/src/content/diagnosticsPanel.js",
+    "extension/src/content/diffReviewPanel.js",
+    "extension/src/content/legacyGlobalRegistry.js",
+    "extension/src/content/localSkillsPanel.js",
+    "extension/src/content/markdownDomRenderer.js",
+    "extension/src/content/markdownText.js",
+    "extension/src/content/mathText.js",
+    "extension/src/content/mirrorHealth.js",
+    "extension/src/content/modelPicker.js",
+    "extension/src/content/modelPickerSupport.js",
+    "extension/src/content/moduleRegistryKernel.js",
+    "extension/src/content/nativeChannel.js",
+    "extension/src/content/nativeCompatibilityController.js",
+    "extension/src/content/otWarmMirror.js",
+    "extension/src/content/otWarmMirrorController.js",
+    "extension/src/content/pageBridgeClient.js",
+    "extension/src/content/panelMaintenance.js",
+    "extension/src/content/panelRenderer.js",
+    "extension/src/content/pendingInputView.js",
+    "extension/src/content/postNavigationSettlementPersistence.js",
+    "extension/src/content/projectProviderSelection.js",
+    "extension/src/content/projectSessionCleanup.js",
+    "extension/src/content/projectSettingsCoordinator.js",
+    "extension/src/content/providerSettingsCoordinator.js",
+    "extension/src/content/providerSettingsDialog.js",
+    "extension/src/content/recentProjects.js",
+    "extension/src/content/reviewHunks.js",
+    "extension/src/content/runController.js",
+    "extension/src/content/runGuidanceController.js",
+    "extension/src/content/runGuidanceView.js",
+    "extension/src/content/runQueueScheduler.js",
+    "extension/src/content/runSettlementPersistence.js",
+    "extension/src/content/runTimelineView.js",
+    "extension/src/content/scopedPersistenceCoordinator.js",
+    "extension/src/content/scopedPersistenceDetachedCommit.js",
+    "extension/src/content/scopedPersistencePanelState.js",
+    "extension/src/content/sessionManager.js",
+    "extension/src/content/sessionMenuView.js",
+    "extension/src/content/sessionPanel.js",
+    "extension/src/content/sessionPersistence.js",
+    "extension/src/content/settingsPanel.js",
+    "extension/src/content/themeController.js",
+    "extension/src/content/updateIdle.js",
+    "extension/src/content/updateNotice.js",
+    "extension/src/content/writebackController.js",
+    "extension/src/content/writebackOrchestrator.js",
+    "extension/src/shared/agentTranscript.js",
+    "extension/src/shared/auditRecords.js",
+    "extension/src/shared/compatibility.js",
+    "extension/src/shared/compileAdapter.js",
+    "extension/src/shared/failureReasons.js",
+    "extension/src/shared/governanceRules.js",
+    "extension/src/shared/i18n.js",
+    "extension/src/shared/lineReferences.js",
+    "extension/src/shared/managedUpdateProjection.js",
+    "extension/src/shared/models.js",
+    "extension/src/shared/otText.js",
+    "extension/src/shared/pageRpcContract.js",
+    "extension/src/shared/pathRedaction.js",
+    "extension/src/shared/projectFiles.js",
+    "extension/src/shared/providerProfiles.js",
+    "extension/src/shared/reviewing.js",
+    "extension/src/shared/runExecutionSnapshot.js",
+    "extension/src/shared/runExecutionSnapshotCodec.js",
+    "extension/src/shared/runInputQueue.js",
+    "extension/src/shared/scopedPersistenceBrowserAdapter.js",
+    "extension/src/shared/scopedPersistenceQueuePolicy.js",
+    "extension/src/shared/scopedPersistenceReceipt.js",
+    "extension/src/shared/scopedPersistenceTransaction.js",
+    "extension/src/shared/sensitiveScan.js",
+    "extension/src/shared/sessionState.js",
+    "extension/src/shared/settlementFacts.js",
+    "extension/src/shared/staleGuard.js",
+    "extension/src/shared/storageDb.js",
+    "extension/src/shared/storageKeys.js",
+    "extension/src/shared/storageMigration.js",
+    "extension/src/shared/storageRunActions.js",
+    "extension/src/shared/storageSessionClaims.js",
+    "extension/src/shared/summary.js",
+    "extension/src/shared/undoOperations.js",
+    "extension/src/shared/writebackEvidenceProjection.js",
+    "extension/src/shared/writebackOperationEvidence.js",
+    "extension/src/shared/writebackSettlement.js",
+    "extension/vendor/katex/katex.min.js",
+    "extension/vendor/markdown-it/markdown-it.min.js"
+  ]
+}

package/extension/src/content/legacyGlobalRegistry.js

@@ -0,0 +1,129 @@
+(function initCodexOverleafLegacyGlobalRegistry(root, factory) {
+  'use strict';
+
+  const api = factory();
+  if (typeof module === 'object' && module.exports) {
+    module.exports = api;
+  }
+  if (root) {
+    root.CodexOverleafLegacyGlobalRegistry = api;
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function legacyGlobalRegistryFactory() {
+  'use strict';
+
+  const REQUIRED_MODULES = Object.freeze([
+    'ActiveTurnControl',
+    'AgentTranscript',
+    'ApplyResultFormatters',
+    'AuditRecords',
+    'Compatibility',
+    'ComposerAttachments',
+    'ComposerPanel',
+    'ContentRuntime',
+    'ContextTray',
+    'DiagnosticsController',
+    'DiagnosticsPanel',
+    'DiffReviewPanel',
+    'FailureReasons',
+    'GovernanceRules',
+    'I18n',
+    'LineReferences',
+    'LocalSkillsPanel',
+    'MarkdownText',
+    'MirrorHealth',
+    'ModelPicker',
+    'NativeChannel',
+    'NativeCompatibilityController',
+    'OtWarmMirror',
+    'OtWarmMirrorController',
+    'PageBridgeClient',
+    'PageRpcContract',
+    'PanelMaintenance',
+    'PanelRenderer',
+    'PendingInputView',
+    'PostNavigationSettlementPersistence',
+    'ProjectFiles',
+    'ProjectProviderSelection',
+    'ProjectSettingsCoordinator',
+    'ProviderSettingsCoordinator',
+    'RecentProjects',
+    'ReviewHunks',
+    'RunController',
+    'RunExecutionSnapshot',
+    'RunGuidanceController',
+    'RunInputQueue',
+    'RunQueueScheduler',
+    'RunSettlementPersistence',
+    'RunTimelineView',
+    'ScopedPersistenceCoordinator',
+    'ScopedPersistenceTransaction',
+    'SensitiveScan',
+    'SessionManager',
+    'SessionPanel',
+    'SessionPersistence',
+    'SessionState',
+    'SettingsPanel',
+    'StorageDb',
+    'StorageKeys',
+    'StorageMigration',
+    'Summary',
+    'Theme',
+    'UndoOperations',
+    'UpdateIdle',
+    'UpdateNotice',
+    'WritebackController',
+    'WritebackOrchestrator',
+    'WritebackSettlement'
+  ]);
+
+  const SUPPORT_MODULES = Object.freeze([
+    'CompileAdapter',
+    'MarkdownDomRenderer',
+    'MathText',
+    'ModelPickerSupport',
+    'ProjectSessionCleanup',
+    'ProviderProfiles',
+    'ProviderSettingsDialog',
+    'RunGuidanceView',
+    'SessionMenuView'
+  ]);
+
+  function create(root) {
+    if (!root || typeof root !== 'object') {
+      throw new TypeError('Codex Overleaf content startup requires a browser global.');
+    }
+    const modules = {};
+    const missing = [];
+    for (const name of [...REQUIRED_MODULES, ...SUPPORT_MODULES]) {
+      const value = root[`CodexOverleaf${name}`];
+      if (!value) {
+        missing.push(`CodexOverleaf${name}`);
+      } else {
+        modules[name] = value;
+      }
+    }
+    if (missing.length) {
+      const error = new Error(`Codex Overleaf content dependencies are missing: ${missing.join(', ')}`);
+      error.code = 'content_dependency_missing';
+      error.missing = missing;
+      throw error;
+    }
+    const vendor = Object.freeze({
+      katex: root.katex || null,
+      markdownit: root.markdownit || null
+    });
+    return Object.freeze({
+      root,
+      chromeApi: root.chrome,
+      document: root.document,
+      modules: Object.freeze(modules),
+      vendor
+    });
+  }
+
+  return Object.freeze({
+    create,
+    requiredModules: REQUIRED_MODULES,
+    supportModules: SUPPORT_MODULES
+  });
+});

package/extension/src/content/markdownText.js

@@ -1,8 +1,6 @@
 (function initCodexOverleafMarkdownText() {
   'use strict';
 
-  const LineReferences = window.CodexOverleafLineReferences;
-
   // Markdown / assistant-text rendering — block + inline markdown, the
   // assistant-visible sanitizers, and line-reference resolution/buttons carved
   // out of contentRuntime.js (v1.4.5 structural-debt phase 1). The code below
@@ -10,15 +8,19 @@
   // are factory-injected so behavior is unchanged.
   function create(deps = {}) {
     const {
+      LineReferences,
+      MathText,
       tx,
-      callPageBridge,
+      callPageBridge, getCurrentProjectId,
       getCurrentProjectReferenceFiles,
+      getCurrentProjectMathSources,
       showPluginToast
     } = deps;
 
   function renderMarkdownInlineText(target, value) {
     target.replaceChildren(...buildMarkdownInlineNodes(value));
   }
+  function getMathMacros() { return MathText?.buildMathMacros?.(getCurrentProjectMathSources?.() || []) || {}; }
 
   function sanitizeAssistantVisibleText(value) {
     if (typeof value !== 'string' || !value) {
@@ -63,17 +65,12 @@
 
   function buildMarkdownInlineNodes(value) {
     const source = String(value || '');
-    const mathText = typeof window !== 'undefined'
-      ? window.CodexOverleafMathText
-      : null;
+    const mathText = MathText;
     if (!mathText?.buildMathNodes) {
       return buildMarkdownInlineNodesWithoutMath(source);
     }
-    return mathText.buildMathNodes(source, {
-      document,
-      katex: window.katex,
-      renderText: buildMarkdownInlineNodesWithoutMath
-    });
+    return mathText.buildMathNodes(source, { document, katex: window.katex,
+      macros: getMathMacros(), renderText: buildMarkdownInlineNodesWithoutMath });
   }
 
   function buildMarkdownInlineNodesWithoutMath(value) {
@@ -111,6 +108,10 @@
   function buildInlineCodeNodes(value) {
     const source = String(value || '');
     const trimmed = source.trim();
+    const standaloneMath = MathText?.parseStandaloneMath?.(trimmed);
+    if (standaloneMath && MathText?.createMathNode) return [MathText.createMathNode(
+      standaloneMath, { document, katex: window.katex, macros: getMathMacros() }
+    )];
     const refs = trimmed ? parseRuntimeLineReferences(trimmed, 'plain-text-token') : [];
     const ref = refs.length === 1 && refs[0]?.rawText === trimmed ? refs[0] : null;
     if (ref && !isRuntimeLocalPathLike(ref.rawPath)) {
@@ -287,7 +288,7 @@
       button.disabled = true;
       button.dataset.status = 'pending';
       try {
-        const result = await callPageBridge('jumpToPosition', params);
+        const result = await callPageBridge('jumpToPosition', { ...params, runProjectId: getCurrentProjectId?.() || '' });
         if (result?.ok === false) {
           button.dataset.status = 'failed';
           button.title = tx('Could not open that referenced line.', '无法打开引用的行。');
@@ -494,12 +495,11 @@
               `[${safeLabel.replace(/]/g, '\\]')}](${target.replace(/\)/g, '\\)')})`
             );
           },
-          renderCodeNodes: text => buildMarkdownInlineNodes(`\`${String(text || '').replace(/`/g, '\\`')}\``),
+          renderCodeNodes: text => buildInlineCodeNodes(text),
           sanitizeText: sanitizeAssistantVisibleText,
-          createMathNode: segment => runtimeRoot.CodexOverleafMathText.createMathNode(segment, {
-            document, katex: runtimeRoot.katex,
-            renderText: text => buildMarkdownInlineNodes(text)
-          }),
+          createMathNode: segment => runtimeRoot.CodexOverleafMathText.createMathNode(segment,
+            { document, katex: runtimeRoot.katex, macros: getMathMacros(),
+              renderText: text => buildMarkdownInlineNodes(text) }),
           recordDiagnostic: recordRenderingDiagnostic
         });
         return;

package/extension/src/content/mathText.js

@@ -9,6 +9,19 @@
   ]);
   const LONG_INLINE_MATH_CHARS = 120;
   const COMPLEX_INLINE_MATH_CHARS = 80;
+  const MAX_PROJECT_MACRO_SOURCES = 12;
+  const MAX_PROJECT_MACRO_SOURCE_CHARS = 256 * 1024;
+  const MAX_PROJECT_MACROS = 64;
+  const MAX_MACRO_EXPANSION_CHARS = 512;
+  const DEFAULT_MATH_MACROS = Object.freeze({
+    '\\E': '\\mathbb{E}',
+    '\\Var': '\\operatorname{Var}',
+    '\\Cov': '\\operatorname{Cov}',
+    '\\R': '\\mathbb{R}',
+    '\\N': '\\mathbb{N}',
+    '\\Z': '\\mathbb{Z}'
+  });
+  const UNSAFE_MACRO_PATTERN = /\\(?:href|url|includegraphics|input|include|write|openout|read|html\w*|class|style|data|def|gdef|edef|xdef|newcommand|renewcommand|providecommand|DeclareMathOperator)\b/i;
 
   function parseMathSegments(value) {
     const source = String(value || '');
@@ -74,9 +87,10 @@
         searchFrom = start + delimiter.open.length;
         continue;
       }
-      const value = source.slice(start + delimiter.open.length, closeStart);
+      const rawValue = source.slice(start + delimiter.open.length, closeStart);
+      const value = rawValue.trim();
       const end = closeStart + delimiter.close.length;
-      if (!isValidMathValue(value, delimiter) || overlapsCodeRange(start, end, codeRanges)) {
+      if (!isValidMathValue(rawValue, delimiter) || overlapsCodeRange(start, end, codeRanges)) {
         searchFrom = start + delimiter.open.length;
         continue;
       }
@@ -94,7 +108,7 @@
     }
     const previous = source[index - 1] || '';
     const next = source[index + 1] || '';
-    return previous !== '$' && next !== '$' && next !== '' && !/\s/.test(next);
+    return previous !== '$' && next !== '$' && next !== '';
   }
 
   function findClosingDelimiter(source, fromIndex, delimiter, codeRanges) {
@@ -107,7 +121,7 @@
       const previous = source[index - 1] || '';
       const next = source[index + delimiter.close.length] || '';
       const invalidSingleDollar = delimiter.singleDollar
-        && (previous === '$' || next === '$' || /\s/.test(previous));
+        && (previous === '$' || next === '$');
       if (!isEscaped(source, index) && !isInsideRange(index, codeRanges) && !invalidSingleDollar) {
         return index;
       }
@@ -118,10 +132,24 @@
 
   function isValidMathValue(value, delimiter) {
     const source = String(value || '');
-    if (!source.trim()) {
+    const trimmed = source.trim();
+    if (!trimmed) {
       return false;
     }
-    return delimiter.display || !/[\r\n]/.test(source);
+    if (!delimiter.display && /[\r\n]/.test(source)) {
+      return false;
+    }
+    if (!delimiter.singleDollar || (!/^\s/.test(source) && !/\s$/.test(source))) {
+      return true;
+    }
+    return looksLikeWhitespaceWrappedMath(trimmed);
+  }
+
+  function looksLikeWhitespaceWrappedMath(value) {
+    const source = String(value || '').trim();
+    return /\\[A-Za-z]+/.test(source)
+      || /[_^=<>+\-*/()[\]{}|]/.test(source)
+      || /^[A-Za-z](?:_[A-Za-z0-9{}]+|\^[A-Za-z0-9{}]+)?$/.test(source);
   }
 
   function collectInlineCodeRanges(source) {
@@ -179,7 +207,8 @@
       }
       nodes.push(createMathNode(segment, {
         document: documentRef,
-        katex: options.katex || root.katex
+        katex: options.katex || root.katex,
+        macros: options.macros || buildMathMacros(options.projectSources)
       }));
     }
     return nodes;
@@ -206,6 +235,7 @@
         strict: 'warn',
         maxExpand: 200,
         maxSize: 20,
+        macros: options.macros || buildMathMacros(),
         output: 'htmlAndMathml'
       });
       node.dataset.mathRendered = 'true';
@@ -213,7 +243,7 @@
     } catch (_error) {
       node.classList.add('run-math--fallback');
       node.dataset.mathRendered = 'false';
-      node.textContent = segment.raw;
+      node.textContent = source;
       return node;
     }
   }
@@ -235,6 +265,120 @@
     return /(?:=|\\(?:le|ge|approx|sim|to|Rightarrow|Longrightarrow)\b|\\begin\{(?:aligned|gathered|split|array)\}|\\\\)/.test(source);
   }
 
+  function parseStandaloneMath(value) {
+    const source = String(value || '').trim();
+    if (!source) {
+      return null;
+    }
+    const segments = parseMathSegments(source);
+    if (segments.length !== 1 || segments[0].type !== 'math' || segments[0].raw !== source) {
+      return null;
+    }
+    return segments[0];
+  }
+
+  function buildMathMacros(projectSources = []) {
+    const macros = { ...DEFAULT_MATH_MACROS };
+    let remainingChars = MAX_PROJECT_MACRO_SOURCE_CHARS;
+    let projectMacroCount = 0;
+    for (const sourceRecord of Array.isArray(projectSources)
+      ? projectSources.slice(0, MAX_PROJECT_MACRO_SOURCES)
+      : []) {
+      if (projectMacroCount >= MAX_PROJECT_MACROS || remainingChars <= 0) {
+        break;
+      }
+      const path = String(sourceRecord?.path || '');
+      if (!/\.(?:tex|sty|cls|ltx)$/i.test(path)) {
+        continue;
+      }
+      const source = stripLatexComments(
+        String(sourceRecord?.content || '').slice(0, remainingChars)
+      );
+      remainingChars -= source.length;
+      const pattern = /\\(newcommand|renewcommand|providecommand|DeclareMathOperator)(\*)?/g;
+      let match;
+      while ((match = pattern.exec(source)) !== null && projectMacroCount < MAX_PROJECT_MACROS) {
+        let cursor = skipWhitespace(source, pattern.lastIndex);
+        const nameGroup = readBracedGroup(source, cursor);
+        if (!nameGroup) {
+          continue;
+        }
+        const macroName = nameGroup.value.trim();
+        cursor = skipWhitespace(source, nameGroup.end);
+        if (source[cursor] === '[') {
+          continue;
+        }
+        const expansionGroup = readBracedGroup(source, cursor);
+        if (!expansionGroup) {
+          continue;
+        }
+        let expansion = expansionGroup.value.trim();
+        if (match[1] === 'DeclareMathOperator') {
+          expansion = `\\operatorname${match[2] ? '*' : ''}{${expansion}}`;
+        }
+        if (!isSafeMacroDefinition(macroName, expansion)) {
+          continue;
+        }
+        macros[macroName] = expansion;
+        projectMacroCount++;
+        pattern.lastIndex = expansionGroup.end;
+      }
+    }
+    return macros;
+  }
+
+  function readBracedGroup(source, start) {
+    if (source[start] !== '{') {
+      return null;
+    }
+    let depth = 0;
+    for (let index = start; index < source.length; index++) {
+      if (source[index] === '{' && !isEscaped(source, index)) {
+        depth++;
+      } else if (source[index] === '}' && !isEscaped(source, index)) {
+        depth--;
+        if (depth === 0) {
+          return {
+            value: source.slice(start + 1, index),
+            end: index + 1
+          };
+        }
+      }
+    }
+    return null;
+  }
+
+  function skipWhitespace(source, start) {
+    let index = start;
+    while (index < source.length && /\s/.test(source[index])) {
+      index++;
+    }
+    return index;
+  }
+
+  function stripLatexComments(source) {
+    return String(source || '').split(/\r?\n/).map(line => {
+      for (let index = 0; index < line.length; index++) {
+        if (line[index] === '%' && !isEscaped(line, index)) {
+          return line.slice(0, index);
+        }
+      }
+      return line;
+    }).join('\n');
+  }
+
+  function isSafeMacroDefinition(name, expansion) {
+    const macroName = String(name || '');
+    const body = String(expansion || '');
+    return /^\\[A-Za-z@]+$/.test(macroName)
+      && body.length > 0
+      && body.length <= MAX_MACRO_EXPANSION_CHARS
+      && !body.includes('#')
+      && !body.includes(macroName)
+      && !UNSAFE_MACRO_PATTERN.test(macroName)
+      && !UNSAFE_MACRO_PATTERN.test(body);
+  }
+
   function toNodeArray(value) {
     if (Array.isArray(value)) {
       return value;
@@ -265,11 +409,13 @@
   }
 
   const api = {
+    buildMathMacros,
     buildMathNodes,
     createMathNode,
     matchMathAt,
     normalizeMathForRendering,
-    parseMathSegments
+    parseMathSegments,
+    parseStandaloneMath
   };
   root.CodexOverleafMathText = api;
   if (typeof module !== 'undefined' && module.exports) {

package/extension/src/content/modelPicker.js

@@ -24,7 +24,7 @@
       getPanel,
       getState
     } = deps;
-    const Support = window.CodexOverleafModelPickerSupport;
+    const Support = deps.Support;
     const {
       formatCompactModelLabel,
       normalizeModelOptionId,

package/extension/src/content/modelPickerSupport.js

@@ -1,4 +1,10 @@
-(function initCodexOverleafModelPickerSupport(root) {
+(function initCodexOverleafModelPickerSupport(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory(require('../shared/models'));
+  } else {
+    root.CodexOverleafModuleRegistry.define('ModelPickerSupport', ['Models'], factory);
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function modelPickerSupportFactory(Models) {
   'use strict';
 
   function normalizeModelOptionId(id) {
@@ -37,7 +43,7 @@
   }
 
   function getModelCatalog({ getPanel } = {}) {
-    const shared = root.CodexOverleafModels;
+    const shared = Models;
     if (Array.isArray(shared?.FALLBACK_MODELS) && typeof shared?.normalizeDiscoveredModels === 'function') {
       return shared;
     }
@@ -110,6 +116,5 @@
     retainSelectedModel,
     shouldUseBuiltInFallback
   };
-  root.CodexOverleafModelPickerSupport = api;
-  if (typeof module === 'object' && module.exports) module.exports = api;
-})(typeof window !== 'undefined' ? window : globalThis);
+  return api;
+});