layoutbridge-light 0.0.0-stage → 1.0.1

package/indesign/commands/71-outlines.js

@@ -0,0 +1,92 @@
+/*
+ * Auftrag A-8.7 (Sitzung 9) – convert_text_to_outlines: Text eines Rahmens
+ * in Pfade umwandeln (unumkehrbar). Adobe-DOM (Auftrag, geprueft
+ * 05.09.2026): TextFrame.createOutlines(deleteOriginal) -> PageItem
+ * (Gruppe oder einzelnes Polygon; was InDesign bei mehreren Zeilen
+ * liefert: live pruefen, Journal).
+ */
+
+/* Schriften eines Rahmens: {family, style} je verwendeter Schrift (Reihenfolge des Auftretens). */
+function idcFontsInFrame(frame) {
+  var out = [], seen = {}, ranges, i, run, font, key, family = null, style = null;
+  try { ranges = frame.parentStory.textStyleRanges; } catch (e0) { return out; }
+  for (i = 0; i < ranges.length; i++) {
+    try { run = ranges.item(i); } catch (e1) { continue; }
+    try { font = idcReadFontLoose(run); family = font.family; style = font.style; } catch (e2) { family = null; style = null; }
+    if (family === null) { continue; }
+    key = family + '\t' + (style === null ? '' : style);
+    if (IDC.hasOwn(seen, key)) { continue; }
+    seen[key] = 1;
+    out.push({ family: family, style: style });
+  }
+  return out;
+}
+
+IDC.register('convert_text_to_outlines', { needs_document: true, read_only: false, ruler: 'page' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcTextFrameArg(doc, args, 'frame_id');
+    var frame = found.item;
+    var story = idcStoryOf(frame);
+    var deleteOriginal = args.delete_original !== false;
+    var characters = 0, frames = 0, result, concrete, type, memberCount = 0, fonts, landing, tables = 0, sourceId;
+
+    if (args.confirm !== true) {
+      IDC.fail('invalid_argument', 'convert_text_to_outlines is irreversible – pass confirm true to run it.', { frame_id: args.frame_id });
+    }
+    try { characters = Number(story.characters.length); } catch (e0) { characters = 0; }
+    if (characters === 0) {
+      IDC.fail('invalid_state', 'Text frame ' + args.frame_id + ' is empty; there is no text to convert.', { frame_id: args.frame_id });
+    }
+    try { frames = Number(story.textContainers.length); } catch (e1) { frames = 1; }
+    if (frames > 1) {
+      IDC.fail('invalid_state', 'Text frame ' + args.frame_id + ' is threaded (the story runs over ' + frames + ' frames); convert only unthreaded frames.', { frame_id: args.frame_id, frame_count: frames });
+    }
+    if (idcOverflows(frame) === true) {
+      IDC.fail('invalid_state', 'Text frame ' + args.frame_id + ' overflows; overset text would be lost. Enlarge the frame first.', { frame_id: args.frame_id });
+    }
+    try { tables = Number(story.tables.length); } catch (e2) { tables = 0; }
+    if (tables > 0) {
+      ctx.warn('The frame holds ' + tables + ' table(s); InDesign converts only the text, table cells may be dropped or changed – check the result.');
+    }
+    fonts = idcFontsInFrame(frame);
+    sourceId = Number(frame.id);
+
+    try {
+      result = frame.createOutlines(deleteOriginal);
+    } catch (e) {
+      IDC.fail('script_error', 'InDesign could not convert the text of frame ' + args.frame_id + ' to outlines: ' + String(e.message ? e.message : e), { frame_id: args.frame_id });
+    }
+    /* createOutlines liefert ein ExtendScript-Array (Live 05.09.2026), das IDC.isArray nicht erkennt – ueber Klassenname/length pruefen wie bei get_selection. */
+    if (IDC.isArray(result) || IDC.className(result) === 'Array' || (result && typeof result.length === 'number' && result.id === undefined)) {
+      result = result.length > 0 ? result[0] : null;
+    }
+    if (result === null || result === undefined) {
+      IDC.fail('script_error', 'InDesign returned no object after converting the text to outlines.', { frame_id: args.frame_id });
+    }
+    concrete = IDC.concrete(result);
+    type = IDC.itemType(concrete);
+    if (type === 'group') {
+      try { memberCount = Number(concrete.pageItems.length); } catch (e3) { memberCount = null; }
+    } else {
+      memberCount = 1;
+    }
+    landing = IDC.landing(concrete);
+    ctx.warn('The text is now outlines: it can no longer be searched or edited as text, and the fonts ' + (fonts.length > 0 ? '(' + (function () { var n = [], i; for (i = 0; i < fonts.length; i++) { n.push(fonts[i].family + (fonts[i].style ? ' ' + fonts[i].style : '')); } return n.join(', '); })() + ') ' : '') + 'are no longer needed for it.');
+    var changes = { created_frame_ids: [Number(concrete.id)] };
+    if (deleteOriginal) { changes.removed_frame_ids = [sourceId]; }
+    ctx.changes = changes;
+    return {
+      frame_id: Number(concrete.id),
+      type: type,
+      member_count: memberCount,
+      bounds_mm: idcItemBounds(doc, concrete),
+      page_id: landing.page_id,
+      page_name: landing.page_name,
+      source_frame_id: sourceId,
+      source_deleted: deleteOriginal,
+      characters_converted: characters,
+      fonts_used: fonts
+    };
+  });

