@ankhorage/expo-runtime 3.1.1 → 3.2.0

package/src/reader/epub/path.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from 'bun:test';
+
+import { isExternalReference, normalizeArchivePath, resolveArchivePath } from './path';
+
+describe('EPUB archive paths', () => {
+  test('resolves package-relative resources without escaping the archive', () => {
+    expect(resolveArchivePath('OPS/package.opf', 'text/../images/cover.jpg')).toBe(
+      'OPS/images/cover.jpg',
+    );
+    expect(() => resolveArchivePath('', '../../outside')).toThrow('escapes the archive');
+  });
+
+  test('normalizes platform separators and encoded names', () => {
+    expect(normalizeArchivePath('OPS\\Text%20One.xhtml')).toBe('OPS/Text One.xhtml');
+  });
+
+  test('classifies active external URL schemes', () => {
+    expect(isExternalReference('https://example.test')).toBe(true);
+    expect(isExternalReference('javascript:alert(1)')).toBe(true);
+    expect(isExternalReference('../images/cover.png')).toBe(false);
+  });
+});

package/src/reader/epub/path.ts

@@ -0,0 +1,26 @@
+export function normalizeArchivePath(path: string): string {
+  const segments: string[] = [];
+  for (const segment of decodeURIComponent(path).replaceAll('\\', '/').split('/')) {
+    if (segment === '' || segment === '.') continue;
+    if (segment === '..') {
+      if (segments.length === 0) throw new Error(`EPUB resource escapes the archive: ${path}`);
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  return segments.join('/');
+}
+
+export function resolveArchivePath(basePath: string, reference: string): string {
+  const cleanReference = reference.split('#', 1)[0]?.split('?', 1)[0] ?? '';
+  if (cleanReference.startsWith('/')) return normalizeArchivePath(cleanReference);
+  const baseDirectory = basePath.includes('/')
+    ? basePath.slice(0, basePath.lastIndexOf('/') + 1)
+    : '';
+  return normalizeArchivePath(`${baseDirectory}${cleanReference}`);
+}
+
+export function isExternalReference(reference: string): boolean {
+  return /^(?:https?:|mailto:|tel:|data:|javascript:|\/\/)/i.test(reference.trim());
+}

package/src/reader/epub/sanitizeEpubDocument.ts

@@ -0,0 +1,121 @@
+import { isExternalReference, resolveArchivePath } from './path';
+
+const REMOVED_ELEMENTS = 'script, form, iframe, frame, object, embed';
+const RESOURCE_ATTRIBUTES = ['src', 'poster', 'data'] as const;
+
+export function sanitizeEpubDocument(
+  source: string,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): string {
+  const document = new DOMParser().parseFromString(source, 'application/xhtml+xml');
+  if (document.querySelector('parsererror')) {
+    throw new Error(`Invalid EPUB XHTML resource: ${resourcePath}`);
+  }
+
+  document.querySelectorAll(REMOVED_ELEMENTS).forEach((element) => element.remove());
+  document
+    .querySelectorAll('meta[http-equiv]')
+    .forEach(
+      (element) =>
+        element.getAttribute('http-equiv')?.toLowerCase() === 'refresh' && element.remove(),
+    );
+
+  sanitizeElementAttributes(document, resourcePath, resolveResourceUrl);
+  rewriteDocumentResources(document, resourcePath, resolveResourceUrl);
+  rewriteDocumentLinks(document);
+  return new XMLSerializer().serializeToString(document);
+}
+
+function sanitizeElementAttributes(
+  document: XMLDocument,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): void {
+  for (const element of document.querySelectorAll('*')) {
+    for (const attribute of Array.from(element.attributes)) {
+      if (attribute.name.toLowerCase().startsWith('on')) element.removeAttribute(attribute.name);
+    }
+    const inlineStyle = element.getAttribute('style');
+    if (inlineStyle) {
+      element.setAttribute(
+        'style',
+        sanitizeEpubStylesheet(inlineStyle, resourcePath, resolveResourceUrl),
+      );
+    }
+    element.removeAttribute('srcset');
+  }
+
+  for (const style of document.querySelectorAll('style')) {
+    style.textContent = sanitizeEpubStylesheet(style.textContent, resourcePath, resolveResourceUrl);
+  }
+}
+
+function rewriteDocumentResources(
+  document: XMLDocument,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): void {
+  for (const attributeName of RESOURCE_ATTRIBUTES) {
+    for (const element of document.querySelectorAll(`[${attributeName}]`)) {
+      rewriteResourceAttribute(element, attributeName, resourcePath, resolveResourceUrl);
+    }
+  }
+
+  for (const link of document.querySelectorAll('link[href]')) {
+    rewriteResourceAttribute(link, 'href', resourcePath, resolveResourceUrl);
+  }
+}
+
+function rewriteDocumentLinks(document: XMLDocument): void {
+  for (const anchor of document.querySelectorAll('a[href]')) {
+    const href = anchor.getAttribute('href')?.trim();
+    if (!href) continue;
+    if (/^(?:https?:|mailto:|tel:|\/\/)/i.test(href)) {
+      anchor.setAttribute('data-reader-external-href', href);
+      anchor.removeAttribute('href');
+    } else if (isExternalReference(href)) {
+      anchor.removeAttribute('href');
+    }
+  }
+}
+
+export function sanitizeEpubStylesheet(
+  source: string,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): string {
+  const withoutImports = source.replaceAll(/@import\s+(?:url\([^)]*\)|[^;]+);?/gi, '');
+  return withoutImports.replaceAll(
+    /url\(\s*(['"]?)([^)'"\s]+)\1\s*\)/gi,
+    (match, _quote, value: string) => {
+      if (isExternalReference(value)) return 'url(about:blank)';
+      try {
+        return `url("${resolveResourceUrl(resolveArchivePath(resourcePath, value)) ?? 'about:blank'}")`;
+      } catch {
+        return 'url(about:blank)';
+      }
+    },
+  );
+}
+
+function rewriteResourceAttribute(
+  element: Element,
+  attributeName: string,
+  resourcePath: string,
+  resolveResourceUrl: (path: string) => string | undefined,
+): void {
+  const value = element.getAttribute(attributeName)?.trim();
+  if (!value) return;
+  if (isExternalReference(value)) {
+    element.removeAttribute(attributeName);
+    return;
+  }
+  try {
+    const resolved = resolveResourceUrl(resolveArchivePath(resourcePath, value));
+    if (resolved === undefined) element.removeAttribute(attributeName);
+    else element.setAttribute(attributeName, resolved);
+  } catch {
+    element.removeAttribute(attributeName);
+  }
+}

package/src/reader/loadReaderSourceAsync.test.ts

@@ -0,0 +1,52 @@
+import { afterEach, describe, expect, mock, test } from 'bun:test';
+
+import { loadReaderSourceAsync } from './loadReaderSourceAsync';
+
+const originalFetch = globalThis.fetch;
+
+describe('loadReaderSourceAsync', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    mock.restore();
+  });
+
+  test('loads a bounded source without forwarding credentials', async () => {
+    const requests: RequestInit[] = [];
+    globalThis.fetch = mock((_url: string | URL | Request, init?: RequestInit) => {
+      requests.push(init ?? {});
+      return Promise.resolve(new Response(new Uint8Array([1, 2, 3]), { status: 200 }));
+    }) as typeof fetch;
+
+    const controller = new AbortController();
+    expect(await loadReaderSourceAsync('https://example.test/book.pdf', controller.signal)).toEqual(
+      new Uint8Array([1, 2, 3]),
+    );
+    expect(requests[0]?.credentials).toBe('omit');
+    expect(requests[0]?.signal).toBe(controller.signal);
+  });
+
+  test('rejects unsuccessful responses before reading their body', () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response('missing', { status: 404 })),
+    ) as typeof fetch;
+
+    expect(
+      loadReaderSourceAsync('https://example.test/missing.epub', new AbortController().signal),
+    ).rejects.toThrow('HTTP 404');
+  });
+
+  test('rejects a declared body larger than the reader download budget', () => {
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(null, {
+          headers: { 'content-length': String(256 * 1024 * 1024 + 1) },
+          status: 200,
+        }),
+      ),
+    ) as typeof fetch;
+
+    expect(
+      loadReaderSourceAsync('https://example.test/huge.epub', new AbortController().signal),
+    ).rejects.toThrow('download limit');
+  });
+});

