diff --git a/.changeset/config.json b/.changeset/config.json
index 43989e1..b4a5cbc 100644
--- a/.changeset/config.json
+++ b/.changeset/config.json
@@ -2,8 +2,8 @@
   "$schema": "https://unpkg.com/@changesets/config@3.1.3/schema.json",
   "changelog": "@changesets/cli/changelog",
   "commit": false,
-  "fixed": [],
-  "linked": [["@ritojs/core", "@ritojs/kit", "@ritojs/react"]],
+  "fixed": [["@ritojs/core", "@ritojs/kit", "@ritojs/react"]],
+  "linked": [],
   "access": "public",
   "baseBranch": "master",
   "updateInternalDependencies": "patch",
diff --git a/packages/kit/CHANGELOG.md b/packages/kit/CHANGELOG.md
index 4397633..0407daa 100644
--- a/packages/kit/CHANGELOG.md
+++ b/packages/kit/CHANGELOG.md
@@ -1,5 +1,14 @@
 # @ritojs/kit
 
+## 0.12.1
+
+### Patch Changes
+
+- Updated dependencies [9c1688b]
+- Updated dependencies [9c1688b]
+- Updated dependencies [9c1688b]
+  - @ritojs/core@0.12.1
+
 ## 0.12.0
 
 ### Minor Changes
diff --git a/packages/kit/package.json b/packages/kit/package.json
index a24e017..797ddf5 100644
--- a/packages/kit/package.json
+++ b/packages/kit/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@ritojs/kit",
   "type": "module",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Framework-agnostic controller, overlays, and transitions for @ritojs/core",
   "license": "AGPL-3.0-only",
   "main": "./dist/index.mjs",
diff --git a/packages/react/CHANGELOG.md b/packages/react/CHANGELOG.md
index e2f043e..9f4dbd9 100644
--- a/packages/react/CHANGELOG.md
+++ b/packages/react/CHANGELOG.md
@@ -1,5 +1,15 @@
 # @ritojs/react
 
+## 0.12.1
+
+### Patch Changes
+
+- Updated dependencies [9c1688b]
+- Updated dependencies [9c1688b]
+- Updated dependencies [9c1688b]
+  - @ritojs/core@0.12.1
+  - @ritojs/kit@0.12.1
+
 ## 0.12.0
 
 ### Minor Changes
diff --git a/packages/react/package.json b/packages/react/package.json
index 62764a6..2ce6732 100644
--- a/packages/react/package.json
+++ b/packages/react/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@ritojs/react",
   "type": "module",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "React hooks and components for @ritojs/core",
   "license": "AGPL-3.0-only",
   "main": "./dist/index.mjs",
diff --git a/packages/rito/CHANGELOG.md b/packages/rito/CHANGELOG.md
index aa6df47..0ce8a59 100644
--- a/packages/rito/CHANGELOG.md
+++ b/packages/rito/CHANGELOG.md
@@ -1,5 +1,30 @@
 # @ritojs/core
 
+## 0.12.1
+
+### Patch Changes
+
+- 9c1688b: Open spec-violating EPUBs that earlier failed to load. The OPF parser now
+  defaults missing `dc:title` / `dc:language` / `dc:identifier` to an empty string
+  with a warning instead of throwing (the structural `<manifest>` / `<spine>`
+  checks stay strict), and the ZIP reader percent-decodes container paths on a
+  lookup miss, so a manifest href like `Text/Character%20Profile.xhtml` resolves
+  to the literal `Text/Character Profile.xhtml` archive entry.
+- 9c1688b: Resolve in-content illustrations that previously rendered as broken images.
+  `loadEpub` now indexes every image file present in the archive — not only those
+  declared in the OPF manifest — so spec-violating books that reference undeclared
+  illustrations still get image data. Manifest resource reads are individually
+  tolerant (a single missing/mislabeled entry is skipped with a warning instead of
+  aborting the load), and href resolution percent-decodes on miss so references
+  like `Images/My%20Pic.jpg` match a literal `Images/My Pic.jpg` entry.
+- 9c1688b: Parse EPUB chapters whose XHTML is invalid in strict XML. The source normalizer
+  now escapes stray ampersands (e.g. `Schmidt & Bender`), remaps HTML named
+  entities undefined without a DTD (`&copy;`, `&mdash;`, `&nbsp;`, …) to numeric
+  references, and strips characters illegal in XML (C0 controls, `U+FFFE/FFFF`,
+  lone surrogates, and numeric refs pointing to them), while leaving comments and
+  CDATA sections untouched. Chapters that previously failed with errors such as
+  `EntityRef: expecting ';'` or `PCDATA invalid Char value 31` now parse.
+
 ## 0.12.0
 
 ### Minor Changes
diff --git a/packages/rito/package.json b/packages/rito/package.json
index b059058..d766d1d 100644
--- a/packages/rito/package.json
+++ b/packages/rito/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@ritojs/core",
   "type": "module",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "EPUB rendering engine with a Web Canvas backend",
   "license": "AGPL-3.0-only",
   "main": "./dist/index.mjs",
diff --git a/packages/rito/src/parser/epub/package-parser.ts b/packages/rito/src/parser/epub/package-parser.ts
index 01c42e9..32675fc 100644
--- a/packages/rito/src/parser/epub/package-parser.ts
+++ b/packages/rito/src/parser/epub/package-parser.ts
@@ -1,10 +1,11 @@
 import type { ManifestItem, PackageDocument, PackageMetadata, SpineItem } from './types';
 import { EpubParseError } from './errors';
+import type { Logger } from '../../utils/logger';
 
 /**
  * Parse an OPF package document XML string into a PackageDocument.
  */
