layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/23-save-package.js

@@ -0,0 +1,255 @@
+/* Wunschliste J2 Nr. 23 (Sitzung 8) – Kopie speichern und Verpacken: save_document_as, package_document. */
+
+function idcTargetFileArg(path, field, extensions) {
+  var file, lower, i, ok = false;
+  if (typeof path !== 'string' || path.length === 0) {
+    IDC.fail('invalid_argument', field + ' must be a non-empty file path.', null);
+  }
+  lower = path.toLowerCase();
+  for (i = 0; i < extensions.length; i++) {
+    if (lower.length > extensions[i].length && lower.substring(lower.length - extensions[i].length) === extensions[i]) { ok = true; break; }
+  }
+  if (!ok) {
+    IDC.fail('invalid_argument', field + ' must end in ' + extensions.join(' or ') + '.', { path: path });
+  }
+  file = IDC.fileFor(path);
+  if (!IDC.fileParentExists(file)) {
+    IDC.fail('io_error', 'The folder for ' + field + ' does not exist: ' + path, { path: path });
+  }
+  return file;
+}
+
+IDC.register('save_document_as', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var mode = args.mode === undefined || args.mode === null ? 'copy' : args.mode;
+    var overwrite = args.overwrite === true;
+    var extensions = ['.indd', '.indt'];
+    var file, own = idcDocumentPath(doc), nameBefore, existed, result;
+
+    if (mode !== 'copy' && mode !== 'switch') {
+      IDC.fail('invalid_argument', 'mode must be copy (the open document keeps its file) or switch (the open document continues under the new name).', { mode: mode });
+    }
+    file = idcTargetFileArg(args.path, 'path', extensions);
+    if (own !== '' && IDC.fsPath(file) === own) {
+      IDC.fail('invalid_argument', 'path is the file of the document itself; use save_document.', { path: args.path });
+    }
+    existed = file.exists === true;
+    if (existed && !overwrite) {
+      IDC.fail('io_error', 'A file exists at path already; pass overwrite true to replace it.', { path: args.path });
+    }
+    try { nameBefore = String(doc.name); } catch (e0) { nameBefore = ''; }
+    try {
+      if (mode === 'copy') {
+        doc.saveACopy(file, args.template === true);
+      } else {
+        doc.save(file, args.template === true);
+      }
+    } catch (e1) {
+      IDC.fail('io_error', 'InDesign could not save ' + (mode === 'copy' ? 'a copy' : 'the document') + ' to ' + args.path + ': ' + String(e1.message ? e1.message : e1), { path: args.path });
+    }
+    result = {
+      document_id: Number(doc.id),
+      mode: mode,
+      path: IDC.fsPath(file) || args.path,
+      bytes: IDC.fileSize(file),
+      overwritten: existed,
+      template: args.template === true,
+      name: String(doc.name),
+      document_path: idcDocumentPath(doc),
+      name_before: nameBefore
+    };
+    if (mode === 'copy' && result.document_path === '') {
+      ctx.warn('The open document itself is still unsaved (untitled); only the copy was written.');
+    }
+    ctx.changes = mode === 'copy' ? { written_files: [result.path] } : { saved_document_ids: [Number(doc.id)], written_files: [result.path] };
+    return result;
+  });
+
+IDC.register('package_document', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var folder, issues, ok = false, pdfPreset = '', result, count = 0, reportFile;
+    var copyFonts = args.copy_fonts !== false;
+    var copyGraphics = args.copy_graphics !== false;
+    var copyProfiles = args.copy_profiles === true;
+    var updateGraphics = args.update_graphics !== false;
+    var includeHidden = args.include_hidden_layers === true;
+    var ignorePreflight = args.ignore_preflight_errors !== false;
+    var createReport = args.create_report !== false;
+    var includeIdml = args.include_idml === true;
+    var includePdf = args.include_pdf === true;
+
+    if (typeof args.folder_path !== 'string' || args.folder_path.length === 0) {
+      IDC.fail('invalid_argument', 'folder_path is required (the package folder InDesign creates or fills).', null);
+    }
+    if (idcDocumentPath(doc) === '') {
+      IDC.fail('invalid_state', 'The document has never been saved; save_document with path first.', null);
+    }
+    folder = IDC.folderFor(args.folder_path);
+    if (!IDC.fileParentExists(folder)) {
+      IDC.fail('io_error', 'The parent folder of folder_path does not exist: ' + args.folder_path, { folder_path: args.folder_path });
+    }
+    if (includePdf) {
+      if (args.pdf_preset !== undefined && args.pdf_preset !== null) {
+        if (typeof args.pdf_preset !== 'string' || args.pdf_preset === '') { IDC.fail('invalid_argument', 'pdf_preset must be a preset name.', null); }
+        if (idcPdfPresetByName(args.pdf_preset) === null) {
+          IDC.fail('not_found', 'PDF preset "' + args.pdf_preset + '" not found.', { pdf_preset: args.pdf_preset, available: idcPdfPresetNames() });
+        }
+        pdfPreset = args.pdf_preset;
+      } else {
+        try { pdfPreset = String(idcHighQualityPreset().name); } catch (e0) { pdfPreset = ''; }
+      }
+    }
+    issues = idcDocumentIssues(doc);
+    if (issues.missing_links && issues.missing_links.length > 0) {
+      ctx.warn(issues.missing_links.length + ' missing link(s) cannot be packaged: ' + issues.missing_links.join(', '));
+    }
+    if (issues.missing_fonts && issues.missing_fonts.length > 0) {
+      ctx.warn(issues.missing_fonts.length + ' missing font(s): ' + issues.missing_fonts.join(', '));
+    }
+    try {
+      ok = doc.packageForPrint(folder, copyFonts, copyGraphics, copyProfiles, updateGraphics, includeHidden, ignorePreflight, createReport,
+        includeIdml, includePdf, pdfPreset, false, '', true);
+    } catch (e1) {
+      IDC.fail('io_error', 'InDesign could not package the document: ' + String(e1.message ? e1.message : e1), { folder_path: args.folder_path });
+    }
+    if (ok !== true) {
+      IDC.fail('io_error', 'InDesign reported that packaging did not succeed (preflight errors? missing links?).', { folder_path: args.folder_path, missing_links: issues.missing_links, missing_fonts: issues.missing_fonts });
+    }
+    result = {
+      document_id: Number(doc.id),
+      folder_path: IDC.fsPath(folder) || args.folder_path,
+      copy_fonts: copyFonts,
+      copy_graphics: copyGraphics,
+      copy_profiles: copyProfiles,
+      update_graphics: updateGraphics,
+      include_hidden_layers: includeHidden,
+      ignore_preflight_errors: ignorePreflight,
+      create_report: createReport,
+      include_idml: includeIdml,
+      include_pdf: includePdf,
+      pdf_preset: includePdf ? pdfPreset : null,
+      missing_links: issues.missing_links || [],
+      missing_fonts: issues.missing_fonts || [],
+      document_path: idcDocumentPath(doc)
+    };
+    try {
+      count = folder.getFiles ? folder.getFiles().length : null;
+    } catch (e2) { count = null; }
+    result.entries_in_folder = count;
+
+    /* Demo-Heft-Befund 6 (Sitzung 10): welche Schriften liegen im Paket, welche nicht. */
+    var fontReport = idcPackagedFontReport(doc, folder, copyFonts);
+    result.fonts = fontReport.fonts;
+    result.fonts_total = fontReport.fonts.length;
+    result.fonts_packaged_count = fontReport.packaged_count;
+    result.fonts_not_packaged = fontReport.not_packaged;
+    result.fonts_folder = fontReport.folder;
+    if (copyFonts && fontReport.not_packaged.length > 0) {
+      ctx.warn(fontReport.not_packaged.length + ' font(s) are not in the package folder: ' + fontReport.not_packaged.join(', ') +
+        ' – fonts from Adobe Fonts (Creative Cloud) and other protected fonts are never copied by InDesign; the printer needs them installed.');
+    }
+    ctx.changes = { written_folders: [result.folder_path] };
+    return result;
+  });
+
+/* ------------------------------------------- Schriften im Paket (Befund 6) */
+
+/*
+ * FontTypes nach indesignjs.de (Adobes Seite liefert 404; live am 05.09.2026
+ * zu bestaetigen): TYPE_1, TRUETYPE, CID, ATC, BITMAP, OCF, OPENTYPE_CFF,
+ * OPENTYPE_TT, OPENTYPE_CID, UNKNOWN.
+ */
+function idcFontTypeName(value) {
+  if (typeof FontTypes === 'undefined' || value === undefined || value === null) { return null; }
+  if (IDC.enumIs(value, FontTypes.TYPE_1)) { return 'type1'; }
+  if (IDC.enumIs(value, FontTypes.TRUETYPE)) { return 'truetype'; }
+  if (IDC.enumIs(value, FontTypes.OPENTYPE_CFF)) { return 'opentype_cff'; }
+  if (IDC.enumIs(value, FontTypes.OPENTYPE_TT)) { return 'opentype_tt'; }
+  if (IDC.enumIs(value, FontTypes.OPENTYPE_CID)) { return 'opentype_cid'; }
+  if (IDC.enumIs(value, FontTypes.CID)) { return 'cid'; }
+  if (IDC.enumIs(value, FontTypes.ATC)) { return 'atc'; }
+  if (IDC.enumIs(value, FontTypes.BITMAP)) { return 'bitmap'; }
+  if (IDC.enumIs(value, FontTypes.OCF)) { return 'ocf'; }
+  return 'unknown';
+}
+
+function idcBaseName(path) {
+  return String(path).replace(/^.*[\/\\]/, '');
+}
+
+/* Dateinamen (klein geschrieben) im Ordner "Document fonts" des Pakets. */
+function idcPackagedFontFiles(folder) {
+  var out = { exists: false, names: [] };
+  var base = IDC.fsPath(folder);
+  var sub, files, i, entry, name;
+  if (base === '') { return out; }
+  try { sub = IDC.folderFor(base + '/Document fonts'); } catch (e0) { return out; }
+  try { if (sub.exists !== true) { return out; } } catch (e1) { return out; }
+  out.exists = true;
+  try {
+    files = sub.getFiles();
+    for (i = 0; i < files.length; i++) {
+      entry = files[i];
+      name = null;
+      try { if (entry && entry.name !== undefined) { name = String(entry.name); } } catch (e2) { name = null; }
+      if (name === null) { name = idcBaseName(entry); }
+      out.names.push(name.toLowerCase());
+    }
+  } catch (e3) { /* Liste bleibt, so weit sie kam */ }
+  return out;
+}
+
+function idcIsAdobeFontsLocation(location) {
+  var text = String(location).toLowerCase();
+  return text.indexOf('/coresync/') >= 0 || text.indexOf('livetype') >= 0 || text.indexOf('/adobe fonts') >= 0;
+}
+
+/* Schriften des Dokuments mit Paketstatus. */
+function idcPackagedFontReport(doc, folder, copyFonts) {
+  var files = copyFonts ? idcPackagedFontFiles(folder) : { exists: false, names: [] };
+  var out = { fonts: [], packaged_count: 0, not_packaged: [], folder: files.exists ? IDC.fsPath(folder) + '/Document fonts' : null };
+  var i, j, font, entry, location, base, status;
+  try {
+    for (i = 0; i < doc.fonts.length; i++) {
+      font = doc.fonts.item(i);
+      entry = { family: null, style: null, name: null, postscript_name: null, type: null, status: 'installed', location: null, packaged: null, reason: null };
+      try { entry.family = String(font.fontFamily); } catch (e0) { /* bleibt null */ }
+      try { entry.style = String(font.fontStyleName); } catch (e1) { /* bleibt null */ }
+      try { entry.name = String(font.name); } catch (e2) { /* bleibt null */ }
+      try { entry.postscript_name = String(font.postscriptName); } catch (e3) { /* bleibt null */ }
+      try { entry.type = idcFontTypeName(font.fontType); } catch (e4) { /* bleibt null */ }
+      try { status = font.status; entry.status = idcFontStatusName(status); } catch (e5) { entry.status = 'installed'; }
+      location = '';
+      try { location = String(font.location); } catch (e6) { location = ''; }
+      entry.location = location === '' ? null : location;
+      if (!copyFonts) {
+        entry.packaged = false;
+        entry.reason = 'copy_fonts_off';
+      } else if (entry.status !== 'installed') {
+        entry.packaged = false;
+        entry.reason = 'not_installed';
+      } else if (location === '' || !files.exists) {
+        entry.packaged = null;
+        entry.reason = files.exists ? 'location_unknown' : 'fonts_folder_missing';
+      } else {
+        base = idcBaseName(location).toLowerCase();
+        entry.packaged = false;
+        for (j = 0; j < files.names.length; j++) {
+          if (files.names[j] === base) { entry.packaged = true; break; }
+        }
+        if (!entry.packaged) {
+          entry.reason = idcIsAdobeFontsLocation(location) ? 'adobe_fonts' : 'not_copied';
+        }
+      }
+      if (entry.packaged === true) { out.packaged_count += 1; }
+      if (entry.packaged === false && entry.reason !== 'copy_fonts_off') { out.not_packaged.push(entry.name === null ? String(entry.family) : entry.name); }
+      out.fonts.push(entry);
+    }
+  } catch (e7) { /* Liste bleibt, so weit sie kam */ }
+  return out;
+}
+

