@likecoin/epubcheck-ts 0.3.8 → 0.4.0

package/dist/index.cjs

@@ -7,6 +7,13 @@ var fflate = require('fflate');
 // src/content/validator.ts
 
 // src/messages/messages.ts
+var severityOverrides = /* @__PURE__ */ new Map();
+function setSeverityOverrides(overrides) {
+  severityOverrides = overrides;
+}
+function clearSeverityOverrides() {
+  severityOverrides = /* @__PURE__ */ new Map();
+}
 var MessageDefs = {
   // Package/Container errors (PKG-*)
   PKG_001: {
@@ -1177,10 +1184,15 @@ function formatMessageList() {
 function createMessage(options) {
   const { id, message, location, suggestion, severityOverride } = options;
   const registeredSeverity = getDefaultSeverity(id);
-  if (registeredSeverity === "suppressed" && !severityOverride) {
+  const globalOverride = severityOverrides.get(id);
+  const effectiveOverride = severityOverride ?? globalOverride;
+  if (effectiveOverride === "suppressed") {
+    return null;
+  }
+  if (registeredSeverity === "suppressed" && !effectiveOverride) {
     return null;
   }
-  const severity = severityOverride ?? registeredSeverity;
+  const severity = effectiveOverride ? effectiveOverride : registeredSeverity;
   const result = {
     id,
     severity,
@@ -1200,6 +1212,30 @@ function pushMessage(messages, options) {
     messages.push(msg);
   }
 }
+function parseCustomMessages(content) {
+  const overrides = /* @__PURE__ */ new Map();
+  const validSeverities = /* @__PURE__ */ new Set([
+    "fatal",
+    "error",
+    "warning",
+    "info",
+    "usage",
+    "suppressed"
+  ]);
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.toLowerCase().startsWith("id	") || trimmed.toLowerCase() === "id") continue;
+    const parts = trimmed.split("	");
+    const id = parts[0]?.trim();
+    const severity = parts[1]?.trim().toLowerCase();
+    if (!id || !severity) continue;
+    if (validSeverities.has(severity)) {
+      overrides.set(id, severity);
+    }
+  }
+  return overrides;
+}
 
 // src/css/validator.ts
 var BLESSED_FONT_TYPES = /* @__PURE__ */ new Set([
@@ -1604,31 +1640,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"]);
     cssTree.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 = libxml2Wasm.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("/");
   }
 };
 
@@ -1890,6 +2171,18 @@ 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_OPS_NS = { epub: "http://www.idpf.org/2007/ops" };
+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();
@@ -2182,6 +2475,122 @@ var HTML_ENTITIES = /* @__PURE__ */ new Set([
   "thorn",
   "yuml"
 ]);
+var HTML5_ELEMENTS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "math",
+  "menu",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "search",
+  "section",
+  "select",
+  "slot",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "svg",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr"
+]);
 function isItemFixedLayout(packageDoc, itemId) {
   const spineItem = packageDoc.spine.find((s) => s.idref === itemId);
   if (!spineItem) return false;
@@ -2209,6 +2618,12 @@ var ContentValidator = class {
         }
       }
     }
+    context.contentFeatures = {};
+    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);
@@ -2224,9 +2639,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;
@@ -2313,6 +2815,8 @@ var ContentValidator = class {
       this.validateSvgEpubType(context, path, root);
       this.checkUnknownEpubAttributes(context, path, root);
       this.checkSVGLinkAccessibility(context, path, root);
+      this.checkForeignObjectContent(context, path, root, true);
+      this.checkSVGTitleContent(context, path, root);
       const packageDoc = context.packageDocument;
       if (packageDoc && isItemFixedLayout(packageDoc, manifestItem.id)) {
         const viewBox = this.getAttribute(root, "viewBox");
@@ -2324,6 +2828,7 @@ var ContentValidator = class {
           });
         }
       }
+      this.checkMediaOverlayActiveClassCSS(context, path, root, manifestItem, svgContent);
     } finally {
       doc.dispose();
     }