-export function parsePackageDocument(opfXml: string): PackageDocument {
+export function parsePackageDocument(opfXml: string, logger?: Logger): PackageDocument {
   const doc = new DOMParser().parseFromString(opfXml, 'application/xml');
 
   const parserError = doc.querySelector('parsererror');
@@ -12,30 +13,37 @@ export function parsePackageDocument(opfXml: string): PackageDocument {
     throw new EpubParseError(`Invalid OPF package document: ${parserError.textContent}`);
   }
 
-  const metadata = parseMetadata(doc);
+  const metadata = parseMetadata(doc, logger);
   const manifest = parseManifest(doc);
   const spine = parseSpine(doc);
 
   return { metadata, manifest, spine };
 }
 
-function parseMetadata(doc: Document): PackageMetadata {
+/**
+ * Parse Dublin Core metadata. The EPUB spec requires `<dc:title>`,
+ * `<dc:language>` and `<dc:identifier>`, but spec-violating files (e.g. some
+ * Sigil exports) omit them while remaining perfectly readable. Rather than
+ * refusing to open such books, missing fields fall back to an empty string and
+ * a warning — the structural `<manifest>`/`<spine>` checks below stay strict.
+ */
+function parseMetadata(doc: Document, logger?: Logger): PackageMetadata {
   const title = getMetadataText(doc, 'title');
   const language = getMetadataText(doc, 'language');
   const identifier = getMetadataText(doc, 'identifier');
 
-  if (!title) {
-    throw new EpubParseError('Missing required <dc:title> in package metadata');
-  }
-  if (!language) {
-    throw new EpubParseError('Missing required <dc:language> in package metadata');
-  }
+  if (!title) logger?.warn('Missing <dc:title> in package metadata; using empty title');
+  if (!language) logger?.warn('Missing <dc:language> in package metadata; using empty language');
   if (!identifier) {
-    throw new EpubParseError('Missing required <dc:identifier> in package metadata');
+    logger?.warn('Missing <dc:identifier> in package metadata; using empty identifier');
   }
 
   const creator = getMetadataText(doc, 'creator');
-  const result: PackageMetadata = { title, language, identifier };
+  const result: PackageMetadata = {
+    title: title ?? '',
+    language: language ?? '',
+    identifier: identifier ?? '',
+  };
 
   if (creator) {
     return { ...result, creator };
diff --git a/packages/rito/src/parser/epub/zip-reader.ts b/packages/rito/src/parser/epub/zip-reader.ts
index 1827681..ac46801 100644
--- a/packages/rito/src/parser/epub/zip-reader.ts
+++ b/packages/rito/src/parser/epub/zip-reader.ts
@@ -15,7 +15,10 @@ export function createZipReader(data: ArrayBuffer): ZipReader {
   return {
     readFile(path: string): Uint8Array {
       if (!entries) throw new EpubParseError('ZipReader has been closed');
-      const entry = entries[path];
+      // OPF/NCX hrefs are URLs, so they may be percent-encoded (e.g.
+      // "Character%20Profile.xhtml") while the actual zip entry name is literal.
+      // Try the raw path first, then fall back to its percent-decoded form.
+      const entry = entries[path] ?? entries[percentDecodePath(path)];
       if (!entry) {
         throw new EpubParseError(`File not found in EPUB archive: ${path}`);
       }
@@ -36,3 +39,13 @@ export function createZipReader(data: ArrayBuffer): ZipReader {
     },
   };
 }
+
+/** Percent-decode a container path, falling back to the raw path if malformed. */
+function percentDecodePath(path: string): string {
+  if (!path.includes('%')) return path;
+  try {
+    return decodeURIComponent(path);
+  } catch {
+    return path;
+  }
+}
diff --git a/packages/rito/src/parser/xhtml/xhtml-named-entities.ts b/packages/rito/src/parser/xhtml/xhtml-named-entities.ts
new file mode 100644
index 0000000..be7f56d
--- /dev/null
+++ b/packages/rito/src/parser/xhtml/xhtml-named-entities.ts
@@ -0,0 +1,258 @@
+// HTML4 named character references (the canonical 252-entry set), minus the
+// five XML-predefined entities (amp/lt/gt/quot/apos) which need no remapping.
+//
+// In `application/xhtml+xml` parsing there is no DTD, so named entities such as
+// `&copy;` or `&mdash;` are undefined and abort the parse. EPUBs in the wild use
+// them anyway, so we remap each to its numeric character reference before parsing.
+//
+// Generated from Python `html.entities.name2codepoint`. Do not edit by hand.
+export const HTML_NAMED_ENTITIES: Readonly<Record<string, number>> = {
+  AElig: 198,
+  Aacute: 193,
+  Acirc: 194,
+  Agrave: 192,
+  Alpha: 913,
+  Aring: 197,
+  Atilde: 195,
+  Auml: 196,
+  Beta: 914,
+  Ccedil: 199,
+  Chi: 935,
+  Dagger: 8225,
+  Delta: 916,
+  ETH: 208,
+  Eacute: 201,
+  Ecirc: 202,
+  Egrave: 200,
+  Epsilon: 917,
+  Eta: 919,
+  Euml: 203,
+  Gamma: 915,
+  Iacute: 205,
+  Icirc: 206,
+  Igrave: 204,
+  Iota: 921,
+  Iuml: 207,
+  Kappa: 922,
+  Lambda: 923,
+  Mu: 924,
+  Ntilde: 209,
+  Nu: 925,
+  OElig: 338,
+  Oacute: 211,
+  Ocirc: 212,
+  Ograve: 210,
+  Omega: 937,
+  Omicron: 927,
+  Oslash: 216,
+  Otilde: 213,
+  Ouml: 214,
+  Phi: 934,
+  Pi: 928,
+  Prime: 8243,
+  Psi: 936,
+  Rho: 929,
+  Scaron: 352,
+  Sigma: 931,
+  THORN: 222,
+  Tau: 932,
+  Theta: 920,
+  Uacute: 218,
+  Ucirc: 219,
+  Ugrave: 217,
+  Upsilon: 933,
+  Uuml: 220,
+  Xi: 926,
+  Yacute: 221,
+  Yuml: 376,
+  Zeta: 918,
+  aacute: 225,
+  acirc: 226,
+  acute: 180,
+  aelig: 230,
+  agrave: 224,
+  alefsym: 8501,
+  alpha: 945,
+  and: 8743,
+  ang: 8736,
+  aring: 229,
+  asymp: 8776,
+  atilde: 227,
+  auml: 228,
+  bdquo: 8222,
+  beta: 946,
+  brvbar: 166,
+  bull: 8226,
+  cap: 8745,
+  ccedil: 231,
+  cedil: 184,
+  cent: 162,
+  chi: 967,
+  circ: 710,
+  clubs: 9827,
+  cong: 8773,
+  copy: 169,
+  crarr: 8629,
+  cup: 8746,
+  curren: 164,
+  dArr: 8659,
+  dagger: 8224,
+  darr: 8595,
+  deg: 176,
+  delta: 948,
+  diams: 9830,
+  divide: 247,
+  eacute: 233,
+  ecirc: 234,
+  egrave: 232,
+  empty: 8709,
+  emsp: 8195,
+  ensp: 8194,
+  epsilon: 949,
+  equiv: 8801,
+  eta: 951,
+  eth: 240,
+  euml: 235,
+  euro: 8364,
+  exist: 8707,
+  fnof: 402,
+  forall: 8704,
+  frac12: 189,
+  frac14: 188,
+  frac34: 190,
+  frasl: 8260,
+  gamma: 947,
+  ge: 8805,
+  hArr: 8660,
+  harr: 8596,
+  hearts: 9829,
+  hellip: 8230,
+  iacute: 237,
+  icirc: 238,
+  iexcl: 161,
+  igrave: 236,
+  image: 8465,
+  infin: 8734,
+  int: 8747,
+  iota: 953,
+  iquest: 191,
+  isin: 8712,
+  iuml: 239,
+  kappa: 954,
+  lArr: 8656,
+  lambda: 955,
+  lang: 9001,
+  laquo: 171,
+  larr: 8592,
+  lceil: 8968,
+  ldquo: 8220,
+  le: 8804,
+  lfloor: 8970,
+  lowast: 8727,
+  loz: 9674,
+  lrm: 8206,
+  lsaquo: 8249,
+  lsquo: 8216,
+  macr: 175,
+  mdash: 8212,
+  micro: 181,
+  middot: 183,
+  minus: 8722,
+  mu: 956,
+  nabla: 8711,
+  nbsp: 160,
+  ndash: 8211,
+  ne: 8800,
+  ni: 8715,
+  not: 172,
+  notin: 8713,
+  nsub: 8836,
+  ntilde: 241,
+  nu: 957,
+  oacute: 243,
+  ocirc: 244,
+  oelig: 339,
+  ograve: 242,
+  oline: 8254,
+  omega: 969,
+  omicron: 959,
+  oplus: 8853,
+  or: 8744,
+  ordf: 170,
+  ordm: 186,
+  oslash: 248,
+  otilde: 245,
+  otimes: 8855,
+  ouml: 246,
+  para: 182,
+  part: 8706,
+  permil: 8240,
+  perp: 8869,
+  phi: 966,
+  pi: 960,
+  piv: 982,
+  plusmn: 177,
+  pound: 163,
+  prime: 8242,
+  prod: 8719,
+  prop: 8733,
+  psi: 968,
+  rArr: 8658,
+  radic: 8730,
+  rang: 9002,
+  raquo: 187,
+  rarr: 8594,
+  rceil: 8969,
+  rdquo: 8221,
+  real: 8476,
+  reg: 174,
+  rfloor: 8971,
+  rho: 961,
+  rlm: 8207,
+  rsaquo: 8250,
+  rsquo: 8217,
+  sbquo: 8218,
+  scaron: 353,
+  sdot: 8901,
+  sect: 167,
+  shy: 173,
+  sigma: 963,
+  sigmaf: 962,
+  sim: 8764,
+  spades: 9824,
+  sub: 8834,
+  sube: 8838,
+  sum: 8721,
+  sup: 8835,
+  sup1: 185,
+  sup2: 178,
+  sup3: 179,
+  supe: 8839,
+  szlig: 223,
+  tau: 964,
+  there4: 8756,
+  theta: 952,
+  thetasym: 977,
+  thinsp: 8201,
+  thorn: 254,
+  tilde: 732,
+  times: 215,
+  trade: 8482,
+  uArr: 8657,
+  uacute: 250,
+  uarr: 8593,
+  ucirc: 251,
+  ugrave: 249,
+  uml: 168,
+  upsih: 978,
+  upsilon: 965,
+  uuml: 252,
+  weierp: 8472,
+  xi: 958,
+  yacute: 253,
+  yen: 165,
+  yuml: 255,
+  zeta: 950,
+  zwj: 8205,
+  zwnj: 8204,
+};
diff --git a/packages/rito/src/parser/xhtml/xhtml-source-normalizer.ts b/packages/rito/src/parser/xhtml/xhtml-source-normalizer.ts
index b4aa68b..d463d83 100644
--- a/packages/rito/src/parser/xhtml/xhtml-source-normalizer.ts
+++ b/packages/rito/src/parser/xhtml/xhtml-source-normalizer.ts
@@ -1,16 +1,64 @@
+import { HTML_NAMED_ENTITIES } from './xhtml-named-entities';
+
 const XML_DECLARATION_RE = /^(\uFEFF?)<\?xml\s+([^?]*?)\?>/;
 const SINGLE_QUOTED_XML_DECLARATION_ATTRIBUTE_RE = /\b(version|encoding|standalone)='([^']*)'/g;
-const XHTML_NBSP_ENTITY_RE = /&nbsp;/g;
+
+// Matches `&` optionally followed by a numeric reference or a named token.
+// Group 1 (when present) is the entity body without the leading `&`.
+const AMPERSAND_RE = /&(#x[0-9a-fA-F]+;|#[0-9]+;|[a-zA-Z][a-zA-Z0-9]*;)?/g;
+
+// Regions where `&` is already literal and must be preserved verbatim:
+// comments and CDATA sections (common around inline <script>/<style>).
+const PRESERVED_REGION_RE = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>/g;
+
+// Entities that the XML parser understands without a DTD — left untouched.
+const XML_PREDEFINED = new Set(['amp', 'lt', 'gt', 'quot', 'apos']);
+
+// Characters XML 1.0 forbids outright (not even escapable): C0 controls except
+// TAB/LF/CR, the U+FFFE/U+FFFF noncharacters, and lone surrogates (valid astral
+// pairs are kept). They show up as junk in some EPUBs and abort the parse with
+// "PCDATA invalid Char value N".
+const ILLEGAL_XML_CHARS_RE =
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
 
 /**
  * Normalize XHTML source quirks commonly found in EPUB files before XML parsing.
  *
- * The browser DOMParser accepts more XHTML-in-the-wild than happy-dom's XML parser.
- * Keeping this layer narrow makes Node tests match browser behavior without
- * turning malformed markup into a full HTML parser path.
+ * Real EPUB chapters routinely contain markup that a strict
+ * `application/xhtml+xml` parser (browser or libxml2) rejects but that
+ * authors expect to work: raw ampersands (e.g. `Schmidt & Bender`), HTML named
+ * entities (`&copy;`, `&mdash;`, `&nbsp;`) that are undefined without a DTD, and
+ * stray control characters illegal in XML. Each aborts parsing of the whole chapter.
+ *
+ * This layer rewrites the source so such chapters parse, without turning
+ * malformed markup into a full HTML parser path:
+ *   - characters illegal in XML (and numeric refs pointing to them) are dropped
+ *   - valid numeric and XML-predefined references are preserved verbatim
+ *   - known HTML named entities are remapped to numeric character references
+ *   - every other `&` (bare, or an unknown `&name;`) is escaped to `&amp;`
+ *
+ * Comments and CDATA sections are preserved verbatim, since `&` is already
+ * literal there.
  */
 export function normalizeXhtmlSource(source: string): string {
-  return replaceXhtmlEntities(normalizeXmlDeclaration(source));
+  return normalizeAmpersandsOutsidePreserved(normalizeXmlDeclaration(stripIllegalXmlChars(source)));
+}
+
+function stripIllegalXmlChars(source: string): string {
+  return source.replace(ILLEGAL_XML_CHARS_RE, '');
+}
+
+/** Whether a Unicode code point is a legal XML 1.0 character. */
+function isValidXmlChar(codePoint: number): boolean {
+  return (
+    codePoint === 0x9 ||
+    codePoint === 0xa ||
+    codePoint === 0xd ||
+    (codePoint >= 0x20 && codePoint <= 0xd7ff) ||
+    (codePoint >= 0xe000 && codePoint <= 0xfffd) ||
+    (codePoint >= 0x10000 && codePoint <= 0x10ffff)
+  );
 }
 
 function normalizeXmlDeclaration(source: string): string {
@@ -23,6 +71,36 @@ function normalizeXmlDeclaration(source: string): string {
   });
 }
 
-function replaceXhtmlEntities(source: string): string {
-  return source.replace(XHTML_NBSP_ENTITY_RE, '&#160;');
+function normalizeAmpersandsOutsidePreserved(source: string): string {
+  let result = '';
+  let lastIndex = 0;
+  for (const match of source.matchAll(PRESERVED_REGION_RE)) {
+    const start = match.index;
+    result += normalizeAmpersands(source.slice(lastIndex, start));
+    result += match[0]; // comment / CDATA — left untouched
+    lastIndex = start + match[0].length;
+  }
+  return result + normalizeAmpersands(source.slice(lastIndex));
+}
+
+function normalizeAmpersands(source: string): string {
+  return source.replace(AMPERSAND_RE, (match, body: string | undefined) => {
+    // Bare `&` not followed by any entity-like token (e.g. `A & B`).
+    if (body === undefined) return '&amp;';
+    // Numeric character reference — keep it, but drop refs to illegal chars
+    // (e.g. `&#31;` / `&#x1F;`) that would otherwise abort the parse.
+    if (body.startsWith('#')) {
+      const hex = body[1] === 'x' || body[1] === 'X';
+      const codePoint = Number.parseInt(body.slice(hex ? 2 : 1, -1), hex ? 16 : 10);
+      return isValidXmlChar(codePoint) ? match : '';
+    }
+    // Named token: `name;` → strip the trailing `;` to look up.
+    const name = body.slice(0, -1);
+    if (XML_PREDEFINED.has(name)) return match;
+    const codePoint = HTML_NAMED_ENTITIES[name];
+    if (codePoint !== undefined) return `&#${String(codePoint)};`;
+    // Unknown named entity (e.g. `&foo;`): escape the `&` so the literal
+    // text survives instead of aborting the parse.
+    return `&amp;${body}`;
+  });
 }
diff --git a/packages/rito/src/runtime/load-epub.ts b/packages/rito/src/runtime/load-epub.ts
index e3110d5..2b8c232 100644
--- a/packages/rito/src/runtime/load-epub.ts
+++ b/packages/rito/src/runtime/load-epub.ts
@@ -27,24 +27,16 @@ export function loadEpub(data: ArrayBuffer, options?: LoadOptions): EpubDocument
   const rootfilePath = parseContainer(containerXml);
 
   const opfXml = reader.readTextFile(rootfilePath);
-  const packageDocument = parsePackageDocument(opfXml);
+  const packageDocument = parsePackageDocument(opfXml, log);
 
   const opfDir = rootfilePath.substring(0, rootfilePath.lastIndexOf('/') + 1);
-  const manifestById = new Map(packageDocument.manifest.map((item) => [item.id, item.href]));
-
-  // Build the idref → full zip path lookup for lazy chapter loading
-  const maxChapters = options?.maxChapters ?? Infinity;
-  const chapterPaths = new Map<string, string>();
-  let count = 0;
-  for (const spineItem of packageDocument.spine) {
-    if (count >= maxChapters) break;
-    const href = manifestById.get(spineItem.idref);
-    if (!href) continue;
-    chapterPaths.set(spineItem.idref, opfDir + href);
-    count++;
-  }
-
-  const { stylesheets, fonts, images } = loadManifestResources(packageDocument, reader, opfDir);
+  const chapterPaths = buildChapterPaths(packageDocument, opfDir, options?.maxChapters ?? Infinity);
+  const { stylesheets, fonts, images } = loadManifestResources(
+    packageDocument,
+    reader,
+    opfDir,
+    log,
+  );
 
   const toc = loadToc(reader, packageDocument, opfDir, log);
   log.info('EPUB loaded: %d spine items, %d stylesheets', chapterPaths.size, stylesheets.size);
@@ -66,6 +58,25 @@ export function loadEpub(data: ArrayBuffer, options?: LoadOptions): EpubDocument
   };
 }
 
+/** Build the idref → full zip path lookup used for lazy chapter loading. */
+function buildChapterPaths(
+  pkg: PackageDocument,
+  opfDir: string,
+  maxChapters: number,
+): Map<string, string> {
+  const manifestById = new Map(pkg.manifest.map((item) => [item.id, item.href]));
+  const chapterPaths = new Map<string, string>();
+  let count = 0;
+  for (const spineItem of pkg.spine) {
+    if (count >= maxChapters) break;
+    const href = manifestById.get(spineItem.idref);
+    if (!href) continue;
+    chapterPaths.set(spineItem.idref, opfDir + href);
+    count++;
+  }
+  return chapterPaths;
+}
+
 const FONT_MEDIA_TYPES = new Set([
   'font/ttf',
   'font/otf',
@@ -79,10 +90,13 @@ const FONT_MEDIA_TYPES = new Set([
   'application/font-sfnt',
 ]);
 
+const IMAGE_EXTENSIONS_RE = /\.(jpe?g|png|gif|webp|avif|bmp|svg|tiff?|ico)$/i;
+
 function loadManifestResources(
   pkg: PackageDocument,
   reader: ZipReader,
   opfDir: string,
+  log: Logger,
 ): {
   stylesheets: Map<string, string>;
   fonts: Map<string, Uint8Array>;
@@ -93,12 +107,31 @@ function loadManifestResources(
   const images = new Map<string, Uint8Array>();
 
   for (const item of pkg.manifest) {
-    if (item.mediaType === 'text/css') {
-      stylesheets.set(item.href, reader.readTextFile(opfDir + item.href));
-    } else if (FONT_MEDIA_TYPES.has(item.mediaType)) {
-      fonts.set(item.href, reader.readFile(opfDir + item.href));
-    } else if (item.mediaType.startsWith('image/')) {
-      images.set(item.href, reader.readFile(opfDir + item.href));
+    // A single missing/mislabeled manifest entry must not abort the whole load.
+    try {
+      if (item.mediaType === 'text/css') {
+        stylesheets.set(item.href, reader.readTextFile(opfDir + item.href));
+      } else if (FONT_MEDIA_TYPES.has(item.mediaType)) {
+        fonts.set(item.href, reader.readFile(opfDir + item.href));
+      } else if (item.mediaType.startsWith('image/')) {
+        images.set(item.href, reader.readFile(opfDir + item.href));
+      }
+    } catch (e) {
+      log.warn('Skipping unreadable manifest resource %s: %s', item.href, e);
+    }
+  }
+
+  // Some EPUBs (especially older ones) reference images that are absent from the
+  // manifest. Index every image file in the archive so undeclared illustrations
+  // still resolve. Keyed opfDir-relative to match the resolver's href matching.
+  for (const fullPath of reader.listFiles()) {
+    if (!IMAGE_EXTENSIONS_RE.test(fullPath)) continue;
+    const key = fullPath.startsWith(opfDir) ? fullPath.slice(opfDir.length) : fullPath;
+    if (images.has(key)) continue;
+    try {
+      images.set(key, reader.readFile(fullPath));
+    } catch (e) {
+      log.warn('Failed to read archive image %s: %s', fullPath, e);
     }
   }
 
diff --git a/packages/rito/src/utils/resolve-href.ts b/packages/rito/src/utils/resolve-href.ts
index 6e3ad70..50dfb8b 100644
--- a/packages/rito/src/utils/resolve-href.ts
+++ b/packages/rito/src/utils/resolve-href.ts
@@ -40,6 +40,16 @@ function stripRelativePrefix(src: string): string {
   return normalized;
 }
 
+/** Percent-decode an href, falling back to the raw value if malformed. */
+function percentDecode(src: string): string {
+  if (!src.includes('%')) return src;
+  try {
+    return decodeURIComponent(src);
+  } catch {
+    return src;
+  }
+}
+
 /**
  * Build a lookup function that resolves an EPUB-internal src reference
  * (e.g., `../Images/cover.jpg`) against a map keyed by manifest hrefs
@@ -53,42 +63,54 @@ function stripRelativePrefix(src: string): string {
 export function buildHrefResolver<T>(
   resources: ReadonlyMap<string, T>,
 ): (src: string) => T | undefined {
-  const { byHref, bySuffix, byBasename } = buildHrefIndex(resources);
+  const index = buildHrefIndex(resources);
 
   return (src: string): T | undefined => {
-    // 1. Exact match
-    const exact = byHref.get(src);
-    if (exact !== undefined) return exact;
+    // Try the raw src first, then a percent-decoded form. EPUB hrefs are URLs,
+    // so `Images/My%20Pic.jpg` must resolve to a literal `Images/My Pic.jpg` key.
+    const direct = resolveAgainstIndex(index, src);
+    if (direct !== undefined) return direct;
+    const decoded = percentDecode(src);
+    return decoded === src ? undefined : resolveAgainstIndex(index, decoded);
+  };
+}
 
-    // 2. Suffix match via pre-built maps.
-    const normalized = stripRelativePrefix(src);
+function resolveAgainstIndex<T>(
+  { byHref, bySuffix, byBasename }: HrefIndex<T>,
+  src: string,
+): T | undefined {
+  // 1. Exact match
+  const exact = byHref.get(src);
+  if (exact !== undefined) return exact;
 
-    // Check normalized src in suffix map: handles href.endsWith(src) case.
-    const suffixDirect = bySuffix.get(normalized);
-    if (suffixDirect !== undefined && suffixDirect !== null) return suffixDirect;
+  // 2. Suffix match via pre-built maps.
+  const normalized = stripRelativePrefix(src);
 
-    // Check if stripping ../ yields an exact href match.
-    if (normalized !== src) {
-      const afterStrip = byHref.get(normalized);
-      if (afterStrip !== undefined) return afterStrip;
-    }
+  // Check normalized src in suffix map: handles href.endsWith(src) case.
+  const suffixDirect = bySuffix.get(normalized);
+  if (suffixDirect !== undefined && suffixDirect !== null) return suffixDirect;
 
-    // Check path suffixes of normalized src against exact hrefs:
-    // handles src.endsWith(href) case.
-    const srcParts = normalized.split('/');
-    for (let i = 1; i < srcParts.length; i++) {
-      const srcSuffix = srcParts.slice(i).join('/');
-      const hrefMatch = byHref.get(srcSuffix);
-      if (hrefMatch !== undefined) return hrefMatch;
-    }
+  // Check if stripping ../ yields an exact href match.
+  if (normalized !== src) {
+    const afterStrip = byHref.get(normalized);
+    if (afterStrip !== undefined) return afterStrip;
+  }
 
-    // 3. Basename match (only if unambiguous)
-    const srcBasename = srcParts[srcParts.length - 1];
-    if (srcBasename) {
-      const match = byBasename.get(srcBasename);
-      if (match !== undefined && match !== null) return match;
-    }
+  // Check path suffixes of normalized src against exact hrefs:
+  // handles src.endsWith(href) case.
+  const srcParts = normalized.split('/');
+  for (let i = 1; i < srcParts.length; i++) {
+    const srcSuffix = srcParts.slice(i).join('/');
+    const hrefMatch = byHref.get(srcSuffix);
+    if (hrefMatch !== undefined) return hrefMatch;
+  }
 
-    return undefined;
-  };
+  // 3. Basename match (only if unambiguous)
+  const srcBasename = srcParts[srcParts.length - 1];
+  if (srcBasename) {
+    const match = byBasename.get(srcBasename);
+    if (match !== undefined && match !== null) return match;
+  }
+
+  return undefined;
 }
diff --git a/packages/rito/tests/unit/load-epub.test.ts b/packages/rito/tests/unit/load-epub.test.ts
index caa0785..f1326a1 100644
--- a/packages/rito/tests/unit/load-epub.test.ts
+++ b/packages/rito/tests/unit/load-epub.test.ts
@@ -1,7 +1,38 @@
 // @vitest-environment happy-dom
 import { describe, expect, it } from 'vitest';
+import { zipSync, strToU8 } from 'fflate';
 import { loadEpub } from '../../src/runtime/load-epub';
 import { buildMinimalEpub } from '../helpers/epub-builder';
+import { buildHrefResolver } from '../../src/utils/resolve-href';
+
+/** Build an EPUB whose archive contains an image that is NOT in the manifest. */
+function epubWithUndeclaredImage(): ArrayBuffer {
+  const opf = `<?xml version="1.0" encoding="UTF-8"?>
+<package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="uid">
+  <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
+    <dc:title>Undeclared</dc:title><dc:language>en</dc:language>
+    <dc:identifier id="uid">urn:uuid:x</dc:identifier>
+  </metadata>
+  <manifest>
+    <item id="ch1" href="ch1.xhtml" media-type="application/xhtml+xml"/>
+    <item id="cover" href="images/cover.jpg" media-type="image/jpeg"/>
+  </manifest>
+  <spine><itemref idref="ch1"/></spine>
+</package>`;
+  const container = `<?xml version="1.0"?>
+<container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
+  <rootfiles><rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/></rootfiles>
+</container>`;
+  const zip = zipSync({
+    mimetype: strToU8('application/epub+zip'),
+    'META-INF/container.xml': strToU8(container),
+    'OEBPS/content.opf': strToU8(opf),
+    'OEBPS/ch1.xhtml': strToU8('<html><body><img src="images/illus1.jpg"/></body></html>'),
+    'OEBPS/images/cover.jpg': new Uint8Array([0xff, 0xd8, 0xff, 1]),
+    'OEBPS/images/illus1.jpg': new Uint8Array([0xff, 0xd8, 0xff, 2]), // not in manifest
+  });
+  return zip.buffer as ArrayBuffer;
+}
 
 describe('loadEpub', () => {
   it('loads a minimal EPUB and returns an EpubDocument', () => {
@@ -93,4 +124,15 @@ describe('loadEpub', () => {
       doc.close();
     }).not.toThrow();
   });
+
+  it('indexes images present in the archive but absent from the manifest', () => {
+    // Spec-violating books reference illustrations not declared in the manifest;
+    // those must still be loaded so they are not rendered as broken images.
+    const doc = loadEpub(epubWithUndeclaredImage());
+    const resolve = buildHrefResolver(doc.images);
+
+    expect(resolve('images/cover.jpg')).toBeDefined(); // declared
+    expect(resolve('images/illus1.jpg')).toBeDefined(); // undeclared, still indexed
+    expect(doc.images.get('images/illus1.jpg')).toEqual(new Uint8Array([0xff, 0xd8, 0xff, 2]));
+  });
 });
diff --git a/packages/rito/tests/unit/package-parser.test.ts b/packages/rito/tests/unit/package-parser.test.ts
index e91ecfc..0013586 100644
--- a/packages/rito/tests/unit/package-parser.test.ts
+++ b/packages/rito/tests/unit/package-parser.test.ts
@@ -44,19 +44,30 @@ describe('parsePackageDocument', () => {
       expect(pkg.metadata).not.toHaveProperty('creator');
     });
 
-    it('throws on missing title', () => {
+    it('defaults missing title to empty string instead of throwing', () => {
       const opf = VALID_OPF.replace('<dc:title>Test Book</dc:title>', '');
-      expect(() => parsePackageDocument(opf)).toThrow('dc:title');
+      const pkg = parsePackageDocument(opf);
+      expect(pkg.metadata.title).toBe('');
     });
 
-    it('throws on missing language', () => {
+    it('defaults missing language to empty string instead of throwing', () => {
       const opf = VALID_OPF.replace('<dc:language>en</dc:language>', '');
-      expect(() => parsePackageDocument(opf)).toThrow('dc:language');
+      const pkg = parsePackageDocument(opf);
+      expect(pkg.metadata.language).toBe('');
     });
 
-    it('throws on missing identifier', () => {
+    it('defaults missing identifier to empty string instead of throwing', () => {
       const opf = VALID_OPF.replace('<dc:identifier id="uid">urn:uuid:1234</dc:identifier>', '');
-      expect(() => parsePackageDocument(opf)).toThrow('dc:identifier');
+      const pkg = parsePackageDocument(opf);
+      expect(pkg.metadata.identifier).toBe('');
+    });
+
+    it('loads a spec-violating book missing all required metadata', () => {
+      const opf = VALID_OPF.replace(/<metadata[\s\S]*?<\/metadata>/, '<metadata></metadata>');
+      const pkg = parsePackageDocument(opf);
+      expect(pkg.metadata).toEqual({ title: '', language: '', identifier: '' });
+      expect(pkg.manifest.length).toBeGreaterThan(0);
+      expect(pkg.spine.length).toBeGreaterThan(0);
     });
   });
 
diff --git a/packages/rito/tests/unit/resolve-href.test.ts b/packages/rito/tests/unit/resolve-href.test.ts
index 911a09f..6c94e85 100644
--- a/packages/rito/tests/unit/resolve-href.test.ts
+++ b/packages/rito/tests/unit/resolve-href.test.ts
@@ -57,4 +57,12 @@ describe('buildHrefResolver', () => {
 
     expect(resolve('Images/cover.jpg')).toBe('blob:exact');
   });
+
+  it('resolves a percent-encoded src to a literal key', () => {
+    const resources = new Map([['Images/My Pic.jpg', 'blob:pic']]);
+    const resolve = buildHrefResolver(resources);
+
+    expect(resolve('Images/My%20Pic.jpg')).toBe('blob:pic');
+    expect(resolve('../Images/My%20Pic.jpg')).toBe('blob:pic');
+  });
 });
diff --git a/packages/rito/tests/unit/xhtml-parser.test.ts b/packages/rito/tests/unit/xhtml-parser.test.ts
index 01d447c..840bab0 100644
--- a/packages/rito/tests/unit/xhtml-parser.test.ts
+++ b/packages/rito/tests/unit/xhtml-parser.test.ts
@@ -1,6 +1,7 @@
 // @vitest-environment happy-dom
 import { describe, expect, it } from 'vitest';
 import { parseXhtml } from '../../src/parser/xhtml/xhtml-parser';
+import { normalizeXhtmlSource } from '../../src/parser/xhtml/xhtml-source-normalizer';
 import { XhtmlParseError } from '../../src/parser/xhtml/errors';
 import type { BlockNode, InlineNode, TextNode } from '../../src/parser/xhtml/types';
 
@@ -63,6 +64,97 @@ describe('parseXhtml', () => {
       const p = nodes[0] as BlockNode;
       expect((p.children[0] as TextNode).content).toBe('Hello\u00A0world');
     });
+
+    it('keeps a raw ampersand as literal text instead of aborting the parse', () => {
+      // Regression: real EPUB chapters contain unescaped `&` (e.g. "Schmidt & Bender").
+      // A strict application/xhtml+xml parser otherwise fails with "EntityRef: expecting ';'".
+      const { nodes } = parseXhtml(
+        xhtml('<p>\u65BD\u5BC6\u7279&\u73ED\u7279\u578B\u7784\u51C6\u955C</p>'),
+      );
+
+      const p = nodes[0] as BlockNode;
+      expect((p.children[0] as TextNode).content).toBe(
+        '\u65BD\u5BC6\u7279&\u73ED\u7279\u578B\u7784\u51C6\u955C',
+      );
+    });
+
+    it('preserves a raw ampersand inside an attribute value', () => {
+      const { nodes } = parseXhtml(xhtml('<p><a href="page?a=1&b=2">link</a></p>'));
+
+      const a = (nodes[0] as BlockNode).children[0] as InlineNode;
+      expect(a.tag).toBe('a');
+      expect(a.attributes?.href).toBe('page?a=1&b=2');
+    });
+
+    it('remaps HTML named entities undefined in XML to their characters', () => {
+      const { nodes } = parseXhtml(xhtml('<p>A&copy;B&mdash;C&hellip;D&rsquo;E</p>'));
+
+      const p = nodes[0] as BlockNode;
+      expect((p.children[0] as TextNode).content).toBe('A\u00A9B\u2014C\u2026D\u2019E');
+    });
+
+    it('preserves valid numeric character references', () => {
+      const { nodes } = parseXhtml(xhtml('<p>&#160;&#x40;&#8212;</p>'));
+
+      const p = nodes[0] as BlockNode;
+      expect((p.children[0] as TextNode).content).toBe('\u00A0@\u2014');
+    });
+
+    it('escapes an unknown named entity to literal text', () => {
+      const { nodes } = parseXhtml(xhtml('<p>x&notarealentity;y</p>'));
+
+      const p = nodes[0] as BlockNode;
+      expect((p.children[0] as TextNode).content).toBe('x&notarealentity;y');
+    });
+  });
+
+  // Source normalization is a pure string transform applied before XML parsing.
+  // CDATA/comment preservation is asserted here rather than through parseXhtml
+  // because happy-dom's XML parser (unlike real browsers / libxml2) rejects CDATA.
+  describe('source normalization', () => {
+    it('escapes a raw ampersand to a valid entity', () => {
+      expect(normalizeXhtmlSource('<p>a & b</p>')).toBe('<p>a &amp; b</p>');
+    });
+
+    it('remaps known HTML named entities to numeric references', () => {
+      expect(normalizeXhtmlSource('<p>&copy;&mdash;&nbsp;</p>')).toBe('<p>&#169;&#8212;&#160;</p>');
+    });
+
+    it('preserves valid numeric and XML-predefined references', () => {
+      expect(normalizeXhtmlSource('<p>&#160;&#x40;&amp;&lt;&gt;</p>')).toBe(
+        '<p>&#160;&#x40;&amp;&lt;&gt;</p>',
+      );
+    });
+
+    it('escapes an unknown named entity', () => {
+      expect(normalizeXhtmlSource('<p>&bogus;</p>')).toBe('<p>&amp;bogus;</p>');
+    });
+
+    it('leaves ampersands inside comments untouched', () => {
+      expect(normalizeXhtmlSource('<!-- a && b & c --><p>x & y</p>')).toBe(
+        '<!-- a && b & c --><p>x &amp; y</p>',
+      );
+    });
+
+    it('leaves ampersands inside CDATA sections untouched', () => {
+      expect(normalizeXhtmlSource('<p>x & y<![CDATA[ a && b & c ]]>z & w</p>')).toBe(
+        '<p>x &amp; y<![CDATA[ a && b & c ]]>z &amp; w</p>',
+      );
+    });
+
+    it('strips control characters illegal in XML, keeping TAB/LF/CR', () => {
+      // U+001F (Unit Separator) is illegal PCDATA; tab/newline/CR are legal.
+      const input = '<p>“\u001F? ok”\tline\nbreak\r</p>';
+      expect(normalizeXhtmlSource(input)).toBe('<p>“? ok”\tline\nbreak\r</p>');
+    });
+
+    it('preserves valid astral characters (surrogate pairs)', () => {
+      expect(normalizeXhtmlSource('<p>emoji 😀 漢字</p>')).toBe('<p>emoji 😀 漢字</p>');
+    });
+
+    it('drops numeric references that point to illegal characters', () => {
+      expect(normalizeXhtmlSource('<p>a&#31;b&#x1F;c&#0;d</p>')).toBe('<p>abcd</p>');
+    });
   });
 
   describe('inline elements', () => {
diff --git a/packages/rito/tests/unit/zip-reader.test.ts b/packages/rito/tests/unit/zip-reader.test.ts
index 3bed4d3..c5dbd2d 100644
--- a/packages/rito/tests/unit/zip-reader.test.ts
+++ b/packages/rito/tests/unit/zip-reader.test.ts
@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest';
+import { zipSync } from 'fflate';
 import { createZipReader } from '../../src/parser/epub/zip-reader';
 import { buildMinimalEpub } from '../helpers/epub-builder';
 
@@ -38,6 +39,28 @@ describe('createZipReader', () => {
     expect(() => reader.readFile('nonexistent.xml')).toThrow('File not found in EPUB archive');
   });
 
+  it('resolves a percent-encoded href to its literal entry name', () => {
+    // Real EPUBs (e.g. some Sigil exports) reference "Character%20Profile.xhtml"
+    // while the actual zip entry name contains a literal space.
+    const zip = zipSync({
+      'OEBPS/Text/Character Profile.xhtml': new TextEncoder().encode('<p>hi</p>'),
+    });
+    const reader = createZipReader(zip.buffer as ArrayBuffer);
+
+    expect(reader.readTextFile('OEBPS/Text/Character%20Profile.xhtml')).toBe('<p>hi</p>');
+    // a literal path still resolves directly
+    expect(reader.readTextFile('OEBPS/Text/Character Profile.xhtml')).toBe('<p>hi</p>');
+  });
+
+  it('still throws for a percent-encoded path with no matching entry', () => {
+    const zip = zipSync({ 'OEBPS/a.xhtml': new TextEncoder().encode('x') });
+    const reader = createZipReader(zip.buffer as ArrayBuffer);
+
+    expect(() => reader.readFile('OEBPS/missing%20file.xhtml')).toThrow(
+      'File not found in EPUB archive',
+    );
+  });
+
   it('rejects data that is too small', () => {
     const tiny = new ArrayBuffer(2);
     expect(() => createZipReader(tiny)).toThrow('Data too small');