queue updates when offline

main.lua

···
 	self.refresh_token = self.settings:readSetting("refresh_token")
 	self.did = self.settings:readSetting("did")
 	self.document_mappings = self.settings:readSetting("document_mappings") or {}
+	self.offline_queue = self.settings:readSetting("offline_queue") or {}
 	self.auto_sync_enabled = self.settings:readSetting("auto_sync_enabled")
 	if self.auto_sync_enabled == nil then
 		self.auto_sync_enabled = false -- Default OFF for safety
···
 	-- Validate session at startup if we have credentials
 	if self:isAuthenticated() then
 		self:validateSessionAtStartup()
+
+		-- Try to flush any queued syncs from previous sessions
+		self:flushOfflineQueue()
 	end
 end
 
···
 	self.settings:saveSetting("refresh_token", self.refresh_token)
 	self.settings:saveSetting("did", self.did)
 	self.settings:saveSetting("document_mappings", self.document_mappings)
+	self.settings:saveSetting("offline_queue", self.offline_queue)
 	self.settings:saveSetting("auto_sync_enabled", self.auto_sync_enabled)
 	self.settings:flush()
 end
···
 			{
 				text_func = function()
 					local doc_path = self:getCurrentDocumentPath()
+
+					-- Check if there's a queued sync for this document
+					if doc_path and self.offline_queue[doc_path] then
+						local queued = self.offline_queue[doc_path]
+						return T(_("Last synced: Queued - offline (%1%)"), queued.percent)
+					end
+
 					if
 						doc_path
 						and self.document_mappings[doc_path]
···
 		return
 	end
 
-	local mapping = self.document_mappings[doc_path]
+	-- Cancel any pending auto-sync for current document (manual sync takes priority)
+	if self.auto_sync_task then
+		UIManager:unschedule(self.auto_sync_task)
+		self.auto_sync_task = nil
+	end
 
 	-- Get document statistics
 	local pages = self.ui.document:getPageCount()
···
 	end
 	local percent = math.floor((current_page / pages) * 100)
 
+	-- Try to sync
+	local success = self:attemptSync(doc_path, percent, current_page, pages)
+
+	if success then
+		-- Show success notification (silent for auto-sync)
+		if not use_notification then
+			-- Use InfoMessage for manual sync and document close
+			UIManager:show(InfoMessage:new({
+				text = T(_("Synced: %1% (%2/%3)"), percent, current_page, pages),
+				timeout = 2,
+			}))
+		end
+
+		-- On success, try to flush any queued syncs
+		self:flushOfflineQueue()
+	else
+		-- Queue this sync for later (silent)
+		self:queueOfflineSync(doc_path, percent, current_page, pages)
+	end
+end
+
+-- Helper function to detect network errors
+function Paperbnd:isNetworkError(error_msg)
+	if not error_msg then
+		return false
+	end
+	local error_lower = string.lower(error_msg)
+	return string.find(error_lower, "connection") ~= nil
+		or string.find(error_lower, "timeout") ~= nil
+		or string.find(error_lower, "unreachable") ~= nil
+		or string.find(error_lower, "network") ~= nil
+		or string.find(error_lower, "no address associated") ~= nil
+end
+
+-- Attempt to sync progress, returns true on success, false on network error
+function Paperbnd:attemptSync(doc_path, percent, current_page, pages)
+	local mapping = self.document_mappings[doc_path]
+	if not mapping then
+		return false
+	end
+
 	-- Fetch current record
 	local record_response, err = self.xrpc:getRecord(self.did, "social.popfeed.feed.listItem", mapping.rkey)
 
 	if err then
-		UIManager:show(InfoMessage:new({
-			text = T(_("Failed to fetch record: %1"), err),
-		}))
-		return
+		if self:isNetworkError(err) then
+			-- Network error - return false to trigger queuing
+			return false
+		else
+			-- Other error (auth, data, etc.) - show error and return false
+			UIManager:show(InfoMessage:new({
+				text = T(_("Failed to fetch record: %1"), err),
+			}))
+			return false
+		end
 	end
 
 	local record = record_response.value
···
 		updatedAt = os.date("!%Y-%m-%dT%H:%M:%S.000Z"),
 	}
 
