@likecoin/epubcheck-ts 0.3.7 → 0.3.9

package/dist/index.js

@@ -1602,31 +1602,276 @@ var CSSValidator = class {
    * Check for reserved media overlay class names
    */
   checkMediaOverlayClasses(context, ast, resourcePath) {
-    const reservedClassNames = /* @__PURE__ */ new Set([
-      "-epub-media-overlay-active",
-      "media-overlay-active",
-      "-epub-media-overlay-playing",
-      "media-overlay-playing"
-    ]);
+    const activeClassNames = /* @__PURE__ */ new Set(["-epub-media-overlay-active", "media-overlay-active"]);
+    const playbackClassNames = /* @__PURE__ */ new Set(["-epub-media-overlay-playing", "media-overlay-playing"]);
     walk(ast, (node) => {
       if (node.type === "ClassSelector") {
         const className = node.name.toLowerCase();
-        if (reservedClassNames.has(className)) {
-          const loc = node.loc;
-          const start = loc?.start;
-          const location = { path: resourcePath };
-          if (start) {
-            location.line = start.line;
-            location.column = start.column;
-          }
+        const isActive = activeClassNames.has(className);
+        const isPlayback = playbackClassNames.has(className);
+        if (!isActive && !isPlayback) return;
+        const isDeclared = isActive ? !!context.mediaActiveClass : !!context.mediaPlaybackActiveClass;
+        if (isDeclared) return;
+        const loc = node.loc;
+        const start = loc?.start;
+        const location = { path: resourcePath };
+        if (start) {
+          location.line = start.line;
+          location.column = start.column;
+        }
+        const property = isActive ? "media:active-class" : "media:playback-active-class";
+        pushMessage(context.messages, {
+          id: MessageId.CSS_029,
+          message: `Class name "${className}" is reserved for media overlays but "${property}" is not declared in the package document`,
+          location
+        });
+      }
+    });
+  }
+};
+
+// src/smil/clock.ts
+var FULL_CLOCK_RE = /^(\d+):([0-5]\d):([0-5]\d)(\.\d+)?$/;
+var PARTIAL_CLOCK_RE = /^([0-5]\d):([0-5]\d)(\.\d+)?$/;
+var TIMECOUNT_RE = /^(\d+(\.\d+)?)(h|min|s|ms)?$/;
+function parseSmilClock(value) {
+  const trimmed = value.trim();
+  const full = FULL_CLOCK_RE.exec(trimmed);
+  if (full) {
+    const hours = Number.parseInt(full[1] ?? "0", 10);
+    const minutes = Number.parseInt(full[2] ?? "0", 10);
+    const seconds = Number.parseInt(full[3] ?? "0", 10);
+    const frac = full[4] ? Number.parseFloat(full[4]) : 0;
+    return hours * 3600 + minutes * 60 + seconds + frac;
+  }
+  const partial = PARTIAL_CLOCK_RE.exec(trimmed);
+  if (partial) {
+    const minutes = Number.parseInt(partial[1] ?? "0", 10);
+    const seconds = Number.parseInt(partial[2] ?? "0", 10);
+    const frac = partial[3] ? Number.parseFloat(partial[3]) : 0;
+    return minutes * 60 + seconds + frac;
+  }
+  const timecount = TIMECOUNT_RE.exec(trimmed);
+  if (timecount) {
+    const num = Number.parseFloat(timecount[1] ?? "0");
+    const unit = timecount[3] ?? "s";
+    switch (unit) {
+      case "h":
+        return num * 3600;
+      case "min":
+        return num * 60;
+      case "s":
+        return num;
+      case "ms":
+        return num / 1e3;
+      default:
+        return NaN;
+    }
+  }
+  return NaN;
+}
+function isValidSmilClock(value) {
+  return !Number.isNaN(parseSmilClock(value));
+}
+
+// src/smil/validator.ts
+var SMIL_NS = { smil: "http://www.w3.org/ns/SMIL" };
+var BLESSED_AUDIO_TYPES = /* @__PURE__ */ new Set(["audio/mpeg", "audio/mp4"]);
+var BLESSED_AUDIO_PATTERN = /^audio\/ogg\s*;\s*codecs=opus$/i;
+function isBlessedAudioType(mimeType) {
+  return BLESSED_AUDIO_TYPES.has(mimeType) || BLESSED_AUDIO_PATTERN.test(mimeType);
+}
+var SMILValidator = class {
+  getAttribute(element, name) {
+    return element.attr(name)?.value ?? null;
+  }
+  getEpubAttribute(element, localName) {
+    return element.attr(localName, "epub")?.value ?? null;
+  }
+  validate(context, path, manifestByPath) {
+    const result = {
+      textReferences: [],
+      referencedDocuments: /* @__PURE__ */ new Set(),
+      hasRemoteResources: false
+    };
+    const data = context.files.get(path);
+    if (!data) return result;
+    const content = typeof data === "string" ? data : new TextDecoder().decode(data);
+    let doc = null;
+    try {
+      doc = XmlDocument.fromString(content);
+    } catch {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_016,
+        message: "Media Overlay document is not well-formed XML",
+        location: { path }
+      });
+      return result;
+    }
+    try {
+      const root = doc.root;
+      this.validateStructure(context, path, root);
+      this.validateAudioElements(context, path, root, manifestByPath, result);
+      this.extractTextReferences(path, root, result);
+    } finally {
+      doc.dispose();
+    }
+    return result;
+  }
+  validateStructure(context, path, root) {
+    try {
+      for (const text of root.find(".//smil:seq/smil:text", SMIL_NS)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "element 'text' not allowed here; expected 'seq' or 'par'",
+          location: { path, line: text.line }
+        });
+      }
+      for (const audio of root.find(".//smil:seq/smil:audio", SMIL_NS)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "element 'audio' not allowed here; expected 'seq' or 'par'",
+          location: { path, line: audio.line }
+        });
+      }
+    } catch {
+    }
+    try {
+      for (const seq of root.find(".//smil:par/smil:seq", SMIL_NS)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "element 'seq' not allowed here; expected 'text' or 'audio'",
+          location: { path, line: seq.line }
+        });
+      }
+      const parElements = root.find(".//smil:par", SMIL_NS);
+      for (const par of parElements) {
+        const textChildren = par.find("./smil:text", SMIL_NS);
+        for (let i = 1; i < textChildren.length; i++) {
+          const extra = textChildren[i];
+          if (!extra) continue;
           pushMessage(context.messages, {
-            id: MessageId.CSS_029,
-            message: `Class name "${className}" is reserved for media overlays`,
-            location
+            id: MessageId.RSC_005,
+            message: "element 'text' not allowed here; only one 'text' element is allowed in 'par'",
+            location: { path, line: extra.line }
           });
         }
       }
-    });
+    } catch {
+    }
+    try {
+      const headMetaElements = root.find(".//smil:head/smil:meta", SMIL_NS);
+      for (const meta of headMetaElements) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "element 'meta' not allowed here; expected 'metadata'",
+          location: { path, line: meta.line }
+        });
+      }
+    } catch {
+    }
+  }
+  validateAudioElements(context, path, root, manifestByPath, result) {
+    try {
+      const audioElements = root.find(".//smil:audio", SMIL_NS);
+      for (const audio of audioElements) {
+        const elem = audio;
+        const src = this.getAttribute(elem, "src");
+        if (src) {
+          if (/^https?:\/\//i.test(src)) {
+            result.hasRemoteResources = true;
+          }
+          if (src.includes("#")) {
+            pushMessage(context.messages, {
+              id: MessageId.MED_014,
+              message: `Media overlay audio file URLs must not have a fragment: "${src}"`,
+              location: { path, line: audio.line }
+            });
+          }
+          if (manifestByPath) {
+            const audioPath = this.resolveRelativePath(path, src.split("#")[0] ?? src);
+            const audioItem = manifestByPath.get(audioPath);
+            if (audioItem && !isBlessedAudioType(audioItem.mediaType)) {
+              pushMessage(context.messages, {
+                id: MessageId.MED_005,
+                message: `Media Overlay audio reference "${src}" to non-standard audio type "${audioItem.mediaType}"`,
+                location: { path, line: audio.line }
+              });
+            }
+          }
+        }
+        const clipBegin = this.getAttribute(elem, "clipBegin");
+        const clipEnd = this.getAttribute(elem, "clipEnd");
+        this.checkClipTiming(context, path, audio.line, clipBegin, clipEnd);
+      }
+    } catch {
+    }
+  }
+  checkClipTiming(context, path, line, clipBegin, clipEnd) {
+    if (clipEnd === null) return;
+    const beginStr = clipBegin ?? "0";
+    const start = parseSmilClock(beginStr);
+    const end = parseSmilClock(clipEnd);
+    if (Number.isNaN(start) || Number.isNaN(end)) return;
+    const location = line != null ? { path, line } : { path };
+    if (start > end) {
+      pushMessage(context.messages, {
+        id: MessageId.MED_008,
+        message: "The time specified in the clipBegin attribute must not be after clipEnd",
+        location
+      });
+    } else if (start === end) {
+      pushMessage(context.messages, {
+        id: MessageId.MED_009,
+        message: "The time specified in the clipBegin attribute must not be the same as clipEnd",
+        location
+      });
+    }
+  }
+  extractTextReferences(path, root, result) {
+    try {
+      const textElements = root.find(".//smil:text", SMIL_NS);
+      for (const text of textElements) {
+        const src = this.getAttribute(text, "src");
+        if (!src) continue;
+        const hashIndex = src.indexOf("#");
+        const docRef = hashIndex >= 0 ? src.substring(0, hashIndex) : src;
+        const fragment = hashIndex >= 0 ? src.substring(hashIndex + 1) : void 0;
+        const docPath = this.resolveRelativePath(path, docRef);
+        result.textReferences.push({ docPath, fragment, line: text.line });
+        result.referencedDocuments.add(docPath);
+      }
+      const bodyElements = root.find(".//smil:body", SMIL_NS);
+      const seqElements = root.find(".//smil:seq", SMIL_NS);
+      for (const elem of [...bodyElements, ...seqElements]) {
+        const textref = this.getEpubAttribute(elem, "textref");
+        if (!textref) continue;
+        const hashIndex = textref.indexOf("#");
+        const docRef = hashIndex >= 0 ? textref.substring(0, hashIndex) : textref;
+        const fragment = hashIndex >= 0 ? textref.substring(hashIndex + 1) : void 0;
+        const docPath = this.resolveRelativePath(path, docRef);
+        result.textReferences.push({ docPath, fragment, line: elem.line });
+        result.referencedDocuments.add(docPath);
+      }
+    } catch {
+    }
+  }
+  resolveRelativePath(basePath, relativePath) {
+    if (relativePath.startsWith("/") || /^[a-zA-Z]+:/.test(relativePath)) {
+      return relativePath;
+    }
+    const baseDir = basePath.includes("/") ? basePath.substring(0, basePath.lastIndexOf("/")) : "";
+    if (!baseDir) return relativePath;
+    const segments = `${baseDir}/${relativePath}`.split("/");
+    const resolved = [];
+    for (const seg of segments) {
+      if (seg === "..") {
+        resolved.pop();
+      } else if (seg !== ".") {
+        resolved.push(seg);
+      }
+    }
+    return resolved.join("/");
   }
 };
 