package/indesign/commands/72-place-text.js

@@ -0,0 +1,476 @@
+/* Wunschliste J2 Nr. 15 (Sitzung 7) – Manuskript einfliessen lassen: place_text_file. */
+
+/* Namen aller Absatzformate (auch in Gruppen) als Nachschlagetabelle. */
+function idcParagraphStyleNames(doc) {
+  var names = {};
+  var all, i;
+  try {
+    all = doc.allParagraphStyles;
+    for (i = 0; i < all.length; i++) { names[String(all[i].name)] = true; }
+  } catch (e) { /* leer */ }
+  return names;
+}
+
+/* Vorgaben eines Einstellungsobjekts merken, setzen und zurueckstellen. */
+function idcWithPreferences(ctx, prefs, values, fn) {
+  var saved = {};
+  var key;
+  if (prefs === null || prefs === undefined) { return fn(); }
+  for (key in values) {
+    if (!IDC.hasOwn(values, key) || values[key] === null || values[key] === undefined) { continue; }
+    try { saved[key] = prefs[key]; } catch (e0) { continue; }
+    try { prefs[key] = values[key]; } catch (e1) { ctx.warn('Could not set import preference ' + key + ': ' + String(e1.message ? e1.message : e1)); }
+  }
+  try {
+    return fn();
+  } finally {
+    for (key in saved) {
+      if (IDC.hasOwn(saved, key)) {
+        try { prefs[key] = saved[key]; } catch (e2) { ctx.warn('Could not restore import preference ' + key + '.'); }
+      }
+    }
+  }
+}
+
+/* A-67 Punkt 2 (Sitzung 72): bis 1.0.3 hoechstens 200 Seiten je Aufruf; ein Roman mit gut 300 Seiten brach ab. */
+var IDC_AUTOFLOW_MAX_PAGES = 2000;
+
+IDC.register('place_text_file', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcTextFrameArg(doc, args, 'frame_id');
+    var frame = found.item;
+    var story = idcStoryOf(frame);
+    var path = args.file_path;
+    var mode = args.mode === undefined || args.mode === null ? 'replace' : args.mode;
+    var retain = args.retain_formatting === true;
+    var styleMap = args.style_map === undefined || args.style_map === null ? null : args.style_map;
+    var styleName = args.paragraph_style === undefined || args.paragraph_style === null ? null : args.paragraph_style;
+    var typographersQuotes = args.typographers_quotes !== false;
+    var pageBreaks = args.page_breaks === undefined || args.page_breaks === null ? 'none' : args.page_breaks;
+    var file, ext, isWord, isText, lengthBefore = 0, lengthAfter = 0, insertAt, namesBefore, namesAfter, added = [];
+    var key, target, targetStyle, targets = {}, mapped = {}, placedRange, paragraphs, i, p, name, count = 0, insertion;
+
+    if (typeof path !== 'string' || path === '') {
+      IDC.fail('invalid_argument', 'file_path is required: a .docx, .doc, .rtf or .txt file on the machine running InDesign.', null);
+    }
+    if (mode !== 'replace' && mode !== 'append') {
+      IDC.fail('invalid_argument', 'mode must be replace (default) or append.', { mode: mode });
+    }
+    if (pageBreaks !== 'none' && pageBreaks !== 'page_break' && pageBreaks !== 'column_break') {
+      IDC.fail('invalid_argument', 'page_breaks must be none (default), page_break or column_break.', { page_breaks: pageBreaks });
+    }
+    var autoflow = args.autoflow === true;
+    var maxPages = idcCountArg(args.max_pages, 'max_pages', 1, IDC_AUTOFLOW_MAX_PAGES, 20);
+    /* Sitzung 10 (Demo-Heft-Befund 1): der Autofluss springt auf die neue Seite; Ansicht merken. */
+    var keepView = idcKeepViewArg(args);
+    var view = null, viewRestored = null;
+    ext = (path.match(/\.([A-Za-z0-9]+)$/) || ['', ''])[1].toLowerCase();
+    isWord = ext === 'docx' || ext === 'doc' || ext === 'rtf';
+    isText = ext === 'txt' || ext === 'text' || ext === 'md';
+    if (!isWord && !isText) {
+      IDC.fail('invalid_argument', 'file_path must end in .docx, .doc, .rtf or .txt (got .' + ext + ').', { file_path: path });
+    }
+    file = IDC.fileFor(path);
+    if (!file.exists) {
+      IDC.fail('not_found', 'File not found: ' + path, { file_path: path });
+    }
+    if (IDC.fileSize(file) === 0) {
+      IDC.fail('io_error', 'File is empty (0 bytes) – a cloud placeholder that is not downloaded yet? ' + path, { file_path: path });
+    }
+    idcRejectStoryLocked(story, Number(frame.id), 'place_text_file');
+    if (styleMap !== null) {
+      if (typeof styleMap !== 'object' || IDC.isArray(styleMap)) {
+        IDC.fail('invalid_argument', 'style_map must be an object { "Word style name": "InDesign style name" }.', null);
+      }
+      for (key in styleMap) {
+        if (!IDC.hasOwn(styleMap, key)) { continue; }
+        target = styleMap[key];
+        if (typeof target !== 'string' || target === '') {
+          IDC.fail('invalid_argument', 'style_map values must be style names.', { key: key, value: target });
+        }
+        targetStyle = IDC.paragraphStyleByName(doc, target);
+        if (targetStyle === null) {
+          IDC.fail('not_found', 'Paragraph style "' + target + '" (target of style_map "' + key + '") does not exist.', { style_name: target });
+        }
+        targets[key] = targetStyle;
+      }
+      retain = true;
+    }
+    if (styleName !== null) {
+      targetStyle = IDC.paragraphStyleByName(doc, styleName);
+      if (targetStyle === null) {
+        IDC.fail('not_found', 'Paragraph style "' + styleName + '" not found.', { style_name: styleName });
+      }
+    }
+
+    try { lengthBefore = Number(story.characters.length); } catch (e0) { lengthBefore = 0; }
+    namesBefore = idcParagraphStyleNames(doc);
+
+    if (mode === 'replace' && lengthBefore > 0) {
+      try { story.contents = ''; } catch (e1) {
+        IDC.fail('script_error', 'Could not clear the story before placing: ' + String(e1.message ? e1.message : e1), { frame_id: args.frame_id });
+      }
+      lengthBefore = 0;
+    }
+    insertAt = lengthBefore;
+
+    var wordValues = {
+      removeFormatting: !retain,
+      preserveLocalOverrides: retain,
+      importUnusedStyles: false,
+      useTypographersQuotes: typographersQuotes,
+      preserveGraphics: false,
+      preserveTrackChanges: false,
+      importFootnotes: true,
+      importEndnotes: true,
+      importIndex: false,
+      importTOC: false
+    };
+    if (typeof ResolveStyleClash !== 'undefined') {
+      wordValues.resolveParagraphStyleClash = ResolveStyleClash.RESOLVE_CLASH_USE_EXISTING;
+      wordValues.resolveCharacterStyleClash = ResolveStyleClash.RESOLVE_CLASH_USE_EXISTING;
+    }
+    /*
+     * A-67 Punkt 5 (Sitzung 72): bis 1.0.3 immer NONE – Seiten- und
+     * Spaltenumbrueche aus Word fielen weg, eine Titelei stand auf einer
+     * Seite. InDesigns eigene Vorgabe ist PAGE_BREAK (Live-Probe 28.10.2026);
+     * page_breaks waehlt, Vorgabe bleibt none (E-79).
+     */
+    if (typeof ConvertPageBreaks !== 'undefined') {
+      wordValues.convertPageBreaks = pageBreaks === 'page_break' ? ConvertPageBreaks.PAGE_BREAK : ConvertPageBreaks.NONE;
+      if (pageBreaks === 'column_break') { wordValues.convertPageBreaks = ConvertPageBreaks.COLUMN_BREAK; }
+    }
+    var textValues = { useTypographersQuotes: typographersQuotes, stripReturnsBetweenLines: false, stripReturnsBetweenParagraphs: false };
+    if (typeof TextImportCharacterSet !== 'undefined') { textValues.characterSet = TextImportCharacterSet.UTF8; }
+
+    var prefs = null;
+    try { prefs = isWord ? app.wordRTFImportPreferences : app.textImportPreferences; } catch (e2) { prefs = null; }
+
+    idcWithPreferences(ctx, prefs, isWord ? wordValues : textValues, function () {
+      try {
+        insertion = story.insertionPoints.item(story.insertionPoints.length - 1);
+        placedRange = insertion.place(file);
+      } catch (e3) {
+        IDC.fail('io_error', 'InDesign could not place ' + path + ': ' + String(e3.message ? e3.message : e3), { file_path: path, frame_id: args.frame_id });
+      }
+    });
+
+    try { lengthAfter = Number(story.characters.length); } catch (e4) { lengthAfter = lengthBefore; }
+    namesAfter = idcParagraphStyleNames(doc);
+    for (name in namesAfter) {
+      if (IDC.hasOwn(namesAfter, name) && !namesBefore[name]) { added.push(name); }
+    }
+
+    /* Absatzformate: erst die Zuordnung Word -> Haus, dann ein Format ueber alles Platzierte. */
+    /*
+     * Ueber story.paragraphs mit Zeichenzaehlung – characters.itemByRange(...)
+     * .paragraphs lieferte am lebenden InDesign 21.5 eine leere Sammlung
+     * (Live-Fund 05.09.2026), deshalb wurde nichts zugeordnet.
+     */
+    try {
+      if (lengthAfter > insertAt) {
+        paragraphs = story.paragraphs;
+        var position = 0, plen;
+        for (i = 0; i < paragraphs.length; i++) {
+          p = paragraphs.item(i);
+          try { plen = Number(p.characters.length); } catch (ep) { plen = 0; }
+          if (position + plen <= insertAt) { position += plen; continue; }
+          position += plen;
+          count += 1;
+          if (styleMap !== null) {
+            name = idcParagraphStyleName(p);
+            if (name !== null && IDC.hasOwn(targets, name)) {
+              p.appliedParagraphStyle = targets[name];
+              mapped[name] = (mapped[name] || 0) + 1;
+            }
+          }
+          if (styleName !== null) { p.appliedParagraphStyle = targetStyle; }
+        }
+      }
+    } catch (e5) {
+      ctx.warn('The text was placed, but the paragraph styles could not be applied: ' + String(e5.message ? e5.message : e5));
+    }
+
+    /*
+     * Zugeordnete Word-Formate wieder entfernen: sie kamen erst mit diesem
+     * Import und sind nach der Zuordnung an keinem Absatz mehr in Gebrauch.
+     * remove(ersatz) haengt eventuelle Reste an das Zielformat.
+     */
+    var removed = [];
+    if (styleMap !== null) {
+      var remaining = [];
+      for (i = 0; i < added.length; i++) {
+        name = added[i];
+        if (IDC.hasOwn(targets, name)) {
+          try {
+            var stray = IDC.paragraphStyleByName(doc, name);
+            if (stray !== null) { stray.remove(targets[name]); removed.push(name); continue; }
+          } catch (e8) { ctx.warn('Imported style "' + name + '" could not be removed: ' + String(e8.message ? e8.message : e8)); }
+        }
+        remaining.push(name);
+      }
+      added = remaining;
+    }
+
+    var overset = null;
+    try {
+      var containers = story.textContainers;
+      overset = containers[containers.length - 1].overflows === true;
+    } catch (e6) { try { overset = story.overflows === true; } catch (e7) { overset = null; } }
+    var flow = null;
+    if (overset === true && autoflow) {
+      if (keepView) { view = idcCaptureView(doc); }
+      flow = idcAutoflow(ctx, doc, story, maxPages);
+      overset = flow.overset;
+      if (view !== null) { viewRestored = view.window === null ? null : idcRestoreView(view); }
+    }
+    if (overset === true) {
+      ctx.warn('The story overflows (Uebersatz) after placing – ' + (autoflow ? 'autoflow stopped at max_pages ' + maxPages + '; raise it or shorten the text.' : 'thread more frames, pass autoflow true, or shorten the text.'));
+    }
+    if (added.length > 0) {
+      ctx.warn('The import added ' + added.length + ' paragraph style(s): ' + added.join(', ') + '.');
+    }
+
+    ctx.changes = { modified_frame_ids: [Number(frame.id)], modified_story_ids: [Number(story.id)] };
+    if (flow !== null && flow.frames_added.length > 0) {
+      ctx.changes.created_frame_ids = [];
+      ctx.changes.created_page_ids = [];
+      for (i = 0; i < flow.frames_added.length; i++) { ctx.changes.created_frame_ids.push(flow.frames_added[i].frame_id); }
+      for (i = 0; i < flow.pages_added.length; i++) { ctx.changes.created_page_ids.push(flow.pages_added[i].page_id); }
+    }
+    return {
+      frame_id: Number(frame.id),
+      story_id: Number(story.id),
+      file_name: String(path).replace(/^.*[\/\\]/, ''),
+      mode: mode,
+      retain_formatting: retain,
+      placed_start_index: insertAt,
+      placed_end_index: lengthAfter,
+      inserted_chars: lengthAfter - insertAt,
+      story_length: lengthAfter,
+      paragraph_count: count,
+      styles_added: added,
+      styles_mapped: mapped,
+      styles_removed: removed,
+      paragraph_style_applied: styleName,
+      page_breaks: isWord ? pageBreaks : null,
+      overset: overset,
+      autoflow: flow,
+      view_restored: viewRestored
+    };
+  });
+
+/*
+ * A-67 Punkt 2 (Sitzung 72): Autofluss fuer eine Story, die schon im
+ * Dokument steht – ohne Datei. Bis 1.0.3 ging das nur ueber eine Datei mit
+ * einem Leerzeichen per place_text_file mode append. Gleiche Seiten, Rahmen
+ * und Rueckgabe autoflow {...} wie place_text_file.
+ */
+IDC.register('autoflow_story', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var found = idcTextFrameArg(doc, args, 'frame_id');
+    var frame = found.item;
+    var story = idcStoryOf(frame);
+    var maxPages = idcCountArg(args.max_pages, 'max_pages', 1, IDC_AUTOFLOW_MAX_PAGES, 20);
+    var keepView = idcKeepViewArg(args);
+    var view = null, viewRestored = null, flow, overset = null, containers, i;
+
+    idcRejectStoryLocked(story, Number(frame.id), 'autoflow_story');
+    try {
+      containers = story.textContainers;
+      overset = containers[containers.length - 1].overflows === true;
+    } catch (e0) { try { overset = story.overflows === true; } catch (e1) { overset = null; } }
+    if (overset !== true) {
+      flow = { pages_added: [], frames_added: [], overset: overset === null ? null : false, stopped: 'fits' };
+    } else {
+      if (keepView) { view = idcCaptureView(doc); }
+      flow = idcAutoflow(ctx, doc, story, maxPages);
+      overset = flow.overset;
+      if (view !== null) { viewRestored = view.window === null ? null : idcRestoreView(view); }
+    }
+    if (overset === true) {
+      ctx.warn('The story still overflows (Uebersatz) – autoflow stopped at max_pages ' + maxPages + '; call again or raise max_pages.');
+    }
+    ctx.changes = { modified_frame_ids: [Number(frame.id)], modified_story_ids: [Number(story.id)] };
+    if (flow.frames_added.length > 0) {
+      ctx.changes.created_frame_ids = [];
+      ctx.changes.created_page_ids = [];
+      for (i = 0; i < flow.frames_added.length; i++) { ctx.changes.created_frame_ids.push(flow.frames_added[i].frame_id); }
+      for (i = 0; i < flow.pages_added.length; i++) { ctx.changes.created_page_ids.push(flow.pages_added[i].page_id); }
+    }
+    return {
+      frame_id: Number(frame.id),
+      story_id: Number(story.id),
+      overset: overset === null ? null : overset === true,
+      autoflow: flow,
+      view_restored: viewRestored
+    };
+  });
+
+/*
+ * Autoflow: solange die Story ueberlaeuft, hinter der Seite des letzten
+ * Rahmens eine Seite (gleiche Musterseite) anlegen, darauf einen Rahmen mit
+ * den Massen und Rahmenoptionen des letzten anlegen und verketten.
+ */
+function idcAutoflow(ctx, doc, story, maxPages) {
+  var out = { pages_added: [], frames_added: [], overset: true, stopped: '' };
+  var round, containers, last = null, page, rect, newPage, newFrame, prefsCopied, copied, placed;
+  for (round = 0; round < maxPages; round++) {
+    /*
+     * Der letzte Rahmen ist ab der zweiten Runde der eben angehaengte –
+     * textContainers waechst mit jeder Seite und wird nur einmal gelesen
+     * (A-67 Punkt 2, bis zu 2000 Seiten je Aufruf).
+     */
+    if (last === null) {
+      try {
+        containers = story.textContainers;
+        last = IDC.concrete(containers[containers.length - 1]);
+      } catch (e0) { out.stopped = 'last frame unreadable'; return out; }
+    }
+    try { if (last.overflows !== true) { out.overset = false; out.stopped = 'fits'; return out; } } catch (e1) { /* weiter */ }
+    page = null;
+    try { page = last.parentPage; } catch (e2) { page = null; }
+    if (page === null || page === undefined || page.isValid !== true) {
+      IDC.fail('invalid_state', 'Autoflow needs the last frame on a document page (it lies on the pasteboard or a parent page).', null);
+    }
+    if (IDC.isOnParentSpread(last)) {
+      IDC.fail('invalid_state', 'Autoflow does not run on parent pages.', null);
+    }
+    rect = IDC.boundsOnPage(doc, last, page);
+    try {
+      newPage = doc.pages.add(LocationOptions.AFTER, page);
+    } catch (e3) {
+      IDC.fail('script_error', 'Autoflow could not add a page: ' + String(e3.message ? e3.message : e3), null);
+    }
+    try {
+      if (page.appliedMaster && page.appliedMaster.isValid === true) { newPage.appliedMaster = page.appliedMaster; }
+    } catch (e4) { /* Vorgabe bleibt */ }
+    placed = idcAutoflowRect(doc, rect, page, newPage);
+    rect = placed.rect;
+    newFrame = idcAddItem(doc, newPage, 'textFrames', idcRectToBounds(rect), 'page');
+    /*
+     * Rahmenoptionen einzeln kopieren (Demo-Heft-Befund 4, 05.09.2026): die
+     * Zuweisung von textFramePreferences.properties liess am lebenden
+     * InDesign die Spalten des Ausgangsrahmens weg (neuer Rahmen einspaltig).
+     */
+    copied = idcCopyTextFramePreferences(last, newFrame);
+    prefsCopied = copied.failed.length === 0;
+    try { newFrame.itemLayer = last.itemLayer; } catch (e6) { /* aktive Ebene */ }
+    try {
+      last.nextTextFrame = newFrame;
+    } catch (e7) {
+      IDC.fail('script_error', 'Autoflow could not thread the new frame: ' + String(e7.message ? e7.message : e7), { page_id: Number(newPage.id) });
+    }
+    out.pages_added.push({ page_id: Number(newPage.id), page_name: String(newPage.name) });
+    out.frames_added.push({
+      frame_id: Number(newFrame.id),
+      page_id: Number(newPage.id),
+      bounds_mm: rect,
+      placement: placed.placement,
+      frame_options_copied: prefsCopied,
+      frame_options_failed: copied.failed,
+      frame_options_skipped: copied.skipped,
+      columns: idcReadColumnsOf(newFrame)
+    });
+    last = newFrame;
+  }
+  try {
+    containers = story.textContainers;
+    last = IDC.concrete(containers[containers.length - 1]);
+    out.overset = last.overflows === true;
+  } catch (e8) { out.overset = true; }
+  out.stopped = out.overset ? 'max_pages' : 'fits';
+  return out;
+}
+
+/*
+ * Lage des neuen Autoflow-Rahmens (A-43 Nr. 5, KDP-Befund 3): Bei
+ * Doppelseiten wechselt die Seite die Seite des Bundes. Fuellt der letzte
+ * Rahmen den Satzspiegel seiner Seite, kommt der neue in den Satzspiegel der
+ * neuen Seite ('type_area'); sonst wird er am Bund gespiegelt – gleicher
+ * Abstand zum Bund wie vorher ('mirrored'). Gleiche Seite des Bundes oder
+ * Einzelseiten: Masse unveraendert ('same'). Bis 1.0.1 bekam eine linke Seite
+ * die Koordinaten der rechten Startseite (Bundsteg und Aussensteg vertauscht).
+ */
+function idcAutoflowRect(doc, rect, fromPage, toPage) {
+  var fromSide = IDC.pageSide(fromPage);
+  var toSide = IDC.pageSide(toPage);
+  var fromArea, toArea, fromWidth, toWidth, inside, x;
+  if (!idcFacing(doc) || fromSide === 'SINGLE_SIDED' || toSide === 'SINGLE_SIDED' || fromSide === toSide) {
+    return { rect: rect, placement: 'same' };
+  }
+  try {
+    fromArea = idcDescribeGrid(fromPage, false, true).type_area_mm;
+    toArea = idcDescribeGrid(toPage, false, true).type_area_mm;
+    if (Math.abs(rect.x - fromArea.x) <= 0.05 && Math.abs(rect.y - fromArea.y) <= 0.05
+      && Math.abs(rect.width - fromArea.width) <= 0.05 && Math.abs(rect.height - fromArea.height) <= 0.05
+      && toArea.width > 0 && toArea.height > 0) {
+      return { rect: { x: toArea.x, y: toArea.y, width: toArea.width, height: toArea.height }, placement: 'type_area' };
+    }
+  } catch (e0) { /* dann spiegeln */ }
+  fromWidth = IDC.pageSize(fromPage).width;
+  toWidth = IDC.pageSize(toPage).width;
+  inside = fromSide === 'RIGHT_HAND' ? rect.x : fromWidth - rect.x - rect.width;
+  x = toSide === 'RIGHT_HAND' ? inside : toWidth - inside - rect.width;
+  return { rect: { x: IDC.round(x), y: rect.y, width: rect.width, height: rect.height }, placement: 'mirrored' };
+}
+
+/*
+ * Rahmenoptionen eines Textrahmens auf einen anderen uebertragen – Wert fuer
+ * Wert, in der Reihenfolge, die InDesign verlangt (erst die Spaltenart, dann
+ * Zahl, Steg und feste Breite). Liefert copied[] und failed[] (Eigenschaft
+ * samt Meldung); Eigenschaften, die die Laufzeit nicht kennt, zaehlen nicht.
+ */
+/* Adobe-DOM TextFramePreference (geprueft 05.09.2026): alle schreibbar. Automatische Groesse und Spaltenlinien bleiben Vorgabe. */
+var IDC_TEXT_FRAME_PREFS = [
+  'useFixedColumnWidth', 'useFlexibleColumnWidth', 'textColumnCount', 'textColumnGutter', 'textColumnFixedWidth',
+  'textColumnMaxWidth', 'insetSpacing', 'verticalJustification', 'verticalThreshold', 'firstBaselineOffset',
+  'minimumFirstBaselineOffset', 'ignoreWrap', 'verticalBalanceColumns'
+];
+
+function idcCopyTextFramePreferences(source, target) {
+  var out = { copied: [], skipped: [], failed: [] };
+  var from, to, i, key, value, justified = false, fixedWidth = false, flexibleWidth = false;
+  try { from = source.textFramePreferences; to = target.textFramePreferences; } catch (e0) {
+    out.failed.push({ property: 'textFramePreferences', message: String(e0.message ? e0.message : e0) });
+    return out;
+  }
+  /*
+   * Live-Fund 05.09.2026: verticalThreshold laesst sich nur setzen, wenn der
+   * Rahmen vertikal im Blocksatz steht ("Diese Eigenschaft ist im aktuellen
+   * Status nicht zutreffend."); die festen/flexiblen Spaltenbreiten gelten nur
+   * bei der jeweiligen Spaltenart. Was nicht zutrifft, wird uebersprungen.
+   */
+  try { justified = typeof VerticalJustification !== 'undefined' && IDC.enumIs(from.verticalJustification, VerticalJustification.JUSTIFY_ALIGN); } catch (ej) { justified = false; }
+  try { fixedWidth = from.useFixedColumnWidth === true; } catch (ef) { fixedWidth = false; }
+  try { flexibleWidth = from.useFlexibleColumnWidth === true; } catch (ex) { flexibleWidth = false; }
+  for (i = 0; i < IDC_TEXT_FRAME_PREFS.length; i++) {
+    key = IDC_TEXT_FRAME_PREFS[i];
+    if ((key === 'verticalThreshold' && !justified) || (key === 'textColumnFixedWidth' && !fixedWidth) || (key === 'textColumnMaxWidth' && !flexibleWidth)) {
+      out.skipped.push(key);
+      continue;
+    }
+    try { value = from[key]; } catch (e1) { continue; }
+    if (value === undefined) { continue; }
+    if (IDC.isArray(value)) { value = value.slice(0); }
+    try {
+      to[key] = value;
+      out.copied.push(key);
+    } catch (e2) {
+      out.failed.push({ property: key, message: String(e2.message ? e2.message : e2) });
+    }
+  }
+  return out;
+}
+
+/* Spalten eines Textrahmens zum Gegenlesen: {count, gutter_mm}. */
+function idcReadColumnsOf(frame) {
+  var out = { count: null, gutter_mm: null };
+  try { out.count = Number(frame.textFramePreferences.textColumnCount); } catch (e0) { /* bleibt null */ }
+  try { out.gutter_mm = IDC.round(Number(frame.textFramePreferences.textColumnGutter)); } catch (e1) { /* bleibt null */ }
+  return out;
+}