package/src/reader/loadReaderSourceAsync.ts

@@ -0,0 +1,59 @@
+const MAX_READER_SOURCE_BYTES = 256 * 1024 * 1024;
+
+export async function loadReaderSourceAsync(
+  sourceUri: string,
+  signal: AbortSignal,
+): Promise<Uint8Array> {
+  const response = await fetch(sourceUri, {
+    credentials: 'omit',
+    signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(`Reader source request failed with HTTP ${response.status}.`);
+  }
+
+  const declaredLength = Number(response.headers.get('content-length'));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_READER_SOURCE_BYTES) {
+    throw new Error(`Reader source exceeds the ${MAX_READER_SOURCE_BYTES}-byte download limit.`);
+  }
+
+  if (response.body === null) {
+    return validateSourceSize(new Uint8Array(await response.arrayBuffer()));
+  }
+
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let byteLength = 0;
+
+  try {
+    for (;;) {
+      const result = await reader.read();
+      if (result.done) break;
+      byteLength += result.value.byteLength;
+      if (byteLength > MAX_READER_SOURCE_BYTES) {
+        throw new Error(
+          `Reader source exceeds the ${MAX_READER_SOURCE_BYTES}-byte download limit.`,
+        );
+      }
+      chunks.push(result.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+
+function validateSourceSize(bytes: Uint8Array): Uint8Array {
+  if (bytes.byteLength > MAX_READER_SOURCE_BYTES) {
+    throw new Error(`Reader source exceeds the ${MAX_READER_SOURCE_BYTES}-byte download limit.`);
+  }
+  return bytes;
+}

package/src/reader/readerViewportPresentation.ts

@@ -0,0 +1,28 @@
+import type { ReaderViewportState } from './types';
+
+export const LOADING_STATE: ReaderViewportState = {
+  canGoNext: false,
+  canGoPrevious: false,
+  page: 1,
+  progress: 0,
+  status: 'loading',
+};
+
+export const READER_STYLES = `
+  :root, body, #root { height: 100%; margin: 0; overflow: hidden; }
+  * { box-sizing: border-box; }
+  .reader-root { background: #fff; color: #111; height: 100%; outline: none; overflow: hidden; touch-action: pan-y; width: 100%; }
+  .reader-dark { background: #111; color: #f5f5f5; }
+  .reader-sepia { background: #f4ecd8; color: #3f3527; }
+  .reader-content { height: 100%; overflow: auto; position: relative; width: 100%; }
+  .reader-content > div:not(.reader-pdf-page) { height: 100%; width: 100%; }
+  .reader-pdf-page { --user-unit: 1; --total-scale-factor: calc(var(--scale-factor) * var(--user-unit)); margin: 0 auto; position: relative; }
+  .reader-pdf-page canvas { display: block; position: absolute; inset: 0; }
+  .reader-pdf-text-layer { --min-font-size: 1; --text-scale-factor: calc(var(--total-scale-factor) * var(--min-font-size)); --min-font-size-inv: calc(1 / var(--min-font-size)); inset: 0; line-height: 1; opacity: 1; overflow: hidden; position: absolute; text-align: initial; text-size-adjust: none; transform-origin: 0 0; }
+  .reader-pdf-text-layer span, .reader-pdf-text-layer br { color: transparent; cursor: text; position: absolute; transform-origin: 0 0; user-select: text; white-space: pre; }
+  .reader-pdf-text-layer > :not(.markedContent), .reader-pdf-text-layer .markedContent span:not(.markedContent) { --font-height: 0; --scale-x: 1; --rotate: 0deg; font-size: calc(var(--text-scale-factor) * var(--font-height)); transform: rotate(var(--rotate)) scaleX(var(--scale-x)) scale(var(--min-font-size-inv)); }
+  .reader-pdf-text-layer .markedContent { display: contents; }
+  .reader-pdf-text-layer ::selection { background: rgba(0, 100, 255, 0.35); }
+  .reader-pdf-link-layer { inset: 0; pointer-events: none; position: absolute; }
+  .reader-pdf-link-layer a { outline-offset: 2px; pointer-events: auto; position: absolute; }
+`;

package/src/reader/rendererPackages.test.ts

@@ -2,12 +2,14 @@ import { describe, expect, test } from 'bun:test';
 
 describe('reader renderer package boundary', () => {
   test('provides the EPUB navigator and archive APIs required by the driver', async () => {
-    const [{ EpubNavigator }, { BlobReader, ZipReader }] = await Promise.all([
+    const [{ EpubNavigator }, { Publication }, { BlobReader, ZipReader }] = await Promise.all([
       import('@readium/navigator'),
+      import('@readium/shared'),
       import('@zip.js/zip.js'),
     ]);
 
     expect(EpubNavigator).toBeFunction();
+    expect(Publication).toBeFunction();
     expect(BlobReader).toBeFunction();
     expect(ZipReader).toBeFunction();
   });

package/src/reader/types.ts

@@ -0,0 +1,61 @@
+import type { ReaderErrorEvent, ReaderLocationChangeEvent } from '@ankhorage/zora';
+import type { DOMProps } from 'expo/dom';
+
+export interface ReaderAppearance {
+  readonly colorScheme: 'dark' | 'light' | 'sepia' | 'system';
+  readonly fontScale: number;
+  readonly lineHeight: number;
+}
+
+export interface ReaderCommand {
+  readonly id: number;
+  readonly sourceUri: string;
+  readonly type: 'next' | 'previous';
+}
+
+export interface ReaderViewportState {
+  readonly canGoNext: boolean;
+  readonly canGoPrevious: boolean;
+  readonly location?: ReaderLocationChangeEvent;
+  readonly page: number;
+  readonly pageCount?: number;
+  readonly progress: number;
+  readonly status: 'loading' | 'ready';
+}
+
+export interface ReaderViewportProps {
+  readonly appearance: ReaderAppearance;
+  readonly command?: ReaderCommand;
+  readonly format: 'epub' | 'pdf';
+  readonly initialLocation?: string;
+  readonly onError: (event: ReaderErrorEvent) => Promise<void>;
+  readonly onOpenExternalLink: (event: { readonly url: string }) => Promise<void>;
+  readonly onStateChange: (state: ReaderViewportState) => Promise<void>;
+  readonly sourceUri: string;
+  readonly dom?: DOMProps;
+}
+
+export interface ReaderDriverState {
+  readonly canGoNext: boolean;
+  readonly canGoPrevious: boolean;
+  readonly chapterId?: string;
+  readonly chapterTitle?: string;
+  readonly locator: string;
+  readonly page: number;
+  readonly pageCount?: number;
+  readonly progression: number;
+}
+
+export interface ReaderDriver {
+  readonly direction: 'ltr' | 'rtl';
+  destroy(): Promise<void>;
+  getState(): ReaderDriverState;
+  goNext(trigger: ReaderLocationChangeEvent['trigger']): Promise<void>;
+  goPrevious(trigger: ReaderLocationChangeEvent['trigger']): Promise<void>;
+}
+
+export interface ReaderTouchStart {
+  readonly interactive: boolean;
+  readonly x: number;
+  readonly y: number;
+}

package/src/reader/validateEpubArchiveEntriesAsync.test.ts

@@ -0,0 +1,142 @@
+import type { Entry } from '@zip.js/zip.js';
+import {
+  ERR_OVERLAPPING_ENTRY,
+  TextReader,
+  Uint8ArrayReader,
+  Uint8ArrayWriter,
+  ZipReader,
+  ZipWriter,
+} from '@zip.js/zip.js';
+import { describe, expect, test } from 'bun:test';
+
+import { validateEpubArchiveEntriesAsync } from './validateEpubArchiveEntriesAsync';
+
+describe('validateEpubArchiveEntriesAsync archive budgets', () => {
+  test('accepts a bounded archive and preflights every file without extracting it', async () => {
+    const entries = await createArchiveEntries([
+      ['mimetype', 'application/epub+zip'],
+      ['META-INF/container.xml', '<container />'],
+    ]);
+
+    expect(validateEpubArchiveEntriesAsync(entries)).resolves.toBeUndefined();
+    expect(entries.every((entry) => entry.directory || entry.localDirectory)).toBe(true);
+  });
+
+  test('rejects excessive entry counts before reading entry data', async () => {
+    const [entry] = await createArchiveEntries([['mimetype', 'application/epub+zip']]);
+
+    expect(validateEpubArchiveEntriesAsync(Array<Entry>(10_001).fill(entry))).rejects.toThrow(
+      'exceeds the 10000-entry limit',
+    );
+    expect(entry.localDirectory).toBeUndefined();
+  });
+
+  test('rejects an oversized entry before reading entry data', async () => {
+    const [entry] = await createArchiveEntries([['chapter.xhtml', '<p>Chapter</p>']]);
+    entry.uncompressedSize = 64 * 1024 * 1024 + 1;
+    entry.compressedSize = entry.uncompressedSize;
+
+    expect(validateEpubArchiveEntriesAsync([entry])).rejects.toThrow(
+      'exceeds the 67108864-byte uncompressed limit',
+    );
+    expect(entry.localDirectory).toBeUndefined();
+  });
+
+  test('rejects excessive aggregate expansion before reading entry data', async () => {
+    const entries = await createArchiveEntries(
+      Array.from({ length: 9 }, (_, index) => [`chapter-${index}.xhtml`, '<p>Chapter</p>']),
+    );
+
+    for (const entry of entries) {
+      entry.uncompressedSize = 64 * 1024 * 1024;
+      entry.compressedSize = entry.uncompressedSize;
+    }
+
+    expect(validateEpubArchiveEntriesAsync(entries)).rejects.toThrow(
+      'exceeds the 536870912-byte aggregate uncompressed limit',
+    );
+    expect(entries.every((entry) => !entry.localDirectory)).toBe(true);
+  });
+
+  test('rejects suspicious compression ratios before reading entry data', async () => {
+    const [entry] = await createArchiveEntries([['chapter.xhtml', '<p>Chapter</p>']]);
+    entry.uncompressedSize = 10_001;
+    entry.compressedSize = 100;
+
+    expect(validateEpubArchiveEntriesAsync([entry])).rejects.toThrow(
+      'exceeds the 100:1 compression-ratio limit',
+    );
+    expect(entry.localDirectory).toBeUndefined();
+  });
+});
+
+describe('validateEpubArchiveEntriesAsync archive structure', () => {
+  test('rejects invalid declared sizes before reading entry data', async () => {
+    const [entry] = await createArchiveEntries([['chapter.xhtml', '<p>Chapter</p>']]);
+    entry.compressedSize = Number.NaN;
+
+    expect(validateEpubArchiveEntriesAsync([entry])).rejects.toThrow('declares invalid sizes');
+    expect(entry.localDirectory).toBeUndefined();
+  });
+
+  test('rejects overlapping entry ranges during the no-extraction preflight', async () => {
+    const archive = await createArchive([
+      ['first.txt', 'same'],
+      ['other.txt', 'same'],
+    ]);
+    const centralDirectoryOffsets = findSignatureOffsets(archive, 0x02014b50);
+    const archiveView = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+    const firstLocalHeaderOffset = archiveView.getUint32(centralDirectoryOffsets[0] + 42, true);
+    const firstCentralFilename = archive.slice(
+      centralDirectoryOffsets[0] + 46,
+      centralDirectoryOffsets[0] + 46 + 'first.txt'.length,
+    );
+    archive.set(firstCentralFilename, centralDirectoryOffsets[1] + 46);
+    archiveView.setUint32(centralDirectoryOffsets[1] + 42, firstLocalHeaderOffset, true);
+    const entries = await readArchiveEntries(archive, 'balanced');
+
+    expect(validateEpubArchiveEntriesAsync(entries)).rejects.toThrow(ERR_OVERLAPPING_ENTRY);
+  });
+});
+
+async function createArchive(
+  files: readonly (readonly [filename: string, content: string])[],
+): Promise<Uint8Array> {
+  const writer = new ZipWriter(new Uint8ArrayWriter());
+
+  for (const [filename, content] of files) {
+    await writer.add(filename, new TextReader(content));
+  }
+
+  return writer.close();
+}
+
+async function createArchiveEntries(
+  files: readonly (readonly [filename: string, content: string])[],
+): Promise<Entry[]> {
+  return readArchiveEntries(await createArchive(files));
+}
+
+function findSignatureOffsets(data: Uint8Array, signature: number): number[] {
+  const offsets: number[] = [];
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+  for (let offset = 0; offset <= data.byteLength - 4; offset += 1) {
+    if (view.getUint32(offset, true) === signature) {
+      offsets.push(offset);
+    }
+  }
+
+  return offsets;
+}
+
+async function readArchiveEntries(
+  data: Uint8Array,
+  strictness: 'balanced' | 'strict' = 'strict',
+): Promise<Entry[]> {
+  const reader = new ZipReader(new Uint8ArrayReader(data), {
+    strictness,
+  });
+
+  return reader.getEntries({ strictness });
+}

package/src/reader/validateEpubArchiveEntriesAsync.ts

@@ -0,0 +1,73 @@
+import type { Entry } from '@zip.js/zip.js';
+import { Uint8ArrayWriter } from '@zip.js/zip.js';
+
+const MAX_COMPRESSION_RATIO = 100;
+const MAX_ENTRY_COUNT = 10_000;
+const MAX_ENTRY_UNCOMPRESSED_BYTES = 64 * 1024 * 1024;
+const MAX_TOTAL_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
+
+export async function validateEpubArchiveEntriesAsync(
+  entries: readonly Entry[],
+  signal?: AbortSignal,
+): Promise<void> {
+  if (entries.length > MAX_ENTRY_COUNT) {
+    throw new Error(`EPUB archive exceeds the ${MAX_ENTRY_COUNT}-entry limit.`);
+  }
+
+  let totalUncompressedBytes = 0;
+
+  for (const entry of entries) {
+    validateDeclaredSizes(entry);
+
+    if (entry.directory) {
+      continue;
+    }
+
+    if (entry.uncompressedSize > MAX_ENTRY_UNCOMPRESSED_BYTES) {
+      throw new Error(
+        `EPUB archive entry "${entry.filename}" exceeds the ${MAX_ENTRY_UNCOMPRESSED_BYTES}-byte uncompressed limit.`,
+      );
+    }
+
+    if (
+      entry.uncompressedSize > 0 &&
+      (entry.compressedSize === 0 ||
+        entry.uncompressedSize > entry.compressedSize * MAX_COMPRESSION_RATIO)
+    ) {
+      throw new Error(
+        `EPUB archive entry "${entry.filename}" exceeds the ${MAX_COMPRESSION_RATIO}:1 compression-ratio limit.`,
+      );
+    }
+
+    if (totalUncompressedBytes > MAX_TOTAL_UNCOMPRESSED_BYTES - entry.uncompressedSize) {
+      throw new Error(
+        `EPUB archive exceeds the ${MAX_TOTAL_UNCOMPRESSED_BYTES}-byte aggregate uncompressed limit.`,
+      );
+    }
+
+    totalUncompressedBytes += entry.uncompressedSize;
+  }
+
+  for (const entry of entries) {
+    if (entry.directory) {
+      continue;
+    }
+
+    await entry.getData(new Uint8ArrayWriter(), {
+      checkOverlappingEntryOnly: true,
+      signal,
+      strictness: 'strict',
+    });
+  }
+}
+
+function validateDeclaredSizes(entry: Entry): void {
+  if (
+    !Number.isSafeInteger(entry.compressedSize) ||
+    entry.compressedSize < 0 ||
+    !Number.isSafeInteger(entry.uncompressedSize) ||
+    entry.uncompressedSize < 0
+  ) {
+    throw new Error(`EPUB archive entry "${entry.filename}" declares invalid sizes.`);
+  }
+}

package/src/resolveExpoRuntimePlan.test.ts

@@ -97,6 +97,42 @@ describe('resolveExpoRuntimePlan barcode capability', () => {
   });
 });
 
+describe('resolveExpoRuntimePlan ebook reader capability', () => {
+  test('selects the reader adapter and exact renderer packages without permissions', () => {
+    const plan = resolveExpoRuntimePlan(
+      withFirstScreenRequirements({ capabilities: [{ capability: 'ebookReader' }] }),
+    );
+
+    expect(plan.permissions).toEqual([]);
+    expect(plan.impliedPermissions).toEqual([]);
+    expect(plan.providers).toEqual([]);
+    expect(plan.nativeConfig.plugins).toEqual([]);
+    expect(plan.runtimeAdapters).toEqual(['ExpoReaderSurfaceAdapter']);
+    expect(plan.dependencies.map(({ name, version }) => ({ name, version }))).toEqual([
+      {
+        name: '@ankhorage/expo-runtime',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['@ankhorage/expo-runtime'],
+      },
+      {
+        name: '@readium/navigator',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['@readium/navigator'],
+      },
+      {
+        name: '@readium/shared',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['@readium/shared'],
+      },
+      {
+        name: '@zip.js/zip.js',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['@zip.js/zip.js'],
+      },
+      {
+        name: 'pdfjs-dist',
+        version: GENERATED_RUNTIME_DEPENDENCY_VERSIONS['pdfjs-dist'],
+      },
+    ]);
+  });
+});
+
 describe('resolveExpoRuntimePlan Expo 57 plugin coverage', () => {
   test('keeps microphone-only native configuration free of background audio behavior', () => {
     const plan = resolveExpoRuntimePlan(