@@ -1702,7 +1947,12 @@ var SPINE_PROPERTIES = /* @__PURE__ */ new Set([
   "rendition:layout-pre-paginated",
   "rendition:orientation-auto",
   "rendition:orientation-landscape",
-  "rendition:orientation-portrait"
+  "rendition:orientation-portrait",
+  "rendition:flow-auto",
+  "rendition:flow-paginated",
+  "rendition:flow-scrolled-continuous",
+  "rendition:flow-scrolled-doc",
+  "rendition:align-x-center"
 ]);
 
 // src/references/types.ts
@@ -1723,6 +1973,89 @@ function isPublicationResourceReference(type) {
   return PUBLICATION_RESOURCE_TYPES.has(type);
 }
 
+// src/references/uri-schemes.ts
+var URI_SCHEMES = /* @__PURE__ */ new Set([
+  "aaa",
+  "aaas",
+  "acap",
+  "afs",
+  "cap",
+  "cid",
+  "crid",
+  "data",
+  "dav",
+  "dict",
+  "dns",
+  "dtn",
+  "fax",
+  "file",
+  "ftp",
+  "go",
+  "gopher",
+  "h323",
+  "http",
+  "https",
+  "iax",
+  "icap",
+  "im",
+  "imap",
+  "info",
+  "ipp",
+  "irc",
+  "iris",
+  "iris.beep",
+  "iris.lwz",
+  "iris.xpc",
+  "iris.xpcs",
+  "javascript",
+  "ldap",
+  "mailto",
+  "mailserver",
+  "mid",
+  "modem",
+  "msrp",
+  "msrps",
+  "mtqp",
+  "mupdate",
+  "news",
+  "nfs",
+  "nntp",
+  "opaquelocktoken",
+  "pack",
+  "pop",
+  "pres",
+  "prospero",
+  "rtsp",
+  "service",
+  "shttp",
+  "sip",
+  "sips",
+  "snews",
+  "snmp",
+  "soap.beep",
+  "soap.beeps",
+  "tag",
+  "tel",
+  "telnet",
+  "tftp",
+  "thismessage",
+  "tip",
+  "tn3270",
+  "tv",
+  "urn",
+  "vemmi",
+  "videotex",
+  "wais",
+  "xmlrpc.beep",
+  "xmlrpc.beeps",
+  "xmpp",
+  "z39.50r",
+  "z39.50s"
+]);
+function isRegisteredScheme(scheme) {
+  return URI_SCHEMES.has(scheme.toLowerCase());
+}
+
 // src/references/url.ts
 function parseURL(urlString) {
   const hashIndex = urlString.indexOf("#");
@@ -1758,15 +2091,9 @@ function hasParentDirectoryReference(url) {
   return url.includes("..");
 }
 function isMalformedURL(url) {
-  if (!url) return true;
-  try {
-    const trimmed = url.trim();
-    if (!trimmed) return true;
-    if (/[\s<>]/.test(trimmed)) return true;
-    return false;
-  } catch {
-    return true;
-  }
+  if (!url.trim()) return true;
+  if (/[\s<>]/.test(url)) return true;
+  return false;
 }
 function isHTTPS(url) {
   return url.startsWith("https://");
@@ -1803,6 +2130,38 @@ function resolveManifestHref(opfDir, href) {
 // src/content/validator.ts
 var DISCOURAGED_ELEMENTS = /* @__PURE__ */ new Set(["base", "embed", "rp"]);
 var ABSOLUTE_URI_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+var SPECIAL_URL_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "ftp", "ws", "wss"]);
+var CSS_CHARSET_RE = /^@charset\s+"([^"]+)"\s*;/;
+var EPUB_XMLNS_RE = /xmlns:epub\s*=\s*"([^"]*)"/;
+var XHTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+var EPUB_TYPE_FORBIDDEN_ELEMENTS = /* @__PURE__ */ new Set([
+  "head",
+  "meta",
+  "title",
+  "style",
+  "link",
+  "script",
+  "noscript",
+  "base"
+]);
+function validateAbsoluteHyperlinkURL(context, href, path, line) {
+  const location = line != null ? { path, line } : { path };
+  const scheme = href.slice(0, href.indexOf(":")).toLowerCase();
+  if (!isRegisteredScheme(scheme)) {
+    pushMessage(context.messages, {
+      id: MessageId.HTM_025,
+      message: "Hyperlink uses non-registered URI scheme type",
+      location
+    });
+  }
+  if (/[\s<>]/.test(href) || SPECIAL_URL_SCHEMES.has(scheme) && !href.slice(href.indexOf(":")).startsWith("://")) {
+    pushMessage(context.messages, {
+      id: MessageId.RSC_020,
+      message: `URL is not valid: "${href}"`,
+      location
+    });
+  }
+}
 var IMAGE_MAGIC = [
   { mime: "image/jpeg", bytes: [255, 216], extensions: [".jpg", ".jpeg", ".jpe"] },
   { mime: "image/gif", bytes: [71, 73, 70, 56], extensions: [".gif"] },
@@ -2077,6 +2436,16 @@ var HTML_ENTITIES = /* @__PURE__ */ new Set([
   "thorn",
   "yuml"
 ]);
+function isItemFixedLayout(packageDoc, itemId) {
+  const spineItem = packageDoc.spine.find((s) => s.idref === itemId);
+  if (!spineItem) return false;
+  if (spineItem.properties?.includes("rendition:layout-pre-paginated")) return true;
+  if (spineItem.properties?.includes("rendition:layout-reflowable")) return false;
+  const globalLayout = packageDoc.metaElements.find(
+    (m) => m.property === "rendition:layout" && !m.refines
+  );
+  return globalLayout?.value === "pre-paginated";
+}
 var ContentValidator = class {
   cssWithRemoteResources = /* @__PURE__ */ new Set();
   validate(context, registry, refValidator) {
@@ -2094,6 +2463,11 @@ var ContentValidator = class {
         }
       }
     }
+    const overlayDocMap = /* @__PURE__ */ new Map();
+    const manifestByPath = /* @__PURE__ */ new Map();
+    for (const item of packageDoc.manifest) {
+      manifestByPath.set(resolveManifestHref(opfDir, item.href), item);
+    }
     for (const item of packageDoc.manifest) {
       if (item.mediaType === "application/xhtml+xml") {
         const fullPath = resolveManifestHref(opfDir, item.href);
@@ -2109,9 +2483,96 @@ var ContentValidator = class {
         if (refValidator) {
           this.extractSVGReferences(context, fullPath, opfDir, refValidator);
         }
+      } else if (item.mediaType === "application/smil+xml") {
+        const fullPath = resolveManifestHref(opfDir, item.href);
+        const smilValidator = new SMILValidator();
+        const result = smilValidator.validate(context, fullPath, manifestByPath);
+        overlayDocMap.set(item.id, result.referencedDocuments);
+        if (refValidator) {
+          for (const textRef of result.textReferences) {
+            const refUrl = textRef.fragment ? `${textRef.docPath}#${textRef.fragment}` : textRef.docPath;
+            const location = textRef.line != null ? { path: fullPath, line: textRef.line } : { path: fullPath };
+            const ref = {
+              url: refUrl,
+              targetResource: textRef.docPath,
+              type: "overlay-text-link" /* OVERLAY_TEXT_LINK */,
+              location
+            };
+            if (textRef.fragment !== void 0) ref.fragment = textRef.fragment;
+            refValidator.addReference(ref);
+            context.overlayTextLinks ??= [];
+            const link = {
+              targetResource: textRef.docPath,
+              location
+            };
+            if (textRef.fragment !== void 0) link.fragment = textRef.fragment;
+            context.overlayTextLinks.push(link);
+          }
+        }
+        if (result.hasRemoteResources) {
+          const properties = item.properties ?? [];
+          if (!properties.includes("remote-resources")) {
+            pushMessage(context.messages, {
+              id: MessageId.OPF_014,
+              message: `The "remote-resources" property must be set on the media overlay item "${item.href}" because it references remote audio resources`,
+              location: { path: context.opfPath ?? "" }
+            });
+          }
+        }
       }
       this.validateMediaFile(context, item, opfDir);
     }
+    this.validateMediaOverlayCrossRefs(context, packageDoc, opfDir, overlayDocMap);
+  }
+  validateMediaOverlayCrossRefs(context, packageDoc, opfDir, overlayDocMap) {
+    if (overlayDocMap.size === 0) return;
+    const docToOverlays = /* @__PURE__ */ new Map();
+    for (const [overlayId, docPaths] of overlayDocMap) {
+      for (const docPath of docPaths) {
+        const existing = docToOverlays.get(docPath) ?? [];
+        existing.push(overlayId);
+        docToOverlays.set(docPath, existing);
+      }
+    }
+    const opfPath = context.opfPath ?? "";
+    for (const item of packageDoc.manifest) {
+      if (item.mediaType !== "application/xhtml+xml" && item.mediaType !== "image/svg+xml") {
+        continue;
+      }
+      const fullPath = resolveManifestHref(opfDir, item.href);
+      const referencingOverlays = docToOverlays.get(fullPath);
+      if (referencingOverlays && referencingOverlays.length > 0) {
+        if (referencingOverlays.length > 1) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_011,
+            message: `EPUB Content Document "${item.href}" referenced from multiple Media Overlay Documents`,
+            location: { path: opfPath }
+          });
+        }
+        if (!item.mediaOverlay) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_010,
+            message: `EPUB Content Document "${item.href}" referenced from a Media Overlay must specify the "media-overlay" attribute`,
+            location: { path: opfPath }
+          });
+        } else if (!referencingOverlays.includes(item.mediaOverlay)) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_012,
+            message: `The "media-overlay" attribute does not match the ID of the Media Overlay that refers to this document`,
+            location: { path: opfPath }
+          });
+        }
+      } else if (item.mediaOverlay) {
+        const overlayDocs = overlayDocMap.get(item.mediaOverlay);
+        if (overlayDocs && !overlayDocs.has(fullPath)) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_013,
+            message: `Media Overlay Document referenced from the "media-overlay" attribute does not contain a reference to this Content Document`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
   }
   validateMediaFile(context, item, opfDir) {
     const declaredType = item.mediaType;
@@ -2197,6 +2658,19 @@ var ContentValidator = class {
       this.checkSVGInvalidIDs(context, path, root);
       this.validateSvgEpubType(context, path, root);
       this.checkUnknownEpubAttributes(context, path, root);
+      this.checkSVGLinkAccessibility(context, path, root);
+      const packageDoc = context.packageDocument;
+      if (packageDoc && isItemFixedLayout(packageDoc, manifestItem.id)) {
+        const viewBox = this.getAttribute(root, "viewBox");
+        if (!viewBox) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_048,
+            message: "SVG Fixed-Layout Documents must have a viewBox attribute on the outermost svg element",
+            location: { path }
+          });
+        }
+      }
+      this.checkMediaOverlayActiveClassCSS(context, path, root, manifestItem, svgContent);
     } finally {
       doc.dispose();
     }