-	-- If not already in currently_reading, update listType
-	-- if record.listType ~= "currently_reading_books" then
-	--     record.listType = "currently_reading_books"
-	-- TODO: Also update the listUri to point to currently_reading list
-	-- end
-
 	-- Put updated record
 	local _res, put_err = self.xrpc:putRecord(self.did, "social.popfeed.feed.listItem", mapping.rkey, record)
 
 	if put_err then
-		UIManager:show(InfoMessage:new({
-			text = T(_("Failed to sync progress: %1"), put_err),
-		}))
-		return
+		if self:isNetworkError(put_err) then
+			-- Network error - return false to trigger queuing
+			return false
+		else
+			-- Other error - show error and return false
+			UIManager:show(InfoMessage:new({
+				text = T(_("Failed to sync progress: %1"), put_err),
+			}))
+			return false
+		end
 	end
 
-	-- Record last sync info for status display (per-document)
+	-- Success! Update last sync info
 	self.document_mappings[doc_path].last_sync_time = os.time()
 	self.document_mappings[doc_path].last_sync_percent = percent
 	self:saveSettings()
 
-	-- Show success notification (silent for auto-sync)
-	if not use_notification then
-		-- Use InfoMessage for manual sync and document close
+	return true
+end
+
+-- Queue a sync for offline processing
+function Paperbnd:queueOfflineSync(doc_path, percent, current_page, pages)
+	local mapping = self.document_mappings[doc_path]
+	if not mapping then
+		return
+	end
+
+	-- Cancel any pending auto-sync (this queued sync is newer)
+	if self.auto_sync_task then
+		UIManager:unschedule(self.auto_sync_task)
+		self.auto_sync_task = nil
+	end
+
+	-- Store or update queue entry (latest only per document)
+	self.offline_queue[doc_path] = {
+		percent = percent,
+		current_page = current_page,
+		total_pages = pages,
+		timestamp = os.time(),
+		rkey = mapping.rkey,
+		title = mapping.title,
+		author = mapping.author,
+	}
+
+	self:saveSettings()
+end
+
+-- Flush all queued syncs (called after successful sync)
+function Paperbnd:flushOfflineQueue()
+	if not self:isAuthenticated() then
+		return
+	end
+
+	local queue_count = 0
+	for _ in pairs(self.offline_queue) do
+		queue_count = queue_count + 1
+	end
+
+	if queue_count == 0 then
+		return
+	end
+
+	local flushed_count = 0
+	local failed_paths = {}
+	local current_doc_path = self:getCurrentDocumentPath()
+
+	-- Try to sync each queued item
+	for doc_path, queue_entry in pairs(self.offline_queue) do
+		local percent, current_page, pages
+
+		-- If this is the current document, use latest progress instead of queued
+		if doc_path == current_doc_path and self.ui.document then
+			pages = self.ui.document:getPageCount()
+			if self.ui.paging then
+				current_page = self.ui.paging.current_page
+			elseif self.ui.rolling then
+				current_page = self.ui.rolling.current_page
+			else
+				current_page = 1
+			end
+			percent = math.floor((current_page / pages) * 100)
+		else
+			-- Use queued progress for other documents
+			percent = queue_entry.percent
+			current_page = queue_entry.current_page
+			pages = queue_entry.total_pages
+		end
+
+		local success = self:attemptSync(doc_path, percent, current_page, pages)
+		if success then
+			-- Remove from queue on success
+			self.offline_queue[doc_path] = nil
+			flushed_count = flushed_count + 1
+		else
+			-- Keep in queue on failure
+			table.insert(failed_paths, doc_path)
+		end
+	end
+
+	-- Save updated queue
+	if flushed_count > 0 then
+		self:saveSettings()
+
+		-- Show notification for flushed syncs
 		UIManager:show(InfoMessage:new({
-			text = T(_("Synced: %1% (%2/%3)"), percent, current_page, pages),
+			text = T(_("Flushed %1 queued sync(s)"), flushed_count),
 			timeout = 2,
 		}))
 	end
-	-- Auto-sync is completely silent (use_notification = true)
 end
 
 function Paperbnd:scheduleDebouncedSync(pageno)