layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/76-text-variables.js

@@ -0,0 +1,260 @@
+/* Wunschliste J2 Nr. 22 (Sitzung 8) – Textvariablen: list_text_variables, create_text_variable, insert_text_variable. */
+
+var IDC_VARIABLE_TYPES = [
+  ['custom_text', 'CUSTOM_TEXT_TYPE'],
+  ['running_header_paragraph', 'MATCH_PARAGRAPH_STYLE_TYPE'],
+  ['running_header_character', 'MATCH_CHARACTER_STYLE_TYPE'],
+  ['file_name', 'FILE_NAME_TYPE'],
+  ['output_date', 'OUTPUT_DATE_TYPE'],
+  ['creation_date', 'CREATION_DATE_TYPE'],
+  ['modification_date', 'MODIFICATION_DATE_TYPE'],
+  ['last_page_number', 'LAST_PAGE_NUMBER_TYPE'],
+  ['chapter_number', 'CHAPTER_NUMBER_TYPE']
+];
+
+function idcVariableTypesEnum() {
+  return typeof VariableTypes === 'undefined' ? null : VariableTypes;
+}
+
+function idcVariableTypeName(value) {
+  var i, enumObject = idcVariableTypesEnum();
+  if (value === undefined || value === null) { return null; }
+  if (enumObject === null) { return String(value); }
+  for (i = 0; i < IDC_VARIABLE_TYPES.length; i++) {
+    try { if (IDC.enumIs(value, enumObject[IDC_VARIABLE_TYPES[i][1]])) { return IDC_VARIABLE_TYPES[i][0]; } } catch (e) { /* naechster */ }
+  }
+  return String(value);
+}
+
+function idcVariableTypeFor(name) {
+  var i, enumObject = idcVariableTypesEnum(), value = null;
+  for (i = 0; i < IDC_VARIABLE_TYPES.length; i++) {
+    if (IDC_VARIABLE_TYPES[i][0] === name) {
+      if (enumObject === null) { IDC.fail('invalid_state', 'This runtime has no VariableTypes enumeration.', null); }
+      try { value = enumObject[IDC_VARIABLE_TYPES[i][1]]; } catch (e) { value = null; }
+      if (value === null || value === undefined) { IDC.fail('invalid_state', 'This InDesign has no variable type ' + name + '.', { type: name }); }
+      return value;
+    }
+  }
+  IDC.fail('invalid_argument', 'type must be one of ' + idcTableNames(IDC_VARIABLE_TYPES).join(', ') + '.', { type: name });
+  return null;
+}
+
+function idcSearchStrategyName(value) {
+  if (value === undefined || value === null || typeof SearchStrategies === 'undefined') { return null; }
+  if (IDC.enumIs(value, SearchStrategies.FIRST_ON_PAGE)) { return 'first'; }
+  if (IDC.enumIs(value, SearchStrategies.LAST_ON_PAGE)) { return 'last'; }
+  return String(value);
+}
+
+function idcTextVariableByName(doc, name) {
+  var i, variable;
+  try {
+    for (i = 0; i < doc.textVariables.length; i++) {
+      variable = doc.textVariables.item(i);
+      if (String(variable.name) === String(name)) { return variable; }
+    }
+  } catch (e) { /* keiner */ }
+  return null;
+}
+
+function idcCountVariableInstances(doc, variable) {
+  var count = 0, i, j, story, instances, instance;
+  try {
+    for (i = 0; i < doc.stories.length; i++) {
+      story = doc.stories.item(i);
+      instances = story.textVariableInstances;
+      for (j = 0; j < instances.length; j++) {
+        instance = instances.item(j);
+        try { if (String(instance.associatedTextVariable.name) === String(variable.name)) { count += 1; } } catch (e0) { /* ohne */ }
+      }
+    }
+  } catch (e1) { return null; }
+  return count;
+}
+
+function idcDescribeTextVariable(doc, variable) {
+  var out = { name: null, type: null, options: {}, instance_count: null, built_in: false };
+  var options = null, type;
+  try { out.name = String(variable.name); } catch (e0) { /* null */ }
+  try { type = variable.variableType; out.type = idcVariableTypeName(type); } catch (e1) { out.type = null; }
+  try { options = variable.variableOptions; } catch (e2) { options = null; }
+  if (options !== null && options !== undefined) {
+    if (out.type === 'custom_text') {
+      try { out.options.text = String(options.contents); } catch (e3) { /* ohne */ }
+    } else if (out.type === 'running_header_paragraph' || out.type === 'running_header_character') {
+      if (out.type === 'running_header_paragraph') {
+        try { out.options.paragraph_style = String(options.appliedParagraphStyle.name); } catch (e4) { out.options.paragraph_style = null; }
+      } else {
+        try { out.options.character_style = String(options.appliedCharacterStyle.name); } catch (e5) { out.options.character_style = null; }
+      }
+      try { out.options.use = idcSearchStrategyName(options.searchStrategy); } catch (e6) { /* ohne */ }
+      try { out.options.text_before = String(options.textBefore); } catch (e7) { /* ohne */ }
+      try { out.options.text_after = String(options.textAfter); } catch (e8) { /* ohne */ }
+      try { out.options.delete_end_punctuation = options.deleteEndPunctuation === true; } catch (e9) { /* ohne */ }
+    } else if (out.type === 'file_name') {
+      try { out.options.include_extension = options.includeExtension === true; } catch (e10) { /* ohne */ }
+      try { out.options.include_path = options.includePath === true; } catch (e11) { /* ohne */ }
+      try { out.options.text_before = String(options.textBefore); } catch (e12) { /* ohne */ }
+      try { out.options.text_after = String(options.textAfter); } catch (e13) { /* ohne */ }
+    } else if (out.type === 'output_date' || out.type === 'creation_date' || out.type === 'modification_date') {
+      try { out.options.format = String(options.format); } catch (e14) { /* ohne */ }
+      try { out.options.text_before = String(options.textBefore); } catch (e15) { /* ohne */ }
+      try { out.options.text_after = String(options.textAfter); } catch (e16) { /* ohne */ }
+    } else {
+      try { out.options.text_before = String(options.textBefore); } catch (e17) { /* ohne */ }
+      try { out.options.text_after = String(options.textAfter); } catch (e18) { /* ohne */ }
+    }
+  }
+  out.instance_count = idcCountVariableInstances(doc, variable);
+  return out;
+}
+
+/* Optionen einer Variablen aus den Werkzeugparametern schreiben. */
+function idcApplyVariableOptions(ctx, doc, variable, type, args) {
+  var options = null, style, strategy;
+  try { options = variable.variableOptions; } catch (e0) { options = null; }
+  if (options === null || options === undefined) {
+    ctx.warn('InDesign exposes no options for this variable; nothing written.');
+    return;
+  }
+  try {
+    if (type === 'custom_text') {
+      if (args.text === undefined || args.text === null) { IDC.fail('invalid_argument', 'custom_text needs text.', null); }
+      options.contents = idcNormaliseText(String(args.text));
+    } else if (type === 'running_header_paragraph' || type === 'running_header_character') {
+      if (type === 'running_header_paragraph') {
+        if (args.paragraph_style === undefined || args.paragraph_style === null) { IDC.fail('invalid_argument', 'running_header_paragraph needs paragraph_style.', null); }
+        style = idcParagraphStyleArg(doc, args.paragraph_style, 'paragraph_style');
+        options.appliedParagraphStyle = style;
+      } else {
+        if (typeof args.character_style !== 'string' || args.character_style === '') { IDC.fail('invalid_argument', 'running_header_character needs character_style.', null); }
+        style = idcCharacterStyleByName(doc, args.character_style);
+        if (style === null) { IDC.fail('not_found', 'Character style "' + args.character_style + '" not found.', { character_style: args.character_style }); }
+        options.appliedCharacterStyle = style;
+      }
+      if (args.use !== undefined && args.use !== null) {
+        if (typeof SearchStrategies === 'undefined') { IDC.fail('invalid_state', 'This runtime has no SearchStrategies enumeration.', null); }
+        if (args.use === 'first') { strategy = SearchStrategies.FIRST_ON_PAGE; }
+        else if (args.use === 'last') { strategy = SearchStrategies.LAST_ON_PAGE; }
+        else { IDC.fail('invalid_argument', 'use must be first or last.', { use: args.use }); }
+        options.searchStrategy = strategy;
+      }
+      if (args.text_before !== undefined && args.text_before !== null) { options.textBefore = String(args.text_before); }
+      if (args.text_after !== undefined && args.text_after !== null) { options.textAfter = String(args.text_after); }
+      if (args.delete_end_punctuation !== undefined && args.delete_end_punctuation !== null) { options.deleteEndPunctuation = args.delete_end_punctuation === true; }
+    } else if (type === 'file_name') {
+      if (args.include_extension !== undefined && args.include_extension !== null) { options.includeExtension = args.include_extension === true; }
+      if (args.include_path !== undefined && args.include_path !== null) { options.includePath = args.include_path === true; }
+      if (args.text_before !== undefined && args.text_before !== null) { options.textBefore = String(args.text_before); }
+      if (args.text_after !== undefined && args.text_after !== null) { options.textAfter = String(args.text_after); }
+    } else {
+      if (args.date_format !== undefined && args.date_format !== null && (type === 'output_date' || type === 'creation_date' || type === 'modification_date')) { options.format = String(args.date_format); }
+      if (args.text_before !== undefined && args.text_before !== null) { options.textBefore = String(args.text_before); }
+      if (args.text_after !== undefined && args.text_after !== null) { options.textAfter = String(args.text_after); }
+    }
+  } catch (e1) {
+    if (e1 && e1.isIdcError) { throw e1; }
+    IDC.fail('script_error', 'InDesign could not set the variable options: ' + String(e1.message ? e1.message : e1), { name: String(variable.name) });
+  }
+}
+
+IDC.register('list_text_variables', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var doc = ctx.doc;
+    var out = [], i;
+    try {
+      for (i = 0; i < doc.textVariables.length; i++) { out.push(idcDescribeTextVariable(doc, doc.textVariables.item(i))); }
+    } catch (e) { /* leer */ }
+    return { variables: out, count: out.length };
+  });
+
+IDC.register('create_text_variable', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var name = args.name;
+    var existing, variable = null, created = false, typeValue, currentType, description, instances;
+
+    if (typeof name !== 'string' || name === '') { IDC.fail('invalid_argument', 'name is required.', null); }
+    existing = idcTextVariableByName(doc, name);
+    if (args.remove === true) {
+      if (existing === null) { IDC.fail('not_found', 'No text variable named "' + name + '".', { name: name }); }
+      instances = idcCountVariableInstances(doc, existing);
+      description = idcDescribeTextVariable(doc, existing);
+      try { existing.remove(); } catch (e0) {
+        IDC.fail('script_error', 'InDesign could not remove the variable "' + name + '": ' + String(e0.message ? e0.message : e0), { name: name });
+      }
+      if (instances !== null && instances > 0) { ctx.warn(instances + ' instance(s) of "' + name + '" in the text were removed with the variable.'); }
+      ctx.changes = { modified_document_ids: [Number(doc.id)] };
+      return { removed: true, variable: description };
+    }
+    if (typeof args.type !== 'string') { IDC.fail('invalid_argument', 'type is required.', null); }
+    typeValue = idcVariableTypeFor(args.type);
+    if (existing !== null) {
+      try { currentType = idcVariableTypeName(existing.variableType); } catch (e1) { currentType = null; }
+      if (currentType !== args.type) {
+        IDC.fail('invalid_state', 'A text variable named "' + name + '" exists with type ' + currentType + '; remove it first or choose another name.',
+          { name: name, existing_type: currentType });
+      }
+      variable = existing;
+    } else {
+      try {
+        variable = doc.textVariables.add({ name: name, variableType: typeValue });
+      } catch (e2) {
+        IDC.fail('script_error', 'InDesign could not create the text variable "' + name + '": ' + String(e2.message ? e2.message : e2), { name: name });
+      }
+      created = true;
+    }
+    try {
+      idcApplyVariableOptions(ctx, doc, variable, args.type, args);
+    } catch (e3) {
+      /* Frisch angelegt und Optionen abgewiesen: nichts halb zuruecklassen. */
+      if (created) { try { variable.remove(); } catch (e4) { /* bleibt */ } }
+      throw e3;
+    }
+    description = idcDescribeTextVariable(doc, variable);
+    ctx.changes = { modified_document_ids: [Number(doc.id)] };
+    return { created: created, updated: !created, variable: description };
+  });
+
+IDC.register('insert_text_variable', { 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 story = idcStoryOf(found.item);
+    var variable, length = 0, index, insertionPoint, instance = null, resultText = null, description;
+
+    if (typeof args.name !== 'string' || args.name === '') { IDC.fail('invalid_argument', 'name is required (a text variable of the document).', null); }
+    variable = idcTextVariableByName(doc, args.name);
+    if (variable === null) { IDC.fail('not_found', 'No text variable named "' + args.name + '"; see list_text_variables.', { name: args.name }); }
+    try { length = Number(story.characters.length); } catch (e0) { length = 0; }
+    if (args.index === undefined || args.index === null) { index = length; }
+    else {
+      if (typeof args.index !== 'number' || Math.floor(args.index) !== args.index || args.index < 0 || args.index > length) {
+        IDC.fail('invalid_argument', 'index must be a whole number from 0 to the story length (' + length + ').', { index: args.index, story_length: length });
+      }
+      index = args.index;
+    }
+    try { insertionPoint = story.insertionPoints.item(index); } catch (e1) {
+      IDC.fail('script_error', 'InDesign could not address insertion point ' + index + '.', { index: index });
+    }
+    try {
+      instance = insertionPoint.textVariableInstances.add({ associatedTextVariable: variable });
+    } catch (e2) {
+      try {
+        instance = insertionPoint.textVariableInstances.add(LocationOptions.AT_END, undefined, { associatedTextVariable: variable });
+      } catch (e3) {
+        IDC.fail('script_error', 'InDesign could not insert the variable "' + args.name + '": ' + String(e3.message ? e3.message : e3), { name: args.name, index: index });
+      }
+    }
+    try { resultText = String(instance.resultText); } catch (e4) { resultText = null; }
+    description = { instance_id: null, name: args.name, story_id: Number(story.id), frame_id: Number(found.item.id), index: index, result_text: resultText, story_length: null };
+    try { description.instance_id = Number(instance.id); } catch (e5) { /* null */ }
+    try { description.story_length = Number(story.characters.length); } catch (e6) { /* null */ }
+    description.overset = idcOverflows(found.item);
+    if (description.overset === true) { ctx.warn('The story overflows after inserting the variable (Übersatz).'); }
+    ctx.changes = { modified_frame_ids: [Number(found.item.id)] };
+    return description;
+  });