@@ -2382,7 +2856,26 @@ var ContentValidator = class {
     if (!cssData) {
       return;
     }
-    const cssContent = new TextDecoder().decode(cssData);
+    let cssContent;
+    const utf16Encoding = cssData.length >= 2 && cssData[0] === 254 && cssData[1] === 255 ? "utf-16be" : cssData.length >= 2 && cssData[0] === 255 && cssData[1] === 254 ? "utf-16le" : null;
+    if (utf16Encoding) {
+      pushMessage(context.messages, {
+        id: MessageId.CSS_003,
+        message: "CSS documents should be encoded in UTF-8, but UTF-16 was detected",
+        location: { path }
+      });
+      cssContent = new TextDecoder(utf16Encoding).decode(cssData);
+    } else {
+      cssContent = new TextDecoder().decode(cssData);
+      const charsetMatch = CSS_CHARSET_RE.exec(cssContent);
+      if (charsetMatch?.[1] && charsetMatch[1].toLowerCase() !== "utf-8") {
+        pushMessage(context.messages, {
+          id: MessageId.CSS_004,
+          message: `CSS documents must be encoded in UTF-8, but detected "${charsetMatch[1]}"`,
+          location: { path }
+        });
+      }
+    }
     const cssValidator = new CSSValidator();
     const result = cssValidator.validate(context, cssContent, path);
     const hasRemoteResources = result.references.some(
@@ -2475,11 +2968,28 @@ var ContentValidator = class {
     if (!data) {
       return;
     }
-    const content = new TextDecoder().decode(data);
+    if (data.length >= 2 && (data[0] === 254 && data[1] === 255 || data[0] === 255 && data[1] === 254)) {
+      pushMessage(context.messages, {
+        id: MessageId.HTM_058,
+        message: "HTML documents must be encoded in UTF-8, but UTF-16 was detected",
+        location: { path }
+      });
+      return;
+    }
+    let content = new TextDecoder().decode(data);
     const packageDoc = context.packageDocument;
     if (!packageDoc) {
       return;
     }
+    const epubNsMatch = EPUB_XMLNS_RE.exec(content);
+    if (epubNsMatch?.[1] && epubNsMatch[1] !== "http://www.idpf.org/2007/ops") {
+      pushMessage(context.messages, {
+        id: MessageId.HTM_010,
+        message: `Namespace URI "${epubNsMatch[1]}" is unusual for the "epub" prefix`,
+        location: { path }
+      });
+      content = content.replace(epubNsMatch[0], 'xmlns:epub="http://www.idpf.org/2007/ops"');
+    }
     this.checkUnescapedAmpersands(context, path, content);
     if (context.version !== "2.0") {
       const doctypeMatch = /<!DOCTYPE\s+html\b([\s\S]*?)>/i.exec(content);
@@ -2685,6 +3195,7 @@ var ContentValidator = class {
       this.checkHttpEquivCharset(context, path, root);
       this.checkLangMismatch(context, path, root);
       this.checkDpubAriaDeprecated(context, path, root);
+      this.validateIdRefs(context, path, root);
       this.checkTableBorder(context, path, root);
       this.checkTimeElement(context, path, root);
       this.checkMathMLAnnotations(context, path, root);
@@ -2692,6 +3203,7 @@ var ContentValidator = class {
       this.checkDataAttributes(context, path, root);
       this.checkAccessibility(context, path, root);
       this.validateImages(context, path, root);
+      this.checkUsemapAttribute(context, path, root);
       if (context.version.startsWith("3")) {
         this.validateEpubTypes(context, path, root);
       }
@@ -2704,8 +3216,24 @@ var ContentValidator = class {
         this.extractAndRegisterIDs(path, root, registry);
       }
       if (refValidator && opfDir !== void 0) {
-        this.extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, !!isNavItem);
-        this.extractAndRegisterStylesheets(path, root, opfDir, refValidator);
+        const remoteXmlBase = this.getRemoteXmlBase(root);
+        this.extractAndRegisterHyperlinks(
+          context,
+          path,
+          root,
+          opfDir,
+          refValidator,
+          !!isNavItem,
+          remoteXmlBase
+        );
+        this.extractAndRegisterStylesheets(
+          context,
+          path,
+          root,
+          opfDir,
+          refValidator,
+          remoteXmlBase
+        );
         this.extractAndRegisterImages(context, path, root, opfDir, refValidator, registry);
         this.extractAndRegisterMathMLAltimg(path, root, opfDir, refValidator);
         this.extractAndRegisterScripts(path, root, opfDir, refValidator);
@@ -2720,10 +3248,65 @@ var ContentValidator = class {
           registry
         );
       }
+      this.checkMediaOverlayActiveClassCSS(context, path, root, manifestItem);
     } finally {
       doc.dispose();
     }
   }
+  /**
+   * CSS-030: If media:active-class or media:playback-active-class is declared in OPF,
+   * and this content document has a media-overlay, it must have at least some CSS.
+   */
+  checkMediaOverlayActiveClassCSS(context, path, root, manifestItem, decodedContent) {
+    if (!manifestItem?.mediaOverlay) return;
+    if (!context.mediaActiveClass && !context.mediaPlaybackActiveClass) return;
+    const isSVG = root.name === "svg" || root.name.endsWith(":svg");
+    let hasCSS = false;
+    if (isSVG) {
+      try {
+        const styles = root.find(".//svg:style", { svg: "http://www.w3.org/2000/svg" });
+        if (styles.length > 0) hasCSS = true;
+      } catch {
+      }
+      if (!hasCSS) {
+        try {
+          const links = root.find(".//html:link", XHTML_NS);
+          if (links.length > 0) hasCSS = true;
+        } catch {
+        }
+      }
+      if (!hasCSS) {
+        const content = decodedContent ?? new TextDecoder().decode(context.files.get(path));
+        if (content.includes("<?xml-stylesheet")) hasCSS = true;
+      }
+    } else {
+      try {
+        const links = root.find(".//html:link[@rel]", XHTML_NS);
+        for (const link of links) {
+          const rel = this.getAttribute(link, "rel");
+          if (rel?.toLowerCase().includes("stylesheet")) {
+            hasCSS = true;
+            break;
+          }
+        }
+      } catch {
+      }
+      if (!hasCSS) {
+        try {
+          const styles = root.find(".//html:style", XHTML_NS);
+          if (styles.length > 0) hasCSS = true;
+        } catch {
+        }
+      }
+    }
+    if (!hasCSS) {
+      pushMessage(context.messages, {
+        id: MessageId.CSS_030,
+        message: 'The "media:active-class" property is declared in the package document but no CSS was found in this content document',
+        location: { path }
+      });
+    }
+  }
   parseLibxmlError(error) {
     const lineRegex = /(?:Entity:\s*)?line\s+(\d+):/;
     const lineMatch = lineRegex.exec(error);
@@ -3464,6 +4047,92 @@ var ContentValidator = class {
     } catch {
     }
   }
+  collectIds(root) {
+    const ids = /* @__PURE__ */ new Set();
+    try {
+      for (const el of root.find(".//*[@id]")) {
+        const id = this.getAttribute(el, "id");
+        if (id) ids.add(id);
+      }
+    } catch {
+    }
+    return ids;
+  }
+  validateIdRefs(context, path, root) {
+    try {
+      const allIds = this.collectIds(root);
+      const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
+      const idrefsChecks = [
+        { xpath: ".//*[@aria-describedby]", attr: "aria-describedby" },
+        { xpath: ".//*[@aria-flowto]", attr: "aria-flowto" },
+        { xpath: ".//*[@aria-labelledby]", attr: "aria-labelledby" },
+        { xpath: ".//*[@aria-owns]", attr: "aria-owns" },
+        { xpath: ".//*[@aria-controls]", attr: "aria-controls" },
+        { xpath: ".//html:output[@for]", attr: "for", ns: HTML_NS },
+        {
+          xpath: ".//html:td[@headers] | .//html:th[@headers]",
+          attr: "headers",
+          ns: HTML_NS
+        }
+      ];
+      for (const { xpath, attr, ns } of idrefsChecks) {
+        const elements = ns ? root.find(xpath, ns) : root.find(xpath);
+        for (const elem of elements) {
+          const value = this.getAttribute(elem, attr);
+          if (!value) continue;
+          const idrefs = value.trim().split(/\s+/);
+          if (idrefs.some((idref) => !allIds.has(idref))) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `The ${attr} attribute must refer to elements in the same document (target ID missing)`,
+              location: { path, line: elem.line }
+            });
+          }
+        }
+      }
+      const activedescMsg = "The aria-activedescendant attribute must refer to a descendant element.";
+      for (const elem of root.find(".//*[@aria-activedescendant]")) {
+        const idref = this.getAttribute(elem, "aria-activedescendant");
+        if (!idref) continue;
+        if (!allIds.has(idref)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: activedescMsg,
+            location: { path, line: elem.line }
+          });
+        } else {
+          try {
+            if (elem.find(`.//*[@id="${idref}"]`).length === 0) {
+              pushMessage(context.messages, {
+                id: MessageId.RSC_005,
+                message: activedescMsg,
+                location: { path, line: elem.line }
+              });
+            }
+          } catch {
+          }
+        }
+      }
+      for (const elem of root.find(".//*[@aria-describedat]")) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: 'attribute "aria-describedat" not allowed here',
+          location: { path, line: elem.line }
+        });
+      }
+      for (const elem of root.find(".//html:label[@for]", HTML_NS)) {
+        const idref = this.getAttribute(elem, "for");
+        if (idref && !allIds.has(idref)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The for attribute must refer to an element in the same document (the ID "${idref}" does not exist).`,
+            location: { path, line: elem.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
   validateEpubSwitch(context, path, root) {
     const EPUB_NS = { epub: "http://www.idpf.org/2007/ops" };
     try {
@@ -3552,15 +4221,7 @@ var ContentValidator = class {
     try {
       const triggers = root.find(".//epub:trigger", EPUB_NS);
       if (triggers.length === 0) return;
-      const allIds = /* @__PURE__ */ new Set();
-      try {
-        const idElements = root.find(".//*[@id]");
-        for (const el of idElements) {
-          const idAttr = this.getAttribute(el, "id");
-          if (idAttr) allIds.add(idAttr);
-        }
-      } catch {
-      }
+      const allIds = this.collectIds(root);
       for (const trigger of triggers) {
         pushMessage(context.messages, {
           id: MessageId.RSC_017,
@@ -3691,6 +4352,22 @@ var ContentValidator = class {
     } catch {
     }
   }
+  checkUsemapAttribute(context, path, root) {
+    try {
+      const elements = root.find(".//html:*[@usemap]", XHTML_NS);
+      for (const elem of elements) {
+        const usemap = this.getAttribute(elem, "usemap");
+        if (usemap !== null && !/^#.+$/.test(usemap)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `value of attribute "usemap" is invalid; must be a string matching the regular expression "#.+"`,
+            location: { path, line: elem.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
   checkTimeElement(context, path, root) {
     const HTML_NS = { html: "http://www.w3.org/1999/xhtml" };
     try {
@@ -3900,22 +4577,7 @@ var ContentValidator = class {
         });
       }
     }
-    const svgLinks = root.find(".//svg:a", {
-      svg: "http://www.w3.org/2000/svg",
-      xlink: "http://www.w3.org/1999/xlink"
-    });
-    for (const svgLink of svgLinks) {
-      const svgElem = svgLink;
-      const title = svgElem.get("./svg:title", { svg: "http://www.w3.org/2000/svg" });
-      const ariaLabel = this.getAttribute(svgElem, "aria-label");
-      if (!title && !ariaLabel) {
-        pushMessage(context.messages, {
-          id: MessageId.ACC_011,
-          message: "SVG hyperlink has no accessible name (missing title element or aria-label)",
-          location: { path }
-        });
-      }
-    }
+    this.checkSVGLinkAccessibility(context, path, root);
     const mathElements = root.find(".//math:math", { math: "http://www.w3.org/1998/Math/MathML" });
     for (const mathElem of mathElements) {
       const elem = mathElem;
@@ -3933,6 +4595,29 @@ var ContentValidator = class {
       }
     }
   }
+  hasSVGLinkAccessibleName(svgElem) {
+    const ns = { svg: "http://www.w3.org/2000/svg" };
+    if (svgElem.get(".//svg:title", ns)) return true;
+    if (svgElem.get(".//svg:text", ns)) return true;
+    if (this.getAttribute(svgElem, "aria-label")) return true;
+    if (this.getAttribute(svgElem, "xlink:title")) return true;
+    return false;
+  }
+  checkSVGLinkAccessibility(context, path, root) {
+    const svgLinks = root.find(".//svg:a", {
+      svg: "http://www.w3.org/2000/svg",
+      xlink: "http://www.w3.org/1999/xlink"
+    });
+    for (const svgLink of svgLinks) {
+      if (!this.hasSVGLinkAccessibleName(svgLink)) {
+        pushMessage(context.messages, {
+          id: MessageId.ACC_011,
+          message: "SVG hyperlink has no accessible name (missing title element or aria-label)",
+          location: { path }
+        });
+      }
+    }
+  }
   validateImages(context, path, root) {
     const packageDoc = context.packageDocument;
     if (!packageDoc) return;
@@ -3994,6 +4679,14 @@ var ContentValidator = class {
       const elemTyped = elem;
       const epubTypeAttr = elemTyped.attr("type", "epub");
       if (!epubTypeAttr?.value) continue;
+      if (EPUB_TYPE_FORBIDDEN_ELEMENTS.has(elemTyped.name)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `attribute "epub:type" not allowed here`,
+          location: { path, line: elem.line }
+        });
+        continue;
+      }
       for (const part of epubTypeAttr.value.split(/\s+/)) {
         if (!part) continue;
         const hasPrefix = part.includes(":");
@@ -4089,41 +4782,131 @@ var ContentValidator = class {
     const attr = attrs.find((a) => a.name === name);
     return attr?.value ?? null;
   }
+  /**
+   * Get remote xml:base URL from the document root element.
+   * Returns the URL if it's remote (http/https), or null otherwise.
+   */
+  getRemoteXmlBase(root) {
+    const xmlBase = root.attr("base", "xml")?.value ?? null;
+    if (xmlBase?.startsWith("http://") || xmlBase?.startsWith("https://")) {
+      return xmlBase;
+    }
+    return null;
+  }
   validateViewportMeta(context, path, root, manifestItem) {
-    const isFixedLayout = manifestItem?.properties?.includes("fixed-layout");
-    const metaTags = root.find(".//html:meta[@name]", { html: "http://www.w3.org/1999/xhtml" });
-    let hasViewportMeta = false;
-    for (const meta of metaTags) {
+    const packageDoc = context.packageDocument;
+    const isFixedLayout = manifestItem && packageDoc ? isItemFixedLayout(packageDoc, manifestItem.id) : false;
+    const headMetas = root.find(".//html:head/html:meta[@name]", {
+      html: "http://www.w3.org/1999/xhtml"
+    });
+    let viewportCount = 0;
+    for (const meta of headMetas) {
       const nameAttr = this.getAttribute(meta, "name");
-      if (nameAttr === "viewport") {
-        hasViewportMeta = true;
-        const contentAttr = this.getAttribute(meta, "content");
-        if (isFixedLayout) {
-          if (!contentAttr) {
-            pushMessage(context.messages, {
-              id: MessageId.HTM_046,
-              message: "Viewport meta element should have a content attribute in fixed-layout documents",
-              location: { path }
-            });
-            continue;
-          }
-        } else {
-          pushMessage(context.messages, {
-            id: MessageId.HTM_060b,
-            message: `EPUB reading systems must ignore viewport meta elements in reflowable documents; viewport declaration "${contentAttr ?? ""}" will be ignored`,
-            location: { path }
-          });
-        }
+      if (nameAttr !== "viewport") continue;
+      viewportCount++;
+      const contentAttr = this.getAttribute(meta, "content");
+      if (!isFixedLayout) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_060b,
+          message: `EPUB reading systems must ignore viewport meta elements in reflowable documents; viewport declaration "${contentAttr ?? ""}" will be ignored`,
+          location: { path, line: meta.line }
+        });
+        continue;
+      }
+      if (viewportCount > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_060a,
+          message: `EPUB reading systems must ignore secondary viewport meta elements in fixed-layout documents; viewport declaration "${contentAttr ?? ""}" will be ignored`,
+          location: { path, line: meta.line }
+        });
+        continue;
+      }
+      if (!contentAttr?.trim()) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_047,
+          message: `Viewport metadata "${contentAttr ?? ""}" has a syntax error`,
+          location: { path, line: meta.line }
+        });
+        continue;
       }
+      this.parseViewportContent(context, path, contentAttr, meta.line);
     }
-    if (isFixedLayout && !hasViewportMeta) {
+    if (isFixedLayout && viewportCount === 0) {
       pushMessage(context.messages, {
-        id: MessageId.HTM_049,
-        message: "Fixed-layout document should include a viewport meta element",
+        id: MessageId.HTM_046,
+        message: "Fixed layout document has no viewport meta element",
         location: { path }
       });
     }
   }
+  parseViewportContent(context, path, content, line) {
+    const location = line != null ? { path, line } : { path };
+    const parts = content.split(/[,;]/);
+    const seenKeys = /* @__PURE__ */ new Set();
+    let hasWidth = false;
+    let hasHeight = false;
+    let hasSyntaxError = false;
+    for (const part of parts) {
+      const trimmed = part.trim();
+      if (!trimmed) continue;
+      const eqIndex = trimmed.indexOf("=");
+      let key;
+      let value;
+      if (eqIndex < 0) {
+        key = trimmed;
+        value = "";
+      } else {
+        key = trimmed.substring(0, eqIndex).trim();
+        const rawValue = trimmed.substring(eqIndex + 1);
+        if (!rawValue.trim()) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_047,
+            message: `Viewport metadata "${content}" has a syntax error`,
+            location
+          });
+          hasSyntaxError = true;
+          break;
+        }
+        value = rawValue.trim();
+      }
+      if (key === "width" || key === "height") {
+        if (seenKeys.has(key)) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_059,
+            message: `Viewport "${key}" property must not be defined more than once`,
+            location
+          });
+        }
+        seenKeys.add(key);
+        if (key === "width") hasWidth = true;
+        if (key === "height") hasHeight = true;
+        const deviceKeyword = key === "width" ? "device-width" : "device-height";
+        if (value === deviceKeyword) ; else if (value === "" || !/^[0-9]*\.?[0-9]+$/.test(value)) {
+          pushMessage(context.messages, {
+            id: MessageId.HTM_057,
+            message: `Viewport "${key}" value must be a positive number or the keyword "${deviceKeyword}"`,
+            location
+          });
+        }
+      }
+    }
+    if (!hasSyntaxError) {
+      if (!hasWidth) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_056,
+          message: 'Viewport metadata has no "width" dimension (both "width" and "height" properties are required)',
+          location
+        });
+      }
+      if (!hasHeight) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_056,
+          message: 'Viewport metadata has no "height" dimension (both "width" and "height" properties are required)',
+          location
+        });
+      }
+    }
+  }
   extractAndRegisterIDs(path, root, registry) {
     const elementsWithId = root.find(".//*[@id]");
     for (const elem of elementsWithId) {
@@ -4138,7 +4921,7 @@ var ContentValidator = class {
       }
     }
   }
-  extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, isNavDocument = false) {
+  extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, isNavDocument = false, remoteXmlBase = null) {
     const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
     const navAnchorTypes = /* @__PURE__ */ new Map();
     if (isNavDocument) {
@@ -4174,7 +4957,17 @@ var ContentValidator = class {
       }
       const line = link.line;
       const refType = isNavDocument ? navAnchorTypes.get(`${String(line)}:${href}`) ?? "hyperlink" /* HYPERLINK */ : "hyperlink" /* HYPERLINK */;
+      if (href.startsWith("data:") || href.startsWith("file:")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: href,
+          type: refType,
+          location: { path, line }
+        });
+        continue;
+      }
       if (ABSOLUTE_URI_RE.test(href)) {
+        validateAbsoluteHyperlinkURL(context, href, path, line);
         continue;
       }
       if (href.includes("#epubcfi(")) {
@@ -4192,6 +4985,15 @@ var ContentValidator = class {
         });
         continue;
       }
+      if (remoteXmlBase && !ABSOLUTE_URI_RE.test(href)) {
+        const resolvedUrl = new URL(href, remoteXmlBase).href;
+        pushMessage(context.messages, {
+          id: MessageId.RSC_006,
+          message: `Remote resource reference is not allowed; resource "${resolvedUrl}" must be located in the EPUB container`,
+          location: { path, line }
+        });
+        continue;
+      }
       const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
       const hashIndex = resolvedPath.indexOf("#");
       const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
@@ -4212,7 +5014,19 @@ var ContentValidator = class {
       const href = this.getAttribute(area, "href")?.trim();
       if (!href) continue;
       const line = area.line;
-      if (ABSOLUTE_URI_RE.test(href)) continue;
+      if (href.startsWith("data:") || href.startsWith("file:")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: href,
+          type: "hyperlink" /* HYPERLINK */,
+          location: { path, line }
+        });
+        continue;
+      }
+      if (ABSOLUTE_URI_RE.test(href)) {
+        validateAbsoluteHyperlinkURL(context, href, path, line);
+        continue;
+      }
       if (href.includes("#epubcfi(")) continue;
       if (href.startsWith("#")) {
         refValidator.addReference({
@@ -4248,7 +5062,17 @@ var ContentValidator = class {
       const href = this.getAttribute(elem, "xlink:href") ?? this.getAttribute(elem, "href");
       if (!href) continue;
       const line = link.line;
-      if (href.startsWith("http://") || href.startsWith("https://")) {
+      if (href.startsWith("data:") || href.startsWith("file:")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: href,
+          type: "hyperlink" /* HYPERLINK */,
+          location: { path, line }
+        });
+        continue;
+      }
+      if (ABSOLUTE_URI_RE.test(href)) {
+        validateAbsoluteHyperlinkURL(context, href, path, line);
         continue;
       }
       if (href.startsWith("#")) {
@@ -4279,8 +5103,12 @@ var ContentValidator = class {
       refValidator.addReference(svgRef);
     }
   }
-  extractAndRegisterStylesheets(path, root, opfDir, refValidator) {
+  extractAndRegisterStylesheets(context, path, root, opfDir, refValidator, remoteXmlBase = null) {
     const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    const baseElem = root.get(".//html:base[@href]", { html: "http://www.w3.org/1999/xhtml" });
+    const baseHref = baseElem ? this.getAttribute(baseElem, "href") : null;
+    const effectiveBase = baseHref ?? remoteXmlBase;
+    const remoteBaseUrl = effectiveBase?.startsWith("http://") || effectiveBase?.startsWith("https://") ? effectiveBase : null;
     const linkElements = root.find(".//html:link[@href]", { html: "http://www.w3.org/1999/xhtml" });
     for (const linkElem of linkElements) {
       const href = this.getAttribute(linkElem, "href");
@@ -4298,6 +5126,15 @@ var ContentValidator = class {
         });
         continue;
       }
+      if (remoteBaseUrl && !ABSOLUTE_URI_RE.test(href)) {
+        const resolvedUrl = new URL(href, remoteBaseUrl).href;
+        pushMessage(context.messages, {
+          id: MessageId.RSC_006,
+          message: `Remote resource reference is not allowed; resource "${resolvedUrl}" must be located in the EPUB container`,
+          location: { path, line }
+        });
+        continue;
+      }
       const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
       const hashIndex = resolvedPath.indexOf("#");
       const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
@@ -5355,6 +6192,8 @@ var OCFValidator = class {
     this.validateUtf8Filenames(zip, context.messages);
     this.validateEmptyDirectories(zip, context.messages);
     this.parseEncryption(zip, context);
+    this.validateEncryptionXml(context);
+    this.validateSignaturesXml(context);
   }
   /**
    * Validate the mimetype file
@@ -5695,14 +6534,109 @@ var OCFValidator = class {
       const xml = block[0];
       const algorithmMatch = /Algorithm=["']([^"']+)["']/.exec(xml);
       const uriMatch = /<(?:\w+:)?CipherReference[^>]+URI=["']([^"']+)["']/.exec(xml);
-      if (algorithmMatch?.[1] === IDPF_OBFUSCATION && uriMatch?.[1]) {
-        obfuscated.add(uriMatch[1]);
+      const algorithm = algorithmMatch?.[1];
+      const uri = uriMatch?.[1];
+      if (!uri) continue;
+      if (algorithm === IDPF_OBFUSCATION) {
+        obfuscated.add(uri);
       }
+      pushMessage(context.messages, {
+        id: MessageId.RSC_004,
+        message: `File "${uri}" is encrypted, its content will not be checked`,
+        location: { path: encryptionPath }
+      });
     }
     if (obfuscated.size > 0) {
       context.obfuscatedResources = obfuscated;
     }
   }
+  /**
+   * Validate encryption.xml structure:
+   * - Root element must be "encryption" in OCF namespace
+   * - Compression Method must be "0" or "8"
+   * - Compression OriginalLength must be a non-negative integer
+   * - All Id attributes must be unique
+   */
+  extractRootElementName(xml) {
+    const match = /<(\w+)[\s>]/.exec(xml.replace(/<\?xml[^?]*\?>/, "").trimStart());
+    return match?.[1] ?? null;
+  }
+  validateEncryptionXml(context) {
+    const encPath = "META-INF/encryption.xml";
+    const content = context.files.get(encPath);
+    if (!content) return;
+    const xml = new TextDecoder().decode(content);
+    const rootName = this.extractRootElementName(xml);
+    if (rootName !== null && rootName !== "encryption") {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: `expected element "encryption" but found "${rootName}"`,
+        location: { path: encPath }
+      });
+      return;
+    }
+    const idPattern = /\bId=["']([^"']+)["']/g;
+    const ids = /* @__PURE__ */ new Map();
+    let idMatch;
+    while ((idMatch = idPattern.exec(xml)) !== null) {
+      const id = idMatch[1] ?? "";
+      ids.set(id, (ids.get(id) ?? 0) + 1);
+    }
+    for (const [id, count] of ids) {
+      if (count > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `Duplicate "${id}"`,
+          location: { path: encPath }
+        });
+      }
+    }
+    const compressionPattern = /<(?:\w+:)?Compression\s+([^>]*)\/?>/g;
+    let compMatch;
+    while ((compMatch = compressionPattern.exec(xml)) !== null) {
+      const attrs = compMatch[1] ?? "";
+      const methodMatch = /Method=["']([^"']*)["']/.exec(attrs);
+      const lengthMatch = /OriginalLength=["']([^"']*)["']/.exec(attrs);
+      if (methodMatch) {
+        const method = methodMatch[1] ?? "";
+        if (method !== "0" && method !== "8") {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `value of attribute "Method" is invalid; must be "0" or "8"`,
+            location: { path: encPath }
+          });
+        }
+      }
+      if (lengthMatch) {
+        const length = lengthMatch[1] ?? "";
+        if (!/^\d+$/.test(length)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `value of attribute "OriginalLength" is invalid; must be a non-negative integer`,
+            location: { path: encPath }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Validate signatures.xml structure:
+   * - Root element must be "signatures" in OCF namespace
+   */
+  validateSignaturesXml(context) {
+    const sigPath = "META-INF/signatures.xml";
+    const content = context.files.get(sigPath);
+    if (!content) return;
+    const xml = new TextDecoder().decode(content);
+    const rootName = this.extractRootElementName(xml);
+    if (rootName !== null && rootName !== "signatures") {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: `expected element "signatures" but found "${rootName}"`,
+        location: { path: sigPath }
+      });
+    }
+  }
   /**
    * Validate empty directories
    */
@@ -5730,6 +6664,65 @@ var OCFValidator = class {
   }
 };
 
+// src/util/encoding.ts
+function sniffXmlEncoding(data) {
+  if (data.length < 2) return null;
+  if (data.length >= 4) {
+    if (data[0] === 0 && data[1] === 0 && data[2] === 254 && data[3] === 255) {
+      return "UCS-4";
+    }
+    if (data[0] === 255 && data[1] === 254 && data[2] === 0 && data[3] === 0) {
+      return "UCS-4";
+    }
+    if (data[0] === 0 && data[1] === 0 && data[2] === 255 && data[3] === 254) {
+      return "UCS-4";
+    }
+    if (data[0] === 254 && data[1] === 255 && data[2] === 0 && data[3] === 0) {
+      return "UCS-4";
+    }
+    if (data[0] === 0 && data[1] === 0 && data[2] === 0 && data[3] === 60) {
+      return "UCS-4";
+    }
+    if (data[0] === 60 && data[1] === 0 && data[2] === 0 && data[3] === 0) {
+      return "UCS-4";
+    }
+    if (data[0] === 0 && data[1] === 0 && data[2] === 60 && data[3] === 0) {
+      return "UCS-4";
+    }
+    if (data[0] === 0 && data[1] === 60 && data[2] === 0 && data[3] === 0) {
+      return "UCS-4";
+    }
+  }
+  if (data[0] === 254 && data[1] === 255) {
+    return "UTF-16";
+  }
+  if (data[0] === 255 && data[1] === 254) {
+    return "UTF-16";
+  }
+  if (data.length >= 4) {
+    if (data[0] === 0 && data[1] === 60 && data[2] === 0 && data[3] === 63) {
+      return "UTF-16";
+    }
+    if (data[0] === 60 && data[1] === 0 && data[2] === 63 && data[3] === 0) {
+      return "UTF-16";
+    }
+  }
+  if (data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191) {
+    return null;
+  }
+  if (data.length >= 4 && data[0] === 76 && data[1] === 111 && data[2] === 167 && data[3] === 148) {
+    return "EBCDIC";
+  }
+  const prefix = String.fromCharCode(...data.slice(0, Math.min(256, data.length)));
+  const match = /^<\?xml[^?]*\bencoding\s*=\s*["']([^"']+)["']/.exec(prefix);
+  if (match) {
+    const declared = (match[1] ?? "").toUpperCase();
+    if (declared === "UTF-8") return null;
+    return declared;
+  }
+  return null;
+}
+
 // src/opf/parser.ts
 function parseOPF(xml) {
   const packageRegex = /<package[^>]*\sversion=["']([^"']+)["'][^>]*(?:\sunique-identifier=["']([^"']+)["'])?[^>]*>/;
@@ -6080,6 +7073,25 @@ var DEPRECATED_MEDIA_TYPES = /* @__PURE__ */ new Set([
   "application/x-oeb1-package",
   "text/x-oeb1-html"
 ]);
+function getPreferredMediaType(mimeType, path) {
+  switch (mimeType) {
+    case "application/font-sfnt":
+      if (path.endsWith(".ttf")) return "font/ttf";
+      if (path.endsWith(".otf")) return "font/otf";
+      return "font/(ttf|otf)";
+    case "application/vnd.ms-opentype":
+      return "font/otf";
+    case "application/font-woff":
+      return "font/woff";
+    case "application/x-font-ttf":
+      return "font/ttf";
+    case "text/javascript":
+    case "application/ecmascript":
+      return "application/javascript";
+    default:
+      return null;
+  }
+}
 var VALID_RELATOR_CODES = /* @__PURE__ */ new Set([
   "abr",
   "acp",
@@ -6362,6 +7374,60 @@ var DEPRECATED_LINK_REL = /* @__PURE__ */ new Set([
   "xmp-record",
   "xml-signature"
 ]);
+var EXCLUSIVE_SPINE_GROUPS = [
+  ["rendition:layout-reflowable", "rendition:layout-pre-paginated"],
+  [
+    "rendition:orientation-auto",
+    "rendition:orientation-landscape",
+    "rendition:orientation-portrait"
+  ],
+  [
+    "rendition:spread-auto",
+    "rendition:spread-both",
+    "rendition:spread-landscape",
+    "rendition:spread-none",
+    "rendition:spread-portrait"
+  ],
+  ["page-spread-left", "page-spread-right", "rendition:page-spread-center"],
+  [
+    "rendition:flow-auto",
+    "rendition:flow-paginated",
+    "rendition:flow-scrolled-continuous",
+    "rendition:flow-scrolled-doc"
+  ]
+];
+var RENDITION_META_RULES = [
+  {
+    property: "rendition:layout",
+    allowedValues: /* @__PURE__ */ new Set(["reflowable", "pre-paginated"]),
+    forbidRefines: true
+  },
+  {
+    property: "rendition:orientation",
+    allowedValues: /* @__PURE__ */ new Set(["landscape", "portrait", "auto"]),
+    forbidRefines: true
+  },
+  {
+    property: "rendition:spread",
+    allowedValues: /* @__PURE__ */ new Set(["none", "landscape", "portrait", "both", "auto"]),
+    forbidRefines: true,
+    deprecatedValues: /* @__PURE__ */ new Set(["portrait"])
+  },
+  {
+    property: "rendition:flow",
+    allowedValues: /* @__PURE__ */ new Set(["paginated", "scrolled-continuous", "scrolled-doc", "auto"]),
+    forbidRefines: true
+  },
+  {
+    property: "rendition:viewport",
+    deprecated: true,
+    allowedValues: /* @__PURE__ */ new Set(),
+    validateSyntax: (v) => /^(width=\d+,\s*height=\d+|height=\d+,\s*width=\d+)$/.test(v)
+  }
+];
+var KNOWN_RENDITION_META_PROPERTIES = new Set(
+  RENDITION_META_RULES.map((r) => r.property.slice("rendition:".length))
+);
 var GRANDFATHERED_LANG_TAGS = /* @__PURE__ */ new Set([
   "en-GB-oed",
   "i-ami",
@@ -6415,6 +7481,20 @@ var OPFValidator = class {
       });
       return;
     }
+    const encoding = sniffXmlEncoding(opfData);
+    if (encoding === "UTF-16") {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_027,
+        message: `Detected non-UTF-8 encoding "${encoding}" in "${opfPath}"`,
+        location: { path: opfPath }
+      });
+    } else if (encoding !== null) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_028,
+        message: `Detected non-UTF-8 encoding "${encoding}" in "${opfPath}"`,
+        location: { path: opfPath }
+      });
+    }
     const opfXml = new TextDecoder().decode(opfData);
     try {
       this.packageDoc = parseOPF(opfXml);
@@ -6704,6 +7784,9 @@ var OPFValidator = class {
     }
     if (this.packageDoc.version !== "2.0") {
       this.validateMetaPropertiesVocab(context, opfPath, dcElements);
+      this.validateRenditionVocab(context, opfPath);
+      this.validateMediaOverlaysVocab(context, opfPath);
+      this.validateMediaOverlayItems(context, opfPath);
     }
     if (this.packageDoc.version !== "2.0") {
       const modifiedMetas = this.packageDoc.metaElements.filter(
@@ -6994,6 +8077,206 @@ var OPFValidator = class {
       }
     }
   }
+  /**
+   * Validate rendition vocabulary meta properties (rendition:layout, orientation, spread, flow, viewport).
+   * Ports the Schematron rules from package-30.sch for the rendition vocabulary.
+   */
+  validateRenditionVocab(context, opfPath) {
+    if (!this.packageDoc) return;
+    const metas = this.packageDoc.metaElements;
+    for (const rp of RENDITION_META_RULES) {
+      const matching = metas.filter((m) => m.property === rp.property);
+      for (const meta of matching) {
+        if (meta.refines && rp.forbidRefines) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The "${rp.property}" property must not refine a publication resource`,
+            location: { path: opfPath }
+          });
+          continue;
+        }
+        if (rp.deprecated) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_086,
+            message: `The "${rp.property}" property is deprecated`,
+            location: { path: opfPath }
+          });
+        }
+        if (rp.validateSyntax) {
+          if (!rp.validateSyntax(meta.value)) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `The value of the "${rp.property}" property must be of the form "width=x, height=y"`,
+              location: { path: opfPath }
+            });
+          }
+        } else if (!rp.allowedValues.has(meta.value)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The value of the "${rp.property}" property must be ${[...rp.allowedValues].map((v) => `"${v}"`).join(" or ")}`,
+            location: { path: opfPath }
+          });
+        }
+        if (rp.deprecatedValues?.has(meta.value)) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_086,
+            message: `The "${rp.property}" property value "${meta.value}" is deprecated`,
+            location: { path: opfPath }
+          });
+        }
+      }
+      const countable = rp.forbidRefines ? matching : matching.filter((m) => !m.refines);
+      if (countable.length > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `The "${rp.property}" property must not occur more than one time as a global value`,
+          location: { path: opfPath }
+        });
+      }
+    }
+    for (const meta of metas) {
+      if (meta.property.startsWith("rendition:")) {
+        const localName = meta.property.slice("rendition:".length);
+        if (!KNOWN_RENDITION_META_PROPERTIES.has(localName)) {
+          pushMessage(context.messages, {
+            id: MessageId.OPF_027,
+            message: `Undefined property: "${meta.property}"`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Validate media overlays vocabulary meta properties (media:active-class, playback-active-class, duration).
+   * Ports the Schematron rules from package-30.sch for the media overlays vocabulary.
+   */
+  validateMediaOverlaysVocab(context, opfPath) {
+    if (!this.packageDoc) return;
+    const metas = this.packageDoc.metaElements;
+    const matchingActive = metas.filter((m) => m.property === "media:active-class");
+    const matchingPlayback = metas.filter((m) => m.property === "media:playback-active-class");
+    for (const [prop, matching] of [
+      ["media:active-class", matchingActive],
+      ["media:playback-active-class", matchingPlayback]
+    ]) {
+      const displayName = prop.slice("media:".length);
+      if (matching.length > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `The '${displayName}' property must not occur more than one time in the package metadata`,
+          location: { path: opfPath }
+        });
+      }
+      for (const meta of matching) {
+        if (meta.refines) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `@refines must not be used with the ${prop} property`,
+            location: { path: opfPath }
+          });
+        }
+        if (meta.value.trim().includes(" ")) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `the '${displayName}' property must define a single class name`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+    if (matchingActive[0]) context.mediaActiveClass = matchingActive[0].value.trim();
+    if (matchingPlayback[0]) context.mediaPlaybackActiveClass = matchingPlayback[0].value.trim();
+    for (const meta of metas) {
+      if (meta.property === "media:duration") {
+        if (!isValidSmilClock(meta.value.trim())) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `The value of the "media:duration" property must be a valid SMIL3 clock value`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+    const globalDuration = metas.find((m) => m.property === "media:duration" && !m.refines);
+    if (globalDuration) {
+      const totalSeconds = parseSmilClock(globalDuration.value.trim());
+      if (!Number.isNaN(totalSeconds)) {
+        let sumSeconds = 0;
+        let allValid = true;
+        for (const meta of metas) {
+          if (meta.property === "media:duration" && meta.refines) {
+            const s = parseSmilClock(meta.value.trim());
+            if (Number.isNaN(s)) {
+              allValid = false;
+              break;
+            }
+            sumSeconds += s;
+          }
+        }
+        if (allValid && Math.abs(totalSeconds - sumSeconds) > 1) {
+          pushMessage(context.messages, {
+            id: MessageId.MED_016,
+            message: `Media Overlays total duration should be the sum of the durations of all Media Overlays documents.`,
+            location: { path: opfPath }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Validate media-overlay manifest item constraints:
+   * - media-overlay must reference a SMIL item (application/smil+xml)
+   * - media-overlay attribute only allowed on XHTML and SVG content documents
+   * - Global media:duration required when overlays exist
+   * - Per-item media:duration required for each overlay
+   */
+  validateMediaOverlayItems(context, opfPath) {
+    if (!this.packageDoc) return;
+    const manifest = this.packageDoc.manifest;
+    const metas = this.packageDoc.metaElements;
+    const itemsWithOverlay = manifest.filter((item) => item.mediaOverlay);
+    if (itemsWithOverlay.length === 0) return;
+    for (const item of itemsWithOverlay) {
+      const moId = item.mediaOverlay;
+      if (!moId) continue;
+      const moItem = this.manifestById.get(moId);
+      if (moItem && moItem.mediaType !== "application/smil+xml") {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `media overlay items must be of the "application/smil+xml" type (given type was "${moItem.mediaType}")`,
+          location: { path: opfPath }
+        });
+      }
+      if (item.mediaType !== "application/xhtml+xml" && item.mediaType !== "image/svg+xml") {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `The media-overlay attribute is only allowed on XHTML and SVG content documents.`,
+          location: { path: opfPath }
+        });
+      }
+    }
+    if (!metas.some((m) => m.property === "media:duration" && !m.refines)) {
+      pushMessage(context.messages, {
+        id: MessageId.RSC_005,
+        message: `global media:duration meta element not set`,
+        location: { path: opfPath }
+      });
+    }
+    const overlayIds = new Set(
+      itemsWithOverlay.map((item) => item.mediaOverlay).filter((id) => id != null && this.manifestById.has(id))
+    );
+    for (const overlayId of overlayIds) {
+      const refinesUri = `#${overlayId}`;
+      if (!metas.some((m) => m.property === "media:duration" && m.refines === refinesUri)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: `item media:duration meta element not set (expecting: meta property='media:duration' refines='${refinesUri}')`,
+          location: { path: opfPath }
+        });
+      }
+    }
+  }
   /**
    * Validate EPUB 3 link elements in metadata
    */
