update

## Summary
- add a dedicated edit table of contents tool to the React UI, complete
with bookmark editor, import/export actions, and parameter handling
- register the tool in the translated registry and extend the English
translations with the new strings
- wire up the backend endpoints through a new operation hook and
form-data serialization helpers

## Testing
- ./gradlew build

------
[Codex
Task](https://chatgpt.com/codex/tasks/task_b_691a4a87a9c4832899ecd1c55989f27f)

---------

Co-authored-by: Reece Browne <74901996+reecebrowne@users.noreply.github.com>

app/common/src/main/java/stirling/software/common/annotations/api/InviteApi.java

@@ -0,0 +1,37 @@
+package stirling.software.common.annotations.api;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+/**
+ * Combined annotation for Invite management controllers.
+ * Includes @RestController, @RequestMapping("/api/v1/invite"), and OpenAPI @Tag.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@RestController
+@RequestMapping("/api/v1/invite")
+@Tag(
+        name = "Invite",
+        description =
+                """
+                Invite-link generation and acceptance endpoints for onboarding new users.
+
+                Provides the ability to issue invitation tokens, send optional email invites,
+                validate and accept invite links, and manage pending invitations for teams.
+
+                Typical use cases include:
+                • Admin workflows for issuing time-limited invitations to external users
+                • Self-service invite acceptance and team assignment
+                • License limit enforcement when provisioning new accounts
+
+                Target users: administrators and automation scripts orchestrating user onboarding.
+                """)
+public @interface InviteApi {}

app/core/src/main/java/stirling/software/SPDF/config/WebMvcConfig.java

@@ -63,13 +63,51 @@ public class WebMvcConfig implements WebMvcConfigurer {
                             .toArray(new String[0]);
 
             registry.addMapping("/**")
-                    .allowedOrigins(allowedOrigins)
-                    .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH")
-                    .allowedHeaders("*")
+                    .allowedOriginPatterns(allowedOrigins)
+                    .allowedMethods("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS")
+                    .allowedHeaders(
+                            "Authorization",
+                            "Content-Type",
+                            "X-Requested-With",
+                            "Accept",
+                            "Origin",
+                            "X-API-KEY",
+                            "X-CSRF-TOKEN",
+                            "X-XSRF-TOKEN")
+                    .exposedHeaders(
+                            "WWW-Authenticate",
+                            "X-Total-Count",
+                            "X-Page-Number",
+                            "X-Page-Size",
+                            "Content-Disposition",
+                            "Content-Type")
+                    .allowCredentials(true)
+                    .maxAge(3600);
+        } else {
+            // Default to allowing all origins when nothing is configured
+            logger.info(
+                    "No CORS allowed origins configured in settings.yml (system.corsAllowedOrigins); allowing all origins.");
+            registry.addMapping("/**")
+                    .allowedOriginPatterns("*")
+                    .allowedMethods("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS")
+                    .allowedHeaders(
+                            "Authorization",
+                            "Content-Type",
+                            "X-Requested-With",
+                            "Accept",
+                            "Origin",
+                            "X-API-KEY",
+                            "X-CSRF-TOKEN",
+                            "X-XSRF-TOKEN")
+                    .exposedHeaders(
+                            "WWW-Authenticate",
+                            "X-Total-Count",
+                            "X-Page-Number",
+                            "X-Page-Size",
+                            "Content-Disposition",
+                            "Content-Type")
                     .allowCredentials(true)
                     .maxAge(3600);
         }
-        // If no origins are configured and not in Tauri mode, CORS is not enabled (secure by
-        // default)
     }
 }

app/core/src/main/java/stirling/software/SPDF/controller/api/EditTableOfContentsController.java

@@ -29,7 +29,6 @@ import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 
-import stirling.software.SPDF.config.swagger.JsonDataResponse;
 import stirling.software.SPDF.config.swagger.StandardPdfResponse;
 import stirling.software.SPDF.model.api.EditTableOfContentsRequest;
 import stirling.software.common.annotations.AutoJobPostMapping;
@@ -49,13 +48,12 @@ public class EditTableOfContentsController {
     @AutoJobPostMapping(
             value = "/extract-bookmarks",
             consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
-    @JsonDataResponse
     @Operation(
             summary = "Extract PDF Bookmarks",
             description = "Extracts bookmarks/table of contents from a PDF document as JSON.")
     @ResponseBody
-    public List<Map<String, Object>> extractBookmarks(@RequestParam("file") MultipartFile file)
-            throws Exception {
+    public ResponseEntity<List<Map<String, Object>>> extractBookmarks(
+            @RequestParam("file") MultipartFile file) throws Exception {
         PDDocument document = null;
         try {
             document = pdfDocumentFactory.load(file);
@@ -63,10 +61,10 @@ public class EditTableOfContentsController {
 
             if (outline == null) {
                 log.info("No outline/bookmarks found in PDF");
-                return new ArrayList<>();
+                return ResponseEntity.ok(new ArrayList<>());
             }
 
-            return extractBookmarkItems(document, outline);
+            return ResponseEntity.ok(extractBookmarkItems(document, outline));
         } finally {
             if (document != null) {
                 document.close();

app/core/src/main/java/stirling/software/SPDF/controller/api/misc/ConfigController.java

@@ -154,6 +154,25 @@ public class ConfigController {
                 // EE features not available, continue without them
             }
 
+            // Add version and machine info for update checking
+            try {
+                if (applicationContext.containsBean("appVersion")) {
+                    configData.put(
+                            "appVersion", applicationContext.getBean("appVersion", String.class));
+                }
+                if (applicationContext.containsBean("machineType")) {
+                    configData.put(
+                            "machineType", applicationContext.getBean("machineType", String.class));
+                }
+                if (applicationContext.containsBean("activeSecurity")) {
+                    configData.put(
+                            "activeSecurity",
+                            applicationContext.getBean("activeSecurity", Boolean.class));
+                }
+            } catch (Exception e) {
+                // Version/machine info not available
+            }
+
             return ResponseEntity.ok(configData);
 
         } catch (Exception e) {

app/core/src/test/java/stirling/software/SPDF/controller/api/EditTableOfContentsControllerTest.java

@@ -24,6 +24,7 @@ import org.mockito.ArgumentMatchers;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.mock.web.MockMultipartFile;
@@ -86,9 +87,13 @@ class EditTableOfContentsControllerTest {
         when(mockOutlineItem.getNextSibling()).thenReturn(null);
 
         // When
-        List<Map<String, Object>> result = editTableOfContentsController.extractBookmarks(mockFile);
+        ResponseEntity<List<Map<String, Object>>> response =
+                editTableOfContentsController.extractBookmarks(mockFile);
 
         // Then
+        assertNotNull(response);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        List<Map<String, Object>> result = response.getBody();
         assertNotNull(result);
         assertEquals(1, result.size());
 
@@ -108,9 +113,13 @@ class EditTableOfContentsControllerTest {
         when(mockCatalog.getDocumentOutline()).thenReturn(null);
 
         // When
-        List<Map<String, Object>> result = editTableOfContentsController.extractBookmarks(mockFile);
+        ResponseEntity<List<Map<String, Object>>> response =
+                editTableOfContentsController.extractBookmarks(mockFile);
 
         // Then
+        assertNotNull(response);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        List<Map<String, Object>> result = response.getBody();
         assertNotNull(result);
         assertTrue(result.isEmpty());
         verify(mockDocument).close();
@@ -142,9 +151,13 @@ class EditTableOfContentsControllerTest {
         when(childItem.getNextSibling()).thenReturn(null);
 
         // When
-        List<Map<String, Object>> result = editTableOfContentsController.extractBookmarks(mockFile);
+        ResponseEntity<List<Map<String, Object>>> response =
+                editTableOfContentsController.extractBookmarks(mockFile);
 
         // Then
+        assertNotNull(response);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        List<Map<String, Object>> result = response.getBody();
         assertNotNull(result);
         assertEquals(1, result.size());
 
@@ -178,9 +191,13 @@ class EditTableOfContentsControllerTest {
         when(mockOutlineItem.getNextSibling()).thenReturn(null);
 
         // When
-        List<Map<String, Object>> result = editTableOfContentsController.extractBookmarks(mockFile);
+        ResponseEntity<List<Map<String, Object>>> response =
+                editTableOfContentsController.extractBookmarks(mockFile);
 
         // Then
+        assertNotNull(response);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        List<Map<String, Object>> result = response.getBody();
         assertNotNull(result);
         assertEquals(1, result.size());
 

app/proprietary/src/main/java/stirling/software/proprietary/security/configuration/SecurityConfiguration.java

@@ -129,61 +129,53 @@ public class SecurityConfiguration {
 
     @Bean
     public CorsConfigurationSource corsConfigurationSource() {
-        // Read CORS allowed origins from settings
-        if (applicationProperties.getSystem() != null
-                && applicationProperties.getSystem().getCorsAllowedOrigins() != null
-                && !applicationProperties.getSystem().getCorsAllowedOrigins().isEmpty()) {
+        List<String> configuredOrigins = null;
+        if (applicationProperties.getSystem() != null) {
+            configuredOrigins = applicationProperties.getSystem().getCorsAllowedOrigins();
+        }
 
-            List<String> allowedOrigins = applicationProperties.getSystem().getCorsAllowedOrigins();
-
-            CorsConfiguration cfg = new CorsConfiguration();
-
-            // Use setAllowedOriginPatterns for better wildcard and port support
-            cfg.setAllowedOriginPatterns(allowedOrigins);
+        CorsConfiguration cfg = new CorsConfiguration();
+        if (configuredOrigins != null && !configuredOrigins.isEmpty()) {
+            cfg.setAllowedOriginPatterns(configuredOrigins);
             log.debug(
                     "CORS configured with allowed origin patterns from settings.yml: {}",
-                    allowedOrigins);
-
-            // Set allowed methods explicitly (including OPTIONS for preflight)
-            cfg.setAllowedMethods(List.of("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"));
-
-            // Set allowed headers explicitly
-            cfg.setAllowedHeaders(
-                    List.of(
-                            "Authorization",
-                            "Content-Type",
-                            "X-Requested-With",
-                            "Accept",
-                            "Origin",
-                            "X-API-KEY",
-                            "X-CSRF-TOKEN"));
-
-            // Set exposed headers (headers that the browser can access)
-            cfg.setExposedHeaders(
-                    List.of(
-                            "WWW-Authenticate",
-                            "X-Total-Count",
-                            "X-Page-Number",
-                            "X-Page-Size",
-                            "Content-Disposition",
-                            "Content-Type"));
-
-            // Allow credentials (cookies, authorization headers)
-            cfg.setAllowCredentials(true);
-
-            // Set max age for preflight cache
-            cfg.setMaxAge(3600L);
-
-            UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
-            source.registerCorsConfiguration("/**", cfg);
-            return source;
+                    configuredOrigins);
         } else {
-            // No CORS origins configured - return null to disable CORS processing entirely
-            // This avoids empty CORS policy that unexpectedly rejects preflights
+            // Default to allowing all origins when nothing is configured
+            cfg.setAllowedOriginPatterns(List.of("*"));
             log.info(
-                    "CORS is disabled - no allowed origins configured in settings.yml (system.corsAllowedOrigins)");
-            return null;
+                    "No CORS allowed origins configured in settings.yml (system.corsAllowedOrigins); allowing all origins.");
         }
+
+        // Explicitly configure supported HTTP methods (include OPTIONS for preflight)
+        cfg.setAllowedMethods(List.of("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"));
+
+        cfg.setAllowedHeaders(
+                List.of(
+                        "Authorization",
+                        "Content-Type",
+                        "X-Requested-With",
+                        "Accept",
+                        "Origin",
+                        "X-API-KEY",
+                        "X-CSRF-TOKEN",
+                        "X-XSRF-TOKEN"));
+
+        cfg.setExposedHeaders(
+                List.of(
+                        "WWW-Authenticate",
+                        "X-Total-Count",
+                        "X-Page-Number",
+                        "X-Page-Size",
+                        "Content-Disposition",
+                        "Content-Type"));
+
+        cfg.setAllowCredentials(true);
+        cfg.setMaxAge(3600L);
+
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        source.registerCorsConfiguration("/**", cfg);
+        return source;
     }
 
     @Bean

app/proprietary/src/main/java/stirling/software/proprietary/security/controller/api/InviteLinkController.java

@@ -15,7 +15,7 @@ import jakarta.servlet.http.HttpServletRequest;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
-import stirling.software.common.annotations.api.UserApi;
+import stirling.software.common.annotations.api.InviteApi;
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.model.enumeration.Role;
 import stirling.software.proprietary.model.Team;
@@ -26,11 +26,9 @@ import stirling.software.proprietary.security.service.EmailService;
 import stirling.software.proprietary.security.service.TeamService;
 import stirling.software.proprietary.security.service.UserService;
 
-@UserApi
+@InviteApi
 @Slf4j
 @RequiredArgsConstructor
-@RestController
-@RequestMapping("/api/v1/invite")
 public class InviteLinkController {
 
     private final InviteTokenRepository inviteTokenRepository;

app/proprietary/src/main/java/stirling/software/proprietary/security/controller/api/UserController.java

@@ -36,8 +36,6 @@ import stirling.software.proprietary.model.Team;
 import stirling.software.proprietary.security.database.repository.UserRepository;
 import stirling.software.proprietary.security.model.AuthenticationType;
 import stirling.software.proprietary.security.model.User;
-import stirling.software.proprietary.security.model.api.user.UserSettingsRequest;
-import stirling.software.proprietary.security.model.api.user.UserSettingsResponse;
 import stirling.software.proprietary.security.model.api.user.UsernameAndPass;
 import stirling.software.proprietary.security.repository.TeamRepository;
 import stirling.software.proprietary.security.saml2.CustomSaml2AuthenticatedPrincipal;
@@ -61,37 +59,6 @@ public class UserController {
     private final Optional<EmailService> emailService;
     private final UserLicenseSettingsService licenseSettingsService;
 
-    @PreAuthorize("!hasAuthority('ROLE_DEMO_USER')")
-    @GetMapping("/settings")
-    public ResponseEntity<?> getUserSettings(Principal principal) {
-        if (principal == null) {
-            return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
-                    .body(Map.of("error", "notAuthenticated", "message", "User not authenticated"));
-        }
-        Map<String, String> settings = userService.getUserSettings(principal.getName());
-        if (settings == null) {
-            return ResponseEntity.status(HttpStatus.NOT_FOUND)
-                    .body(Map.of("error", "userNotFound", "message", "User not found"));
-        }
-        return ResponseEntity.ok(new UserSettingsResponse(settings));
-    }
-
-    @PreAuthorize("!hasAuthority('ROLE_DEMO_USER')")
-    @PutMapping("/settings")
-    @Audited(type = AuditEventType.USER_PROFILE_UPDATE, level = AuditLevel.BASIC)
-    public ResponseEntity<?> saveUserSettings(
-            @RequestBody UserSettingsRequest request, Principal principal)
-            throws SQLException, UnsupportedProviderException {
-        if (principal == null) {
-            return ResponseEntity.status(HttpStatus.UNAUTHORIZED)
-                    .body(Map.of("error", "notAuthenticated", "message", "User not authenticated"));
-        }
-        Map<String, String> updates =
-                request != null && request.settings() != null ? request.settings() : Map.of();
-        userService.updateUserSettings(principal.getName(), updates);
-        return ResponseEntity.ok(new UserSettingsResponse(updates));
-    }
-
     @PreAuthorize("!hasAuthority('ROLE_DEMO_USER')")
     @PostMapping("/register")
     public ResponseEntity<?> register(@RequestBody UsernameAndPass usernameAndPass)

app/proprietary/src/main/java/stirling/software/proprietary/security/model/api/user/UserSettingsRequest.java

@@ -1,10 +0,0 @@
-package stirling.software.proprietary.security.model.api.user;
-
-import java.util.Map;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-/** Request payload for updating a user's stored settings map. */
-public record UserSettingsRequest(
-        @Schema(description = "Key/value map of settings to persist for the user")
-                Map<String, String> settings) {}

app/proprietary/src/main/java/stirling/software/proprietary/security/model/api/user/UserSettingsResponse.java

@@ -1,10 +0,0 @@
-package stirling.software.proprietary.security.model.api.user;
-
-import java.util.Map;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-
-/** Response payload containing the user's stored settings map. */
-public record UserSettingsResponse(
-        @Schema(description = "Key/value map of the user's saved settings")
-                Map<String, String> settings) {}

app/proprietary/src/main/java/stirling/software/proprietary/security/service/UserService.java

@@ -3,7 +3,6 @@ package stirling.software.proprietary.security.service;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -372,28 +371,14 @@ public class UserService implements UserServiceInterface {
             if (settingsMap == null) {
                 settingsMap = new HashMap<>();
             }
-            Map<String, String> sanitizedUpdates =
-                    updates == null ? Collections.emptyMap() : new HashMap<>(updates);
             settingsMap.clear();
-            settingsMap.putAll(sanitizedUpdates);
+            settingsMap.putAll(updates);
             user.setSettings(settingsMap);
             userRepository.save(user);
             databaseService.exportDatabase();
         }
     }
 
-    public Map<String, String> getUserSettings(String username) {
-        Optional<User> userOpt = findByUsernameIgnoreCaseWithSettings(username);
-        if (userOpt.isEmpty()) {
-            return null;
-        }
-        Map<String, String> settingsMap = userOpt.get().getSettings();
-        if (settingsMap == null) {
-            return new HashMap<>();
-        }
-        return new HashMap<>(settingsMap);
-    }
-
     public Optional<User> findByUsername(String username) {
         return userRepository.findByUsername(username);
     }

frontend/public/locales/en-GB/translation.json

@@ -41,6 +41,30 @@
     "cancel": "Cancel",
     "confirm": "Extract"
   },
+  "defaultApp": {
+    "title": "Set as Default PDF App",
+    "message": "Would you like to set Stirling PDF as your default PDF editor?",
+    "description": "You can change this later in your system settings.",
+    "notNow": "Not Now",
+    "setDefault": "Set Default",
+    "dismiss": "Dismiss",
+    "prompt": {
+      "title": "Set as Default PDF Editor",
+      "message": "Make Stirling PDF your default application for opening PDF files."
+    },
+    "success": {
+      "title": "Default App Set",
+      "message": "Stirling PDF is now your default PDF editor"
+    },
+    "settingsOpened": {
+      "title": "Settings Opened",
+      "message": "Please select Stirling PDF in your system settings"
+    },
+    "error": {
+      "title": "Error",
+      "message": "Failed to set default PDF handler"
+    }
+  },
   "language": {
     "direction": "ltr"
   },
@@ -333,9 +357,20 @@
         "fullscreen": "Fullscreen",
         "sidebar": "Sidebar"
       },
-      "syncSettings": "Sync settings across devices",
-      "syncSettingsDescription": "Carry your theme, language, favourites, and hotkeys to other browsers when signed in.",
-      "syncSettingsTooltip": "Automatically back up your preferences to your account so they follow you on every device."
+      "defaultPdfEditor": "Default PDF editor",
+      "defaultPdfEditorActive": "Stirling PDF is your default PDF editor",
+      "defaultPdfEditorInactive": "Another application is set as default",
+      "defaultPdfEditorChecking": "Checking...",
+      "defaultPdfEditorSet": "Already Default",
+      "setAsDefault": "Set as Default",
+      "updates": {
+        "title": "Software Updates",
+        "description": "Check for updates and view version information",
+        "currentVersion": "Current Version",
+        "latestVersion": "Latest Version",
+        "checkForUpdates": "Check for Updates",
+        "viewDetails": "View Details"
+      }
     },
     "hotkeys": {
       "title": "Keyboard Shortcuts",
@@ -356,6 +391,37 @@
       "searchPlaceholder": "Search tools..."
     }
   },
