layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/80-styles.js

@@ -0,0 +1,1620 @@
+/* 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;
+}
+
+/* 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: idcIsNothing(style) ? null : String(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; }
+  if (read.style === '' || read.style === 'undefined') { read.style = null; }
+  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. */
+function idcCharacterStyleByName(doc, name) {
+  var style, all, i;
+  try {
+    style = doc.characterStyles.itemByName(name);
+    if (style && style.isValid === true) { return style; }
+  } catch (e) { /* weiter */ }
+  try {
+    all = doc.allCharacterStyles;
+    for (i = 0; i < all.length; i++) {
+      if (String(all[i].name) === String(name)) { return all[i]; }
+    }
+  } catch (e2) { /* weiter */ }
+  return null;
+}
+
+/* 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) {
+  var n = 2;
+  var candidate;
+  function taken(name) {
+    if (kind === 'paragraph') { return IDC.paragraphStyleByName(doc, name) !== null; }
+    if (kind === 'character') { return idcCharacterStyleByName(doc, name) !== null; }
+    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; }
+}
+
+/* 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)
+  };
+}
+
+/* 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)
+  };
+}
+
+/* ------------------------------------------------------------ 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';
+}
+
+/*
+ * Alle Schriften, die InDesign kennt: [{ family, style, status }]. Ueber
+ * everyItem() in drei DOM-Aufrufen; faellt auf die Schleife zurueck, wo es
+ * everyItem() nicht gibt.
+ */
+function idcFontCatalogue() {
+  var out = [];
+  var families, styles, statuses, i, entry;
+  try {
+    families = app.fonts.everyItem().fontFamily;
+    styles = app.fonts.everyItem().fontStyleName;
+    statuses = app.fonts.everyItem().status;
+    if (IDC.isArray(families) && families.length === styles.length) {
+      for (i = 0; i < families.length; i++) {
+        out.push({ family: String(families[i]), style: String(styles[i]), status: idcFontStatusName(statuses[i]) });
+      }
+      return out;
+    }
+  } catch (e) { /* Schleife */ }
+  out = [];
+  try {
+    for (i = 0; i < app.fonts.length; i++) {
+      entry = app.fonts.item(i);
+      out.push({ family: String(entry.fontFamily), style: String(entry.fontStyleName), status: idcFontStatusName(entry.status) });
+    }
+  } catch (e2) { /* was da ist */ }
+  return out;
+}
+
+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);
+}
+
+/* Schnitte einer Familie aus dem Katalog. */
+function idcStylesOfFamily(catalogue, family) {
+  var out = [];
+  var i;
+  for (i = 0; i < catalogue.length; i++) {
+    if (idcSameFamily(catalogue[i].family, family)) { out.push(catalogue[i].style); }
+  }
+  return out;
+}
+
+function idcCatalogueStatus(catalogue, family, style) {
+  var i;
+  for (i = 0; i < catalogue.length; i++) {
+    if (idcSameFamily(catalogue[i].family, family) && idcSameText(catalogue[i].style, style)) { return catalogue[i].status; }
+  }
+  return null;
+}
+
+/* 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, catalogue, probe) {
+  var fontObject, text, after;
+  var applied = [];
+  var reader = idcPresent(probe) ? probe : target;
+  if (idcGiven(family) && idcGiven(styleName)) {
+    text = String(family) + '\t' + String(styleName);
+    fontObject = null;
+    try {
+      fontObject = app.fonts.itemByName(text);
+      if (!fontObject || fontObject.isValid !== true) { fontObject = null; }
+    } catch (e0) { fontObject = 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: idcStylesOfFamily(catalogue, 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: idcStylesOfFamily(catalogue, 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 ? [] : idcStylesOfFamily(catalogue, 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 ? [] : idcStylesOfFamily(catalogue, 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 catalogue = null;
+  var fontApplied, leading, swatch, hex;
+
+  if (idcGiven(args.font_family) || idcGiven(args.font_style)) {
+    catalogue = idcFontCatalogue();
+    fontApplied = idcApplyFont(ctx, style, args.font_family, args.font_style, catalogue);
+    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 (kind === 'paragraph') {
+    applied = applied.concat(idcApplyCompositionOptions(style, args));
+    applied = applied.concat(idcApplyIndentTabLanguage(doc, style, args));
+  }
+  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 */ }
+    }
+  }
+}
+
+/*
+ * Attribute setzen, aber nichts Halbfertiges hinterlassen: schlaegt ein
+ * Attribut fehl (etwa eine nicht installierte Schrift), wird das in diesem
+ * Aufruf neu angelegte Format samt seiner neuen Farbfelder wieder entfernt
+ * und der Fehler weitergereicht. Ein mit on_collision "update" veraendertes
+ * Format bleibt stehen – es gehoerte dem Dokument schon vorher.
+ * Live-Fund 04.09.2026 (E-46).
+ */
+function idcApplyStyleAttributesOrRollback(ctx, doc, style, args, created, kind, isNew) {
+  try {
+    return idcApplyStyleAttributes(ctx, doc, style, args, created, kind);
+  } catch (e) {
+    if (isNew) {
+      try { style.remove(); } catch (e1) { /* bleibt stehen */ }
+    }
+    try { idcRemoveSwatchesById(doc, created); } catch (e2) { /* bleibt stehen */ }
+    throw e;
+  }
+}
+
+/* ---------------------------------------------------- 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
+    };
+  });
+
+/* --------------------------------------------------- define_paragraph_style */
+
+IDC.register('define_paragraph_style', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var name = idcStyleNameArg(args.name, 'name');
+    var onCollision = idcCollisionArg(args.on_collision);
+    var existing = IDC.paragraphStyleByName(doc, name);
+    var collision = 'none';
+    var chosenName = name;
+    var createdSwatches = [];
+    var style = null;
+    var applied, changes;
+
+    if (existing !== null) {
+      if (onCollision === 'error') {
+        IDC.fail('invalid_state', 'Paragraph 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, 'paragraph');
+        collision = 'versioned';
+      }
+    }
+    if (style === null) {
+      try {
+        style = doc.paragraphStyles.add({ name: chosenName });
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not create the paragraph style "' + chosenName + '": ' + String(e.message ? e.message : e), { name: chosenName });
+      }
+    }
+    applied = idcApplyStyleAttributesOrRollback(ctx, doc, style, args, createdSwatches, 'paragraph', collision !== 'updated');
+
+    changes = collision === 'updated'
+      ? { modified_style_ids: [Number(style.id)] }
+      : { created_style_ids: [Number(style.id)] };
+    if (createdSwatches.length > 0) { changes.created_swatch_ids = createdSwatches; }
+    ctx.changes = changes;
+    return {
+      style_id: Number(style.id),
+      name: String(style.name),
+      collision: collision,
+      existed: existing !== null,
+      applied: applied,
+      definition: idcDescribeParagraphStyle(style)
+    };
+  });
+
+/* --------------------------------------------------- define_character_style */
+
+IDC.register('define_character_style', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var name = idcStyleNameArg(args.name, 'name');
+    var onCollision = idcCollisionArg(args.on_collision);
+    var existing = idcCharacterStyleByName(doc, name);
+    var collision = 'none';
+    var chosenName = name;
+    var createdSwatches = [];
+    var style = null;
+    var applied, changes;
+
+    if (!idcGiven(args.font_family) && !idcGiven(args.font_style) && !idcGiven(args.point_size) && !idcGiven(args.fill_hex) && !idcGiven(args.swatch_name) && !idcGiven(args.tracking)) {
+      IDC.fail('invalid_argument', 'At least one attribute is required: font_family, font_style, point_size, fill_hex, swatch_name or tracking.', null);
+    }
+    if (existing !== null) {
+      if (onCollision === 'error') {
+        IDC.fail('invalid_state', 'Character 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, 'character');
+        collision = 'versioned';
+      }
+    }
+    if (style === null) {
+      try {
+        style = doc.characterStyles.add({ name: chosenName });
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not create the character style "' + chosenName + '": ' + String(e.message ? e.message : e), { name: chosenName });
+      }
+    }
+    applied = idcApplyStyleAttributesOrRollback(ctx, doc, style, args, createdSwatches, 'character', collision !== 'updated');
+
+    changes = collision === 'updated'
+      ? { modified_style_ids: [Number(style.id)] }
+      : { created_style_ids: [Number(style.id)] };
+    if (createdSwatches.length > 0) { changes.created_swatch_ids = createdSwatches; }
+    ctx.changes = changes;
+    return {
+      style_id: Number(style.id),
+      name: String(style.name),
+      collision: collision,
+      existed: existing !== null,
+      applied: applied,
+      definition: idcDescribeCharacterStyle(style)
+    };
+  });
+
+/* --------------------------------------------------------- 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;
+
+    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;
+
+    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);
+    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, catalogue, swatch, first, font, sizeApplied = null, fill = null;
+
+    if (!idcGiven(args.font_family) && !idcGiven(args.font_style) && !idcGiven(args.swatch_name) && !idcGiven(args.superscript) &&
+      !idcGiven(args.tracking) && !idcGiven(args.point_size)) {
+      IDC.fail('invalid_argument', 'At least one attribute is required: font_style, swatch_name, superscript, tracking or point_size.', null);
+    }
+    range = idcRangeArg(story, args, false);
+
+    if (idcGiven(args.font_family) || idcGiven(args.font_style)) {
+      catalogue = idcFontCatalogue();
+      applied = applied.concat(idcApplyFont(ctx, range.text, args.font_family, args.font_style, catalogue, 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');
+    }
+
+    first = idcFirstCharacter(story, range.start);
+    if (first !== null) {
+      sizeApplied = idcReadPt(first, 'pointSize');
+      font = idcReadFontLoose(first);
+      fill = idcReadSwatchName(first, 'fillColor');
+    } 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
+    };
+  });
+
+/* ----------------------------------------------------- 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;
+
+    if (!idcGiven(args.alignment) && !idcGiven(args.hyphenation) && !idcGiven(args.no_break) && !idcCompositionGiven(args) && !idcIndentTabLanguageGiven(args)) {
+      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, tab_stops or language is required.', null);
+    }
+    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 };
+    }
+    /* Die Optionsgruppen zuerst am ersten Absatz pruefen (Fehler vor jeder Aenderung). */
+    var groups = [];
+    var indentFields = [];
+    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);
+      }
+    } 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);
+
+    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
+    };
+  });
+
+/* ---------------------------------------------------- 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, catalogue, 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; }
+    catalogue = idcFontCatalogue();
+    status = font.family === null ? null : idcCatalogueStatus(catalogue, font.family, font.style);
+    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 ? [] : idcStylesOfFamily(catalogue, 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 catalogue = 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];
+      if (status !== undefined) { return status; }
+      if (catalogue === null) { catalogue = idcFontCatalogue(); }
+      status = idcCatalogueStatus(catalogue, family, style);
+      return status === null ? 'not_available' : 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
+    };
+  });