layoutbridge-light 0.0.0-stage → 1.0.1

package/indesign/commands/91-epub.js

@@ -0,0 +1,629 @@
+/*
+ * A-45 Punkt 1 (Sitzung 60) – E-Book: export_epub und check_epub
+ * (Dokumentteil; die Pruefung der fertigen Datei laeuft ohne InDesign im
+ * Server, src/mcp/epub-check.ts). Grundlage: ExtendScript-Probe an
+ * InDesign 21.6 am 23.10.2026 (docs/EPUB-ANFORDERUNGEN.md, Teil b): die
+ * Exporteinstellungen haengen am Dokument (doc.epubExportPreferences,
+ * doc.epubFixedLayoutExportPreferences), es gibt keine auf Anwendungsebene.
+ * Jede gesetzte Einstellung markiert das Dokument als geaendert, auch wenn
+ * sie danach zurueckgestellt wird (E-101). Unbekannte Namen fuer
+ * Inhaltsverzeichnis-Formate und fehlende Coverdateien nimmt InDesign
+ * stillschweigend an – beides wird hier vorher geprueft.
+ */
+
+/* ------------------------------------------------------------ Hilfen */
+
+function idcEpubAvailable() {
+  if (typeof EpubVersion === 'undefined' || typeof EpubCover === 'undefined' || typeof ExportFormat === 'undefined'
+    || typeof EpubFixedLayoutSpreadControl === 'undefined' || typeof EpubNavigationStyle === 'undefined'
+    || ExportFormat.EPUB === undefined || ExportFormat.FIXED_LAYOUT_EPUB === undefined) {
+    IDC.fail('invalid_state', 'This InDesign version offers no EPUB export through scripting.', { code: 'epub_not_available' });
+  }
+}
+
+/* Zuordnungen Parameterwert -> Aufzaehlungswert (Namen laut Probe InDesign 21.6). */
+function idcEpubTables() {
+  return {
+    version: { '2': EpubVersion.EPUB2, '3': EpubVersion.EPUB3 },
+    cover: { none: EpubCover.NONE, first_page: EpubCover.FIRST_PAGE, image: EpubCover.EXTERNAL_IMAGE },
+    order: { layout: ExportOrder.LAYOUT_ORDER, articles: ExportOrder.ARTICLE_PANEL_ORDER, xml: ExportOrder.XML_STRUCTURE_ORDER },
+    resolution: { '72': ImageResolution.PPI_72, '96': ImageResolution.PPI_96, '150': ImageResolution.PPI_150, '300': ImageResolution.PPI_300 },
+    format: { automatic: ImageConversion.AUTOMATIC, jpeg: ImageConversion.JPEG, png: ImageConversion.PNG, gif: ImageConversion.GIF },
+    /* A-68 (8), Sitzung 81: Ausrichtung und Groesse der Objekte (Probe 11.11.2026). */
+    alignment: typeof ImageAlignmentType === 'undefined' ? {} : { left: ImageAlignmentType.ALIGN_LEFT, center: ImageAlignmentType.ALIGN_CENTER, right: ImageAlignmentType.ALIGN_RIGHT },
+    size: typeof ImageSizeOption === 'undefined' ? {} : { none: ImageSizeOption.SIZE_NONE, fixed: ImageSizeOption.SIZE_FIXED, relative: ImageSizeOption.SIZE_RELATIVE_TO_TEXT_FLOW },
+    quality: { low: JPEGOptionsQuality.LOW, medium: JPEGOptionsQuality.MEDIUM, high: JPEGOptionsQuality.HIGH, maximum: JPEGOptionsQuality.MAXIMUM },
+    spread: { document: EpubFixedLayoutSpreadControl.SPREADS_BASED_ON_DOC, physical: EpubFixedLayoutSpreadControl.PHYSICAL_SPREADS,
+      synthetic: EpubFixedLayoutSpreadControl.SYNTHETIC_SPREADS, none: EpubFixedLayoutSpreadControl.NO_SPREADS },
+    navigation: { none: EpubNavigationStyle.NO_NAVIGATION, file_names: EpubNavigationStyle.FILENAME_NAVIGATION,
+      toc_style: EpubNavigationStyle.TOC_STYLE_NAVIGATION, bookmarks: EpubNavigationStyle.BOOKMARKS_NAVIGATION }
+  };
+}
+
+/* Parameterwert zu einem gelesenen Aufzaehlungswert; unbekannt = Zeichenkette des Werts. */
+function idcEpubNameOf(value, table) {
+  var k;
+  for (k in table) { if (table.hasOwnProperty(k) && Number(table[k]) === Number(value)) { return k; } }
+  try { return String(value); } catch (e) { return null; }
+}
+
+/* Waehlt aus einer Zuordnung {wert: Aufzaehlungswert}; unbekannt = invalid_argument. */
+function idcEpubPick(key, value, table) {
+  var k;
+  var names = [];
+  for (k in table) { if (table.hasOwnProperty(k)) { names.push(k); } }
+  if (!table.hasOwnProperty(String(value))) {
+    IDC.fail('invalid_argument', key + ' must be one of ' + names.join(', ') + '.', { value: value });
+  }
+  return table[String(value)];
+}
+
+/*
+ * Setzt eine Einstellung nur, wenn sie sich unterscheidet, und merkt den
+ * alten Wert zum Zurueckstellen. Vergleich ueber Number() fuer
+ * Aufzaehlungen und Zahlen, sonst als Zeichenkette.
+ */
+function idcEpubSet(prefs, key, value, changes) {
+  var old = prefs[key];
+  var same;
+  if (typeof value === 'string') { same = String(old) === value; }
+  else if (typeof value === 'boolean') { same = old === value; }
+  else { same = Number(old) === Number(value); }
+  if (same) { return; }
+  changes.push({ prefs: prefs, key: key, old: old });
+  prefs[key] = value;
+}
+
+function idcEpubRestore(changes, problems) {
+  var i, c;
+  for (i = changes.length - 1; i >= 0; i--) {
+    c = changes[i];
+    try { c.prefs[c.key] = c.old; } catch (e) { problems.push(c.key + ': ' + String(e.message ? e.message : e)); }
+  }
+}
+
+function idcEpubTocStyleNames(doc) {
+  var names = [];
+  var i;
+  try { for (i = 0; i < doc.tocStyles.length; i++) { names.push(String(doc.tocStyles.item(i).name)); } } catch (e) { /* keine */ }
+  return names;
+}
+
+function idcEpubHasName(list, name) {
+  var i;
+  for (i = 0; i < list.length; i++) { if (list[i] === name) { return true; } }
+  return false;
+}
+
+function idcEpubLanguage(doc) {
+  try { return String(doc.textDefaults.appliedLanguage.name); } catch (e) { return null; }
+}
+
+/* "[Keine Sprache]" / "[No Language]": eckige Klammer = keine Sprache (InDesign-Namensregel fuer Grundeintraege). */
+function idcEpubLanguageMissing(name) {
+  return name === null || name === '' || name.charAt(0) === '[';
+}
+
+/* Seitenobjekte oberster Ebene einer Seite (verankerte Objekte stecken im Text, nicht hier). */
+function idcEpubTopItems(page) {
+  var out = [];
+  var i, items;
+  try { items = page.pageItems; } catch (e) { return out; }
+  /* A-68 Befund, Sitzung 81: pageItems liefert allgemeine PageItem-Objekte; ein
+     Textrahmen mit verankerter Vignette galt so als nicht verankertes Objekt
+     (Klasse PageItem, Inhalt ueber allGraphics). Deshalb die konkrete Klasse. */
+  for (i = 0; i < items.length; i++) { out.push(IDC.concrete(items.item(i))); }
+  return out;
+}
+
+function idcEpubItemHasContent(item) {
+  var cls = IDC.className(item);
+  if (cls === 'TextFrame') {
+    try { return String(item.parentStory.contents).length > 0; } catch (e) { return true; }
+  }
+  try { if (item.allGraphics && item.allGraphics.length > 0) { return true; } } catch (e2) { /* weiter */ }
+  return cls === 'Group';
+}
+
+/* A-77: split_by_paragraph_style als Name oder Liste -> Liste ohne Doppelte. */
+function idcEpubSplitNames(value) {
+  var list = [], out = [], i, j, seen;
+  if (IDC.isArray(value)) { list = value; } else { list = [value]; }
+  if (list.length === 0) { IDC.fail('invalid_argument', 'split_by_paragraph_style must name at least one paragraph style.', null); }
+  for (i = 0; i < list.length; i++) {
+    if (typeof list[i] !== 'string' || list[i].length === 0) {
+      IDC.fail('invalid_argument', 'split_by_paragraph_style must be a paragraph style name or a list of names.', { value: list[i] });
+    }
+    seen = false;
+    for (j = 0; j < out.length; j++) { if (out[j] === list[i]) { seen = true; } }
+    if (!seen) { out.push(list[i]); }
+  }
+  return out;
+}
+
+/* Alle Absatzformate und welche davon teilen sollen; fehlende Namen = not_found (alle auf einmal). */
+function idcEpubSplitStyles(doc, names) {
+  var all = [], chosen = [], missing = [], found, i, k, coll;
+  try { coll = doc.allParagraphStyles; } catch (e) { coll = []; }
+  for (i = 0; i < coll.length; i++) { all.push(coll[i]); chosen.push(false); }
+  for (k = 0; k < names.length; k++) {
+    found = false;
+    for (i = 0; i < all.length; i++) {
+      if (String(all[i].name) === names[k]) { chosen[i] = true; found = true; }
+    }
+    if (!found) { missing.push(names[k]); }
+  }
+  if (missing.length > 0) {
+    IDC.fail('not_found', 'Paragraph style(s) not in this document: ' + missing.join(', ') + '.',
+      { code: 'paragraph_style_not_found', paragraph_style: missing[0], missing: missing });
+  }
+  return { all: all, chosen: chosen };
+}
+
+/* Womit geteilt wird: null ohne Teilung, sonst die Formatnamen (ein Name oder die Exporttags). */
+function idcEpubSplitUsed(doc, prefs) {
+  var out = [], coll, i;
+  if (prefs.breakDocument !== true) { return null; }
+  if (String(prefs.paragraphStyleName) !== '') { return [String(prefs.paragraphStyleName)]; }
+  try { coll = doc.allParagraphStyles; } catch (e) { coll = []; }
+  for (i = 0; i < coll.length; i++) {
+    try { if (coll[i].splitDocument === true) { out.push(String(coll[i].name)); } } catch (e2) { /* weiter */ }
+  }
+  return out;
+}
+
+/* ------------------------------------------------------------ export_epub */
+
+IDC.register('export_epub', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var fixed, prefs, file, existed, overwrite, changes = [], problems = [], used = {}, meta, key, value;
+    var tocNames, coverMode, coverFile, bytes, modifiedBefore, language, i, j, items, item, landing, unanchored = 0, fonts, f, font, status;
+    var splitNames = null, splitStyles = null;
+
+    idcEpubAvailable();
+    var t = idcEpubTables();
+    if (typeof args.path !== 'string' || args.path.length === 0) {
+      IDC.fail('invalid_argument', 'path is required (the target .epub file).', null);
+    }
+    if (!/\.epub$/i.test(args.path)) {
+      IDC.fail('invalid_argument', 'path must end in .epub.', { path: args.path });
+    }
+    if (args.layout !== 'reflowable' && args.layout !== 'fixed_layout') {
+      IDC.fail('invalid_argument', 'layout must be reflowable or fixed_layout.', { value: args.layout });
+    }
+    fixed = args.layout === 'fixed_layout';
+    file = IDC.fileFor(args.path);
+    if (!IDC.fileParentExists(file)) {
+      IDC.fail('io_error', 'The folder for the target path does not exist: ' + args.path, { path: args.path });
+    }
+    overwrite = args.overwrite === true;
+    existed = file.exists === true;
+    if (existed && !overwrite) {
+      IDC.fail('io_error', 'A file exists at path already; pass overwrite true to replace it.', { code: 'file_exists', path: args.path });
+    }
+
+    prefs = fixed ? doc.epubFixedLayoutExportPreferences : doc.epubExportPreferences;
+    modifiedBefore = doc.modified === true;
+
+    /* Argumente pruefen, bevor irgendetwas gesetzt wird. */
+    if (args.epub_version !== undefined && fixed) {
+      ctx.warn('epub_version applies to reflowable EPUB only; a fixed-layout EPUB is always EPUB 3.');
+    }
+    if (args.export_order !== undefined && fixed) { ctx.warn('export_order applies to reflowable EPUB only and was ignored.'); }
+    if (args.split_by_paragraph_style !== undefined && fixed) { ctx.warn('split_by_paragraph_style applies to reflowable EPUB only and was ignored.'); }
+    if (args.embed_fonts !== undefined && fixed) { ctx.warn('embed_fonts applies to reflowable EPUB only; a fixed-layout EPUB embeds the fonts.'); }
+    if ((args.image_alignment !== undefined || args.image_size !== undefined) && fixed) {
+      ctx.warn('image_alignment and image_size apply to reflowable EPUB only and were ignored.');
+    }
+    if ((args.page_range !== undefined || args.spread_control !== undefined) && !fixed) {
+      ctx.warn('page_range and spread_control apply to fixed-layout EPUB only and were ignored.');
+    }
+    if (args.orientation !== undefined && !fixed) {
+      ctx.warn('orientation applies to fixed-layout EPUB only and was ignored.');
+    }
+    if (args.orientation !== undefined && args.orientation !== 'portrait' && args.orientation !== 'landscape' && args.orientation !== 'auto') {
+      IDC.fail('invalid_argument', 'orientation must be portrait, landscape or auto.', { value: args.orientation });
+    }
+    tocNames = idcEpubTocStyleNames(doc);
+    if (args.toc_style !== undefined && !idcEpubHasName(tocNames, String(args.toc_style))) {
+      IDC.fail('not_found', 'TOC style "' + args.toc_style + '" does not exist in this document (list_toc_styles).',
+        { code: 'toc_style_not_found', toc_style: args.toc_style, available: tocNames });
+    }
+    if (args.split_by_paragraph_style !== undefined && !fixed) {
+      splitNames = idcEpubSplitNames(args.split_by_paragraph_style);
+      if (splitNames.length === 1) {
+        var splitStyle = null;
+        try { splitStyle = doc.paragraphStyles.itemByName(splitNames[0]); } catch (eS) { splitStyle = null; }
+        if (splitStyle === null || splitStyle.isValid !== true) { splitStyle = IDC.paragraphStyleByName(doc, splitNames[0]); }
+        if (splitStyle === null || splitStyle.isValid !== true) {
+          IDC.fail('not_found', 'Paragraph style "' + splitNames[0] + '" does not exist in this document.',
+            { code: 'paragraph_style_not_found', paragraph_style: splitNames[0] });
+        }
+      } else {
+        splitStyles = idcEpubSplitStyles(doc, splitNames);
+      }
+    }
+    coverMode = args.cover === undefined ? null : String(args.cover);
+    if (coverMode !== null && coverMode !== 'none' && coverMode !== 'first_page' && coverMode !== 'image') {
+      IDC.fail('invalid_argument', 'cover must be none, first_page or image.', { value: args.cover });
+    }
+    if (coverMode === 'image') {
+      if (typeof args.cover_image_path !== 'string' || args.cover_image_path.length === 0) {
+        IDC.fail('invalid_argument', 'cover image requires cover_image_path.', null);
+      }
+      coverFile = IDC.fileFor(args.cover_image_path);
+      if (coverFile.exists !== true) {
+        IDC.fail('not_found', 'The cover image does not exist: ' + args.cover_image_path, { code: 'cover_image_not_found', path: args.cover_image_path });
+      }
+      if (!/\.(jpe?g|png|gif)$/i.test(args.cover_image_path)) {
+        ctx.warn('The cover image is not JPEG, PNG or GIF; reading systems may not show it.');
+      }
+    } else if (args.cover_image_path !== undefined) {
+      ctx.warn('cover_image_path is used only with cover image and was ignored.');
+    }
+
+    try {
+      /* Version, Cover, Inhaltsverzeichnis */
+      if (args.epub_version !== undefined && !fixed) {
+        idcEpubSet(prefs, 'version', idcEpubPick('epub_version', args.epub_version, t.version), changes);
+      }
+      if (coverMode !== null) {
+        if (coverMode === 'image') { idcEpubSet(prefs, 'coverImageFile', IDC.fsPath(coverFile), changes); }
+        idcEpubSet(prefs, 'epubCover', idcEpubPick('cover', coverMode, t.cover), changes);
+      }
+      if (args.toc_style !== undefined) {
+        idcEpubSet(prefs, 'tocStyleName', String(args.toc_style), changes);
+        if (fixed) { idcEpubSet(prefs, 'epubNavigationStyles', t.navigation.toc_style, changes); }
+      }
+      /* Nur reflowable */
+      if (!fixed) {
+        if (args.export_order !== undefined) {
+          idcEpubSet(prefs, 'exportOrder', idcEpubPick('export_order', args.export_order, t.order), changes);
+        }
+        if (args.split_by_paragraph_style !== undefined && splitStyles === null) {
+          idcEpubSet(prefs, 'breakDocument', true, changes);
+          idcEpubSet(prefs, 'paragraphStyleName', splitNames[0], changes);
+        } else if (splitStyles !== null) {
+          /* A-77: mehrere Formate ueber die Exporttags (splitDocument) der
+             Absatzformate; InDesign teilt danach nur bei leerem
+             paragraphStyleName (Probe 11.11.2026). Genau die genannten
+             Formate teilen, alle anderen voruebergehend nicht. */
+          for (i = 0; i < splitStyles.all.length; i++) {
+            idcEpubSet(splitStyles.all[i], 'splitDocument', splitStyles.chosen[i] === true, changes);
+          }
+          idcEpubSet(prefs, 'breakDocument', true, changes);
+          idcEpubSet(prefs, 'paragraphStyleName', '', changes);
+        }
+        if (args.embed_fonts !== undefined) { idcEpubSet(prefs, 'embedFont', args.embed_fonts === true, changes); }
+        if (args.image_alignment !== undefined) {
+          idcEpubSet(prefs, 'imageAlignment', idcEpubPick('image_alignment', args.image_alignment, t.alignment), changes);
+        }
+        if (args.image_size !== undefined) {
+          idcEpubSet(prefs, 'customImageSizeOption', idcEpubPick('image_size', args.image_size, t.size), changes);
+        }
+      }
+      /* Nur fixed layout */
+      if (fixed) {
+        if (args.page_range !== undefined) {
+          idcEpubSet(prefs, 'epubPageRange', String(args.page_range), changes);
+          idcEpubSet(prefs, 'epubPageRangeFormat', PageRangeFormat.EXPORT_PAGE_RANGE, changes);
+        }
+        if (args.spread_control !== undefined) {
+          idcEpubSet(prefs, 'epubSpreadControlOptions', idcEpubPick('spread_control', args.spread_control, t.spread), changes);
+        }
+      }
+      /* Bilder (beide) */
+      if (args.image_resolution !== undefined) {
+        idcEpubSet(prefs, 'imageExportResolution', idcEpubPick('image_resolution', args.image_resolution, t.resolution), changes);
+      }
+      if (args.image_format !== undefined) {
+        idcEpubSet(prefs, 'imageConversion', idcEpubPick('image_format', args.image_format, t.format), changes);
+      }
+      if (args.jpeg_quality !== undefined) {
+        idcEpubSet(prefs, 'jpegOptionsQuality', idcEpubPick('jpeg_quality', args.jpeg_quality, t.quality), changes);
+      }
+      /* Metadaten */
+      meta = args.metadata;
+      if (meta !== undefined && meta !== null) {
+        var metaMap = { title: 'epubTitle', creator: 'epubCreator', publisher: 'epubPublisher', description: 'epubDescription',
+          subject: 'epubSubject', rights: 'epubRights', date: 'epubDate', identifier: 'id' };
+        for (key in meta) {
+          if (!meta.hasOwnProperty(key)) { continue; }
+          if (!metaMap.hasOwnProperty(key)) {
+            IDC.fail('invalid_argument', 'metadata.' + key + ' is not supported (title, creator, publisher, description, subject, rights, date, identifier).', { key: key });
+          }
+          value = meta[key];
+          if (typeof value !== 'string') { IDC.fail('invalid_argument', 'metadata.' + key + ' must be a string.', { key: key }); }
+          idcEpubSet(prefs, metaMap[key], value, changes);
+        }
+      }
+
+      /* Werte nach dem Setzen lesen – das ist, womit exportiert wird. */
+      used.layout = fixed ? 'fixed_layout' : 'reflowable';
+      used.epub_version = '3';
+      if (!fixed && Number(prefs.version) === Number(EpubVersion.EPUB2)) { used.epub_version = '2'; }
+      used.cover = idcEpubNameOf(prefs.epubCover, t.cover);
+      used.cover_image_path = used.cover === 'image' ? String(prefs.coverImageFile) : null;
+      used.toc_style = String(prefs.tocStyleName) === '' ? null : String(prefs.tocStyleName);
+      used.image_resolution = idcEpubNameOf(prefs.imageExportResolution, t.resolution);
+      used.image_format = idcEpubNameOf(prefs.imageConversion, t.format);
+      used.jpeg_quality = idcEpubNameOf(prefs.jpegOptionsQuality, t.quality);
+      if (!fixed) {
+        used.export_order = idcEpubNameOf(prefs.exportOrder, t.order);
+        used.split_by_paragraph_styles = idcEpubSplitUsed(doc, prefs);
+        used.split_by_paragraph_style = used.split_by_paragraph_styles === null ? null
+          : (String(prefs.paragraphStyleName) !== '' ? String(prefs.paragraphStyleName) : (used.split_by_paragraph_styles.length > 0 ? used.split_by_paragraph_styles[0] : null));
+        used.embed_fonts = prefs.embedFont === true;
+        try { used.image_alignment = idcEpubNameOf(prefs.imageAlignment, t.alignment); } catch (eIa) { used.image_alignment = null; }
+        try { used.image_size = idcEpubNameOf(prefs.customImageSizeOption, t.size); } catch (eIs) { used.image_size = null; }
+      } else {
+        used.page_range = Number(prefs.epubPageRangeFormat) === Number(PageRangeFormat.EXPORT_PAGE_RANGE) ? String(prefs.epubPageRange) : null;
+        used.spread_control = idcEpubNameOf(prefs.epubSpreadControlOptions, t.spread);
+        used.navigation = idcEpubNameOf(prefs.epubNavigationStyles, t.navigation);
+      }
+      used.metadata = {
+        title: String(prefs.epubTitle), creator: String(prefs.epubCreator), publisher: String(prefs.epubPublisher),
+        description: String(prefs.epubDescription), subject: String(prefs.epubSubject), rights: String(prefs.epubRights),
+        date: String(prefs.epubDate), identifier: String(prefs.id)
+      };
+
+      try {
+        doc.exportFile(fixed ? ExportFormat.FIXED_LAYOUT_EPUB : ExportFormat.EPUB, file, false);
+      } catch (eX) {
+        IDC.fail('io_error', 'EPUB export failed: ' + String(eX.message ? eX.message : eX), { path: args.path, layout: used.layout });
+      }
+    } finally {
+      idcEpubRestore(changes, problems);
+    }
+    if (problems.length > 0) { ctx.warn('Some export settings could not be restored: ' + problems.join('; ')); }
+
+    bytes = IDC.fileSize(IDC.fileFor(IDC.fsPath(file)));
+
+    /* Hinweise zum Ergebnis */
+    language = idcEpubLanguage(doc);
+    if (idcEpubLanguageMissing(language)) {
+      ctx.warn('The document has no default language (text defaults); the EPUB language (dc:language) is taken from it.');
+    }
+    if (used.metadata.title === '') { ctx.warn('No title in metadata; InDesign uses the file name as dc:title.'); }
+    if (used.metadata.creator === '') { ctx.warn('No creator (author) in metadata.'); }
+    if (used.toc_style === null) {
+      ctx.warn('No TOC style chosen; the EPUB navigation lists only the exported file names (toc_style, list_toc_styles).');
+    }
+    if (used.cover === 'none') { ctx.warn('Exported without a cover image inside the EPUB.'); }
+    if (!fixed) {
+      for (i = 0; i < doc.pages.length; i++) {
+        items = idcEpubTopItems(doc.pages.item(i));
+        for (j = 0; j < items.length; j++) {
+          item = items[j];
+          if (IDC.className(item) !== 'TextFrame' && idcEpubItemHasContent(item)) { unanchored += 1; }
+        }
+      }
+      if (unanchored > 0) {
+        ctx.warn(unanchored + ' object(s) are not anchored in the text flow; in a reflowable EPUB their place follows the export order, not the page (check_epub lists them).');
+      }
+    }
+    if (fixed || used.embed_fonts === true) {
+      try { fonts = doc.fonts; } catch (eF) { fonts = null; }
+      if (fonts !== null) {
+        for (f = 0; f < fonts.length; f++) {
+          font = fonts.item(f);
+          try { status = idcFontStatusName(font.status); } catch (eFs) { status = 'unknown'; }
+          if (status !== 'installed') { ctx.warn('Font not installed, cannot be embedded: ' + String(font.name).replace('\t', ' ') + '.'); }
+          else {
+            try { if (font.allowEditableEmbedding === false || font.allowPDFEmbedding === false) { ctx.warn('Font licence may not allow embedding: ' + String(font.name).replace('\t', ' ') + '.'); } } catch (eFa) { /* unbekannt */ }
+          }
+        }
+      }
+    }
+    if (changes.length > 0 && !modifiedBefore) {
+      ctx.warn('InDesign marks the document as modified when export settings are set, although they were restored; close without saving if nothing else changed.');
+    }
+
+    /* A-62: Seitenformat fuer die Ausrichtung im fixed layout (der Server setzt rendition:orientation nach dem Export). */
+    var pageOrientation = null;
+    try {
+      var pw = Number(doc.documentPreferences.pageWidth), ph = Number(doc.documentPreferences.pageHeight);
+      pageOrientation = 'square';
+      if (ph > pw) { pageOrientation = 'portrait'; }
+      if (pw > ph) { pageOrientation = 'landscape'; }
+    } catch (eO) { pageOrientation = null; }
+
+    return {
+      path: IDC.fsPath(file),
+      bytes: bytes,
+      overwritten: existed,
+      page_orientation: pageOrientation,
+      layout: used.layout,
+      settings_used: used,
+      document_language: language,
+      settings_changed_for_export: changes.length,
+      document_marked_modified: changes.length > 0 && !modifiedBefore
+    };
+  });
+
+/* ------------------------------------------------------- check_epub (Dokument) */
+
+function idcEpubPush(state, finding) {
+  state.total += 1;
+  if (finding.severity === 'error') { state.errors += 1; }
+  if (state.total <= state.max) { state.findings.push(finding); } else { state.truncated = true; }
+}
+
+IDC.register('check_epub', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var fixed, minPpi, maxFindings, state, checks = [], skipped = [], i, j, k, items, item, page, landing, cls, tocNames, language;
+    var masters, mpage, stories, story, paras, count, name, graphics, graphic, ppi, link, pdfLike, fonts, font, status, title, creator, prefs;
+
+    idcEpubAvailable();
+    if (args.layout !== undefined && args.layout !== 'reflowable' && args.layout !== 'fixed_layout') {
+      IDC.fail('invalid_argument', 'layout must be reflowable or fixed_layout.', { value: args.layout });
+    }
+    fixed = args.layout === 'fixed_layout';
+    minPpi = null;
+    if (args.min_ppi !== undefined && args.min_ppi !== null) {
+      if (typeof args.min_ppi !== 'number' || args.min_ppi < 1) { IDC.fail('invalid_argument', 'min_ppi must be a number of at least 1.', { value: args.min_ppi }); }
+      minPpi = args.min_ppi;
+    }
+    maxFindings = 200;
+    if (args.max_findings !== undefined) {
+      if (typeof args.max_findings !== 'number' || args.max_findings < 1 || args.max_findings > 1000) { IDC.fail('invalid_argument', 'max_findings must be from 1 to 1000.', { value: args.max_findings }); }
+      maxFindings = args.max_findings;
+    }
+    state = { total: 0, errors: 0, max: maxFindings, truncated: false, findings: [] };
+    prefs = fixed ? doc.epubFixedLayoutExportPreferences : doc.epubExportPreferences;
+
+    /* 1. Sprache */
+    checks.push('document_language');
+    language = idcEpubLanguage(doc);
+    if (idcEpubLanguageMissing(language)) {
+      idcEpubPush(state, { check: 'document_language', severity: 'error', page_id: null, page_name: null, object_id: null,
+        hint: 'Set a default language in the text defaults (Textvorgaben); the EPUB language (dc:language) is taken from it.', actual: language });
+    }
+
+    /* 2. Inhaltsverzeichnis-Format */
+    checks.push('toc_style');
+    tocNames = idcEpubTocStyleNames(doc);
+    if (args.toc_style !== undefined) {
+      if (!idcEpubHasName(tocNames, String(args.toc_style))) {
+        idcEpubPush(state, { check: 'toc_style', severity: 'error', page_id: null, page_name: null, object_id: null,
+          hint: 'TOC style "' + args.toc_style + '" does not exist; available: ' + tocNames.join(', ') + '.', actual: null });
+      }
+    } else if (String(prefs.tocStyleName) === '') {
+      idcEpubPush(state, { check: 'toc_style', severity: 'warning', page_id: null, page_name: null, object_id: null,
+        hint: 'No TOC style chosen for the EPUB; the navigation would list only file names. Pass toc_style to export_epub (define_toc_style, list_toc_styles).', actual: tocNames });
+    }
+
+    /* 3. Metadaten */
+    checks.push('metadata');
+    title = String(prefs.epubTitle);
+    creator = String(prefs.epubCreator);
+    if (title === '') {
+      idcEpubPush(state, { check: 'metadata', severity: 'warning', page_id: null, page_name: null, object_id: null,
+        hint: 'No title in the EPUB export settings; InDesign then uses the file name as dc:title. Pass metadata.title to export_epub.', actual: null });
+    }
+    if (creator === '') {
+      idcEpubPush(state, { check: 'metadata', severity: 'warning', page_id: null, page_name: null, object_id: null,
+        hint: 'No creator (author) in the EPUB export settings; pass metadata.creator to export_epub.', actual: null });
+    }
+
+    /* 4. Nicht verankerte Objekte (nur reflowable) */
+    if (!fixed) {
+      checks.push('unanchored_objects');
+      for (i = 0; i < doc.pages.length; i++) {
+        page = doc.pages.item(i);
+        items = idcEpubTopItems(page);
+        for (j = 0; j < items.length; j++) {
+          item = items[j];
+          cls = IDC.className(item);
+          if (cls === 'TextFrame' || !idcEpubItemHasContent(item)) { continue; }
+          idcEpubPush(state, { check: 'unanchored_objects', severity: 'warning', page_id: Number(page.id), page_name: String(page.name),
+            object_id: Number(item.id), kind: cls,
+            hint: 'Not anchored in the text flow; in a reflowable EPUB it lands where the export order puts it. Anchor it at the text position (anchor_frame_in_text).' });
+        }
+      }
+
+      /* 5. Objekte auf Musterseiten (nur reflowable: dort nicht exportiert) */
+      checks.push('parent_page_objects');
+      try { masters = doc.masterSpreads; } catch (eM) { masters = null; }
+      if (masters !== null) {
+        for (i = 0; i < masters.length; i++) {
+          for (j = 0; j < masters.item(i).pages.length; j++) {
+            mpage = masters.item(i).pages.item(j);
+            items = idcEpubTopItems(mpage);
+            for (k = 0; k < items.length; k++) {
+              item = items[k];
+              if (!idcEpubItemHasContent(item)) { continue; }
+              idcEpubPush(state, { check: 'parent_page_objects', severity: 'warning', page_id: Number(mpage.id), page_name: String(mpage.name),
+                object_id: Number(item.id), kind: IDC.className(item),
+                hint: 'On a parent page; a reflowable EPUB leaves it out (fine for running heads and page numbers).' });
+            }
+          }
+        }
+      }
+
+      /* 6. Texte ohne eigenes Absatzformat */
+      checks.push('paragraph_styles');
+      try { stories = doc.stories; } catch (eSt) { stories = null; }
+      if (stories !== null) {
+        for (i = 0; i < stories.length; i++) {
+          story = stories.item(i);
+          count = 0;
+          /* Texte auf Musterseiten kommen in einen reflowable EPUB nicht hinein (Befund S60 am Musterbuch). */
+          try { if (story.textContainers.length > 0 && IDC.isOnParentSpread(story.textContainers[0])) { continue; } } catch (eTc) { /* weiter */ }
+          try { paras = story.paragraphs; } catch (eP) { paras = null; }
+          if (paras === null) { continue; }
+          for (j = 0; j < paras.length; j++) {
+            try { name = String(paras.item(j).appliedParagraphStyle.name); } catch (eN) { name = ''; }
+            if (name === '' || name.charAt(0) === '[') { count += 1; }
+          }
+          if (count > 0) {
+            landing = { page_id: null, page_name: null };
+            try { landing = IDC.landing(story.textContainers[0]); } catch (eL) { /* unbekannt */ }
+            idcEpubPush(state, { check: 'paragraph_styles', severity: 'warning', page_id: landing.page_id, page_name: landing.page_name,
+              object_id: Number(story.id), kind: 'Story', paragraphs: count,
+              hint: count + ' paragraph(s) use a basic paragraph style; EPUB headings, navigation and CSS classes come from named paragraph styles.' });
+          }
+        }
+      }
+    } else {
+      skipped.push('unanchored_objects', 'parent_page_objects', 'paragraph_styles');
+    }
+
+    /* 7. Bildaufloesung */
+    if (minPpi === null) {
+      skipped.push('image_resolution');
+    } else {
+      checks.push('image_resolution');
+      try { graphics = doc.allGraphics; } catch (eG) { graphics = []; }
+      for (i = 0; i < graphics.length; i++) {
+        graphic = graphics[i];
+        pdfLike = false;
+        try { pdfLike = /pdf|eps|postscript/i.test(String(graphic.imageTypeName)) || IDC.className(graphic) === 'PDF' || IDC.className(graphic) === 'EPS'; } catch (eP2) { pdfLike = false; }
+        if (pdfLike) { continue; }
+        try { ppi = idcPpi(graphic.effectivePpi); } catch (eE) { ppi = null; }
+        if (ppi === null || ppi.min >= minPpi) { continue; }
+        landing = IDC.landing(graphic);
+        link = null;
+        try { link = String(graphic.itemLink.name); } catch (eLk) { link = null; }
+        idcEpubPush(state, { check: 'image_resolution', severity: 'warning', page_id: landing.page_id, page_name: landing.page_name,
+          object_id: Number(graphic.id), kind: 'Graphic', file_name: link, effective_ppi: ppi.min,
+          hint: 'Effective resolution ' + ppi.min + ' ppi is below ' + minPpi + ' ppi.' });
+      }
+    }
+
+    /* 8. Schriften */
+    checks.push('fonts');
+    try { fonts = doc.fonts; } catch (eF) { fonts = null; }
+    if (fonts !== null) {
+      for (i = 0; i < fonts.length; i++) {
+        font = fonts.item(i);
+        try { status = idcFontStatusName(font.status); } catch (eFs) { status = 'unknown'; }
+        if (status !== 'installed') {
+          idcEpubPush(state, { check: 'fonts', severity: fixed ? 'error' : 'warning', page_id: null, page_name: null, object_id: null,
+            font: String(font.name).replace('\t', ' '), status: status,
+            hint: 'Font not installed; it cannot be embedded' + (fixed ? ' (a fixed-layout EPUB needs embedded fonts).' : '.') });
+        }
+      }
+    }
+
+    if (state.truncated) { ctx.warn(state.total + ' findings, only the first ' + state.max + ' returned (max_findings).'); }
+    if (minPpi === null) { ctx.warn('image_resolution not checked: pass min_ppi or set epub.min_ppi in the server configuration.'); }
+
+    return {
+      passed: state.errors === 0,
+      layout: fixed ? 'fixed_layout' : 'reflowable',
+      checked: 'document',
+      checks_run: checks,
+      skipped_checks: skipped,
+      document_language: language,
+      toc_styles: tocNames,
+      errors: state.errors,
+      findings: state.findings,
+      findings_total: state.total,
+      findings_truncated: state.truncated
+    };
+  });