layoutbridge-light 0.0.0-stage → 1.0.0

package/indesign/commands/90-print-on-demand.js

@@ -0,0 +1,495 @@
+/*
+ * A-43 (Sitzung 43) – Buchsatz fuer Print-on-Demand: check_print_on_demand
+ * und create_book_cover. Alle Grenzwerte und Masse kommen als Parameter
+ * oder aus der Serverkonfiguration (print_on_demand); im Code steht kein
+ * Wert eines bestimmten Dienstes (E-56, E-98).
+ */
+
+var IDC_POD_TOLERANCE_MM = 0.01;
+
+function idcPodNumber(args, key, min, max) {
+  var v = args[key];
+  if (v === undefined || v === null) { return null; }
+  if (typeof v !== 'number' || !isFinite(v) || v < min || v > max) {
+    IDC.fail('invalid_argument', key + ' must be a number from ' + min + ' to ' + max + '.', { value: v });
+  }
+  return v;
+}
+
+/* Stufen des Bundstegs [{max_pages, min_mm}], aufsteigend nach max_pages. */
+function idcPodTiers(value) {
+  var out = [], i, t;
+  if (value === undefined || value === null) { return null; }
+  if (!IDC.isArray(value) || value.length === 0) {
+    IDC.fail('invalid_argument', 'inside_margin_tiers must be a non-empty array of {max_pages, min_mm}.', null);
+  }
+  for (i = 0; i < value.length; i++) {
+    t = value[i];
+    if (!t || typeof t !== 'object' || typeof t.max_pages !== 'number' || t.max_pages < 1 || typeof t.min_mm !== 'number' || t.min_mm < 0) {
+      IDC.fail('invalid_argument', 'inside_margin_tiers[' + i + '] must be {max_pages >= 1, min_mm >= 0}.', { tier: t });
+    }
+    out.push({ max_pages: t.max_pages, min_mm: t.min_mm });
+  }
+  out.sort(function (a, b) { return a.max_pages - b.max_pages; });
+  return out;
+}
+
+function idcPodCheck(name, status, required, actual) {
+  return { check: name, status: status, required: required, actual: actual, findings: [] };
+}
+
+function idcPodSkipped(name, key) {
+  var c = idcPodCheck(name, 'skipped', null, null);
+  c.reason = 'no limit given: pass ' + key + ' or set print_on_demand.' + key + ' in the server configuration';
+  return c;
+}
+
+/* Seiten des Dokuments und ihre Raender (innen/aussen bei Doppelseiten). */
+function idcPodPageInfo(page, facing) {
+  var prefs = page.marginPreferences;
+  var side = IDC.pageSide(page);
+  var size = IDC.pageSize(page);
+  return {
+    page: page,
+    page_id: Number(page.id),
+    page_name: String(page.name),
+    side: side,
+    width: size.width,
+    height: size.height,
+    top: Number(prefs.top),
+    bottom: Number(prefs.bottom),
+    inside: Number(prefs.left),
+    outside: Number(prefs.right),
+    /* linke Kante / rechte Kante der Seite in Seitenkoordinaten */
+    left_is_inside: !facing || side !== 'LEFT_HAND'
+  };
+}
+
+/* Abstand eines Rechtecks zu den Beschnittkanten: innen, aussen, oben, unten. */
+function idcPodEdgeDistances(info, rect) {
+  var left = rect.x;
+  var right = info.width - rect.x - rect.width;
+  return {
+    inside: info.left_is_inside ? left : right,
+    outside: info.left_is_inside ? right : left,
+    top: rect.y,
+    bottom: info.height - rect.y - rect.height
+  };
+}
+
+function idcPodBeyondTrim(dist) {
+  return dist.inside < -IDC_POD_TOLERANCE_MM || dist.outside < -IDC_POD_TOLERANCE_MM
+    || dist.top < -IDC_POD_TOLERANCE_MM || dist.bottom < -IDC_POD_TOLERANCE_MM;
+}
+
+function idcPodPush(check, finding, state) {
+  state.total += 1;
+  if (state.total <= state.max) { check.findings.push(finding); } else { state.truncated = true; }
+}
+
+function idcPodRound(v) { return v === null ? null : IDC.round(v); }
+
+IDC.register('check_print_on_demand', { needs_document: true, read_only: true, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var facing = idcFacing(doc);
+    var minPages = idcPodNumber(args, 'min_page_count', 1, 100000);
+    var maxPages = idcPodNumber(args, 'max_page_count', 1, 100000);
+    var multiple = idcPodNumber(args, 'page_count_multiple', 1, 1000);
+    var tiers = idcPodTiers(args.inside_margin_tiers);
+    var minOutside = idcPodNumber(args, 'min_outside_margin_mm', 0, 1000);
+    var bleedWanted = idcPodNumber(args, 'bleed_mm', 0, 50);
+    var bleedTolerance = idcPodNumber(args, 'bleed_tolerance_mm', 0, 5);
+    var minFont = idcPodNumber(args, 'min_font_size_pt', 0, 1296);
+    var minPpi = idcPodNumber(args, 'min_ppi', 1, 100000);
+    var maxFindings = idcPodNumber(args, 'max_findings', 1, 1000);
+    var state = { total: 0, max: maxFindings === null ? 200 : maxFindings, truncated: false };
+    var checks = [], pages = [], pageCount = Number(doc.pages.length);
+    var i, j, c, info, insideReq = null, tier = null, minIn = null, minOut = null, worst, items, item, rect, dist, id;
+
+    if (bleedTolerance === null) { bleedTolerance = 0.1; }
+    if (multiple !== null && Math.floor(multiple) !== multiple) { IDC.fail('invalid_argument', 'page_count_multiple must be a whole number.', { value: multiple }); }
+    if (!facing) { ctx.warn('The document has single pages, not facing pages; the left margin is read as the inside margin (Bundsteg) and the right one as the outside margin.'); }
+    for (i = 0; i < pageCount; i++) { pages.push(idcPodPageInfo(doc.pages.item(i), facing)); }
+
+    /* 1. Seitenzahl */
+    if (minPages === null && maxPages === null && multiple === null) {
+      c = idcPodSkipped('page_count', 'min_page_count / max_page_count / page_count_multiple');
+      c.actual = pageCount;
+    } else {
+      c = idcPodCheck('page_count', 'pass', { min: minPages, max: maxPages, multiple_of: multiple }, pageCount);
+      if (minPages !== null && pageCount < minPages) { c.status = 'fail'; c.findings.push({ problem: 'too_few_pages', page_count: pageCount, min: minPages }); }
+      if (maxPages !== null && pageCount > maxPages) { c.status = 'fail'; c.findings.push({ problem: 'too_many_pages', page_count: pageCount, max: maxPages }); }
+      if (multiple !== null && pageCount % multiple !== 0) { c.status = 'fail'; c.findings.push({ problem: 'not_a_multiple', page_count: pageCount, multiple_of: multiple }); }
+    }
+    checks.push(c);
+
+    /* 2. Bundsteg je Seitenzahlstufe */
+    for (i = 0; i < pages.length; i++) { if (minIn === null || pages[i].inside < minIn) { minIn = pages[i].inside; } }
+    if (tiers === null) {
+      c = idcPodSkipped('inside_margin', 'inside_margin_tiers');
+      c.actual = idcPodRound(minIn);
+    } else {
+      for (i = 0; i < tiers.length; i++) { if (pageCount <= tiers[i].max_pages) { tier = tiers[i]; break; } }
+      if (tier === null) {
+        c = idcPodCheck('inside_margin', 'fail', null, idcPodRound(minIn));
+        c.findings.push({ problem: 'page_count_above_last_tier', page_count: pageCount, last_tier_max_pages: tiers[tiers.length - 1].max_pages });
+      } else {
+        insideReq = tier.min_mm;
+        c = idcPodCheck('inside_margin', 'pass', { min_mm: insideReq, tier_max_pages: tier.max_pages }, idcPodRound(minIn));
+        for (i = 0; i < pages.length; i++) {
+          if (pages[i].inside < insideReq - IDC_POD_TOLERANCE_MM) {
+            c.status = 'fail';
+            idcPodPush(c, { page_id: pages[i].page_id, page_name: pages[i].page_name, inside_mm: idcPodRound(pages[i].inside) }, state);
+          }
+        }
+      }
+    }
+    checks.push(c);
+
+    /* 3. Aussen, oben, unten */
+    for (i = 0; i < pages.length; i++) {
+      worst = Math.min(pages[i].outside, pages[i].top, pages[i].bottom);
+      if (minOut === null || worst < minOut) { minOut = worst; }
+    }
+    if (minOutside === null) {
+      c = idcPodSkipped('outside_margins', 'min_outside_margin_mm');
+      c.actual = idcPodRound(minOut);
+    } else {
+      c = idcPodCheck('outside_margins', 'pass', { min_mm: minOutside }, idcPodRound(minOut));
+      for (i = 0; i < pages.length; i++) {
+        info = pages[i];
+        if (info.outside < minOutside - IDC_POD_TOLERANCE_MM || info.top < minOutside - IDC_POD_TOLERANCE_MM || info.bottom < minOutside - IDC_POD_TOLERANCE_MM) {
+          c.status = 'fail';
+          idcPodPush(c, { page_id: info.page_id, page_name: info.page_name, outside_mm: idcPodRound(info.outside), top_mm: idcPodRound(info.top), bottom_mm: idcPodRound(info.bottom) }, state);
+        }
+      }
+    }
+    checks.push(c);
+
+    /* 4. Anschnitt: innen 0 bei Doppelseiten, aussen/oben/unten wie verlangt; randabfallende Objekte brauchen Anschnitt. */
+    var bleed = idcDocumentBleedMm(doc);
+    var bleedingItems = [], crossing = [];
+    for (i = 0; i < pages.length; i++) {
+      info = pages[i];
+      try { items = info.page.pageItems; } catch (eI) { continue; }
+      for (j = 0; j < items.length; j++) {
+        item = IDC.concrete(items.item(j));
+        try { rect = IDC.boundsOnPage(doc, item, info.page); } catch (eR) { continue; }
+        dist = idcPodEdgeDistances(info, rect);
+        if (idcPodBeyondTrim(dist)) { bleedingItems.push({ item: item, info: info, dist: dist }); }
+      }
+    }
+    c = idcPodCheck('bleed', 'pass', { inside_mm: facing ? 0 : null, top_bottom_outside_mm: bleedWanted, tolerance_mm: bleedTolerance }, bleed);
+    if (bleed !== null) {
+      if (facing && bleed.inside_or_left > IDC_POD_TOLERANCE_MM) {
+        c.status = 'fail';
+        c.findings.push({ problem: 'inside_bleed_not_zero', inside_mm: bleed.inside_or_left });
+      }
+      if (bleedWanted !== null) {
+        var edges = [['top', bleed.top], ['bottom', bleed.bottom], [facing ? 'outside' : 'right', bleed.outside_or_right]];
+        if (!facing) { edges.push(['left', bleed.inside_or_left]); }
+        for (i = 0; i < edges.length; i++) {
+          if (bleedingItems.length > 0 || edges[i][1] > IDC_POD_TOLERANCE_MM) {
+            if (Math.abs(edges[i][1] - bleedWanted) > bleedTolerance + 0.0001) {
+              c.status = 'fail';
+              c.findings.push({ problem: 'bleed_differs', edge: edges[i][0], actual_mm: edges[i][1], required_mm: bleedWanted });
+            }
+          }
+        }
+      }
+      if (bleedingItems.length > 0 && bleed.top <= IDC_POD_TOLERANCE_MM && bleed.bottom <= IDC_POD_TOLERANCE_MM && bleed.outside_or_right <= IDC_POD_TOLERANCE_MM) {
+        c.status = 'fail';
+        c.findings.push({ problem: 'bleeding_objects_without_bleed', object_count: bleedingItems.length });
+      }
+    }
+    c.bleeding_object_count = bleedingItems.length;
+    checks.push(c);
+
+    /* 5. Objekte im Randbereich (naeher am Beschnitt als die Mindestraender, ohne randabfallende) */
+    if (minOutside === null && insideReq === null) {
+      c = idcPodSkipped('objects_in_margin', 'min_outside_margin_mm / inside_margin_tiers');
+    } else {
+      c = idcPodCheck('objects_in_margin', 'pass', { inside_mm: insideReq, outside_top_bottom_mm: minOutside }, null);
+      for (i = 0; i < pages.length; i++) {
+        info = pages[i];
+        try { items = info.page.pageItems; } catch (eI2) { continue; }
+        for (j = 0; j < items.length; j++) {
+          item = IDC.concrete(items.item(j));
+          try { rect = IDC.boundsOnPage(doc, item, info.page); id = Number(item.id); } catch (eR2) { continue; }
+          dist = idcPodEdgeDistances(info, rect);
+          if (idcPodBeyondTrim(dist)) { continue; }
+          var close = [];
+          if (insideReq !== null && dist.inside < insideReq - IDC_POD_TOLERANCE_MM) { close.push('inside'); }
+          if (minOutside !== null && dist.outside < minOutside - IDC_POD_TOLERANCE_MM) { close.push('outside'); }
+          if (minOutside !== null && dist.top < minOutside - IDC_POD_TOLERANCE_MM) { close.push('top'); }
+          if (minOutside !== null && dist.bottom < minOutside - IDC_POD_TOLERANCE_MM) { close.push('bottom'); }
+          if (close.length > 0) {
+            c.status = 'fail';
+            idcPodPush(c, {
+              item_id: id, type: IDC.itemType(item), page_id: info.page_id, page_name: info.page_name, edges: close,
+              distance_mm: { inside: idcPodRound(dist.inside), outside: idcPodRound(dist.outside), top: idcPodRound(dist.top), bottom: idcPodRound(dist.bottom) }
+            }, state);
+          }
+        }
+      }
+    }
+    checks.push(c);
+
+    /* 6. Objekte ueber den Bund (bei Anschnitt innen 0 werden sie am Bund abgeschnitten) */
+    if (!facing) {
+      c = idcPodCheck('objects_across_spine', 'skipped', null, null);
+      c.reason = 'single pages – no spine';
+    } else {
+      c = idcPodCheck('objects_across_spine', 'pass', null, null);
+      for (i = 0; i < bleedingItems.length; i++) {
+        if (bleedingItems[i].dist.inside < -IDC_POD_TOLERANCE_MM) {
+          crossing.push(bleedingItems[i]);
+          c.status = 'fail';
+          idcPodPush(c, {
+            item_id: Number(bleedingItems[i].item.id), type: IDC.itemType(bleedingItems[i].item),
+            page_id: bleedingItems[i].info.page_id, page_name: bleedingItems[i].info.page_name,
+            beyond_spine_mm: idcPodRound(-bleedingItems[i].dist.inside)
+          }, state);
+        }
+      }
+      c.actual = crossing.length;
+    }
+    checks.push(c);
+
+    /* 7. Mindestschriftgrad (alle Textlaeufe, auch Musterseiten und Uebersatz) */
+    if (minFont === null) {
+      c = idcPodSkipped('min_font_size', 'min_font_size_pt');
+    } else {
+      c = idcPodCheck('min_font_size', 'pass', { min_pt: minFont }, null);
+      var smallest = null, s, story, ranges, r, range, size, frames;
+      for (s = 0; s < doc.stories.length; s++) {
+        story = doc.stories.item(s);
+        try { ranges = story.textStyleRanges; } catch (eT) { continue; }
+        for (r = 0; r < ranges.length; r++) {
+          range = ranges.item(r);
+          try {
+            size = IDC.inPoints(function () { return Number(range.pointSize); });
+          } catch (eS) { continue; }
+          var text = '';
+          try { text = String(range.contents); } catch (eC) { text = ''; }
+          if (text.replace(/[\s\r\n\u0016\u0007\u0008]/g, '') === '') { continue; }
+          if (smallest === null || size < smallest) { smallest = size; }
+          if (size < minFont - 0.001) {
+            c.status = 'fail';
+            frames = idcRunFrames(range);
+            idcPodPush(c, {
+              story_id: Number(story.id), point_size: IDC.round(size, 2), page_id: frames.page_id, page_name: frames.page_name,
+              frame_ids: frames.frame_ids, is_master: frames.is_master, snippet: idcSnippet(text, 40)
+            }, state);
+          }
+        }
+      }
+      c.actual = smallest === null ? null : IDC.round(smallest, 2);
+    }
+    checks.push(c);
+
+    /* 8. Bildaufloesung (effektiv, nur Pixelbilder) */
+    if (minPpi === null) {
+      c = idcPodSkipped('image_resolution', 'min_ppi');
+    } else {
+      c = idcPodCheck('image_resolution', 'pass', { min_ppi: minPpi }, null);
+      var graphics = [], g, graphic, ppi, lowest = null, landing, link, pdfLike;
+      try { graphics = doc.allGraphics; } catch (eG) { graphics = []; }
+      for (g = 0; g < graphics.length; g++) {
+        graphic = graphics[g];
+        pdfLike = false;
+        try { pdfLike = /pdf|eps|postscript/i.test(String(graphic.imageTypeName)) || IDC.className(graphic) === 'PDF' || IDC.className(graphic) === 'EPS'; } catch (eP) { pdfLike = false; }
+        if (pdfLike) { continue; }
+        try { ppi = idcPpi(graphic.effectivePpi); } catch (eE) { ppi = null; }
+        if (ppi === null) { continue; }
+        if (lowest === null || ppi.min < lowest) { lowest = ppi.min; }
+        if (ppi.min < minPpi) {
+          c.status = 'fail';
+          landing = IDC.landing(graphic);
+          link = null;
+          try { link = String(graphic.itemLink.name); } catch (eL) { link = null; }
+          idcPodPush(c, { graphic_id: Number(graphic.id), file_name: link, effective_ppi: ppi.min, page_id: landing.page_id, page_name: landing.page_name }, state);
+        }
+      }
+      c.actual = lowest;
+    }
+    checks.push(c);
+
+    /* 9. Schriften: vorhanden und einbettbar (ob sie im PDF eingebettet sind, zeigt erst das PDF) */
+    c = idcPodCheck('fonts', 'pass', { installed: true, pdf_embedding_allowed: true }, null);
+    var fonts, f, font, status, allowed, fontCount = 0;
+    try { fonts = doc.fonts; } catch (eF) { fonts = null; }
+    if (fonts !== null) {
+      for (f = 0; f < fonts.length; f++) {
+        font = fonts.item(f);
+        fontCount += 1;
+        try { status = idcFontStatusName(font.status); } catch (eFs) { status = 'unknown'; }
+        allowed = null;
+        try { if (font.allowPDFEmbedding === false) { allowed = false; } else if (font.allowPDFEmbedding === true) { allowed = true; } } catch (eFa) { allowed = null; }
+        if (status !== 'installed' || allowed === false) {
+          c.status = 'fail';
+          idcPodPush(c, { font: String(font.name).replace('\t', ' '), status: status, pdf_embedding_allowed: allowed }, state);
+        }
+      }
+    }
+    c.actual = fontCount;
+    checks.push(c);
+
+    var failed = [], skipped = [];
+    for (i = 0; i < checks.length; i++) {
+      if (checks[i].status === 'fail') { failed.push(checks[i].check); }
+      if (checks[i].status === 'skipped') { skipped.push(checks[i].check); }
+    }
+    if (state.truncated) { ctx.warn(state.total + ' findings, only the first ' + state.max + ' returned (max_findings).'); }
+    if (skipped.length > 0) { ctx.warn('Not checked for lack of a limit: ' + skipped.join(', ') + '.'); }
+
+    return {
+      passed: failed.length === 0,
+      failed_checks: failed,
+      skipped_checks: skipped,
+      page_count: pageCount,
+      facing_pages: facing,
+      page_size_mm: pages.length > 0 ? { width: pages[0].width, height: pages[0].height } : null,
+      checks: checks,
+      findings_total: state.total,
+      findings_truncated: state.truncated
+    };
+  });
+
+/* ------------------------------------------------------- create_book_cover */
+
+var IDC_MM_PER_INCH = 25.4;
+var IDC_PT_PER_MM = 72 / 25.4;
+
+function idcPodSize(widthMm, heightMm) {
+  return {
+    width_mm: IDC.round(widthMm, 3),
+    height_mm: IDC.round(heightMm, 3),
+    width_pt: IDC.round(widthMm * IDC_PT_PER_MM, 2),
+    height_pt: IDC.round(heightMm * IDC_PT_PER_MM, 2),
+    width_in: IDC.round(widthMm / IDC_MM_PER_INCH, 4),
+    height_in: IDC.round(heightMm / IDC_MM_PER_INCH, 4)
+  };
+}
+
+IDC.register('create_book_cover', { needs_document: false, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var pageCount = idcPodNumber(args, 'page_count', 1, 100000);
+    var trimW = idcPodNumber(args, 'trim_width_mm', 1, 2000);
+    var trimH = idcPodNumber(args, 'trim_height_mm', 1, 2000);
+    var perPageMm = idcPodNumber(args, 'spine_per_page_mm', 0, 10);
+    var perPageIn = idcPodNumber(args, 'spine_per_page_in', 0, 1);
+    var bleedMm = idcPodNumber(args, 'bleed_mm', 0, 50);
+    var safety = idcPodNumber(args, 'safety_margin_mm', 0, 500);
+    var spineSafety = idcPodNumber(args, 'spine_safety_mm', 0, 100);
+    var barcode = args.barcode_area === undefined || args.barcode_area === null ? null : args.barcode_area;
+    var spine, width, doc, prefs, page, spread, guides = [], barcodeId = null, k, keys;
+
+    if (pageCount === null || Math.floor(pageCount) !== pageCount) { IDC.fail('invalid_argument', 'page_count is required: the number of interior pages (whole number).', { page_count: args.page_count }); }
+    if (trimW === null || trimH === null) { IDC.fail('invalid_argument', 'trim_width_mm and trim_height_mm (trim size of the book, Endformat) are required.', null); }
+    if (perPageIn !== null) {
+      spine = pageCount * perPageIn * IDC_MM_PER_INCH;
+    } else if (perPageMm !== null) {
+      spine = pageCount * perPageMm;
+    } else {
+      IDC.fail('invalid_argument', 'Pass spine_per_page_mm or spine_per_page_in (paper thickness per page as the printer states it), or set print_on_demand.spine_per_page_mm in the server configuration.', null);
+    }
+    if (bleedMm === null) { bleedMm = 0; ctx.warn('No bleed_mm given and none configured – the cover has no bleed (Anschnitt).'); }
+    if (safety === null) { safety = 0; }
+    if (barcode !== null) {
+      keys = ['width_mm', 'height_mm', 'offset_x_mm', 'offset_y_mm'];
+      if (typeof barcode !== 'object') { IDC.fail('invalid_argument', 'barcode_area must be {width_mm, height_mm, offset_x_mm, offset_y_mm}.', null); }
+      for (k = 0; k < keys.length; k++) {
+        if (typeof barcode[keys[k]] !== 'number' || barcode[keys[k]] < 0) {
+          IDC.fail('invalid_argument', 'barcode_area.' + keys[k] + ' must be a number of 0 or more.', { barcode_area: barcode });
+        }
+      }
+      if (barcode.width_mm + barcode.offset_x_mm > trimW || barcode.height_mm + barcode.offset_y_mm > trimH) {
+        IDC.fail('invalid_argument', 'barcode_area does not fit on the back cover.', { barcode_area: barcode, trim_width_mm: trimW, trim_height_mm: trimH });
+      }
+    }
+    width = 2 * trimW + spine;
+
+    try {
+      doc = app.documents.add();
+    } catch (e0) {
+      IDC.fail('script_error', 'InDesign could not create a document: ' + String(e0.message ? e0.message : e0), null);
+    }
+    try {
+      prefs = doc.documentPreferences;
+      prefs.facingPages = false;
+      prefs.pagesPerDocument = 1;
+      prefs.pageWidth = width;
+      prefs.pageHeight = trimH;
+      prefs.documentBleedUniformSize = true;
+      prefs.documentBleedTopOffset = bleedMm;
+      prefs.documentBleedBottomOffset = bleedMm;
+      prefs.documentBleedInsideOrLeftOffset = bleedMm;
+      prefs.documentBleedOutsideOrRightOffset = bleedMm;
+      page = doc.pages.item(0);
+      idcApplyMargins(doc, { top: safety, bottom: safety, left: safety, right: safety }, { count: 1, gutter_mm: 0 });
+      idcApplyMargins(page, { top: safety, bottom: safety, left: safety, right: safety }, { count: 1, gutter_mm: 0 });
+      spread = page.parent;
+    } catch (e1) {
+      IDC.fail('script_error', 'The cover document was created but could not be set up: ' + String(e1.message ? e1.message : e1), { document_id: Number(doc.id) });
+    }
+
+    /* Hilfslinien: Falz Rueckseite/Ruecken und Ruecken/Vorderseite, optional die Sicherheitszone im Ruecken. */
+    function addGuide(position, role) {
+      var guide = null;
+      try {
+        guide = IDC.withRulerOrigin(doc, RulerOrigin.PAGE_ORIGIN, function () {
+          return spread.guides.add(undefined, { orientation: HorizontalOrVertical.VERTICAL, location: position });
+        });
+      } catch (eG) {
+        ctx.warn('Could not add the ' + role + ' guide: ' + String(eG.message ? eG.message : eG));
+        return;
+      }
+      guides.push({ guide_id: Number(guide.id), role: role, position_mm: IDC.round(position, 3) });
+    }
+    addGuide(trimW, 'spine_left');
+    addGuide(trimW + spine, 'spine_right');
+    if (spineSafety !== null && spineSafety > 0) {
+      if (spine > 2 * spineSafety) {
+        addGuide(trimW + spineSafety, 'spine_safety_left');
+        addGuide(trimW + spine - spineSafety, 'spine_safety_right');
+      } else {
+        ctx.warn('The spine (' + IDC.round(spine, 3) + ' mm) is narrower than twice spine_safety_mm – no room for spine text.');
+      }
+    }
+
+    /* Freiraum fuer den Strichcode: nicht druckender Rahmen auf der Rueckseite, gemessen von Ruecken und Unterkante. */
+    if (barcode !== null) {
+      var bx = trimW - barcode.offset_x_mm - barcode.width_mm;
+      var by = trimH - barcode.offset_y_mm - barcode.height_mm;
+      var frame = idcAddItem(doc, page, 'rectangles', [by, bx, by + barcode.height_mm, bx + barcode.width_mm], 'page');
+      try { frame.nonprinting = true; } catch (eN) { ctx.warn('Could not make the barcode frame non-printing – delete it before export.'); }
+      try { frame.name = 'barcode_area'; } catch (eNm) { /* ohne Namen */ }
+      barcodeId = Number(frame.id);
+    }
+
+    ctx.changes = { created_document_ids: [Number(doc.id)] };
+    if (barcodeId !== null) { ctx.changes.created_frame_ids = [barcodeId]; }
+
+    return {
+      document_id: Number(doc.id),
+      name: String(doc.name),
+      page_id: Number(page.id),
+      page_count: pageCount,
+      spine_width_mm: IDC.round(spine, 3),
+      spine_width_in: IDC.round(spine / IDC_MM_PER_INCH, 4),
+      trim_size: idcPodSize(width, trimH),
+      size_with_bleed: idcPodSize(width + 2 * bleedMm, trimH + 2 * bleedMm),
+      bleed_mm: bleedMm,
+      safety_margin_mm: safety,
+      back_cover_mm: { x: 0, width: IDC.round(trimW, 3) },
+      spine_mm: { x: IDC.round(trimW, 3), width: IDC.round(spine, 3) },
+      front_cover_mm: { x: IDC.round(trimW + spine, 3), width: IDC.round(trimW, 3) },
+      guides: guides,
+      barcode_frame_id: barcodeId,
+      barcode_area_mm: barcodeId === null ? null : { x: IDC.round(trimW - barcode.offset_x_mm - barcode.width_mm, 3), y: IDC.round(trimH - barcode.offset_y_mm - barcode.height_mm, 3), width: barcode.width_mm, height: barcode.height_mm }
+    };
+  });