package/indesign/commands/25-export.js

@@ -0,0 +1,379 @@
+/* Bereich A – Export und Preflight. */
+
+/* ------------------------------------------------------------ export_pdf */
+
+/*
+ * Vorgaben ohne Angabe im Aufruf: Hauptpreset = lokalisiertes "High Quality
+ * Print", kein zweiter Durchgang. Hauswerte (Preset-Namen, Groessenschwelle)
+ * kommen aus der Serverkonfiguration und stehen dann schon in den args
+ * (E-54, A-6.3).
+ */
+/* Lokalisierte Namen der mitgelieferten Vorgabe "High Quality Print". */
+var IDC_HQ_PRESET_PATTERN = /high quality print|qualitativ hochwertiger druck|hochwertiger druck/i;
+
+function idcPdfPresetByName(name) {
+  var preset;
+  if (typeof name !== 'string' || name.length === 0) { return null; }
+  try {
+    preset = app.pdfExportPresets.itemByName(name);
+    if (preset && preset.isValid === true) { return preset; }
+  } catch (e) { /* nicht vorhanden */ }
+  return null;
+}
+
+function idcPdfPresetNames() {
+  var names = [];
+  var i;
+  try {
+    for (i = 0; i < app.pdfExportPresets.length; i++) {
+      names.push(String(app.pdfExportPresets.item(i).name));
+    }
+  } catch (e) { /* leer */ }
+  return names;
+}
+
+function idcHighQualityPreset() {
+  var i, preset;
+  try {
+    for (i = 0; i < app.pdfExportPresets.length; i++) {
+      preset = app.pdfExportPresets.item(i);
+      if (IDC_HQ_PRESET_PATTERN.test(String(preset.name))) { return preset; }
+    }
+  } catch (e) { /* keine */ }
+  return null;
+}
+
+/* Seitenindex zu einem Namen aus einem Seitenbereich; "+3" = dritte Seite absolut. */
+function idcPageIndexByName(doc, text) {
+  var name = text;
+  var i, n;
+  if (name.charAt(0) === '+') {
+    n = Number(name.substr(1));
+    if (isNaN(n) || n < 1 || n > doc.pages.length) { return -1; }
+    return n - 1;
+  }
+  for (i = 0; i < doc.pages.length; i++) {
+    if (String(doc.pages.item(i).name) === name) { return i; }
+  }
+  return -1;
+}
+
+function idcTrim(text) {
+  return String(text).replace(/^\s+/, '').replace(/\s+$/, '');
+}
+
+/*
+ * Seitenbereich wie in InDesigns Exportdialog ("6-8", "1, 3-5", "+2-+4")
+ * gegen die angezeigten Seitennamen aufloesen. Liefert die Zahl der Seiten.
+ */
+function idcCountPagesInRange(doc, rangeText) {
+  var parts = String(rangeText).split(',');
+  var count = 0;
+  var p, part, single, from, to, cut, left, right, found;
+
+  for (p = 0; p < parts.length; p++) {
+    part = idcTrim(parts[p]);
+    if (part === '') { continue; }
+    single = idcPageIndexByName(doc, part);
+    if (single >= 0) { count += 1; continue; }
+
+    found = false;
+    for (cut = 1; cut < part.length; cut++) {
+      if (part.charAt(cut) !== '-') { continue; }
+      left = idcTrim(part.substr(0, cut));
+      right = idcTrim(part.substr(cut + 1));
+      from = idcPageIndexByName(doc, left);
+      to = idcPageIndexByName(doc, right);
+      if (from >= 0 && to >= 0) { found = true; break; }
+    }
+    if (!found) {
+      IDC.fail('invalid_argument',
+        'page_range "' + rangeText + '": "' + part + '" names no page of this document (page names are the printed page numbers; "+3" addresses the third page).',
+        { page_range: String(rangeText), part: part });
+    }
+    if (to < from) {
+      IDC.fail('invalid_argument', 'page_range "' + rangeText + '": "' + part + '" runs backwards.',
+        { page_range: String(rangeText), part: part });
+    }
+    count += to - from + 1;
+  }
+  if (count === 0) {
+    IDC.fail('invalid_argument', 'page_range "' + rangeText + '" selects no page.', { page_range: String(rangeText) });
+  }
+  return count;
+}
+
+function idcExportPdfOnce(doc, file, preset, rangeText) {
+  var prefs = app.pdfExportPreferences;
+  var prevRange = null;
+  var prevView = null;
+  var rangeSet = false;
+  var viewSet = false;
+
+  try {
+    try {
+      prevView = prefs.viewPDF;
+      prefs.viewPDF = false;
+      viewSet = true;
+    } catch (e0) { /* nicht jede Fassung kennt viewPDF */ }
+    prevRange = prefs.pageRange;
+    prefs.pageRange = rangeText === null ? PageRange.ALL_PAGES : rangeText;
+    rangeSet = true;
+    if (preset !== null) { doc.exportFile(ExportFormat.PDF_TYPE, file, false, preset); }
+    else { doc.exportFile(ExportFormat.PDF_TYPE, file, false); }
+  } catch (e) {
+    IDC.fail('io_error', 'PDF export failed: ' + String(e.message ? e.message : e),
+      { path: IDC.fsPath(file), preset: preset === null ? null : String(preset.name) });
+  } finally {
+    if (rangeSet) { try { prefs.pageRange = prevRange; } catch (e1) { /* egal */ } }
+    if (viewSet) { try { prefs.viewPDF = prevView; } catch (e2) { /* egal */ } }
+  }
+  /*
+   * Frisches File-Objekt: ExtendScript haelt length im Objekt fest, nach dem
+   * zweiten Export stand sonst noch die Groesse des ersten drin (am lebenden
+   * InDesign 21.5 am 04.09.2026 gesehen).
+   */
+  return IDC.fileSize(IDC.fileFor(IDC.fsPath(file)));
+}
+
+IDC.register('export_pdf', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var file, rangeText, exportedCount, preset, presetUsed, bytes, fallbackName, threshold, fallback;
+
+    if (typeof args.path !== 'string' || args.path.length === 0) {
+      IDC.fail('invalid_argument', 'path is required (the target file path, not output_path).', null);
+    }
+    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 });
+    }
+
+    rangeText = null;
+    if (args.page_range !== undefined && args.page_range !== null && idcTrim(args.page_range) !== ''
+      && idcTrim(args.page_range).toLowerCase() !== 'all') {
+      rangeText = idcTrim(args.page_range);
+      exportedCount = idcCountPagesInRange(doc, rangeText);
+    } else {
+      exportedCount = doc.pages.length;
+    }
+
+    /* Preset-Kette: Wunschpreset, sonst High Quality Print, sonst aktuelle Vorgaben. */
+    var wanted = null;
+    if (args.preset !== undefined && args.preset !== null && String(args.preset) !== '') {
+      wanted = String(args.preset);
+    }
+    preset = wanted === null ? null : idcPdfPresetByName(wanted);
+    presetUsed = wanted;
+    if (preset === null) {
+      preset = idcHighQualityPreset();
+      if (preset !== null) {
+        presetUsed = String(preset.name);
+        if (wanted !== null) {
+          ctx.warn('PDF preset "' + wanted + '" not found; used "' + presetUsed + '" instead. Available: ' + idcPdfPresetNames().join(', '));
+        }
+      } else {
+        presetUsed = '[current export preferences]';
+        if (wanted !== null) {
+          ctx.warn('PDF preset "' + wanted + '" not found and no High Quality Print preset either; exported with the current export preferences. Available: ' + idcPdfPresetNames().join(', '));
+        } else {
+          ctx.warn('No High Quality Print preset found; exported with the current export preferences. Available: ' + idcPdfPresetNames().join(', '));
+        }
+      }
+    }
+
+    bytes = idcExportPdfOnce(doc, file, preset, rangeText);
+
+    fallbackName = args.fallback_preset === undefined || args.fallback_preset === null
+      ? '' : String(args.fallback_preset);
+    threshold = args.fallback_over_bytes === undefined || args.fallback_over_bytes === null
+      ? 0 : Number(args.fallback_over_bytes);
+
+    if (fallbackName !== '' && threshold > 0 && bytes !== null && bytes > threshold) {
+      fallback = idcPdfPresetByName(fallbackName);
+      if (fallback === null) {
+        ctx.warn('PDF is ' + bytes + ' bytes (over ' + threshold + '), but fallback preset "' + fallbackName + '" was not found; first export kept.');
+      } else {
+        ctx.warn('PDF was ' + bytes + ' bytes (over ' + threshold + '); exported again with "' + fallbackName + '". A spread preset turns single pages into spreads (Doppelseiten) – check exported_page_count.');
+        bytes = idcExportPdfOnce(doc, file, fallback, rangeText);
+        presetUsed = fallbackName;
+        if (bytes !== null && bytes > threshold) {
+          ctx.warn('Still ' + bytes + ' bytes after the fallback export.');
+        }
+      }
+    }
+
+    ctx.changes = { exported_files: [IDC.fsPath(file)] };
+
+    return {
+      path: IDC.fsPath(file),
+      page_count: exportedCount,
+      exported_page_count: exportedCount,
+      document_page_count: doc.pages.length,
+      bytes: bytes,
+      preset_used: presetUsed,
+      page_range_used: rangeText === null ? 'all' : rangeText
+    };
+  });
+
+/* ---------------------------------------------------- preflight_document */
+
+function idcPreflightProfileNames() {
+  var names = [];
+  var i;
+  try {
+    for (i = 0; i < app.preflightProfiles.length; i++) {
+      names.push(String(app.preflightProfiles.item(i).name));
+    }
+  } catch (e) { /* leer */ }
+  return names;
+}
+
+function idcText(value) {
+  if (value === null || value === undefined) { return null; }
+  return String(value);
+}
+
+/*
+ * aggregatedResults ist [Dokumentname, Profilname, Eintraege[]]. Die Form
+ * eines Eintrags ist in Adobes Dokumentation nur als "Array of Strings or
+ * Numbers or Arrays" beschrieben; deshalb werden beide beobachtete Formen
+ * gelesen: [Kategorie, Beschreibung, Seite, Objekt] und
+ * [Kategorie, Beschreibung, [[Seite, Objekt], ...]].
+ */
+function idcParsePreflightFindings(raw) {
+  var out = [];
+  var list, i, entry, category, description, rest, j, sub;
+
+  if (!IDC.isArray(raw)) { return out; }
+  list = (raw.length >= 3 && IDC.isArray(raw[2])) ? raw[2] : raw;
+
+  for (i = 0; i < list.length; i++) {
+    entry = list[i];
+    if (!IDC.isArray(entry)) { continue; }
+    category = idcText(entry[0]);
+    description = idcText(entry[1]);
+    rest = entry.length > 2 ? entry[2] : undefined;
+
+    if (IDC.isArray(rest)) {
+      if (rest.length === 0) {
+        out.push({ category: category, description: description, page_name: null, item: null });
+      }
+      for (j = 0; j < rest.length; j++) {
+        sub = rest[j];
+        if (IDC.isArray(sub)) {
+          out.push({
+            category: category,
+            description: description,
+            page_name: sub.length > 0 ? idcText(sub[0]) : null,
+            item: sub.length > 1 ? idcText(sub[1]) : null
+          });
+        } else {
+          out.push({
+            category: category,
+            description: description,
+            page_name: idcText(sub),
+            item: entry.length > 3 ? idcText(entry[3]) : null
+          });
+        }
+      }
+    } else {
+      out.push({
+        category: category,
+        description: description,
+        page_name: rest === undefined ? null : idcText(rest),
+        item: entry.length > 3 ? idcText(entry[3]) : null
+      });
+    }
+  }
+  return out;
+}
+
+IDC.register('preflight_document', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var profiles = idcPreflightProfileNames();
+    var maxFindings, profile, working, process, waited, summary, raw, findings, capped;
+
+    if (args.list_profiles_only === true) {
+      return { profiles: profiles, profile_count: profiles.length };
+    }
+
+    maxFindings = args.max_findings === undefined || args.max_findings === null ? 100 : Number(args.max_findings);
+    if (isNaN(maxFindings) || maxFindings < 1 || maxFindings > 500) {
+      IDC.fail('invalid_argument', 'max_findings must be between 1 and 500.', { max_findings: args.max_findings });
+    }
+
+    profile = null;
+    if (args.profile_name !== undefined && args.profile_name !== null && String(args.profile_name) !== '') {
+      try {
+        profile = app.preflightProfiles.itemByName(String(args.profile_name));
+        if (!profile || profile.isValid !== true) { profile = null; }
+      } catch (e) { profile = null; }
+      if (profile === null) {
+        IDC.fail('not_found', 'Preflight profile "' + args.profile_name + '" not found.',
+          { profile_name: String(args.profile_name), available: profiles });
+      }
+    } else {
+      /*
+       * Das Arbeitsprofil des Dokuments kann ein ungueltiges Objekt sein –
+       * oder laut Adobes DOM auch nur ein Name (String). Beides abfangen.
+       */
+      try {
+        working = doc.preflightOptions.preflightWorkingProfile;
+        if (typeof working === 'string' && working !== '') {
+          working = app.preflightProfiles.itemByName(working);
+        }
+        if (working && working.isValid === true) { profile = working; }
+      } catch (e2) { profile = null; }
+      if (profile === null) {
+        if (app.preflightProfiles.length === 0) {
+          IDC.fail('invalid_state', 'InDesign has no preflight profile at all.', null);
+        }
+        profile = app.preflightProfiles.item(0);
+        ctx.warn('The document has no valid working profile; used the first available profile "' + String(profile.name) + '".');
+      }
+    }
+
+    try {
+      process = app.preflightProcesses.add(doc, profile);
+    } catch (e3) {
+      IDC.fail('script_error', 'Could not start the preflight process: ' + String(e3.message ? e3.message : e3), null);
+    }
+
+    try {
+      /*
+       * waitForProcess(sekunden) blockiert, bis der Prozess fertig ist oder
+       * die Zeit um ist. Adobes Dokumentation und alle bekannten Praxisskripte
+       * rufen es genau einmal auf und werten den Rueckgabewert nicht aus –
+       * am lebenden InDesign 21.5 kam er sofort und ohne true zurueck, eine
+       * Warteschleife darauf drehte leer (04.09.2026). Deshalb: einmal warten,
+       * dann lesen.
+       */
+      var startedAt = new Date().getTime();
+      try { process.waitForProcess(600); } catch (eWait) { /* dann eben ohne Warten lesen */ }
+      waited = Math.round((new Date().getTime() - startedAt) / 1000);
+      if (waited >= 600) {
+        IDC.fail('timeout', 'Preflight did not finish within ' + waited + ' seconds.', null);
+      }
+      summary = idcTrim(String(process.processResults));
+      raw = process.aggregatedResults;
+      findings = idcParsePreflightFindings(raw);
+    } finally {
+      try { process.remove(); } catch (e4) { /* Prozess bleibt dann stehen, stoert nicht */ }
+    }
+
+    capped = findings.length > maxFindings ? findings.slice(0, maxFindings) : findings;
+    if (findings.length > maxFindings) {
+      ctx.warn(findings.length + ' findings, only the first ' + maxFindings + ' returned (max_findings).');
+    }
+
+    return {
+      profile_used: String(profile.name),
+      summary: summary,
+      error_count: findings.length,
+      findings: capped
+    };
+  });