@@ -7073,7 +8356,30 @@ var OPFValidator = class {
         });
         continue;
       }
+      if (isDataURL(href)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_029,
+          message: `Data URLs are not allowed in the package document link href`,
+          location: { path: opfPath }
+        });
+        continue;
+      }
+      if (isFileURL(href)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_030,
+          message: `File URLs are not allowed in the package document`,
+          location: { path: opfPath }
+        });
+        continue;
+      }
       const isRemote = /^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(href);
+      if (!isRemote && href.includes("?")) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_033,
+          message: `Relative URL strings must not have a query component: "${href}"`,
+          location: { path: opfPath }
+        });
+      }
       if (hasVoicing && link.mediaType && !link.mediaType.startsWith("audio/")) {
         pushMessage(context.messages, {
           id: MessageId.OPF_095,
@@ -7098,10 +8404,12 @@ var OPFValidator = class {
           location: { path: opfPath }
         });
       }
-      const resolvedPath = resolvePath(opfPath, basePath);
-      const resolvedPathDecoded = basePathDecoded !== basePath ? resolvePath(opfPath, basePathDecoded) : resolvedPath;
+      const basePathNoQuery = basePath.includes("?") ? basePath.substring(0, basePath.indexOf("?")) : basePath;
+      const basePathDecodedNoQuery = basePathDecoded.includes("?") ? basePathDecoded.substring(0, basePathDecoded.indexOf("?")) : basePathDecoded;
+      const resolvedPath = resolvePath(opfPath, basePathNoQuery);
+      const resolvedPathDecoded = basePathDecodedNoQuery !== basePathNoQuery ? resolvePath(opfPath, basePathDecodedNoQuery) : resolvedPath;
       const fileExists = context.files.has(resolvedPath) || context.files.has(resolvedPathDecoded);
-      const inManifest = this.manifestByHref.has(basePath) || this.manifestByHref.has(basePathDecoded);
+      const inManifest = this.manifestByHref.has(basePathNoQuery) || this.manifestByHref.has(basePathDecodedNoQuery);
       if (!fileExists && !inManifest) {
         pushMessage(context.messages, {
           id: MessageId.RSC_007w,
@@ -7135,7 +8443,24 @@ var OPFValidator = class {
         });
       }
       seenHrefs.add(item.href);
-      const fullPath = resolvePath(opfPath, item.href);
+      if (isDataURL(item.href)) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_029,
+          message: `Data URLs are not allowed in the manifest item href`,
+          location: { path: opfPath }
+        });
+        continue;
+      }
+      const isRemoteItem = /^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(item.href);
+      if (!isRemoteItem && item.href.includes("?")) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_033,
+          message: `Relative URL strings must not have a query component: "${item.href}"`,
+          location: { path: opfPath }
+        });
+      }
+      const itemHrefBase = item.href.includes("?") ? item.href.substring(0, item.href.indexOf("?")) : item.href;
+      const fullPath = resolvePath(opfPath, itemHrefBase);
       if (fullPath === opfPath) {
         pushMessage(context.messages, {
           id: MessageId.OPF_099,
@@ -7153,8 +8478,8 @@ var OPFValidator = class {
           });
         }
       }
