@papyrus-sdk/ui-react-native 0.2.35-beta.8 → 0.2.35

package/runtime/runtime.js

@@ -109,6 +109,191 @@
 /* @papyrus-comic-runtime:end */
 
 (function () {
+/* @papyrus-epub-reader:start */
+(function(root){
+  function mode(value){return value==='chapter-scroll'?'chapter-scroll':'paged';}
+  function validCfi(value){return typeof value==='string' && value.length<=4096 && /^epubcfi\([^\n<>]+\)$/.test(value);}
+  function options(value){return {manager:'default',flow:mode(value)==='paged'?'paginated':'scrolled-doc',spread:'none',width:'100%',height:'100%',allowScriptedContent:false};}
+  function gesture(start,end,state){
+    if(!start || !end || state.selected || state.interactive || state.multitouch)return null;
+    var dx=end.x-start.x,dy=end.y-start.y,elapsed=end.time-start.time;
+    if(state.mode==='paged' && Math.abs(dx)>=48 && Math.abs(dx)>Math.abs(dy)*1.5 && elapsed>=0 && elapsed<1500)return (dx<0)!==Boolean(state.rtl)?'next':'prev';
+    if(elapsed>=0 && elapsed<450 && Math.hypot(dx,dy)<=12)return 'tap';
+    return null;
+  }
+  function location(raw,count,readingMode,geometry){
+    var start=raw && raw.start;if(!start || !validCfi(start.cfi))return null;
+    var displayed=start.displayed||{},chapter=Math.max(1,(Number(start.index)||0)+1);
+    var visualPage=mode(readingMode)==='paged' && Number.isFinite(displayed.page)?displayed.page:null;
+    var total=mode(readingMode)==='paged' && Number.isFinite(displayed.total)?displayed.total:null;
+    var atStart=Boolean(raw.atStart),atEnd=Boolean(raw.atEnd);
+    // Chromium may round a column offset down by a fraction of a CSS pixel.
+    // Keep epub.js authoritative outside a 1px boundary, and for RTL layouts.
+    if(visualPage!==null && total>0 && geometry && geometry.direction==='ltr' && geometry.pageWidth>0 && Number.isFinite(geometry.offset)){
+      var boundary=Math.round(geometry.offset/geometry.pageWidth);
+      if(Math.abs(geometry.offset-boundary*geometry.pageWidth)<=1){
+        visualPage=Math.min(total,Math.max(1,boundary+1));
+        atStart=chapter===(geometry.firstIndex ?? 0)+1 && visualPage===1;
+        atEnd=chapter===(geometry.lastIndex ?? count-1)+1 && visualPage===total;
+      }
+    }
+    var fraction=total?Math.max(0,(visualPage-1)/total):0;
+    return {version:1,cfi:start.cfi,href:start.href||'',chapter:chapter,chapterCount:count,visualPage:visualPage,visualPageCount:total,progress:Math.min(1,Math.max(0,(chapter-1+fraction)/Math.max(1,count))),mode:mode(readingMode),atStart:atStart,atEnd:atEnd};
+  }
+  function installResizeAnchor(manager,readCfi){
+    var original=manager.resize,anchor=null;
+    function resize(width,height,target){
+      if(validCfi(target))anchor=target;
+      if(!anchor){var current=readCfi();if(validCfi(current))anchor=current;}
+      // epub.js accepts a logical target as its third argument. Keep it across
+      // keyboard/dialog reflows instead of adopting each new viewport start.
+      return original.call(this,width,height,anchor || target);
+    }
+    manager.resize=resize;
+    return {cfi:function(){return anchor;},invalidate:function(){anchor=null;},destroy:function(){if(manager.resize===resize)manager.resize=original;anchor=null;}};
+  }
+  function install(contents,config){
+    var doc=contents.document,win=contents.window,start=null,blocked=false;
+    function point(e){var t=e.changedTouches&&e.changedTouches[0]||e.touches&&e.touches[0];return t?{x:t.clientX,y:t.clientY,time:Date.now()}:null;}
+    function selected(){return Boolean(String(win.getSelection()||'').trim()) || config.blocked();}
+    function interactive(target){return Boolean(target && target.closest && target.closest('a,button,input,textarea,select,[contenteditable="true"],[data-papyrus-overlay]'));}
+    function begin(e){start=point(e);blocked=e.touches.length!==1 || selected() || interactive(e.target);}
+    function invalidateScroll(finish){if(config.current() && start && finish && config.mode()==='chapter-scroll' && !blocked && !selected() && Math.abs(finish.y-start.y)>12 && Math.abs(finish.y-start.y)>Math.abs(finish.x-start.x) && config.interact)config.interact();}
+    function move(e){if(e.touches.length!==1)blocked=true;invalidateScroll(point(e));}
+    function end(e){var finish=point(e);invalidateScroll(finish);var action=gesture(start,finish,{mode:config.mode(),rtl:config.rtl(),selected:selected(),interactive:blocked||interactive(e.target)||Boolean(config.annotationHit && config.annotationHit(point(e))),multitouch:blocked});start=null;if(!config.current())return;if(action==='tap')config.tap();else if(action)config.turn(action==='next'?1:-1);}
+    function cancel(){start=null;blocked=true;}
+    function link(e){if(config.current() && e.target?.closest?.('a') && config.interact)config.interact();}
+    doc.addEventListener('touchstart',begin,{passive:true});doc.addEventListener('touchmove',move,{passive:true});doc.addEventListener('touchend',end,{passive:true});doc.addEventListener('touchcancel',cancel,{passive:true});doc.addEventListener('click',link);
+    return function(){doc.removeEventListener('touchstart',begin);doc.removeEventListener('touchmove',move);doc.removeEventListener('touchend',end);doc.removeEventListener('touchcancel',cancel);doc.removeEventListener('click',link);};
+  }
+  root.PapyrusEpubReader={mode:mode,validCfi:validCfi,options:options,gesture:gesture,location:location,installResizeAnchor:installResizeAnchor,install:install};
+})(typeof window==='undefined'?globalThis:window);
+
+/* @papyrus-epub-reader:end */
+/* @papyrus-epub-annotations:start */
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.PapyrusEpubAnnotations = factory();
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  function validAnchor(anchor) {
+    return anchor && anchor.version === 1 && anchor.kind === 'epub-cfi' &&
+      typeof anchor.cfiRange === 'string' && anchor.cfiRange.length <= 4096 && /^epubcfi\([^\n<>]+\)$/.test(anchor.cfiRange) &&
+      typeof anchor.href === 'string' && !/^(javascript|data):/i.test(anchor.href) &&
+      typeof anchor.quote === 'string' && anchor.quote.length > 0 && anchor.quote.length <= 100000;
+  }
+  function textNodes(document) {
+    var walker = document.createTreeWalker(document.body, 4);
+    var nodes = [], text = '', node;
+    while ((node = walker.nextNode())) {
+      if (node.parentElement.closest('script,style,[data-papyrus-overlay]')) continue;
+      nodes.push({node:node, start:text.length}); text += node.textContent;
+    }
+    return {nodes:nodes,text:text};
+  }
+  function recoverRange(document, anchor) {
+    var source = textNodes(document), match = null, start = source.text.indexOf(anchor.quote);
+    while (start >= 0) {
+      var end = start + anchor.quote.length;
+      if ((!anchor.prefix || source.text.slice(Math.max(0,start-anchor.prefix.length),start) === anchor.prefix) &&
+          (!anchor.suffix || source.text.slice(end,end+anchor.suffix.length) === anchor.suffix)) {
+        if (match) return null; match = {start:start,end:end};
+      }
+      start = source.text.indexOf(anchor.quote,start+1);
+    }
+    if (!match) return null;
+    var range = document.createRange();
+    var first = source.nodes.find(function(n){return n.start+n.node.length > match.start;});
+    var last = source.nodes.find(function(n){return n.start+n.node.length >= match.end;});
+    if (!first || !last) return null;
+    range.setStart(first.node,match.start-first.start); range.setEnd(last.node,match.end-last.start);
+    return range;
+  }
+  function resolveRange(contents, anchor) {
+    if (!validAnchor(anchor)) return null;
+    try { var range = contents.range(anchor.cfiRange); if (range && range.toString() === anchor.quote) return range; } catch (_) {}
+    return recoverRange(contents.document,anchor);
+  }
+  function selection(contents, cfiRange, href, documentId) {
+    var range;
+    try { range = contents.range(cfiRange); } catch (_) { return null; }
+    if (!range || !range.toString()) return null;
+    var before = contents.document.createRange(); before.selectNodeContents(contents.document.body); before.setEnd(range.startContainer,range.startOffset);
+    var after = contents.document.createRange(); after.selectNodeContents(contents.document.body); after.setStart(range.endContainer,range.endOffset);
+    var anchor = {version:1,kind:'epub-cfi',cfiRange:cfiRange,href:href,spineIndex:contents.sectionIndex,documentId:documentId,quote:range.toString(),prefix:before.toString().slice(-48),suffix:after.toString().slice(0,48)};
+    return validAnchor(anchor) ? anchor : null;
+  }
+  function install(contents, options) {
+    var doc = contents.document, win = contents.window, alive = true, frame = 0;
+    var overlay = doc.createElement('div'); overlay.dataset.papyrusOverlay = 'annotations';
+    overlay.style.cssText = 'position:absolute;left:0;top:0;width:100%;height:0;pointer-events:none;z-index:3';
+    var originalPosition=doc.body.style.position;
+    if(win.getComputedStyle(doc.body).position==='static')doc.body.style.position='relative';
+    doc.body.appendChild(overlay);
+    var registry = new Map(), hitRegions = [];
+    function render() {
+      frame = 0; if (!alive || !options.isCurrent()) return;
+      var keep = new Set(), noteGroups = new Map();
+      hitRegions = [];
+      options.annotations().forEach(function(annotation) {
+        var anchor = annotation.anchor;
+        if (!validAnchor(anchor) || anchor.href !== options.href || anchor.documentId && options.documentId && anchor.documentId !== options.documentId) return;
+        var range = resolveRange(contents,anchor); if (!range) return;
+        var rects = Array.from(range.getClientRects()).filter(function(r){return r.width>0 && r.height>0;});
+        if (!rects.length) return;
+        keep.add(annotation.id);
+        var group = registry.get(annotation.id);
+        if (!group) { group = doc.createElement('div'); group.dataset.annotationId = annotation.id; overlay.appendChild(group); registry.set(annotation.id,group); if (!doc.defaultView.matchMedia || !doc.defaultView.matchMedia('(prefers-reduced-motion: reduce)').matches) { if (typeof group.animate === 'function') group.animate([{opacity:0},{opacity:1}],{duration:180,easing:'ease-out'}); } }
+        group.replaceChildren();
+        hitRegions.push({id:annotation.id,rects:rects});
+        var color = /^#[0-9a-f]{6}$/i.test(annotation.color) ? annotation.color : '#FFC928';
+        var style = annotation.markupStyle || annotation.type;
+        var opacity = Number.isFinite(annotation.opacity) ? Math.max(0,Math.min(1,annotation.opacity)) : 0.35;
+        if(style === 'highlight')opacity=Math.min(0.35,opacity);
+        rects.forEach(function(rect) {
+          var mark = doc.createElement('div');
+          var bodyRect=doc.body.getBoundingClientRect();
+          var height = style === 'highlight' ? rect.height : 2;
+          var y = style === 'strikeout' ? rect.top+rect.height/2 : style === 'underline' ? rect.bottom-2 : rect.top;
+          mark.style.cssText = 'position:absolute;pointer-events:none;left:'+(rect.left-bodyRect.left)+'px;top:'+(y-bodyRect.top)+'px;width:'+rect.width+'px;height:'+height+'px;background:'+color+';opacity:'+opacity;
+          if (['highlight','underline','strikeout'].includes(style)) group.appendChild(mark);
+        });
+        var hasNote = annotation.noteContent !== undefined || annotation.type === 'comment' || annotation.type === 'text';
+        if (hasNote) {
+          var last = rects[rects.length-1], button = doc.createElement('button');
+          button.textContent = '●'; button.setAttribute('aria-label',options.labels().comment || '');
+          var pageWidth=Math.max(44, options.pageWidth ? options.pageWidth() : win.innerWidth);
+          var bodyRect=doc.body.getBoundingClientRect(), column=Math.max(0,Math.floor((last.left-bodyRect.left)/pageWidth));
+          button.style.cssText = 'position:absolute;pointer-events:auto;border:0;background:transparent;color:'+color+';width:44px;height:44px;left:'+((column+1)*pageWidth-44)+'px;top:'+(Math.floor(last.top/44)*44-doc.body.getBoundingClientRect().top)+'px';
+          var key = column+":"+Math.floor(last.top/44);
+          var neighbors=noteGroups.get(key);
+          if(!neighbors){neighbors={button:button,ids:[]};noteGroups.set(key,neighbors);group.appendChild(button);}
+          neighbors.ids.push(annotation.id);
+        }
+      });
+      noteGroups.forEach(function(group){
+        group.button.textContent=group.ids.length>1?String(group.ids.length):'●';
+        group.button.addEventListener('click',function(e){e.stopPropagation();if(options.isCurrent())options.onTap(group.ids[0],group.ids);});
+      });
+      registry.forEach(function(group,id){if (!keep.has(id)) {group.remove();registry.delete(id);}});
+    }
+    function schedule() { if (alive && !frame) frame = win.requestAnimationFrame(render); }
+    function tapMarkup(event) {
+      if(!alive || !options.isCurrent() || String(win.getSelection() || '').length || event.target.closest('[data-papyrus-overlay]'))return;
+      var hit=hitRegions.find(function(item){return item.rects.some(function(r){return event.clientX>=r.left && event.clientX<=r.right && event.clientY>=r.top && event.clientY<=r.bottom;});});
+      if(hit) {event.stopPropagation();options.onTap(hit.id);}
+    }
+    doc.addEventListener('click',tapMarkup);
+    var observer = typeof win.ResizeObserver === 'function' ? new win.ResizeObserver(schedule) : null;
+    if (observer) observer.observe(doc.body);
+    win.addEventListener('resize',schedule);win.addEventListener('scroll',schedule); doc.addEventListener('load',schedule,true);
+    if (doc.fonts && doc.fonts.ready) doc.fonts.ready.then(schedule);
+    schedule();
+    return {schedule:schedule, hit:function(x,y){return hitRegions.some(function(item){return item.rects.some(function(r){return x>=r.left && x<=r.right && y>=r.top && y<=r.bottom;});});}, range:function(anchor){return resolveRange(contents,anchor);}, destroy:function(){alive=false;if(frame)win.cancelAnimationFrame(frame);if(observer)observer.disconnect();win.removeEventListener('resize',schedule);win.removeEventListener('scroll',schedule);doc.removeEventListener('load',schedule,true);doc.removeEventListener('click',tapMarkup);overlay.remove();doc.body.style.position=originalPosition;registry.clear();}};
+  }
+  return {validAnchor:validAnchor,recoverRange:recoverRange,resolveRange:resolveRange,selection:selection,install:install};
+});
+
+/* @papyrus-epub-annotations:end */
   const viewer = document.getElementById('viewer');
   const DEFAULT_FONT_SIZE = 16;
   const TEXT_PAGE_CHUNK = 1600;
