layoutbridge-light 0.0.0-stage → 1.0.1

package/indesign/commands/80-styles.js

@@ -0,0 +1,1960 @@
+/* Bereich H – Formate und Zeichenformatierung. */
+
+/* ------------------------------------------------------------- Hilfen */
+
+/*
+ * Vorhanden? DOM-Objekte (Color, Swatch) ueberladen === in ExtendScript und
+ * werfen beim Vergleich mit null ("Color.===() cannot work with instances of
+ * this class", Live-Fund 04.09.2026) – wirft der Vergleich, ist es ein Objekt.
+ */
+function idcPresent(value) {
+  try {
+    return !(value === null || value === undefined);
+  } catch (e) { return true; }
+}
+
+/* NothingEnum.NOTHING: so liest InDesign ein nicht gesetztes Attribut (Zeichenformate). */
+function idcIsNothing(value) {
+  if (!idcPresent(value)) { return true; }
+  try {
+    if (typeof NothingEnum !== 'undefined' && IDC.enumIs(value, NothingEnum.NOTHING)) { return true; }
+  } catch (e) { /* kein Enum */ }
+  return false;
+}
+
+/*
+ * Schnitt oder null. A-68 Befund (15), Sitzung 81: ein Zeichenformat ohne
+ * Schnitt las sich live als "NOTHING" (Zeichenkette des Enumerators, an
+ * idcIsNothing vorbei) – auch "", "undefined" und "NOTHING" sind kein Schnitt.
+ */
+function idcFontStyleOrNull(value) {
+  var text;
+  if (idcIsNothing(value)) { return null; }
+  text = String(value);
+  if (text === '' || text === 'undefined' || text === 'NOTHING') { return null; }
+  return text;
+}
+
+/* Schrift eines Text- oder Formatobjekts; nicht gesetzte Attribute bleiben null. */
+function idcReadFontLoose(target) {
+  var raw;
+  try { raw = target.appliedFont; } catch (e) { raw = null; }
+  if (idcIsNothing(raw)) {
+    var style = null;
+    try { style = target.fontStyle; } catch (e2) { style = null; }
+    return { family: null, style: idcFontStyleOrNull(style) };
+  }
+  var read = idcReadDefaultFont(target);
+  /* Nicht gesetzte Familie eines Zeichenformats liest sich als "" oder "undefined" (Live-Fund 04.09.2026). */
+  if (read.family === '' || read.family === 'undefined') { read.family = null; }
+  read.style = idcFontStyleOrNull(read.style);
+  return read;
+}
+
+/* Punktwert lesen (Schriftgrad, Abstand): unter Punkt-Masseinheit, null wenn nicht gesetzt. */
+function idcReadPt(target, property) {
+  var value;
+  try {
+    value = IDC.inPoints(function () { return target[property]; });
+  } catch (e) { return null; }
+  if (idcIsNothing(value)) { return null; }
+  return IDC.round(Number(value), 3);
+}
+
+/* Zeilenabstand: { pt, auto } – pt null bei automatischem Zeilenabstand. */
+function idcReadLeading(target) {
+  var value;
+  try {
+    value = IDC.inPoints(function () { return target.leading; });
+  } catch (e) { return { pt: null, auto: false }; }
+  if (idcIsNothing(value)) { return { pt: null, auto: false }; }
+  if (typeof Leading !== 'undefined' && IDC.enumIs(value, Leading.AUTO)) { return { pt: null, auto: true }; }
+  var n = Number(value);
+  if (isNaN(n)) { return { pt: null, auto: false }; }
+  return { pt: IDC.round(n, 3), auto: false };
+}
+
+function idcReadNumberLoose(target, property, digits) {
+  var value;
+  try { value = target[property]; } catch (e) { return null; }
+  if (idcIsNothing(value)) { return null; }
+  var n = Number(value);
+  return isNaN(n) ? null : IDC.round(n, digits === undefined ? 3 : digits);
+}
+
+function idcReadBoolLoose(target, property) {
+  var value;
+  try { value = target[property]; } catch (e) { return null; }
+  if (idcIsNothing(value)) { return null; }
+  return value === true;
+}
+
+function idcReadSwatchName(target, property) {
+  var value;
+  try { value = target[property]; } catch (e) { return null; }
+  if (idcIsNothing(value)) { return null; }
+  try { return String(value.name); } catch (e2) { return null; }
+}
+
+/* Gruppenpfad eines Formats ("Group/Subgroup"), leer auf oberster Ebene. */
+function idcStyleGroupPath(style) {
+  var names = [];
+  var current, name, step;
+  try { current = style.parent; } catch (e) { return ''; }
+  for (step = 0; step < 12; step++) {
+    if (current === null || current === undefined) { break; }
+    name = IDC.className(current);
+    if (name === 'ParagraphStyleGroup' || name === 'CharacterStyleGroup') {
+      try { names.unshift(String(current.name)); } catch (e2) { break; }
+      try { current = current.parent; } catch (e3) { break; }
+    } else {
+      break;
+    }
+  }
+  return names.join('/');
+}
+
+/* Name des Grundlagenformats; die Wurzel ([Kein Absatzformat]) kommt als Verweis ohne lesbaren Namen zurueck (Live-Fund 04.09.2026) – dann null. */
+function idcBasedOnName(style) {
+  var base, name;
+  try { base = style.basedOn; } catch (e) { return null; }
+  if (idcIsNothing(base)) { return null; }
+  if (typeof base === 'string') { return base === '' || base === 'undefined' ? null : base; }
+  try { name = String(base.name); } catch (e2) { name = 'undefined'; }
+  if (name === 'undefined' || name === '') {
+    try { name = String(IDC.concrete(base).name); } catch (e3) { name = 'undefined'; }
+  }
+  return name === 'undefined' || name === '' ? null : name;
+}
+
+/* Ausrichtungsname zu einem Justification-Wert. */
+function idcJustificationName(value) {
+  if (typeof Justification === 'undefined') { return value === undefined ? null : String(value); }
+  if (idcIsNothing(value)) { return null; }
+  var table = [
+    ['left', Justification.LEFT_ALIGN],
+    ['center', Justification.CENTER_ALIGN],
+    ['right', Justification.RIGHT_ALIGN],
+    ['justify_left', Justification.LEFT_JUSTIFIED],
+    ['justify_center', Justification.CENTER_JUSTIFIED],
+    ['justify_right', Justification.RIGHT_JUSTIFIED],
+    ['justify_full', Justification.FULLY_JUSTIFIED],
+    ['away_from_binding', Justification.AWAY_FROM_BINDING_SIDE],
+    ['to_binding', Justification.TO_BINDING_SIDE]
+  ];
+  var i;
+  for (i = 0; i < table.length; i++) {
+    if (IDC.enumIs(value, table[i][1])) { return table[i][0]; }
+  }
+  return String(value);
+}
+
+/* Justification-Wert zu einem Ausrichtungsnamen; "justify" = Blocksatz, letzte Zeile links. */
+function idcJustificationFor(name, field) {
+  var text = String(name);
+  if (typeof Justification === 'undefined') {
+    IDC.fail('invalid_state', 'This runtime has no Justification enumeration.', null);
+  }
+  if (text === 'left') { return Justification.LEFT_ALIGN; }
+  if (text === 'center') { return Justification.CENTER_ALIGN; }
+  if (text === 'right') { return Justification.RIGHT_ALIGN; }
+  if (text === 'justify' || text === 'justify_left') { return Justification.LEFT_JUSTIFIED; }
+  if (text === 'justify_center') { return Justification.CENTER_JUSTIFIED; }
+  if (text === 'justify_right') { return Justification.RIGHT_JUSTIFIED; }
+  if (text === 'justify_full') { return Justification.FULLY_JUSTIFIED; }
+  IDC.fail('invalid_argument', field + ' must be one of left, center, right, justify, justify_left, justify_center, justify_right, justify_full.', { value: text });
+  return null;
+}
+
+function idcStyleNameArg(value, field) {
+  if (typeof value !== 'string' || value.length === 0) {
+    IDC.fail('invalid_argument', field + ' is required (a non-empty string).', null);
+  }
+  if (value.charAt(0) === '[') {
+    IDC.fail('invalid_argument', field + ' must not start with "[" – those names are reserved for InDesign\'s internal styles.', { value: value });
+  }
+  return value;
+}
+
+function idcCollisionArg(value) {
+  if (value === undefined || value === null) { return 'error'; }
+  if (value !== 'error' && value !== 'update' && value !== 'version') {
+    IDC.fail('invalid_argument', 'on_collision must be error, update or version.', { value: value });
+  }
+  return value;
+}
+
+function idcNumberArg(value, field, min, max) {
+  if (typeof value !== 'number' || !isFinite(value)) {
+    IDC.fail('invalid_argument', field + ' must be a number.', { value: value });
+  }
+  if (min !== null && value < min) {
+    IDC.fail('invalid_argument', field + ' must be ' + min + ' or more.', { value: value });
+  }
+  if (max !== null && value > max) {
+    IDC.fail('invalid_argument', field + ' must be ' + max + ' or less.', { value: value });
+  }
+  return value;
+}
+
+function idcGiven(value) {
+  return value !== undefined && value !== null;
+}
+
+/* Zeichenformat ueber den Namen, auch in Formatgruppen; eine gleichnamige Gruppe zaehlt nicht (IDC.styleFromLookup). */
+function idcCharacterStyleByName(doc, name) {
+  var style, all, i;
+  try { all = doc.allCharacterStyles; } catch (e0) { all = null; }
+  try {
+    style = IDC.styleFromLookup(doc.characterStyles.itemByName(name), all);
+    if (style !== null) { return style; }
+  } catch (e) { /* weiter */ }
+  if (all === null) { return null; }
+  try {
+    for (i = 0; i < all.length; i++) {
+      if (String(all[i].name) === String(name)) { return all[i]; }
+    }
+  } catch (e2) { /* weiter */ }
+  return null;
+}
+
+/*
+ * Formatgruppe dieses Namens auf oberster Ebene, sonst null. InDesign laesst
+ * daneben kein gleichnamiges Format zu ("Es existiert bereits ein Format
+ * dieses Namens", Live-Fund 23.10.2026, A-59) – der Name ist belegt, die
+ * Gruppe selbst aber kein Format, das sich aendern liesse.
+ */
+function idcTopLevelStyleGroup(doc, name, kind) {
+  var groups;
+  /* Schleife statt itemByName: das liefert auch fuer einen Formatnamen einen gueltigen Gruppenverweis (Live-Fund 23.10.2026). */
+  try { groups = kind === 'character' ? doc.characterStyleGroups : doc.paragraphStyleGroups; } catch (e) { return null; }
+  return idcDirectChildByName(groups, name);
+}
+
+/* Name durch eine Gruppe belegt: version weicht aus (true), error und update scheitern mit details.code "style_group_name". */
+function idcGroupNameCollision(doc, name, kind, onCollision) {
+  var group = idcTopLevelStyleGroup(doc, name, kind);
+  var what = kind === 'character' ? 'character' : 'paragraph';
+  if (group === null) { return false; }
+  if (onCollision === 'version') { return true; }
+  IDC.fail('invalid_state', '"' + name + '" is the name of a ' + what + ' style group; InDesign allows no ' + what + ' style of the same name beside it, and a group cannot be ' +
+    (onCollision === 'update' ? 'updated' : 'used') + ' as a style. Choose another name or pass on_collision "version" to add "' + name + ' 2".',
+    { code: 'style_group_name', name: name, group_id: (function () { try { return Number(group.id); } catch (e) { return null; } })() });
+  return false;
+}
+
+/* Alle Absatz- bzw. Zeichenformate als Array, auch aus Gruppen. */
+function idcAllStyles(doc, kind) {
+  var out = [];
+  var all, collection, i;
+  try {
+    all = kind === 'character' ? doc.allCharacterStyles : doc.allParagraphStyles;
+    for (i = 0; i < all.length; i++) { out.push(all[i]); }
+    return out;
+  } catch (e) { /* Rueckfall: nur die oberste Ebene */ }
+  try {
+    collection = kind === 'character' ? doc.characterStyles : doc.paragraphStyles;
+    for (i = 0; i < collection.length; i++) { out.push(collection.item(i)); }
+  } catch (e2) { /* leer */ }
+  return out;
+}
+
+/* Naechster freier Name "Name 2", "Name 3" ... fuer Absatz-/Zeichenformat oder Farbfeld. */
+function idcFreeName(doc, base, kind, container) {
+  var n = 2;
+  var candidate;
+  /* Formatnamen im ganzen Dokument frei, dazu kein Gruppenname auf der Zielebene (container, Vorgabe oberste Ebene). */
+  function groupThere(name) {
+    if (idcPresent(container) && container !== doc) { return idcDirectChildByName(idcGroupsOf(container, kind), name) !== null; }
+    return idcTopLevelStyleGroup(doc, name, kind) !== null;
+  }
+  function taken(name) {
+    if (kind === 'paragraph') { return IDC.paragraphStyleByName(doc, name) !== null || groupThere(name); }
+    if (kind === 'character') { return idcCharacterStyleByName(doc, name) !== null || groupThere(name); }
+    return idcPresent(idcSwatchByName(doc, name));
+  }
+  for (n = 2; n < 1000; n++) {
+    candidate = base + ' ' + n;
+    if (!taken(candidate)) { return candidate; }
+  }
+  IDC.fail('invalid_state', 'No free name found for "' + base + '".', { name: base });
+  return null;
+}
+
+function idcSwatchByName(doc, name) {
+  var swatch = null;
+  try {
+    swatch = doc.swatches.itemByName(String(name));
+    if (swatch && swatch.isValid === true) { return swatch; }
+  } catch (e) { /* weiter */ }
+  return null;
+}
+
+/* Zeichenformat [None]; der Skriptname ist in jeder Sprachfassung "[None]". */
+function idcNoneCharacterStyle(doc) {
+  var style = null;
+  try {
+    style = doc.characterStyles.itemByName('[None]');
+    if (style && style.isValid === true) { return style; }
+  } catch (e) { /* weiter */ }
+  try {
+    style = doc.characterStyles.item(0);
+    if (style && style.isValid === true) { return style; }
+  } catch (e2) { /* weiter */ }
+  return null;
+}
+
+/* Ist ein Zeichenformat das eingebaute [None]? Sein Name ist lokalisiert ("[Ohne]" in der deutschen Fassung, Live-Fund 04.09.2026) – deshalb ueber die ID. */
+function idcIsNoneCharacterStyle(doc, style) {
+  var none = idcNoneCharacterStyle(doc);
+  if (!idcPresent(style) || none === null) { return null; }
+  try { return Number(style.id) === Number(none.id); } catch (e) { /* weiter */ }
+  try { return String(style.name).charAt(0) === '['; } catch (e2) { return null; }
+}
+
+/*
+ * A-68 (1) und (3), Sitzung 81 – Grundlage Probe InDesign 21.6 am 11.11.2026:
+ * ParagraphStyle.gridAlignment (GridAlignment NONE, ALIGN_BASELINE, ...) und
+ * capitalization an Absatz- und Zeichenformaten (Capitalization NORMAL,
+ * SMALL_CAPS, ALL_CAPS, CAP_TO_SMALL_CAP, LOWER_CASE; am neuen Zeichenformat
+ * NothingEnum.NOTHING = nicht festgelegt).
+ */
+var IDC_CAPITALIZATIONS = [
+  ['normal', 'NORMAL'], ['small_caps', 'SMALL_CAPS'], ['all_caps', 'ALL_CAPS'],
+  ['cap_to_small_caps', 'CAP_TO_SMALL_CAP'], ['lower_case', 'LOWER_CASE']
+];
+
+function idcCapitalizationFor(name) {
+  var i, names = [];
+  if (typeof Capitalization === 'undefined') { IDC.fail('invalid_state', 'This runtime has no Capitalization enumeration.', null); }
+  for (i = 0; i < IDC_CAPITALIZATIONS.length; i++) {
+    if (IDC_CAPITALIZATIONS[i][0] === name) { return Capitalization[IDC_CAPITALIZATIONS[i][1]]; }
+    names.push(IDC_CAPITALIZATIONS[i][0]);
+  }
+  IDC.fail('invalid_argument', 'capitalization must be one of ' + names.join(', ') + '.', { value: name });
+  return null;
+}
+
+function idcReadCapitalization(style) {
+  var value, i;
+  try { value = style.capitalization; } catch (e0) { return null; }
+  if (value === undefined || value === null || idcIsNothing(value) || typeof Capitalization === 'undefined') { return null; }
+  for (i = 0; i < IDC_CAPITALIZATIONS.length; i++) {
+    try { if (IDC.enumIs(value, Capitalization[IDC_CAPITALIZATIONS[i][1]])) { return IDC_CAPITALIZATIONS[i][0]; } } catch (e1) { /* weiter */ }
+  }
+  return String(value);
+}
+
+/* true bei Ausrichtung an der Grundlinie, false bei keiner, sonst der Name (Em-Box, ICF – nur ueber InDesign gesetzt). */
+function idcReadGridAlignment(style) {
+  var value;
+  try { value = style.gridAlignment; } catch (e0) { return null; }
+  if (value === undefined || value === null || typeof GridAlignment === 'undefined') { return null; }
+  if (IDC.enumIs(value, GridAlignment.ALIGN_BASELINE)) { return true; }
+  if (IDC.enumIs(value, GridAlignment.NONE)) { return false; }
+  return String(value);
+}
+
+/* Beschreibung eines Absatzformats fuer list_paragraph_styles und debug_inspect_run. */
+function idcDescribeParagraphStyle(style) {
+  var font = idcReadFontLoose(style);
+  var leading = idcReadLeading(style);
+  var id = null, name = null, alignment = null;
+  try { id = Number(style.id); } catch (e1) { id = null; }
+  try { name = String(style.name); } catch (e2) { name = null; }
+  try { alignment = idcJustificationName(style.justification); } catch (e3) { alignment = null; }
+  return {
+    name: name,
+    style_id: id,
+    group: idcStyleGroupPath(style),
+    based_on: idcBasedOnName(style),
+    font_family: font.family,
+    font_style: font.style,
+    point_size: idcReadPt(style, 'pointSize'),
+    leading_pt: leading.pt,
+    leading_auto: leading.auto,
+    fill_swatch: idcReadSwatchName(style, 'fillColor'),
+    alignment: alignment,
+    space_before_pt: idcReadPt(style, 'spaceBefore'),
+    space_after_pt: idcReadPt(style, 'spaceAfter'),
+    hyphenation: idcReadBoolLoose(style, 'hyphenation'),
+    tracking: idcReadNumberLoose(style, 'tracking', 1),
+    /* A-7.1 bis A-7.3 (81-composition.js) */
+    keep_options: idcReadKeepOptions(style),
+    hyphenation_options: idcReadHyphenationOptions(style),
+    justification_options: idcReadJustificationOptions(style),
+    /* Sitzung 10, Demo-Heft-Befund 3 (83-indents-tabs.js) */
+    indents: idcReadIndentTabLanguage(style),
+    /* A-67 Punkt 1, Sitzung 72 (83-drop-caps.js) */
+    drop_cap: idcReadDropCap(style),
+    /* A-68 (1) und (3), Sitzung 81 */
+    align_to_baseline_grid: idcReadGridAlignment(style),
+    capitalization: idcReadCapitalization(style),
+    /* A-79, Sitzung 82 (92-accessibility.js): "" = kein PDF-Tag */
+    pdf_tag: idcReadPdfTag(style)
+  };
+}
+
+/* Beschreibung eines Zeichenformats; nicht gesetzte Attribute sind null. */
+function idcDescribeCharacterStyle(style) {
+  var font = idcReadFontLoose(style);
+  var id = null, name = null;
+  try { id = Number(style.id); } catch (e1) { id = null; }
+  try { name = String(style.name); } catch (e2) { name = null; }
+  return {
+    name: name,
+    style_id: id,
+    group: idcStyleGroupPath(style),
+    based_on: idcBasedOnName(style),
+    font_family: font.family,
+    font_style: font.style,
+    point_size: idcReadPt(style, 'pointSize'),
+    fill_swatch: idcReadSwatchName(style, 'fillColor'),
+    tracking: idcReadNumberLoose(style, 'tracking', 1),
+    /* A-68 (3), Sitzung 81: null, wenn das Zeichenformat die Schreibweise nicht festlegt */
+    capitalization: idcReadCapitalization(style),
+    /* A-79, Sitzung 82 (92-accessibility.js): "" = kein PDF-Tag */
+    pdf_tag: idcReadPdfTag(style)
+  };
+}
+
+/* ------------------------------------------------------------ Schriften */
+
+function idcFontStatusName(status) {
+  if (typeof FontStatus === 'undefined' || idcIsNothing(status)) { return 'installed'; }
+  if (IDC.enumIs(status, FontStatus.INSTALLED)) { return 'installed'; }
+  if (IDC.enumIs(status, FontStatus.SUBSTITUTED)) { return 'substituted'; }
+  if (IDC.enumIs(status, FontStatus.FAUXED)) { return 'substituted'; }
+  if (IDC.enumIs(status, FontStatus.NOT_AVAILABLE)) { return 'not_available'; }
+  if (IDC.enumIs(status, FontStatus.UNKNOWN)) { return 'not_available'; }
+  return 'not_available';
+}
+
+/*
+ * Schriften gezielt aufloesen statt die ganze Schriftliste zu lesen (A-59,
+ * Sitzung 70, E-105). Bei einem Kunden mit sehr vielen aktiven Schriften hing
+ * InDesign an jedem Werkzeug, das die Liste las: app.fonts.item(i) kostet je
+ * Zugriff Zeit proportional zur Schriftzahl (live 26.10.2026, InDesign 21.6:
+ * 22 ms bei 1409, 47 ms bei 4199 Schriften), eine Schleife darueber waechst
+ * quadratisch. Darum: erst itemByName("Familie\tSchnitt"), die Namensliste
+ * nur fuer available_styles und Schreibvarianten – in einem DOM-Aufruf und nie
+ * ueber app.fonts.item(i).
+ */
+
+/* Schrift unter genau diesem Namen, sonst null. itemByName ist auch fuer unbekannte Namen gueltig; erst das Lesen wirft (live 26.10.2026). */
+function idcFontByExactName(name) {
+  var fontObject, family, style, status;
+  try {
+    fontObject = app.fonts.itemByName(name);
+    if (!fontObject || fontObject.isValid !== true) { return null; }
+    family = String(fontObject.fontFamily);
+    style = String(fontObject.fontStyleName);
+    status = idcFontStatusName(fontObject.status);
+  } catch (e) { return null; }
+  return { object: fontObject, family: family, style: style, status: status };
+}
+
+/* Namen aller Schriften als [{ family, style, name }] – ein DOM-Aufruf (name ist "Familie\tSchnitt"). */
+function idcFontNames() {
+  var out = [];
+  var names = null;
+  var all, i, text, tab;
+  try { names = app.fonts.everyItem().name; } catch (e) { names = null; }
+  if (!IDC.isArray(names)) {
+    names = [];
+    try { all = app.fonts.everyItem().getElements(); } catch (e2) { all = []; }
+    for (i = 0; i < all.length; i++) {
+      try { names.push(String(all[i].name)); } catch (e3) { /* Eintrag ohne Namen */ }
+    }
+  }
+  for (i = 0; i < names.length; i++) {
+    text = String(names[i]);
+    tab = text.indexOf('\t');
+    out.push({ family: tab < 0 ? text : text.substr(0, tab), style: tab < 0 ? '' : text.substr(tab + 1), name: text });
+  }
+  return out;
+}
+
+/*
+ * Schriftauskunft eines Aufrufs. find(family, style): { object, family, style,
+ * status } oder null, wenn InDesign die Schrift nicht fuehrt – erst gezielt,
+ * dann ueber die Namensliste (Gross-/Kleinschreibung, Formatzusatz " (OTF)").
+ * stylesOf(family): Schnitte der Familie aus der Namensliste. Die Liste wird
+ * hoechstens einmal je Aufruf gelesen und nur, wenn sie gebraucht wird.
+ */
+function idcFontLookup() {
+  var names = null;
+  function list() {
+    if (names === null) { names = idcFontNames(); }
+    return names;
+  }
+  function find(family, style) {
+    var exact = idcFontByExactName(String(family) + '\t' + String(style));
+    var entries, i, viaList;
+    if (exact !== null && idcSameFamily(exact.family, family) && idcSameText(exact.style, style)) { return exact; }
+    entries = list();
+    for (i = 0; i < entries.length; i++) {
+      if (idcSameFamily(entries[i].family, family) && idcSameText(entries[i].style, style)) {
+        viaList = idcFontByExactName(entries[i].name);
+        if (viaList !== null) { return viaList; }
+        return { object: null, family: entries[i].family, style: entries[i].style, status: 'not_available' };
+      }
+    }
+    return null;
+  }
+  function stylesOf(family) {
+    var out = [];
+    var entries = list();
+    var i;
+    for (i = 0; i < entries.length; i++) {
+      if (idcSameFamily(entries[i].family, family)) { out.push(entries[i].style); }
+    }
+    return out;
+  }
+  function hasFamily(family) {
+    /* itemByName mit der Familie allein liefert ihren ersten Schnitt (live 26.10.2026). */
+    var first = idcFontByExactName(String(family));
+    if (first !== null && idcSameFamily(first.family, family)) { return true; }
+    return stylesOf(family).length > 0;
+  }
+  return { find: find, stylesOf: stylesOf, hasFamily: hasFamily };
+}
+
+function idcSameText(a, b) {
+  return String(a).toLowerCase() === String(b).toLowerCase();
+}
+
+/*
+ * Familienname ohne Formatzusatz: InDesign haengt " (OTF)", " (TT)" oder
+ * " (T1)" an, wenn es eine Familie in mehreren Formaten kennt (Demo-Heft-
+ * Befund 7, 05.09.2026: "Source Sans 3 (OTF)"). Vergleiche von Familiennamen
+ * lassen den Zusatz auf beiden Seiten weg.
+ */
+function idcFamilyKey(name) {
+  return String(name).toLowerCase().replace(/\s*\((otf|tt|t1|ttf|opentype|truetype|type ?1)\)\s*$/, '');
+}
+
+function idcSameFamily(a, b) {
+  return idcFamilyKey(a) === idcFamilyKey(b);
+}
+
+/* Status der im Dokument benutzten Schriften: { "Familie\tSchnitt": status }. */
+function idcDocumentFontStatuses(doc) {
+  var out = {};
+  var i, entry, name, status;
+  try {
+    for (i = 0; i < doc.fonts.length; i++) {
+      entry = doc.fonts.item(i);
+      name = String(entry.name);
+      try { status = idcFontStatusName(entry.status); } catch (e1) { status = 'installed'; }
+      out[name] = status;
+      try {
+        out[String(entry.fontFamily) + '\t' + String(entry.fontStyleName)] = status;
+      } catch (e2) { /* Name reicht */ }
+    }
+  } catch (e) { /* leer */ }
+  return out;
+}
+
+/*
+ * Schrift auf ein Format oder eine Textstelle setzen. Beides: ueber das
+ * Font-Objekt, wenn installiert, sonst als "Familie\tSchnitt" (InDesign fuehrt
+ * sie dann als fehlend). Nur Familie: InDesign behaelt eine unbekannte
+ * Familie stillschweigend – deshalb zuruecklesen.
+ */
+function idcApplyFont(ctx, target, family, styleName, fonts, probe) {
+  var fontObject, text, after, found;
+  var applied = [];
+  var reader = idcPresent(probe) ? probe : target;
+  if (idcGiven(family) && idcGiven(styleName)) {
+    text = String(family) + '\t' + String(styleName);
+    /* Bei installierter Familie ist der Verweis auch fuer einen fehlenden Schnitt gueltig (Live-Fund 23.10.2026, A-59) – nur ein Schnitt, den InDesign fuehrt, zaehlt. */
+    found = fonts.find(family, styleName);
+    fontObject = found !== null && found.status !== 'not_available' ? found.object : null;
+    try {
+      if (fontObject !== null) { target.appliedFont = fontObject; }
+      else { target.appliedFont = text; }
+    } catch (e1) {
+      /* InDesign 21.5: "Die gewuenschte Schriftfamilie ist nicht verfuegbar." – eine fehlende Schrift laesst sich per Skript nicht setzen (Live-Fund 04.09.2026). */
+      IDC.fail('not_found', 'Font "' + String(family) + ' ' + String(styleName) + '" is not installed; InDesign rejects it: ' + String(e1.message ? e1.message : e1),
+        { font_family: family, font_style: styleName, available_styles: fonts.stylesOf(family) });
+    }
+    after = idcReadFontLoose(reader);
+    if (fontObject === null) {
+      if (after.family !== null && !idcSameFamily(after.family, family)) {
+        IDC.fail('not_found', 'Font "' + String(family) + ' ' + String(styleName) + '" is not installed; InDesign kept "' + after.family + ' ' + after.style + '".',
+          { font_family: family, font_style: styleName, available_styles: fonts.stylesOf(family) });
+      }
+      ctx.warn('Font "' + String(family) + ' ' + String(styleName) + '" is not installed; InDesign lists it as missing (fehlende Schrift).');
+    }
+    applied.push('font_family');
+    applied.push('font_style');
+    return applied;
+  }
+  if (idcGiven(family)) {
+    try { target.appliedFont = String(family); } catch (e2) {
+      /* InDesign 21.5 wirft auch bei der Familie allein (Live-Fund 04.09.2026, Suite Lauf 2). */
+      IDC.fail('not_found', 'Font family "' + String(family) + '" is not installed; InDesign rejects it: ' + String(e2.message ? e2.message : e2), { font_family: family });
+    }
+    after = idcReadFontLoose(reader);
+    if (after.family === null || !idcSameFamily(after.family, family)) {
+      IDC.fail('not_found', 'Font family "' + String(family) + '" is not installed; InDesign kept "' + after.family + '". Pass font_style as well to define a missing font on purpose.',
+        { font_family: family });
+    }
+    applied.push('font_family');
+    return applied;
+  }
+  if (idcGiven(styleName)) {
+    var before = idcReadFontLoose(reader);
+    try { target.fontStyle = String(styleName); } catch (e3) {
+      IDC.fail('invalid_argument', 'Font style "' + String(styleName) + '" is not available for "' + before.family + '" – use get_font_info_at_index for the exact style names (e.g. "75 Bold").',
+        { font_style: styleName, font_family: before.family, available_styles: before.family === null ? [] : fonts.stylesOf(before.family) });
+    }
+    after = idcReadFontLoose(reader);
+    if (after.style === null || !idcSameText(after.style, styleName)) {
+      IDC.fail('invalid_argument', 'Font style "' + String(styleName) + '" is not available for "' + before.family + '"; InDesign kept "' + after.style + '" – use get_font_info_at_index for the exact style names.',
+        { font_style: styleName, font_family: before.family, available_styles: before.family === null ? [] : fonts.stylesOf(before.family) });
+    }
+    applied.push('font_style');
+    return applied;
+  }
+  return applied;
+}
+
+/* Gemeinsame Attribute von define_paragraph_style und define_character_style. */
+function idcApplyStyleAttributes(ctx, doc, style, args, created, kind) {
+  var applied = [];
+  var fontApplied, leading, swatch, hex;
+
+  if (idcGiven(args.font_family) || idcGiven(args.font_style)) {
+    fontApplied = idcApplyFont(ctx, style, args.font_family, args.font_style, idcFontLookup());
+    applied = applied.concat(fontApplied);
+  }
+  if (kind === 'paragraph' && idcGiven(args.size_pt)) {
+    idcNumberArg(args.size_pt, 'size_pt', 0.1, 1296);
+    IDC.inPoints(function () { style.pointSize = args.size_pt; });
+    applied.push('size_pt');
+  }
+  if (kind === 'character' && idcGiven(args.point_size)) {
+    idcNumberArg(args.point_size, 'point_size', 0.1, 1296);
+    IDC.inPoints(function () { style.pointSize = args.point_size; });
+    applied.push('point_size');
+  }
+  if (idcGiven(args.leading_pt)) {
+    leading = args.leading_pt;
+    if (leading === 'auto') {
+      if (typeof Leading === 'undefined') { IDC.fail('invalid_state', 'This runtime has no Leading enumeration.', null); }
+      style.leading = Leading.AUTO;
+    } else {
+      idcNumberArg(leading, 'leading_pt', 0, 5000);
+      IDC.inPoints(function () { style.leading = leading; });
+    }
+    applied.push('leading_pt');
+  }
+  if (idcGiven(args.alignment)) {
+    style.justification = idcJustificationFor(args.alignment, 'alignment');
+    applied.push('alignment');
+  }
+  hex = kind === 'paragraph' ? args.color_hex : args.fill_hex;
+  /* A-9.3: swatch_name setzt ein vorhandenes Farbfeld (CMYK, Vollton, Ton, Verlauf) statt ueber Hex ein RGB-Feld anzulegen. */
+  if (idcGiven(hex) && idcGiven(args.swatch_name)) {
+    IDC.fail('invalid_argument', 'Pass either ' + (kind === 'paragraph' ? 'color_hex' : 'fill_hex') + ' or swatch_name, not both.', null);
+  }
+  if (idcGiven(hex)) {
+    swatch = idcSwatchForHex(doc, hex, kind === 'paragraph' ? 'color_hex' : 'fill_hex', created);
+    style.fillColor = swatch;
+    applied.push(kind === 'paragraph' ? 'color_hex' : 'fill_hex');
+  }
+  if (idcGiven(args.swatch_name)) {
+    swatch = idcSwatchArg(doc, args.swatch_name, 'swatch_name');
+    style.fillColor = swatch;
+    applied.push('fill_swatch');
+  }
+  if (idcGiven(args.space_before_pt)) {
+    idcNumberArg(args.space_before_pt, 'space_before_pt', 0, 8640);
+    IDC.inPoints(function () { style.spaceBefore = args.space_before_pt; });
+    applied.push('space_before_pt');
+  }
+  if (idcGiven(args.space_after_pt)) {
+    idcNumberArg(args.space_after_pt, 'space_after_pt', 0, 8640);
+    IDC.inPoints(function () { style.spaceAfter = args.space_after_pt; });
+    applied.push('space_after_pt');
+  }
+  if (idcGiven(args.tracking)) {
+    idcNumberArg(args.tracking, 'tracking', -1000, 10000);
+    style.tracking = args.tracking;
+    applied.push('tracking');
+  }
+  if (idcGiven(args.hyphenation)) {
+    if (typeof args.hyphenation !== 'boolean') { IDC.fail('invalid_argument', 'hyphenation must be true or false.', { value: args.hyphenation }); }
+    style.hyphenation = args.hyphenation;
+    applied.push('hyphenation');
+  }
+  if (idcGiven(args.capitalization)) {
+    style.capitalization = idcCapitalizationFor(args.capitalization);
+    applied.push('capitalization');
+  }
+  if (kind === 'paragraph' && idcGiven(args.align_to_baseline_grid)) {
+    if (typeof args.align_to_baseline_grid !== 'boolean') {
+      IDC.fail('invalid_argument', 'align_to_baseline_grid must be true or false.', { value: args.align_to_baseline_grid });
+    }
+    if (typeof GridAlignment === 'undefined') { IDC.fail('invalid_state', 'This runtime has no GridAlignment enumeration.', null); }
+    style.gridAlignment = args.align_to_baseline_grid ? GridAlignment.ALIGN_BASELINE : GridAlignment.NONE;
+    applied.push('align_to_baseline_grid');
+  }
+  /* A-79, Sitzung 82 (E-117 Nachtrag 1): PDF-Tag des Formats */
+  if (idcGiven(args.pdf_tag)) {
+    idcApplyPdfTag(style, args.pdf_tag);
+    applied.push('pdf_tag');
+  }
+  if (kind === 'paragraph') {
+    applied = applied.concat(idcApplyCompositionOptions(style, args));
+    applied = applied.concat(idcApplyIndentTabLanguage(doc, style, args, ctx));
+    if (idcGiven(args.drop_cap)) { applied = applied.concat(idcApplyDropCap(style, idcDropCapArg(doc, args.drop_cap))); }
+  }
+  return applied;
+}
+
+/*
+ * Farbfelder wieder entfernen, die dieser Aufruf angelegt hat (Ruecknahme).
+ * Nur ueber die ID, damit kein gleichnamiges Farbfeld des Hefts getroffen wird.
+ */
+function idcRemoveSwatchesById(doc, ids) {
+  var i, j, swatch, id;
+  if (!ids || ids.length === 0) { return; }
+  for (i = 0; i < ids.length; i++) {
+    id = Number(ids[i]);
+    for (j = doc.swatches.length - 1; j >= 0; j--) {
+      swatch = doc.swatches.item(j);
+      try {
+        if (Number(swatch.id) === id) { swatch.remove(); break; }
+      } catch (e) { /* naechstes */ }
+    }
+  }
+}
+
+/* ---------------------------------------------------- list_paragraph_styles */
+
+IDC.register('list_paragraph_styles', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var doc = ctx.doc;
+    var styles = [];
+    var characterStyles = [];
+    var internal = 0;
+    var all, i, entry, name;
+
+    all = idcAllStyles(doc, 'paragraph');
+    for (i = 0; i < all.length; i++) {
+      try { name = String(all[i].name); } catch (e1) { continue; }
+      if (name.charAt(0) === '[') { internal += 1; continue; }
+      entry = idcDescribeParagraphStyle(all[i]);
+      styles.push(entry);
+    }
+    all = idcAllStyles(doc, 'character');
+    for (i = 0; i < all.length; i++) {
+      try { name = String(all[i].name); } catch (e2) { continue; }
+      if (name.charAt(0) === '[') { internal += 1; continue; }
+      characterStyles.push(idcDescribeCharacterStyle(all[i]));
+    }
+    return {
+      styles: styles,
+      count: styles.length,
+      character_styles: characterStyles,
+      character_style_count: characterStyles.length,
+      internal_styles_excluded: internal
+    };
+  });
+
+/* ------------------------------------------- Elternformat und Formatgruppe (A-60) */
+
+/*
+ * Direktes Kind einer Sammlung (Formate oder Gruppen einer Ebene) ueber den
+ * Namen – per Schleife, nie per itemByName: InDesign liefert dort fuer den
+ * Namen eines Formats auch einen gueltigen Gruppenverweis und umgekehrt,
+ * auf jeder Ebene (Live-Fund 23.10.2026, Sitzungen 66 und 67).
+ */
+function idcDirectChildByName(collection, name) {
+  var i, item;
+  try {
+    for (i = 0; i < collection.length; i++) {
+      item = collection.item(i);
+      if (String(item.name) === String(name)) { return item; }
+    }
+  } catch (e) { /* leer */ }
+  return null;
+}
+
+function idcStylesOf(container, kind) {
+  return kind === 'character' ? container.characterStyles : container.paragraphStyles;
+}
+
+function idcGroupsOf(container, kind) {
+  return kind === 'character' ? container.characterStyleGroups : container.paragraphStyleGroups;
+}
+
+/* group: "A/B" oder ["A", "B"] – Liste der Gruppennamen, [] = oberste Ebene, null = nicht angegeben. */
+function idcGroupPathArg(value) {
+  var parts, i, out = [];
+  if (!idcGiven(value)) { return null; }
+  if (typeof value === 'string') {
+    if (value === '') { return []; }
+    parts = value.split('/');
+  } else if (IDC.isArray(value)) {
+    parts = value;
+  } else {
+    IDC.fail('invalid_argument', 'group must be a path such as "Headings/Main" or a list of group names.', { value: value });
+  }
+  for (i = 0; i < parts.length; i++) {
+    if (typeof parts[i] !== 'string' || parts[i].length === 0) {
+      IDC.fail('invalid_argument', 'group contains an empty group name – write "Headings/Main" without leading, trailing or double "/", or pass a list of names.', { value: value });
+    }
+    out.push(parts[i]);
+  }
+  return out;
+}
+
+/* Vorhandene Gruppe zum Pfad, ohne etwas anzulegen; null, wenn ein Glied fehlt. */
+function idcFindGroup(doc, segments, kind) {
+  var container = doc;
+  var i;
+  for (i = 0; i < segments.length; i++) {
+    container = idcDirectChildByName(idcGroupsOf(container, kind), segments[i]);
+    if (container === null) { return null; }
+  }
+  return container;
+}
+
+function idcGroupNameClash(segments, index, kind) {
+  var what = kind === 'character' ? 'character' : 'paragraph';
+  IDC.fail('invalid_state', 'Cannot create the ' + what + ' style group "' + segments[index] + '": a ' + what + ' style of that name exists at the same level, and InDesign allows no group of the same name beside it. Choose another group name.',
+    { code: 'style_group_name', group: segments.slice(0, index + 1).join('/') });
+}
+
+/* Gruppenpfad anlegen, wo er fehlt; neu angelegte Gruppen landen in created (fuer die Ruecknahme). */
+function idcEnsureGroup(doc, segments, kind, created) {
+  var container = doc;
+  var i, next;
+  for (i = 0; i < segments.length; i++) {
+    next = idcDirectChildByName(idcGroupsOf(container, kind), segments[i]);
+    if (next === null) {
+      if (idcDirectChildByName(idcStylesOf(container, kind), segments[i]) !== null) { idcGroupNameClash(segments, i, kind); }
+      try {
+        next = idcGroupsOf(container, kind).add({ name: segments[i] });
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not create the style group "' + segments[i] + '": ' + String(e.message ? e.message : e), { group: segments.slice(0, i + 1).join('/') });
+      }
+      created.push(next);
+    }
+    container = next;
+  }
+  return container;
+}
+
+/* Alle Formate dieser Art mit genau diesem Namen (Gruppen eingeschlossen). */
+function idcStylesNamed(doc, name, kind) {
+  var all = idcAllStyles(doc, kind);
+  var out = [];
+  var i;
+  for (i = 0; i < all.length; i++) {
+    try { if (String(all[i].name) === String(name)) { out.push(all[i]); } } catch (e) { /* naechstes */ }
+  }
+  return out;
+}
+
+/*
+ * Elternformat zu based_on: zuerst als Pfad "Gruppe/Format", dann als Name
+ * (wie die Anwende-Werkzeuge). Die internen Wurzeln auch unter ihrem
+ * Skriptnamen, den die deutsche Fassung ueber itemByName nicht findet
+ * (Live-Fund 23.10.2026): "[No Paragraph Style]", "[Basic Paragraph]", "[None]".
+ */
+function idcParentStyleArg(ctx, doc, value, kind) {
+  var parts, group, found, named;
+  if (typeof value !== 'string' || value.length === 0) {
+    IDC.fail('invalid_argument', 'based_on must be the name of an existing style.', { value: value });
+  }
+  if (kind === 'paragraph' && value === '[No Paragraph Style]') { return doc.paragraphStyles.item(0); }
+  if (kind === 'paragraph' && value === '[Basic Paragraph]') { return doc.paragraphStyles.item(1); }
+  if (kind === 'character' && value === '[None]') { return idcNoneCharacterStyle(doc); }
+  if (value.indexOf('/') > 0) {
+    parts = value.split('/');
+    group = idcFindGroup(doc, parts.slice(0, parts.length - 1), kind);
+    if (group !== null) {
+      found = idcDirectChildByName(idcStylesOf(group, kind), parts[parts.length - 1]);
+      if (found !== null) { return found; }
+    }
+  }
+  found = kind === 'character' ? idcCharacterStyleByName(doc, value) : IDC.paragraphStyleByName(doc, value);
+  if (found === null) {
+    IDC.fail('not_found', (kind === 'character' ? 'Character' : 'Paragraph') + ' style "' + value + '" for based_on not found – ' +
+      (kind === 'character' ? 'list_paragraph_styles lists the character styles; "[None]" is the root.' : 'list_paragraph_styles shows the names; "[Basic Paragraph]" and "[No Paragraph Style]" are the built-in ones.') +
+      ' A style in a group can be named as "Group/Style".', { code: 'based_on_not_found', based_on: value });
+  }
+  named = idcStylesNamed(doc, value, kind);
+  if (named.length > 1) {
+    ctx.warn('Several ' + kind + ' styles are named "' + value + '"; based_on took the one in "' + idcStyleGroupPath(found) + '" (top level when empty) – pass "Group/Style" to choose another.');
+  }
+  return found;
+}
+
+/* Zirkel: Liegt style schon in der Kette ueber parent (oder ist es selbst)? InDesign lehnt das ab (Live-Fund 23.10.2026). */
+function idcBasedOnCycle(style, parent) {
+  var current = parent;
+  var target, step, id;
+  try { target = Number(style.id); } catch (e) { return false; }
+  for (step = 0; step < 100; step++) {
+    if (!idcPresent(current)) { return false; }
+    try { id = Number(current.id); } catch (e1) { return false; }
+    if (isNaN(id)) { return false; }
+    if (id === target) { return true; }
+    try { current = current.basedOn; } catch (e2) { return false; }
+    if (typeof current === 'string' || idcIsNothing(current)) { return false; }
+  }
+  return false;
+}
+
+/* --------------------------------------- define_paragraph_style / define_character_style */
+
+function idcDefineStyle(ctx, kind) {
+  var args = ctx.args;
+  var doc = ctx.doc;
+  var what = kind === 'character' ? 'Character' : 'Paragraph';
+  var name = idcStyleNameArg(args.name, 'name');
+  var onCollision = idcCollisionArg(args.on_collision);
+  var segments = idcGroupPathArg(args.group);
+  var parent = null;
+  var container = doc;
+  var existing, clash, elsewhere, i;
+  var collision = 'none';
+  var chosenName = name;
+  var createdSwatches = [];
+  var createdGroups = [];
+  var style = null;
+  var isNew = false;
+  var applied = [];
+  var changes, groupIds;
+
+  if (kind === 'character' && !idcGiven(args.font_family) && !idcGiven(args.font_style) && !idcGiven(args.point_size) && !idcGiven(args.fill_hex) && !idcGiven(args.swatch_name) && !idcGiven(args.tracking) && !idcGiven(args.based_on) && !idcGiven(args.capitalization) && !idcGiven(args.pdf_tag)) {
+    IDC.fail('invalid_argument', 'At least one attribute is required: font_family, font_style, point_size, fill_hex, swatch_name, tracking, capitalization, pdf_tag or based_on.', null);
+  }
+  /* A-68 (3): Schreibweise vor jeder Aenderung pruefen. */
+  if (idcGiven(args.capitalization)) { idcCapitalizationFor(args.capitalization); }
+  if (idcGiven(args.pdf_tag)) { idcPdfTagArg(args.pdf_tag); }
+  if (idcGiven(args.based_on)) { parent = idcParentStyleArg(ctx, doc, args.based_on, kind); }
+
+  if (segments === null) {
+    /* Ohne group wie bis 1.0.2: Name im ganzen Dokument, Gruppenname auf oberster Ebene. */
+    existing = kind === 'character' ? idcCharacterStyleByName(doc, name) : IDC.paragraphStyleByName(doc, name);
+  } else {
+    /* Mit group: Formate und Gruppen dieser einen Ebene; eine noch fehlende Gruppe hat keine. */
+    container = segments.length === 0 ? doc : idcFindGroup(doc, segments, kind);
+    existing = container === null ? null : idcDirectChildByName(idcStylesOf(container, kind), name);
+  }
+
+  if (existing !== null) {
+    if (onCollision === 'error') {
+      IDC.fail('invalid_state', what + ' style "' + name + '" exists already. Pass on_collision "update" to change it or "version" to add "' + name + ' 2".',
+        { name: name, style_id: (function () { try { return Number(existing.id); } catch (e) { return null; } })() });
+    }
+    if (onCollision === 'update') {
+      style = existing;
+      collision = 'updated';
+    } else {
+      chosenName = idcFreeName(doc, name, kind, container);
+      collision = 'versioned';
+    }
+  } else if (segments === null) {
+    if (idcGroupNameCollision(doc, name, kind, onCollision)) {
+      chosenName = idcFreeName(doc, name, kind, doc);
+      collision = 'versioned';
+    }
+  } else if (container !== null) {
+    clash = idcDirectChildByName(idcGroupsOf(container, kind), name);
+    if (clash !== null) {
+      if (onCollision !== 'version') {
+        IDC.fail('invalid_state', '"' + name + '" is the name of a ' + kind + ' style group in "' + segments.join('/') + '"; InDesign allows no ' + kind + ' style of the same name beside it. Choose another name or pass on_collision "version" to add "' + name + ' 2".',
+          { code: 'style_group_name', name: name, group_id: (function () { try { return Number(clash.id); } catch (e) { return null; } })() });
+      }
+      chosenName = idcFreeName(doc, name, kind, container);
+      collision = 'versioned';
+    }
+  }
+  if (segments !== null && collision !== 'updated') {
+    elsewhere = idcStylesNamed(doc, chosenName, kind);
+    if (elsewhere.length > 0) {
+      ctx.warn('A ' + kind + ' style "' + chosenName + '" exists in "' + idcStyleGroupPath(elsewhere[0]) + '" (top level when empty) as well; tools that take a style name use the first match – keep names unique where you can.');
+    }
+  }
+  if (style !== null && parent !== null && idcBasedOnCycle(style, parent)) {
+    IDC.fail('invalid_state', what + ' style "' + name + '" cannot be based on "' + args.based_on + '": that style is "' + name + '" itself or based on it (circular based-on).',
+      { code: 'based_on_cycle', name: name, based_on: args.based_on });
+  }
+
+  try {
+    if (style === null) {
+      if (segments !== null && container === null) { container = idcEnsureGroup(doc, segments, kind, createdGroups); }
+      try {
+        style = idcStylesOf(container, kind).add({ name: chosenName });
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not create the ' + kind + ' style "' + chosenName + '": ' + String(e.message ? e.message : e), { name: chosenName });
+      }
+      isNew = true;
+    }
+    if (parent !== null) {
+      try {
+        style.basedOn = parent;
+      } catch (e3) {
+        IDC.fail('invalid_state', 'InDesign rejects "' + args.based_on + '" as based_on for "' + chosenName + '": ' + String(e3.message ? e3.message : e3), { code: 'based_on_rejected', based_on: args.based_on });
+      }
+      applied.push('based_on');
+    }
+    if (segments !== null && isNew) { applied.push('group'); }
+    applied = applied.concat(idcApplyStyleAttributes(ctx, doc, style, args, createdSwatches, kind));
+  } catch (err) {
+    /* Nichts Halbfertiges (E-46): neues Format, neue Farbfelder und neue Gruppen wieder weg; ein mit update geaendertes Format bleibt. */
+    if (isNew && style !== null) {
+      try { style.remove(); } catch (e4) { /* bleibt stehen */ }
+    }
+    try { idcRemoveSwatchesById(doc, createdSwatches); } catch (e5) { /* bleibt stehen */ }
+    for (i = createdGroups.length - 1; i >= 0; i--) {
+      try { createdGroups[i].remove(); } catch (e6) { /* bleibt stehen */ }
+    }
+    throw err;
+  }
+
+  changes = collision === 'updated'
+    ? { modified_style_ids: [Number(style.id)] }
+    : { created_style_ids: [Number(style.id)] };
+  if (createdSwatches.length > 0) { changes.created_swatch_ids = createdSwatches; }
+  groupIds = [];
+  for (i = 0; i < createdGroups.length; i++) {
+    try { groupIds.push(Number(createdGroups[i].id)); } catch (e7) { /* ohne ID */ }
+  }
+  if (groupIds.length > 0) { changes.created_group_ids = groupIds; }
+  ctx.changes = changes;
+  return {
+    style_id: Number(style.id),
+    name: String(style.name),
+    collision: collision,
+    existed: existing !== null || collision === 'versioned',
+    applied: applied,
+    based_on: idcBasedOnName(style),
+    group: idcStyleGroupPath(style),
+    created_groups: (function () {
+      var paths = [];
+      var k;
+      for (k = 0; k < createdGroups.length; k++) { paths.push(segments.slice(0, segments.length - createdGroups.length + k + 1).join('/')); }
+      return paths;
+    })(),
+    definition: kind === 'character' ? idcDescribeCharacterStyle(style) : idcDescribeParagraphStyle(style)
+  };
+}
+
+IDC.register('define_paragraph_style', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) { return idcDefineStyle(ctx, 'paragraph'); });
+
+IDC.register('define_character_style', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) { return idcDefineStyle(ctx, 'character'); });
+
+/* --------------------------------------------------------- Zeichenbereiche */
+
+/*
+ * Zeichenbereich [start_index, end_index) einer Story wie in Bereich G:
+ * start einschliesslich, end ausschliesslich, beide aus get_frame_text.
+ * Liefert { start, end, text } mit text = characters.itemByRange(start, end - 1).
+ */
+function idcRangeArg(story, args, allowEmpty) {
+  var start = args.start_index;
+  var end = args.end_index;
+  var length = 0;
+  var text;
+  if (typeof start !== 'number' || Math.floor(start) !== start || start < 0) {
+    IDC.fail('invalid_argument', 'start_index must be a whole number of 0 or more (inclusive).', { start_index: start });
+  }
+  if (typeof end !== 'number' || Math.floor(end) !== end || end < start) {
+    IDC.fail('invalid_argument', 'end_index must be a whole number not smaller than start_index (exclusive).', { start_index: start, end_index: end });
+  }
+  try { length = Number(story.characters.length); } catch (e0) { length = 0; }
+  if (end > length) {
+    IDC.fail('invalid_argument', 'end_index ' + end + ' exceeds the story length ' + length + '.', { end_index: end, story_length: length });
+  }
+  if (end === start && allowEmpty !== true) {
+    IDC.fail('invalid_argument', 'The range is empty (start_index equals end_index); formatting needs at least one character.', { start_index: start, end_index: end });
+  }
+  try {
+    text = story.characters.itemByRange(start, end - 1);
+  } catch (e) {
+    IDC.fail('script_error', 'InDesign could not address characters ' + start + '–' + end + ': ' + String(e.message ? e.message : e),
+      { start_index: start, end_index: end });
+  }
+  return { start: start, end: end, text: text };
+}
+
+/* Erstes Zeichen eines Bereichs (fuer Gegenproben). */
+function idcFirstCharacter(story, index) {
+  try { return story.characters.item(index); } catch (e) { return null; }
+}
+
+/*
+ * Absatzformat sauber zuweisen: Format mit "Abweichungen loeschen", danach
+ * Zeichenformat [None], alle lokalen Abweichungen weg, Format noch einmal.
+ * So stimmt nicht nur der Formatname, sondern auch der Druck.
+ */
+function idcApplyParagraphStyleClean(doc, textObject, style, clearOverrides) {
+  var none;
+  try {
+    textObject.applyParagraphStyle(style, clearOverrides === true);
+  } catch (e) {
+    textObject.appliedParagraphStyle = style;
+  }
+  if (clearOverrides !== true) { return; }
+  none = idcNoneCharacterStyle(doc);
+  if (none !== null) {
+    try { textObject.applyCharacterStyle(none); } catch (e1) {
+      try { textObject.appliedCharacterStyle = none; } catch (e1b) { /* dann bleibt es */ }
+    }
+  }
+  try {
+    if (typeof OverrideType !== 'undefined') { textObject.clearOverrides(OverrideType.ALL); }
+    else { textObject.clearOverrides(); }
+  } catch (e2) { /* nicht ueberall vorhanden */ }
+  try {
+    textObject.applyParagraphStyle(style, true);
+  } catch (e3) {
+    textObject.appliedParagraphStyle = style;
+  }
+}
+
+function idcParagraphStyleArg(doc, name, field) {
+  var style;
+  if (typeof name !== 'string' || name.length === 0) {
+    IDC.fail('invalid_argument', field + ' is required.', null);
+  }
+  style = IDC.paragraphStyleByName(doc, name);
+  if (style === null) {
+    IDC.fail('not_found', 'Paragraph style "' + name + '" not found – list_paragraph_styles shows the names (groups as "Gruppe/Name" are matched by the style name alone).',
+      { style_name: name });
+  }
+  return style;
+}
+
+/* Absaetze der Story (als Array), die den Zeichenbereich [start, end) beruehren. */
+function idcStoryParagraphsInRange(story, start, end) {
+  var out = [];
+  var i, p, position = 0, length;
+  try {
+    for (i = 0; i < story.paragraphs.length; i++) {
+      p = story.paragraphs.item(i);
+      try { length = Number(p.characters.length); } catch (e1) { length = 0; }
+      if (position < end && position + length > start) { out.push(p); }
+      position += length;
+      if (position >= end) { break; }
+    }
+  } catch (e) { /* was da ist */ }
+  return out;
+}
+
+function idcParagraphStart(paragraph) {
+  try { return Number(paragraph.characters.item(0).index); } catch (e) { return null; }
+}
+
+function idcParagraphEnd(paragraph) {
+  var start = idcParagraphStart(paragraph);
+  if (start === null) { return null; }
+  try { return start + Number(paragraph.characters.length); } catch (e) { return null; }
+}
+
+/* ---------------------------------------------------- apply_paragraph_style */
+
+IDC.register('apply_paragraph_style', { 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 style = idcParagraphStyleArg(doc, args.style_name, 'style_name');
+    var clear = args.clear_overrides !== false;
+    var paragraphs, count = 0, i, threaded;
+
+    idcRejectStoryLocked(idcContentStoryOf(frame), Number(frame.id), 'apply_paragraph_style');
+
+    try {
+      paragraphs = frame.paragraphs;
+      count = Number(paragraphs.length);
+    } catch (e0) { count = 0; }
+    if (count === 0) {
+      ctx.warn('The frame holds no text; nothing was formatted.');
+      return { frame_id: Number(frame.id), style_applied: String(style.name), affected_paragraphs: 0, overrides_cleared: clear, threaded: idcIsThreaded(frame) };
+    }
+    try {
+      for (i = 0; i < count; i++) {
+        idcApplyParagraphStyleClean(doc, paragraphs.item(i), style, clear);
+      }
+    } catch (e) {
+      IDC.fail('script_error', 'InDesign could not apply the paragraph style "' + args.style_name + '" to frame ' + args.frame_id + ': ' + String(e.message ? e.message : e),
+        { frame_id: args.frame_id, style_name: args.style_name, paragraphs_done: i });
+    }
+    threaded = idcIsThreaded(frame);
+    if (threaded) {
+      ctx.warn('The frame is threaded (verkettet): only the ' + count + ' paragraph(s) touching this frame were formatted – use apply_paragraph_style_to_range over the whole story for the rest.');
+    }
+    if (!clear) {
+      ctx.warn('clear_overrides is false: local character formatting and character styles stay in place – the style name is right, the print may not be.');
+    }
+    ctx.changes = { modified_frame_ids: [Number(frame.id)] };
+    return {
+      frame_id: Number(frame.id),
+      style_applied: String(style.name),
+      affected_paragraphs: count,
+      overrides_cleared: clear,
+      threaded: threaded
+    };
+  });
+
+/* ------------------------------------------- apply_paragraph_style_to_range */
+
+IDC.register('apply_paragraph_style_to_range', { 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 style = idcParagraphStyleArg(doc, args.style_name, 'style_name');
+    var range = idcRangeArg(story, args, false);
+    var paragraphs, count = 0, i, first, firstStart = null, lastEnd = null, startChar;
+
+    idcRejectStoryLocked(story, Number(frame.id), 'apply_paragraph_style_to_range');
+
+    startChar = idcFirstCharacter(story, range.start);
+    try {
+      if (startChar !== null && String(startChar.contents).charCodeAt(0) === 13) {
+        ctx.warn('start_index ' + range.start + ' is the paragraph mark of the preceding paragraph – that paragraph is formatted too. Start one character later to leave it alone.');
+      }
+    } catch (e0) { /* egal */ }
+
+    try {
+      paragraphs = range.text.paragraphs;
+      count = Number(paragraphs.length);
+    } catch (e1) {
+      IDC.fail('script_error', 'InDesign could not read the paragraphs of the range: ' + String(e1.message ? e1.message : e1), { start_index: range.start, end_index: range.end });
+    }
+    try {
+      for (i = 0; i < count; i++) {
+        idcApplyParagraphStyleClean(doc, paragraphs.item(i), style, true);
+      }
+    } catch (e) {
+      IDC.fail('script_error', 'InDesign could not apply the paragraph style "' + args.style_name + '": ' + String(e.message ? e.message : e),
+        { frame_id: args.frame_id, style_name: args.style_name, paragraphs_done: i });
+    }
+    if (count > 0) {
+      first = paragraphs.item(0);
+      firstStart = idcParagraphStart(first);
+      lastEnd = idcParagraphEnd(paragraphs.item(count - 1));
+    }
+    ctx.changes = { modified_frame_ids: [Number(frame.id)] };
+    return {
+      frame_id: Number(frame.id),
+      story_id: (function () { try { return Number(story.id); } catch (e2) { return null; } })(),
+      style_applied: String(style.name),
+      affected_paragraphs: count,
+      start_index: range.start,
+      end_index: range.end,
+      first_paragraph_start_index: firstStart,
+      last_paragraph_end_index: lastEnd,
+      overrides_cleared: true
+    };
+  });
+
+/* ------------------------------------------- apply_character_style_to_range */
+
+IDC.register('apply_character_style_to_range', { 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 name = args.character_style_name;
+    var style, range;
+
+    if (typeof name !== 'string' || name.length === 0) {
+      IDC.fail('invalid_argument', 'character_style_name is required.', null);
+    }
+    style = idcCharacterStyleByName(doc, name);
+    if (style === null) {
+      IDC.fail('not_found', 'Character style "' + name + '" not found – define it with define_character_style first; list_paragraph_styles lists the existing ones.',
+        { character_style_name: name });
+    }
+    range = idcRangeArg(story, args, false);
+    idcRejectStoryLocked(story, Number(frame.id), 'apply_character_style_to_range');
+    try {
+      range.text.applyCharacterStyle(style);
+    } catch (e) {
+      try { range.text.appliedCharacterStyle = style; } catch (e2) {
+        IDC.fail('script_error', 'InDesign could not apply the character style "' + name + '": ' + String(e.message ? e.message : e), { character_style_name: name });
+      }
+    }
+    /*
+     * Demo-Heft-Befund 9 (Sitzung 10): die Laufweite des Zeichenformats ersetzt
+     * die des Absatzformats – die wirksame Laufweite am ersten Zeichen zurueckgeben.
+     */
+    var styleTracking = idcReadNumberLoose(style, 'tracking', 1);
+    var effective = null, paragraphTracking = null, firstChar = null, paragraphStyle = null;
+    try { firstChar = idcFirstCharacter(story, range.start); } catch (e3) { firstChar = null; }
+    if (firstChar !== null) {
+      effective = idcReadNumberLoose(firstChar, 'tracking', 1);
+      try { paragraphStyle = firstChar.appliedParagraphStyle; } catch (e4) { paragraphStyle = null; }
+      if (paragraphStyle !== null && paragraphStyle !== undefined) { paragraphTracking = idcReadNumberLoose(paragraphStyle, 'tracking', 1); }
+    }
+    ctx.changes = { modified_frame_ids: [Number(frame.id)] };
+    return {
+      frame_id: Number(frame.id),
+      characters_affected: range.end - range.start,
+      style_applied: String(style.name),
+      start_index: range.start,
+      end_index: range.end,
+      tracking: { effective: effective, character_style: styleTracking, paragraph_style: paragraphTracking }
+    };
+  });
+
+/* ------------------------------------------ apply_character_format_to_range */
+
+IDC.register('apply_character_format_to_range', { 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 applied = [];
+    var range, swatch, first, font, sizeApplied = null, fill = null, lang = null, langRead = null;
+
+    if (!idcGiven(args.font_family) && !idcGiven(args.font_style) && !idcGiven(args.swatch_name) && !idcGiven(args.superscript) &&
+      !idcGiven(args.tracking) && !idcGiven(args.point_size) && !idcGiven(args.language)) {
+      IDC.fail('invalid_argument', 'At least one attribute is required: font_style, swatch_name, superscript, tracking, point_size or language.', null);
+    }
+    range = idcRangeArg(story, args, false);
+    idcRejectStoryLocked(story, Number(frame.id), 'apply_character_format_to_range');
+    /* A-78: Sprache vor jeder Aenderung aufloesen (gleicher Loeser wie define_paragraph_style). */
+    if (idcGiven(args.language)) { lang = idcLanguageArg(doc, args.language, 'language', ctx); }
+
+    if (idcGiven(args.font_family) || idcGiven(args.font_style)) {
+      applied = applied.concat(idcApplyFont(ctx, range.text, args.font_family, args.font_style, idcFontLookup(), idcFirstCharacter(story, range.start)));
+    }
+    if (idcGiven(args.swatch_name)) {
+      swatch = idcSwatchByName(doc, args.swatch_name);
+      if (!idcPresent(swatch)) {
+        IDC.fail('not_found', 'Swatch "' + args.swatch_name + '" not found – create it with create_swatch (names are exact; the built-in ones are "Black", "Paper", "None").',
+          { swatch_name: args.swatch_name });
+      }
+      try { range.text.fillColor = swatch; } catch (e1) {
+        IDC.fail('script_error', 'InDesign could not set the fill colour: ' + String(e1.message ? e1.message : e1), { swatch_name: args.swatch_name });
+      }
+      applied.push('swatch_name');
+    }
+    if (idcGiven(args.superscript)) {
+      if (typeof args.superscript !== 'boolean') { IDC.fail('invalid_argument', 'superscript must be true or false.', { value: args.superscript }); }
+      if (typeof Position === 'undefined') { IDC.fail('invalid_state', 'This runtime has no Position enumeration.', null); }
+      try { range.text.position = args.superscript ? Position.SUPERSCRIPT : Position.NORMAL; } catch (e2) {
+        IDC.fail('script_error', 'InDesign could not set the superscript position: ' + String(e2.message ? e2.message : e2), null);
+      }
+      applied.push('superscript');
+    }
+    if (idcGiven(args.tracking)) {
+      idcNumberArg(args.tracking, 'tracking', -1000, 10000);
+      /* Toleranz nur aus der Serverkonfiguration (tracking_warn_beyond, E-54); ohne Eintrag keine Warnung. */
+      if (typeof args.tracking_warn_beyond === 'number' && isFinite(args.tracking_warn_beyond)
+        && Math.abs(args.tracking) > args.tracking_warn_beyond) {
+        ctx.warn('tracking ' + args.tracking + ' is beyond the configured tolerance of \u00b1' + args.tracking_warn_beyond + ' (tracking_warn_beyond).');
+      }
+      try { range.text.tracking = args.tracking; } catch (e3) {
+        IDC.fail('script_error', 'InDesign could not set the tracking: ' + String(e3.message ? e3.message : e3), null);
+      }
+      applied.push('tracking');
+    }
+    if (idcGiven(args.point_size)) {
+      idcNumberArg(args.point_size, 'point_size', 0.1, 1296);
+      try { IDC.inPoints(function () { range.text.pointSize = args.point_size; }); } catch (e4) {
+        IDC.fail('script_error', 'InDesign could not set the point size: ' + String(e4.message ? e4.message : e4), null);
+      }
+      applied.push('point_size');
+    }
+    if (lang !== null) {
+      try { range.text.appliedLanguage = lang; } catch (e5) {
+        IDC.fail('script_error', 'InDesign could not set the language: ' + String(e5.message ? e5.message : e5), { language: args.language });
+      }
+      applied.push('language');
+    }
+
+    first = idcFirstCharacter(story, range.start);
+    if (first !== null) {
+      sizeApplied = idcReadPt(first, 'pointSize');
+      font = idcReadFontLoose(first);
+      fill = idcReadSwatchName(first, 'fillColor');
+      langRead = idcReadLanguage(first);
+    } else {
+      font = { family: null, style: null };
+    }
+    ctx.changes = { modified_frame_ids: [Number(frame.id)] };
+    return {
+      frame_id: Number(frame.id),
+      start_index: range.start,
+      end_index: range.end,
+      characters_affected: range.end - range.start,
+      applied: applied,
+      point_size_applied: sizeApplied,
+      font_family: font.family,
+      font_style: font.style,
+      fill_color: fill,
+      language: langRead
+    };
+  });
+
+/* ----------------------------------------------------- set_paragraph_options */
+
+IDC.register('set_paragraph_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 justification = null;
+    var paragraphs, count = 0, i, p, range = null, first;
+
+    var dropCap = null;
+    if (!idcGiven(args.alignment) && !idcGiven(args.hyphenation) && !idcGiven(args.no_break) && !idcCompositionGiven(args) && !idcIndentTabLanguageGiven(args) && !idcGiven(args.drop_cap)) {
+      IDC.fail('invalid_argument', 'At least one of alignment, hyphenation, no_break, keep_options, hyphenation_options, justification_options, left_indent_mm, first_line_indent_mm, right_indent_mm, last_line_indent_mm, drop_cap, tab_stops or language is required.', null);
+    }
+    if (idcGiven(args.drop_cap)) { dropCap = idcDropCapArg(doc, args.drop_cap); }
+    if (idcGiven(args.alignment)) {
+      justification = idcJustificationFor(args.alignment, 'alignment');
+      if (String(args.alignment) === 'justify') {
+        IDC.fail('invalid_argument', 'alignment must name the last line: justify_left, justify_center, justify_right or justify_full.', { value: args.alignment });
+      }
+    }
+    if (idcGiven(args.hyphenation) && typeof args.hyphenation !== 'boolean') {
+      IDC.fail('invalid_argument', 'hyphenation must be true or false.', { value: args.hyphenation });
+    }
+    if (idcGiven(args.no_break) && typeof args.no_break !== 'boolean') {
+      IDC.fail('invalid_argument', 'no_break must be true or false.', { value: args.no_break });
+    }
+
+    if (idcGiven(args.start_index) || idcGiven(args.end_index)) {
+      range = idcRangeArg(story, args, false);
+      /*
+       * Nicht range.text.paragraphs: an deren Absaetzen bleibt hyphenation
+       * wirkungslos (Live-Fund 04.09.2026, justification greift). Die
+       * Absaetze der Story, die den Bereich beruehren, verhalten sich wie
+       * frame.paragraphs.
+       */
+      paragraphs = idcStoryParagraphsInRange(story, range.start, range.end);
+      count = paragraphs.length;
+    } else {
+      /*
+       * Nicht frame.paragraphs waehrend der Schleife: Umbruchoptionen schieben
+       * Absaetze in die naechste Spalte oder den Uebersatz, die Rahmensammlung
+       * schrumpft und item(i) wird "Object is invalid" (Live-Fund 05.09.2026).
+       * Deshalb die Absaetze der Story nehmen, die den Rahmenanteil beruehren –
+       * die bleiben gueltig, wohin der Text auch laeuft.
+       */
+      var frameStart = null, frameLength = 0;
+      try { frameLength = Number(frame.characters.length); } catch (e1) { frameLength = 0; }
+      try { if (frameLength > 0) { frameStart = Number(frame.characters.item(0).index); } } catch (e1b) { frameStart = null; }
+      if (frameStart !== null && frameLength > 0) {
+        paragraphs = idcStoryParagraphsInRange(story, frameStart, frameStart + frameLength);
+        count = paragraphs.length;
+        range = { start: frameStart, end: frameStart + frameLength, whole_frame: true };
+      } else {
+        count = 0;
+      }
+    }
+    if (count === 0) {
+      ctx.warn('No paragraphs in the given scope; nothing was changed.');
+      return { frame_id: Number(frame.id), paragraphs_changed: 0, alignment: null, hyphenation: null, no_break: null, changed: [],
+        keep_options: null, hyphenation_options: null, justification_options: null, indents: null, overset: null, drop_cap: null };
+    }
+    /* Die Optionsgruppen zuerst am ersten Absatz pruefen (Fehler vor jeder Aenderung). */
+    var groups = [];
+    var indentFields = [];
+    var dropCapFields = [];
+    try {
+      for (i = 0; i < count; i++) {
+        p = paragraphs[i];
+        if (justification !== null) { p.justification = justification; }
+        if (idcGiven(args.hyphenation)) { p.hyphenation = args.hyphenation; }
+        if (idcGiven(args.no_break)) { p.noBreak = args.no_break; }
+        groups = idcApplyCompositionOptions(p, args);
+        indentFields = idcApplyIndentTabLanguage(doc, p, args, i === 0 ? ctx : null);
+        dropCapFields = idcApplyDropCap(p, dropCap);
+      }
+    } catch (e) {
+      if (e && e.isIdcError) { throw e; }
+      IDC.fail('script_error', 'InDesign could not change the paragraph options: ' + String(e.message ? e.message : e), { frame_id: args.frame_id, paragraphs_done: i });
+    }
+    if (justification !== null) { changed.push('alignment'); }
+    if (idcGiven(args.hyphenation)) { changed.push('hyphenation'); }
+    if (idcGiven(args.no_break)) { changed.push('no_break'); }
+    changed = changed.concat(groups).concat(indentFields).concat(dropCapFields);
+
+    first = paragraphs[0];
+    var composition = idcReadCompositionOptions(first);
+    var overset = null;
+    try { overset = story.overflows === true; } catch (e3) { overset = null; }
+    if (overset === true && groups.length > 0) {
+      ctx.warn('The story overflows after the change – strict keep or justification options can push text out; check get_frame_lines.');
+    }
+    ctx.changes = { modified_frame_ids: [Number(frame.id)] };
+    return {
+      frame_id: Number(frame.id),
+      paragraphs_changed: count,
+      alignment: (function () { try { return idcJustificationName(first.justification); } catch (e2) { return null; } })(),
+      hyphenation: idcReadBoolLoose(first, 'hyphenation'),
+      no_break: idcReadBoolLoose(first, 'noBreak'),
+      changed: changed,
+      scope: range.whole_frame === true ? 'frame' : 'range',
+      start_index: range.whole_frame === true ? null : range.start,
+      end_index: range.whole_frame === true ? null : range.end,
+      keep_options: composition.keep_options,
+      hyphenation_options: composition.hyphenation_options,
+      justification_options: composition.justification_options,
+      indents: idcReadIndentTabLanguage(first),
+      overset: overset,
+      drop_cap: idcReadDropCap(first)
+    };
+  });
+
+/* ---------------------------------------------------- get_font_info_at_index */
+
+IDC.register('get_font_info_at_index', { needs_document: true, read_only: true, 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 index = args.index;
+    var length = 0;
+    var character, font, fonts, found, status, text = null;
+
+    if (typeof index !== 'number' || Math.floor(index) !== index || index < 0) {
+      IDC.fail('invalid_argument', 'index must be a whole number of 0 or more (a story index from get_frame_text).', { index: index });
+    }
+    try { length = Number(story.characters.length); } catch (e0) { length = 0; }
+    if (index >= length) {
+      IDC.fail('invalid_argument', 'index ' + index + ' is beyond the story length ' + length + '.', { index: index, story_length: length });
+    }
+    character = idcFirstCharacter(story, index);
+    if (character === null) {
+      IDC.fail('script_error', 'InDesign could not address character ' + index + '.', { index: index });
+    }
+    font = idcReadFontLoose(character);
+    try { text = String(character.contents); } catch (e1) { text = null; }
+    fonts = idcFontLookup();
+    found = font.family === null ? null : fonts.find(font.family, font.style);
+    status = found === null ? null : found.status;
+    if (status === null && font.family !== null) {
+      status = idcDocumentFontStatuses(doc)[font.family + '\t' + font.style] || 'not_available';
+    }
+    return {
+      frame_id: Number(frame.id),
+      index: index,
+      character: text,
+      font_family: font.family,
+      font_style: font.style,
+      font_status: status,
+      available_styles: font.family === null ? [] : fonts.stylesOf(font.family),
+      point_size: idcReadPt(character, 'pointSize'),
+      paragraph_style: idcReadSwatchName(character, 'appliedParagraphStyle'),
+      character_style: idcReadSwatchName(character, 'appliedCharacterStyle'),
+      character_style_is_none: (function () { try { return idcIsNoneCharacterStyle(doc, character.appliedCharacterStyle); } catch (e2) { return null; } })()
+    };
+  });
+
+/* ----------------------------------------------------------- find_font_usage */
+
+/* Rahmen eines Textlaufs: IDs und Seite des ersten Rahmens. */
+function idcRunFrames(textObject) {
+  var out = { frame_ids: [], page_id: null, page_name: '', is_master: false };
+  var frames, i, frame, landing;
+  try {
+    frames = textObject.parentTextFrames;
+    for (i = 0; i < frames.length; i++) {
+      frame = IDC.concrete(frames[i]);
+      out.frame_ids.push(Number(frame.id));
+      if (i === 0) {
+        landing = IDC.landing(frame);
+        out.page_id = landing.page_id;
+        out.page_name = landing.page_name;
+        out.is_master = IDC.isOnParentSpread(frame);
+      }
+    }
+  } catch (e) { /* Uebersatz ohne Rahmen */ }
+  return out;
+}
+
+/* Liegt eine Story (ueber ihren ersten Rahmen) auf einer Musterseite? */
+function idcStoryOnMaster(story) {
+  var containers, first;
+  try {
+    containers = story.textContainers;
+    if (containers && containers.length > 0) {
+      first = IDC.concrete(containers[0]);
+      return IDC.isOnParentSpread(first);
+    }
+  } catch (e) { /* unbekannt */ }
+  return false;
+}
+
+function idcSnippet(text, max) {
+  /* Absatz-/Zeilenwechsel, Sonderzeichen und das Tabellenzeichen U+0016 (live 05.09.2026) werden Leerzeichen. */
+  var s = String(text).replace(/[\r\n\u000e\u000f\u0010\u0011\u0012\u0016\u0007\u0008]/g, ' ');
+  if (s.length > max) { s = s.substr(0, max) + '...'; }
+  return s.replace(/\s+$/, '');
+}
+
+function idcMergeIds(target, extra) {
+  var i, j, seen;
+  for (i = 0; i < extra.length; i++) {
+    seen = false;
+    for (j = 0; j < target.length; j++) { if (target[j] === extra[i]) { seen = true; break; } }
+    if (!seen) { target.push(extra[i]); }
+  }
+}
+
+IDC.register('find_font_usage', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var wantFamily = idcGiven(args.font_family) ? String(args.font_family) : null;
+    var wantStyle = idcGiven(args.font_style) ? String(args.font_style) : null;
+    var onlyMissing = args.only_missing === true;
+    var includeMasters = args.include_master_pages !== false;
+    var maxOccurrences = 500;
+    var docStatuses = idcDocumentFontStatuses(doc);
+    var fonts = null;
+    var used = {};
+    var usedOrder = [];
+    var occurrences = [];
+    var totalMatching = 0;
+    var storyCount = 0, s, story, storyId, onMaster, ranges, r, run, runs, range, font, key, start, length, frames, snippet, i, entry;
+
+    function statusOf(family, style) {
+      var name = family + '\t' + style;
+      var status = docStatuses[name];
+      var found;
+      if (status !== undefined) { return status; }
+      if (fonts === null) { fonts = idcFontLookup(); }
+      found = fonts.find(family, style);
+      return found === null ? 'not_available' : found.status;
+    }
+
+    function matches(runEntry, status) {
+      if (wantFamily !== null && !idcSameFamily(runEntry.family, wantFamily)) { return false; }
+      if (wantStyle !== null && !idcSameText(runEntry.style, wantStyle)) { return false; }
+      if (onlyMissing && status === 'installed') { return false; }
+      return true;
+    }
+
+    try { storyCount = Number(doc.stories.length); } catch (e0) {
+      IDC.fail('script_error', 'InDesign could not list the stories of the document.', null);
+    }
+
+    for (s = 0; s < storyCount; s++) {
+      story = doc.stories.item(s);
+      try { storyId = Number(story.id); } catch (e1) { storyId = null; }
+      onMaster = idcStoryOnMaster(story);
+      if (onMaster && !includeMasters) { continue; }
+      runs = [];
+      try {
+        ranges = story.textStyleRanges;
+        for (r = 0; r < ranges.length; r++) {
+          range = ranges.item(r);
+          font = idcReadFontLoose(range);
+          if (font.family === null) { continue; }
+          key = font.family + '\t' + (font.style === null ? '' : font.style);
+          try { start = Number(range.index); } catch (e2) { start = null; }
+          try { length = Number(range.characters.length); } catch (e3) { length = 0; }
+          if (start === null) {
+            try { start = Number(range.characters.item(0).index); } catch (e3b) { start = 0; }
+          }
+          frames = idcRunFrames(range);
+          if (runs.length > 0 && runs[runs.length - 1].key === key && runs[runs.length - 1].end === start) {
+            run = runs[runs.length - 1];
+            run.end = start + length;
+            idcMergeIds(run.frame_ids, frames.frame_ids);
+            if (run.page_id === null) { run.page_id = frames.page_id; run.page_name = frames.page_name; }
+            if (run.raw.length < 60) {
+              try { run.raw += String(range.contents); } catch (e4b) { /* bleibt */ }
+            }
+          } else {
+            try { snippet = String(range.contents); } catch (e4) { snippet = ''; }
+            runs.push({
+              key: key, family: font.family, style: font.style === null ? '' : font.style,
+              start: start, end: start + length, raw: snippet,
+              frame_ids: frames.frame_ids, page_id: frames.page_id, page_name: frames.page_name,
+              is_master: onMaster || frames.is_master
+            });
+          }
+        }
+      } catch (e5) {
+        ctx.warn('Story ' + storyId + ' could not be read completely: ' + String(e5.message ? e5.message : e5));
+      }
+      for (i = 0; i < runs.length; i++) {
+        run = runs[i];
+        entry = used[run.key];
+        if (entry === undefined) {
+          entry = { family: run.family, style: run.style, status: statusOf(run.family, run.style), occurrences: 0, characters: 0 };
+          used[run.key] = entry;
+          usedOrder.push(run.key);
+        }
+        entry.occurrences += 1;
+        entry.characters += run.end - run.start;
+        if (matches(run, entry.status)) {
+          totalMatching += 1;
+          if (occurrences.length < maxOccurrences) {
+            occurrences.push({
+              family: run.family, style: run.style, status: entry.status,
+              story_id: storyId, frame_ids: run.frame_ids, page_id: run.page_id, page_name: run.page_name,
+              is_master: run.is_master, start_index: run.start, end_index: run.end, snippet: idcSnippet(run.raw, 60)
+            });
+          }
+        }
+      }
+    }
+
+    var fontsUsed = [];
+    for (i = 0; i < usedOrder.length; i++) { fontsUsed.push(used[usedOrder[i]]); }
+    fontsUsed.sort(function (a, b) {
+      var ka = (a.family + '\t' + a.style).toLowerCase();
+      var kb = (b.family + '\t' + b.style).toLowerCase();
+      return ka < kb ? -1 : (ka > kb ? 1 : 0);
+    });
+    if (totalMatching > maxOccurrences) {
+      ctx.warn('Only the first ' + maxOccurrences + ' of ' + totalMatching + ' matching occurrences are listed.');
+    }
+    return {
+      fonts_used: fontsUsed,
+      occurrences: occurrences,
+      occurrence_count: totalMatching,
+      stories_scanned: storyCount,
+      filter: { font_family: wantFamily, font_style: wantStyle, only_missing: onlyMissing, include_master_pages: includeMasters }
+    };
+  });
+
+/* ----------------------------------------------------------- debug_inspect_run */
+
+function idcFrameScale(frame) {
+  var h = null, v = null;
+  try { h = IDC.round(Number(frame.absoluteHorizontalScale), 3); } catch (e1) { h = null; }
+  try { v = IDC.round(Number(frame.absoluteVerticalScale), 3); } catch (e2) { v = null; }
+  if (h === null) { try { h = IDC.round(Number(frame.horizontalScale), 3); } catch (e3) { h = null; } }
+  if (v === null) { try { v = IDC.round(Number(frame.verticalScale), 3); } catch (e4) { v = null; } }
+  return { horizontal: h, vertical: v };
+}
+
+/* Absatz des Zeichens mit Umbruch-, Trennungs- und Blocksatzoptionen (A-7). */
+function idcInspectParagraph(character) {
+  var paragraph = null;
+  var out;
+  try { paragraph = character.paragraphs.item(0); } catch (e) { paragraph = null; }
+  if (paragraph === null || paragraph === undefined) { return null; }
+  out = idcReadCompositionOptions(paragraph);
+  /* Live 05.09.2026: Paragraph.index ist der Zeichenindex des Absatzanfangs, keine Ordnungszahl – deshalb beides ausdruecklich. */
+  out.start_index = idcParagraphStart(paragraph);
+  out.index = null;
+  try {
+    var story = paragraph.parentStory, ordinal, probe;
+    for (ordinal = 0; ordinal < story.paragraphs.length; ordinal++) {
+      probe = idcParagraphStart(story.paragraphs.item(ordinal));
+      if (probe === out.start_index) { out.index = ordinal; break; }
+      if (probe !== null && probe > out.start_index) { break; }
+    }
+  } catch (e2) { out.index = null; }
+  try { out.alignment = idcJustificationName(paragraph.justification); } catch (e3) { out.alignment = null; }
+  out.hyphenation = idcReadBoolLoose(paragraph, 'hyphenation');
+  return out;
+}
+
+IDC.register('debug_inspect_run', { needs_document: true, read_only: true, 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 index = idcGiven(args.index) ? args.index : 0;
+    var length = 0;
+    var character, font, out, styleInfo = null, all, i, name, hits, kind;
+
+    if (typeof index !== 'number' || Math.floor(index) !== index || index < 0) {
+      IDC.fail('invalid_argument', 'index must be a whole number of 0 or more.', { index: index });
+    }
+    try { length = Number(story.characters.length); } catch (e0) { length = 0; }
+    if (length === 0) {
+      IDC.fail('invalid_state', 'The frame holds no text; there is no character to inspect.', { frame_id: args.frame_id });
+    }
+    if (index >= length) {
+      IDC.fail('invalid_argument', 'index ' + index + ' is beyond the story length ' + length + '.', { index: index, story_length: length });
+    }
+    character = idcFirstCharacter(story, index);
+    font = idcReadFontLoose(character);
+    out = {
+      frame_id: Number(frame.id),
+      index: index,
+      character: (function () { try { return String(character.contents); } catch (e1) { return null; } })(),
+      point_size: idcReadPt(character, 'pointSize'),
+      leading_pt: idcReadLeading(character).pt,
+      leading_auto: idcReadLeading(character).auto,
+      applied_paragraph_style: idcReadSwatchName(character, 'appliedParagraphStyle'),
+      applied_character_style: idcReadSwatchName(character, 'appliedCharacterStyle'),
+      character_style_is_none: (function () { try { return idcIsNoneCharacterStyle(doc, character.appliedCharacterStyle); } catch (e1b) { return null; } })(),
+      fill_color: idcReadSwatchName(character, 'fillColor'),
+      applied_font: font.family,
+      font_style: font.style,
+      tracking: idcReadNumberLoose(character, 'tracking', 1),
+      horizontal_scale: idcReadNumberLoose(character, 'horizontalScale', 3),
+      vertical_scale: idcReadNumberLoose(character, 'verticalScale', 3),
+      style_overridden: idcReadBoolLoose(character, 'styleOverridden'),
+      frame_scale: idcFrameScale(frame),
+      paragraph: idcInspectParagraph(character)
+    };
+
+    if (idcGiven(args.style_name)) {
+      name = String(args.style_name);
+      hits = [];
+      kind = null;
+      all = idcAllStyles(doc, 'paragraph');
+      for (i = 0; i < all.length; i++) {
+        try { if (String(all[i].name) === name) { hits.push(all[i]); } } catch (e2) { /* weiter */ }
+      }
+      if (hits.length > 0) { kind = 'paragraph'; }
+      else {
+        all = idcAllStyles(doc, 'character');
+        for (i = 0; i < all.length; i++) {
+          try { if (String(all[i].name) === name) { hits.push(all[i]); } } catch (e3) { /* weiter */ }
+        }
+        if (hits.length > 0) { kind = 'character'; }
+      }
+      if (hits.length === 0) {
+        styleInfo = { name: name, found: false, kind: null, matches: 0, duplicated: false, nested: false, definition: null, groups: [] };
+      } else {
+        var groups = [];
+        for (i = 0; i < hits.length; i++) { groups.push(idcStyleGroupPath(hits[i])); }
+        styleInfo = {
+          name: name,
+          found: true,
+          kind: kind,
+          matches: hits.length,
+          duplicated: hits.length > 1,
+          nested: groups[0] !== '',
+          groups: groups,
+          definition: kind === 'paragraph' ? idcDescribeParagraphStyle(hits[0]) : idcDescribeCharacterStyle(hits[0])
+        };
+        if (hits.length > 1) {
+          ctx.warn('The style name "' + name + '" occurs ' + hits.length + ' times (in groups: ' + groups.join(', ') + ') – apply by name may pick the wrong one.');
+        }
+      }
+      out.style = styleInfo;
+    }
+    return out;
+  });
+
+/* --------------------------------------------------------------- create_swatch */
+
+function idcCmykArg(spec) {
+  var keys = ['c', 'm', 'y', 'k'];
+  var out = [];
+  var i, v;
+  if (typeof spec !== 'object' || spec === null || IDC.isArray(spec)) {
+    IDC.fail('invalid_argument', 'cmyk must be an object { c, m, y, k } with values 0–100.', { value: spec });
+  }
+  for (i = 0; i < keys.length; i++) {
+    v = spec[keys[i]];
+    if (typeof v !== 'number' || !isFinite(v) || v < 0 || v > 100) {
+      IDC.fail('invalid_argument', 'cmyk.' + keys[i] + ' must be a number from 0 to 100.', { value: v });
+    }
+    out.push(v);
+  }
+  return out;
+}
+
+IDC.register('create_swatch', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var name = args.name;
+    var onCollision = idcCollisionArg(args.on_collision);
+    var hasHex = idcGiven(args.hex);
+    var hasCmyk = idcGiven(args.cmyk);
+    var values, space, spaceName, existing, collision = 'none', chosenName, swatch = null, className;
+    var haveSwatch = false, existed = false;
+
+    if (typeof name !== 'string' || name.length < 1 || name.length > 60) {
+      IDC.fail('invalid_argument', 'name is required (1–60 characters).', { name: name });
+    }
+    if (name.charAt(0) === '[') {
+      IDC.fail('invalid_argument', 'name must not start with "[" – those names are reserved for InDesign\'s built-in swatches.', { name: name });
+    }
+    if (hasHex === hasCmyk) {
+      IDC.fail('invalid_argument', 'Pass exactly one of hex (RGB, e.g. "#1A2B3C") or cmyk ({ c, m, y, k } in percent).', null);
+    }
+    if (hasHex) {
+      var rgb = idcParseHex(args.hex, 'hex');
+      values = [rgb.r, rgb.g, rgb.b];
+      space = ColorSpace.RGB;
+      spaceName = 'rgb';
+    } else {
+      values = idcCmykArg(args.cmyk);
+      space = ColorSpace.CMYK;
+      spaceName = 'cmyk';
+    }
+    chosenName = name;
+    existing = idcSwatchByName(doc, name);
+    existed = idcPresent(existing);
+    if (existed) {
+      if (onCollision === 'error') {
+        IDC.fail('invalid_state', 'Swatch "' + name + '" exists already. Pass on_collision "update" to change it or "version" to add "' + name + ' 2".',
+          { name: name, swatch_id: (function () { try { return Number(existing.id); } catch (e) { return null; } })() });
+      }
+      if (onCollision === 'update') {
+        className = IDC.className(existing);
+        if (className !== 'Color' && className !== 'Swatch') {
+          IDC.fail('invalid_state', 'Swatch "' + name + '" is a ' + className + ', not a colour; it cannot be updated with values.', { name: name, type: className });
+        }
+        swatch = existing;
+        haveSwatch = true;
+        collision = 'updated';
+        try {
+          swatch.model = ColorModel.PROCESS;
+          swatch.space = space;
+          swatch.colorValue = values;
+        } catch (e1) {
+          IDC.fail('script_error', 'InDesign could not update the swatch "' + name + '": ' + String(e1.message ? e1.message : e1), { name: name });
+        }
+      } else {
+        chosenName = idcFreeName(doc, name, 'swatch');
+        collision = 'versioned';
+      }
+    }
+    if (!haveSwatch) {
+      try {
+        /* Colors.add nimmt nur withProperties (Live-Fund Sitzung 3). */
+        swatch = doc.colors.add({ name: chosenName, model: ColorModel.PROCESS, space: space, colorValue: values });
+      } catch (e2) {
+        IDC.fail('script_error', 'InDesign could not create the swatch "' + chosenName + '": ' + String(e2.message ? e2.message : e2), { name: chosenName });
+      }
+    }
+    ctx.changes = collision === 'updated'
+      ? { modified_swatch_ids: [Number(swatch.id)] }
+      : { created_swatch_ids: [Number(swatch.id)] };
+    return {
+      name: String(swatch.name),
+      swatch_id: Number(swatch.id),
+      collision: collision,
+      existed: existed,
+      space: spaceName,
+      values: values
+    };
+  });