package/indesign/commands/77-story-options.js

@@ -0,0 +1,86 @@
+/*
+ * Auftrag A-7.4 (Sitzung 9) – set_story_options: storyweite Einstellungen,
+ * zuerst der optische Randausgleich (haengende Interpunktion).
+ * Adobe-DOM (StoryPreference, geprueft 05.09.2026):
+ * opticalMarginAlignment (Bool), opticalMarginSize (Punkt, 0.1–1296).
+ */
+
+function idcStoryPreferences(story) {
+  var prefs = null;
+  try { prefs = story.storyPreferences; } catch (e) { prefs = null; }
+  if (prefs === null || prefs === undefined) {
+    IDC.fail('invalid_state', 'The story has no storyPreferences in this runtime.', null);
+  }
+  return prefs;
+}
+
+function idcReadStoryOptions(story) {
+  var prefs = null;
+  var out = { optical_margin_alignment: null, optical_margin_size_pt: null };
+  try { prefs = story.storyPreferences; } catch (e0) { prefs = null; }
+  if (prefs === null || prefs === undefined) { return out; }
+  try { out.optical_margin_alignment = prefs.opticalMarginAlignment === true; } catch (e1) { /* null */ }
+  try {
+    out.optical_margin_size_pt = IDC.inPoints(function () { return IDC.round(Number(prefs.opticalMarginSize), 3); });
+  } catch (e2) { /* null */ }
+  return out;
+}
+
+function idcStoryFrameIds(story) {
+  var ids = [], containers, i;
+  try { containers = story.textContainers; } catch (e0) { return ids; }
+  for (i = 0; i < containers.length; i++) {
+    try { ids.push(Number(containers[i].id)); } catch (e1) { /* auslassen */ }
+  }
+  return ids;
+}
+
+IDC.register('set_story_options', { 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 changed = [];
+    var prefs, overset = null, before, after;
+
+    if (idcGiven(args.optical_margin_alignment) && typeof args.optical_margin_alignment !== 'boolean') {
+      IDC.fail('invalid_argument', 'optical_margin_alignment must be true or false.', { value: args.optical_margin_alignment });
+    }
+    if (idcGiven(args.optical_margin_size_pt)) {
+      idcNumberArg(args.optical_margin_size_pt, 'optical_margin_size_pt', 0.1, 1296);
+    }
+
+    before = idcReadStoryOptions(story);
+    if (idcGiven(args.optical_margin_alignment) || idcGiven(args.optical_margin_size_pt)) {
+      prefs = idcStoryPreferences(story);
+      try {
+        if (idcGiven(args.optical_margin_alignment)) {
+          prefs.opticalMarginAlignment = args.optical_margin_alignment;
+          changed.push('optical_margin_alignment');
+        }
+        if (idcGiven(args.optical_margin_size_pt)) {
+          IDC.inPoints(function () { prefs.opticalMarginSize = args.optical_margin_size_pt; });
+          changed.push('optical_margin_size_pt');
+        }
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not set the story options: ' + String(e.message ? e.message : e), { frame_id: args.frame_id });
+      }
+      ctx.changes = { modified_story_ids: [Number(story.id)] };
+    }
+    after = idcReadStoryOptions(story);
+    try { overset = story.overflows === true; } catch (e2) { overset = null; }
+    if (changed.length > 0 && overset === true) {
+      ctx.warn('The story overflows after the change – optical margin alignment recomposes every line.');
+    }
+    return {
+      story_id: Number(story.id),
+      frame_ids: idcStoryFrameIds(story),
+      optical_margin_alignment: after.optical_margin_alignment,
+      optical_margin_size_pt: after.optical_margin_size_pt,
+      previous: before,
+      changed: changed,
+      overset: overset
+    };
+  });