@@ -116,6 +301,12 @@
   let currentType = null;
   let book = null;
   let rendition = null;
+  let epubResizeAnchor = null;
+  let documentSessionId = null;
+  let annotationDocumentId;
+  let annotationLabels = {};
+  let epubAnnotations = [];
+  const epubAnnotationRenderers = new Map();
   let spineItems = [];
   let textPages = [];
   let textContainer = null;
@@ -523,6 +714,9 @@
   };
 
   const clearViewer = () => {
+    if(epubResizeAnchor){epubResizeAnchor.destroy();epubResizeAnchor=null;}
+    epubAnnotationRenderers.forEach(renderer => renderer.destroy());
+    epubAnnotationRenderers.clear();
     if (epubInteractionCleanup) {
       epubInteractionCleanup();
       epubInteractionCleanup = null;
@@ -1177,21 +1371,65 @@
       pageCount,
     });
 
+    if (book.locations?.generate) {
+      const activeBook=book;
+      activeBook.locations.generate(150).then(() => {
+        if (isCurrentLoad() && activeBook===book && epubLocation) {
+          epubLocation.progress=activeBook.locations.percentageFromCfi(epubLocation.cfi);
+          sendEvent('EPUB_LOCATION',{documentSessionId,location:epubLocation});
+        }
+      }).catch(() => {});
+    }
+    return renderEpubRendition(loadId,generation,null);
+  };
+
+  const renderEpubRendition = async (loadId,generation,target) => {
+    const diagnosticPayload={loadId};
+    const isCurrentLoad=()=>generation===epubLoadGeneration;
+    if(epubInteractionCleanup)epubInteractionCleanup();
+    if(rendition)rendition.destroy();
     clearViewer();
-    rendition = book.renderTo(viewer, {
-      manager: 'continuous',
-      width: '100%',
-      height: '100%',
-      flow: 'scrolled-continuous',
-      spread: 'none',
-    });
+    rendition = book.renderTo(viewer, window.PapyrusEpubReader.options(epubViewMode === 'single' ? 'paged' : 'chapter-scroll'));
     sendEpubDiagnostic('epub.rendition.created', diagnosticPayload);
 
     if (rendition && rendition.hooks && rendition.hooks.content) {
+      const session = documentSessionId;
+      const activeRendition = rendition;
       rendition.hooks.content.register((contents) => {
+        const removeGestureListeners = window.PapyrusEpubReader.install(contents, {
+          mode: () => epubViewMode === 'single' ? 'paged' : 'chapter-scroll',
+          rtl: () => book.package?.metadata?.direction === 'rtl' || book.spine?.direction === 'rtl',
+          blocked: () => Boolean(nativeMenuSelection && String(nativeMenuSelection.contents?.window?.getSelection() || '').trim()),
+          annotationHit: point => epubAnnotationRenderers.get(contents)?.hit(point.x,point.y),
+          current: () => session === documentSessionId && activeRendition === rendition,
+          interact: () => epubResizeAnchor?.invalidate(),
+          tap: () => sendEvent('EPUB_CONTENT_TAP',{documentSessionId:session}),
+          turn: direction => {
+            epubNavigationQueue = epubNavigationQueue.catch(()=>{}).then(() => {
+              if(session !== documentSessionId || activeRendition !== rendition)return;
+              epubResizeAnchor?.invalidate();
+              return direction<0?activeRendition.prev():activeRendition.next();
+            });
+            epubNavigationQueue.catch(error => sendEvent('EPUB_NAVIGATION_ERROR',{message:String(error)}));
+          },
+        });
+        const gestureCleanup = () => {removeGestureListeners();epubSelectionCleanups.delete(gestureCleanup);};
+        epubSelectionCleanups.add(gestureCleanup);
+        contents.__papyrusGestureCleanup=gestureCleanup;
+        const href = spineItems[contents.sectionIndex]?.href;
+        if (href && window.PapyrusEpubAnnotations) {
+          const renderer = window.PapyrusEpubAnnotations.install(contents, {
+            href, get documentId() { return annotationDocumentId; },
+            isCurrent: () => session === documentSessionId && activeRendition === rendition,
+            pageWidth: () => activeRendition.layout?.width || viewer.clientWidth,
+            annotations: () => epubAnnotations, labels: () => annotationLabels,
+            onTap: (id, ids) => sendEvent("EPUB_ANNOTATION_TAP", {documentSessionId: session, id, ids}),
+          });
+          epubAnnotationRenderers.set(contents,renderer);
+        }
         const frame = contents && contents.document ? contents.document.defaultView.frameElement : null;
         if (frame) {
-          frame.setAttribute('sandbox', 'allow-scripts allow-same-origin');
+          frame.setAttribute('sandbox', 'allow-same-origin');
         }
         const selectionDocument = contents && contents.document;
         const selectionWindow = contents && contents.window;
@@ -1201,13 +1439,42 @@
           selectionWindow &&
           typeof selectionWindow.getSelection === 'function'
         ) {
+          let selectionTimer = null;
+
+          const reportSelection = () => {
+            selectionTimer = null;
+            if (session !== documentSessionId || activeRendition !== rendition) return;
+            const selected = selectionWindow.getSelection();
+            if (!selected || selected.isCollapsed || selected.rangeCount === 0 ||
+                typeof contents.cfiFromRange !== 'function') return;
+            const range = selected.getRangeAt(0).cloneRange();
+            if (!range.toString().trim()) return;
+            const href = spineItems[contents.sectionIndex]?.href;
+            if (!href) return;
+            let cfi;
+            try { cfi = contents.cfiFromRange(range); } catch (_) { return; }
+            const anchor = window.PapyrusEpubAnnotations?.selection(contents, cfi, href, annotationDocumentId);
+            if (!anchor) return;
+            if (nativeMenuSelection?.payload?.anchor?.cfiRange === anchor.cfiRange && nativeMenuSelection?.payload?.anchor?.quote === anchor.quote) return;
+            const payload = {documentSessionId: session, text: anchor.quote,
+              pageIndex: contents.sectionIndex + 1, anchor};
+            nativeMenuSelection = {contents, payload};
+            sendEvent('EPUB_TEXT_SELECTED', payload);
+          };
           const handleSelectionChange = () => {
             const selection = selectionWindow.getSelection();
             const text = selection ? selection.toString().trim() : '';
             epubScrollDiagnostics && epubScrollDiagnostics.setSelectionActive(Boolean(text));
+            if (selectionTimer !== null) clearTimeout(selectionTimer);
+            // epub.js "selected" is not reliable on every iOS WKWebView path.
+            // The content document still emits selectionchange, so resolve its
+            // live Range to a CFI before the native menu action can fire.
+            if (text) reportSelection();
+            else if (nativeMenuSelection?.contents === contents) nativeMenuSelection = null;
           };
           selectionDocument.addEventListener('selectionchange', handleSelectionChange);
           const selectionCleanup = () => {
+            if (selectionTimer !== null) clearTimeout(selectionTimer);
             selectionDocument.removeEventListener('selectionchange', handleSelectionChange);
             epubSelectionCleanups.delete(selectionCleanup);
           };
@@ -1226,29 +1493,53 @@
       typeof rendition.hooks.unloaded.register === 'function'
     ) {
       rendition.hooks.unloaded.register((view) => {
+        view?.contents?.__papyrusGestureCleanup?.();
         const cleanup = view && view.contents && view.contents.__papyrusSelectionCleanup;
         if (typeof cleanup === 'function') cleanup();
+        const renderer = epubAnnotationRenderers.get(view?.contents);
+        if (renderer) renderer.destroy();
+        epubAnnotationRenderers.delete(view?.contents);
       });
     }
 
     if (rendition && typeof rendition.on === 'function') {
+      const selectionSession = documentSessionId;
+      const selectionRendition = rendition;
       rendition.on('selected', (cfiRange, contents) => {
-        const selection = contents && contents.window ? contents.window.getSelection() : null;
-        const text = selection ? selection.toString().trim() : '';
-        epubScrollDiagnostics && epubScrollDiagnostics.setSelectionActive(Boolean(text));
-        if (text) {
-          sendEvent('TEXT_SELECTED', { text, pageIndex: Math.max(0, currentPage - 1) });
-        }
-        if (rendition && rendition.annotations && typeof rendition.annotations.remove === 'function') {
-          rendition.annotations.remove(cfiRange, 'highlight');
-        }
+        if (selectionSession !== documentSessionId || selectionRendition !== rendition) return;
+        const href = spineItems[contents.sectionIndex]?.href;
+        const anchor = href && window.PapyrusEpubAnnotations?.selection(contents,cfiRange,href,annotationDocumentId);
+        if (!anchor || nativeMenuSelection?.payload?.anchor?.cfiRange === anchor.cfiRange && nativeMenuSelection?.payload?.anchor?.quote === anchor.quote) return;
+        epubScrollDiagnostics && epubScrollDiagnostics.setSelectionActive(true);
+        const payload = {documentSessionId: selectionSession, text: anchor.quote, pageIndex: contents.sectionIndex+1, anchor};
+        nativeMenuSelection = {contents, payload};
+        sendEvent('EPUB_TEXT_SELECTED', payload);
       });
+      ['rendered','resized','layout','relocated'].forEach(name => rendition.on(name, () => {
+        if (selectionSession === documentSessionId && selectionRendition === rendition) epubAnnotationRenderers.forEach(renderer => renderer.schedule());
+      }));
       rendition.on('relocated', (location) => {
+        if (selectionSession !== documentSessionId || selectionRendition !== rendition) return;
         const start = location && location.start;
         let index = start && Number.isInteger(start.index) ? start.index : -1;
         if (index < 0 && start && start.href) index = getSpineIndexByHref(start.href);
         if (index < 0 || index >= spineItems.length) return;
         epubScrollDiagnostics && epubScrollDiagnostics.relocated(location);
+        let pageGeometry;
+        const manager=rendition.manager,layout=manager?.layout;
+        if(epubViewMode==='single' && layout?.divisor===1 && !manager?.settings?.fullsize && manager?.settings?.direction==='ltr'){
+          const visible=manager.visible?.();
+          const view=visible?.find(view=>view.index===index);
+          if(view && manager.container){
+            pageGeometry={direction:'ltr',firstIndex:book.spine.first()?.index,lastIndex:book.spine.last()?.index,pageWidth:layout.pageWidth,offset:manager.container.getBoundingClientRect().left-view.position().left};
+          }
+        }
+        epubLocation=window.PapyrusEpubReader.location(location,spineItems.length,epubViewMode==='single'?'paged':'chapter-scroll',pageGeometry);
+        if(epubLocation){
+          epubLocation.cfi=epubResizeAnchor?.cfi() || epubLocation.cfi;
+          if(book.locations?.length?.()>0)epubLocation.progress=book.locations.percentageFromCfi(epubLocation.cfi);
+          sendEvent('EPUB_LOCATION',{documentSessionId,location:epubLocation});
+        }
         const nextPage = index + 1;
         if (nextPage === currentPage) return;
         currentPage = nextPage;
@@ -1256,21 +1547,23 @@
       });
     }
 
+    applyEpubZoom();
     sendEpubDiagnostic('epub.display.start', diagnosticPayload);
     await withEpubStageTimeout(
-      displayEpubPage(0),
+      rendition.display(target || spineItems[0]?.href),
       'rendition.display',
       diagnosticPayload,
     );
     if (!isCurrentLoad()) throw new Error('EPUB load superseded by a newer load');
     sendEpubDiagnostic('epub.display.end', diagnosticPayload);
+    const resizeRendition=rendition;
+    epubResizeAnchor=window.PapyrusEpubReader.installResizeAnchor(resizeRendition.manager,()=>resizeRendition.location?.start?.cfi);
     if (
       rendition &&
       rendition.manager &&
       typeof rendition.manager.on === 'function' &&
       typeof rendition.on === 'function'
     ) {
-      let touchStart = null;
       let lastScrollOffset = -1;
       const manager = rendition.manager;
       epubScrollDiagnostics = createEpubScrollDiagnostics(manager);
@@ -1345,47 +1638,19 @@
           return result;
         };
       }
-      const getTouchPoint = (event) => {
-        const touch =
-          (event && event.changedTouches && event.changedTouches[0]) ||
-          (event && event.touches && event.touches[0]);
-        if (!touch) return null;
-        const x = Number(touch.screenX ?? touch.clientX);
-        const y = Number(touch.screenY ?? touch.clientY);
-        return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
-      };
-      const handleScroll = (event) => {
+      const handleScroll = event => {
         const offsetY = Math.max(0, Number(event && event.top) || 0);
         epubScrollDiagnostics && epubScrollDiagnostics.scroll(event);
-        if (Math.abs(offsetY - lastScrollOffset) < 1) return;
-        lastScrollOffset = offsetY;
-        sendEvent('VIEWER_SCROLL', { offsetY });
+        if (Math.abs(offsetY-lastScrollOffset)<1) return;
+        lastScrollOffset=offsetY;
+        sendEvent('VIEWER_SCROLL',{offsetY});
       };
-      const handleTouchStart = (event) => {
-        touchStart = getTouchPoint(event);
-        epubScrollDiagnostics && epubScrollDiagnostics.touchStart(event);
-      };
-      const handleTouchMove = (event) => {
-        epubScrollDiagnostics && epubScrollDiagnostics.touchMove(event);
-      };
-      const handleTouchEnd = (event) => {
-        const end = getTouchPoint(event);
-        const start = touchStart;
-        touchStart = null;
-        if (start && end && Math.hypot(end.x - start.x, end.y - start.y) <= 12) {
-          sendEvent('VIEWER_TAP', {});
-        }
-        epubScrollDiagnostics && epubScrollDiagnostics.touchEnd(event);
-      };
-
       manager.on('scroll', handleScroll);
       const handleScrolled = (event) => {
         epubScrollDiagnostics && epubScrollDiagnostics.settled(event);
       };
       manager.on('scrolled', handleScrolled);
-      rendition.on('touchstart', handleTouchStart);
-      rendition.on('touchmove', handleTouchMove);
-      rendition.on('touchend', handleTouchEnd);
+
       epubInteractionCleanup = () => {
         epubSelectionCleanups.forEach((cleanup) => cleanup());
         epubSelectionCleanups.clear();
@@ -1394,16 +1659,9 @@
         if (originalEnqueue) queue.enqueue = originalEnqueue;
         if (typeof manager.off === 'function') manager.off('scroll', handleScroll);
         if (typeof manager.off === 'function') manager.off('scrolled', handleScrolled);
-        if (typeof rendition.off === 'function') {
-          rendition.off('touchstart', handleTouchStart);
-          rendition.off('touchmove', handleTouchMove);
-          rendition.off('touchend', handleTouchEnd);
-        }
         epubScrollDiagnostics = null;
       };
     }
-    applyEpubZoom();
-
     const outline = await withEpubStageTimeout(
       buildOutline(),
       'outline',
@@ -1417,6 +1675,8 @@
     return { pageCount, outline };
   };
 
+  let epubNavigationQueue = Promise.resolve();
+  let epubNavigationRequest = 0;
   const displayEpubPage = async (pageIndex) => {
     if (!rendition) return;
     const item = spineItems[pageIndex];
@@ -1426,9 +1686,19 @@
       target,
       pageIndex,
     });
-    await rendition.display(target);
-    currentPage = pageIndex + 1;
-    sendState();
+    const activeRendition = rendition;
+    const session = documentSessionId;
+    const request = ++epubNavigationRequest;
+    const navigation = epubNavigationQueue.catch(() => {}).then(async () => {
+      if (request !== epubNavigationRequest || session !== documentSessionId || activeRendition !== rendition) return;
+      epubResizeAnchor?.invalidate();
+      await activeRendition.display(target);
+      if (request !== epubNavigationRequest || session !== documentSessionId || activeRendition !== rendition) return;
+      currentPage = pageIndex + 1;
+      sendState();
+    });
+    epubNavigationQueue = navigation;
+    await navigation;
   };
 
   const getTextContent = async (pageIndex) => {
@@ -1529,6 +1799,10 @@
     }
   };
 