+  "update": {
+    "modalTitle": "Update Available",
+    "current": "Current Version",
+    "latest": "Latest Version",
+    "latestStable": "Latest Stable",
+    "priorityLabel": "Priority",
+    "recommendedAction": "Recommended Action",
+    "breakingChangesDetected": "Breaking Changes Detected",
+    "breakingChangesMessage": "Some versions contain breaking changes. Please review the migration guides below before updating.",
+    "migrationGuides": "Migration Guides",
+    "viewGuide": "View Guide",
+    "loadingDetailedInfo": "Loading detailed information...",
+    "close": "Close",
+    "viewAllReleases": "View All Releases",
+    "downloadLatest": "Download Latest",
+    "availableUpdates": "Available Updates",
+    "unableToLoadDetails": "Unable to load detailed information.",
+    "version": "Version",
+    "urgentUpdateAvailable": "Urgent Update",
+    "updateAvailable": "Update Available",
+    "releaseNotes": "Release Notes",
+    "priority": {
+      "urgent": "Urgent",
+      "normal": "Normal",
+      "minor": "Minor",
+      "low": "Low"
+    },
+    "breakingChanges": "Breaking Changes",
+    "breakingChangesDefault": "This version contains breaking changes.",
+    "migrationGuide": "Migration Guide"
+  },
   "changeCreds": {
     "title": "Change Credentials",
     "header": "Update Your Account Details",
@@ -1400,6 +1466,93 @@
     },
     "submit": "Change"
   },