package/indesign/commands/78-frame-lines.js

@@ -0,0 +1,304 @@
+/*
+ * Auftrag A-7.5 (Sitzung 9) – get_frame_lines: den Umbruch direkt in
+ * InDesign lesen – Zeilen je Textspalte eines Rahmens mit Grundlinie,
+ * Story-Indizes, Absatzstellung und Kennzahlen (Hurenkind-/Schusterjungen-
+ * Verdacht, Trennstrichleitern, Leerzeilen). Rein lesend.
+ *
+ * Adobe-DOM (geprueft 05.09.2026): TextFrame.textColumns, TextFrame.lines,
+ * Line {baseline, ascent, descent, horizontalOffset, endHorizontalOffset,
+ * characters, paragraphs, words, contents}. TextColumn lieferte 404 – die
+ * Klasse ist ein Text-Objekt mit lines; ohne textColumns gilt der Rahmen
+ * als eine Spalte.
+ *
+ * Grundlinien und horizontale Lagen werden unter Bogen-Nullpunkt gelesen
+ * (Millimeter ueber die Masseinheiten-Klammer) und um den Seitenversatz
+ * verschoben – wie IDC.boundsOnPage.
+ */
+
+/* Bindestrich, weicher Trennstrich, Trennstrich, geschuetzter Trennstrich. */
+var IDC_LINE_HYPHENS = {};
+IDC_LINE_HYPHENS['-'] = 1;
+IDC_LINE_HYPHENS['\u00AD'] = 1;
+IDC_LINE_HYPHENS['\u2010'] = 1;
+IDC_LINE_HYPHENS['\u2011'] = 1;
+
+function idcIsLetter(ch) {
+  if (ch === '' || ch === null || ch === undefined) { return false; }
+  return /[A-Za-z\u00C0-\u024F\u0370-\u03FF\u0400-\u04FF]/.test(ch);
+}
+
+/* Story-Index des ersten Zeichens eines Textobjekts (Zeile, Absatz). */
+function idcTextStartIndex(textObject) {
+  try { return Number(textObject.characters.item(0).index); } catch (e) { return null; }
+}
+
+function idcTextLength(textObject) {
+  try { return Number(textObject.characters.length); } catch (e) { return null; }
+}
+
+/*
+ * Absaetze der Story: Startindex -> Ordnungszahl, dazu Zeilenzahl je
+ * Absatz storyweit (paragraph.lines.length), einmal je Aufruf.
+ */
+function idcParagraphMap(story) {
+  var map = { starts: [], count: 0 };
+  var paragraphs, i, p, start, lines;
+  try { paragraphs = story.paragraphs; map.count = Number(paragraphs.length); } catch (e0) { return map; }
+  for (i = 0; i < map.count; i++) {
+    p = paragraphs.item(i);
+    start = idcTextStartIndex(p);
+    lines = null;
+    try { lines = Number(p.lines.length); } catch (e1) { lines = null; }
+    map.starts.push({ start: start, length: idcTextLength(p), lines: lines });
+  }
+  return map;
+}
+
+function idcParagraphOrdinal(map, startIndex) {
+  var i;
+  for (i = 0; i < map.starts.length; i++) {
+    if (map.starts[i].start === startIndex) { return i; }
+  }
+  return null;
+}
+
+/* Spaltenbegrenzungen aus Rahmen, Innenabstand, Spaltenzahl und Steg (Seitenkoordinaten). */
+function idcColumnBounds(doc, frame, page, count) {
+  var bounds = IDC.boundsOnPage(doc, frame, page);
+  var inset = [0, 0, 0, 0];
+  var gutter = 0;
+  var out = [], i, width, x;
+  try { inset = frame.textFramePreferences.insetSpacing; } catch (e0) { inset = [0, 0, 0, 0]; }
+  if (!IDC.isArray(inset) || inset.length < 4) { inset = [0, 0, 0, 0]; }
+  try { gutter = Number(frame.textFramePreferences.textColumnGutter); } catch (e1) { gutter = 0; }
+  if (isNaN(gutter)) { gutter = 0; }
+  width = (bounds.width - Number(inset[1]) - Number(inset[3]) - (count - 1) * gutter) / count;
+  for (i = 0; i < count; i++) {
+    x = bounds.x + Number(inset[1]) + i * (width + gutter);
+    out.push({
+      x: IDC.round(x),
+      y: IDC.round(bounds.y + Number(inset[0])),
+      width: IDC.round(width),
+      height: IDC.round(bounds.height - Number(inset[0]) - Number(inset[2]))
+    });
+  }
+  return out;
+}
+
+function idcDescribeLine(doc, line, indexInColumn, map, dx, includeText) {
+  var start = idcTextStartIndex(line);
+  var length = idcTextLength(line);
+  var paragraph = null, pStart = null, pLength = null, pLines = null;
+  var text = null, contents = '', lastChar = '', wordCount = null;
+  var out;
+
+  try { paragraph = line.paragraphs.item(0); } catch (e0) { paragraph = null; }
+  if (paragraph !== null) {
+    pStart = idcTextStartIndex(paragraph);
+    pLength = idcTextLength(paragraph);
+    try { pLines = Number(paragraph.lines.length); } catch (e1) { pLines = null; }
+  }
+  try { contents = String(line.contents); } catch (e2) { contents = ''; }
+  if (contents.length > 0) { lastChar = contents.charAt(contents.length - 1); }
+  try { wordCount = Number(line.words.length); } catch (e3) { wordCount = null; }
+  if (contents.replace(/[\r\n\s]/g, '') === '') { wordCount = 0; }
+
+  out = {
+    index: indexInColumn,
+    start_index: start,
+    end_index: start === null || length === null ? null : start + length,
+    baseline_mm: null,
+    ascent_pt: null,
+    descent_pt: null,
+    left_mm: null,
+    right_mm: null,
+    paragraph_index: pStart === null ? null : idcParagraphOrdinal(map, pStart),
+    is_first_line_of_paragraph: pStart !== null && start === pStart,
+    is_last_line_of_paragraph: pStart !== null && pLength !== null && start !== null && length !== null && start + length === pStart + pLength,
+    paragraph_line_count: pLines,
+    ends_with_hyphen: IDC.hasOwn(IDC_LINE_HYPHENS, lastChar),
+    is_empty: length !== null && (length === 0 || (length === 1 && (lastChar === '\r' || lastChar === '\n'))),
+    word_count: wordCount,
+    last_char: lastChar === '\r' ? '\\r' : lastChar
+  };
+  try { out.baseline_mm = IDC.round(Number(line.baseline)); } catch (e4) { /* null */ }
+  try { out.ascent_pt = IDC.inPoints(function () { return IDC.round(Number(line.ascent), 3); }); } catch (e5) { /* null */ }
+  try { out.descent_pt = IDC.inPoints(function () { return IDC.round(Number(line.descent), 3); }); } catch (e6) { /* null */ }
+  try { out.left_mm = IDC.round(Number(line.horizontalOffset) - dx); } catch (e7) { /* null */ }
+  try { out.right_mm = IDC.round(Number(line.endHorizontalOffset) - dx); } catch (e8) { /* null */ }
+  if (includeText) {
+    text = contents.replace(/[\r\n]+$/, '');
+    out.text = text;
+  }
+  return out;
+}
+
+/*
+ * Automatische Trennung: der Trennstrich steht nicht im Text. Endet eine
+ * Zeile mit einem Buchstaben und beginnt die naechste Zeile desselben
+ * Absatzes mit einem Buchstaben, ist das Wort getrennt (oder erzwungen
+ * gebrochen) – ends_with_hyphen wird dann gesetzt.
+ */
+function idcMarkSoftHyphens(lines, texts) {
+  var i, a, b;
+  for (i = 0; i + 1 < lines.length; i++) {
+    a = lines[i];
+    b = lines[i + 1];
+    if (a.ends_with_hyphen) { continue; }
+    if (a.paragraph_index === null || a.paragraph_index !== b.paragraph_index) { continue; }
+    if (a.is_last_line_of_paragraph) { continue; }
+    if (idcIsLetter(texts[i].last) && idcIsLetter(texts[i + 1].first)) { a.ends_with_hyphen = true; }
+  }
+}
+
+function idcColumnFigures(lines) {
+  var out = {
+    line_count: lines.length,
+    first_baseline_mm: null,
+    last_baseline_mm: null,
+    starts_with_last_line_of_paragraph: false,
+    ends_with_first_line_of_paragraph: false,
+    starts_with_empty_line: false,
+    consecutive_hyphens_max: 0,
+    ends_with_single_word: false,
+    single_word_last_lines: []
+  };
+  var i, run = 0, first, last;
+  if (lines.length === 0) { return out; }
+  first = lines[0];
+  last = lines[lines.length - 1];
+  out.first_baseline_mm = first.baseline_mm;
+  out.last_baseline_mm = last.baseline_mm;
+  out.starts_with_last_line_of_paragraph = first.is_last_line_of_paragraph && !first.is_first_line_of_paragraph && !first.is_empty;
+  out.ends_with_first_line_of_paragraph = last.is_first_line_of_paragraph && !last.is_last_line_of_paragraph && !last.is_empty;
+  out.starts_with_empty_line = first.is_empty === true;
+  for (i = 0; i < lines.length; i++) {
+    if (lines[i].ends_with_hyphen) { run += 1; if (run > out.consecutive_hyphens_max) { out.consecutive_hyphens_max = run; } }
+    else { run = 0; }
+    if (lines[i].is_last_line_of_paragraph && !lines[i].is_empty && lines[i].word_count === 1 && lines[i].paragraph_line_count !== null && lines[i].paragraph_line_count > 1) {
+      out.single_word_last_lines.push(lines[i].index);
+    }
+  }
+  out.ends_with_single_word = last.is_last_line_of_paragraph && !last.is_empty && last.word_count === 1 && last.paragraph_line_count !== null && last.paragraph_line_count > 1;
+  return out;
+}
+
+/* Zeilen einer Spalte (TextColumn) oder des ganzen Rahmens als Array. */
+function idcLinesOf(textObject) {
+  var out = [], lines, i;
+  try { lines = textObject.lines; } catch (e0) { return out; }
+  for (i = 0; i < lines.length; i++) { out.push(lines.item(i)); }
+  return out;
+}
+
+function idcFrameColumns(frame) {
+  var out = [], columns, i;
+  try { columns = frame.textColumns; } catch (e0) { columns = null; }
+  if (columns === null || columns === undefined) { return null; }
+  try {
+    for (i = 0; i < columns.length; i++) { out.push(columns.item(i)); }
+  } catch (e1) { return null; }
+  return out;
+}
+
+/*
+ * Zeilen eines Rahmens je Spalte samt Kennzahlen – gemeinsam fuer
+ * get_frame_lines und check_typography. Warnungen gehen an ctx (null =
+ * keine).
+ */
+function idcFrameLineData(doc, frame, story, includeText, maxLines, ctx) {
+  var page = null, dx = 0, columns, columnObjects, i, c, lines, entries, texts, line, total = 0, truncated = false, overset = null;
+  var map, bounds, frameIndex = null, containers;
+
+  try { page = frame.parentPage; } catch (e0) { page = null; }
+  try { if (page !== null && page !== undefined && page.isValid !== true) { page = null; } } catch (e0b) { page = null; }
+  if (page === null || page === undefined) { page = null; }
+  dx = page === null ? 0 : IDC.spreadOffsetOfPage(page);
+
+  try {
+    containers = story.textContainers;
+    for (i = 0; i < containers.length; i++) {
+      if (Number(containers[i].id) === Number(frame.id)) { frameIndex = i; break; }
+    }
+  } catch (e1) { frameIndex = null; }
+  try { overset = story.overflows === true; } catch (e2) { overset = null; }
+
+  map = idcParagraphMap(story);
+  columnObjects = idcFrameColumns(frame);
+  if (columnObjects === null || columnObjects.length === 0) { columnObjects = [frame]; }
+  bounds = idcColumnBounds(doc, frame, page, columnObjects.length);
+
+  columns = [];
+  for (c = 0; c < columnObjects.length; c++) {
+    lines = idcLinesOf(columnObjects[c]);
+    entries = [];
+    texts = [];
+    for (i = 0; i < lines.length; i++) {
+      if (total >= maxLines) { truncated = true; break; }
+      line = lines[i];
+      entries.push(idcDescribeLine(doc, line, i, map, dx, includeText));
+      var contents = '';
+      try { contents = String(line.contents); } catch (e3) { contents = ''; }
+      /* Endet die Zeile mit Absatzmarke, erzwungenem Umbruch (Live-Fund 05.09.2026: initial_text mit LF) oder Zeilentrenner, ist nichts getrennt. */
+      var rawLast = contents.charAt(contents.length - 1);
+      var brokenByBreak = rawLast === '\r' || rawLast === '\n' || rawLast === '\u2028' || rawLast === '\u2029';
+      texts.push({ first: contents.charAt(0), last: brokenByBreak ? '' : rawLast });
+      total += 1;
+    }
+    idcMarkSoftHyphens(entries, texts);
+    var figures = idcColumnFigures(entries);
+    figures.column_index = c;
+    figures.bounds_mm = bounds[c] || null;
+    figures.lines = entries;
+    columns.push(figures);
+    if (truncated) { break; }
+  }
+  if (ctx !== null && truncated) {
+    ctx.warn('More than ' + maxLines + ' lines; output cut at max_lines (truncated true).');
+  }
+  if (ctx !== null && total === 0) {
+    ctx.warn('The frame shows no composed line – it is empty, or the text is overset before it.');
+  }
+
+  return {
+    frame_id: Number(frame.id),
+    story_id: Number(story.id),
+    frame_index: frameIndex,
+    page_id: page === null ? null : Number(page.id),
+    page_name: page === null ? '' : String(page.name),
+    paragraph_count: map.count,
+    column_count: columns.length,
+    line_count: total,
+    columns: columns,
+    overset: overset,
+    truncated: truncated
+  };
+}
+
+IDC.register('get_frame_lines', { needs_document: true, read_only: true, ruler: 'spread' },
+  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 includeText = args.include_text === true;
+    var maxLines = idcGiven(args.max_lines) ? args.max_lines : 500;
+
+    if (typeof maxLines !== 'number' || Math.floor(maxLines) !== maxLines || maxLines < 1 || maxLines > 5000) {
+      IDC.fail('invalid_argument', 'max_lines must be a whole number between 1 and 5000.', { max_lines: args.max_lines });
+    }
+    var data = idcFrameLineData(doc, frame, story, includeText, maxLines, ctx);
+    return {
+      frame_id: data.frame_id,
+      story_id: data.story_id,
+      frame_index: data.frame_index,
+      page_id: data.page_id,
+      coordinate_space: data.page_id === null ? 'spread' : 'page',
+      column_count: data.column_count,
+      line_count: data.line_count,
+      columns: data.columns,
+      overset: data.overset,
+      truncated: data.truncated
+    };
+  });