layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/30-pages.js

@@ -0,0 +1,1032 @@
+/* Bereich B – Seiten. */
+
+/* Seitenseite nach Spezifikation: LEFT_HAND | RIGHT_HAND | SINGLE_SIDED. */
+function idcPageSide(page) {
+  return IDC.pageSide(page);
+}
+
+/* Name der angewandten Musterseite, "[None]" wenn keine. */
+function idcAppliedParentName(page) {
+  var master;
+  try { master = page.appliedMaster; } catch (e) { return '[None]'; }
+  try {
+    if (master && master.isValid) { return String(master.name); }
+  } catch (e2) { /* NothingEnum kennt kein isValid */ }
+  return '[None]';
+}
+
+/* Klassenname und Objektart kommen aus dem Kern (IDC.className, IDC.itemType). */
+function idcClassName(item) {
+  return IDC.className(item);
+}
+
+function idcItemType(item) {
+  return IDC.itemType(item);
+}
+
+/* Absatzformat, wenn im ganzen Rahmen einheitlich, sonst null. */
+function idcUniformParagraphStyle(frame) {
+  var name = null;
+  var i, current;
+  try {
+    if (frame.paragraphs.length === 0) { return null; }
+    for (i = 0; i < frame.paragraphs.length; i++) {
+      current = String(frame.paragraphs.item(i).appliedParagraphStyle.name);
+      if (name === null) { name = current; }
+      else if (name !== current) { return null; }
+    }
+  } catch (e) { return null; }
+  return name;
+}
+
+function idcTextSnippet(frame) {
+  var text = '';
+  try { text = String(frame.contents); } catch (e) { return ''; }
+  if (text.length > 200) { text = text.substr(0, 200); }
+  return text;
+}
+
+function idcDescribeItem(item, parentGroupId, doc, page) {
+  var type = idcItemType(item);
+  var entry = {
+    id: null,
+    type: type,
+    bounds_mm: null,
+    paragraph_style: null,
+    text_snippet: null,
+    child_count: 0,
+    parent_group_id: parentGroupId,
+    layer_name: idcLayerName(item)
+  };
+
+  /* Bei "other" sagen, was es wirklich ist – sonst hilft die Angabe niemandem. */
+  if (type === 'other') {
+    entry.class_name = idcClassName(item);
+  }
+
+  try { entry.id = Number(item.id); } catch (e1) { entry.id = null; }
+  try {
+    entry.bounds_mm = doc ? IDC.boundsOnPage(doc, item, page) : IDC.boundsToRect(item.geometricBounds);
+  } catch (e2) { entry.bounds_mm = null; }
+
+  if (type === 'text') {
+    entry.paragraph_style = idcUniformParagraphStyle(item);
+    entry.text_snippet = idcTextSnippet(item);
+  }
+  if (type === 'group') {
+    try { entry.child_count = item.pageItems.length; } catch (e3) { entry.child_count = 0; }
+  }
+  return entry;
+}
+
+function idcCollectItems(container, out, parentGroupId, includeChildren, doc, page) {
+  var i, item, entry;
+  for (i = 0; i < container.pageItems.length; i++) {
+    item = IDC.concrete(container.pageItems.item(i));
+    entry = idcDescribeItem(item, parentGroupId, doc, page);
+    out.push(entry);
+    if (entry.type === 'group' && includeChildren) {
+      idcCollectItems(item, out, entry.id, includeChildren, doc, page);
+    }
+  }
+}
+
+IDC.register('list_pages', { needs_document: true, read_only: true, ruler: 'page' },
+  function (ctx) {
+    var doc = ctx.doc;
+    var pages = [];
+    var i, page;
+    for (i = 0; i < doc.pages.length; i++) {
+      page = doc.pages.item(i);
+      pages.push({
+        page_id: Number(page.id),
+        index: Number(page.documentOffset),
+        side: idcPageSide(page),
+        parent: idcAppliedParentName(page),
+        name: String(page.name)
+      });
+    }
+    return { pages: pages, count: pages.length };
+  });
+
+IDC.register('get_page_state', { needs_document: true, read_only: true, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+
+    if (args.page_id === undefined || args.page_id === null) {
+      IDC.fail('invalid_argument', 'page_id is required.', null);
+    }
+
+    var found = IDC.pageById(doc, args.page_id);
+    if (found === null) {
+      IDC.fail('not_found', 'No page with page_id ' + args.page_id + ' in this document.',
+        { page_id: args.page_id });
+    }
+
+    var page = found.page;
+    var includeChildren = args.include_group_children === false ? false : true;
+    var frames = [];
+    /* Begrenzungen relativ zu dieser Seite, auch bei Anschnitt ueber den Bund (E-28). */
+    idcCollectItems(page, frames, null, includeChildren, doc, page);
+
+    /*
+     * Seitenbegrenzung relativ zur Seite selbst: immer x = 0, y = 0.
+     * page.bounds liefert unter Seiten-Nullpunkt fuer die rechte Seite eines
+     * Bogens x = 210 (Live-Fund 04.09.2026), deshalb nur die Groesse lesen.
+     */
+    var bounds = null;
+    try {
+      var size = IDC.pageSize(page);
+      bounds = { x: 0, y: 0, width: size.width, height: size.height };
+    } catch (e) { bounds = null; }
+
+    return {
+      page_id: Number(page.id),
+      name: String(page.name),
+      is_parent_page: found.is_parent_page,
+      include_group_children: includeChildren,
+      coordinate_space: 'page',
+      page_bounds_mm: bounds,
+      frames: frames,
+      frame_count: frames.length
+    };
+  });
+
+/* -------------------------------------------------------------- add_page */
+
+/* Dokumentseite (keine Musterseite) ueber die ID, sonst Fehler. */
+function idcDocumentPageById(doc, id, field) {
+  var found;
+  if (id === undefined || id === null) {
+    IDC.fail('invalid_argument', field + ' is required.', null);
+  }
+  found = IDC.pageById(doc, id);
+  if (found === null) {
+    IDC.fail('not_found', 'No page with ' + field + ' ' + id + ' in this document.', { page_id: id });
+  }
+  if (found.is_parent_page) {
+    IDC.fail('invalid_state', field + ' ' + id + ' is a master page (Musterseite); this tool works on document pages.',
+      { page_id: id });
+  }
+  return found.page;
+}
+
+function idcDescribePage(page) {
+  var spread = null;
+  try { spread = page.parent; } catch (e) { spread = null; }
+  return {
+    page_id: Number(page.id),
+    index: Number(page.documentOffset),
+    name: String(page.name),
+    side: idcPageSide(page),
+    spread_index: spread === null ? null : IDC.spreadIndex(spread)
+  };
+}
+
+IDC.register('add_page', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var at = args.at;
+    var page, ref, spread, spreadCount;
+    /* Sitzung 10 (Demo-Heft-Befund 1): pages.add() kann die Ansicht verschieben; Ansicht merken. */
+    var keepView = idcKeepViewArg(args);
+    var view = keepView ? idcCaptureView(doc) : null;
+    var viewRestored = null;
+
+    try {
+      if (at === undefined || at === null || at === 'end') {
+        page = doc.pages.add(LocationOptions.AT_END);
+      } else if (at === 'start') {
+        page = doc.pages.add(LocationOptions.AT_BEGINNING);
+      } else if (typeof at === 'object' && at.after_page_id !== undefined) {
+        ref = idcDocumentPageById(doc, at.after_page_id, 'at.after_page_id');
+        page = doc.pages.add(LocationOptions.AFTER, ref);
+      } else if (typeof at === 'object' && at.before_page_id !== undefined) {
+        ref = idcDocumentPageById(doc, at.before_page_id, 'at.before_page_id');
+        page = doc.pages.add(LocationOptions.BEFORE, ref);
+      } else {
+        IDC.fail('invalid_argument',
+          'at must be "start", "end", { after_page_id } or { before_page_id }.', { at: at });
+      }
+    } catch (e) {
+      if (e && e.isIdcError) { throw e; }
+      IDC.fail('script_error', 'InDesign could not add the page: ' + String(e.message ? e.message : e), null);
+    }
+
+    spread = page.parent;
+    spreadCount = spread.pages.length;
+    if (spreadCount > 2) {
+      ctx.warn('The new page landed on a spread (Druckbogen) with ' + spreadCount +
+        ' pages – InDesign appends to the existing spread when "allow pages to shuffle" is off. Use move_pages_to_new_spread to repair.');
+    }
+    /*
+     * InDesign gibt der neuen Seite meist die Musterseite der Nachbarseite
+     * (am lebenden Dokument gesehen); nur wenn keine dran ist, warnen.
+     */
+    var parentName = idcAppliedParentName(page);
+    if (parentName === '[None]') {
+      ctx.warn('The new page has no master page (Musterseite); use apply_parent_to_page.');
+    }
+
+    if (view !== null) { viewRestored = view.window === null ? null : idcRestoreView(view); }
+
+    ctx.changes = { created_page_ids: [Number(page.id)] };
+    return {
+      page_id: Number(page.id),
+      index: Number(page.documentOffset),
+      name: String(page.name),
+      parent: parentName,
+      side: idcPageSide(page),
+      spread_index: IDC.spreadIndex(spread),
+      spread_page_count: spreadCount,
+      page_count: doc.pages.length,
+      view_restored: viewRestored
+    };
+  });
+
+/* ----------------------------------------------------------- delete_page */
+
+/* Ist der Rahmen mit einem anderen verkettet? NothingEnum hat kein isValid. */
+function idcIsThreaded(frame) {
+  var next = null;
+  var prev = null;
+  try { next = frame.nextTextFrame; } catch (e1) { next = null; }
+  try { prev = frame.previousTextFrame; } catch (e2) { prev = null; }
+  function real(ref) {
+    try { return ref !== null && ref !== undefined && ref.isValid === true; } catch (e) { return false; }
+  }
+  return real(next) || real(prev);
+}
+
+/* Beurteilt ein Objekt fuer delete_page: blockiert es, und warum. */
+function idcAssessItem(item, out) {
+  var type = idcItemType(item);
+  var entry = { id: null, type: type, blocking: false, reason: '', text_snippet: null };
+  var i, child, childEntry, text;
+
+  try { entry.id = Number(item.id); } catch (e0) { entry.id = null; }
+
+  if (type === 'text') {
+    text = '';
+    try { text = String(item.contents); } catch (e1) { text = ''; }
+    entry.text_snippet = text.length > 80 ? text.substr(0, 80) : text;
+    if (idcIsThreaded(item)) {
+      entry.blocking = true;
+      entry.reason = 'threaded text frame (verketteter Rahmen)';
+    } else if (text.length > 0) {
+      entry.blocking = true;
+      entry.reason = 'text frame with content';
+    } else {
+      entry.reason = 'empty text frame';
+    }
+  } else if (type === 'image') {
+    entry.blocking = true;
+    entry.reason = 'frame with a placed graphic';
+  } else if (type === 'rectangle' || type === 'ellipse' || type === 'polygon') {
+    entry.reason = 'empty frame';
+  } else if (type === 'line') {
+    entry.reason = 'line';
+  } else if (type === 'group') {
+    entry.reason = 'group';
+    try {
+      for (i = 0; i < item.pageItems.length; i++) {
+        child = IDC.concrete(item.pageItems.item(i));
+        childEntry = idcAssessItem(child, out);
+        if (childEntry.blocking) {
+          entry.blocking = true;
+          entry.reason = 'group with content';
+        }
+      }
+    } catch (e2) { /* Gruppe ohne lesbare Kinder */ }
+  } else {
+    entry.reason = 'other object (' + idcClassName(item) + ')';
+  }
+  out.push(entry);
+  return entry;
+}
+
+/*
+ * Sitzung 24 (Befund aus dem Praxiseinsatz, E-79): Objekte auf der Montageflaeche
+ * gehoeren zum Bogen, nicht zur Seite. Verschwindet mit der Seite ein Bogen,
+ * sind sie weg, ohne dass delete_page sie bisher erwaehnte. Vorhergesagt
+ * wird nur der Fall, dass die Seite die einzige ihres Bogens ist. Die
+ * fruehere Annahme (b) – bei Doppelseiten mit "Seiten neu anordnen" gehe der
+ * leere letzte Bogen samt Montageflaeche – ist am lebenden InDesign
+ * widerlegt (Nacharbeit Sitzung 24, E-80): das Objekt blieb erhalten. Nach
+ * dem Loeschen vergleicht der Handler alle Montageflaechen-Objekte des
+ * Dokuments: verloren (pasteboard_lost_ids) oder auf einen anderen Bogen
+ * bzw. eine andere Lage gewandert (pasteboard_relocated).
+ */
+function idcPasteboardEntry(doc, item) {
+  var entry = { frame_id: null, type: idcItemType(item), spread_index: null, bounds_mm: null, link_name: null, link_path: null, text_snippet: null };
+  var graphics, link, spread;
+  try { entry.frame_id = Number(item.id); } catch (e0) { entry.frame_id = null; }
+  spread = IDC.spreadOfItem(item);
+  if (spread !== null) { entry.spread_index = IDC.spreadIndex(spread); }
+  try { entry.bounds_mm = IDC.boundsOnPage(doc, item, null); } catch (e1) { entry.bounds_mm = null; }
+  try {
+    graphics = idcGraphicsOf(item);
+    if (graphics.length > 0) {
+      link = idcLinkOf(graphics[0]);
+      if (link !== null) {
+        try { entry.link_name = String(link.name); } catch (e2) { entry.link_name = null; }
+        try { entry.link_path = String(link.filePath); } catch (e3) { entry.link_path = null; }
+      }
+    }
+  } catch (e4) { /* keine Grafik */ }
+  if (entry.type === 'text') {
+    entry.text_snippet = idcTextSnippet(item);
+    if (entry.text_snippet.length > 80) { entry.text_snippet = entry.text_snippet.substr(0, 80); }
+  }
+  return entry;
+}
+
+/* Objekte auf der Montageflaeche eines Bogens (oberste Ebene, keine Gruppenmitglieder). */
+function idcPasteboardItemsOf(spread) {
+  var out = [];
+  var i, item;
+  for (i = 0; i < spread.pageItems.length; i++) {
+    item = IDC.concrete(spread.pageItems.item(i));
+    if (IDC.landing(item).on_pasteboard) { out.push(item); }
+  }
+  return out;
+}
+
+/* Boegen, die mit der Seite verschwinden (siehe oben): nur der eigene, wenn die Seite seine einzige ist. */
+function idcSpreadsAtRisk(doc, page) {
+  var out = [];
+  var own = page.parent;
+  if (own.pages.length === 1) { out.push(own); }
+  return out;
+}
+
+/* Seiten eines Bogens: IDs (Vergleich; Namen werden beim Loeschen neu gezaehlt) und Namen (Meldung). */
+function idcSpreadPages(spread) {
+  var out = { ids: [], names: [] };
+  var i, page;
+  if (spread === null) { return out; }
+  for (i = 0; i < spread.pages.length; i++) {
+    page = spread.pages.item(i);
+    out.ids.push(Number(page.id));
+    out.names.push(String(page.name));
+  }
+  return out;
+}
+
+/* Alle Montageflaechen-Objekte des Dokuments mit Bogen und Lage (vor dem Loeschen). */
+function idcPasteboardSnapshot(doc) {
+  var out = [];
+  var i, j, spread, items, bounds;
+  for (i = 0; i < doc.spreads.length; i++) {
+    spread = doc.spreads.item(i);
+    items = idcPasteboardItemsOf(spread);
+    for (j = 0; j < items.length; j++) {
+      try { bounds = IDC.boundsOnPage(doc, items[j], null); } catch (e0) { bounds = null; }
+      out.push({ id: Number(items[j].id), spread_index: IDC.spreadIndex(spread), pages: idcSpreadPages(spread), bounds: bounds });
+    }
+  }
+  return out;
+}
+
+function idcSameBounds(a, b) {
+  if (a === null || b === null) { return a === b; }
+  return Math.abs(a.x - b.x) < 0.01 && Math.abs(a.y - b.y) < 0.01 && Math.abs(a.width - b.width) < 0.01 && Math.abs(a.height - b.height) < 0.01;
+}
+
+/* on_pasteboard_items: warn (Vorgabe) | abort | move. */
+function idcPasteboardModeArg(args) {
+  var mode = args.on_pasteboard_items;
+  if (mode === undefined || mode === null) { return 'warn'; }
+  if (mode !== 'warn' && mode !== 'abort' && mode !== 'move') {
+    IDC.fail('invalid_argument', 'on_pasteboard_items must be "warn", "abort" or "move".', { on_pasteboard_items: mode });
+  }
+  return mode;
+}
+
+/*
+ * Objekt auf die Montageflaeche des Bogens von target bringen: gleiche Lage
+ * zum Bogen; was rechts neben dem alten Bogen lag, liegt rechts neben dem
+ * neuen (gleicher Abstand zur rechten Seitenkante).
+ */
+function idcMoveToPasteboardOf(ctx, doc, item, target) {
+  var before = IDC.boundsOnPage(doc, item, null);
+  var sourceWidth = 0, targetWidth, spread, i, x, current, moved;
+  spread = IDC.spreadOfItem(item);
+  for (i = 0; i < spread.pages.length; i++) { sourceWidth += IDC.pageSize(spread.pages.item(i)).width; }
+  targetWidth = idcSpreadWidthOfPage(target);
+  x = before.x;
+  if (before.x >= sourceWidth) { x = targetWidth + (before.x - sourceWidth); }
+  moved = item.move(target);
+  if (IDC.isArray(moved)) { moved = moved[0]; }
+  if (moved !== undefined && moved !== null) { item = IDC.concrete(moved); }
+  /* Unter Bogen-Nullpunkt gelesen: Bogenkoordinaten, gleich ob auf einer Seite oder daneben. */
+  current = IDC.boundsOnPage(doc, item, null);
+  idcMoveBy(doc, item, x - current.x, before.y - current.y);
+  if (!IDC.landing(item).on_pasteboard) {
+    ctx.warn('Object ' + Number(item.id) + ' was moved to the spread of page ' + String(target.name) + ', but lands on page ' +
+      IDC.landing(item).page_name + ' there – move it with move_frame_to_page (pasteboard).');
+  }
+  return Number(item.id);
+}
+
+IDC.register('delete_page', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var page, summary, blocking, i, j, item, formerIndex, name, pageId, boilerplate, removedFrameIds;
+    var pasteboardMode, atRisk, riskItems, pasteboardEntries, target, movedIds, lostIds, allBefore, riskText, onSpread;
+    var relocated, still, stillSpread, stillPages, stillBounds, entryText, lostEntry;
+
+    page = idcDocumentPageById(doc, args.page_id, 'page_id');
+    if (doc.pages.length <= 1) {
+      IDC.fail('invalid_state', 'The only page of a document cannot be deleted.', { page_id: args.page_id });
+    }
+    pasteboardMode = idcPasteboardModeArg(args);
+    target = null;
+    if (pasteboardMode === 'move') {
+      if (args.pasteboard_target_page_id === undefined || args.pasteboard_target_page_id === null) {
+        IDC.fail('invalid_argument', 'on_pasteboard_items "move" needs pasteboard_target_page_id (a page whose spread receives the objects).', null);
+      }
+      target = idcDocumentPageById(doc, args.pasteboard_target_page_id, 'pasteboard_target_page_id');
+      if (Number(target.id) === Number(page.id)) {
+        IDC.fail('invalid_argument', 'pasteboard_target_page_id must be another page than the one deleted.', { pasteboard_target_page_id: args.pasteboard_target_page_id });
+      }
+    }
+
+    summary = [];
+    blocking = [];
+    for (i = 0; i < page.pageItems.length; i++) {
+      item = IDC.concrete(page.pageItems.item(i));
+      idcAssessItem(item, summary);
+    }
+    for (i = 0; i < summary.length; i++) {
+      if (summary[i].blocking) { blocking.push(summary[i]); }
+    }
+    boilerplate = 0;
+    try { boilerplate = page.masterPageItems.length; } catch (e1) { boilerplate = 0; }
+
+    if (blocking.length > 0 && args.force !== true) {
+      IDC.fail('invalid_state',
+        'Page ' + String(page.name) + ' holds ' + blocking.length +
+        ' object(s) with content (text, images or threaded frames). Nothing was deleted. Pass force: true to delete anyway – there is no undo.',
+        { page_id: Number(page.id), blocking_items: blocking, item_summary: summary, boilerplate_ignored: boilerplate });
+    }
+
+    /* Montageflaeche: gefaehrdete Boegen und ihre Objekte, vor jeder Aenderung. */
+    atRisk = idcSpreadsAtRisk(doc, page);
+    riskItems = [];
+    pasteboardEntries = [];
+    for (i = 0; i < atRisk.length; i++) {
+      onSpread = idcPasteboardItemsOf(atRisk[i]);
+      for (j = 0; j < onSpread.length; j++) {
+        riskItems.push(onSpread[j]);
+        pasteboardEntries.push(idcPasteboardEntry(doc, onSpread[j]));
+      }
+    }
+    if (target !== null) {
+      for (i = 0; i < atRisk.length; i++) {
+        if (IDC.spreadIndex(atRisk[i]) === IDC.spreadIndex(target.parent)) {
+          IDC.fail('invalid_argument', 'pasteboard_target_page_id lies on a spread that disappears with this page; choose a page on another spread.',
+            { pasteboard_target_page_id: Number(target.id), spread_index: IDC.spreadIndex(target.parent) });
+        }
+      }
+    }
+    if (riskItems.length > 0 && pasteboardMode === 'abort') {
+      IDC.fail('invalid_state',
+        'Deleting page ' + String(page.name) + ' removes a spread (Druckbogen) with ' + riskItems.length +
+        ' object(s) on its pasteboard (Montageflaeche). Nothing was deleted. Move them first (move_frame_to_page) or pass on_pasteboard_items "move" with pasteboard_target_page_id.',
+        { code: 'pasteboard_items_present', page_id: Number(page.id), pasteboard_items: pasteboardEntries });
+    }
+
+    pageId = Number(page.id);
+    name = String(page.name);
+    formerIndex = Number(page.documentOffset);
+    removedFrameIds = [];
+    for (i = 0; i < summary.length; i++) {
+      if (summary[i].id !== null) { removedFrameIds.push(summary[i].id); }
+    }
+
+    movedIds = [];
+    if (riskItems.length > 0 && pasteboardMode === 'move') {
+      for (i = 0; i < riskItems.length; i++) {
+        try {
+          movedIds.push(idcMoveToPasteboardOf(ctx, doc, riskItems[i], target));
+        } catch (eM) {
+          IDC.fail('script_error', 'InDesign could not move pasteboard object ' + pasteboardEntries[i].frame_id + ' to the spread of page ' +
+            String(target.name) + ': ' + String(eM.message ? eM.message : eM) + '. The page was not deleted.',
+            { page_id: pageId, moved_frame_ids: movedIds, pasteboard_items: pasteboardEntries });
+        }
+      }
+    }
+    allBefore = idcPasteboardSnapshot(doc);
+
+    try {
+      page.remove();
+    } catch (e2) {
+      IDC.fail('script_error', 'InDesign could not delete the page: ' + String(e2.message ? e2.message : e2),
+        { page_id: pageId });
+    }
+
+    /* Nach dem Loeschen: was ist verloren, was liegt jetzt an einem anderen Bogen oder anders? */
+    lostIds = [];
+    relocated = [];
+    for (i = 0; i < allBefore.length; i++) {
+      still = IDC.itemById(doc, allBefore[i].id, 'document');
+      if (still === null) { lostIds.push(allBefore[i].id); continue; }
+      still = still.item;
+      stillSpread = IDC.spreadOfItem(still);
+      stillPages = idcSpreadPages(stillSpread);
+      try { stillBounds = IDC.boundsOnPage(doc, still, null); } catch (e3) { stillBounds = null; }
+      if (stillPages.ids.join(',') !== allBefore[i].pages.ids.join(',') || !idcSameBounds(stillBounds, allBefore[i].bounds)) {
+        relocated.push({
+          frame_id: allBefore[i].id,
+          spread_page_ids_before: allBefore[i].pages.ids,
+          spread_page_ids: stillPages.ids,
+          spread_page_names_before: allBefore[i].pages.names,
+          spread_page_names: stillPages.names,
+          spread_index: stillSpread === null ? null : IDC.spreadIndex(stillSpread),
+          bounds_mm_before: allBefore[i].bounds,
+          bounds_mm: stillBounds,
+          on_pasteboard: IDC.landing(still).on_pasteboard === true
+        });
+      }
+    }
+    if (lostIds.length > 0) {
+      riskText = [];
+      for (i = 0; i < lostIds.length; i++) {
+        removedFrameIds.push(lostIds[i]);
+        entryText = String(lostIds[i]);
+        for (j = 0; j < pasteboardEntries.length; j++) {
+          lostEntry = pasteboardEntries[j];
+          if (lostEntry.frame_id === lostIds[i]) {
+            entryText += ' (' + lostEntry.type + (lostEntry.link_name !== null ? ', ' + lostEntry.link_name : '') + ')';
+          }
+        }
+        riskText.push(entryText);
+      }
+      ctx.warn('A spread (Druckbogen) went with page ' + name + '; ' + lostIds.length + ' object(s) on its pasteboard (Montageflaeche) were deleted: ' +
+        riskText.join(', ') + '. See pasteboard_items and pasteboard_lost_ids; on_pasteboard_items "abort" or "move" prevents this.');
+    }
+    if (relocated.length > 0) {
+      riskText = [];
+      for (i = 0; i < relocated.length; i++) {
+        riskText.push(relocated[i].frame_id + ' now beside [' + relocated[i].spread_page_names.join(' ') + ']' +
+          (relocated[i].spread_page_ids_before.join(',') !== relocated[i].spread_page_ids.join(',') ? ' (was [' + relocated[i].spread_page_names_before.join(' ') + '] before deleting)' : ' (position changed)'));
+      }
+      ctx.warn('InDesign regrouped the spreads; ' + relocated.length + ' pasteboard object(s) (Montageflaeche) now lie elsewhere: ' + riskText.join(', ') + '. See pasteboard_relocated.');
+    }
+
+    if (boilerplate > 0) {
+      ctx.warn(boilerplate + ' master page object(s) (Musterseitenobjekte) were on the page; they belong to the master and were not counted.');
+    }
+    if (blocking.length > 0) {
+      ctx.warn('Deleted with force: ' + blocking.length + ' object(s) with content are gone.');
+    }
+
+    ctx.changes = movedIds.length > 0
+      ? { removed_page_ids: [pageId], removed_frame_ids: removedFrameIds, modified_frame_ids: movedIds }
+      : { removed_page_ids: [pageId], removed_frame_ids: removedFrameIds };
+    return {
+      page_id: pageId,
+      name: name,
+      former_index: formerIndex,
+      items_deleted: summary.length,
+      boilerplate_ignored: boilerplate,
+      item_summary: summary,
+      page_count: doc.pages.length,
+      on_pasteboard_items: pasteboardMode,
+      pasteboard_items: pasteboardEntries,
+      pasteboard_moved_ids: movedIds,
+      pasteboard_lost_ids: lostIds,
+      pasteboard_relocated: relocated
+    };
+  });
+
+/* ------------------------------------------------------------ move_pages */
+
+/* Seitenliste pruefen: IDs vorhanden, Dokumentseiten, direkte Nachbarn; sortiert nach Position. */
+function idcAdjacentPages(doc, ids, field, minCount, maxCount) {
+  var pages = [];
+  var i, j, tmp, seen = {};
+
+  if (!IDC.isArray(ids) || ids.length < minCount || ids.length > maxCount) {
+    IDC.fail('invalid_argument', field + ' must be an array of ' + minCount + ' to ' + maxCount + ' page ids.',
+      { count: IDC.isArray(ids) ? ids.length : null });
+  }
+  for (i = 0; i < ids.length; i++) {
+    if (seen[String(ids[i])]) {
+      IDC.fail('invalid_argument', field + ' names page ' + ids[i] + ' twice.', { page_id: ids[i] });
+    }
+    seen[String(ids[i])] = true;
+    pages.push(idcDocumentPageById(doc, ids[i], field));
+  }
+  /* nach documentOffset sortieren (Einfuegesortierung, ES3-sicher) */
+  for (i = 1; i < pages.length; i++) {
+    tmp = pages[i];
+    j = i - 1;
+    while (j >= 0 && Number(pages[j].documentOffset) > Number(tmp.documentOffset)) {
+      pages[j + 1] = pages[j];
+      j -= 1;
+    }
+    pages[j + 1] = tmp;
+  }
+  for (i = 1; i < pages.length; i++) {
+    if (Number(pages[i].documentOffset) !== Number(pages[i - 1].documentOffset) + 1) {
+      IDC.fail('invalid_argument', field + ' must be direct neighbours in the page order (' +
+        String(pages[i - 1].name) + ' and ' + String(pages[i].name) + ' are not).',
+        { page_ids: ids });
+    }
+  }
+  return pages;
+}
+
+function idcSnapshotSides(doc) {
+  var out = {};
+  var i, page;
+  for (i = 0; i < doc.pages.length; i++) {
+    page = doc.pages.item(i);
+    out[String(Number(page.id))] = idcPageSide(page);
+  }
+  return out;
+}
+
+function idcDescribeAllPages(doc) {
+  var out = [];
+  var i;
+  for (i = 0; i < doc.pages.length; i++) {
+    out.push(idcDescribePage(doc.pages.item(i)));
+  }
+  return out;
+}
+
+/*
+ * Sitzung 24 (Befund aus dem Praxiseinsatz, E-79/E-80): InDesign haelt hoechstens
+ * zehn Seiten auf einem Bogen. Ohne "Seiten neu anordnen" (oder mit einem
+ * Zielbogen, der selbst nicht neu angeordnet wird) landen die verschobenen
+ * Seiten auf dem Bogen der Bezugsseite – vorher pruefen, damit InDesign nicht
+ * mitten im Verschieben abbricht.
+ */
+var IDC_SPREAD_PAGE_LIMIT = 10;
+
+function idcPredictTargetSpreadCount(doc, pages, ref, shuffleArg) {
+  var target = ref.parent;
+  var shuffle, island = false, joining = 0, i;
+  if (shuffleArg === true || shuffleArg === false) { shuffle = shuffleArg; }
+  else {
+    try { shuffle = doc.documentPreferences.allowPageShuffle === true; } catch (e0) { shuffle = true; }
+  }
+  try { island = target.allowPageShuffle === false; } catch (e1) { island = false; }
+  if (shuffle && !island) { return null; }
+  for (i = 0; i < pages.length; i++) {
+    if (IDC.spreadIndex(pages[i].parent) !== IDC.spreadIndex(target)) { joining += 1; }
+  }
+  return { spread_index: IDC.spreadIndex(target), count: target.pages.length + joining };
+}
+
+/* Bogenaufteilung als Text: [1] [2 3] [4 5 6] … (Seitennamen). */
+function idcSpreadDivisionText(doc) {
+  var parts = [];
+  var i, j, spread, names;
+  for (i = 0; i < doc.spreads.length; i++) {
+    spread = doc.spreads.item(i);
+    names = [];
+    for (j = 0; j < spread.pages.length; j++) { names.push(String(spread.pages.item(j).name)); }
+    parts.push('[' + names.join(' ') + ']');
+  }
+  return parts.join(' ');
+}
+
+/*
+ * keep_spreads: die Boegen zwischen alter und neuer Stelle wieder als Paare
+ * bilden – bei Doppelseiten linke und rechte Seite zusammen, beginnend wie
+ * die erste Seite des Dokuments (rechts: erste Seite allein), sonst eine
+ * Seite je Bogen. Gruppen, die schon genau einen Bogen bilden und deren
+ * Seiten links/rechts richtig stehen, bleiben; fuer die anderen entsteht ein
+ * neuer Bogen vor dem Bogen ihrer ersten Seite (ohne Neuanordnen).
+ *
+ * Nacharbeit 2 zu Sitzung 24 (Lauf S24 am 22.09.2026): ein Bogen ohne
+ * Neuanordnen behaelt seinen Bund. Der neue Bogen kommt mit zwei
+ * Platzhaltern (links | rechts); wer mit AT_END angehaengt wird, liegt
+ * rechts vom Bund, und nach dem Entfernen der Platzhalter standen alle
+ * Seiten auf RIGHT_HAND. Darum: die linke Seite der Gruppe an den Anfang
+ * (vor den linken Platzhalter), die rechte an das Ende, dann genau die
+ * Platzhalter entfernen. Danach wird jede Seite gegen die erwartete Seite
+ * geprueft (idcExpectedSide); Abweichungen meldet der Aufrufer als Warnung.
+ * Liefert { created, mismatched: [Seitennamen], failures: [Meldungen] }.
+ */
+function idcExpectedSide(offset, facing, firstRight) {
+  if (!facing) { return 'SINGLE_SIDED'; }
+  if ((offset % 2 === 0) === firstRight) { return 'RIGHT_HAND'; }
+  return 'LEFT_HAND';
+}
+
+/*
+ * Nacharbeit 3 zu Sitzung 24 (Lauf S24 am 22.09.2026): ein Seitenverweis
+ * gilt in InDesign nur, solange die Seite auf dem Bogen liegt, auf dem er
+ * geholt wurde; nach move/spreads.add/remove auf einem anderen Bogen
+ * scheitert jeder Zugriff („Objekt existiert nicht mehr“, Zeile 3464 im
+ * Buendel: Name ueber einen alten Verweis gelesen). Darum wird jede Seite
+ * unmittelbar vor ihrer Verwendung per id neu geholt (idcFreshPage), die
+ * Platzhalter aller neuen Boegen werden erst am Ende entfernt, und ein
+ * Scheitern bei einer Gruppe haelt die uebrigen nicht auf.
+ */
+function idcFreshPage(doc, id) {
+  var found = IDC.pageById(doc, id);
+  if (found === null || found.is_parent_page) { return null; }
+  return found.page;
+}
+
+function idcRebuildSpreadPairs(doc, lo, hi, firstRight) {
+  var facing = false, groups = [], current = null, currentKey = null;
+  var i, j, g, spread, page, offset, key, created = 0, mismatched = [], failures = [], placeholderIds = [];
+  try { facing = doc.documentPreferences.facingPages === true; } catch (e0) { facing = false; }
+  for (i = lo; i <= hi; i++) {
+    spread = doc.spreads.item(i);
+    for (j = 0; j < spread.pages.length; j++) {
+      page = spread.pages.item(j);
+      offset = Number(page.documentOffset);
+      if (!facing) { key = offset; }
+      else if (firstRight) { key = Math.floor((offset + 1) / 2); }
+      else { key = Math.floor(offset / 2); }
+      if (current === null || key !== currentKey) {
+        current = [];
+        currentKey = key;
+        groups.push(current);
+      }
+      current.push({ id: Number(page.id), side: idcExpectedSide(offset, facing, firstRight) });
+    }
+  }
+  IDC.withShuffle(doc, false, function () {
+    var k, entry, first, whole, newSpread, newSpreadId, moved, target;
+    for (g = 0; g < groups.length; g++) {
+      try {
+        first = idcFreshPage(doc, groups[g][0].id);
+        if (first === null) { throw new Error('page ' + groups[g][0].id + ' not found'); }
+        spread = first.parent;
+        whole = spread.pages.length === groups[g].length;
+        for (k = 0; whole && k < groups[g].length; k++) {
+          page = spread.pages.item(k);
+          if (Number(page.id) !== groups[g][k].id) { whole = false; }
+          else if (idcPageSide(page) !== groups[g][k].side) { whole = false; }
+        }
+        if (whole) { continue; }
+        newSpread = doc.spreads.add(LocationOptions.BEFORE, spread);
+        newSpread.allowPageShuffle = false;
+        newSpreadId = Number(newSpread.id);
+        for (k = 0; k < newSpread.pages.length; k++) { placeholderIds.push(Number(newSpread.pages.item(k).id)); }
+        /* linke Seiten rueckwaerts an den Anfang (Reihenfolge bleibt), rechte der Reihe nach an das Ende */
+        moved = [];
+        for (k = groups[g].length - 1; k >= 0; k--) {
+          entry = groups[g][k];
+          if (entry.side === 'LEFT_HAND') { moved.push({ entry: entry, at: LocationOptions.AT_BEGINNING }); }
+        }
+        for (k = 0; k < groups[g].length; k++) {
+          entry = groups[g][k];
+          if (entry.side !== 'LEFT_HAND') { moved.push({ entry: entry, at: LocationOptions.AT_END }); }
+        }
+        for (k = 0; k < moved.length; k++) {
+          page = idcFreshPage(doc, moved[k].entry.id);
+          target = doc.spreads.itemByID(newSpreadId);
+          if (page === null) { throw new Error('page ' + moved[k].entry.id + ' not found'); }
+          page.move(moved[k].at, target);
+        }
+        created += 1;
+      } catch (eG) {
+        failures.push(String(eG.message ? eG.message : eG));
+      }
+    }
+    /* Platzhalter erst jetzt entfernen – jeden einzeln neu geholt */
+    for (k = 0; k < placeholderIds.length; k++) {
+      try {
+        page = idcFreshPage(doc, placeholderIds[k]);
+        if (page !== null) { page.remove(); }
+      } catch (eP) {
+        failures.push(String(eP.message ? eP.message : eP));
+      }
+    }
+  });
+  for (g = 0; g < groups.length; g++) {
+    for (i = 0; i < groups[g].length; i++) {
+      page = idcFreshPage(doc, groups[g][i].id);
+      if (page !== null && idcPageSide(page) !== groups[g][i].side) {
+        mismatched.push(String(page.name) + ' (' + idcPageSide(page) + ', expected ' + groups[g][i].side + ')');
+      }
+    }
+  }
+  return { created: created, mismatched: mismatched, failures: failures };
+}
+
+IDC.register('move_pages', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var pages, ref, position, i, movedIds, namesBefore, namesAfter, sidesBefore, sidesAfter, flipped, counts, key, page;
+    var keepSpreads, predicted, neighbourIds, firstRight, touched, lo, hi, found, rebuilt, rebuiltInfo, overfull, refId, index;
+
+    pages = idcAdjacentPages(doc, args.page_ids, 'page_ids', 1, 48);
+    ref = idcDocumentPageById(doc, args.reference_page_id, 'reference_page_id');
+    for (i = 0; i < pages.length; i++) {
+      if (Number(pages[i].id) === Number(ref.id)) {
+        IDC.fail('invalid_argument', 'reference_page_id must lie outside the pages being moved.',
+          { reference_page_id: args.reference_page_id });
+      }
+    }
+    position = args.position;
+    if (position !== 'before' && position !== 'after') {
+      IDC.fail('invalid_argument', 'position must be "before" or "after".', { position: position });
+    }
+    if (args.keep_spreads !== undefined && args.keep_spreads !== null && typeof args.keep_spreads !== 'boolean') {
+      IDC.fail('invalid_argument', 'keep_spreads must be true or false.', { keep_spreads: args.keep_spreads });
+    }
+    keepSpreads = args.keep_spreads === true;
+
+    /* 10-Seiten-Grenze je Bogen vor dem Verschieben (E-80). */
+    predicted = idcPredictTargetSpreadCount(doc, pages, ref, args.allow_page_shuffle);
+    if (predicted !== null && predicted.count > IDC_SPREAD_PAGE_LIMIT) {
+      IDC.fail('invalid_state',
+        'Moving ' + pages.length + ' page(s) next to page ' + String(ref.name) + ' would put ' + predicted.count +
+        ' pages on one spread (Druckbogen); InDesign allows at most ' + IDC_SPREAD_PAGE_LIMIT + '. Nothing was moved. Move fewer pages at once, or pass allow_page_shuffle true.',
+        { code: 'spread_page_limit', spread_index: predicted.spread_index, predicted_page_count: predicted.count, limit: IDC_SPREAD_PAGE_LIMIT });
+    }
+
+    /* Fuer keep_spreads: Nachbarn des Blocks und Seite der ersten Dokumentseite vor dem Verschieben. */
+    neighbourIds = [Number(ref.id)];
+    if (Number(pages[0].documentOffset) > 0) { neighbourIds.push(Number(doc.pages.item(Number(pages[0].documentOffset) - 1).id)); }
+    if (Number(pages[pages.length - 1].documentOffset) < doc.pages.length - 1) {
+      neighbourIds.push(Number(doc.pages.item(Number(pages[pages.length - 1].documentOffset) + 1).id));
+    }
+    firstRight = idcPageSide(doc.pages.item(0)) !== 'LEFT_HAND';
+
+    movedIds = [];
+    namesBefore = [];
+    for (i = 0; i < pages.length; i++) {
+      movedIds.push(Number(pages[i].id));
+      namesBefore.push(String(pages[i].name));
+    }
+    sidesBefore = idcSnapshotSides(doc);
+
+    /* Verweise vor jedem Schritt per id neu holen (Nacharbeit 3 zu Sitzung 24, idcFreshPage). */
+    refId = Number(ref.id);
+    IDC.withShuffle(doc, args.allow_page_shuffle, function () {
+      var k;
+      try {
+        if (position === 'after') {
+          /* rueckwaerts: jede Seite direkt hinter die Referenz, Reihenfolge bleibt */
+          for (k = movedIds.length - 1; k >= 0; k--) { idcFreshPage(doc, movedIds[k]).move(LocationOptions.AFTER, idcFreshPage(doc, refId)); }
+        } else {
+          for (k = 0; k < movedIds.length; k++) { idcFreshPage(doc, movedIds[k]).move(LocationOptions.BEFORE, idcFreshPage(doc, refId)); }
+        }
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not move the pages: ' + String(e.message ? e.message : e),
+          { page_ids: movedIds });
+      }
+    });
+
+    rebuilt = 0;
+    if (keepSpreads) {
+      try {
+        touched = [];
+        for (i = 0; i < movedIds.length; i++) { touched.push(movedIds[i]); }
+        for (i = 0; i < neighbourIds.length; i++) { touched.push(neighbourIds[i]); }
+        lo = null;
+        hi = null;
+        for (i = 0; i < touched.length; i++) {
+          found = idcFreshPage(doc, touched[i]);
+          index = found === null ? null : IDC.spreadIndex(found.parent);
+          if (index === null) { continue; }
+          if (lo === null || index < lo) { lo = index; }
+          if (hi === null || index > hi) { hi = index; }
+        }
+        if (lo === null) { throw new Error('the moved pages were not found'); }
+        rebuiltInfo = idcRebuildSpreadPairs(doc, lo, hi, firstRight);
+        rebuilt = rebuiltInfo.created;
+        if (rebuiltInfo.failures.length > 0) {
+          ctx.warn('The pages were moved, but ' + rebuiltInfo.failures.length + ' step(s) of rebuilding the spreads as pairs failed: ' +
+            rebuiltInfo.failures.join('; ') + ' – repair with move_pages_to_new_spread.');
+        }
+        if (rebuiltInfo.mismatched.length > 0) {
+          ctx.warn('The spreads were rebuilt as pairs, but ' + rebuiltInfo.mismatched.length +
+            ' page(s) are not on the expected side (left/right): ' + rebuiltInfo.mismatched.join(', ') +
+            '. Check the spreads in InDesign.');
+        }
+      } catch (eR) {
+        ctx.warn('The pages were moved, but the spreads could not be rebuilt as pairs: ' + String(eR.message ? eR.message : eR) +
+          ' – repair with move_pages_to_new_spread.');
+      }
+    }
+
+    namesAfter = [];
+    for (i = 0; i < movedIds.length; i++) {
+      page = idcFreshPage(doc, movedIds[i]);
+      namesAfter.push(page === null ? '' : String(page.name));
+    }
+
+    sidesAfter = idcSnapshotSides(doc);
+    flipped = [];
+    for (key in sidesAfter) {
+      if (IDC.hasOwn(sidesAfter, key) && IDC.hasOwn(sidesBefore, key) && sidesAfter[key] !== sidesBefore[key]) {
+        page = IDC.pageById(doc, Number(key));
+        flipped.push(page === null ? key : String(page.page.name));
+      }
+    }
+    if (flipped.length > 0) {
+      ctx.warn('Page side changed (left/right swapped) for ' + flipped.length + ' page(s): ' + flipped.join(', ') +
+        '. Moving an odd number of pages flips every page in between.');
+    }
+    counts = IDC.spreadPageCounts(doc);
+    overfull = false;
+    for (i = 0; i < counts.length; i++) {
+      if (counts[i] > 2) {
+        overfull = true;
+        ctx.warn('Spread (Druckbogen) ' + i + ' now holds ' + counts[i] + ' pages.');
+      }
+    }
+    if (overfull) {
+      ctx.warn('New spread division (Bogenaufteilung): ' + idcSpreadDivisionText(doc) +
+        (keepSpreads ? '' : ' – pass keep_spreads true to rebuild the spreads as pairs, or repair with move_pages_to_new_spread.'));
+    }
+
+    ctx.changes = { moved_page_ids: movedIds };
+    return {
+      moved_page_ids: movedIds,
+      names_before: namesBefore,
+      names_after: namesAfter,
+      page_count: doc.pages.length,
+      spread_count: doc.spreads.length,
+      spread_page_counts: counts,
+      pages: idcDescribeAllPages(doc),
+      keep_spreads: keepSpreads,
+      spreads_rebuilt: rebuilt
+    };
+  });
+
+/* ------------------------------------------------ move_pages_to_new_spread */
+
+IDC.register('move_pages_to_new_spread', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var pages, source, sourceIndex, i, movedIds, names, newSpread, placeholder, sourceCountBefore;
+
+    pages = idcAdjacentPages(doc, args.page_ids, 'page_ids', 1, 24);
+    source = pages[0].parent;
+    sourceIndex = IDC.spreadIndex(source);
+    for (i = 1; i < pages.length; i++) {
+      if (IDC.spreadIndex(pages[i].parent) !== sourceIndex) {
+        IDC.fail('invalid_argument', 'All page_ids must lie on the same spread (Druckbogen).',
+          { page_ids: args.page_ids });
+      }
+    }
+    sourceCountBefore = source.pages.length;
+    if (pages.length >= sourceCountBefore) {
+      IDC.fail('invalid_argument',
+        'page_ids names every page of the spread; leave at least one page behind.',
+        { page_ids: args.page_ids, spread_page_count: sourceCountBefore });
+    }
+
+    movedIds = [];
+    names = [];
+    for (i = 0; i < pages.length; i++) {
+      movedIds.push(Number(pages[i].id));
+      names.push(String(pages[i].name));
+    }
+
+    IDC.withShuffle(doc, false, function () {
+      var k;
+      try {
+        /*
+         * Ein neuer Bogen kommt nicht leer: in einem Doppelseiten-Dokument
+         * mit zwei Platzhalterseiten, sonst mit einer (am lebenden InDesign
+         * 21.5 am 04.09.2026 gesehen). Erst die Seiten anhaengen, dann alle
+         * Platzhalter vorn entfernen.
+         */
+        newSpread = doc.spreads.add(LocationOptions.AFTER, source);
+        newSpread.allowPageShuffle = false;
+        placeholder = newSpread.pages.length;
+        for (k = 0; k < pages.length; k++) {
+          pages[k].move(LocationOptions.AT_END, newSpread);
+        }
+        while (placeholder > 0 && newSpread.pages.length > pages.length) {
+          newSpread.pages.item(0).remove();
+          placeholder -= 1;
+        }
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not build the new spread: ' + String(e.message ? e.message : e),
+          { page_ids: movedIds });
+      }
+    });
+
+    ctx.changes = { moved_page_ids: movedIds, created_spread_indexes: [IDC.spreadIndex(newSpread)] };
+    return {
+      moved_page_ids: movedIds,
+      names: names,
+      new_spread_index: IDC.spreadIndex(newSpread),
+      new_spread_page_count: newSpread.pages.length,
+      source_spread_index: sourceIndex,
+      source_spread_page_count: source.pages.length,
+      spread_count: doc.spreads.length,
+      page_count: doc.pages.length
+    };
+  });