+  let nativeMenuSelection = null;
+  let epubViewMode = "single";
+  let epubLocation = null;
+
   const handleCommand = async (message) => {
     const { id, kind, payload } = message;
 
@@ -1536,7 +1810,15 @@
       if (kind === 'load') {
         const generation = (epubLoadGeneration += 1);
         currentType = payload.type;
+        documentSessionId = payload.documentSessionId || null;
+        epubAnnotations = [];
+        annotationDocumentId = undefined;
         zoom = 1.0;
+        epubViewMode = payload.epubMode === "chapter-scroll" ? "continuous" : "single";
+        epubLocation = null;
+        nativeMenuSelection = null;
+        epubNavigationRequest += 1;
+        epubNavigationQueue = Promise.resolve();
 
         if (currentType === 'text') {
           const result = await loadText(
@@ -1576,6 +1858,43 @@
         throw new Error('Unsupported document type');
       }
 
+      if (kind === 'epub-annotations' || kind === 'epub-annotation-navigate') {
+        if (currentType !== 'epub' || !documentSessionId || payload.documentSessionId !== documentSessionId) throw new Error('Stale EPUB annotation session');
+        if (kind === 'epub-annotations') {
+          const incoming = payload.annotations;
+          if (!Array.isArray(incoming) || incoming.length > 10000 || incoming.some(a => !a || typeof a.id !== 'string' || a.id.length > 256)) throw new Error('Invalid EPUB annotations');
+          const ids = new Set();
+          epubAnnotations = incoming.filter(a => {
+            if (ids.has(a.id) || !window.PapyrusEpubAnnotations.validAnchor(a.anchor)) return false;
+            ids.add(a.id); return true;
+          });
+          annotationDocumentId = typeof payload.documentId === 'string' ? payload.documentId : undefined;
+          annotationLabels = {comment: typeof payload.labels?.comment === 'string' ? payload.labels.comment.slice(0,128) : ''};
+          epubAnnotationRenderers.forEach(renderer => renderer.schedule());
+        } else {
+          const annotation = epubAnnotations.find(a => a.id === payload.annotationId);
+          if (!annotation || (annotation.anchor.documentId && annotation.anchor.documentId !== annotationDocumentId)) throw new Error('Annotation not available for this document');
+          // Navigation uses the CFI, never a synthetic percentage/page rectangle.
+          const navigationSession = documentSessionId;
+          const activeRendition = rendition;
+          // Open the confirmed chapter first, resolve its quote, then navigate its actual range.
+          epubNavigationRequest += 1;
+          const navigation = epubNavigationQueue.catch(() => {}).then(async () => {
+            if(navigationSession !== documentSessionId || activeRendition !== rendition)throw new Error('Stale EPUB navigation');
+            epubResizeAnchor?.invalidate();
+            await activeRendition.display(annotation.anchor.href);
+            if(navigationSession !== documentSessionId || activeRendition !== rendition)throw new Error('Stale EPUB navigation');
+            const contents = activeRendition.getContents().find(c => spineItems[c.sectionIndex]?.href === annotation.anchor.href);
+            const range = contents && window.PapyrusEpubAnnotations.resolveRange(contents,annotation.anchor);
+            if(!range)throw new Error('EPUB anchor unresolved');
+            await activeRendition.display(contents.cfiFromRange(range));
+          });
+          epubNavigationQueue = navigation;
+          await navigation;
+        }
+        sendResponse(id,true,null); return;
+      }
+
       if (kind === 'go-to-page') {
         const page = Math.max(1, payload.page || 1);
         if (currentType === 'text') {
@@ -1598,12 +1917,55 @@
         return;
       }
 
+      if (kind === 'epub-turn-page') {
+        if (epubViewMode !== 'single') {sendResponse(id,true,null); return;}
+        if (currentType !== 'epub' || payload.documentSessionId !== documentSessionId) throw new Error('Stale EPUB navigation');
+        const active = rendition;
+        epubNavigationQueue = epubNavigationQueue.catch(() => {}).then(() => {
+          if (active !== rendition || payload.documentSessionId !== documentSessionId) return;
+          epubResizeAnchor?.invalidate();
+          return payload.direction < 0 ? active.prev() : active.next();
+        });
+        await epubNavigationQueue;
+        sendResponse(id,true,null); return;
+      }
+
+      if (kind === 'set-epub-view-mode') {
+        if (currentType !== 'epub' || payload.documentSessionId !== documentSessionId) throw new Error('Stale EPUB layout session');
+        const next=payload.epubMode ? (payload.epubMode==='paged'?'single':'continuous') : (payload.viewMode==='single'?'single':'continuous');
+        {
+          epubNavigationQueue=epubNavigationQueue.catch(()=>{}).then(async()=>{
+            if(payload.documentSessionId!==documentSessionId || next===epubViewMode)return;
+            const target=epubResizeAnchor?.cfi() || epubLocation?.cfi;
+            epubViewMode=next;
+            await renderEpubRendition('layout',epubLoadGeneration,target);
+          });
+          await epubNavigationQueue;
+        }
+        sendResponse(id,true,null);return;
+      }
+      if(kind === 'epub-go-to-location'){
+        if(currentType!=='epub' || payload.documentSessionId!==documentSessionId || !window.PapyrusEpubReader.validCfi(payload.cfi))throw new Error('Invalid EPUB location');
+        epubNavigationQueue=epubNavigationQueue.catch(()=>{}).then(()=>{if(payload.documentSessionId!==documentSessionId)return;epubResizeAnchor?.invalidate();return rendition.display(payload.cfi);});
+        await epubNavigationQueue;sendResponse(id,true,null);return;
+      }
+
       if (kind === 'set-zoom') {
-        zoom = Math.max(0.5, Math.min(4.0, payload.zoom || 1.0));
-        applyZoom();
-        sendState();
-        sendResponse(id, true, { zoom });
-        return;
+        const requestedZoom=Math.max(0.5,Math.min(4.0,payload.zoom || 1.0));
+        if(currentType === 'epub') {
+          const session=documentSessionId;
+          epubNavigationQueue=epubNavigationQueue.catch(()=>{}).then(async()=>{
+            if(session!==documentSessionId)return;
+            const active=rendition;
+            const cfi=epubResizeAnchor?.cfi() || epubLocation?.cfi;
+            zoom=requestedZoom;applyEpubZoom();
+            // Let the content CSS update before redisplaying the logical anchor.
+            await new Promise(resolve=>(window.requestAnimationFrame || (callback=>setTimeout(callback,0)))(resolve));
+            if(cfi && active===rendition && session===documentSessionId)await active.display(cfi);
+          });
+          await epubNavigationQueue;
+        } else {zoom=requestedZoom;applyZoom();}
+        sendState();sendResponse(id,true,{zoom});return;
       }
 
       if (kind === 'set-rotation') {
@@ -1745,6 +2107,26 @@
       return;
     }
 
+    if (message.type === 'epub-selection-action') {
+      const selected = nativeMenuSelection;
+      if (!selected || message.documentSessionId !== documentSessionId ||
+          selected.payload.documentSessionId !== documentSessionId) return;
+      if (message.key === 'selectAll') {
+        const doc = selected.contents.document;
+        const range = doc.createRange();
+        range.selectNodeContents(doc.body);
+        const selection = selected.contents.window.getSelection();
+        selection.removeAllRanges();
+        selection.addRange(range);
+        return;
+      }
+      if (!['copy','define','highlight','underline','strikeout','comment'].includes(message.key)) return;
+      sendEvent('EPUB_SELECTION_ACTION', {...selected.payload, action: message.key});
+      selected.contents.window.getSelection()?.removeAllRanges();
+      nativeMenuSelection = null;
+      return;
+    }
+
     if (!message.kind) return;
     handleCommand(message);
   };