@@ -2534,21 +3039,24 @@ var ContentValidator = class {
     const hasRemoteResources = result.references.some(
       (ref) => ref.url.startsWith("http://") || ref.url.startsWith("https://")
     );
+    const cssManifestItem = context.packageDocument?.manifest.find(
+      (item) => path.endsWith(`/${item.href}`) || path === item.href
+    );
     if (hasRemoteResources) {
       this.cssWithRemoteResources.add(path);
-      const packageDoc = context.packageDocument;
-      if (packageDoc) {
-        const manifestItem = packageDoc.manifest.find(
-          (item) => path.endsWith(`/${item.href}`) || path === item.href
-        );
-        if (manifestItem && !manifestItem.properties?.includes("remote-resources")) {
-          pushMessage(context.messages, {
-            id: MessageId.OPF_014,
-            message: 'CSS document references remote resources but manifest item is missing "remote-resources" property',
-            location: { path }
-          });
-        }
+      if (cssManifestItem && !cssManifestItem.properties?.includes("remote-resources")) {
+        pushMessage(context.messages, {
+          id: MessageId.OPF_014,
+          message: 'CSS document references remote resources but manifest item is missing "remote-resources" property',
+          location: { path }
+        });
       }
+    } else if (cssManifestItem?.properties?.includes("remote-resources")) {
+      pushMessage(context.messages, {
+        id: MessageId.OPF_018,
+        message: 'The "remote-resources" property was declared in the Package Document, but no reference to remote resources has been found',
+        location: { path }
+      });
     }
     const cssDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
     for (const ref of result.references) {
@@ -2848,6 +3356,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);
@@ -2855,9 +3364,20 @@ 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.checkDisallowedDescendants(context, path, root);
+        this.checkMicrodataCoOccurrence(context, path, root);
+        this.checkUnknownElements(context, path, root);
+        this.checkForeignObjectContent(context, path, root, false);
+        this.checkSVGTitleContent(context, path, root);
+      }
       if (context.version.startsWith("3")) {
         this.validateEpubTypes(context, path, root);
       }
+      if (context.version.startsWith("3")) {
+        this.collectFeatures(context, root);
+      }
       this.validateEpubSwitch(context, path, root);
       this.validateEpubTrigger(context, path, root);
       this.validateStyleAttributes(context, path, root);
@@ -2867,8 +3387,24 @@ var ContentValidator = class {
         this.extractAndRegisterIDs(path, root, registry);
       }
       if (refValidator && opfDir !== void 0) {
-        this.extractAndRegisterHyperlinks(context, path, root, opfDir, refValidator, !!isNavItem);
-        this.extractAndRegisterStylesheets(context, 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);
@@ -2883,10 +3419,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);
@@ -2944,8 +3535,15 @@ var ContentValidator = class {
       if (types.includes("toc") && !tocNav) {
         tocNav = nav;
       }
-      if (types.includes("page-list")) pageListCount++;
+      if (types.includes("page-list")) {
+        pageListCount++;
+        if (context.contentFeatures) context.contentFeatures.hasPageList = true;
+      }
       if (types.includes("landmarks")) landmarksCount++;
+      if (types.includes("loi") && context.contentFeatures) context.contentFeatures.hasLOI = true;
+      if (types.includes("lot") && context.contentFeatures) context.contentFeatures.hasLOT = true;
+      if (types.includes("loa") && context.contentFeatures) context.contentFeatures.hasLOA = true;
+      if (types.includes("lov") && context.contentFeatures) context.contentFeatures.hasLOV = true;
     }
     if (!tocNav) {
       pushMessage(context.messages, {
@@ -2985,6 +3583,14 @@ var ContentValidator = class {
       if (!isStandard) {
         this.checkNavFirstChildHeading(context, path, navElem);
       }
+      const flatNavType = types.includes("page-list") ? "page-list" : types.includes("landmarks") ? "landmarks" : null;
+      if (flatNavType && navElem.find(".//html:ol", XHTML_NS).length > 1) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_017,
+          message: `A "${flatNavType}" nav element should contain only a single ol descendant (no nested sublists)`,
+          location: { path }
+        });
+      }
       if (types.includes("landmarks")) {
         this.checkNavLandmarks(context, path, navElem);
       }
@@ -3627,6 +4233,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 {
@@ -3715,15 +4407,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,
@@ -3854,6 +4538,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 {
@@ -4057,7 +4757,7 @@ var ContentValidator = class {
       const altAttr = this.getAttribute(img, "alt");
       if (altAttr === null) {
         pushMessage(context.messages, {
-          id: MessageId.ACC_005,
+          id: MessageId.ACC_001,
           message: "Image is missing alt attribute",
           location: { path }
         });
@@ -4080,6 +4780,53 @@ var ContentValidator = class {
         });
       }
     }
+    const tables = root.find(".//html:table", XHTML_NS);
+    for (const table of tables) {
+      const tableElem = table;
+      const thCells = tableElem.find(".//html:th", XHTML_NS);
+      if (thCells.length === 0) {
+        pushMessage(context.messages, {
+          id: MessageId.ACC_005,
+          message: 'Table heading cells should be identified by "th" elements for accessibility',
+          location: { path }
+        });
+      }
+      for (const th of thCells) {
+        if (!th.content.trim()) {
+          pushMessage(context.messages, {
+            id: MessageId.ACC_014,
+            message: "Table header cell is empty",
+            location: { path }
+          });
+        }
+      }
+      if (!tableElem.get(".//html:thead", XHTML_NS)) {
+        pushMessage(context.messages, {
+          id: MessageId.ACC_006,
+          message: 'Tables should include a "thead" element for accessibility',
+          location: { path }
+        });
+      }
+      if (!tableElem.get("./html:caption", XHTML_NS)) {
+        pushMessage(context.messages, {
+          id: MessageId.ACC_012,
+          message: 'Table elements should include a "caption" element',
+          location: { path }
+        });
+      }
+    }
+    if (context.packageDocument?.version.startsWith("3.")) {
+      const epubTypeElements = root.find(".//*[@epub:type]", {
+        epub: "http://www.idpf.org/2007/ops"
+      });
+      if (epubTypeElements.length === 0) {
+        pushMessage(context.messages, {
+          id: MessageId.ACC_007,
+          message: 'Content Documents do not use "epub:type" attributes for semantic inflection',
+          location: { path }
+        });
+      }
+    }
   }
   hasSVGLinkAccessibleName(svgElem) {
     const ns = { svg: "http://www.w3.org/2000/svg" };
@@ -4104,6 +4851,46 @@ var ContentValidator = class {
       }
     }
   }
+  collectFeatures(context, root) {
+    const features = context.contentFeatures;
+    if (!features) return;
+    if (!features.hasTable && root.get(".//html:table", XHTML_NS)) {
+      features.hasTable = true;
+    }
+    if (!features.hasFigure && root.get(".//html:figure", XHTML_NS)) {
+      features.hasFigure = true;
+    }
+    if (!features.hasAudio && root.get(".//html:audio", XHTML_NS)) {
+      features.hasAudio = true;
+    }
+    if (!features.hasVideo && root.get(".//html:video", XHTML_NS)) {
+      features.hasVideo = true;
+    }
+    if (!features.hasPageBreak || !features.hasDictionary || !features.hasIndex) {
+      const epubTypeElements = root.find(".//*[@epub:type]", EPUB_OPS_NS);
+      for (const el of epubTypeElements) {
+        const attr = el.attr("type", "epub");
+        if (!attr?.value) continue;
+        const tokens = attr.value.trim().split(/\s+/);
+        if (!features.hasPageBreak && tokens.includes("pagebreak")) {
+          features.hasPageBreak = true;
+        }
+        if (!features.hasDictionary && tokens.includes("dictionary")) {
+          features.hasDictionary = true;
+        }
+        if (!features.hasIndex && tokens.includes("index")) {
+          features.hasIndex = true;
+        }
+        if (features.hasPageBreak && features.hasDictionary && features.hasIndex) break;
+      }
+    }
+    if (!features.hasMicrodata && root.get(".//*[@itemscope]")) {
+      features.hasMicrodata = true;
+    }
+    if (!features.hasRDFa && root.get(".//*[@property]")) {
+      features.hasRDFa = true;
+    }
+  }
   validateImages(context, path, root) {
     const packageDoc = context.packageDocument;
     if (!packageDoc) return;
@@ -4165,6 +4952,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(":");
@@ -4194,41 +4989,30 @@ var ContentValidator = class {
   }
   validateStylesheetLinks(context, path, root) {
     const linkElements = root.find(".//html:link[@rel]", { html: "http://www.w3.org/1999/xhtml" });
-    const stylesheetTitles = /* @__PURE__ */ new Map();
     for (const linkElem of linkElements) {
       const elem = linkElem;
       const relAttr = this.getAttribute(elem, "rel");
-      const titleAttr = this.getAttribute(elem, "title");
-      const hrefAttr = this.getAttribute(elem, "href");
-      if (!relAttr || !hrefAttr) continue;
-      const rel = relAttr.toLowerCase();
-      const rels = rel.split(/\s+/);
-      if (rels.includes("stylesheet")) {
-        const isAlternate = rels.includes("alternate");
-        if (isAlternate && !titleAttr) {
+      if (!relAttr) continue;
+      const rels = relAttr.toLowerCase().split(/\s+/);
+      const classAttr = this.getAttribute(elem, "class");
+      if (classAttr) {
+        const classSet = new Set(classAttr.toLowerCase().split(/\s+/));
+        if (classSet.has("vertical") && classSet.has("horizontal") || classSet.has("day") && classSet.has("night")) {
+          pushMessage(context.messages, {
+            id: MessageId.CSS_005,
+            message: `Conflicting Alt Style Tags found in class attribute: "${classAttr}"`,
+            location: { path }
+          });
+        }
+      }
+      if (rels.includes("stylesheet") && rels.includes("alternate")) {
+        if (!this.getAttribute(elem, "title")) {
           pushMessage(context.messages, {
             id: MessageId.CSS_015,
             message: "Alternate stylesheet must have a title attribute",
             location: { path }
           });
         }
-        if (titleAttr) {
-          const key = `${titleAttr}:${isAlternate ? "alt" : "persistent"}`;
-          const expectedRel = isAlternate ? "alternate" : "persistent";
-          const existing = stylesheetTitles.get(key);
-          if (existing) {
-            if (!existing.has(expectedRel)) {
-              pushMessage(context.messages, {
-                id: MessageId.CSS_005,
-                message: `Stylesheet with title "${titleAttr}" conflicts with another stylesheet with same title`,
-                location: { path }
-              });
-            }
-            existing.add(expectedRel);
-          } else {
-            stylesheetTitles.set(key, /* @__PURE__ */ new Set([expectedRel]));
-          }
-        }
       }
     }
   }
@@ -4260,6 +5044,17 @@ 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 packageDoc = context.packageDocument;
     const isFixedLayout = manifestItem && packageDoc ? isItemFixedLayout(packageDoc, manifestItem.id) : false;
@@ -4388,7 +5183,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) {
@@ -4452,6 +5247,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;
@@ -4561,11 +5365,12 @@ var ContentValidator = class {
       refValidator.addReference(svgRef);
     }
   }
-  extractAndRegisterStylesheets(context, 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 remoteBaseUrl = baseHref?.startsWith("http://") || baseHref?.startsWith("https://") ? baseHref : 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");
@@ -5150,56 +5955,309 @@ var ContentValidator = class {
       }
     }
   }
-  parseSrcset(srcset, docDir, opfDir, path, line, refValidator) {
-    const entries = srcset.split(",");
-    for (const entry of entries) {
-      const trimmed = entry.trim();
-      if (!trimmed) continue;
-      const url = trimmed.split(/\s+/)[0];
-      if (!url) continue;
-      const location = line !== void 0 ? { path, line } : { path };
-      if (url.startsWith("http://") || url.startsWith("https://")) {
-        refValidator.addReference({
-          url,
-          targetResource: url,
-          type: "image" /* IMAGE */,
-          location
-        });
-      } else {
-        const resolvedPath = this.resolveRelativePath(docDir, url, opfDir);
-        refValidator.addReference({
-          url,
-          targetResource: resolvedPath,
-          type: "image" /* IMAGE */,
-          location
-        });
-      }
-    }
-  }
-  resolveRelativePath(docDir, href, _opfDir) {
-    let decoded;
+  parseSrcset(srcset, docDir, opfDir, path, line, refValidator) {
+    const entries = srcset.split(",");
+    for (const entry of entries) {
+      const trimmed = entry.trim();
+      if (!trimmed) continue;
+      const url = trimmed.split(/\s+/)[0];
+      if (!url) continue;
+      const location = line !== void 0 ? { path, line } : { path };
+      if (url.startsWith("http://") || url.startsWith("https://")) {
+        refValidator.addReference({
+          url,
+          targetResource: url,
+          type: "image" /* IMAGE */,
+          location
+        });
+      } else {
+        const resolvedPath = this.resolveRelativePath(docDir, url, opfDir);
+        refValidator.addReference({
+          url,
+          targetResource: resolvedPath,
+          type: "image" /* IMAGE */,
+          location
+        });
+      }
+    }
+  }
+  resolveRelativePath(docDir, href, _opfDir) {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(href);
+    } catch {
+      decoded = href;
+    }
+    const hrefWithoutFragment = decoded.split("#")[0] ?? decoded;
+    const fragment = decoded.includes("#") ? decoded.split("#")[1] : "";
+    if (hrefWithoutFragment.startsWith("/")) {
+      const result2 = hrefWithoutFragment.slice(1).normalize("NFC");
+      return fragment ? `${result2}#${fragment}` : result2;
+    }
+    const parts = docDir ? docDir.split("/") : [];
+    const relParts = hrefWithoutFragment.split("/");
+    for (const part of relParts) {
+      if (part === "..") {
+        parts.pop();
+      } else if (part !== "." && part !== "") {
+        parts.push(part);
+      }
+    }
+    const result = parts.join("/").normalize("NFC");
+    return fragment ? `${result}#${fragment}` : result;
+  }
+  // ── Schematron-equivalent checks ──────────────────────────────────────────
+  checkDisallowedDescendants(context, path, root) {
+    const pairsByAncestor = /* @__PURE__ */ new Map([
+      ["dfn", ["dfn"]],
+      ["form", ["form"]],
+      ["progress", ["progress"]],
+      ["meter", ["meter"]],
+      ["header", ["header", "footer"]],
+      ["footer", ["footer", "header"]],
+      ["label", ["label"]],
+      ["address", ["address", "header", "footer"]],
+      ["caption", ["table"]],
+      ["audio", ["audio", "video"]],
+      ["video", ["video", "audio"]]
+    ]);
+    for (const [ancestor, descendants] of pairsByAncestor) {
+      try {
+        if (root.find(`.//html:${ancestor}`, XHTML_NS).length === 0) continue;
+      } catch {
+        continue;
+      }
+      for (const descendant of descendants) {
+        try {
+          const matches = root.find(`.//html:${ancestor}//html:${descendant}`, XHTML_NS);
+          for (const el of matches) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `The ${descendant} element must not appear inside ${ancestor} elements`,
+              location: { path, line: el.line }
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    const interactiveExprs = [
+      "html:a",
+      "html:audio[@controls]",
+      "html:button",
+      "html:details",
+      "html:embed",
+      "html:iframe",
+      "html:img[@usemap]",
+      "html:input[not(@type='hidden')]",
+      "html:label",
+      "html:select",
+      "html:textarea",
+      "html:video[@controls]"
+    ];
+    for (const ancestor of ["a", "button"]) {
+      try {
+        if (root.find(`.//html:${ancestor}`, XHTML_NS).length === 0) continue;
+      } catch {
+        continue;
+      }
+      for (const expr of interactiveExprs) {
+        try {
+          const matches = root.find(`.//html:${ancestor}//${expr}`, XHTML_NS);
+          for (const el of matches) {
+            const xmlEl = el;
+            const localName = xmlEl.name.includes(":") ? xmlEl.name.substring(xmlEl.name.indexOf(":") + 1) : xmlEl.name;
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `The ${localName} element must not appear inside ${ancestor} elements`,
+              location: { path, line: el.line }
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    try {
+      const bdos = root.find(".//html:bdo[not(@dir)]", XHTML_NS);
+      for (const el of bdos) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "The bdo element must have a dir attribute",
+          location: { path, line: el.line }
+        });
+      }
+    } catch {
+    }
+    try {
+      const maps = root.find(".//html:map[@id and @name]", XHTML_NS);
+      for (const el of maps) {
+        const id = this.getAttribute(el, "id");
+        const name = this.getAttribute(el, "name");
+        if (id && name && id !== name) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: "The id attribute on the map element must have the same value as the name attribute",
+            location: { path, line: el.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  checkMicrodataCoOccurrence(context, path, root) {
+    try {
+      const els = root.find(
+        ".//html:a[@itemprop and not(@href)] | .//html:area[@itemprop and not(@href)]",
+        XHTML_NS
+      );
+      for (const el of els) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "If the itemprop is specified on an a element, then the href attribute must also be specified",
+          location: { path, line: el.line }
+        });
+      }
+    } catch {
+    }
+    try {
+      const els = root.find(
+        ".//html:iframe[@itemprop and not(@data)] | .//html:embed[@itemprop and not(@data)] | .//html:object[@itemprop and not(@data)]",
+        XHTML_NS
+      );
+      for (const el of els) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "If the itemprop is specified on an iframe, embed or object element, then the data attribute must also be specified",
+          location: { path, line: el.line }
+        });
+      }
+    } catch {
+    }
+    try {
+      const els = root.find(
+        ".//html:audio[@itemprop and not(@src)] | .//html:video[@itemprop and not(@src)]",
+        XHTML_NS
+      );
+      for (const el of els) {
+        pushMessage(context.messages, {
+          id: MessageId.RSC_005,
+          message: "If the itemprop is specified on an video or audio element, then the src attribute must also be specified",
+          location: { path, line: el.line }
+        });
+      }
+    } catch {
+    }
+  }
+  checkUnknownElements(context, path, root) {
+    const XHTML_NS2 = "http://www.w3.org/1999/xhtml";
+    try {
+      const allElements = root.find(".//*");
+      for (const el of allElements) {
+        const xmlEl = el;
+        const ns = xmlEl.namespaceUri;
+        if (ns !== XHTML_NS2) continue;
+        const localName = xmlEl.name.includes(":") ? xmlEl.name.substring(xmlEl.name.indexOf(":") + 1) : xmlEl.name;
+        if (localName.includes("-")) continue;
+        if (!HTML5_ELEMENTS.has(localName)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `element "${localName}" not allowed here`,
+            location: { path, line: el.line }
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  checkForeignObjectContent(context, path, root, isSVGDoc) {
+    const SVG_NS = { svg: "http://www.w3.org/2000/svg" };
+    const XHTML_URI = "http://www.w3.org/1999/xhtml";
+    const DISALLOWED_FO_CHILDREN = /* @__PURE__ */ new Set(["body", "head", "html", "title"]);
+    let foreignObjects;
+    try {
+      foreignObjects = root.find(".//svg:foreignObject", SVG_NS);
+    } catch {
+      return;
+    }
+    for (const fo of foreignObjects) {
+      const foEl = fo;
+      let children;
+      try {
+        children = foEl.find("./*");
+      } catch {
+        continue;
+      }
+      let bodyCount = 0;
+      for (const child of children) {
+        const childEl = child;
+        const childNs = childEl.namespaceUri;
+        const childLocal = childEl.name.includes(":") ? childEl.name.substring(childEl.name.indexOf(":") + 1) : childEl.name;
+        if (isSVGDoc) {
+          if (childNs !== XHTML_URI) {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `element "${childLocal}" not allowed here`,
+              location: { path, line: child.line }
+            });
+            continue;
+          }
+          if (childLocal === "body") {
+            bodyCount++;
+            if (bodyCount > 1) {
+              pushMessage(context.messages, {
+                id: MessageId.RSC_005,
+                message: 'element "body" not allowed here',
+                location: { path, line: child.line }
+              });
+            }
+          } else if (childLocal === "title" || childLocal === "head" || childLocal === "html") {
+            pushMessage(context.messages, {
+              id: MessageId.RSC_005,
+              message: `element "${childLocal}" not allowed here`,
+              location: { path, line: child.line }
+            });
+          }
+        } else if (childNs === XHTML_URI && DISALLOWED_FO_CHILDREN.has(childLocal)) {
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `element "${childLocal}" not allowed here`,
+            location: { path, line: child.line }
+          });
+        }
+      }
+    }
+  }
+  checkSVGTitleContent(context, path, root) {
+    const SVG_NS = { svg: "http://www.w3.org/2000/svg" };
+    const XHTML_URI = "http://www.w3.org/1999/xhtml";
+    let svgTitles;
     try {
-      decoded = decodeURIComponent(href);
+      svgTitles = root.find(".//svg:title", SVG_NS);
     } catch {
-      decoded = href;
-    }
-    const hrefWithoutFragment = decoded.split("#")[0] ?? decoded;
-    const fragment = decoded.includes("#") ? decoded.split("#")[1] : "";
-    if (hrefWithoutFragment.startsWith("/")) {
-      const result2 = hrefWithoutFragment.slice(1).normalize("NFC");
-      return fragment ? `${result2}#${fragment}` : result2;
+      return;
     }
-    const parts = docDir ? docDir.split("/") : [];
-    const relParts = hrefWithoutFragment.split("/");
-    for (const part of relParts) {
-      if (part === "..") {
-        parts.pop();
-      } else if (part !== "." && part !== "") {
-        parts.push(part);
+    for (const titleNode of svgTitles) {
+      const titleEl = titleNode;
+      let descendants;
+      try {
+        descendants = titleEl.find(".//*");
+      } catch {
+        continue;
+      }
+      const reportedNamespaces = /* @__PURE__ */ new Set();
+      for (const desc of descendants) {
+        const descEl = desc;
+        const descNs = descEl.namespaceUri;
+        if (descNs && descNs !== XHTML_URI && !reportedNamespaces.has(descNs)) {
+          reportedNamespaces.add(descNs);
+          pushMessage(context.messages, {
+            id: MessageId.RSC_005,
+            message: `elements from namespace "${descNs}" are not allowed`,
+            location: { path, line: desc.line }
+          });
+        }
       }
     }
-    const result = parts.join("/").normalize("NFC");
-    return fragment ? `${result}#${fragment}` : result;
   }
 };
 
@@ -5649,6 +6707,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
@@ -6005,6 +7065,93 @@ var OCFValidator = class {
       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
    */
@@ -6032,6 +7179,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=["']([^"']+)["'])?[^>]*>/;
@@ -6382,6 +7588,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",
@@ -6718,7 +7943,6 @@ var RENDITION_META_RULES = [
 var KNOWN_RENDITION_META_PROPERTIES = new Set(
   RENDITION_META_RULES.map((r) => r.property.slice("rendition:".length))
 );
-var SMIL3_CLOCK_RE = /^([0-9]+:[0-5][0-9]:[0-5][0-9](\.[0-9]+)?|[0-5][0-9]:[0-5][0-9](\.[0-9]+)?|[0-9]+(\.[0-9]+)?(h|min|s|ms)?)$/;
 var GRANDFATHERED_LANG_TAGS = /* @__PURE__ */ new Set([
   "en-GB-oed",
   "i-ami",
@@ -6772,6 +7996,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);
@@ -6817,6 +8055,9 @@ var OPFValidator = class {
         }
       }
     }
+    if (this.packageDoc.version.startsWith("3.")) {
+      this.validateAccessibilityMetadata(context, opfPath);
+    }
   }
   /**
    * Build lookup maps for manifest items
@@ -6866,6 +8107,41 @@ var OPFValidator = class {
       }
     }
   }
+  /**
+   * Validate accessibility metadata (ACC-002, ACC-003, ACC-010)
+   */
+  validateAccessibilityMetadata(context, opfPath) {
+    if (!this.packageDoc) return;
+    const metaElements = this.packageDoc.metaElements;
+    const a11yProperties = [
+      "schema:accessMode",
+      "schema:accessibilityFeature",
+      "schema:accessibilityHazard",
+      "schema:accessibilitySummary"
+    ];
+    const hasAnyA11y = metaElements.some((m) => a11yProperties.includes(m.property));
+    if (!hasAnyA11y) {
+      pushMessage(context.messages, {
+        id: MessageId.ACC_003,
+        message: "Publication does not include any accessibility metadata",
+        location: { path: opfPath }
+      });
+    }
+    if (!metaElements.some((m) => m.property === "schema:accessibilityFeature")) {
+      pushMessage(context.messages, {
+        id: MessageId.ACC_002,
+        message: 'Missing "schema:accessibilityFeature" metadata',
+        location: { path: opfPath }
+      });
+    }
+    if (!metaElements.some((m) => m.property === "schema:accessMode")) {
+      pushMessage(context.messages, {
+        id: MessageId.ACC_010,
+        message: 'Missing "schema:accessMode" metadata',
+        location: { path: opfPath }
+      });
+    }
+  }
   /**
    * Validate metadata section
    */
@@ -7063,6 +8339,7 @@ var OPFValidator = class {
       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(
@@ -7430,19 +8707,42 @@ var OPFValidator = class {
   validateMediaOverlaysVocab(context, opfPath) {
     if (!this.packageDoc) return;
     const metas = this.packageDoc.metaElements;
-    for (const prop of ["media:active-class", "media:playback-active-class"]) {
-      if (metas.filter((m) => m.property === prop).length > 1) {
-        const displayName = prop.slice("media:".length);
+    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 (!SMIL3_CLOCK_RE.test(meta.value.trim())) {
+        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`,
@@ -7451,6 +8751,84 @@ var OPFValidator = class {
         }
       }
     }
+    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
@@ -7683,6 +9061,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)) {
@@ -8438,7 +9824,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)) {
@@ -8575,6 +9961,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)) {
@@ -8586,6 +9990,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
@@ -8645,7 +10061,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 ?? "";
@@ -8657,15 +10073,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;
@@ -8680,8 +10116,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
             });
           }
@@ -8900,11 +10336,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 {
@@ -9072,7 +10508,8 @@ var DEFAULT_OPTIONS = {
   includeUsage: false,
   includeInfo: true,
   maxErrors: 0,
-  locale: "en"
+  locale: "en",
+  customMessages: /* @__PURE__ */ new Map()
 };
 var EpubCheck = class _EpubCheck {
   options;
@@ -9098,6 +10535,9 @@ var EpubCheck = class _EpubCheck {
       files: /* @__PURE__ */ new Map(),
       rootfiles: []
     };
+    if (this.options.customMessages.size > 0) {
+      setSeverityOverrides(this.options.customMessages);
+    }
     try {
       const ocfValidator = new OCFValidator();
       ocfValidator.validate(context);
@@ -9115,6 +10555,7 @@ var EpubCheck = class _EpubCheck {
       }
       const contentValidator = new ContentValidator();
       contentValidator.validate(context, registry, refValidator);
+      this.validateCrossDocumentFeatures(context);
       if (context.packageDocument) {
         this.validateNCX(context, registry);
       }
@@ -9126,6 +10567,8 @@ var EpubCheck = class _EpubCheck {
         id: MessageId.PKG_025,
         message: error instanceof Error ? error.message : "Unknown validation error"
       });
+    } finally {
+      clearSeverityOverrides();
     }
     const elapsedMs = performance.now() - startTime;
     const filteredMessages = context.messages.filter((msg) => {
@@ -9156,6 +10599,76 @@ var EpubCheck = class _EpubCheck {
   get version() {
     return this.options.version;
   }
+  /**
+   * Cross-document feature validation (Pattern B from Java EPUBCheck)
+   */
+  validateCrossDocumentFeatures(context) {
+    const features = context.contentFeatures;
+    if (!features || !context.version.startsWith("3")) return;
+    const profile = context.options.profile;
+    const opfPath = context.opfPath ?? "";
+    if (profile === "edupub") {
+      if (features.hasPageBreak && !features.hasPageList) {
+        pushMessage(context.messages, {
+          id: MessageId.NAV_003,
+          message: 'The Navigation Document must have a page list when content contains page breaks (epub:type="pagebreak")',
+          location: { path: opfPath }
+        });
+      }
+      if (features.hasAudio && !features.hasLOA) {
+        pushMessage(context.messages, {
+          id: MessageId.NAV_005,
+          message: 'Content documents contain "audio" elements but the Navigation Document does not have a listing of audio clips (epub:type="loa")',
+          location: { path: opfPath }
+        });
+      }
+      if (features.hasFigure && !features.hasLOI) {
+        pushMessage(context.messages, {
+          id: MessageId.NAV_006,
+          message: 'Content documents contain "figure" elements but the Navigation Document does not have a listing of figures (epub:type="loi")',
+          location: { path: opfPath }
+        });
+      }
+      if (features.hasTable && !features.hasLOT) {
+        pushMessage(context.messages, {
+          id: MessageId.NAV_007,
+          message: 'Content documents contain "table" elements but the Navigation Document does not have a listing of tables (epub:type="lot")',
+          location: { path: opfPath }
+        });
+      }
+      if (features.hasVideo && !features.hasLOV) {
+        pushMessage(context.messages, {
+          id: MessageId.NAV_008,
+          message: 'Content documents contain "video" elements but the Navigation Document does not have a listing of video clips (epub:type="lov")',
+          location: { path: opfPath }
+        });
+      }
+      if (features.hasMicrodata && !features.hasRDFa) {
+        pushMessage(context.messages, {
+          id: MessageId.HTM_051,
+          message: "Found Microdata but no RDFa; EDUPUB recommends the use of RDFa Lite",
+          location: { path: opfPath }
+        });
+      }
+    }
+    const hasDictType = context.packageDocument?.dcElements.some(
+      (dc) => dc.name === "type" && dc.value === "dictionary"
+    ) ?? false;
+    if (features.hasDictionary && !hasDictType) {
+      pushMessage(context.messages, {
+        id: MessageId.OPF_079,
+        message: 'Dictionary content was found (epub:type "dictionary"), the Package Document should declare the dc:type "dictionary"',
+        location: { path: opfPath }
+      });
+    }
+    if (profile === "dict" && hasDictType && !features.hasDictionary) {
+      pushMessage(context.messages, {
+        id: MessageId.OPF_078,
+        message: 'An EPUB Dictionary must contain at least one Content Document with dictionary content (epub:type "dictionary")',
+        location: { path: opfPath }
+      });
+    }
+  }
   /**
    * Validate NCX navigation document (EPUB 2 always, EPUB 3 when NCX present)
    */
@@ -9298,6 +10811,7 @@ exports.formatMessages = formatMessages;
 exports.getAllMessages = getAllMessages;
 exports.getDefaultSeverity = getDefaultSeverity;
 exports.getMessageInfo = getMessageInfo;
+exports.parseCustomMessages = parseCustomMessages;
 exports.pushMessage = pushMessage;
 exports.toJSONReport = toJSONReport;
 //# sourceMappingURL=index.cjs.map