-      const decodedHref = tryDecodeUriComponent(item.href);
-      const fullPathDecoded = decodedHref !== item.href ? resolvePath(opfPath, decodedHref).normalize("NFC") : fullPath;
+      const decodedHref = tryDecodeUriComponent(itemHrefBase);
+      const fullPathDecoded = decodedHref !== itemHrefBase ? resolvePath(opfPath, decodedHref).normalize("NFC") : fullPath;
       if (!context.files.has(fullPath) && !context.files.has(fullPathDecoded) && !item.href.startsWith("http")) {
         pushMessage(context.messages, {
           id: MessageId.RSC_001,
@@ -7183,6 +8508,14 @@ var OPFValidator = class {
           location: { path: opfPath }
         });
       }
+      const preferred = getPreferredMediaType(item.mediaType, fullPath);
+      if (preferred !== null) {
+        pushMessage(context.messages, {
+          id: MessageId.OPF_090,
+          message: `Encouraged to use media type "${preferred}" instead of "${item.mediaType}"`,
+          location: { path: opfPath }
+        });
+      }
       if (this.packageDoc.version !== "2.0" && item.properties) {
         for (const prop of item.properties) {
           if (!ITEM_PROPERTIES.has(prop)) {
@@ -7377,6 +8710,24 @@ var OPFValidator = class {
               location: { path: opfPath }
             });
           }
+          if (prop === "rendition:spread-portrait") {
+            pushMessage(context.messages, {
+              id: MessageId.OPF_086,
+              message: `The "rendition:spread-portrait" property is deprecated`,
+              location: { path: opfPath }
+            });
+          }
+        }
+        const props = new Set(itemref.properties);
+        for (const group of EXCLUSIVE_SPINE_GROUPS) {
+          const found = group.filter((p) => props.has(p));
+          if (found.length > 1) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `Properties "${found.join('", "')}" are mutually exclusive`,
+              location: { path: opfPath }
+            });
+          }
         }
       }
     }
