@likecoin/epubcheck-ts 0.1.0 → 0.2.1

package/dist/index.cjs

@@ -4,8 +4,25 @@ var libxml2Wasm = require('libxml2-wasm');
 var fflate = require('fflate');
 
 // src/content/validator.ts
+
+// src/references/types.ts
+function isPublicationResourceReference(type) {
+  return [
+    "generic" /* GENERIC */,
+    "stylesheet" /* STYLESHEET */,
+    "font" /* FONT */,
+    "image" /* IMAGE */,
+    "audio" /* AUDIO */,
+    "video" /* VIDEO */,
+    "track" /* TRACK */,
+    "media-overlay" /* MEDIA_OVERLAY */
+  ].includes(type);
+}
+
+// src/content/validator.ts
+var DISCOURAGED_ELEMENTS = /* @__PURE__ */ new Set(["base", "embed"]);
 var ContentValidator = class {
-  validate(context) {
+  validate(context, registry, refValidator) {
     const packageDoc = context.packageDocument;
     if (!packageDoc) {
       return;
@@ -15,11 +32,22 @@ var ContentValidator = class {
     for (const item of packageDoc.manifest) {
       if (item.mediaType === "application/xhtml+xml") {
         const fullPath = opfDir ? `${opfDir}/${item.href}` : item.href;
-        this.validateXHTMLDocument(context, fullPath, item.id);
+        this.validateXHTMLDocument(context, fullPath, item.id, opfDir, registry, refValidator);
+      } else if (item.mediaType === "text/css" && refValidator) {
+        const fullPath = opfDir ? `${opfDir}/${item.href}` : item.href;
+        this.validateCSSDocument(context, fullPath, opfDir, refValidator);
       }
     }
   }
-  validateXHTMLDocument(context, path, itemId) {
+  validateCSSDocument(context, path, opfDir, refValidator) {
+    const cssData = context.files.get(path);
+    if (!cssData) {
+      return;
+    }
+    const cssContent = new TextDecoder().decode(cssData);
+    this.extractCSSImports(path, cssContent, opfDir, refValidator);
+  }
+  validateXHTMLDocument(context, path, itemId, opfDir, registry, refValidator) {
     const data = context.files.get(path);
     if (!data) {
       return;
@@ -35,12 +63,19 @@ var ContentValidator = class {
       doc = libxml2Wasm.XmlDocument.fromString(content);
     } catch (error) {
       if (error instanceof Error) {
-        const message = this.normalizeErrorMessage(error.message);
+        const { message, line, column } = this.parseLibxmlError(error.message);
+        const location = { path };
+        if (line !== void 0) {
+          location.line = line;
+        }
+        if (column !== void 0) {
+          location.column = column;
+        }
         context.messages.push({
           id: "HTM-004",
           severity: "error",
           message,
-          location: { path }
+          location
         });
       }
       return;
@@ -84,33 +119,100 @@ var ContentValidator = class {
           location: { path }
         });
       }
-      const isNavItem = packageDoc.manifest.find(
-        (item) => item.id === itemId && item.properties?.includes("nav")
+      const manifestItem = packageDoc.manifest.find(
+        (item) => item.id === itemId
       );
+      const isNavItem = manifestItem?.properties?.includes("nav");
       if (isNavItem) {
         this.checkNavDocument(context, path, doc, root);
       }
+      if (context.version.startsWith("3")) {
+        const hasScripts = this.detectScripts(context, path, root);
+        if (hasScripts && !manifestItem?.properties?.includes("scripted")) {
+          context.messages.push({
+            id: "OPF-014",
+            severity: "error",
+            message: 'Content document contains scripts but manifest item is missing "scripted" property',
+            location: { path }
+          });
+        }
+        const hasMathML = this.detectMathML(context, path, root);
+        if (hasMathML && !manifestItem?.properties?.includes("mathml")) {
+          context.messages.push({
+            id: "OPF-014",
+            severity: "error",
+            message: 'Content document contains MathML but manifest item is missing "mathml" property',
+            location: { path }
+          });
+        }
+        const hasSVG = this.detectSVG(context, path, root);
+        if (hasSVG && !manifestItem?.properties?.includes("svg")) {
+          context.messages.push({
+            id: "OPF-014",
+            severity: "error",
+            message: 'Content document contains SVG but manifest item is missing "svg" property',
+            location: { path }
+          });
+        }
+        const hasRemoteResources = this.detectRemoteResources(context, path, root);
+        if (hasRemoteResources && !manifestItem?.properties?.includes("remote-resources")) {
+          context.messages.push({
+            id: "OPF-014",
+            severity: "error",
+            message: 'Content document references remote resources but manifest item is missing "remote-resources" property',
+            location: { path }
+          });
+        }
+      }
+      this.checkDiscouragedElements(context, path, root);
+      this.checkAccessibility(context, path, root);
+      this.validateImages(context, path, root);
+      if (context.version.startsWith("3")) {
+        this.validateEpubTypes(context, path, root);
+      }
+      this.validateStylesheetLinks(context, path, root);
+      this.validateViewportMeta(context, path, root, manifestItem);
+      if (registry) {
+        this.extractAndRegisterIDs(path, root, registry);
+      }
+      if (refValidator && opfDir !== void 0) {
+        this.extractAndRegisterHyperlinks(path, root, opfDir, refValidator);
+        this.extractAndRegisterStylesheets(path, root, opfDir, refValidator);
+        this.extractAndRegisterImages(path, root, opfDir, refValidator);
+      }
     } finally {
       doc.dispose();
     }
   }
-  normalizeErrorMessage(error) {
+  parseLibxmlError(error) {
+    const lineRegex = /(?:Entity:\s*)?line\s+(\d+):/;
+    const lineMatch = lineRegex.exec(error);
+    const line = lineMatch?.[1] ? Number.parseInt(lineMatch[1], 10) : void 0;
+    const columnRegex = /line\s+\d+:\s*(\d+):/;
+    const columnMatch = columnRegex.exec(error);
+    const column = columnMatch?.[1] ? Number.parseInt(columnMatch[1], 10) : void 0;
+    let message = error;
     if (error.includes("Opening and ending tag mismatch")) {
-      return `Mismatched closing tag: ${error.replace("Opening and ending tag mismatch: ", "")}`;
-    }
-    if (error.includes("mismatch")) {
-      return `Mismatched closing tag: ${error}`;
+      message = `Mismatched closing tag: ${error.replace("Opening and ending tag mismatch: ", "")}`;
+    } else if (error.includes("mismatch")) {
+      message = `Mismatched closing tag: ${error}`;
+    } else {
+      message = error.replace(/^Entity:\s*line\s+\d+:\s*(parser\s+error\s*:)?\s*/, "");
     }
-    return error;
+    return { message, line, column };
   }
   checkUnescapedAmpersands(context, path, content) {
-    const ampersandPattern = /&(?!(?:[a-zA-Z][a-zA-Z0-9]*|#\d+|#x[0-9a-fA-F]+);)/g;
-    if (ampersandPattern.test(content)) {
+    const ampersandRegex = /&(?!(?:[a-zA-Z][a-zA-Z0-9]*|#\d+|#x[0-9a-fA-F]+);)/g;
+    let match;
+    while ((match = ampersandRegex.exec(content)) !== null) {
+      const index = match.index ?? 0;
+      const before = content.substring(0, index);
+      const line = before.split("\n").length;
       context.messages.push({
         id: "HTM-012",
         severity: "error",
         message: "Unescaped ampersand",
-        location: { path }
+        location: { path, line }
       });
     }
   }
@@ -148,6 +250,633 @@ var ContentValidator = class {
         location: { path }
       });
     }
+    this.checkNavRemoteLinks(context, path, root, epubTypeAttr?.value ?? "");
+  }
+  checkNavRemoteLinks(context, path, root, epubTypeValue) {
+    const navTypes = epubTypeValue.split(/\s+/);
+    const isToc = navTypes.includes("toc");
+    const isLandmarks = navTypes.includes("landmarks");
+    const isPageList = navTypes.includes("page-list");
+    if (!isToc && !isLandmarks && !isPageList) {
+      return;
+    }
+    const links = root.find(".//html:a[@href]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const link of links) {
+      const href = this.getAttribute(link, "href");
+      if (href && (href.startsWith("http://") || href.startsWith("https://"))) {
+        const navType = isToc ? "toc" : isLandmarks ? "landmarks" : "page-list";
+        context.messages.push({
+          id: "NAV-010",
+          severity: "error",
+          message: `"${navType}" nav must not link to remote resources; found link to "${href}"`,
+          location: { path }
+        });
+      }
+    }
+  }
+  detectScripts(_context, _path, root) {
+    const htmlScript = root.get(".//html:script", { html: "http://www.w3.org/1999/xhtml" });
+    if (htmlScript) return true;
+    const svgScript = root.get(".//svg:script", { svg: "http://www.w3.org/2000/svg" });
+    if (svgScript) return true;
+    const form = root.get(".//html:form", { html: "http://www.w3.org/1999/xhtml" });
+    if (form) return true;
+    const elementsWithEvents = root.find(
+      ".//*[@onclick or @onload or @onmouseover or @onmouseout or @onchange or @onsubmit or @onfocus or @onblur]"
+    );
+    if (elementsWithEvents.length > 0) return true;
+    return false;
+  }
+  detectMathML(_context, _path, root) {
+    const mathMLElements = root.find(".//math:*", { math: "http://www.w3.org/1998/Math/MathML" });
+    return mathMLElements.length > 0;
+  }
+  detectSVG(_context, _path, root) {
+    const svgElement = root.get(".//html:svg", { html: "http://www.w3.org/1999/xhtml" });
+    if (svgElement) return true;
+    const rootSvg = root.get(".//svg:svg", { svg: "http://www.w3.org/2000/svg" });
+    if (rootSvg) return true;
+    return false;
+  }
+  /**
+   * Detect if the content document references remote resources that require
+   * the "remote-resources" property in the manifest.
+   * Per EPUB spec and Java EPUBCheck behavior:
+   * - Remote images, audio, video, fonts REQUIRE the property
+   * - Remote hyperlinks (<a href>) do NOT require the property
+   * - Remote scripts do NOT require the property (scripted property is used instead)
+   * - Remote stylesheets DO require the property
+   */
+  detectRemoteResources(_context, _path, root) {
+    const images = root.find(".//html:img[@src]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const img of images) {
+      const src = this.getAttribute(img, "src");
+      if (src && (src.startsWith("http://") || src.startsWith("https://"))) {
+        return true;
+      }
+    }
+    const audio = root.find(".//html:audio[@src]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const elem of audio) {
+      const src = this.getAttribute(elem, "src");
+      if (src && (src.startsWith("http://") || src.startsWith("https://"))) {
+        return true;
+      }
+    }
+    const video = root.find(".//html:video[@src]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const elem of video) {
+      const src = this.getAttribute(elem, "src");
+      if (src && (src.startsWith("http://") || src.startsWith("https://"))) {
+        return true;
+      }
+    }
+    const sources = root.find(".//html:source[@src]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const source of sources) {
+      const src = this.getAttribute(source, "src");
+      if (src && (src.startsWith("http://") || src.startsWith("https://"))) {
+        return true;
+      }
+    }
+    const linkElements = root.find(".//html:link[@rel and @href]", {
+      html: "http://www.w3.org/1999/xhtml"
+    });
+    for (const linkElem of linkElements) {
+      const rel = this.getAttribute(linkElem, "rel");
+      const href = this.getAttribute(linkElem, "href");
+      if (href && rel?.toLowerCase().includes("stylesheet")) {
+        if (href.startsWith("http://") || href.startsWith("https://")) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  checkDiscouragedElements(context, path, root) {
+    for (const elemName of DISCOURAGED_ELEMENTS) {
+      const element = root.get(`.//html:${elemName}`, { html: "http://www.w3.org/1999/xhtml" });
+      if (element) {
+        context.messages.push({
+          id: "HTM-055",
+          severity: "usage",
+          message: `The "${elemName}" element is discouraged in EPUB`,
+          location: { path }
+        });
+      }
+    }
+  }
+  checkAccessibility(context, path, root) {
+    const links = root.find(".//html:a", { html: "http://www.w3.org/1999/xhtml" });
+    for (const link of links) {
+      if (!this.hasAccessibleContent(link)) {
+        context.messages.push({
+          id: "ACC-004",
+          severity: "warning",
+          message: "Hyperlink has no accessible text content",
+          location: { path }
+        });
+      }
+    }
+    const images = root.find(".//html:img", { html: "http://www.w3.org/1999/xhtml" });
+    for (const img of images) {
+      const altAttr = this.getAttribute(img, "alt");
+      if (altAttr === null) {
+        context.messages.push({
+          id: "ACC-005",
+          severity: "warning",
+          message: "Image is missing alt attribute",
+          location: { path }
+        });
+      }
+    }
+    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) {
+        context.messages.push({
+          id: "ACC-011",
+          severity: "usage",
+          message: "SVG hyperlink has no accessible name (missing title element or aria-label)",
+          location: { path }
+        });
+      }
+    }
+    const mathElements = root.find(".//math:math", { math: "http://www.w3.org/1998/Math/MathML" });
+    for (const mathElem of mathElements) {
+      const elem = mathElem;
+      const alttext = elem.attr("alttext");
+      const annotation = elem.get('./math:annotation[@encoding="application/x-tex"]', {
+        math: "http://www.w3.org/1998/Math/MathML"
+      });
+      const ariaLabel = this.getAttribute(elem, "aria-label");
+      if (!alttext?.value && !annotation && !ariaLabel) {
+        context.messages.push({
+          id: "ACC-009",
+          severity: "usage",
+          message: "MathML element should have alttext attribute or annotation for accessibility",
+          location: { path }
+        });
+      }
+    }
+  }
+  validateImages(context, path, root) {
+    const packageDoc = context.packageDocument;
+    if (!packageDoc) return;
+    const images = root.find(".//html:img[@src]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const img of images) {
+      const imgElem = img;
+      const srcAttr = this.getAttribute(imgElem, "src");
+      if (!srcAttr) continue;
+      const src = srcAttr;
+      const opfDir = context.opfPath?.includes("/") ? context.opfPath.substring(0, context.opfPath.lastIndexOf("/")) : "";
+      let fullPath = src;
+      if (opfDir && !src.startsWith("http://") && !src.startsWith("https://")) {
+        if (src.startsWith("/")) {
+          fullPath = src.slice(1);
+        } else {
+          const parts = opfDir.split("/");
+          const relParts = src.split("/");
+          for (const part of relParts) {
+            if (part === "..") {
+              parts.pop();
+            } else if (part !== ".") {
+              parts.push(part);
+            }
+          }
+          fullPath = parts.join("/");
+        }
+      }
+      if (src.startsWith("http://") || src.startsWith("https://")) {
+        continue;
+      }
+      const manifestItem = packageDoc.manifest.find(
+        (item) => fullPath.endsWith(item.href) || item.href.endsWith(fullPath)
+      );
+      if (!manifestItem) {
+        context.messages.push({
+          id: "MED-001",
+          severity: "error",
+          message: `Image src references missing manifest item: ${src}`,
+          location: { path }
+        });
+        continue;
+      }
+      const imageMediaTypes = /* @__PURE__ */ new Set([
+        "image/gif",
+        "image/jpeg",
+        "image/jpg",
+        "image/png",
+        "image/svg+xml",
+        "image/webp"
+      ]);
+      if (!imageMediaTypes.has(manifestItem.mediaType)) {
+        context.messages.push({
+          id: "OPF-051",
+          severity: "error",
+          message: `Image has invalid media type "${manifestItem.mediaType}": ${src}`,
+          location: { path }
+        });
+      }
+    }
+  }
+  validateEpubTypes(context, path, root) {
+    const epubTypeElements = root.find(".//*[@epub:type]", {
+      epub: "http://www.idpf.org/2007/ops"
+    });
+    const knownPrefixes = /* @__PURE__ */ new Set([
+      "",
+      "http://idpf.org/epub/structure/v1/",
+      "http://idpf.org/epub/vocab/structure/",
+      "http://www.idpf.org/2007/ops"
+    ]);
+    for (const elem of epubTypeElements) {
+      const elemTyped = elem;
+      const epubTypeAttr = elemTyped.attr("epub:type");
+      if (!epubTypeAttr?.value) continue;
+      const epubTypeValue = epubTypeAttr.value;
+      for (const part of epubTypeValue.split(/\s+/)) {
+        const prefix = part.includes(":") ? part.substring(0, part.indexOf(":")) : "";
+        if (!knownPrefixes.has(prefix) && !prefix.startsWith("http://") && !prefix.startsWith("https://")) {
+          context.messages.push({
+            id: "OPF-088",
+            severity: "usage",
+            message: `Unknown epub:type prefix "${prefix}": ${epubTypeValue}`,
+            location: { path }
+          });
+        }
+      }
+    }
+  }
+  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) {
+          context.messages.push({
+            id: "CSS-015",
+            severity: "error",
+            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)) {
+              context.messages.push({
+                id: "CSS-005",
+                severity: "error",
+                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]));
+          }
+        }
+      }
+    }
+  }
+  hasAccessibleContent(element) {
+    const textContent = element.content;
+    if (textContent && textContent.trim().length > 0) {
+      return true;
+    }
+    const ariaLabel = this.getAttribute(element, "aria-label");
+    if (ariaLabel && ariaLabel.trim().length > 0) {
+      return true;
+    }
+    const img = element.get("./html:img[@alt]", { html: "http://www.w3.org/1999/xhtml" });
+    if (img) {
+      const alt = this.getAttribute(img, "alt");
+      if (alt && alt.trim().length > 0) {
+        return true;
+      }
+    }
+    const title = this.getAttribute(element, "title");
+    if (title && title.trim().length > 0) {
+      return true;
+    }
+    return false;
+  }
+  getAttribute(element, name) {
+    if (!("attrs" in element)) return null;
+    const attrs = element.attrs;
+    const attr = attrs.find((a) => a.name === name);
+    return attr?.value ?? 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 nameAttr = this.getAttribute(meta, "name");
+      if (nameAttr === "viewport") {
+        hasViewportMeta = true;
+        const contentAttr = this.getAttribute(meta, "content");
+        if (isFixedLayout) {
+          if (!contentAttr) {
+            context.messages.push({
+              id: "HTM-046",
+              severity: "error",
+              message: "Viewport meta element should have a content attribute in fixed-layout documents",
+              location: { path }
+            });
+            continue;
+          }
+          const contentLower = contentAttr.toLowerCase();
+          if (contentLower.includes("width=device-width")) {
+            context.messages.push({
+              id: "HTM-047",
+              severity: "error",
+              message: 'Viewport width should not be set to "device-width" in fixed-layout documents',
+              location: { path }
+            });
+          }
+          if (contentLower.includes("height=device-height")) {
+            context.messages.push({
+              id: "HTM-048",
+              severity: "error",
+              message: 'Viewport height should not be set to "device-height" in fixed-layout documents',
+              location: { path }
+            });
+          }
+        } else {
+          context.messages.push({
+            id: "HTM-060b",
+            severity: "usage",
+            message: `EPUB reading systems must ignore viewport meta elements in reflowable documents; viewport declaration "${contentAttr ?? ""}" will be ignored`,
+            location: { path }
+          });
+        }
+      }
+    }
+    if (isFixedLayout && !hasViewportMeta) {
+      context.messages.push({
+        id: "HTM-049",
+        severity: "info",
+        message: "Fixed-layout document should include a viewport meta element",
+        location: { path }
+      });
+    }
+  }
+  extractAndRegisterIDs(path, root, registry) {
+    const elementsWithId = root.find(".//*[@id]");
+    for (const elem of elementsWithId) {
+      const id = this.getAttribute(elem, "id");
+      if (id) {
+        registry.registerID(path, id);
+      }
+    }
+  }
+  extractAndRegisterHyperlinks(path, root, opfDir, refValidator) {
+    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    const links = root.find(".//html:a[@href]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const link of links) {
+      const href = this.getAttribute(link, "href");
+      if (!href) continue;
+      if (href.startsWith("http://") || href.startsWith("https://")) {
+        continue;
+      }
+      if (href.startsWith("mailto:") || href.startsWith("tel:")) {
+        continue;
+      }
+      if (href.startsWith("#")) {
+        const targetResource2 = path;
+        const fragment = href.slice(1);
+        refValidator.addReference({
+          url: href,
+          targetResource: targetResource2,
+          fragment,
+          type: "hyperlink" /* HYPERLINK */,
+          location: { path }
+        });
+        continue;
+      }
+      const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
+      const hashIndex = resolvedPath.indexOf("#");
+      const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
+      const fragmentPart = hashIndex >= 0 ? resolvedPath.slice(hashIndex + 1) : void 0;
+      const ref = {
+        url: href,
+        targetResource,
+        type: "hyperlink" /* HYPERLINK */,
+        location: { path }
+      };
+      if (fragmentPart) {
+        ref.fragment = fragmentPart;
+      }
+      refValidator.addReference(ref);
+    }
+    const svgLinks = root.find(".//svg:a", {
+      svg: "http://www.w3.org/2000/svg",
+      xlink: "http://www.w3.org/1999/xlink"
+    });
+    for (const link of svgLinks) {
+      const elem = link;
+      const href = this.getAttribute(elem, "xlink:href") ?? this.getAttribute(elem, "href");
+      if (!href) continue;
+      if (href.startsWith("http://") || href.startsWith("https://")) {
+        continue;
+      }
+      if (href.startsWith("#")) {
+        const targetResource2 = path;
+        const fragment = href.slice(1);
+        refValidator.addReference({
+          url: href,
+          targetResource: targetResource2,
+          fragment,
+          type: "hyperlink" /* HYPERLINK */,
+          location: { path }
+        });
+        continue;
+      }
+      const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
+      const hashIndex = resolvedPath.indexOf("#");
+      const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
+      const svgFragment = hashIndex >= 0 ? resolvedPath.slice(hashIndex + 1) : void 0;
+      const svgRef = {
+        url: href,
+        targetResource,
+        type: "hyperlink" /* HYPERLINK */,
+        location: { path }
+      };
+      if (svgFragment) {
+        svgRef.fragment = svgFragment;
+      }
+      refValidator.addReference(svgRef);
+    }
+  }
+  extractAndRegisterStylesheets(path, root, opfDir, refValidator) {
+    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    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");
+      const rel = this.getAttribute(linkElem, "rel");
+      if (!href) continue;
+      const isStylesheet = rel?.toLowerCase().includes("stylesheet");
+      const type = isStylesheet ? "stylesheet" /* STYLESHEET */ : "link" /* LINK */;
+      if (href.startsWith("http://") || href.startsWith("https://")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: href,
+          type,
+          location: { path }
+        });
+        continue;
+      }
+      const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
+      const hashIndex = resolvedPath.indexOf("#");
+      const targetResource = hashIndex >= 0 ? resolvedPath.slice(0, hashIndex) : resolvedPath;
+      refValidator.addReference({
+        url: href,
+        targetResource,
+        type,
+        location: { path }
+      });
+    }
+  }
+  /**
+   * Parse CSS content and extract @import statements
+   */
+  extractCSSImports(cssPath, cssContent, opfDir, refValidator) {
+    const cssDir = cssPath.includes("/") ? cssPath.substring(0, cssPath.lastIndexOf("/")) : "";
+    const cleanedCSS = cssContent.replace(/\/\*[\s\S]*?\*\//g, "");
+    const importRegex = /@import\s+(?:url\s*\(\s*)?["']([^"']+)["']\s*\)?[^;]*;/gi;
+    let match;
+    while ((match = importRegex.exec(cleanedCSS)) !== null) {
+      const importUrl = match[1];
+      if (!importUrl) continue;
+      if (importUrl.startsWith("http://") || importUrl.startsWith("https://")) {
+        refValidator.addReference({
+          url: importUrl,
+          targetResource: importUrl,
+          type: "stylesheet" /* STYLESHEET */,
+          location: { path: cssPath }
+        });
+        continue;
+      }
+      const resolvedPath = this.resolveRelativePath(cssDir, importUrl, opfDir);
+      refValidator.addReference({
+        url: importUrl,
+        targetResource: resolvedPath,
+        type: "stylesheet" /* STYLESHEET */,
+        location: { path: cssPath }
+      });
+    }
+  }
+  extractAndRegisterImages(path, root, opfDir, refValidator) {
+    const docDir = path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : "";
+    const images = root.find(".//html:img[@src]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const img of images) {
+      const src = this.getAttribute(img, "src");
+      if (!src) continue;
+      if (src.startsWith("http://") || src.startsWith("https://")) {
+        refValidator.addReference({
+          url: src,
+          targetResource: src,
+          type: "image" /* IMAGE */,
+          location: { path }
+        });
+        continue;
+      }
+      const resolvedPath = this.resolveRelativePath(docDir, src, opfDir);
+      refValidator.addReference({
+        url: src,
+        targetResource: resolvedPath,
+        type: "image" /* IMAGE */,
+        location: { path }
+      });
+    }
+    let svgImages = [];
+    try {
+      const svgImagesXlink = root.find(".//svg:image[@xlink:href]", {
+        svg: "http://www.w3.org/2000/svg",
+        xlink: "http://www.w3.org/1999/xlink"
+      });
+      const svgImagesHref = root.find(".//svg:image[@href]", {
+        svg: "http://www.w3.org/2000/svg"
+      });
+      svgImages = [...svgImagesXlink, ...svgImagesHref];
+    } catch {
+      svgImages = [];
+    }
+    for (const svgImg of svgImages) {
+      const elem = svgImg;
+      const href = this.getAttribute(elem, "xlink:href") ?? this.getAttribute(elem, "href");
+      if (!href) continue;
+      if (href.startsWith("http://") || href.startsWith("https://")) {
+        refValidator.addReference({
+          url: href,
+          targetResource: href,
+          type: "image" /* IMAGE */,
+          location: { path }
+        });
+        continue;
+      }
+      const resolvedPath = this.resolveRelativePath(docDir, href, opfDir);
+      refValidator.addReference({
+        url: href,
+        targetResource: resolvedPath,
+        type: "image" /* IMAGE */,
+        location: { path }
+      });
+    }
+    const videos = root.find(".//html:video[@poster]", { html: "http://www.w3.org/1999/xhtml" });
+    for (const video of videos) {
+      const poster = this.getAttribute(video, "poster");
+      if (!poster) continue;
+      if (poster.startsWith("http://") || poster.startsWith("https://")) {
+        refValidator.addReference({
+          url: poster,
+          targetResource: poster,
+          type: "image" /* IMAGE */,
+          location: { path }
+        });
+        continue;
+      }
+      const resolvedPath = this.resolveRelativePath(docDir, poster, opfDir);
+      refValidator.addReference({
+        url: poster,
+        targetResource: resolvedPath,
+        type: "image" /* IMAGE */,
+        location: { path }
+      });
+    }
+  }
+  resolveRelativePath(docDir, href, _opfDir) {
+    const hrefWithoutFragment = href.split("#")[0] ?? href;
+    const fragment = href.includes("#") ? href.split("#")[1] : "";
+    if (hrefWithoutFragment.startsWith("/")) {
+      const result2 = hrefWithoutFragment.slice(1);
+      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("/");
+    return fragment ? `${result}#${fragment}` : result;
   }
 };
 
@@ -230,9 +959,6 @@ function toJSONReport(result) {
   );
 }
 var NCXValidator = class {
-  /**
-   * Validate NCX document
-   */
   validate(context, ncxContent, ncxPath) {
     let doc = null;
     try {
@@ -270,15 +996,11 @@ var NCXValidator = class {
       }
       this.checkUid(context, root, ncxPath);
       this.checkNavMap(context, root, ncxPath);
+      this.checkContentSrc(context, root, ncxPath);
     } finally {
       doc.dispose();
     }
   }
-  /**
-   * Check for dtb:uid meta element and validate it
-   * Note: dtb:uid is recommended but not strictly required by the NCX spec.
-   * The original epubcheck does not report an error if it's missing.
-   */
   checkUid(context, root, path) {
     const uidMeta = root.get('.//ncx:head/ncx:meta[@name="dtb:uid"]', {
       ncx: "http://www.daisy.org/z3986/2005/ncx/"
@@ -300,9 +1022,6 @@ var NCXValidator = class {
     }
     context.ncxUid = uidContent.trim();
   }
-  /**
-   * Check for navMap element
-   */
   checkNavMap(context, root, path) {
     const navMapNode = root.get(".//ncx:navMap", { ncx: "http://www.daisy.org/z3986/2005/ncx/" });
     if (!navMapNode) {
@@ -314,15 +1033,54 @@ var NCXValidator = class {
       });
     }
   }
+  checkContentSrc(context, root, ncxPath) {
+    const contentElements = root.find(".//ncx:content[@src]", {
+      ncx: "http://www.daisy.org/z3986/2005/ncx/"
+    });
+    const ncxDir = ncxPath.includes("/") ? ncxPath.substring(0, ncxPath.lastIndexOf("/")) : "";
+    for (const contentElem of contentElements) {
+      const srcAttr = contentElem.attr("src");
+      const src = srcAttr?.value;
+      if (!src) continue;
+      const srcBase = src.split("#")[0] ?? src;
+      let fullPath = srcBase;
+      if (ncxDir) {
+        if (srcBase.startsWith("/")) {
+          fullPath = srcBase.slice(1);
+        } else {
+          const parts = ncxDir.split("/");
+          const relParts = srcBase.split("/");
+          for (const part of relParts) {
+            if (part === "..") {
+              parts.pop();
+            } else if (part !== ".") {
+              parts.push(part);
+            }
+          }
+          fullPath = parts.join("/");
+        }
+      }
+      if (!context.files.has(fullPath) && !srcBase.startsWith("http://") && !srcBase.startsWith("https://")) {
+        context.messages.push({
+          id: "NCX-006",
+          severity: "error",
+          message: `NCX content src references missing file: ${src}`,
+          location: { path: ncxPath }
+        });
+      }
+    }
+  }
 };
 var ZipReader = class _ZipReader {
   files;
   _paths;
   _originalOrder;
-  constructor(files, originalOrder) {
+  _rawData;
+  constructor(files, originalOrder, rawData) {
     this.files = files;
     this._originalOrder = originalOrder;
     this._paths = Object.keys(files).sort();
+    this._rawData = rawData;
   }
   /**
    * Open a ZIP file from binary data
@@ -330,7 +1088,45 @@ var ZipReader = class _ZipReader {
   static open(data) {
     const files = fflate.unzipSync(data);
     const originalOrder = Object.keys(files);
-    return new _ZipReader(files, originalOrder);
+    return new _ZipReader(files, originalOrder, data);
+  }
+  /**
+   * Get compression info for the first entry (mimetype) from raw ZIP header
+   * ZIP Local File Header format:
+   * - Offset 0-3: Signature (0x04034b50)
+   * - Offset 4-5: Version needed
+   * - Offset 6-7: General purpose bit flag
+   * - Offset 8-9: Compression method (0=stored, 8=deflated)
+   * - Offset 10-13: Last mod time/date
+   * - Offset 14-17: CRC-32
+   * - Offset 18-21: Compressed size
+   * - Offset 22-25: Uncompressed size
+   * - Offset 26-27: Filename length
+   * - Offset 28-29: Extra field length
+   * - Offset 30+: Filename
+   */
+  getMimetypeCompressionInfo() {
+    const data = this._rawData;
+    if (data.length < 30) {
+      return null;
+    }
+    if (data[0] !== 80 || data[1] !== 75 || data[2] !== 3 || data[3] !== 4) {
+      return null;
+    }
+    const compressionMethod = (data[8] ?? 0) | (data[9] ?? 0) << 8;
+    const filenameLength = (data[26] ?? 0) | (data[27] ?? 0) << 8;
+    const extraFieldLength = (data[28] ?? 0) | (data[29] ?? 0) << 8;
+    if (data.length < 30 + filenameLength) {
+      return null;
+    }
+    const filenameBytes = data.slice(30, 30 + filenameLength);
+    const filename = fflate.strFromU8(filenameBytes);
+    return {
+      compressionMethod,
+      extraFieldLength,
+      filenameLength,
+      filename
+    };
   }
   /**
    * Get all file paths in the ZIP (sorted alphabetically)
@@ -408,6 +1204,8 @@ var OCFValidator = class {
     this.validateMimetype(zip, context.messages);
     this.validateContainer(zip, context);
     this.validateMetaInf(zip, context.messages);
+    this.validateFilenames(zip, context.messages);
+    this.validateEmptyDirectories(zip, context.messages);
   }
   /**
    * Validate the mimetype file
@@ -415,28 +1213,54 @@ var OCFValidator = class {
    * Requirements:
    * - Must exist
    * - Must be first file in ZIP
-   * - Must be uncompressed
+   * - Must be uncompressed (compression method = 0)
+   * - Must have no extra field
    * - Must contain exactly "application/epub+zip"
    */
   validateMimetype(zip, messages) {
-    if (!zip.has("mimetype")) {
+    const compressionInfo = zip.getMimetypeCompressionInfo();
+    if (compressionInfo === null) {
       messages.push({
         id: "PKG-006",
         severity: "error",
-        message: "Missing mimetype file",
+        message: "Could not read ZIP header",
         location: { path: "mimetype" }
       });
       return;
     }
-    const originalOrder = zip.originalOrder;
-    if (originalOrder.length > 0 && originalOrder[0] !== "mimetype") {
+    if (compressionInfo.filename !== "mimetype") {
+      messages.push({
+        id: "PKG-006",
+        severity: "error",
+        message: "Mimetype file must be the first file in the ZIP archive",
+        location: { path: "mimetype" }
+      });
+    }
+    if (compressionInfo.extraFieldLength !== 0) {
       messages.push({
         id: "PKG-005",
         severity: "error",
-        message: "The mimetype file must be the first file in the ZIP archive",
+        message: `Mimetype entry must not have an extra field (found ${String(compressionInfo.extraFieldLength)} bytes)`,
+        location: { path: "mimetype" }
+      });
+    }
+    if (compressionInfo.compressionMethod !== 0) {
+      messages.push({
+        id: "PKG-006",
+        severity: "error",
+        message: "Mimetype file must be uncompressed",
         location: { path: "mimetype" }
       });
     }
+    if (!zip.has("mimetype")) {
+      messages.push({
+        id: "PKG-006",
+        severity: "error",
+        message: "Missing mimetype file",
+        location: { path: "mimetype" }
+      });
+      return;
+    }
     const content = zip.readText("mimetype");
     if (content === void 0) {
       messages.push({
@@ -547,6 +1371,94 @@ var OCFValidator = class {
         message: "Missing META-INF directory",
         location: { path: "META-INF/" }
       });
+      return;
+    }
+    const allowedFiles = /* @__PURE__ */ new Set([
+      "container.xml",
+      "encryption.xml",
+      "signatures.xml",
+      "metadata.xml"
+    ]);
+    for (const file of metaInfFiles) {
+      if (file === "META-INF/") continue;
+      const filename = file.replace("META-INF/", "");
+      if (!allowedFiles.has(filename)) {
+        messages.push({
+          id: "PKG-025",
+          severity: "error",
+          message: `File not allowed in META-INF directory: ${filename}`,
+          location: { path: file }
+        });
+      }
+    }
+  }
+  /**
+   * Validate filenames for invalid characters
+   */
+  validateFilenames(zip, messages) {
+    for (const path of zip.paths) {
+      if (path === "mimetype") continue;
+      if (path.endsWith("/")) continue;
+      const filename = path.includes("/") ? path.split("/").pop() ?? path : path;
+      if (filename === "" || filename === "." || filename === "..") {
+        messages.push({
+          id: "PKG-009",
+          severity: "error",
+          message: `Invalid filename: "${path}"`,
+          location: { path }
+        });
+        continue;
+      }
+      for (let i = 0; i < filename.length; i++) {
+        const code = filename.charCodeAt(i);
+        if (code < 32 || code === 127 || code >= 128 && code <= 159) {
+          messages.push({
+            id: "PKG-010",
+            severity: "error",
+            message: `Filename contains control character: "${path}"`,
+            location: { path }
+          });
+          break;
+        }
+      }
+      const specialChars = '<>:"|?*';
+      for (const char of specialChars) {
+        if (filename.includes(char)) {
+          messages.push({
+            id: "PKG-011",
+            severity: "error",
+            message: `Filename contains special character: "${path}"`,
+            location: { path }
+          });
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * Validate empty directories
+   */
+  validateEmptyDirectories(zip, messages) {
+    const directories = /* @__PURE__ */ new Set();
+    for (const path of zip.paths) {
+      const parts = path.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        const dir = parts.slice(0, i).join("/") + "/";
+        directories.add(dir);
+      }
+    }
+    for (const dir of directories) {
+      if (dir !== "META-INF/" && dir !== "OEBPS/" && dir !== "OPS/") {
+        const filesInDir = zip.paths.filter((p) => p.startsWith(dir) && p !== dir);
+        if (filesInDir.length === 0) {
+          messages.push({
+            id: "PKG-014",
+            severity: "warning",
+            message: `Empty directory found: ${dir}`,
+            location: { path: dir }
+          });
+        }
+      }
     }
   }
 };
@@ -583,6 +1495,7 @@ function parseOPF(xml) {
   const spineResult = parseSpine(spineSection, spineAttrs);
   const guideSection = extractSection(xml, "guide");
   const guide = parseGuide(guideSection);
+  const collections = parseCollections(xml);
   const result = {
     version,
     uniqueIdentifier,
@@ -591,7 +1504,8 @@ function parseOPF(xml) {
     linkElements,
     manifest,
     spine: spineResult.spine,
-    guide
+    guide,
+    collections
   };
   if (Object.keys(prefixes).length > 0) {
     result.prefixes = prefixes;
@@ -825,6 +1739,42 @@ function parseAttributes(attrsStr) {
 function decodeXmlEntities(str) {
   return str.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&apos;/g, "'").replace(/&quot;/g, '"');
 }
+function parseCollections(xml) {
+  const collections = [];
+  const collectionRegex = /<collection[^>]*\srole=["']([^"']+)["'][^>]*>/g;
+  let collectionMatch;
+  while ((collectionMatch = collectionRegex.exec(xml)) !== null) {
+    const role = collectionMatch[1];
+    if (!role) continue;
+    const collectionStart = collectionMatch.index;
+    const collectionStartTag = collectionMatch[0];
+    const idMatch = /id=["']([^"']+)["']/.exec(collectionStartTag);
+    const id = idMatch?.[1];
+    const nameMatch = /name=["']([^"']+)["']/.exec(collectionStartTag);
+    const name = nameMatch?.[1];
+    const links = [];
+    const linkRegex = /<link[^>]*\shref=["']([^"']+)["'][^>]*\/?>/g;
+    const closingTag = `</collection>`;
+    const closingIndex = xml.indexOf(closingTag, collectionStart);
+    const collectionEnd = closingIndex >= 0 ? closingIndex + closingTag.length : xml.length;
+    const collectionXml = xml.slice(collectionStart, collectionEnd);
+    let linkMatch;
+    while ((linkMatch = linkRegex.exec(collectionXml)) !== null) {
+      const href = linkMatch[1];
+      if (href) {
+        links.push(decodeXmlEntities(href));
+      }
+    }
+    const collection = {
+      role,
+      links
+    };
+    if (id) collection.id = id;
+    if (name) collection.name = name;
+    collections.push(collection);
+  }
+  return collections;
+}
 
 // src/opf/types.ts
 var ITEM_PROPERTIES = /* @__PURE__ */ new Set([
@@ -885,7 +1835,7 @@ var OPFValidator = class {
       this.packageDoc = parseOPF(opfXml);
     } catch (error) {
       context.messages.push({
-        id: "OPF-001",
+        id: "OPF-002",
         severity: "fatal",
         message: `Failed to parse package document: ${error instanceof Error ? error.message : "Unknown error"}`,
         location: { path: opfPath }
@@ -903,6 +1853,9 @@ var OPFValidator = class {
     if (this.packageDoc.version === "2.0") {
       this.validateGuide(context, opfPath);
     }
+    if (this.packageDoc.version.startsWith("3.")) {
+      this.validateCollections(context, opfPath);
+    }
   }
   /**
    * Build lookup maps for manifest items
@@ -920,6 +1873,15 @@ var OPFValidator = class {
    */
   validatePackageAttributes(context, opfPath) {
     if (!this.packageDoc) return;
+    const validVersions = /* @__PURE__ */ new Set(["2.0", "3.0", "3.1", "3.2", "3.3"]);
+    if (!validVersions.has(this.packageDoc.version)) {
+      context.messages.push({
+        id: "OPF-001",
+        severity: "error",
+        message: `Invalid package version "${this.packageDoc.version}"; must be one of: ${Array.from(validVersions).join(", ")}`,
+        location: { path: opfPath }
+      });
+    }
     if (!this.packageDoc.uniqueIdentifier) {
       context.messages.push({
         id: "OPF-048",
@@ -948,6 +1910,15 @@ var OPFValidator = class {
   validateMetadata(context, opfPath) {
     if (!this.packageDoc) return;
     const dcElements = this.packageDoc.dcElements;
+    if (dcElements.length === 0 && this.packageDoc.metaElements.length === 0) {
+      context.messages.push({
+        id: "OPF-072",
+        severity: "error",
+        message: "Metadata section is empty",
+        location: { path: opfPath }
+      });
+      return;
+    }
     const hasIdentifier = dcElements.some((dc) => dc.name === "identifier");
     const hasTitle = dcElements.some((dc) => dc.name === "title");
     const hasLanguage = dcElements.some((dc) => dc.name === "language");
@@ -986,18 +1957,144 @@ var OPFValidator = class {
           });
         }
       }
+      if (dc.name === "date" && dc.value) {
+        if (!isValidW3CDateFormat(dc.value)) {
+          context.messages.push({
+            id: "OPF-053",
+            severity: "error",
+            message: `Invalid date format "${dc.value}"; must be W3C date format (ISO 8601)`,
+            location: { path: opfPath }
+          });
+        }
+      }
+      if (dc.name === "creator" && dc.attributes) {
+        const opfRole = dc.attributes["opf:role"];
+        if (opfRole?.startsWith("marc:")) {
+          const relatorCode = opfRole.substring(5);
+          const validRelatorCodes = /* @__PURE__ */ new Set([
+            "arr",
+            "aut",
+            "aut",
+            "ccp",
+            "com",
+            "ctb",
+            "csl",
+            "edt",
+            "ill",
+            "itr",
+            "pbl",
+            "pdr",
+            "prt",
+            "trl",
+            "cre",
+            "art",
+            "ctb",
+            "edt",
+            "pfr",
+            "red",
+            "rev",
+            "spn",
+            "dsx",
+            "pmc",
+            "dte",
+            "ove",
+            "trc",
+            "ldr",
+            "led",
+            "prg",
+            "rap",
+            "rce",
+            "rpc",
+            "rtr",
+            "sad",
+            "sgn",
+            "tce",
+            "aac",
+            "acq",
+            "ant",
+            "arr",
+            "art",
+            "ard",
+            "asg",
+            "aus",
+            "aft",
+            "bdd",
+            "bdd",
+            "clb",
+            "clc",
+            "drd",
+            "edt",
+            "edt",
+            "fmd",
+            "flm",
+            "fmo",
+            "fpy",
+            "hnr",
+            "ill",
+            "ilt",
+            "img",
+            "itr",
+            "lrg",
+            "lsa",
+            "led",
+            "lee",
+            "lel",
+            "lgd",
+            "lse",
+            "mfr",
+            "mod",
+            "mon",
+            "mus",
+            "nrt",
+            "ogt",
+            "org",
+            "oth",
+            "pnt",
+            "ppa",
+            "prv",
+            "pup",
+            "red",
+            "rev",
+            "rsg",
+            "srv",
+            "stn",
+            "stl",
+            "trc",
+            "typ",
+            "vdg",
+            "voc",
+            "wac",
+            "wdc"
+          ]);
+          if (!validRelatorCodes.has(relatorCode)) {
+            context.messages.push({
+              id: "OPF-052",
+              severity: "error",
+              message: `Unknown MARC relator code "${relatorCode}" in dc:creator`,
+              location: { path: opfPath }
+            });
+          }
+        }
+      }
     }
     if (this.packageDoc.version !== "2.0") {
-      const hasModified = this.packageDoc.metaElements.some(
+      const modifiedMeta = this.packageDoc.metaElements.find(
         (meta) => meta.property === "dcterms:modified"
       );
-      if (!hasModified) {
+      if (!modifiedMeta) {
         context.messages.push({
           id: "OPF-054",
           severity: "error",
           message: "EPUB 3 metadata must include a dcterms:modified meta element",
           location: { path: opfPath }
         });
+      } else if (modifiedMeta.value && !isValidW3CDateFormat(modifiedMeta.value)) {
+        context.messages.push({
+          id: "OPF-054",
+          severity: "error",
+          message: `Invalid dcterms:modified date format "${modifiedMeta.value}"; must be W3C date format (ISO 8601)`,
+          location: { path: opfPath }
+        });
       }
     }
   }
@@ -1036,6 +2133,29 @@ var OPFValidator = class {
           location: { path: opfPath }
         });
       }
+      if (!isValidMimeType(item.mediaType)) {
+        context.messages.push({
+          id: "OPF-014",
+          severity: "error",
+          message: `Invalid media-type format "${item.mediaType}" for item "${item.id}"`,
+          location: { path: opfPath }
+        });
+      }
+      const deprecatedTypes = /* @__PURE__ */ new Map([
+        ["text/x-oeb1-document", "OPF-035"],
+        ["text/x-oeb1-css", "OPF-037"],
+        ["application/x-oeb1-package", "OPF-038"],
+        ["text/x-oeb1-html", "OPF-037"]
+      ]);
+      const deprecatedId = deprecatedTypes.get(item.mediaType);
+      if (deprecatedId) {
+        context.messages.push({
+          id: deprecatedId,
+          severity: "warning",
+          message: `Deprecated OEB 1.0 media-type "${item.mediaType}" should not be used`,
+          location: { path: opfPath }
+        });
+      }
       if (this.packageDoc.version !== "2.0" && item.properties) {
         for (const prop of item.properties) {
           if (!ITEM_PROPERTIES.has(prop) && !prop.includes(":")) {
@@ -1066,6 +2186,16 @@ var OPFValidator = class {
           location: { path: opfPath }
         });
       }
+      if (this.packageDoc.version !== "2.0" && (item.href.startsWith("http://") || item.href.startsWith("https://"))) {
+        if (!item.properties?.includes("remote-resources")) {
+          context.messages.push({
+            id: "RSC-006",
+            severity: "error",
+            message: `Manifest item "${item.id}" references remote resource but is missing "remote-resources" property`,
+            location: { path: opfPath }
+          });
+        }
+      }
     }
     if (this.packageDoc.version !== "2.0") {
       const hasNav = this.packageDoc.manifest.some((item) => item.properties?.includes("nav"));
@@ -1078,6 +2208,31 @@ var OPFValidator = class {
         });
       }
     }
+    this.checkUndeclaredResources(context, opfPath);
+  }
+  /**
+   * Check for files in container that are not declared in manifest
+   */
+  checkUndeclaredResources(context, opfPath) {
+    if (!this.packageDoc) return;
+    const declaredPaths = /* @__PURE__ */ new Set();
+    for (const item of this.packageDoc.manifest) {
+      const fullPath = resolvePath(opfPath, item.href);
+      declaredPaths.add(fullPath);
+    }
+    declaredPaths.add(opfPath);
+    for (const filePath of context.files.keys()) {
+      if (filePath.endsWith("/")) continue;
+      if (filePath.startsWith("META-INF/")) continue;
+      if (filePath === "mimetype") continue;
+      if (declaredPaths.has(filePath)) continue;
+      context.messages.push({
+        id: "RSC-008",
+        severity: "error",
+        message: `File in container is not declared in manifest: ${filePath}`,
+        location: { path: filePath }
+      });
+    }
   }
   /**
    * Validate spine section
@@ -1230,6 +2385,89 @@ var OPFValidator = class {
       }
     }
   }
+  validateCollections(context, opfPath) {
+    if (!this.packageDoc) return;
+    const collections = this.packageDoc.collections;
+    if (collections.length === 0) {
+      return;
+    }
+    const validRoles = /* @__PURE__ */ new Set(["dictionary", "index", "preview", "recordings"]);
+    for (const collection of collections) {
+      if (!validRoles.has(collection.role)) {
+        context.messages.push({
+          id: "OPF-071",
+          severity: "warning",
+          message: `Unknown collection role: "${collection.role}"`,
+          location: { path: opfPath }
+        });
+      }
+      if (collection.role === "dictionary") {
+        if (!collection.name || collection.name.trim() === "") {
+          context.messages.push({
+            id: "OPF-072",
+            severity: "error",
+            message: "Dictionary collection must have a name attribute",
+            location: { path: opfPath }
+          });
+        }
+        for (const linkHref of collection.links) {
+          const manifestItem = this.manifestByHref.get(linkHref);
+          if (!manifestItem) {
+            context.messages.push({
+              id: "OPF-073",
+              severity: "error",
+              message: `Collection link "${linkHref}" references non-existent manifest item`,
+              location: { path: opfPath }
+            });
+            continue;
+          }
+          if (manifestItem.mediaType !== "application/xhtml+xml" && manifestItem.mediaType !== "image/svg+xml") {
+            context.messages.push({
+              id: "OPF-074",
+              severity: "error",
+              message: `Dictionary collection item "${linkHref}" must be an XHTML or SVG document`,
+              location: { path: opfPath }
+            });
+          }
+        }
+      }
+      if (collection.role === "index") {
+        for (const linkHref of collection.links) {
+          const manifestItem = this.manifestByHref.get(linkHref);
+          if (!manifestItem) {
+            context.messages.push({
+              id: "OPF-073",
+              severity: "error",
+              message: `Collection link "${linkHref}" references non-existent manifest item`,
+              location: { path: opfPath }
+            });
+            continue;
+          }
+          if (manifestItem.mediaType !== "application/xhtml+xml") {
+            context.messages.push({
+              id: "OPF-075",
+              severity: "error",
+              message: `Index collection item "${linkHref}" must be an XHTML document`,
+              location: { path: opfPath }
+            });
+          }
+        }
+      }
+      if (collection.role === "preview") {
+        for (const linkHref of collection.links) {
+          const manifestItem = this.manifestByHref.get(linkHref);
+          if (!manifestItem) {
+            context.messages.push({
+              id: "OPF-073",
+              severity: "error",
+              message: `Collection link "${linkHref}" references non-existent manifest item`,
+              location: { path: opfPath }
+            });
+          }
+        }
+      }
+    }
+  }
 };
 function isSpineMediaType(mediaType) {
   return mediaType === "application/xhtml+xml" || mediaType === "image/svg+xml" || // EPUB 2 also allows these in spine
@@ -1258,6 +2496,442 @@ function resolvePath(basePath, relativePath) {
   }
   return parts.join("/");
 }
+function isValidMimeType(mediaType) {
+  const mimeTypePattern = /^[a-zA-Z][a-zA-Z0-9!#$&\-^_]*\/[a-zA-Z0-9][a-zA-Z0-9!#$&\-^_+]*(?:\s*;\s*[a-zA-Z0-9-]+=[^;]+)?$/;
+  if (!mimeTypePattern.test(mediaType)) {
+    return false;
+  }
+  const [type, subtypeWithParams] = mediaType.split("/");
+  if (!type || !subtypeWithParams) return false;
+  const subtype = subtypeWithParams.split(";")[0]?.trim();
+  if (!subtype) return false;
+  if (type.length > 127 || subtype.length > 127) {
+    return false;
+  }
+  return true;
+}
+function isValidW3CDateFormat(dateStr) {
+  const trimmed = dateStr.trim();
+  const yearOnlyPattern = /^\d{4}$/;
+  if (yearOnlyPattern.test(trimmed)) {
+    const year = Number(trimmed);
+    return year >= 0 && year <= 9999;
+  }
+  const yearMonthPattern = /^(\d{4})-(\d{2})$/;
+  const yearMonthMatch = yearMonthPattern.exec(trimmed);
+  if (yearMonthMatch) {
+    const year = Number(yearMonthMatch[1]);
+    const month = Number(yearMonthMatch[2]);
+    if (year < 0 || year > 9999) return false;
+    if (month < 1 || month > 12) return false;
+    return true;
+  }
+  const dateOnlyPattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+  const dateMatch = dateOnlyPattern.exec(trimmed);
+  if (dateMatch) {
+    const year = Number(dateMatch[1]);
+    const month = Number(dateMatch[2]);
+    const day = Number(dateMatch[3]);
+    if (year < 0 || year > 9999) return false;
+    if (month < 1 || month > 12) return false;
+    const daysInMonth = new Date(year, month, 0).getDate();
+    if (day < 1 || day > daysInMonth) return false;
+    return true;
+  }
+  const dateTimePattern = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[+-]\d{2}:\d{2})?$/;
+  const dateTimeMatch = dateTimePattern.exec(trimmed);
+  if (dateTimeMatch) {
+    const year = Number(dateTimeMatch[1]);
+    const month = Number(dateTimeMatch[2]);
+    const day = Number(dateTimeMatch[3]);
+    if (year < 0 || year > 9999) return false;
+    if (month < 1 || month > 12) return false;
+    const daysInMonth = new Date(year, month, 0).getDate();
+    if (day < 1 || day > daysInMonth) return false;
+    const hours = Number(dateTimeMatch[4]);
+    const minutes = Number(dateTimeMatch[5]);
+    const seconds = Number(dateTimeMatch[6]);
+    if (hours < 0 || hours > 23) return false;
+    if (minutes < 0 || minutes > 59) return false;
+    if (seconds < 0 || seconds > 59) return false;
+    return true;
+  }
+  return false;
+}
+
+// src/references/registry.ts
+var ResourceRegistry = class {
+  resources;
+  ids;
+  constructor() {
+    this.resources = /* @__PURE__ */ new Map();
+    this.ids = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a resource from manifest
+   */
+  registerResource(resource) {
+    this.resources.set(resource.url, resource);
+    for (const id of resource.ids) {
+      this.registerID(resource.url, id);
+    }
+  }
+  /**
+   * Register an ID in a resource
+   */
+  registerID(resourceURL, id) {
+    if (!id || !this.resources.has(resourceURL)) {
+      return;
+    }
+    if (!this.ids.has(resourceURL)) {
+      this.ids.set(resourceURL, /* @__PURE__ */ new Set());
+    }
+    const resourceIDs = this.ids.get(resourceURL);
+    resourceIDs?.add(id);
+    const resource = this.resources.get(resourceURL);
+    if (resource) {
+      resource.ids.add(id);
+    }
+  }
+  /**
+   * Get a resource by URL
+   */
+  getResource(url) {
+    return this.resources.get(url);
+  }
+  /**
+   * Check if a resource exists
+   */
+  hasResource(url) {
+    return this.resources.has(url);
+  }
+  /**
+   * Check if an ID exists in a resource
+   */
+  hasID(resourceURL, id) {
+    const resourceIDs = this.ids.get(resourceURL);
+    return resourceIDs?.has(id) ?? false;
+  }
+  /**
+   * Get all resources
+   */
+  getAllResources() {
+    return Array.from(this.resources.values());
+  }
+  /**
+   * Get all resource URLs
+   */
+  getResourceURLs() {
+    return Array.from(this.resources.keys());
+  }
+  /**
+   * Get resources in spine
+   */
+  getSpineResources() {
+    return Array.from(this.resources.values()).filter((r) => r.inSpine);
+  }
+  /**
+   * Check if a resource is in spine
+   */
+  isInSpine(url) {
+    const resource = this.resources.get(url);
+    return resource?.inSpine ?? false;
+  }
+};
+
+// src/references/url.ts
+function parseURL(urlString) {
+  const hashIndex = urlString.indexOf("#");
+  if (hashIndex === -1) {
+    return {
+      url: urlString,
+      resource: urlString,
+      hasFragment: false
+    };
+  }
+  const resource = urlString.substring(0, hashIndex);
+  const fragment = urlString.substring(hashIndex + 1);
+  const result = {
+    url: urlString,
+    resource,
+    hasFragment: true
+  };
+  if (fragment) {
+    result.fragment = fragment;
+  }
+  return result;
+}
+function isDataURL(url) {
+  return url.startsWith("data:");
+}
+function isFileURL(url) {
+  return url.startsWith("file:");
+}
+function hasAbsolutePath(url) {
+  return url.startsWith("/");
+}
+function hasParentDirectoryReference(url) {
+  return url.includes("..");
+}
+function isMalformedURL(url) {
+  if (!url) return true;
+  try {
+    if (/[\s<>]/.test(url)) return true;
+    return false;
+  } catch {
+    return true;
+  }
+}
+function isHTTPS(url) {
+  return url.startsWith("https://");
+}
+function isHTTP(url) {
+  return url.startsWith("http://");
+}
+function isRemoteURL(url) {
+  return isHTTP(url) || isHTTPS(url);
+}
+
+// src/references/validator.ts
+var ReferenceValidator = class {
+  registry;
+  version;
+  references = [];
+  constructor(registry, version) {
+    this.registry = registry;
+    this.version = version;
+  }
+  /**
+   * Register a reference for validation
+   */
+  addReference(reference) {
+    this.references.push(reference);
+  }
+  /**
+   * Validate all registered references
+   */
+  validate(context) {
+    for (const reference of this.references) {
+      this.validateReference(context, reference);
+    }
+    this.checkUndeclaredResources(context);
+  }
+  /**
+   * Validate a single reference
+   */
+  validateReference(context, reference) {
+    const url = reference.url;
+    if (isMalformedURL(url)) {
+      context.messages.push({
+        id: "RSC-020",
+        severity: "error",
+        message: `Malformed URL: ${url}`,
+        location: reference.location
+      });
+      return;
+    }
+    if (isDataURL(url)) {
+      if (this.version.startsWith("3.")) {
+        context.messages.push({
+          id: "RSC-029",
+          severity: "error",
+          message: "Data URLs are not allowed in EPUB 3",
+          location: reference.location
+        });
+      }
+      return;
+    }
+    if (isFileURL(url)) {
+      context.messages.push({
+        id: "RSC-026",
+        severity: "error",
+        message: "File URLs are not allowed",
+        location: reference.location
+      });
+      return;
+    }
+    const resourcePath = reference.targetResource || parseURL(url).resource;
+    const fragment = reference.fragment ?? parseURL(url).fragment;
+    const hasFragment = fragment !== void 0 && fragment !== "";
+    if (!isRemoteURL(url)) {
+      this.validateLocalReference(context, reference, resourcePath);
+    } else {
+      this.validateRemoteReference(context, reference);
+    }
+    if (hasFragment) {
+      this.validateFragment(context, reference, resourcePath, fragment);
+    }
+  }
+  /**
+   * Validate a local (non-remote) reference
+   */
+  validateLocalReference(context, reference, resourcePath) {
+    if (hasAbsolutePath(resourcePath)) {
+      context.messages.push({
+        id: "RSC-027",
+        severity: "error",
+        message: "Absolute paths are not allowed in EPUB",
+        location: reference.location
+      });
+    }
+    const forbiddenParentDirTypes = [
+      "hyperlink" /* HYPERLINK */,
+      "nav-toc-link" /* NAV_TOC_LINK */,
+      "nav-pagelist-link" /* NAV_PAGELIST_LINK */
+    ];
+    if (hasParentDirectoryReference(reference.url) && forbiddenParentDirTypes.includes(reference.type)) {
+      context.messages.push({
+        id: "RSC-028",
+        severity: "error",
+        message: "Parent directory references (..) are not allowed",
+        location: reference.location
+      });
+    }
+    if (!this.registry.hasResource(resourcePath)) {
+      const isLinkRef = reference.type === "link" /* LINK */;
+      context.messages.push({
+        id: isLinkRef ? "RSC-007w" : "RSC-007",
+        severity: isLinkRef ? "warning" : "error",
+        message: `Referenced resource not found in manifest: ${resourcePath}`,
+        location: reference.location
+      });
+      return;
+    }
+    const resource = this.registry.getResource(resourcePath);
+    if (reference.type === "hyperlink" /* HYPERLINK */ && !resource?.inSpine) {
+      context.messages.push({
+        id: "RSC-011",
+        severity: "error",
+        message: "Hyperlinks must reference spine items",
+        location: reference.location
+      });
+    }
+    if (reference.type === "hyperlink" /* HYPERLINK */ || reference.type === "overlay-text-link" /* OVERLAY_TEXT_LINK */) {
+      const targetMimeType = resource?.mimeType;
+      if (targetMimeType && !this.isBlessedItemType(targetMimeType, context.version) && !this.isDeprecatedBlessedItemType(targetMimeType) && !resource.hasCoreMediaTypeFallback) {
+        context.messages.push({
+          id: "RSC-010",
+          severity: "error",
+          message: "Publication resource references must point to content documents",
+          location: reference.location
+        });
+      }
+    }
+  }
+  /**
+   * Validate a remote reference
+   */
+  validateRemoteReference(context, reference) {
+    const url = reference.url;
+    if (isHTTP(url) && !isHTTPS(url)) {
+      context.messages.push({
+        id: "RSC-031",
+        severity: "error",
+        message: "Remote resources must use HTTPS",
+        location: reference.location
+      });
+    }
+    if (isPublicationResourceReference(reference.type)) {
+      const allowedRemoteTypes = /* @__PURE__ */ new Set([
+        "audio" /* AUDIO */,
+        "video" /* VIDEO */,
+        "font" /* FONT */
+      ]);
+      if (!allowedRemoteTypes.has(reference.type)) {
+        context.messages.push({
+          id: "RSC-006",
+          severity: "error",
+          message: "Remote resources are only allowed for audio, video, and fonts",
+          location: reference.location
+        });
+      }
+    }
+  }
+  /**
+   * Validate a fragment identifier
+   */
+  validateFragment(context, reference, resourcePath, fragment) {
+    if (!fragment || !this.registry.hasResource(resourcePath)) {
+      return;
+    }
+    const resource = this.registry.getResource(resourcePath);
+    if (reference.type === "stylesheet" /* STYLESHEET */) {
+      context.messages.push({
+        id: "RSC-013",
+        severity: "error",
+        message: "Stylesheet references must not have fragment identifiers",
+        location: reference.location
+      });
+      return;
+    }
+    if (resource?.mimeType === "image/svg+xml") {
+      const hasSVGView = fragment.includes("svgView(") || fragment.includes("viewBox(");
+      if (hasSVGView && reference.type === "hyperlink" /* HYPERLINK */) {
+        context.messages.push({
+          id: "RSC-014",
+          severity: "error",
+          message: "SVG view fragments can only be referenced from SVG documents",
+          location: reference.location
+        });
+      }
+    }
+    if (!this.registry.hasID(resourcePath, fragment)) {
+      context.messages.push({
+        id: "RSC-012",
+        severity: "error",
+        message: `Fragment identifier not found: #${fragment}`,
+        location: reference.location
+      });
+    }
+  }
+  /**
+   * Check for resources that were never referenced
+   * Following Java EPUBCheck OPFChecker30.java logic:
+   * - Skip items in spine (implicitly referenced)
+   * - Skip nav and NCX resources
+   * - Only check for "publication resource references" (not HYPERLINK)
+   */
+  checkUndeclaredResources(context) {
+    const referencedResources = new Set(
+      this.references.filter((ref) => {
+        if (!isPublicationResourceReference(ref.type)) {
+          return false;
+        }
+        const targetResource = ref.targetResource || parseURL(ref.url).resource;
+        return this.registry.hasResource(targetResource);
+      }).map((ref) => ref.targetResource || parseURL(ref.url).resource)
+    );
+    for (const resource of this.registry.getAllResources()) {
+      if (resource.inSpine) continue;
+      if (referencedResources.has(resource.url)) continue;
+      if (resource.url.includes("nav")) continue;
+      if (resource.url.includes("toc.ncx") || resource.url.includes(".ncx")) continue;
+      if (resource.url.includes("cover-image")) continue;
+      context.messages.push({
+        id: "OPF-097",
+        severity: "usage",
+        message: `Resource declared in manifest but not referenced: ${resource.url}`,
+        location: { path: resource.url }
+      });
+    }
+  }
+  /**
+   * Check if a MIME type is a blessed content document type
+   */
+  isBlessedItemType(mimeType, version) {
+    if (version === "2.0") {
+      return mimeType === "application/xhtml+xml" || mimeType === "application/x-dtbook+xml";
+    } else {
+      return mimeType === "application/xhtml+xml" || mimeType === "image/svg+xml";
+    }
+  }
+  /**
+   * Check if a MIME type is a deprecated blessed content document type
+   */
+  isDeprecatedBlessedItemType(mimeType) {
+    return mimeType === "text/x-oeb1-document" || mimeType === "text/html";
+  }
+};
 var COMPRESSED_SCHEMAS = {
   "applications.rng": "H4sIAHZNcGkCA81aX2/bNhB/76fgXKBPtb1u6zC4ToqgSdMC7TqsGbZXWqIlohQpUFQS99PvSOq/RVmSZTdBHhLy/vF49+PxqPXbx4iheyITKvjF7NXi5xki3BM+5cHF7J+79/M/Zm8vn60DiaMISwTUPFnhi1moVLxaLiVh+JEHCyGDJU+WnohirOiGMqp2S8y5UPCvgBkj2XC7eBMlU0+lkhjay2cIrX+az9HzKX7QfG4E+mRLOUEcR+RiBsZGgi+wUjJZUK6IxJ6aIRjeANHFzAwxgu+JsQbY8coXXhoRbld1if6++XT1H/rzFn31QhJhtBUSfbj7/Am9XqF/yQZdxTGjniFG7wnWq0u0pPLn+XrZlGp1Tb32FvOvfJ+a3UFKoHfGG+gKvEE3qSKJy7DSLXYAhkSs5zHLB2BIkm2bmz0B3PALivGGkdmykLFsChkg1Zc4CCaUF1LfJ3wiYbGIBSSYW9p6WXfpemnD9EDEChWC1K5wdRhUhLqxqKe25sY5Quomm4dwMvQrsK/G6IoqrcXEXaG8TR8QeqGgXhF6MHCPWUouATxAtv27ORczrNf8qOaCs52LaotZ4hJR2buqflhMbvYAV5bR6nDidU6AbhjRwytU8PT1X1PJOM+1+WQKF2QJ5lj/BzNbLt5S9115TbZ72bnQ9oWnXFE234qU++cIiRwjHA75y06XHsno+7qkLt7tE5wq4fJIhHmKmWs2hAQ7h6M0HkBpMuiUvmVigxkq1CUI22NZZxgcecR6NUEPVIUoR5wcuE5yDFIepyoS/lQHVhITxqAE8b5NJFBHgodjcAWj36eyUuO5/EZ2OlieznGYh9SQ07DcPyeEcYXIY0w8OMKQjxVGaheTFSo4++ZuU5U7e7ngTiDXp597zpnWqXROQblLnZMcliWp55r2iUcjN5gkBEsvPMGxU0kTx759LSggJBDmPspvPvngCpVS+u7hnt7pTuOToGwj+13XhyqVGerrj1b5bp+I7dYZaB0xr+1xBZiGdk/fcdoJHoT0nZNeiHX5DHfmE4RoDSMdjr8DJEFii240LQIFCk4x+L2nUsEZjYB9IzCsYAV3+VJc391pMcG9N4bYmecduxM4Kw3egVWxJPdUpM69aYWO6r43y7mRexZLEcBdHvYLigdn2QZEQIM+cl83AYRcoRdMvcl5XwTqjWtPspqkoa3cjf3qo3bAFeZRzqtXz3YiE3nVA7kpfb3M7OnpFCvQXSi1n8QVCzprirqahdnO8RVKQ1qEH4fKamZGR1UlKV7QSBefVC1yzRtc26ED7FIw4mKtB/MxpVWrjx14UZ1sM15XP4stE1gtAK7nnAQQ6VCWZYYPz7lypxwWlVMH7IlFAsXfMbbYBHNVmGZ2EYcSJ+0lpu7yvTN9UoBq6B56BOlSLeue6H5ihBWCypZ0tTB1dpZayhrYRsO+dXX0OlD4+hQzEXQC3bUhQRvx+BIKXKh2PAC7lwiaoQ+U++LB4p4V1B/1LH1vzMvs7EK8jGQqvKuJOxXaVZUsRDy8LTkWnjL3D0QmzIhU+6zTIdO+PxwgUJnrKC2B6EQVdS0euwECwOih5/3TpLqhP5zm1cw9IB2CPe1M8TshGJw2NpM1df881tS9s9gY0pXDhmCqDK4ImzZ/xyYdo0mlNdIv5XwqDeDuhjIGUqTxUKYxFmoeOByGspnAGcEzoqCS2KdwJo7wh24WjnCJsvk0mE2SSq3bt1gk+sJrEvQ0mFxJWncafSdSfJGfhXQkPqMVpLL691kOSamiZOJJGqt5ksaxkGWLr1304K7jECAu0fUQDOdO6EZhRBWJLBQz2h+IGe0Pw2BIJwrD/GQgXMj6oRhcIJV27hjYOYbPNAdHQqTmN/g1lNn6bATgjUGtMd45A3IVcT5BhYb5PbZ3KkvvSGK47wGd+Vbkeges1EO3Esch9aBhp3PaCuqf15a+d25ndjYX5qKbKs2r7inuqpOvp37XPtOaTnsDrCpZhIQGYcfr2SBhD9RX4VQvhpC1kzzqtazW9dJfnXV2erTiACLjqN5Ti9scRlUnz2JTJY+7MUxJDL0ZLCGqh+BZI69Gt7qOLaL24HWAigG9sVaYOtQiIwoeQ7sfA/KP7eB95gufX8PzKTwuftQ9P+jwwXjWI7OSBjTJLEP/LllmamebLKOZrE9Wk3eyRllVy1k7ZW33Rt3Y1VRz+AgAdho+AojSRKEN9HfhhRfRLdIWmo9SUFbmvLFvzGizQzhJoI1mPs3Mv94cfamfsPW27+Gn2nurRflejiepftLf1e6b5+7NVSHjgPiauc6i0mzqMqM11WWmI//AySJMRtAfYTKG3giTW9uFMDnNVAhTl/c0Wnn2XX7olWefa7r8re/MAC+5SutuQA5f7TV0htWX4S/HCvj1WAG/HSvg9bECfj9WgDkQDghxx9B6mX0Adfnsf1i38T4sMgAA",
   "aria.rng": "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",
@@ -1617,11 +3291,17 @@ var EpubCheck = class _EpubCheck {
       }
       const opfValidator = new OPFValidator();
       opfValidator.validate(context);
+      const registry = new ResourceRegistry();
+      const refValidator = new ReferenceValidator(registry, context.version);
+      if (context.packageDocument) {
+        this.populateRegistry(context, registry);
+      }
       const contentValidator = new ContentValidator();
-      contentValidator.validate(context);
+      contentValidator.validate(context, registry, refValidator);
       if (context.version === "2.0" && context.packageDocument) {
         this.validateNCX(context);
       }
+      refValidator.validate(context);
       const schemaValidator = new SchemaValidator(context);
       await schemaValidator.validate();
     } catch (error) {
@@ -1632,7 +3312,16 @@ var EpubCheck = class _EpubCheck {
       });
     }
     const elapsedMs = performance.now() - startTime;
-    return buildReport(context.messages, context.version, elapsedMs);
+    const filteredMessages = context.messages.filter((msg) => {
+      if (!this.options.includeUsage && msg.severity === "usage") {
+        return false;
+      }
+      if (!this.options.includeInfo && msg.severity === "info") {
+        return false;
+      }
+      return true;
+    });
+    return buildReport(filteredMessages, context.version, elapsedMs);
   }
   /**
    * Static method to validate an EPUB file with default options
@@ -1676,20 +3365,20 @@ var EpubCheck = class _EpubCheck {
     const ncxContent = new TextDecoder().decode(ncxData);
     const ncxValidator = new NCXValidator();
     ncxValidator.validate(context, ncxContent, ncxPath);
-    if (context.ncxUid) {
-      const dcIdentifiers = context.packageDocument.dcElements.filter(
-        (dc) => dc.name === "identifier"
+    if (context.ncxUid && context.packageDocument.uniqueIdentifier) {
+      const uniqueIdRef = context.packageDocument.uniqueIdentifier;
+      const matchingIdentifier = context.packageDocument.dcElements.find(
+        (dc) => dc.name === "identifier" && dc.id === uniqueIdRef
       );
-      for (const dc of dcIdentifiers) {
-        const opfUid = dc.value.trim();
+      if (matchingIdentifier) {
+        const opfUid = matchingIdentifier.value.trim();
         if (context.ncxUid !== opfUid) {
           context.messages.push({
             id: "NCX-001",
-            severity: "warning",
+            severity: "error",
             message: `NCX uid "${context.ncxUid}" does not match OPF unique identifier "${opfUid}"`,
             location: { path: ncxPath }
           });
-          break;
         }
       }
     }
@@ -1709,6 +3398,25 @@ var EpubCheck = class _EpubCheck {
     }
     messages.push(message);
   }
+  /**
+   * Populate resource registry from package document manifest
+   */
+  populateRegistry(context, registry) {
+    const packageDoc = context.packageDocument;
+    if (!packageDoc) return;
+    const opfPath = context.opfPath ?? "";
+    const opfDir = opfPath.includes("/") ? opfPath.substring(0, opfPath.lastIndexOf("/")) : "";
+    const spineIdrefs = new Set(packageDoc.spine.map((item) => item.idref));
+    for (const item of packageDoc.manifest) {
+      const fullPath = opfDir ? `${opfDir}/${item.href}` : item.href;
+      registry.registerResource({
+        url: fullPath,
+        mimeType: item.mediaType,
+        inSpine: spineIdrefs.has(item.id),
+        ids: /* @__PURE__ */ new Set()
+      });
+    }
+  }
 };
 
 // src/messages/message-id.ts