+  "editTableOfContents": {
+    "settings": {
+      "title": "Bookmarks & outline",
+      "replaceExisting": "Replace existing bookmarks (uncheck to append)",
+      "replaceExistingHint": "When disabled, the new outline is appended after the current bookmarks."
+    },
+    "actions": {
+      "source": "Load bookmarks",
+      "selectedFile": "Loaded from {{file}}",
+      "noFile": "Select a PDF to extract existing bookmarks.",
+      "loadFromPdf": "Load from selected PDF",
+      "importJson": "Import JSON",
+      "importClipboard": "Paste JSON from clipboard",
+      "export": "Export bookmarks",
+      "exportJson": "Download JSON",
+      "exportClipboard": "Copy JSON to clipboard",
+      "clipboardUnavailable": "Clipboard access is not available in this browser."
+    },
+    "info": {
+      "line1": "Each bookmark needs a descriptive title and the page it should open.",
+      "line2": "Use child bookmarks to build a hierarchy for chapters, sections, or subsections.",
+      "line3": "Import bookmarks from the selected PDF or from a JSON file to save time."
+    },
+    "workbench": {
+      "empty": {
+        "title": "Open the tool to start editing",
+        "description": "Select the Edit Table of Contents tool to load its workspace."
+      },
+      "tabTitle": "Outline workspace",
+      "subtitle": "Import bookmarks, build hierarchies, and apply the outline without cramped side panels.",
+      "noFile": "No PDF selected",
+      "fileLabel": "Changes will be applied to the currently selected PDF.",
+      "filePrompt": "Select a PDF from your library or upload a new one to begin.",
+      "changeFile": "Change PDF",
+      "selectFile": "Select PDF"
+    },
+    "editor": {
+      "heading": "Bookmark editor",
+      "description": "Add, nest, and reorder bookmarks to craft your PDF outline.",
+      "addTopLevel": "Add top-level bookmark",
+      "empty": {
+        "title": "No bookmarks yet",
+        "description": "Import existing bookmarks or start by adding your first entry.",
+        "action": "Add first bookmark"
+      },
+      "defaultTitle": "New bookmark",
+      "defaultChildTitle": "Child bookmark",
+      "defaultSiblingTitle": "New bookmark",
+      "untitled": "Untitled bookmark",
+      "childBadge": "Child",
+      "pagePreview": "Page {{page}}",
+      "field": {
+        "title": "Bookmark title",
+        "page": "Target page number"
+      },
+      "actions": {
+        "toggle": "Toggle children",
+        "addChild": "Add child bookmark",
+        "addSibling": "Add sibling bookmark",
+        "remove": "Remove bookmark"
+      },
+      "confirmRemove": "Remove this bookmark and all of its children?"
+    },
+    "messages": {
+      "loadedTitle": "Bookmarks extracted",
+      "loadedBody": "Existing bookmarks from the PDF were loaded into the editor.",
+      "noBookmarks": "No bookmarks were found in the selected PDF.",
+      "loadFailed": "Unable to extract bookmarks from the selected PDF.",
+      "imported": "Bookmarks imported",
+      "importedBody": "Your JSON outline replaced the current editor contents.",
+      "importedClipboard": "Clipboard data replaced the current bookmark list.",
+      "invalidJson": "Invalid JSON structure",
+      "invalidJsonBody": "Please provide a valid bookmark JSON file and try again.",
+      "exported": "JSON download ready",
+      "copied": "Copied to clipboard",
+      "copiedBody": "Bookmark JSON copied successfully.",
+      "copyFailed": "Copy failed"
+    },
+    "error": {
+      "failed": "Failed to update the table of contents"
+    },
+    "submit": "Apply table of contents",
+    "results": {
+      "title": "Updated PDF with bookmarks",
+      "subtitle": "Download the processed file or undo the operation below."
+    }
+  },
   "removePages": {
     "tags": "Remove pages,delete pages",
     "title": "Remove Pages",

frontend/src-tauri/Cargo.lock

@@ -643,6 +643,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "core-services"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0aa845ab21b847ee46954be761815f18f16469b29ef3ba250241b1b8bab659a"
+dependencies = [
+ "core-foundation 0.10.1",
+]
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -3941,6 +3950,8 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 name = "stirling-pdf"
 version = "0.1.0"
 dependencies = [
+ "core-foundation 0.10.1",
+ "core-services",
  "log",
  "reqwest 0.11.27",
  "serde",

frontend/src-tauri/Cargo.toml

@@ -31,3 +31,7 @@ tauri-plugin-fs = "2.4.4"
 tauri-plugin-single-instance = "2.0.1"
 tokio = { version = "1.0", features = ["time"] }
 reqwest = { version = "0.11", features = ["json"] }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+core-foundation = "0.10"
+core-services = "1.0"

frontend/src-tauri/src/commands/default_app.rs

@@ -0,0 +1,217 @@
+use crate::utils::add_log;
+
+#[cfg(any(target_os = "windows", target_os = "linux"))]
+use std::process::Command;
+
+/// Check if Stirling PDF is the default PDF handler
+#[tauri::command]
+pub fn is_default_pdf_handler() -> Result<bool, String> {
+    add_log("🔍 Checking if app is default PDF handler".to_string());
+
+    #[cfg(target_os = "windows")]
+    {
+        check_default_windows()
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        check_default_macos()
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        check_default_linux()
+    }
+}
+
+/// Attempt to set/prompt for Stirling PDF as default PDF handler
+#[tauri::command]
+pub fn set_as_default_pdf_handler() -> Result<String, String> {
+    add_log("⚙️ Attempting to set as default PDF handler".to_string());
+
+    #[cfg(target_os = "windows")]
+    {
+        set_default_windows()
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        set_default_macos()
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        set_default_linux()
+    }
+}
+
+// ============================================================================
+// Windows Implementation
+// ============================================================================
+
+#[cfg(target_os = "windows")]
+fn check_default_windows() -> Result<bool, String> {
+    use std::os::windows::process::CommandExt;
+    const CREATE_NO_WINDOW: u32 = 0x08000000;
+
+    // Query the default handler for .pdf extension
+    let output = Command::new("cmd")
+        .args(["/C", "assoc .pdf"])
+        .creation_flags(CREATE_NO_WINDOW)
+        .output()
+        .map_err(|e| format!("Failed to check default app: {}", e))?;
+
+    let assoc = String::from_utf8_lossy(&output.stdout);
+    add_log(format!("Windows PDF association: {}", assoc.trim()));
+
+    // Get the ProgID for .pdf files
+    if let Some(prog_id) = assoc.trim().strip_prefix(".pdf=") {
+        // Query what application handles this ProgID
+        let output = Command::new("cmd")
+            .args(["/C", &format!("ftype {}", prog_id)])
+            .creation_flags(CREATE_NO_WINDOW)
+            .output()
+            .map_err(|e| format!("Failed to query file type: {}", e))?;
+
+        let ftype = String::from_utf8_lossy(&output.stdout);
+        add_log(format!("Windows file type: {}", ftype.trim()));
+
+        // Check if it contains "Stirling" or our app name
+        let is_default = ftype.to_lowercase().contains("stirling");
+        Ok(is_default)
+    } else {
+        Ok(false)
+    }
+}
+
+#[cfg(target_os = "windows")]
+fn set_default_windows() -> Result<String, String> {
+    // On Windows 10+, we need to open the Default Apps settings
+    // as programmatic setting requires a signed installer
+    Command::new("cmd")
+        .args(["/C", "start", "ms-settings:defaultapps"])
+        .spawn()
+        .map_err(|e| format!("Failed to open default apps settings: {}", e))?;
+
+    add_log("Opened Windows Default Apps settings".to_string());
+    Ok("opened_settings".to_string())
+}
+
+// ============================================================================
+// macOS Implementation (using LaunchServices framework)
+// ============================================================================
+
+#[cfg(target_os = "macos")]
+fn check_default_macos() -> Result<bool, String> {
+    use core_foundation::base::TCFType;
+    use core_foundation::string::{CFString, CFStringRef};
+    use std::os::raw::c_int;
+
+    // Define the LSCopyDefaultRoleHandlerForContentType function
+    #[link(name = "CoreServices", kind = "framework")]
+    extern "C" {
+        fn LSCopyDefaultRoleHandlerForContentType(
+            content_type: CFStringRef,
+            role: c_int,
+        ) -> CFStringRef;
+    }
+
+    const K_LS_ROLES_ALL: c_int = 0xFFFFFFFF_u32 as c_int;
+
+    unsafe {
+        // Query the default handler for "com.adobe.pdf" (PDF UTI - standard macOS identifier)
+        let pdf_uti = CFString::new("com.adobe.pdf");
+        let handler_ref = LSCopyDefaultRoleHandlerForContentType(pdf_uti.as_concrete_TypeRef(), K_LS_ROLES_ALL);
+
+        if handler_ref.is_null() {
+            add_log("No default PDF handler found".to_string());
+            return Ok(false);
+        }
+
+        let handler = CFString::wrap_under_create_rule(handler_ref);
+        let handler_str = handler.to_string();
+        add_log(format!("macOS PDF handler: {}", handler_str));
+
+        // Check if it's our bundle identifier
+        let is_default = handler_str == "stirling.pdf.dev";
+        Ok(is_default)
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn set_default_macos() -> Result<String, String> {
+    use core_foundation::base::TCFType;
+    use core_foundation::string::{CFString, CFStringRef};
+    use std::os::raw::c_int;
+
+    // Define the LSSetDefaultRoleHandlerForContentType function
+    #[link(name = "CoreServices", kind = "framework")]
+    extern "C" {
+        fn LSSetDefaultRoleHandlerForContentType(
+            content_type: CFStringRef,
+            role: c_int,
+            handler_bundle_id: CFStringRef,
+        ) -> c_int; // OSStatus
+    }
+
+    const K_LS_ROLES_ALL: c_int = 0xFFFFFFFF_u32 as c_int;
+
+    unsafe {
+        // Set our app as the default handler for PDF files
+        let pdf_uti = CFString::new("com.adobe.pdf");
+        let our_bundle_id = CFString::new("stirling.pdf.dev");
+
+        let status = LSSetDefaultRoleHandlerForContentType(
+            pdf_uti.as_concrete_TypeRef(),
+            K_LS_ROLES_ALL,
+            our_bundle_id.as_concrete_TypeRef(),
+        );
+
+        if status == 0 {
+            add_log("Successfully triggered default app dialog".to_string());
+            Ok("set_successfully".to_string())
+        } else {
+            let error_msg = format!("LaunchServices returned status: {}", status);
+            add_log(error_msg.clone());
+            Err(error_msg)
+        }
+    }
+}
+
+// ============================================================================
+// Linux Implementation
+// ============================================================================
+
+#[cfg(target_os = "linux")]
+fn check_default_linux() -> Result<bool, String> {
+    // Use xdg-mime to check the default application for PDF files
+    let output = Command::new("xdg-mime")
+        .args(["query", "default", "application/pdf"])
+        .output()
+        .map_err(|e| format!("Failed to check default app: {}", e))?;
+
+    let handler = String::from_utf8_lossy(&output.stdout);
+    add_log(format!("Linux PDF handler: {}", handler.trim()));
+
+    // Check if it's our .desktop file
+    let is_default = handler.trim() == "stirling-pdf.desktop";
+    Ok(is_default)
+}
+
+#[cfg(target_os = "linux")]
+fn set_default_linux() -> Result<String, String> {
+    // Use xdg-mime to set the default application for PDF files
+    let result = Command::new("xdg-mime")
+        .args(["default", "stirling-pdf.desktop", "application/pdf"])
+        .output()
+        .map_err(|e| format!("Failed to set default app: {}", e))?;
+
+    if result.status.success() {
+        add_log("Set as default PDF handler on Linux".to_string());
+        Ok("set_successfully".to_string())
+    } else {
+        let error = String::from_utf8_lossy(&result.stderr);
+        add_log(format!("Failed to set default: {}", error));
+        Err(format!("Failed to set as default: {}", error))
+    }
+}

frontend/src-tauri/src/commands/files.rs

@@ -14,23 +14,11 @@ pub fn add_opened_file(file_path: String) {
 // Command to get opened file paths (if app was launched with files)
 #[tauri::command]
 pub async fn get_opened_files() -> Result<Vec<String>, String> {
-    let mut all_files: Vec<String> = Vec::new();
-
-    // Get files from command line arguments (Windows/Linux 'Open With Stirling' behaviour)
-    let args: Vec<String> = std::env::args().collect();
-    let pdf_files: Vec<String> = args.iter()
-        .skip(1)
-        .filter(|arg| std::path::Path::new(arg).exists())
-        .cloned()
-        .collect();
-
-    all_files.extend(pdf_files);
-
-    // Add any files sent via events or other instances (macOS 'Open With Stirling' behaviour, also Windows/Linux extra files)
-    {
-        let opened_files = OPENED_FILES.lock().unwrap();
-        all_files.extend(opened_files.clone());
-    }
+    // Get all files from the OPENED_FILES store
+    // Command line args are processed in setup() callback and added to this store
+    // Additional files from second instances or events are also added here
+    let opened_files = OPENED_FILES.lock().unwrap();
+    let all_files = opened_files.clone();
 
     add_log(format!("📂 Returning {} opened file(s)", all_files.len()));
     Ok(all_files)

frontend/src-tauri/src/commands/mod.rs

@@ -1,7 +1,9 @@
 pub mod backend;
 pub mod health;
 pub mod files;
+pub mod default_app;
 
 pub use backend::{start_backend, cleanup_backend};
 pub use health::check_backend_health;
 pub use files::{get_opened_files, clear_opened_files, add_opened_file};
+pub use default_app::{is_default_pdf_handler, set_as_default_pdf_handler};

frontend/src-tauri/src/lib.rs

@@ -3,7 +3,16 @@ use tauri::{RunEvent, WindowEvent, Emitter, Manager};
 mod utils;
 mod commands;
 
-use commands::{start_backend, check_backend_health, get_opened_files, clear_opened_files, cleanup_backend, add_opened_file};
+use commands::{
+    start_backend,
+    check_backend_health,
+    get_opened_files,
+    clear_opened_files,
+    cleanup_backend,
+    add_opened_file,
+    is_default_pdf_handler,
+    set_as_default_pdf_handler,
+};
 use utils::{add_log, get_tauri_logs};
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
@@ -23,9 +32,6 @@ pub fn run() {
           // Store file for later retrieval (in case frontend isn't ready yet)
           add_opened_file(arg.clone());
 
-          // Also emit event for immediate handling if frontend is ready
-          let _ = app.emit("file-opened", arg.clone());
-
           // Bring the existing window to front
           if let Some(window) = app.get_webview_window("main") {
             let _ = window.set_focus();
@@ -33,13 +39,34 @@ pub fn run() {
           }
         }
       }
+
+      // Emit a generic notification that files were added (frontend will re-read storage)
+      let _ = app.emit("files-changed", ());
     }))
     .setup(|_app| {
       add_log("🚀 Tauri app setup started".to_string());
+
+      // Process command line arguments on first launch
+      let args: Vec<String> = std::env::args().collect();
+      for arg in args.iter().skip(1) {
+        if std::path::Path::new(arg).exists() {
+          add_log(format!("📂 Initial file from command line: {}", arg));
+          add_opened_file(arg.clone());
+        }
+      }
+
       add_log("🔍 DEBUG: Setup completed".to_string());
       Ok(())
     })
-    .invoke_handler(tauri::generate_handler![start_backend, check_backend_health, get_opened_files, clear_opened_files, get_tauri_logs])
+    .invoke_handler(tauri::generate_handler![
+      start_backend,
+      check_backend_health,
+      get_opened_files,
+      clear_opened_files,
+      get_tauri_logs,
+      is_default_pdf_handler,
+      set_as_default_pdf_handler,
+    ])
     .build(tauri::generate_context!())
     .expect("error while building tauri application")
     .run(|app_handle, event| {
@@ -58,6 +85,7 @@ pub fn run() {
         #[cfg(target_os = "macos")]
         RunEvent::Opened { urls } => {
           add_log(format!("📂 Tauri file opened event: {:?}", urls));
+          let mut added_files = false;
           for url in urls {
             let url_str = url.as_str();
             if url_str.starts_with("file://") {
@@ -65,11 +93,14 @@ pub fn run() {
               if file_path.ends_with(".pdf") {
                 add_log(format!("📂 Processing opened PDF: {}", file_path));
                 add_opened_file(file_path.to_string());
-                // Use unified event name for consistency across platforms
-                let _ = app_handle.emit("file-opened", file_path.to_string());
+                added_files = true;
               }
             }
           }
+          // Emit a generic notification that files were added (frontend will re-read storage)
+          if added_files {
+            let _ = app_handle.emit("files-changed", ());
+          }
         }
         _ => {
           // Only log unhandled events in debug mode to reduce noise

frontend/src/core/App.tsx

@@ -1,5 +1,6 @@
 import { Suspense } from "react";
 import { AppProviders } from "@app/components/AppProviders";
+import { AppLayout } from "@app/components/AppLayout";
 import { LoadingFallback } from "@app/components/shared/LoadingFallback";
 import HomePage from "@app/pages/HomePage";
 import OnboardingTour from "@app/components/onboarding/OnboardingTour";
@@ -16,8 +17,10 @@ export default function App() {
   return (
     <Suspense fallback={<LoadingFallback />}>
       <AppProviders>
-        <HomePage />
-        <OnboardingTour />
+        <AppLayout>
+          <HomePage />
+          <OnboardingTour />
+        </AppLayout>
       </AppProviders>
     </Suspense>
   );

frontend/src/core/components/AppLayout.tsx

@@ -0,0 +1,31 @@
+import { ReactNode } from 'react';
+import { useBanner } from '@app/contexts/BannerContext';
+
+interface AppLayoutProps {
+  children: ReactNode;
+}
+
+/**
+ * App layout wrapper that handles banner rendering and viewport sizing
+ * Automatically adjusts child components to fit remaining space after banner
+ */
+export function AppLayout({ children }: AppLayoutProps) {
+  const { banner } = useBanner();
+
+  return (
+    <>
+      <style>{`
+        .h-screen,
+        .right-rail {
+          height: 100% !important;
+        }
+      `}</style>
+      <div style={{ height: '100vh', display: 'flex', flexDirection: 'column' }}>
+        {banner}
+        <div style={{ flex: 1, minHeight: 0, height: 0 }}>
+          {children}
+        </div>
+      </div>
+    </>
+  );
+}

frontend/src/core/components/AppProviders.tsx

@@ -16,6 +16,7 @@ import { OnboardingProvider } from "@app/contexts/OnboardingContext";
 import { TourOrchestrationProvider } from "@app/contexts/TourOrchestrationContext";
 import { AdminTourOrchestrationProvider } from "@app/contexts/AdminTourOrchestrationContext";
 import { PageEditorProvider } from "@app/contexts/PageEditorContext";
+import { BannerProvider } from "@app/contexts/BannerContext";
 import ErrorBoundary from "@app/components/shared/ErrorBoundary";
 import { useScarfTracking } from "@app/hooks/useScarfTracking";
 import { useAppInitialization } from "@app/hooks/useAppInitialization";
@@ -50,22 +51,23 @@ export function AppProviders({ children, appConfigRetryOptions, appConfigProvide
     <PreferencesProvider>
       <RainbowThemeProvider>
         <ErrorBoundary>
-          <OnboardingProvider>
-            <AppConfigProvider
-              retryOptions={appConfigRetryOptions}
-              {...appConfigProviderProps}
-            >
-              <ScarfTrackingInitializer />
-              <FileContextProvider enableUrlSync={true} enablePersistence={true}>
-                <AppInitializer />
-                <ToolRegistryProvider>
-                  <NavigationProvider>
-                    <FilesModalProvider>
-                      <ToolWorkflowProvider>
-                        <HotkeyProvider>
-                          <SidebarProvider>
-                            <ViewerProvider>
-                              <PageEditorProvider>
+          <BannerProvider>
+            <OnboardingProvider>
+              <AppConfigProvider
+                retryOptions={appConfigRetryOptions}
+                {...appConfigProviderProps}
+              >
+                <ScarfTrackingInitializer />
+                <FileContextProvider enableUrlSync={true} enablePersistence={true}>
+                  <AppInitializer />
+                  <ToolRegistryProvider>
+                    <NavigationProvider>
+                      <FilesModalProvider>
+                        <ToolWorkflowProvider>
+                          <HotkeyProvider>
+                            <SidebarProvider>
+                              <ViewerProvider>
+                                <PageEditorProvider>
                                 <SignatureProvider>
                                   <RightRailProvider>
                                       <TourOrchestrationProvider>
@@ -76,16 +78,17 @@ export function AppProviders({ children, appConfigRetryOptions, appConfigProvide
                                   </RightRailProvider>
                                 </SignatureProvider>
                               </PageEditorProvider>
-                            </ViewerProvider>
-                          </SidebarProvider>
-                        </HotkeyProvider>
-                      </ToolWorkflowProvider>
-                    </FilesModalProvider>
-                  </NavigationProvider>
-                </ToolRegistryProvider>
-              </FileContextProvider>
-            </AppConfigProvider>
-          </OnboardingProvider>
+                              </ViewerProvider>
+                            </SidebarProvider>
+                          </HotkeyProvider>
+                        </ToolWorkflowProvider>
+                      </FilesModalProvider>
+                    </NavigationProvider>
+                  </ToolRegistryProvider>
+                </FileContextProvider>
+              </AppConfigProvider>
+            </OnboardingProvider>
+          </BannerProvider>
         </ErrorBoundary>
       </RainbowThemeProvider>
     </PreferencesProvider>

frontend/src/core/components/onboarding/OnboardingTour.tsx

@@ -1,4 +1,4 @@
-import React from "react";
+import React, { useMemo } from "react";
 import { TourProvider, useTour, type StepType } from '@reactour/tour';
 import { useOnboarding } from '@app/contexts/OnboardingContext';
 import { useTranslation } from 'react-i18next';
@@ -10,6 +10,7 @@ import ArrowForwardIcon from '@mui/icons-material/ArrowForward';
 import CheckIcon from '@mui/icons-material/Check';
 import TourWelcomeModal from '@app/components/onboarding/TourWelcomeModal';
 import '@app/components/onboarding/OnboardingTour.css';
+import i18n from "@app/i18n";
 
 // Enum case order defines order steps will appear
 enum TourStep {
@@ -120,7 +121,7 @@ export default function OnboardingTour() {
   } = useAdminTourOrchestration();
 
   // Define steps as object keyed by enum - TypeScript ensures all keys are present
-  const stepsConfig: Record<TourStep, StepType> = {
+  const stepsConfig: Record<TourStep, StepType> = useMemo(() => ({
     [TourStep.ALL_TOOLS]: {
       selector: '[data-tour="tool-panel"]',
       content: t('onboarding.allTools', 'This is the <strong>Tools</strong> panel, where you can browse and select from all available PDF tools.'),
@@ -248,10 +249,10 @@ export default function OnboardingTour() {
       position: 'right',
       padding: 10,
     },
-  };
+  }), [t]);
 
   // Define admin tour steps
-  const adminStepsConfig: Record<AdminTourStep, StepType> = {
+  const adminStepsConfig: Record<AdminTourStep, StepType> = useMemo(() => ({
     [AdminTourStep.WELCOME]: {
       selector: '[data-tour="config-button"]',
       content: t('adminOnboarding.welcome', "Welcome to the <strong>Admin Tour</strong>! Let's explore the powerful enterprise features and settings available to system administrators."),
@@ -363,7 +364,7 @@ export default function OnboardingTour() {
         removeAllGlows();
       },
     },
-  };
+  }), [t]);
 
   // Select steps based on tour type
   const steps = tourType === 'admin'
@@ -416,7 +417,7 @@ export default function OnboardingTour() {
         }}
       />
       <TourProvider
-        key={tourType}
+        key={`${tourType}-${i18n.language}`}
         steps={steps}
         maskClassName={tourType === 'admin' ? 'admin-tour-mask' : undefined}
         onClickClose={handleCloseTour}

frontend/src/core/components/shared/InfoBanner.tsx

@@ -0,0 +1,72 @@
+import React from 'react';
+import { Paper, Group, Text, Button, ActionIcon } from '@mantine/core';
+import LocalIcon from '@app/components/shared/LocalIcon';
+
+interface InfoBannerProps {
+  icon: string;
+  message: string;
+  buttonText: string;
+  buttonIcon?: string;
+  onButtonClick: () => void;
+  onDismiss: () => void;
+  loading?: boolean;
+  show?: boolean;
+}
+
+/**
+ * Generic info banner component for displaying dismissible messages at the top of the app
+ */
+export const InfoBanner: React.FC<InfoBannerProps> = ({
+  icon,
+  message,
+  buttonText,
+  buttonIcon = 'check-circle-rounded',
+  onButtonClick,
+  onDismiss,
+  loading = false,
+  show = true,
+}) => {
+  if (!show) {
+    return null;
+  }
+
+  return (
+    <Paper
+      p="sm"
+      radius={0}
+      style={{
+        background: 'var(--mantine-color-blue-0)',
+        borderBottom: '1px solid var(--mantine-color-blue-2)',
+        position: 'relative',
+      }}
+    >
+      <Group gap="sm" align="center" wrap="nowrap">
+        <LocalIcon icon={icon} width="1.2rem" height="1.2rem" style={{ color: 'var(--mantine-color-blue-6)', flexShrink: 0 }} />
+        <Text fw={500} size="sm" style={{ color: 'var(--mantine-color-blue-9)' }}>
+          {message}
+        </Text>
+        <Button
+          variant="light"
+          color="blue"
+          size="xs"
+          onClick={onButtonClick}
+          loading={loading}
+          leftSection={<LocalIcon icon={buttonIcon} width="0.9rem" height="0.9rem" />}
+          style={{ flexShrink: 0 }}
+        >
+          {buttonText}
+        </Button>
+      </Group>
+      <ActionIcon
+        variant="subtle"
+        color="gray"
+        size="sm"
+        onClick={onDismiss}
+        aria-label="Dismiss"
+        style={{ position: 'absolute', top: '50%', right: '0.5rem', transform: 'translateY(-50%)' }}
+      >
+        <LocalIcon icon="close-rounded" width="1rem" height="1rem" />
+      </ActionIcon>
+    </Paper>
+  );
+};

frontend/src/core/components/shared/LanguageSelector.tsx

@@ -2,7 +2,6 @@ import React, { useState, useEffect } from 'react';
 import { Menu, Button, ScrollArea, ActionIcon, Tooltip } from '@mantine/core';
 import { useTranslation } from 'react-i18next';
 import { supportedLanguages } from '@app/i18n';
-import { emitLocalSettingsEvent } from '@app/utils/localSettingsEvents';
 import LocalIcon from '@app/components/shared/LocalIcon';
 import styles from '@app/components/shared/LanguageSelector.module.css';
 import { Z_INDEX_OVER_FULLSCREEN_SURFACE } from '@app/styles/zIndex';
@@ -179,7 +178,6 @@ const LanguageSelector: React.FC<LanguageSelectorProps> = ({ position = 'bottom-
     // Simulate processing time for smooth transition
     setTimeout(() => {
       i18n.changeLanguage(value);
-      emitLocalSettingsEvent(['i18nextLng'], 'local');
 
       setTimeout(() => {
         setPendingLanguage(null);
@@ -274,8 +272,13 @@ const LanguageSelector: React.FC<LanguageSelectorProps> = ({ position = 'bottom-
           <ScrollArea h={190} type="scroll">
             <div className={styles.languageGrid}>
               {languageOptions.map((option, index) => {
-                // Enable languages with >90% translation completion
-                const enabledLanguages = ['en-GB', 'ar-AR', 'de-DE', 'es-ES', 'fr-FR', 'it-IT', 'pt-BR', 'ru-RU', 'zh-CN'];
+                const enabledLanguages = [
+                  'en-GB', 'zh-CN', 'zh-TW', 'ar-AR', 'fa-IR', 'tr-TR', 'uk-UA', 'zh-BO', 'sl-SI',
+                  'ru-RU', 'ja-JP', 'ko-KR', 'hu-HU', 'ga-IE', 'bg-BG', 'es-ES', 'hi-IN', 'hr-HR',
+                  'el-GR', 'ml-ML', 'pt-BR', 'pl-PL', 'pt-PT', 'sk-SK', 'sr-LATN-RS', 'no-NB',
+                  'th-TH', 'vi-VN', 'az-AZ', 'eu-ES', 'de-DE', 'sv-SE', 'it-IT', 'ca-CA', 'id-ID',
+                  'ro-RO', 'fr-FR', 'nl-NL', 'da-DK', 'cs-CZ'
+                ];
                 const isDisabled = !enabledLanguages.includes(option.value);
 
                 return (

frontend/src/core/components/shared/UpdateModal.tsx

@@ -0,0 +1,415 @@
+import React, { useState, useEffect } from 'react';
+import { Modal, Stack, Text, Badge, Button, Group, Loader, Center, Divider, Box, Collapse } from '@mantine/core';
+import { useTranslation } from 'react-i18next';
+import { updateService, UpdateSummary, FullUpdateInfo, MachineInfo } from '@app/services/updateService';
+import { Z_INDEX_OVER_CONFIG_MODAL } from '@app/styles/zIndex';
+import WarningAmberIcon from '@mui/icons-material/WarningAmber';
+import InfoOutlinedIcon from '@mui/icons-material/InfoOutlined';
+import OpenInNewIcon from '@mui/icons-material/OpenInNew';
+import DownloadIcon from '@mui/icons-material/Download';
+import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
+import ExpandLessIcon from '@mui/icons-material/ExpandLess';
+
+interface UpdateModalProps {
+  opened: boolean;
+  onClose: () => void;
+  currentVersion: string;
+  updateSummary: UpdateSummary;
+  machineInfo: MachineInfo;
+}
+
+const UpdateModal: React.FC<UpdateModalProps> = ({
+  opened,
+  onClose,
+  currentVersion,
+  updateSummary,
+  machineInfo,
+}) => {
+  const { t } = useTranslation();
+  const [fullUpdateInfo, setFullUpdateInfo] = useState<FullUpdateInfo | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [expandedVersions, setExpandedVersions] = useState<Set<number>>(new Set([0]));
+
+  useEffect(() => {
+    if (opened) {
+      setLoading(true);
+      setExpandedVersions(new Set([0]));
+      updateService.getFullUpdateInfo(currentVersion, machineInfo).then((info) => {
+        setFullUpdateInfo(info);
+        setLoading(false);
+      });
+    }
+  }, [opened, currentVersion, machineInfo]);
+
+  const toggleVersion = (index: number) => {
+    setExpandedVersions((prev) => {
+      const newSet = new Set(prev);
+      if (newSet.has(index)) {
+        newSet.delete(index);
+      } else {
+        newSet.add(index);
+      }
+      return newSet;
+    });
+  };
+
+  const getPriorityColor = (priority: string): string => {
+    switch (priority?.toLowerCase()) {
+      case 'urgent':
+        return 'red';
+      case 'normal':
+        return 'blue';
+      case 'minor':
+        return 'cyan';
+      case 'low':
+        return 'gray';
+      default:
+        return 'gray';
+    }
+  };
+
+  const getPriorityLabel = (priority: string): string => {
+    const key = priority?.toLowerCase();
+    return t(`update.priority.${key}`, priority || 'Normal');
+  };
+
+  const downloadUrl = updateService.getDownloadUrl(machineInfo);
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      title={
+        <Text fw={600} size="lg">
+          {t('update.modalTitle', 'Update Available')}
+        </Text>
+      }
+      centered
+      size="xl"
+      zIndex={Z_INDEX_OVER_CONFIG_MODAL}
+      styles={{
+        body: {
+          maxHeight: '75vh',
+          overflowY: 'auto',
+        },
+      }}
+    >
+      <Stack gap="lg" pt="md">
+        {/* Version Summary Section */}
+        <Box>
+          <Group justify="space-between" align="flex-start" wrap="nowrap" mb="md">
+            <Stack gap={4} style={{ flex: 1 }}>
+              <Text size="xs" c="dimmed" tt="uppercase" fw={500}>
+                {t('update.current', 'Current Version')}
+              </Text>
+              <Text fw={600} size="xl">
+                {currentVersion}
+              </Text>
+            </Stack>
+
+            <Stack gap={4} style={{ flex: 1 }} ta="center">
+              <Text size="xs" c="dimmed" tt="uppercase" fw={500}>
+                {t('update.priorityLabel', 'Priority')}
+              </Text>
+              <Badge
+                color={getPriorityColor(updateSummary.max_priority)}
+                size="lg"
+                variant="filled"
+                style={{ alignSelf: 'center' }}
+              >
+                {getPriorityLabel(updateSummary.max_priority)}
+              </Badge>
+            </Stack>
+
+            <Stack gap={4} style={{ flex: 1 }} ta="right">
+              <Text size="xs" c="dimmed" tt="uppercase" fw={500}>
+                {t('update.latest', 'Latest Version')}
+              </Text>
+              <Text fw={600} size="xl" c="blue">
+                {updateSummary.latest_version}
+              </Text>
+            </Stack>
+          </Group>
+
+          {updateSummary.latest_stable_version && (
+            <Box
+              style={{
+                background: 'var(--mantine-color-green-0)',
+                padding: '10px 16px',
+                borderRadius: '8px',
+                border: '1px solid var(--mantine-color-green-2)',
+              }}
+            >
+              <Group gap="xs" justify="center">
+                <Text size="sm" fw={500}>
+                  {t('update.latestStable', 'Latest Stable')}:
+                </Text>
+                <Text size="sm" fw={600} c="green">
+                  {updateSummary.latest_stable_version}
+                </Text>
+              </Group>
+            </Box>
+          )}
+        </Box>
+
+        {/* Recommended action */}
+        {updateSummary.recommended_action && (
+          <Box
+            style={{
+              background: 'var(--mantine-color-blue-light)',
+              padding: '12px 16px',
+              borderRadius: '8px',
+              border: '1px solid var(--mantine-color-blue-outline)',
+            }}
+          >
+            <Group gap="xs" wrap="nowrap" align="flex-start">
+              <InfoOutlinedIcon style={{ fontSize: 18, color: 'var(--mantine-color-blue-filled)', marginTop: 2 }} />
+              <Box style={{ flex: 1 }}>
+                <Text size="xs" fw={600} mb={4} tt="uppercase">
+                  {t('update.recommendedAction', 'Recommended Action')}
+                </Text>
+                <Text size="sm">
+                  {updateSummary.recommended_action}
+                </Text>
+              </Box>
+            </Group>
+          </Box>
+        )}
+
+        {/* Breaking changes warning */}
+        {updateSummary.any_breaking && (
+          <Box
+            style={{
+              background: 'var(--mantine-color-orange-light)',
+              padding: '12px 16px',
+              borderRadius: '8px',
+              border: '1px solid var(--mantine-color-orange-outline)',
+            }}
+          >
+            <Group gap="xs" wrap="nowrap" align="flex-start">
+              <WarningAmberIcon style={{ fontSize: 18, color: 'var(--mantine-color-orange-filled)', marginTop: 2 }} />
+              <Box style={{ flex: 1 }}>
+                <Text size="xs" fw={600} mb={4} tt="uppercase">
+                  {t('update.breakingChangesDetected', 'Breaking Changes Detected')}
+                </Text>
+                <Text size="sm">
+                  {t(
+                    'update.breakingChangesMessage',
+                    'Some versions contain breaking changes. Please review the migration guides below before updating.'
+                  )}
+                </Text>
+              </Box>
+            </Group>
+          </Box>
+        )}
+
+        {/* Migration guides */}
+        {updateSummary.migration_guides && updateSummary.migration_guides.length > 0 && (
+          <>
+            <Divider />
+            <Stack gap="xs">
+              <Text fw={600} size="sm" tt="uppercase" c="dimmed">
+                {t('update.migrationGuides', 'Migration Guides')}
+              </Text>
+              {updateSummary.migration_guides.map((guide, idx) => (
+                <Box
+                  key={idx}
+                  style={{
+                    border: '1px solid var(--mantine-color-gray-3)',
+                    padding: '12px 16px',
+                    borderRadius: '8px',
+                    background: 'var(--mantine-color-gray-0)',
+                  }}
+                >
+                  <Group justify="space-between" align="center" wrap="nowrap">
+                    <Box style={{ flex: 1 }}>
+                      <Text fw={600} size="sm">
+                        {t('update.version', 'Version')} {guide.version}
+                      </Text>
+                      <Text size="xs" c="dimmed" mt={4}>
+                        {guide.notes}
+                      </Text>
+                    </Box>
+                    <Button
+                      component="a"
+                      href={guide.url}
+                      target="_blank"
+                      variant="light"
+                      size="xs"
+                      rightSection={<OpenInNewIcon style={{ fontSize: 14 }} />}
+                    >
+                      {t('update.viewGuide', 'View Guide')}
+                    </Button>
+                  </Group>
+                </Box>
+              ))}
+            </Stack>
+          </>
+        )}
+
+        {/* Version details */}
+        <Divider />
+        {loading ? (
+          <Center py="xl">
+            <Stack align="center" gap="sm">
+              <Loader size="md" />
+              <Text size="sm" c="dimmed">
+                {t('update.loadingDetailedInfo', 'Loading detailed information...')}
+              </Text>
+            </Stack>
+          </Center>
+        ) : fullUpdateInfo && fullUpdateInfo.new_versions && fullUpdateInfo.new_versions.length > 0 ? (
+          <Stack gap="xs">
+            <Group justify="space-between" align="center">
+              <Text fw={600} size="sm" tt="uppercase" c="dimmed">
+                {t('update.availableUpdates', 'Available Updates')}
+              </Text>
+              <Badge variant="light" color="gray">
+                {fullUpdateInfo.new_versions.length} {fullUpdateInfo.new_versions.length === 1 ? 'version' : 'versions'}
+              </Badge>
+            </Group>
+            <Stack gap="xs">
+              {fullUpdateInfo.new_versions.map((version, index) => {
+                const isExpanded = expandedVersions.has(index);
+                return (
+                  <Box
+                    key={index}
+                    style={{
+                      border: '1px solid var(--mantine-color-gray-3)',
+                      borderRadius: '8px',
+                      overflow: 'hidden',
+                    }}
+                  >
+                    <Group
+                      justify="space-between"
+                      align="center"
+                      p="md"
+                      style={{
+                        cursor: 'pointer',
+                        background: isExpanded ? 'var(--mantine-color-gray-0)' : 'transparent',
+                        transition: 'background 0.15s ease',
+                      }}
+                      onClick={() => toggleVersion(index)}
+                    >
+                      <Group gap="md" style={{ flex: 1 }}>
+                        <Box>
+                          <Text fw={600} size="sm" c="dimmed" mb={2}>
+                            {t('update.version', 'Version')}
+                          </Text>
+                          <Text fw={700} size="lg">
+                            {version.version}
+                          </Text>
+                        </Box>
+                        <Badge color={getPriorityColor(version.priority)} size="md">
+                          {getPriorityLabel(version.priority)}
+                        </Badge>
+                      </Group>
+                      <Group gap="xs">
+                        <Button
+                          component="a"
+                          href={`https://github.com/Stirling-Tools/Stirling-PDF/releases/tag/v${version.version}`}
+                          target="_blank"
+                          variant="light"
+                          size="xs"
+                          onClick={(e) => e.stopPropagation()}
+                          rightSection={<OpenInNewIcon style={{ fontSize: 14 }} />}
+                        >
+                          {t('update.releaseNotes', 'Release Notes')}
+                        </Button>
+                        {isExpanded ? (
+                          <ExpandLessIcon style={{ fontSize: 20, color: 'var(--mantine-color-gray-6)' }} />
+                        ) : (
+                          <ExpandMoreIcon style={{ fontSize: 20, color: 'var(--mantine-color-gray-6)' }} />
+                        )}
+                      </Group>
+                    </Group>
+
+                    <Collapse in={isExpanded}>
+                      <Box p="md" pt={0} style={{ borderTop: '1px solid var(--mantine-color-gray-2)' }}>
+                        <Stack gap="md" mt="md">
+                          <Box>
+                            <Text fw={600} size="sm" mb={6}>
+                              {version.announcement.title}
+                            </Text>
+                            <Text size="sm" c="dimmed" style={{ lineHeight: 1.6 }}>
+                              {version.announcement.message}
+                            </Text>
+                          </Box>
+
+                          {version.compatibility.breaking_changes && (
+                            <Box
+                              style={{
+                                background: 'var(--mantine-color-orange-light)',
+                                padding: '12px',
+                                borderRadius: '6px',
+                                border: '1px solid var(--mantine-color-orange-outline)',
+                              }}
+                            >
+                              <Group gap="xs" align="flex-start" wrap="nowrap" mb="xs">
+                                <WarningAmberIcon style={{ fontSize: 16, color: 'var(--mantine-color-orange-filled)', marginTop: 2 }} />
+                                <Text size="xs" fw={600} tt="uppercase">
+                                  {t('update.breakingChanges', 'Breaking Changes')}
+                                </Text>
+                              </Group>
+                              <Text size="sm" mb="xs">
+                                {version.compatibility.breaking_description ||
+                                  t('update.breakingChangesDefault', 'This version contains breaking changes.')}
+                              </Text>
+                              {version.compatibility.migration_guide_url && (
+                                <Button
+                                  component="a"
+                                  href={version.compatibility.migration_guide_url}
+                                  target="_blank"
+                                  variant="light"
+                                  color="orange"
+                                  size="xs"
+                                  rightSection={<OpenInNewIcon style={{ fontSize: 14 }} />}
+                                >
+                                  {t('update.migrationGuide', 'Migration Guide')}
+                                </Button>
+                              )}
+                            </Box>
+                          )}
+                        </Stack>
+                      </Box>
+                    </Collapse>
+                  </Box>
+                );
+              })}
+            </Stack>
+          </Stack>
+        ) : null}
+
+        {/* Action buttons */}
+        <Divider />
+        <Group justify="flex-end" gap="sm">
+          <Button variant="default" onClick={onClose}>
+            {t('update.close', 'Close')}
+          </Button>
+          <Button
+            variant="light"
+            component="a"
+            href="https://github.com/Stirling-Tools/Stirling-PDF/releases"
+            target="_blank"
+            rightSection={<OpenInNewIcon style={{ fontSize: 16 }} />}
+          >
+            {t('update.viewAllReleases', 'View All Releases')}
+          </Button>
+          {downloadUrl && (
+            <Button
+              component="a"
+              href={downloadUrl}
+              target="_blank"
+              color="green"
+              leftSection={<DownloadIcon style={{ fontSize: 16 }} />}
+            >
+              {t('update.downloadLatest', 'Download Latest')}
+            </Button>
+          )}
+        </Group>
+      </Stack>
+    </Modal>
+  );
+};
+
+export default UpdateModal;

frontend/src/core/components/shared/config/configSections/GeneralSection.tsx

@@ -1,10 +1,12 @@
 import React, { useState, useEffect } from 'react';
-import { Paper, Stack, Switch, Text, Tooltip, NumberInput, SegmentedControl, Code, Group, Anchor, ActionIcon } from '@mantine/core';
+import { Paper, Stack, Switch, Text, Tooltip, NumberInput, SegmentedControl, Code, Group, Anchor, ActionIcon, Button, Badge, Alert } from '@mantine/core';
 import { useTranslation } from 'react-i18next';
 import { usePreferences } from '@app/contexts/PreferencesContext';
 import { useAppConfig } from '@app/contexts/AppConfigContext';
 import type { ToolPanelMode } from '@app/constants/toolPanel';
 import LocalIcon from '@app/components/shared/LocalIcon';
+import { updateService, UpdateSummary } from '@app/services/updateService';
+import UpdateModal from '@app/components/shared/UpdateModal';
 
 const DEFAULT_AUTO_UNZIP_FILE_LIMIT = 4;
 const BANNER_DISMISSED_KEY = 'stirlingpdf_features_banner_dismissed';
@@ -22,12 +24,44 @@ const GeneralSection: React.FC<GeneralSectionProps> = ({ hideTitle = false }) =>
     // Check localStorage on mount
     return localStorage.getItem(BANNER_DISMISSED_KEY) === 'true';
   });
+  const [updateSummary, setUpdateSummary] = useState<UpdateSummary | null>(null);
+  const [updateModalOpened, setUpdateModalOpened] = useState(false);
+  const [checkingUpdate, setCheckingUpdate] = useState(false);
 
   // Sync local state with preference changes
   useEffect(() => {
     setFileLimitInput(preferences.autoUnzipFileLimit);
   }, [preferences.autoUnzipFileLimit]);
 
+  // Check for updates on mount
+  useEffect(() => {
+    if (config?.appVersion && config?.machineType) {
+      checkForUpdate();
+    }
+  }, [config?.appVersion, config?.machineType]);
+
+  const checkForUpdate = async () => {
+    if (!config?.appVersion || !config?.machineType) {
+      return;
+    }
+
+    setCheckingUpdate(true);
+    const machineInfo = {
+      machineType: config.machineType,
+      activeSecurity: config.activeSecurity ?? false,
+      licenseType: config.license ?? 'NORMAL',
+    };
+
+    const summary = await updateService.getUpdateSummary(config.appVersion, machineInfo);
+    if (summary) {
+      const isNewerVersion = updateService.compareVersions(summary.latest_version, config.appVersion) > 0;
+      if (isNewerVersion) {
+        setUpdateSummary(summary);
+      }
+    }
+    setCheckingUpdate(false);
+  };
+
   // Check if login is disabled
   const loginDisabled = !config?.enableLogin;
 
@@ -168,30 +202,110 @@ const GeneralSection: React.FC<GeneralSectionProps> = ({ hideTitle = false }) =>
               />
             </div>
           </Tooltip>
-
-          <Tooltip
-            label={t('settings.general.syncSettingsTooltip', 'Automatically back up your preferences to your account so they follow you on every device.')}
-            multiline
-            w={300}
-            withArrow
-          >
-            <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', cursor: 'help' }}>
-              <div>
-                <Text fw={500} size="sm">
-                  {t('settings.general.syncSettings', 'Sync settings across devices')}
-                </Text>
-                <Text size="xs" c="dimmed" mt={4}>
-                  {t('settings.general.syncSettingsDescription', 'Carry your theme, language, favorites, and hotkeys to other browsers when signed in.')}
-                </Text>
-              </div>
-              <Switch
-                checked={preferences.syncSettingsAcrossDevices}
-                onChange={(event) => updatePreference('syncSettingsAcrossDevices', event.currentTarget.checked)}
-              />
-            </div>
-          </Tooltip>
         </Stack>
       </Paper>
+
+      {/* Update Check Section */}
+      {config?.appVersion && (
+        <Paper withBorder p="md" radius="md">
+          <Stack gap="md">
+            <div>
+              <Group justify="space-between" align="center">
+                <div>
+                  <Text fw={600} size="sm">
+                    {t('settings.general.updates.title', 'Software Updates')}
+                  </Text>
+                  <Text size="xs" c="dimmed" mt={4}>
+                    {t('settings.general.updates.description', 'Check for updates and view version information')}
+                  </Text>
+                </div>
+                {updateSummary && (
+                  <Badge
+                    color={updateSummary.max_priority === 'urgent' ? 'red' : 'blue'}
+                    variant="filled"
+                  >
+                    {updateSummary.max_priority === 'urgent'
+                      ? t('update.urgentUpdateAvailable', 'Urgent Update')
+                      : t('update.updateAvailable', 'Update Available')}
+                  </Badge>
+                )}
+              </Group>
+            </div>
+
+            <Group justify="space-between" align="center">
+              <div>
+                <Text size="sm" c="dimmed">
+                  {t('settings.general.updates.currentVersion', 'Current Version')}:{' '}
+                  <Text component="span" fw={500}>
+                    {config.appVersion}
+                  </Text>
+                </Text>
+                {updateSummary && (
+                  <Text size="sm" c="dimmed" mt={4}>
+                    {t('settings.general.updates.latestVersion', 'Latest Version')}:{' '}
+                    <Text component="span" fw={500} c="blue">
+                      {updateSummary.latest_version}
+                    </Text>
+                  </Text>
+                )}
+              </div>
+              <Group gap="sm">
+                <Button
+                  size="sm"
+                  variant="default"
+                  onClick={checkForUpdate}
+                  loading={checkingUpdate}
+                  leftSection={<LocalIcon icon="refresh-rounded" width="1rem" height="1rem" />}
+                >
+                  {t('settings.general.updates.checkForUpdates', 'Check for Updates')}
+                </Button>
+                {updateSummary && (
+                  <Button
+                    size="sm"
+                    color={updateSummary.max_priority === 'urgent' ? 'red' : 'blue'}
+                    onClick={() => setUpdateModalOpened(true)}
+                    leftSection={<LocalIcon icon="system-update-rounded" width="1rem" height="1rem" />}
+                  >
+                    {t('settings.general.updates.viewDetails', 'View Details')}
+                  </Button>
+                )}
+              </Group>
+            </Group>
+
+            {updateSummary?.any_breaking && (
+              <Alert
+                color="orange"
+                title={t('update.breakingChangesDetected', 'Breaking Changes Detected')}
+                styles={{
+                  title: { fontWeight: 600 }
+                }}
+              >
+                <Text size="sm">
+                  {t(
+                    'update.breakingChangesMessage',
+                    'Some versions contain breaking changes. Please review the migration guides before updating.'
+                  )}
+                </Text>
+              </Alert>
+            )}
+          </Stack>
+        </Paper>
+      )}
+
+      {/* Update Modal */}
+      {updateSummary && config?.appVersion && config?.machineType && (
+        <UpdateModal
+          opened={updateModalOpened}
+          onClose={() => setUpdateModalOpened(false)}
+          currentVersion={config.appVersion}
+          updateSummary={updateSummary}
+          machineInfo={{
+            machineType: config.machineType,
+            activeSecurity: config.activeSecurity ?? false,
+            licenseType: config.license ?? 'NORMAL',
+          }}
+        />
+      )}
     </Stack>
   );
 };

frontend/src/core/components/tools/editTableOfContents/BookmarkEditor.tsx

@@ -0,0 +1,313 @@
+import { Fragment } from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  ActionIcon,
+  Badge,
+  Button,
+  Flex,
+  Group,
+  NumberInput,
+  Paper,
+  Stack,
+  Text,
+  TextInput,
+  Tooltip,
+} from '@mantine/core';
+import LocalIcon from '@app/components/shared/LocalIcon';
+import { BookmarkNode, createBookmarkNode } from '@app/utils/editTableOfContents';
+
+interface BookmarkEditorProps {
+  bookmarks: BookmarkNode[];
+  onChange: (bookmarks: BookmarkNode[]) => void;
+  disabled?: boolean;
+}
+
+const updateTree = (
+  nodes: BookmarkNode[],
+  targetId: string,
+  updater: (bookmark: BookmarkNode) => BookmarkNode,
+): BookmarkNode[] => {
+  return nodes.map(node => {
+    if (node.id === targetId) {
+      return updater(node);
+    }
+
+    if (node.children.length === 0) {
+      return node;
+    }
+
+    const updatedChildren = updateTree(node.children, targetId, updater);
+    if (updatedChildren !== node.children) {
+      return { ...node, children: updatedChildren };
+    }
+
+    return node;
+  });
+};
+
+const removeFromTree = (nodes: BookmarkNode[], targetId: string): BookmarkNode[] => {
+  return nodes
+    .filter(node => node.id !== targetId)
+    .map(node => ({
+      ...node,
+      children: removeFromTree(node.children, targetId),
+    }));
+};
+
+const addChildToTree = (
+  nodes: BookmarkNode[],
+  parentId: string,
+  child: BookmarkNode,
+): { nodes: BookmarkNode[]; added: boolean } => {
+  let added = false;
+  const next = nodes.map(node => {
+    if (node.id === parentId) {
+      added = true;
+      return { ...node, expanded: true, children: [...node.children, child] };
+    }
+
+    if (node.children.length === 0) {
+      return node;
+    }
+
+    const result = addChildToTree(node.children, parentId, child);
+    if (result.added) {
+      added = true;
+      return { ...node, children: result.nodes };
+    }
+
+    return node;
+  });
+
+  return { nodes: added ? next : nodes, added };
+};
+
+const addSiblingInTree = (
+  nodes: BookmarkNode[],
+  targetId: string,
+  sibling: BookmarkNode,
+): { nodes: BookmarkNode[]; added: boolean } => {
+  let added = false;
+  const result: BookmarkNode[] = [];
+
+  nodes.forEach(node => {
+    let currentNode = node;
+
+    if (!added && node.children.length > 0) {
+      const childResult = addSiblingInTree(node.children, targetId, sibling);
+      if (childResult.added) {
+        added = true;
+        currentNode = { ...node, children: childResult.nodes };
+      }
+    }
+
+    result.push(currentNode);
+
+    if (!added && node.id === targetId) {
+      result.push(sibling);
+      added = true;
+    }
+  });
+
+  return { nodes: added ? result : nodes, added };
+};
+
+export default function BookmarkEditor({ bookmarks, onChange, disabled }: BookmarkEditorProps) {
+  const { t } = useTranslation();
+
+  const handleAddTopLevel = () => {
+    const newBookmark = createBookmarkNode({ title: t('editTableOfContents.editor.defaultTitle', 'New bookmark') });
+    onChange([...bookmarks, newBookmark]);
+  };
+
+  const handleTitleChange = (id: string, value: string) => {
+    onChange(updateTree(bookmarks, id, bookmark => ({ ...bookmark, title: value })));
+  };
+
+  const handlePageChange = (id: string, value: number | string) => {
+    const page = typeof value === 'number' ? value : parseInt(value, 10);
+    onChange(updateTree(bookmarks, id, bookmark => ({ ...bookmark, pageNumber: Number.isFinite(page) && page > 0 ? page : 1 })));
+  };
+
+  const handleToggle = (id: string) => {
+    onChange(updateTree(bookmarks, id, bookmark => ({ ...bookmark, expanded: !bookmark.expanded })));
+  };
+
+  const handleRemove = (id: string) => {
+    const confirmation = t(
+      'editTableOfContents.editor.confirmRemove',
+      'Remove this bookmark and all of its children?'
+    );
+    if (window.confirm(confirmation)) {
+      onChange(removeFromTree(bookmarks, id));
+    }
+  };
+
+  const handleAddChild = (parentId: string) => {
+    const child = createBookmarkNode({ title: t('editTableOfContents.editor.defaultChildTitle', 'Child bookmark') });
+    const { nodes, added } = addChildToTree(bookmarks, parentId, child);
+    onChange(added ? nodes : [...bookmarks, child]);
+  };
+
+  const handleAddSibling = (targetId: string) => {
+    const sibling = createBookmarkNode({ title: t('editTableOfContents.editor.defaultSiblingTitle', 'New bookmark') });
+    const { nodes, added } = addSiblingInTree(bookmarks, targetId, sibling);
+    onChange(added ? nodes : [...bookmarks, sibling]);
+  };
+
+  const renderBookmark = (bookmark: BookmarkNode, level = 0) => {
+    const hasChildren = bookmark.children.length > 0;
+    const chevronIcon = bookmark.expanded ? 'expand-more-rounded' : 'chevron-right-rounded';
+
+    return (
+      <Paper
+        key={bookmark.id}
+        radius="md"
+        withBorder
+        p="md"
+        style={{
+          borderColor: 'var(--border-default)',
+          background: level === 0 ? 'var(--bg-surface)' : 'var(--bg-muted)',
+        }}
+      >
+        <Stack gap="sm">
+          <Flex align="flex-start" justify="space-between" gap="md">
+            <Group gap="sm" align="flex-start">
+              <ActionIcon
+                variant="subtle"
+                color="gray"
+                onClick={() => hasChildren && handleToggle(bookmark.id)}
+                disabled={disabled || !hasChildren}
+                aria-label={t('editTableOfContents.editor.actions.toggle', 'Toggle children')}
+                style={{ marginTop: 4 }}
+              >
+                <LocalIcon icon={chevronIcon} />
+              </ActionIcon>
+              <Stack gap={2}>
+                <Group gap="xs" align="center">
+                  <Text fw={600}>{bookmark.title || t('editTableOfContents.editor.untitled', 'Untitled bookmark')}</Text>
+                  {level > 0 && (
+                    <Badge size="xs" variant="light" color="blue">
+                      {t('editTableOfContents.editor.childBadge', 'Child')}
+                    </Badge>
+                  )}
+                </Group>
+                <Text size="sm" c="dimmed">
+                  {t('editTableOfContents.editor.pagePreview', { page: bookmark.pageNumber })}
+                </Text>
+              </Stack>
+            </Group>
+            <Group gap="xs">
+              <Tooltip label={t('editTableOfContents.editor.actions.addChild', 'Add child bookmark')}>
+                <ActionIcon
+                  variant="subtle"
+                  color="green"
+                  onClick={() => handleAddChild(bookmark.id)}
+                  disabled={disabled}
+                >
+                  <LocalIcon icon="subdirectory-arrow-right-rounded" />
+                </ActionIcon>
+              </Tooltip>
+              <Tooltip label={t('editTableOfContents.editor.actions.addSibling', 'Add sibling bookmark')}>
+                <ActionIcon
+                  variant="subtle"
+                  color="blue"
+                  onClick={() => handleAddSibling(bookmark.id)}
+                  disabled={disabled}
+                >
+                  <LocalIcon icon="add-rounded" />
+                </ActionIcon>
+              </Tooltip>
+              <Tooltip label={t('editTableOfContents.editor.actions.remove', 'Remove bookmark')}>
+                <ActionIcon
+                  variant="subtle"
+                  color="red"
+                  onClick={() => handleRemove(bookmark.id)}
+                  disabled={disabled}
+                >
+                  <LocalIcon icon="delete-rounded" />
+                </ActionIcon>
+              </Tooltip>
+            </Group>
+          </Flex>
+
+          {bookmark.expanded && (
+            <Stack gap="sm">
+              <TextInput
+                size="sm"
+                label={t('editTableOfContents.editor.field.title', 'Bookmark title')}
+                value={bookmark.title}
+                onChange={event => handleTitleChange(bookmark.id, event.currentTarget.value)}
+                disabled={disabled}
+              />
+              <NumberInput
+                size="sm"
+                label={t('editTableOfContents.editor.field.page', 'Target page number')}
+                min={1}
+                clampBehavior="strict"
+                value={bookmark.pageNumber}
+                onChange={value => handlePageChange(bookmark.id, value ?? 1)}
+                disabled={disabled}
+              />
+            </Stack>
+          )}
+
+          {bookmark.expanded && hasChildren && (
+            <Stack gap="sm" pl="lg" style={{ borderLeft: '1px solid var(--border-default)' }}>
+              {bookmark.children.map(child => (
+                <Fragment key={child.id}>{renderBookmark(child, level + 1)}</Fragment>
+              ))}
+            </Stack>
+          )}
+        </Stack>
+      </Paper>
+    );
+  };
+
+  return (
+    <Stack gap="md">
+      <Group justify="space-between" align="flex-start">
+        <div>
+          <Text fw={600}>{t('editTableOfContents.editor.heading', 'Bookmark editor')}</Text>
+          <Text size="sm" c="dimmed">
+            {t('editTableOfContents.editor.description', 'Add, nest, and reorder bookmarks to craft your PDF outline.')}
+          </Text>
+        </div>
+        <Button
+          variant="default"
+          color="blue"
+          leftSection={<LocalIcon icon="bookmark-add-rounded" />}
+          onClick={handleAddTopLevel}
+          disabled={disabled}
+        >
+          {t('editTableOfContents.editor.addTopLevel', 'Add top-level bookmark')}
+        </Button>
+      </Group>
+
+      {bookmarks.length === 0 ? (
+        <Paper withBorder radius="md" ta="center" py="xl">
+          <Stack gap="xs" align="center" px="lg">
+            <LocalIcon icon="bookmark-add-rounded" style={{ fontSize: '2.25rem' }} />
+            <Text fw={600}>{t('editTableOfContents.editor.empty.title', 'No bookmarks yet')}</Text>
+            <Text size="sm" c="dimmed" maw={420}>
+              {t('editTableOfContents.editor.empty.description', 'Import existing bookmarks or start by adding your first entry.')}
+            </Text>
+            <Button
+              variant="subtle"
+              color="blue"
+              leftSection={<LocalIcon icon="add-rounded" />}
+              onClick={handleAddTopLevel}
+              disabled={disabled}
+            >
+              {t('editTableOfContents.editor.empty.action', 'Add first bookmark')}
+            </Button>
+          </Stack>
+        </Paper>
+      ) : (
+        <Stack gap="sm">
+          {bookmarks.map(bookmark => renderBookmark(bookmark))}
+        </Stack>
+      )}
+    </Stack>
+  );
+}

frontend/src/core/components/tools/editTableOfContents/EditTableOfContentsSettings.tsx

@@ -0,0 +1,187 @@
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  Alert,
+  Button,
+  Divider,
+  FileButton,
+  Stack,
+  Switch,
+  Text,
+  Tooltip,
+} from '@mantine/core';
+import LocalIcon from '@app/components/shared/LocalIcon';
+import { BookmarkNode } from '@app/utils/editTableOfContents';
+
+interface EditTableOfContentsSettingsProps {
+  bookmarks: BookmarkNode[];
+  replaceExisting: boolean;
+  onReplaceExistingChange: (value: boolean) => void;
+  onSelectFiles: () => void;
+  onLoadFromPdf: () => void;
+  onImportJson: (file: File) => void;
+  onImportClipboard: () => void;
+  onExportJson: () => void;
+  onExportClipboard: () => void;
+  isLoading: boolean;
+  loadError?: string | null;
+  canReadClipboard: boolean;
+  canWriteClipboard: boolean;
+  disabled?: boolean;
+  selectedFileName?: string;
+}
+
+export default function EditTableOfContentsSettings({
+  bookmarks,
+  replaceExisting,
+  onReplaceExistingChange,
+  onSelectFiles,
+  onLoadFromPdf,
+  onImportJson,
+  onImportClipboard,
+  onExportJson,
+  onExportClipboard,
+  isLoading,
+  loadError,
+  canReadClipboard,
+  canWriteClipboard,
+  disabled,
+  selectedFileName,
+}: EditTableOfContentsSettingsProps) {
+  const { t } = useTranslation();
+
+  const infoLines = useMemo(() => ([
+    t('editTableOfContents.info.line1', 'Each bookmark needs a descriptive title and the page it should open.'),
+    t('editTableOfContents.info.line2', 'Use child bookmarks to build a hierarchy for chapters, sections, or subsections.'),
+    t('editTableOfContents.info.line3', 'Import bookmarks from the selected PDF or from a JSON file to save time.'),
+  ]), [t]);
+
+  return (
+    <Stack gap="md">
+      <Stack gap="xs">
+        <Text size="sm" fw={500}>{t('editTableOfContents.actions.source', 'Load bookmarks')}</Text>
+        <Text size="xs" c="dimmed">
+          {selectedFileName
+            ? t('editTableOfContents.actions.selectedFile', { file: selectedFileName })
+            : t('editTableOfContents.actions.noFile', 'Select a PDF to extract existing bookmarks.')}
+        </Text>
+      </Stack>
+
+      <Stack gap="sm">
+        <Button
+          variant="light"
+          leftSection={<LocalIcon icon="folder-rounded" />}
+          onClick={onSelectFiles}
+          fullWidth
+        >
+          {selectedFileName
+            ? t('editTableOfContents.workbench.changeFile', 'Change PDF')
+            : t('editTableOfContents.workbench.selectFile', 'Select PDF')}
+        </Button>
+
+        <Tooltip label={!selectedFileName ? t('editTableOfContents.actions.noFile', 'Select a PDF to extract existing bookmarks.') : ''} disabled={Boolean(selectedFileName)}>
+          <Button
+            variant="default"
+            leftSection={<LocalIcon icon="picture-as-pdf-rounded" />}
+            onClick={onLoadFromPdf}
+            loading={isLoading}
+            disabled={disabled || !selectedFileName}
+            fullWidth
+          >
+            {t('editTableOfContents.actions.loadFromPdf', 'Load from PDF')}
+          </Button>
+        </Tooltip>
+
+        <FileButton
+          onChange={file => file && onImportJson(file)}
+          accept="application/json"
+          disabled={disabled}
+        >
+          {(props) => (
+            <Button
+              {...props}
+              variant="default"
+              leftSection={<LocalIcon icon="upload-rounded" />}
+              disabled={disabled}
+              fullWidth
+            >
+              {t('editTableOfContents.actions.importJson', 'Import JSON')}
+            </Button>
+          )}
+        </FileButton>
+
+        <Tooltip
+          label={canReadClipboard ? '' : t('editTableOfContents.actions.clipboardUnavailable', 'Clipboard access is not available in this browser.')}
+          disabled={canReadClipboard}
+        >
+          <Button
+            variant="default"
+            leftSection={<LocalIcon icon="content-paste-rounded" />}
+            onClick={onImportClipboard}
+            disabled={disabled || !canReadClipboard}
+            fullWidth
+          >
+            {t('editTableOfContents.actions.importClipboard', 'Paste from clipboard')}
+          </Button>
+        </Tooltip>
+      </Stack>
+
+      {loadError && (
+        <Alert color="red" radius="md" icon={<LocalIcon icon="error-outline-rounded" />}>
+          {loadError}
+        </Alert>
+      )}
+
+      <Divider />
+
+      <Stack gap="xs">
+        <Text size="sm" fw={500}>{t('editTableOfContents.actions.export', 'Export bookmarks')}</Text>
+      </Stack>
+
+      <Stack gap="sm">
+        <Button
+          variant="default"
+          leftSection={<LocalIcon icon="download-rounded" />}
+          onClick={onExportJson}
+          disabled={disabled || bookmarks.length === 0}
+          fullWidth
+        >
+          {t('editTableOfContents.actions.exportJson', 'Download JSON')}
+        </Button>
+
+        <Tooltip
+          label={canWriteClipboard ? '' : t('editTableOfContents.actions.clipboardUnavailable', 'Clipboard access is not available in this browser.')}
+          disabled={canWriteClipboard}
+        >
+          <Button
+            variant="default"
+            leftSection={<LocalIcon icon="content-copy-rounded" />}
+            onClick={onExportClipboard}
+            disabled={disabled || bookmarks.length === 0 || !canWriteClipboard}
+            fullWidth
+          >
+            {t('editTableOfContents.actions.exportClipboard', 'Copy to clipboard')}
+          </Button>
+        </Tooltip>
+      </Stack>
+
+      <Divider />
+
+      <Switch
+        checked={replaceExisting}
+        onChange={(event) => onReplaceExistingChange(event.currentTarget.checked)}
+        label={t('editTableOfContents.settings.replaceExisting', 'Replace existing bookmarks')}
+        description={t('editTableOfContents.settings.replaceExistingHint', 'When disabled, the new outline is appended after the current bookmarks.')}
+        disabled={disabled}
+      />
+
+      <Stack gap="xs">
+        {infoLines.map((line, index) => (
+          <Text key={index} size="sm" c="dimmed">
+            {line}
+          </Text>
+        ))}
+      </Stack>
+    </Stack>
+  );
+}

frontend/src/core/components/tools/editTableOfContents/EditTableOfContentsWorkbenchView.tsx

@@ -0,0 +1,203 @@
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  Box,
+  Button,
+  Card,
+  Divider,
+  Group,
+  Stack,
+  Text,
+} from '@mantine/core';
+import LocalIcon from '@app/components/shared/LocalIcon';
+import { BookmarkNode } from '@app/utils/editTableOfContents';
+import ErrorNotification from '@app/components/tools/shared/ErrorNotification';
+import ResultsPreview from '@app/components/tools/shared/ResultsPreview';
+import BookmarkEditor from '@app/components/tools/editTableOfContents/BookmarkEditor';
+
+export interface EditTableOfContentsWorkbenchViewData {
+  bookmarks: BookmarkNode[];
+  selectedFileName?: string;
+  disabled: boolean;
+  files: File[];
+  thumbnails: (string | undefined)[];
+  downloadUrl: string | null;
+  downloadFilename: string | null;
+  errorMessage: string | null;
+  isGeneratingThumbnails: boolean;
+  isExecuteDisabled: boolean;
+  isExecuting: boolean;
+  onClearError: () => void;
+  onBookmarksChange: (bookmarks: BookmarkNode[]) => void;
+  onExecute: () => void;
+  onUndo: () => void;
+  onFileClick: (file: File) => void;
+}
+
+interface EditTableOfContentsWorkbenchViewProps {
+  data: EditTableOfContentsWorkbenchViewData | null;
+}
+
+const EditTableOfContentsWorkbenchView = ({ data }: EditTableOfContentsWorkbenchViewProps) => {
+  const { t } = useTranslation();
+
+  if (!data) {
+    return (
+      <Box p="xl">
+        <Card withBorder radius="md">
+          <Stack gap="sm">
+            <Text fw={600}>{t('editTableOfContents.workbench.empty.title', 'Open the tool to start editing')}</Text>
+            <Text size="sm" c="dimmed">
+              {t('editTableOfContents.workbench.empty.description', 'Select the Edit Table of Contents tool to load its workspace.')}
+            </Text>
+          </Stack>
+        </Card>
+      </Box>
+    );
+  }
+
+  const {
+    bookmarks,
+    selectedFileName,
+    disabled,
+    files,
+    thumbnails,
+    downloadUrl,
+    downloadFilename,
+    errorMessage,
+    isGeneratingThumbnails,
+    isExecuteDisabled,
+    isExecuting,
+    onClearError,
+    onBookmarksChange,
+    onExecute,
+    onUndo,
+    onFileClick,
+  } = data;
+
+  const previewFiles = useMemo(
+    () =>
+      files?.map((file, index) => ({
+        file,
+        thumbnail: thumbnails[index],
+      })) ?? [],
+    [files, thumbnails]
+  );
+
+  const showResults = Boolean(
+    previewFiles.length > 0 || downloadUrl || errorMessage
+  );
+
+  return (
+    <Box
+      p="lg"
+      style={{
+        width: '100%',
+        height: '100%',
+        overflowY: 'auto',
+        background: 'var(--bg-raised)',
+      }}
+    >
+      <Stack gap="xl" maw={1200} mx="auto">
+        <Stack gap={4}>
+          <Text size="xl" fw={700}>
+            {t('home.editTableOfContents.title', 'Edit Table of Contents')}
+          </Text>
+          <Text size="sm" c="dimmed">
+            {t('editTableOfContents.workbench.subtitle', 'Import bookmarks, build hierarchies, and apply the outline without cramped side panels.')}
+          </Text>
+        </Stack>
+
+        <Card
+          withBorder
+          radius="md"
+          p="xl"
+          style={{
+            backgroundColor: 'var(--bg-surface)',
+            borderColor: 'var(--border-default)',
+            boxShadow: 'var(--shadow-md)',
+          }}
+        >
+          <Stack gap="md">
+            <Stack gap={2}>
+              <Text fw={600}>{t('editTableOfContents.editor.heading', 'Bookmark editor')}</Text>
+              <Text size="sm" c="dimmed">
+                {selectedFileName
+                  ? t('editTableOfContents.actions.selectedFile', { file: selectedFileName })
+                  : t('editTableOfContents.workbench.filePrompt', 'Select a PDF from your library or upload a new one to begin.')}
+              </Text>
+            </Stack>
+            <BookmarkEditor bookmarks={bookmarks} onChange={onBookmarksChange} disabled={disabled} />
+            <Divider />
+            <Group justify="flex-end">
+              <Button
+                leftSection={<LocalIcon icon="menu-book-rounded" />}
+                color="blue"
+                onClick={onExecute}
+                disabled={isExecuteDisabled}
+                loading={isExecuting}
+              >
+                {t('editTableOfContents.submit', 'Apply table of contents')}
+              </Button>
+            </Group>
+          </Stack>
+        </Card>
+
+        {showResults && (
+          <Card
+            withBorder
+            radius="md"
+            p="xl"
+            style={{
+              backgroundColor: 'var(--bg-surface)',
+              borderColor: 'var(--border-default)',
+              boxShadow: 'var(--shadow-md)',
+            }}
+          >
+            <Stack gap="md">
+              <Stack gap={4}>
+                <Text fw={600}>{t('editTableOfContents.results.title', 'Updated PDF with bookmarks')}</Text>
+                <Text size="sm" c="dimmed">
+                  {t('editTableOfContents.results.subtitle', 'Download the processed file or undo the operation below.')}
+                </Text>
+              </Stack>
+
+              <ErrorNotification error={errorMessage} onClose={onClearError} />
+
+              {previewFiles.length > 0 && (
+                <ResultsPreview
+                  files={previewFiles}
+                  onFileClick={onFileClick}
+                  isGeneratingThumbnails={isGeneratingThumbnails}
+                />
+              )}
+
+              <Group justify="flex-end" gap="sm">
+                {downloadUrl && (
+                  <Button
+                    component="a"
+                    href={downloadUrl}
+                    download={downloadFilename ?? undefined}
+                    leftSection={<LocalIcon icon='download-rounded' />}
+                  >
+                    {t('download', 'Download')}
+                  </Button>
+                )}
+                <Button
+                  variant="outline"
+                  leftSection={<LocalIcon icon="rotate-left" />}
+                  onClick={onUndo}
+                  disabled={isExecuting}
+                >
+                  {t('undo', 'Undo')}
+                </Button>
+              </Group>
+            </Stack>
+          </Card>
+        )}
+      </Stack>
+    </Box>
+  );
+};
+
+export default EditTableOfContentsWorkbenchView;

frontend/src/core/components/viewer/LocalEmbedPDF.tsx

@@ -191,7 +191,6 @@ export function LocalEmbedPDF({ file, url, enableAnnotations = false, onSignatur
           height: '100%',
           width: '100%',
           position: 'relative',
-          overflow: 'hidden',
           flex: 1,
           minHeight: 0,
           minWidth: 0,
@@ -287,8 +286,6 @@ export function LocalEmbedPDF({ file, url, enableAnnotations = false, onSignatur
               minHeight: 0,
               minWidth: 0,
               contain: 'strict',
-              display: 'flex',
-              justifyContent: 'center',
             }}
           >
           <Scroller

frontend/src/core/components/viewer/ZoomAPIBridge.tsx

@@ -7,9 +7,7 @@ import {
   determineAutoZoom,
   DEFAULT_FALLBACK_ZOOM,
   DEFAULT_VISIBILITY_THRESHOLD,
-  measureRenderedPageRect,
   useFitWidthResize,
-  ZoomViewport,
 } from '@app/utils/viewerZoom';
 import { getFirstPageAspectRatioFromStub } from '@app/utils/pageMetadata';
 
@@ -73,18 +71,6 @@ export function ZoomAPIBridge() {
     }
   }, [spreadMode, zoomState?.zoomLevel, scheduleAutoZoom, requestFitWidth]);
 
-  const getViewportSnapshot = useCallback((): ZoomViewport | null => {
-    if (!zoomState || typeof zoomState !== 'object') {
-      return null;
-    }
-
-    if ('viewport' in zoomState) {
-      const candidate = (zoomState as { viewport?: ZoomViewport | null }).viewport;
-      return candidate ?? null;
-    }
-
-    return null;
-  }, [zoomState]);
 
   const isManagedZoom =
     !!zoom &&
@@ -119,7 +105,7 @@ export function ZoomAPIBridge() {
     }
 
     const fitWidthZoom = zoomState.currentZoomLevel;
-    if (!fitWidthZoom || fitWidthZoom <= 0) {
+    if (!fitWidthZoom || fitWidthZoom <= 0 || fitWidthZoom === 1) {
       return;
     }
 
@@ -137,37 +123,23 @@ export function ZoomAPIBridge() {
       const pagesPerSpread = currentSpreadMode !== SpreadMode.None ? 2 : 1;
       const metadataAspectRatio = getFirstPageAspectRatioFromStub(firstFileStub);
 
-      const viewport = getViewportSnapshot();
-
       if (cancelled) {
         return;
       }
 
-      const metrics = viewport ?? {};
-      const viewportWidth =
-        metrics.clientWidth ?? metrics.width ?? window.innerWidth ?? 0;
-      const viewportHeight =
-        metrics.clientHeight ?? metrics.height ?? window.innerHeight ?? 0;
+      const viewportWidth = window.innerWidth ?? 0;
+      const viewportHeight = window.innerHeight ?? 0;
 
       if (viewportWidth <= 0 || viewportHeight <= 0) {
         return;
       }
 
-      const pageRect = await measureRenderedPageRect({
-        shouldCancel: () => cancelled,
-      });
-      if (cancelled) {
-        return;
-      }
-
       const decision = determineAutoZoom({
         viewportWidth,
         viewportHeight,
         fitWidthZoom,
         pagesPerSpread,
-        pageRect: pageRect
-          ? { width: pageRect.width, height: pageRect.height }
-          : undefined,
+        pageRect: undefined,
         metadataAspectRatio: metadataAspectRatio ?? null,
         visibilityThreshold: DEFAULT_VISIBILITY_THRESHOLD,
         fallbackZoom: DEFAULT_FALLBACK_ZOOM,
@@ -197,7 +169,6 @@ export function ZoomAPIBridge() {
     firstFileId,
     firstFileStub,
     requestFitWidth,
-    getViewportSnapshot,
     autoZoomTick,
     spreadMode,
     triggerImmediateZoomUpdate,

frontend/src/core/contexts/AppConfigContext.tsx

@@ -39,6 +39,9 @@ export interface AppConfig {
   license?: string;
   SSOAutoLogin?: boolean;
   serverCertificateEnabled?: boolean;
+  appVersion?: string;
+  machineType?: string;
+  activeSecurity?: boolean;
   error?: string;
 }
 

frontend/src/core/contexts/BannerContext.tsx

@@ -0,0 +1,26 @@
+import { createContext, useContext, useState, ReactNode } from 'react';
+
+interface BannerContextType {
+  banner: ReactNode;
+  setBanner: (banner: ReactNode) => void;
+}
+
+const BannerContext = createContext<BannerContextType | undefined>(undefined);
+
+export function BannerProvider({ children }: { children: ReactNode }) {
+  const [banner, setBanner] = useState<ReactNode>(null);
+
+  return (
+    <BannerContext.Provider value={{ banner, setBanner }}>
+      {children}
+    </BannerContext.Provider>
+  );
+}
+
+export function useBanner() {
+  const context = useContext(BannerContext);
+  if (!context) {
+    throw new Error('useBanner must be used within BannerProvider');
+  }
+  return context;
+}

frontend/src/core/contexts/HotkeyContext.tsx

@@ -3,7 +3,6 @@ import { HotkeyBinding, bindingEquals, bindingMatchesEvent, deserializeBindings,
 import { useToolWorkflow } from '@app/contexts/ToolWorkflowContext';
 import { ToolId } from '@app/types/toolId';
 import { ToolCategoryId, ToolRegistryEntry } from '@app/data/toolsTaxonomy';
-import { addLocalSettingsListener, emitLocalSettingsEvent } from '@app/utils/localSettingsEvents';
 
 type Bindings = Partial<Record<ToolId, HotkeyBinding>>;
 
@@ -111,25 +110,8 @@ export const HotkeyProvider: React.FC<{ children: React.ReactNode }> = ({ childr
       return;
     }
     window.localStorage.setItem(STORAGE_KEY, serializeBindings(customBindings));
-    emitLocalSettingsEvent([STORAGE_KEY], 'local');
   }, [customBindings]);
 
-  useEffect(() => {
-    if (typeof window === 'undefined') {
-      return;
-    }
-
-    return addLocalSettingsListener(detail => {
-      if (detail.origin !== 'remote') {
-        return;
-      }
-      if (detail.keys.includes(STORAGE_KEY)) {
-        const stored = window.localStorage.getItem(STORAGE_KEY);
-        setCustomBindings(deserializeBindings(stored));
-      }
-    });
-  }, []);
-
   const isBindingAvailable = useCallback((binding: HotkeyBinding, excludeToolId?: ToolId) => {
     const normalized = normalizeBinding(binding);
     return Object.entries(resolved).every(([toolId, existing]) => {

frontend/src/core/contexts/PreferencesContext.tsx

@@ -1,6 +1,5 @@
-import React, { createContext, useContext, useState, useCallback, useEffect } from 'react';
-import { preferencesService, UserPreferences, PREFERENCES_STORAGE_KEY } from '@app/services/preferencesService';
-import { addLocalSettingsListener } from '@app/utils/localSettingsEvents';
+import React, { createContext, useContext, useState, useCallback } from 'react';
+import { preferencesService, UserPreferences } from '@app/services/preferencesService';
 
 interface PreferencesContextValue {
   preferences: UserPreferences;
@@ -19,17 +18,6 @@ export const PreferencesProvider: React.FC<{ children: React.ReactNode }> = ({ c
     return preferencesService.getAllPreferences();
   });
 
-  useEffect(() => {
-    return addLocalSettingsListener(detail => {
-      if (detail.origin !== 'remote') {
-        return;
-      }
-      if (detail.keys.includes(PREFERENCES_STORAGE_KEY)) {
-        setPreferences(preferencesService.getAllPreferences());
-      }
-    });
-  }, []);
-
   const updatePreference = useCallback(
     <K extends keyof UserPreferences>(key: K, value: UserPreferences[K]) => {
       preferencesService.setPreference(key, value);

frontend/src/core/data/useTranslatedToolRegistry.tsx

@@ -31,6 +31,7 @@ import AddWatermark from "@app/tools/AddWatermark";
 import AddStamp from "@app/tools/AddStamp";
 import AddAttachments from "@app/tools/AddAttachments";
 import Merge from '@app/tools/Merge';
+import EditTableOfContents from '@app/tools/EditTableOfContents';
 import Repair from "@app/tools/Repair";
 import AutoRename from "@app/tools/AutoRename";
 import SingleLargePage from "@app/tools/SingleLargePage";
@@ -63,6 +64,7 @@ import { changePermissionsOperationConfig } from "@app/hooks/tools/changePermiss
 import { certSignOperationConfig } from "@app/hooks/tools/certSign/useCertSignOperation";
 import { bookletImpositionOperationConfig } from "@app/hooks/tools/bookletImposition/useBookletImpositionOperation";
 import { mergeOperationConfig } from '@app/hooks/tools/merge/useMergeOperation';
+import { editTableOfContentsOperationConfig } from '@app/hooks/tools/editTableOfContents/useEditTableOfContentsOperation';
 import { autoRenameOperationConfig } from "@app/hooks/tools/autoRename/useAutoRenameOperation";
 import { flattenOperationConfig } from "@app/hooks/tools/flatten/useFlattenOperation";
 import { redactOperationConfig } from "@app/hooks/tools/redact/useRedactOperation";
@@ -345,6 +347,23 @@ export function useTranslatedToolCatalog(): TranslatedToolCatalog {
         automationSettings: ChangeMetadataSingleStep,
         synonyms: getSynonyms(t, "changeMetadata")
       },
+      editTableOfContents: {
+        icon: <LocalIcon icon="toc-rounded" width="1.5rem" height="1.5rem" />,
+        name: t("home.editTableOfContents.title", "Edit Table of Contents"),
+        component: EditTableOfContents,
+        description: t(
+          "home.editTableOfContents.desc",
+          "Add or edit bookmarks and table of contents in PDF documents"
+        ),
+        categoryId: ToolCategoryId.STANDARD_TOOLS,
+        subcategoryId: SubcategoryId.DOCUMENT_REVIEW,
+        maxFiles: 1,
+        endpoints: ["edit-table-of-contents"],
+        operationConfig: editTableOfContentsOperationConfig,
+        automationSettings: null,
+        supportsAutomate: false,
+        synonyms: getSynonyms(t, "editTableOfContents"),
+      },
       // Page Formatting
 
       crop: {
@@ -689,16 +708,6 @@ export function useTranslatedToolCatalog(): TranslatedToolCatalog {
         synonyms: getSynonyms(t, "addImage"),
         automationSettings: null
       },
-      editTableOfContents: {
-        icon: <LocalIcon icon="bookmark-add-rounded" width="1.5rem" height="1.5rem" />,
-        name: t("home.editTableOfContents.title", "Edit Table of Contents"),
-        component: null,
-        description: t("home.editTableOfContents.desc", "Add or edit bookmarks and table of contents in PDF documents"),
-        categoryId: ToolCategoryId.ADVANCED_TOOLS,
-        subcategoryId: SubcategoryId.ADVANCED_FORMATTING,
-        synonyms: getSynonyms(t, "editTableOfContents"),
-        automationSettings: null
-      },
       scannerEffect: {
         icon: <LocalIcon icon="scanner-rounded" width="1.5rem" height="1.5rem" />,
         name: t("home.scannerEffect.title", "Scanner Effect"),

frontend/src/core/hooks/tools/editTableOfContents/useEditTableOfContentsOperation.ts

@@ -0,0 +1,31 @@
+import { useTranslation } from 'react-i18next';
+import { ToolType, type ToolOperationConfig, useToolOperation } from '@app/hooks/tools/shared/useToolOperation';
+import { createStandardErrorHandler } from '@app/utils/toolErrorHandler';
+import { EditTableOfContentsParameters } from '@app/hooks/tools/editTableOfContents/useEditTableOfContentsParameters';
+import { serializeBookmarkNodes } from '@app/utils/editTableOfContents';
+
+const buildFormData = (parameters: EditTableOfContentsParameters, file: File): FormData => {
+  const formData = new FormData();
+  formData.append('fileInput', file);
+  formData.append('replaceExisting', String(parameters.replaceExisting));
+  formData.append('bookmarkData', JSON.stringify(serializeBookmarkNodes(parameters.bookmarks)));
+  return formData;
+};
+
+export const editTableOfContentsOperationConfig: ToolOperationConfig<EditTableOfContentsParameters> = {
+  toolType: ToolType.singleFile,
+  operationType: 'editTableOfContents',
+  endpoint: '/api/v1/general/edit-table-of-contents',
+  buildFormData,
+};
+
+export const useEditTableOfContentsOperation = () => {
+  const { t } = useTranslation();
+  return useToolOperation<EditTableOfContentsParameters>({
+    ...editTableOfContentsOperationConfig,
+    getErrorMessage: createStandardErrorHandler(
+      t('editTableOfContents.error.failed', 'Failed to update the table of contents')
+    ),
+  });
+};
+

frontend/src/core/hooks/tools/editTableOfContents/useEditTableOfContentsParameters.ts

@@ -0,0 +1,37 @@
+import { useCallback } from 'react';
+import { useBaseParameters, type BaseParametersHook } from '@app/hooks/tools/shared/useBaseParameters';
+import { BookmarkNode } from '@app/utils/editTableOfContents';
+
+export interface EditTableOfContentsParameters {
+  replaceExisting: boolean;
+  bookmarks: BookmarkNode[];
+}
+
+export interface EditTableOfContentsParametersHook extends BaseParametersHook<EditTableOfContentsParameters> {
+  setBookmarks: (bookmarks: BookmarkNode[]) => void;
+}
+
+const defaultParameters: EditTableOfContentsParameters = {
+  replaceExisting: true,
+  bookmarks: [],
+};
+
+export const useEditTableOfContentsParameters = (): EditTableOfContentsParametersHook => {
+  const base = useBaseParameters<EditTableOfContentsParameters>({
+    defaultParameters,
+    endpointName: 'edit-table-of-contents',
+  });
+
+  const setBookmarks = useCallback((bookmarks: BookmarkNode[]) => {
+    base.setParameters(prev => ({
+      ...prev,
+      bookmarks,
+    }));
+  }, [base.setParameters]);
+
+  return {
+    ...base,
+    setBookmarks,
+  };
+};
+

frontend/src/core/hooks/tools/useUserToolActivity.ts

@@ -1,6 +1,5 @@
 import { useState, useEffect, useCallback } from 'react';
 import { ToolId } from '@app/types/toolId';
-import { addLocalSettingsListener, emitLocalSettingsEvent } from '@app/utils/localSettingsEvents';
 
 const RECENT_TOOLS_KEY = 'stirlingpdf.recentTools';
 const FAVORITE_TOOLS_KEY = 'stirlingpdf.favoriteTools';
@@ -37,44 +36,6 @@ export function useToolHistory() {
     }
   }, []);
 
-  useEffect(() => {
-    if (typeof window === 'undefined') {
-      return;
-    }
-
-    return addLocalSettingsListener(detail => {
-      if (detail.origin !== 'remote') {
-        return;
-      }
-
-      if (detail.keys.includes(FAVORITE_TOOLS_KEY)) {
-        const favoritesStr = window.localStorage.getItem(FAVORITE_TOOLS_KEY);
-        if (favoritesStr) {
-          try {
-            setFavoriteTools(JSON.parse(favoritesStr));
-          } catch {
-            setFavoriteTools([]);
-          }
-        } else {
-          setFavoriteTools([]);
-        }
-      }
-
-      if (detail.keys.includes(RECENT_TOOLS_KEY)) {
-        const recentStr = window.localStorage.getItem(RECENT_TOOLS_KEY);
-        if (recentStr) {
-          try {
-            setRecentTools(JSON.parse(recentStr));
-          } catch {
-            setRecentTools([]);
-          }
-        } else {
-          setRecentTools([]);
-        }
-      }
-    });
-  }, []);
-
 
   // Toggle favorite status
   const toggleFavorite = useCallback((toolId: ToolId) => {
@@ -88,7 +49,6 @@ export function useToolHistory() {
         ? prev.filter((id) => id !== toolId)
         : [...prev, toolId];
       window.localStorage.setItem(FAVORITE_TOOLS_KEY, JSON.stringify(updated));
-      emitLocalSettingsEvent([FAVORITE_TOOLS_KEY], 'local');
       return updated;
     });
   }, []);

frontend/src/core/services/apiClient.ts

@@ -7,6 +7,7 @@ import { getApiBaseUrl } from '@app/services/apiClientConfig';
 const apiClient = axios.create({
   baseURL: getApiBaseUrl(),
   responseType: 'json',
+  withCredentials: true,
 });
 
 // Setup interceptors (core does nothing, proprietary adds JWT auth)

frontend/src/core/services/preferencesService.ts

@@ -1,6 +1,5 @@
 import { type ToolPanelMode, DEFAULT_TOOL_PANEL_MODE } from '@app/constants/toolPanel';
 import { type ThemeMode, getSystemTheme } from '@app/constants/theme';
-import { emitLocalSettingsEvent } from '@app/utils/localSettingsEvents';
 
 export interface UserPreferences {
   autoUnzip: boolean;
@@ -10,7 +9,6 @@ export interface UserPreferences {
   toolPanelModePromptSeen: boolean;
   showLegacyToolDescriptions: boolean;
   hasCompletedOnboarding: boolean;
-  syncSettingsAcrossDevices: boolean;
 }
 
 export const DEFAULT_PREFERENCES: UserPreferences = {
@@ -21,11 +19,9 @@ export const DEFAULT_PREFERENCES: UserPreferences = {
   toolPanelModePromptSeen: false,
   showLegacyToolDescriptions: false,
   hasCompletedOnboarding: false,
-  syncSettingsAcrossDevices: false,
 };
 
-export const PREFERENCES_STORAGE_KEY = 'stirlingpdf_preferences';
-const STORAGE_KEY = PREFERENCES_STORAGE_KEY;
+const STORAGE_KEY = 'stirlingpdf_preferences';
 
 class PreferencesService {
   getPreference<K extends keyof UserPreferences>(
@@ -55,7 +51,6 @@ class PreferencesService {
       const preferences = stored ? JSON.parse(stored) : {};
       preferences[key] = value;
       localStorage.setItem(STORAGE_KEY, JSON.stringify(preferences));
-      emitLocalSettingsEvent([STORAGE_KEY], 'local');
     } catch (error) {
       console.error('Error writing preference:', key, error);
     }
@@ -81,7 +76,6 @@ class PreferencesService {
   clearAllPreferences(): void {
     try {
       localStorage.removeItem(STORAGE_KEY);
-      emitLocalSettingsEvent([STORAGE_KEY], 'local');
     } catch (error) {
       console.error('Error clearing preferences:', error);
       throw error;

frontend/src/core/services/updateService.ts

@@ -0,0 +1,186 @@
+export interface UpdateSummary {
+  latest_version: string;
+  latest_stable_version?: string;
+  max_priority: 'urgent' | 'normal' | 'minor' | 'low';
+  recommended_action?: string;
+  any_breaking: boolean;
+  migration_guides?: Array<{
+    version: string;
+    notes: string;
+    url: string;
+  }>;
+}
+
+export interface VersionUpdate {
+  version: string;
+  priority: 'urgent' | 'normal' | 'minor' | 'low';
+  announcement: {
+    title: string;
+    message: string;
+  };
+  compatibility: {
+    breaking_changes: boolean;
+    breaking_description?: string;
+    migration_guide_url?: string;
+  };
+}
+
+export interface FullUpdateInfo {
+  latest_version: string;
+  latest_stable_version?: string;
+  new_versions: VersionUpdate[];
+}
+
+export interface MachineInfo {
+  machineType: string;
+  activeSecurity: boolean;
+  licenseType: string;
+}
+
+export class UpdateService {
+  private readonly baseUrl = 'https://supabase.stirling.com/functions/v1/updates';
+
+  /**
+   * Compare two version strings
+   * @returns 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+   */
+  compareVersions(version1: string, version2: string): number {
+    const v1 = version1.split('.');
+    const v2 = version2.split('.');
+
+    for (let i = 0; i < v1.length || i < v2.length; i++) {
+      const n1 = parseInt(v1[i]) || 0;
+      const n2 = parseInt(v2[i]) || 0;
+
+      if (n1 > n2) {
+        return 1;
+      } else if (n1 < n2) {
+        return -1;
+      }
+    }
+
+    return 0;
+  }
+
+  /**
+   * Get download URL based on machine type and security settings
+   */
+  getDownloadUrl(machineInfo: MachineInfo): string | null {
+    // Only show download for non-Docker installations
+    if (machineInfo.machineType === 'Docker' || machineInfo.machineType === 'Kubernetes') {
+      return null;
+    }
+
+    const baseUrl = 'https://files.stirlingpdf.com/';
+
+    // Determine file based on machine type and security
+    if (machineInfo.machineType === 'Server-jar') {
+      return baseUrl + (machineInfo.activeSecurity ? 'Stirling-PDF-with-login.jar' : 'Stirling-PDF.jar');
+    }
+
+    // Client installations
+    if (machineInfo.machineType.startsWith('Client-')) {
+      const os = machineInfo.machineType.replace('Client-', ''); // win, mac, unix
+      const type = machineInfo.activeSecurity ? '-server-security' : '-server';
+
+      if (os === 'unix') {
+        return baseUrl + os + type + '.jar';
+      } else if (os === 'win') {
+        return baseUrl + os + '-installer.exe';
+      } else if (os === 'mac') {
+        return baseUrl + os + '-installer.dmg';
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Fetch update summary from API
+   */
+  async getUpdateSummary(currentVersion: string, machineInfo: MachineInfo): Promise<UpdateSummary | null> {
+    // Map Java License enum to API types
+    let type = 'normal';
+    if (machineInfo.licenseType === 'PRO') {
+      type = 'pro';
+    } else if (machineInfo.licenseType === 'ENTERPRISE') {
+      type = 'enterprise';
+    }
+
+    const url = `${this.baseUrl}?from=${currentVersion}&type=${type}&login=${machineInfo.activeSecurity}&summary=true`;
+    console.log('Fetching update summary from:', url);
+
+    try {
+      const response = await fetch(url);
+      console.log('Response status:', response.status);
+
+      if (response.status === 200) {
+        const data = await response.json();
+        return data as UpdateSummary;
+      } else {
+        console.error('Failed to fetch update summary from Supabase:', response.status);
+        return null;
+      }
+    } catch (error) {
+      console.error('Failed to fetch update summary from Supabase:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Fetch full update information with detailed version info
+   */
+  async getFullUpdateInfo(currentVersion: string, machineInfo: MachineInfo): Promise<FullUpdateInfo | null> {
+    // Map Java License enum to API types
+    let type = 'normal';
+    if (machineInfo.licenseType === 'PRO') {
+      type = 'pro';
+    } else if (machineInfo.licenseType === 'ENTERPRISE') {
+      type = 'enterprise';
+    }
+
+    const url = `${this.baseUrl}?from=${currentVersion}&type=${type}&login=${machineInfo.activeSecurity}&summary=false`;
+    console.log('Fetching full update info from:', url);
+
+    try {
+      const response = await fetch(url);
+      console.log('Full update response status:', response.status);
+
+      if (response.status === 200) {
+        const data = await response.json();
+        return data as FullUpdateInfo;
+      } else {
+        console.error('Failed to fetch full update info from Supabase:', response.status);
+        return null;
+      }
+    } catch (error) {
+      console.error('Failed to fetch full update info from Supabase:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Get current version from GitHub build.gradle as fallback
+   */
+  async getCurrentVersionFromGitHub(): Promise<string> {
+    const url = 'https://raw.githubusercontent.com/Stirling-Tools/Stirling-PDF/master/build.gradle';
+
+    try {
+      const response = await fetch(url);
+      if (response.status === 200) {
+        const text = await response.text();
+        const versionRegex = /version\s*=\s*['"](\d+\.\d+\.\d+)['"]/;
+        const match = versionRegex.exec(text);
+        if (match) {
+          return match[1];
+        }
+      }
+      throw new Error('Version number not found');
+    } catch (error) {
+      console.error('Failed to fetch latest version from build.gradle:', error);
+      return '';
+    }
+  }
+}
+
+export const updateService = new UpdateService();

frontend/src/core/styles/zIndex.ts

@@ -15,7 +15,7 @@ export const Z_INDEX_HOVER_ACTION_MENU = 100;
 export const Z_INDEX_SELECTION_BOX = 1000;
 export const Z_INDEX_DROP_INDICATOR = 1001;
 export const Z_INDEX_DRAG_BADGE = 1001;
-// Modal that appears on top of config modal (e.g., restart confirmation)
+// Modal that appears on top of config modal (e.g., restart confirmation, update modal)
 export const Z_INDEX_OVER_CONFIG_MODAL = 2000;
 
 // Toast notifications and error displays - Always on top (higher than rainbow theme at 10000)

frontend/src/core/tools/EditTableOfContents.tsx

@@ -0,0 +1,394 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import MenuBookRoundedIcon from '@mui/icons-material/MenuBookRounded';
+import { alert } from '@app/components/toast';
+import { createToolFlow } from '@app/components/tools/shared/createToolFlow';
+import EditTableOfContentsWorkbenchView, { EditTableOfContentsWorkbenchViewData } from '@app/components/tools/editTableOfContents/EditTableOfContentsWorkbenchView';
+import EditTableOfContentsSettings from '@app/components/tools/editTableOfContents/EditTableOfContentsSettings';
+import { useEditTableOfContentsParameters } from '@app/hooks/tools/editTableOfContents/useEditTableOfContentsParameters';
+import { useEditTableOfContentsOperation } from '@app/hooks/tools/editTableOfContents/useEditTableOfContentsOperation';
+import { BaseToolProps, ToolComponent } from '@app/types/tool';
+import { useBaseTool } from '@app/hooks/tools/shared/useBaseTool';
+import apiClient from '@app/services/apiClient';
+import { BookmarkPayload, BookmarkNode, hydrateBookmarkPayload, serializeBookmarkNodes } from '@app/utils/editTableOfContents';
+import { useToolWorkflow } from '@app/contexts/ToolWorkflowContext';
+import { useFilesModalContext } from '@app/contexts/FilesModalContext';
+import { useNavigationActions, useNavigationState } from '@app/contexts/NavigationContext';
+import { useFileSelection } from '@app/contexts/FileContext';
+
+const extractBookmarks = async (file: File): Promise<BookmarkPayload[]> => {
+  const formData = new FormData();
+  formData.append('file', file);
+
+  const response = await apiClient.post('/api/v1/general/extract-bookmarks', formData, {
+    headers: { 'Content-Type': 'multipart/form-data' },
+  });
+
+  return response.data as BookmarkPayload[];
+};
+
+const useStableCallback = <T extends (...args: any[]) => any>(callback: T): T => {
+  const callbackRef = useRef(callback);
+
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+
+  return useMemo(() => ((...args: Parameters<T>) => callbackRef.current(...args)) as T, []);
+};
+
+const EditTableOfContents = (props: BaseToolProps) => {
+  const { t } = useTranslation();
+  const base = useBaseTool(
+    'edit-table-of-contents',
+    useEditTableOfContentsParameters,
+    useEditTableOfContentsOperation,
+    props,
+    { minFiles: 1 }
+  );
+  const {
+    registerCustomWorkbenchView,
+    unregisterCustomWorkbenchView,
+    setCustomWorkbenchViewData,
+    clearCustomWorkbenchViewData,
+  } = useToolWorkflow();
+  const { openFilesModal } = useFilesModalContext();
+  const { clearSelections } = useFileSelection();
+  const navigationState = useNavigationState();
+  const { actions: navigationActions } = useNavigationActions();
+
+  const WORKBENCH_VIEW_ID = 'editTableOfContentsWorkbench';
+  const WORKBENCH_ID = 'custom:editTableOfContents' as const;
+  const viewIcon = useMemo(() => <MenuBookRoundedIcon fontSize="small" />, []);
+
+  const [loadError, setLoadError] = useState<string | null>(null);
+  const [isLoadingBookmarks, setIsLoadingBookmarks] = useState(false);
+  const [lastLoadedFileId, setLastLoadedFileId] = useState<string | null>(null);
+  const hasAutoOpenedWorkbenchRef = useRef(false);
+
+  const selectedFile = base.selectedFiles[0];
+
+  const { setBookmarks } = base.params;
+
+  useEffect(() => {
+    registerCustomWorkbenchView({
+      id: WORKBENCH_VIEW_ID,
+      workbenchId: WORKBENCH_ID,
+      label: 'Outline workspace',
+      icon: viewIcon,
+      component: EditTableOfContentsWorkbenchView,
+    });
+
+    return () => {
+      clearCustomWorkbenchViewData(WORKBENCH_VIEW_ID);
+      unregisterCustomWorkbenchView(WORKBENCH_VIEW_ID);
+    };
+  // Register once; avoid re-registering which clears data mid-flight
+  }, []);
+
+  const loadBookmarksForFile = useCallback(async (file: File, { showToast }: { showToast?: boolean } = {}) => {
+    setIsLoadingBookmarks(true);
+    setLoadError(null);
+
+    try {
+      const payload = await extractBookmarks(file);
+      const bookmarks = hydrateBookmarkPayload(payload);
+      setBookmarks(bookmarks);
+      setLastLoadedFileId((file as any)?.fileId ?? file.name);
+
+      if (showToast) {
+        alert({
+          title: t('editTableOfContents.messages.loadedTitle', 'Bookmarks extracted'),
+          body: t('editTableOfContents.messages.loadedBody', 'Existing bookmarks from the PDF were loaded into the editor.'),
+          alertType: 'success',
+        });
+      }
+
+      if (bookmarks.length === 0) {
+        setLoadError(t('editTableOfContents.messages.noBookmarks', 'No bookmarks were found in the selected PDF.'));
+      }
+    } catch (error) {
+      console.error('Failed to load bookmarks', error);
+      setLoadError(t('editTableOfContents.messages.loadFailed', 'Unable to extract bookmarks from the selected PDF.'));
+    } finally {
+      setIsLoadingBookmarks(false);
+    }
+  }, [setBookmarks, t]);
+
+  useEffect(() => {
+    // Don't auto-load bookmarks if we have results - user is viewing the output
+    if (base.hasResults) {
+      return;
+    }
+
+    if (!selectedFile) {
+      setBookmarks([]);
+      setLastLoadedFileId(null);
+      setLoadError(null);
+      return;
+    }
+
+    const fileId = (selectedFile as any)?.fileId ?? selectedFile.name;
+    if (fileId === lastLoadedFileId) {
+      return;
+    }
+
+    loadBookmarksForFile(selectedFile).catch(() => {
+      // errors handled in hook
+    });
+  }, [selectedFile, lastLoadedFileId, loadBookmarksForFile, setBookmarks, base.hasResults]);
+
+  const importJsonCallback = async (file: File) => {
+    try {
+      const text = await file.text();
+      const json = JSON.parse(text) as BookmarkPayload[];
+      setBookmarks(hydrateBookmarkPayload(json));
+      alert({
+        title: t('editTableOfContents.messages.imported', 'Bookmarks imported'),
+        body: t('editTableOfContents.messages.importedBody', 'Your JSON outline replaced the current editor contents.'),
+        alertType: 'success',
+      });
+    } catch (error) {
+      console.error('Failed to import JSON bookmarks', error);
+      alert({
+        title: t('editTableOfContents.messages.invalidJson', 'Invalid JSON structure'),
+        body: t('editTableOfContents.messages.invalidJsonBody', 'Please provide a valid bookmark JSON file and try again.'),
+        alertType: 'error',
+      });
+    }
+  };
+  const handleImportJson = useStableCallback(importJsonCallback);
+
+  const importClipboardCallback = async () => {
+    if (!navigator.clipboard?.readText) {
+      alert({
+        title: t('editTableOfContents.actions.clipboardUnavailable', 'Clipboard access unavailable'),
+        alertType: 'warning',
+      });
+      return;
+    }
+
+    try {
+      const clipboard = await navigator.clipboard.readText();
+      const json = JSON.parse(clipboard) as BookmarkPayload[];
+      setBookmarks(hydrateBookmarkPayload(json));
+      alert({
+        title: t('editTableOfContents.messages.imported', 'Bookmarks imported'),
+        body: t('editTableOfContents.messages.importedClipboard', 'Clipboard data replaced the current bookmark list.'),
+        alertType: 'success',
+      });
+    } catch (error) {
+      console.error('Failed to import bookmarks from clipboard', error);
+      alert({
+        title: t('editTableOfContents.messages.invalidJson', 'Invalid JSON structure'),
+        body: t('editTableOfContents.messages.invalidJsonBody', 'Please provide a valid bookmark JSON file and try again.'),
+        alertType: 'error',
+      });
+    }
+  };
+  const handleImportClipboard = useStableCallback(importClipboardCallback);
+
+  const exportJsonCallback = () => {
+    const data = JSON.stringify(serializeBookmarkNodes(base.params.parameters.bookmarks), null, 2);
+    const blob = new Blob([data], { type: 'application/json' });
+    const url = URL.createObjectURL(blob);
+    const anchor = document.createElement('a');
+    anchor.href = url;
+    anchor.download = 'bookmarks.json';
+    document.body.appendChild(anchor);
+    anchor.click();
+    document.body.removeChild(anchor);
+    URL.revokeObjectURL(url);
+    alert({
+      title: t('editTableOfContents.messages.exported', 'JSON download ready'),
+      alertType: 'success',
+    });
+  };
+  const handleExportJson = useStableCallback(exportJsonCallback);
+
+  const exportClipboardCallback = async () => {
+    if (!navigator.clipboard?.writeText) {
+      alert({
+        title: t('editTableOfContents.actions.clipboardUnavailable', 'Clipboard access unavailable'),
+        alertType: 'warning',
+      });
+      return;
+    }
+
+    const data = JSON.stringify(serializeBookmarkNodes(base.params.parameters.bookmarks), null, 2);
+    try {
+      await navigator.clipboard.writeText(data);
+      alert({
+        title: t('editTableOfContents.messages.copied', 'Copied to clipboard'),
+        body: t('editTableOfContents.messages.copiedBody', 'Bookmark JSON copied successfully.'),
+        alertType: 'success',
+      });
+    } catch (error) {
+      console.error('Failed to copy bookmarks', error);
+      alert({
+        title: t('editTableOfContents.messages.copyFailed', 'Copy failed'),
+        alertType: 'error',
+      });
+    }
+  };
+  const handleExportClipboard = useStableCallback(exportClipboardCallback);
+
+  const clipboardReadAvailable = typeof navigator !== 'undefined' && Boolean(navigator.clipboard?.readText);
+  const clipboardWriteAvailable = typeof navigator !== 'undefined' && Boolean(navigator.clipboard?.writeText);
+
+  const loadFromSelectedCallback = () => {
+    if (selectedFile) {
+      loadBookmarksForFile(selectedFile, { showToast: true });
+    }
+  };
+  const handleLoadFromSelected = useStableCallback(loadFromSelectedCallback);
+
+  const replaceExistingCallback = (value: boolean) => {
+    base.params.updateParameter('replaceExisting', value);
+  };
+  const handleReplaceExistingChange = useStableCallback(replaceExistingCallback);
+
+  const bookmarksChangeCallback = (bookmarks: BookmarkNode[]) => {
+    setBookmarks(bookmarks);
+  };
+  const handleBookmarksChange = useStableCallback(bookmarksChangeCallback);
+
+  const executeCallback = () => {
+    void base.handleExecute();
+  };
+  const handleExecute = useStableCallback(executeCallback);
+
+  const undoCallback = () => {
+    base.handleUndo();
+  };
+  const handleUndo = useStableCallback(undoCallback);
+
+  const clearErrorCallback = () => {
+    base.operation.clearError();
+  };
+  const handleClearError = useStableCallback(clearErrorCallback);
+
+  const fileClickCallback = (file: File) => {
+    base.handleThumbnailClick(file);
+  };
+  const handleFileClick = useStableCallback(fileClickCallback);
+
+  const selectFilesCallback = () => {
+    // Clear existing selection first so the new file replaces instead of adds
+    clearSelections();
+    openFilesModal();
+  };
+  const handleSelectFiles = useStableCallback(selectFilesCallback);
+
+  // Always keep workbench data updated
+  useEffect(() => {
+    const data: EditTableOfContentsWorkbenchViewData = {
+      bookmarks: base.params.parameters.bookmarks,
+      selectedFileName: selectedFile?.name,
+      disabled: base.endpointLoading || base.operation.isLoading,
+      files: base.operation.files ?? [],
+      thumbnails: base.operation.thumbnails ?? [],
+      downloadUrl: base.operation.downloadUrl ?? null,
+      downloadFilename: base.operation.downloadFilename ?? null,
+      errorMessage: base.operation.errorMessage ?? null,
+      isGeneratingThumbnails: base.operation.isGeneratingThumbnails,
+      isExecuteDisabled:
+        !selectedFile ||
+        !base.hasFiles ||
+        base.endpointEnabled === false ||
+        base.operation.isLoading ||
+        base.endpointLoading,
+      isExecuting: base.operation.isLoading,
+      onClearError: handleClearError,
+      onBookmarksChange: handleBookmarksChange,
+      onExecute: handleExecute,
+      onUndo: handleUndo,
+      onFileClick: handleFileClick,
+    };
+
+    setCustomWorkbenchViewData(WORKBENCH_VIEW_ID, data);
+  }, [
+    WORKBENCH_VIEW_ID,
+    base.endpointEnabled,
+    base.endpointLoading,
+    base.hasFiles,
+    base.operation.downloadFilename,
+    base.operation.downloadUrl,
+    base.operation.errorMessage,
+    base.operation.files,
+    base.operation.isGeneratingThumbnails,
+    base.operation.isLoading,
+    base.operation.thumbnails,
+    base.params.parameters.bookmarks,
+    handleBookmarksChange,
+    handleClearError,
+    handleExecute,
+    handleFileClick,
+    handleUndo,
+    selectedFile,
+    setCustomWorkbenchViewData,
+  ]);
+
+  // Auto-navigate to workbench when tool is selected
+  useEffect(() => {
+    if (navigationState.selectedTool !== 'editTableOfContents') {
+      hasAutoOpenedWorkbenchRef.current = false;
+      return;
+    }
+
+    if (hasAutoOpenedWorkbenchRef.current) {
+      return;
+    }
+
+    hasAutoOpenedWorkbenchRef.current = true;
+    // Use timeout to ensure data effect has run first
+    setTimeout(() => {
+      navigationActions.setWorkbench(WORKBENCH_ID);
+    }, 0);
+  }, [navigationActions, navigationState.selectedTool, WORKBENCH_ID]);
+
+  return createToolFlow({
+    files: {
+      selectedFiles: base.selectedFiles,
+      isCollapsed: true,
+      minFiles: 1,
+      isVisible: false,
+    },
+    steps: [
+      {
+        title: t('editTableOfContents.settings.title', 'Bookmarks & outline'),
+        isCollapsed: false,
+        content: (
+          <EditTableOfContentsSettings
+            bookmarks={base.params.parameters.bookmarks}
+            replaceExisting={base.params.parameters.replaceExisting}
+            onReplaceExistingChange={handleReplaceExistingChange}
+            onSelectFiles={handleSelectFiles}
+            onLoadFromPdf={handleLoadFromSelected}
+            onImportJson={handleImportJson}
+            onImportClipboard={handleImportClipboard}
+            onExportJson={handleExportJson}
+            onExportClipboard={handleExportClipboard}
+            isLoading={isLoadingBookmarks}
+            loadError={loadError}
+            canReadClipboard={clipboardReadAvailable}
+            canWriteClipboard={clipboardWriteAvailable}
+            disabled={base.endpointLoading}
+            selectedFileName={selectedFile?.name}
+          />
+        ),
+      },
+    ],
+    review: {
+      isVisible: base.hasResults,
+      operation: base.operation,
+      title: t('editTableOfContents.results.title', 'Updated PDF with bookmarks'),
+      onFileClick: base.handleThumbnailClick,
+      onUndo: handleUndo,
+    },
+  });
+};
+
+(EditTableOfContents as any).tool = () => useEditTableOfContentsOperation;
+
+export default EditTableOfContents as ToolComponent;

frontend/src/core/utils/editTableOfContents.ts

@@ -0,0 +1,47 @@
+export interface BookmarkPayload {
+  title: string;
+  pageNumber: number;
+  children?: BookmarkPayload[];
+}
+
+export interface BookmarkNode {
+  id: string;
+  title: string;
+  pageNumber: number;
+  children: BookmarkNode[];
+  expanded: boolean;
+}
+
+const createBookmarkId = () => {
+  if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
+    return crypto.randomUUID();
+  }
+
+  return `bookmark-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+};
+
+export const createBookmarkNode = (bookmark?: Partial<BookmarkNode>): BookmarkNode => ({
+  id: bookmark?.id ?? createBookmarkId(),
+  title: bookmark?.title ?? '',
+  pageNumber: bookmark?.pageNumber ?? 1,
+  children: bookmark?.children ? bookmark.children.map(child => createBookmarkNode(child)) : [],
+  expanded: bookmark?.expanded ?? true,
+});
+
+export const hydrateBookmarkPayload = (payload: BookmarkPayload[] = []): BookmarkNode[] => {
+  return payload.map(item => ({
+    id: createBookmarkId(),
+    title: item.title ?? '',
+    pageNumber: typeof item.pageNumber === 'number' && item.pageNumber > 0 ? item.pageNumber : 1,
+    expanded: true,
+    children: item.children ? hydrateBookmarkPayload(item.children) : [],
+  }));
+};
+
+export const serializeBookmarkNodes = (bookmarks: BookmarkNode[]): BookmarkPayload[] => {
+  return bookmarks.map(bookmark => ({
+    title: bookmark.title,
+    pageNumber: bookmark.pageNumber,
+    children: serializeBookmarkNodes(bookmark.children),
+  }));
+};

frontend/src/core/utils/localSettingsEvents.ts

@@ -1,46 +0,0 @@
-export const LOCAL_SETTINGS_EVENT = 'stirlingpdf:local-settings-changed';
-
-export type LocalSettingsEventOrigin = 'local' | 'remote';
-
-export interface LocalSettingsEventDetail {
-  keys: string[];
-  origin: LocalSettingsEventOrigin;
-}
-
-export function emitLocalSettingsEvent(keys: string[], origin: LocalSettingsEventOrigin) {
-  if (typeof window === 'undefined') {
-    return;
-  }
-
-  const uniqueKeys = Array.from(new Set(keys)).filter(Boolean);
-  if (uniqueKeys.length === 0) {
-    return;
-  }
-
-  const event = new CustomEvent<LocalSettingsEventDetail>(LOCAL_SETTINGS_EVENT, {
-    detail: {
-      keys: uniqueKeys,
-      origin,
-    },
-  });
-
-  window.dispatchEvent(event);
-}
-
-export function addLocalSettingsListener(
-  listener: (detail: LocalSettingsEventDetail) => void
-): () => void {
-  if (typeof window === 'undefined') {
-    return () => {};
-  }
-
-  const handler = (event: Event) => {
-    const customEvent = event as CustomEvent<LocalSettingsEventDetail>;
-    if (customEvent?.detail) {
-      listener(customEvent.detail);
-    }
-  };
-
-  window.addEventListener(LOCAL_SETTINGS_EVENT, handler as EventListener);
-  return () => window.removeEventListener(LOCAL_SETTINGS_EVENT, handler as EventListener);
-}

frontend/src/core/utils/viewerZoom.ts

@@ -1,6 +1,6 @@
 import { useEffect, useRef } from 'react';
 
-export const DEFAULT_VISIBILITY_THRESHOLD = 80; // Require at least 80% of the page height to be visible
+export const DEFAULT_VISIBILITY_THRESHOLD = 70; // Require at least 70% of the page height to be visible
 export const DEFAULT_FALLBACK_ZOOM = 1.44; // 144% fallback when no reliable metadata is present
 
 export interface ZoomViewport {
@@ -36,47 +36,33 @@ export function determineAutoZoom({
   visibilityThreshold = DEFAULT_VISIBILITY_THRESHOLD,
   fallbackZoom = DEFAULT_FALLBACK_ZOOM,
 }: AutoZoomParams): AutoZoomDecision {
+  // Get aspect ratio from pageRect or metadata
   const rectWidth = pageRect?.width ?? 0;
   const rectHeight = pageRect?.height ?? 0;
-
   const aspectRatio: number | null =
     rectWidth > 0 ? rectHeight / rectWidth : metadataAspectRatio ?? null;
 
-  let renderedHeight: number | null = rectHeight > 0 ? rectHeight : null;
-
-  if (!renderedHeight || renderedHeight <= 0) {
-    if (aspectRatio == null || aspectRatio <= 0) {
-      return { type: 'fallback', zoom: Math.min(fitWidthZoom, fallbackZoom) };
-    }
-
-    const pageWidth = viewportWidth / (fitWidthZoom * pagesPerSpread);
-    const pageHeight = pageWidth * aspectRatio;
-    renderedHeight = pageHeight * fitWidthZoom;
+  // Need aspect ratio to proceed
+  if (!aspectRatio || aspectRatio <= 0) {
+    return { type: 'fallback', zoom: Math.min(fitWidthZoom, fallbackZoom) };
   }
 
-  if (!renderedHeight || renderedHeight <= 0) {
-    return { type: 'fitWidth' };
-  }
-
-  const isLandscape = aspectRatio !== null && aspectRatio < 1;
+  // Landscape pages need 100% visibility, portrait need the specified threshold
+  const isLandscape = aspectRatio < 1;
   const targetVisibility = isLandscape ? 100 : visibilityThreshold;
 
-  const visiblePercent = (viewportHeight / renderedHeight) * 100;
+  // Calculate zoom level that shows targetVisibility% of page height
+  const pageHeightAtFitWidth = (viewportWidth / pagesPerSpread) * aspectRatio;
+  const heightBasedZoom = fitWidthZoom * (viewportHeight / pageHeightAtFitWidth) / (targetVisibility / 100);
 
-  if (visiblePercent >= targetVisibility) {
+  // Use whichever zoom is smaller (more zoomed out) to satisfy both width and height constraints
+  if (heightBasedZoom < fitWidthZoom) {
+    // Need to zoom out from fitWidth to show enough height
+    return { type: 'adjust', zoom: heightBasedZoom };
+  } else {
+    // fitWidth already shows enough
     return { type: 'fitWidth' };
   }
-
-  const allowableHeightRatio = targetVisibility / 100;
-  const zoomScale =
-    viewportHeight / (allowableHeightRatio * renderedHeight);
-  const targetZoom = Math.min(fitWidthZoom, fitWidthZoom * zoomScale);
-
-  if (Math.abs(targetZoom - fitWidthZoom) < 0.001) {
-    return { type: 'fitWidth' };
-  }
-
-  return { type: 'adjust', zoom: targetZoom };
 }
 
 export interface MeasurePageRectOptions {

frontend/src/desktop/components/AppProviders.tsx

@@ -1,6 +1,7 @@
 import { ReactNode } from "react";
 import { AppProviders as ProprietaryAppProviders } from "@proprietary/components/AppProviders";
 import { DesktopConfigSync } from '@app/components/DesktopConfigSync';
+import { DesktopBannerInitializer } from '@app/components/DesktopBannerInitializer';
 import { DESKTOP_DEFAULT_APP_CONFIG } from '@app/config/defaultAppConfig';
 
 /**
@@ -22,6 +23,7 @@ export function AppProviders({ children }: { children: ReactNode }) {
       }}
     >
       <DesktopConfigSync />
+      <DesktopBannerInitializer />
       {children}
     </ProprietaryAppProviders>
   );

frontend/src/desktop/components/DesktopBannerInitializer.tsx

@@ -0,0 +1,13 @@
+import { useEffect } from 'react';
+import { useBanner } from '@app/contexts/BannerContext';
+import { DefaultAppBanner } from '@app/components/shared/DefaultAppBanner';
+
+export function DesktopBannerInitializer() {
+  const { setBanner } = useBanner();
+
+  useEffect(() => {
+    setBanner(<DefaultAppBanner />);
+  }, [setBanner]);
+
+  return null;
+}

frontend/src/desktop/components/shared/DefaultAppBanner.tsx

@@ -0,0 +1,27 @@
+import React, { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { InfoBanner } from '@app/components/shared/InfoBanner';
+import { useDefaultApp } from '@app/hooks/useDefaultApp';
+
+export const DefaultAppBanner: React.FC = () => {
+  const { t } = useTranslation();
+  const { isDefault, isLoading, handleSetDefault } = useDefaultApp();
+  const [dismissed, setDismissed] = useState(false);
+
+  const handleDismissPrompt = () => {
+    setDismissed(true);
+  };
+
+  return (
+    <InfoBanner
+      icon="picture-as-pdf-rounded"
+      message={t('defaultApp.prompt.message', 'Make Stirling PDF your default application for opening PDF files.')}
+      buttonText={t('defaultApp.setDefault', 'Set Default')}
+      buttonIcon="check-circle-rounded"
+      onButtonClick={handleSetDefault}
+      onDismiss={handleDismissPrompt}
+      loading={isLoading}
+      show={!dismissed && isDefault === false}
+    />
+  );
+};

frontend/src/desktop/components/shared/config/configSections/DefaultAppSettings.tsx

@@ -0,0 +1,40 @@
+import React from 'react';
+import { Paper, Text, Button, Group } from '@mantine/core';
+import { useTranslation } from 'react-i18next';
+import { useDefaultApp } from '@app/hooks/useDefaultApp';
+
+export const DefaultAppSettings: React.FC = () => {
+  const { t } = useTranslation();
+  const { isDefault, isLoading, handleSetDefault } = useDefaultApp();
+
+  return (
+    <Paper withBorder p="md" radius="md">
+      <Group justify="space-between" align="center">
+        <div>
+          <Text fw={500} size="sm">
+            {t('settings.general.defaultPdfEditor', 'Default PDF editor')}
+          </Text>
+          <Text size="xs" c="dimmed" mt={4}>
+            {isDefault === true
+              ? t('settings.general.defaultPdfEditorActive', 'Stirling PDF is your default PDF editor')
+              : isDefault === false
+              ? t('settings.general.defaultPdfEditorInactive', 'Another application is set as default')
+              : t('settings.general.defaultPdfEditorChecking', 'Checking...')}
+          </Text>
+        </div>
+        <Button
+          variant={isDefault ? 'light' : 'filled'}
+          color="blue"
+          size="sm"
+          onClick={handleSetDefault}
+          loading={isLoading}
+          disabled={isDefault === true}
+        >
+          {isDefault
+            ? t('settings.general.defaultPdfEditorSet', 'Already Default')
+            : t('settings.general.setAsDefault', 'Set as Default')}
+        </Button>
+      </Group>
+    </Paper>
+  );
+};

frontend/src/desktop/components/shared/config/configSections/GeneralSection.tsx

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Stack } from '@mantine/core';
+import CoreGeneralSection from '@core/components/shared/config/configSections/GeneralSection';
+import { DefaultAppSettings } from '@app/components/shared/config/configSections/DefaultAppSettings';
+
+/**
+ * Desktop extension of GeneralSection that adds default PDF editor settings
+ */
+const GeneralSection: React.FC = () => {
+  return (
+    <Stack gap="lg">
+      <DefaultAppSettings />
+      <CoreGeneralSection />
+    </Stack>
+  );
+};
+
+export default GeneralSection;

frontend/src/desktop/hooks/useAppInitialization.ts

@@ -1,4 +1,4 @@
-import { useEffect, useRef } from 'react';
+import { useEffect } from 'react';
 import { useBackendInitializer } from '@app/hooks/useBackendInitializer';
 import { useOpenedFile } from '@app/hooks/useOpenedFile';
 import { fileOpenService } from '@app/services/fileOpenService';
@@ -20,75 +20,42 @@ export function useAppInitialization(): void {
   // Handle files opened with app (Tauri mode)
   const { openedFilePaths, loading: openedFileLoading } = useOpenedFile();
 
-  // Track if we've already loaded the initial files to prevent duplicate loads
-  const initialFilesLoadedRef = useRef(false);
-
   // Load opened files and add directly to FileContext
   useEffect(() => {
-    if (openedFilePaths.length > 0 && !openedFileLoading && !initialFilesLoadedRef.current) {
-      initialFilesLoadedRef.current = true;
-
-      const loadOpenedFiles = async () => {
-        try {
-          const filesArray: File[] = [];
-
-          // Load all files in parallel
-          await Promise.all(
-            openedFilePaths.map(async (filePath) => {
-              try {
-                const fileData = await fileOpenService.readFileAsArrayBuffer(filePath);
-                if (fileData) {
-                  const file = new File([fileData.arrayBuffer], fileData.fileName, {
-                    type: 'application/pdf'
-                  });
-                  filesArray.push(file);
-                  console.log('[Desktop] Loaded file:', fileData.fileName);
-                }
-              } catch (error) {
-                console.error('[Desktop] Failed to load file:', filePath, error);
-              }
-            })
-          );
-
-          if (filesArray.length > 0) {
-            // Add all files to FileContext at once
-            await addFiles(filesArray);
-            console.log(`[Desktop] ${filesArray.length} opened file(s) added to FileContext`);
-          }
-        } catch (error) {
-          console.error('[Desktop] Failed to load opened files:', error);
-        }
-      };
-
-      loadOpenedFiles();
+    if (openedFilePaths.length === 0 || openedFileLoading) {
+      return;
     }
-  }, [openedFilePaths, openedFileLoading, addFiles]);
 
-  // Listen for runtime file-opened events (from second instances on Windows/Linux)
-  useEffect(() => {
-    const handleRuntimeFileOpen = async (filePath: string) => {
+    const loadOpenedFiles = async () => {
       try {
-        console.log('[Desktop] Runtime file-opened event received:', filePath);
-        const fileData = await fileOpenService.readFileAsArrayBuffer(filePath);
-        if (fileData) {
-          // Create a File object from the ArrayBuffer
-          const file = new File([fileData.arrayBuffer], fileData.fileName, {
-            type: 'application/pdf'
-          });
+        const filesArray: File[] = [];
 
-          // Add directly to FileContext
-          await addFiles([file]);
-          console.log('[Desktop] Runtime opened file added to FileContext:', fileData.fileName);
+        await Promise.all(
+          openedFilePaths.map(async (filePath) => {
+            try {
+              const fileData = await fileOpenService.readFileAsArrayBuffer(filePath);
+              if (fileData) {
+                const file = new File([fileData.arrayBuffer], fileData.fileName, {
+                  type: 'application/pdf'
+                });
+                filesArray.push(file);
+                console.log('[Desktop] Loaded file:', fileData.fileName);
+              }
+            } catch (error) {
+              console.error('[Desktop] Failed to load file:', filePath, error);
+            }
+          })
+        );
+
+        if (filesArray.length > 0) {
+          await addFiles(filesArray);
+          console.log(`[Desktop] ${filesArray.length} opened file(s) added to FileContext`);
         }
       } catch (error) {
-        console.error('[Desktop] Failed to load runtime opened file:', error);
+        console.error('[Desktop] Failed to load opened files:', error);
       }
     };
 
-    // Set up event listener and get cleanup function
-    const unlisten = fileOpenService.onFileOpened(handleRuntimeFileOpen);
-
-    // Clean up listener on unmount
-    return unlisten;
-  }, [addFiles]);
+    loadOpenedFiles();
+  }, [openedFilePaths, openedFileLoading, addFiles]);
 }

frontend/src/desktop/hooks/useDefaultApp.ts

@@ -0,0 +1,61 @@
+import { useState, useEffect } from 'react';
+import { useTranslation } from 'react-i18next';
+import { defaultAppService } from '@app/services/defaultAppService';
+import { alert } from '@app/components/toast';
+
+export const useDefaultApp = () => {
+  const { t } = useTranslation();
+  const [isDefault, setIsDefault] = useState<boolean | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  useEffect(() => {
+    checkDefaultStatus();
+  }, []);
+
+  const checkDefaultStatus = async () => {
+    try {
+      const status = await defaultAppService.isDefaultPdfHandler();
+      setIsDefault(status);
+    } catch (error) {
+      console.error('Failed to check default status:', error);
+    }
+  };
+
+  const handleSetDefault = async () => {
+    setIsLoading(true);
+    try {
+      const result = await defaultAppService.setAsDefaultPdfHandler();
+
+      if (result === 'set_successfully') {
+        alert({
+          alertType: 'success',
+          title: t('defaultApp.success.title', 'Default App Set'),
+          body: t('defaultApp.success.message', 'Stirling PDF is now your default PDF editor'),
+        });
+        setIsDefault(true);
+      } else if (result === 'opened_settings') {
+        alert({
+          alertType: 'neutral',
+          title: t('defaultApp.settingsOpened.title', 'Settings Opened'),
+          body: t('defaultApp.settingsOpened.message', 'Please select Stirling PDF in your system settings'),
+        });
+      }
+    } catch (error) {
+      console.error('Failed to set default:', error);
+      alert({
+        alertType: 'error',
+        title: t('defaultApp.error.title', 'Error'),
+        body: t('defaultApp.error.message', 'Failed to set default PDF handler'),
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  return {
+    isDefault,
+    isLoading,
+    checkDefaultStatus,
+    handleSetDefault,
+  };
+};

frontend/src/desktop/hooks/useOpenedFile.ts

@@ -1,45 +1,46 @@
 import { useState, useEffect } from 'react';
 import { fileOpenService } from '@app/services/fileOpenService';
+import { listen } from '@tauri-apps/api/event';
 
 export function useOpenedFile() {
   const [openedFilePaths, setOpenedFilePaths] = useState<string[]>([]);
   const [loading, setLoading] = useState(true);
 
   useEffect(() => {
-    const checkForOpenedFile = async () => {
-      console.log('🔍 Checking for opened file(s)...');
+    // Function to read and process files from storage
+    const readFilesFromStorage = async () => {
+      console.log('🔍 Reading files from storage...');
       try {
         const filePaths = await fileOpenService.getOpenedFiles();
         console.log('🔍 fileOpenService.getOpenedFiles() returned:', filePaths);
 
         if (filePaths.length > 0) {
-          console.log(`✅ App opened with ${filePaths.length} file(s):`, filePaths);
+          console.log(`✅ Found ${filePaths.length} file(s) in storage:`, filePaths);
           setOpenedFilePaths(filePaths);
-
-          // Clear the files from service state after consuming them
           await fileOpenService.clearOpenedFiles();
-        } else {
-          console.log('ℹ️ No files were opened with the app');
         }
-
       } catch (error) {
-        console.error('❌ Failed to check for opened files:', error);
+        console.error('❌ Failed to read files from storage:', error);
       } finally {
         setLoading(false);
       }
     };
 
-    checkForOpenedFile();
+    // Read files on mount
+    readFilesFromStorage();
 
-    // Listen for runtime file open events (abstracted through service)
-    const unlistenRuntimeEvents = fileOpenService.onFileOpened((filePath: string) => {
-      console.log('📂 Runtime file open event:', filePath);
-      setOpenedFilePaths(prev => [...prev, filePath]);
+    // Listen for files-changed events (when new files are added to storage)
+    let unlisten: (() => void) | undefined;
+    listen('files-changed', async () => {
+      console.log('📂 files-changed event received, re-reading storage...');
+      await readFilesFromStorage();
+    }).then(unlistenFn => {
+      unlisten = unlistenFn;
     });
 
     // Cleanup function
     return () => {
-      unlistenRuntimeEvents();
+      if (unlisten) unlisten();
     };
   }, []);
 

frontend/src/desktop/services/defaultAppService.ts

@@ -0,0 +1,70 @@
+import { invoke } from '@tauri-apps/api/core';
+
+/**
+ * Service for managing default PDF handler settings
+ * Note: Uses localStorage for machine-specific preferences (not synced to server)
+ */
+export const defaultAppService = {
+  /**
+   * Check if Stirling PDF is the default PDF handler
+   */
+  async isDefaultPdfHandler(): Promise<boolean> {
+    try {
+      const result = await invoke<boolean>('is_default_pdf_handler');
+      return result;
+    } catch (error) {
+      console.error('[DefaultApp] Failed to check default handler:', error);
+      return false;
+    }
+  },
+
+  /**
+   * Set or prompt to set Stirling PDF as default PDF handler
+   * Returns a status string indicating what happened
+   */
+  async setAsDefaultPdfHandler(): Promise<'set_successfully' | 'opened_settings' | 'error'> {
+    try {
+      const result = await invoke<string>('set_as_default_pdf_handler');
+      return result as 'set_successfully' | 'opened_settings';
+    } catch (error) {
+      console.error('[DefaultApp] Failed to set default handler:', error);
+      return 'error';
+    }
+  },
+
+  /**
+   * Check if user has dismissed the default app prompt (machine-specific)
+   */
+  hasUserDismissedPrompt(): boolean {
+    try {
+      const dismissed = localStorage.getItem('stirlingpdf_default_app_prompt_dismissed');
+      return dismissed === 'true';
+    } catch {
+      return false;
+    }
+  },
+
+  /**
+   * Mark that user has dismissed the default app prompt (machine-specific)
+   */
+  setPromptDismissed(dismissed: boolean): void {
+    try {
+      localStorage.setItem('stirlingpdf_default_app_prompt_dismissed', dismissed ? 'true' : 'false');
+    } catch (error) {
+      console.error('[DefaultApp] Failed to save prompt preference:', error);
+    }
+  },
+
+  /**
+   * Check if we should show the default app prompt
+   * Returns true if: user hasn't dismissed it AND app is not default handler
+   */
+  async shouldShowPrompt(): Promise<boolean> {
+    if (this.hasUserDismissedPrompt()) {
+      return false;
+    }
+
+    const isDefault = await this.isDefaultPdfHandler();
+    return !isDefault;
+  },
+};

frontend/src/proprietary/App.tsx

@@ -1,6 +1,7 @@
 import { Suspense } from "react";
 import { Routes, Route } from "react-router-dom";
 import { AppProviders } from "@app/components/AppProviders";
+import { AppLayout } from "@app/components/AppLayout";
 import { LoadingFallback } from "@app/components/shared/LoadingFallback";
 import Landing from "@app/routes/Landing";
 import Login from "@app/routes/Login";
@@ -22,17 +23,19 @@ export default function App() {
   return (
     <Suspense fallback={<LoadingFallback />}>
       <AppProviders>
-        <Routes>
-          {/* Auth routes - no nested providers needed */}
-          <Route path="/login" element={<Login />} />
-          <Route path="/signup" element={<Signup />} />
-          <Route path="/auth/callback" element={<AuthCallback />} />
-          <Route path="/invite/:token" element={<InviteAccept />} />
+        <AppLayout>
+          <Routes>
+            {/* Auth routes - no nested providers needed */}
+            <Route path="/login" element={<Login />} />
+            <Route path="/signup" element={<Signup />} />
+            <Route path="/auth/callback" element={<AuthCallback />} />
+            <Route path="/invite/:token" element={<InviteAccept />} />
 
-          {/* Main app routes - Landing handles auth logic */}
-          <Route path="/*" element={<Landing />} />
-        </Routes>
-        <OnboardingTour />
+            {/* Main app routes - Landing handles auth logic */}
+            <Route path="/*" element={<Landing />} />
+          </Routes>
+          <OnboardingTour />
+        </AppLayout>
       </AppProviders>
     </Suspense>
   );

frontend/src/proprietary/auth/springAuthClient.ts

@@ -107,7 +107,7 @@ class SpringAuthClient {
     for (const cookie of cookies) {
       const [name, value] = cookie.trim().split('=');
       if (name === 'XSRF-TOKEN') {
-        return value;
+        return decodeURIComponent(value);
       }
     }
     return null;
@@ -278,7 +278,7 @@ class SpringAuthClient {
     try {
       const response = await apiClient.post('/api/v1/auth/logout', null, {
         headers: {
-          'X-CSRF-TOKEN': this.getCsrfToken() || '',
+          'X-XSRF-TOKEN': this.getCsrfToken() || '',
         },
         withCredentials: true,
       });
@@ -311,7 +311,7 @@ class SpringAuthClient {
     try {
       const response = await apiClient.post('/api/v1/auth/refresh', null, {
         headers: {
-          'X-CSRF-TOKEN': this.getCsrfToken() || '',
+          'X-XSRF-TOKEN': this.getCsrfToken() || '',
         },
         withCredentials: true,
       });

frontend/src/proprietary/components/AppProviders.tsx

@@ -1,6 +1,5 @@
 import { AppProviders as CoreAppProviders, AppProvidersProps } from "@core/components/AppProviders";
 import { AuthProvider } from "@app/auth/UseSession";
-import { UserSettingsSyncProvider } from "@app/components/UserSettingsSyncProvider";
 
 export function AppProviders({ children, appConfigRetryOptions, appConfigProviderProps }: AppProvidersProps) {
   return (
@@ -9,9 +8,7 @@ export function AppProviders({ children, appConfigRetryOptions, appConfigProvide
       appConfigProviderProps={appConfigProviderProps}
     >
       <AuthProvider>
-        <UserSettingsSyncProvider>
-          {children}
-        </UserSettingsSyncProvider>
+        {children}
       </AuthProvider>
     </CoreAppProviders>
   );

frontend/src/proprietary/components/UserSettingsSyncProvider.tsx

@@ -1,11 +0,0 @@
-import { ReactNode } from 'react';
-import { useUserSettingsSync } from '@app/hooks/useUserSettingsSync';
-
-interface Props {
-  children: ReactNode;
-}
-
-export function UserSettingsSyncProvider({ children }: Props) {
-  useUserSettingsSync();
-  return <>{children}</>;
-}