@@ -7920,7 +9271,7 @@ var ReferenceValidator = class {
         location: reference.location
       });
     }
-    if (!this.registry.hasResource(resourcePath)) {
+    if (reference.type !== "overlay-text-link" /* OVERLAY_TEXT_LINK */ && !this.registry.hasResource(resourcePath)) {
       const fileExistsInContainer = context.files.has(resourcePath);
       if (fileExistsInContainer) {
         if (!context.referencedUndeclaredResources?.has(resourcePath)) {
@@ -8057,6 +9408,24 @@ var ReferenceValidator = class {
         });
       }
     }
+    if (reference.type === "overlay-text-link" /* OVERLAY_TEXT_LINK */ && resource) {
+      if (resource.mimeType === "application/xhtml+xml" && /^\w+\(/.test(fragment)) {
+        pushMessage(context.messages, {
+          id: MessageId.MED_017,
+          message: `URL fragment should indicate an element ID, but found '#${fragment}'`,
+          location: reference.location
+        });
+        return;
+      }
+      if (resource.mimeType === "image/svg+xml" && !this.isValidSVGFragment(fragment)) {
+        pushMessage(context.messages, {
+          id: MessageId.MED_018,
+          message: `URL fragment should be an SVG fragment identifier, but found '#${fragment}'`,
+          location: reference.location
+        });
+        return;
+      }
+    }
     const parsedMimeTypes = ["application/xhtml+xml", "image/svg+xml"];
     if (resource && parsedMimeTypes.includes(resource.mimeType) && !isRemoteURL(resourcePath) && !fragment.includes("svgView(") && reference.type !== "svg-symbol" /* SVG_SYMBOL */) {
       if (!this.registry.hasID(resourcePath, fragment)) {
@@ -8068,6 +9437,18 @@ var ReferenceValidator = class {
       }
     }
   }
+  /**
+   * Check if a fragment is a valid SVG fragment identifier.
+   * Valid forms: bare NCName ID, svgView(...), t=..., xywh=..., id=...
+   */
+  isValidSVGFragment(fragment) {
+    if (/^svgView\(.*\)$/.test(fragment)) return true;
+    if (fragment.startsWith("t=")) return true;
+    if (fragment.startsWith("xywh=")) return true;
+    if (fragment.startsWith("id=")) return true;
+    if (!fragment.includes("=") && /^[a-zA-Z_][\w.-]*$/.test(fragment)) return true;
+    return false;
+  }
   /**
    * Check non-spine remote resources that have non-standard types.
    * Fires RSC-006 for remote items that aren't audio/video/font types
@@ -8127,7 +9508,7 @@ var ReferenceValidator = class {
     }
   }
   checkReadingOrder(context) {
-    if (!context.tocLinks || !context.packageDocument) return;
+    if (!context.packageDocument) return;
     const packageDoc = context.packageDocument;
     const spine = packageDoc.spine;
     const opfPath = context.opfPath ?? "";
@@ -8139,15 +9520,35 @@ var ReferenceValidator = class {
         spinePositionMap.set(resolveManifestHref(opfDir, item.href), i);
       }
     }
+    if (context.tocLinks) {
+      this.checkLinkReadingOrder(
+        context,
+        spinePositionMap,
+        context.tocLinks,
+        MessageId.NAV_011,
+        '"toc" nav'
+      );
+    }
+    if (context.overlayTextLinks) {
+      this.checkLinkReadingOrder(
+        context,
+        spinePositionMap,
+        context.overlayTextLinks,
+        MessageId.MED_015,
+        "Media overlay text"
+      );
+    }
+  }
+  checkLinkReadingOrder(context, spinePositionMap, links, messageId, label) {
     let lastSpinePosition = -1;
     let lastAnchorPosition = -1;
-    for (const link of context.tocLinks) {
+    for (const link of links) {
       const spinePos = spinePositionMap.get(link.targetResource);
       if (spinePos === void 0) continue;
       if (spinePos < lastSpinePosition) {
         pushMessage(context.messages, {
-          id: MessageId.NAV_011,
-          message: `"toc" nav must be in reading order; link target "${link.targetResource}" is before the previous link's target in spine order`,
+          id: messageId,
+          message: `${label} must be in reading order; link target "${link.targetResource}" is before the previous link's target in spine order`,
           location: link.location
         });
         lastSpinePosition = spinePos;
@@ -8162,8 +9563,8 @@ var ReferenceValidator = class {
           if (targetAnchorPosition < lastAnchorPosition) {
             const target = link.fragment ? `${link.targetResource}#${link.fragment}` : link.targetResource;
             pushMessage(context.messages, {
-              id: MessageId.NAV_011,
-              message: `"toc" nav must be in reading order; link target "${target}" is before the previous link's target in document order`,
+              id: messageId,
+              message: `${label} must be in reading order; link target "${target}" is before the previous link's target in document order`,
               location: link.location
             });
           }
@@ -8382,11 +9783,11 @@ var RelaxNGValidator = class extends BaseSchemaValidator {
     try {
       const libxml2 = await import('libxml2-wasm');
       const LibRelaxNGValidator = libxml2.RelaxNGValidator;
-      const { XmlDocument: XmlDocument3 } = libxml2;
-      const doc = XmlDocument3.fromString(xml);
+      const { XmlDocument: XmlDocument4 } = libxml2;
+      const doc = XmlDocument4.fromString(xml);
       try {
         const schemaContent = await loadSchema(schemaPath);
-        const schemaDoc = XmlDocument3.fromString(schemaContent);
+        const schemaDoc = XmlDocument4.fromString(schemaContent);
         try {
           const validator = LibRelaxNGValidator.fromDoc(schemaDoc);
           try {