layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/commands/83-indents-tabs.js

@@ -0,0 +1,237 @@
+/*
+ * Sitzung 10 (Demo-Heft-Befund 3, 05.09.2026) – Einzuege, Tabulatoren und
+ * Sprache fuer Absatzformate (define_paragraph_style) und Absaetze
+ * (set_paragraph_options).
+ *
+ * Adobe-DOM (geprueft 05.09.2026, Klasse Text): leftIndent, rightIndent,
+ * firstLineIndent, lastLineIndent (Masseinheit – hier mm, weil der
+ * Interpreter waehrend eines Befehls auf Millimeter steht); tabStops
+ * (Sammlung, add(withProperties)) mit TabStop.position, alignment
+ * (TabStopAlignment LEFT_ALIGN, CENTER_ALIGN, RIGHT_ALIGN, CHARACTER_ALIGN),
+ * leader, alignmentCharacter; appliedLanguage (Language oder
+ * LanguageWithVendors, nimmt auch String) – Language.name (lokalisiert),
+ * untranslatedName, icuLocaleName; Application.languagesWithVendors,
+ * Document.languages.
+ */
+
+var IDC_INDENT_MAX_MM = 3048; /* 8640 pt, InDesigns Grenze */
+
+function idcIndentArg(value, field, min, max) {
+  if (typeof value !== 'number' || isNaN(value) || value < min || value > max) {
+    IDC.fail('invalid_argument', field + ' must be a number from ' + min + ' to ' + max + ' (mm).', { value: value });
+  }
+  return value;
+}
+
+/* ---------------------------------------------------------- Tabulatoren */
+
+function idcTabAlignmentFor(name, field) {
+  var text = name === undefined || name === null ? 'left' : String(name);
+  if (typeof TabStopAlignment === 'undefined') {
+    IDC.fail('invalid_state', 'This runtime has no TabStopAlignment enumeration.', null);
+  }
+  if (text === 'left') { return TabStopAlignment.LEFT_ALIGN; }
+  if (text === 'center') { return TabStopAlignment.CENTER_ALIGN; }
+  if (text === 'right') { return TabStopAlignment.RIGHT_ALIGN; }
+  if (text === 'character') { return TabStopAlignment.CHARACTER_ALIGN; }
+  IDC.fail('invalid_argument', field + ' must be left, center, right or character.', { value: name });
+  return null;
+}
+
+function idcTabAlignmentName(value) {
+  if (typeof TabStopAlignment === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, TabStopAlignment.LEFT_ALIGN)) { return 'left'; }
+  if (IDC.enumIs(value, TabStopAlignment.CENTER_ALIGN)) { return 'center'; }
+  if (IDC.enumIs(value, TabStopAlignment.RIGHT_ALIGN)) { return 'right'; }
+  if (IDC.enumIs(value, TabStopAlignment.CHARACTER_ALIGN)) { return 'character'; }
+  return String(value);
+}
+
+/* tab_stops[] pruefen und in DOM-Eigenschaften uebersetzen (vor jeder Aenderung). */
+function idcTabStopsArg(list) {
+  var out = [];
+  var i, spec, entry, leader, alignOn;
+  if (!IDC.isArray(list)) {
+    IDC.fail('invalid_argument', 'tab_stops must be an array of {position_mm, alignment, leader, align_on}; [] removes every tab stop.', null);
+  }
+  for (i = 0; i < list.length; i++) {
+    spec = list[i];
+    if (spec === null || typeof spec !== 'object' || IDC.isArray(spec)) {
+      IDC.fail('invalid_argument', 'tab_stops[' + i + '] must be an object {position_mm, alignment, leader, align_on}.', { index: i });
+    }
+    entry = { position: idcIndentArg(spec.position_mm, 'tab_stops[' + i + '].position_mm', 0, IDC_INDENT_MAX_MM) };
+    entry.alignment = idcTabAlignmentFor(spec.alignment, 'tab_stops[' + i + '].alignment');
+    leader = spec.leader === undefined || spec.leader === null ? '' : spec.leader;
+    if (typeof leader !== 'string' || leader.length > 8) {
+      IDC.fail('invalid_argument', 'tab_stops[' + i + '].leader must be a string of up to 8 characters (e.g. ".").', { index: i, value: spec.leader });
+    }
+    entry.leader = leader;
+    alignOn = spec.align_on === undefined || spec.align_on === null ? null : spec.align_on;
+    if (alignOn !== null && (typeof alignOn !== 'string' || alignOn.length !== 1)) {
+      IDC.fail('invalid_argument', 'tab_stops[' + i + '].align_on must be a single character (used with alignment character).', { index: i, value: spec.align_on });
+    }
+    entry.alignmentCharacter = alignOn;
+    out.push(entry);
+  }
+  return out;
+}
+
+/* Alle Tabulatoren eines Ziels entfernen und die Liste neu setzen. */
+function idcSetTabStops(target, entries) {
+  var stops, i, stop, props;
+  stops = target.tabStops;
+  for (i = stops.length - 1; i >= 0; i--) {
+    stops.item(i).remove();
+  }
+  for (i = 0; i < entries.length; i++) {
+    props = { position: entries[i].position, alignment: entries[i].alignment, leader: entries[i].leader };
+    if (entries[i].alignmentCharacter !== null) { props.alignmentCharacter = entries[i].alignmentCharacter; }
+    /*
+     * Nur add(withProperties): ein Nachsetzen der Eigenschaften am
+     * zurueckgegebenen TabStop loeschte am lebenden InDesign 21.5 die zuvor
+     * angelegten Tabulatoren (Live-Fund 05.09.2026 – von drei blieb einer).
+     */
+    stop = target.tabStops.add(props);
+  }
+}
+
+function idcReadTabStops(target) {
+  var out = [];
+  var stops, i, stop, entry;
+  try { stops = target.tabStops; } catch (e0) { return null; }
+  try {
+    for (i = 0; i < stops.length; i++) {
+      stop = stops.item(i);
+      entry = { position_mm: null, alignment: null, leader: null, align_on: null };
+      try { entry.position_mm = IDC.round(Number(stop.position)); } catch (e1) { /* bleibt null */ }
+      try { entry.alignment = idcTabAlignmentName(stop.alignment); } catch (e2) { /* bleibt null */ }
+      try { entry.leader = String(stop.leader); } catch (e3) { /* bleibt null */ }
+      if (entry.alignment === 'character') {
+        try { entry.align_on = String(stop.alignmentCharacter); } catch (e4) { /* bleibt null */ }
+      }
+      out.push(entry);
+    }
+  } catch (e5) { return null; }
+  return out;
+}
+
+/* -------------------------------------------------------------- Sprache */
+
+function idcLanguageEntry(lang) {
+  var entry = { name: null, untranslated_name: null, icu_locale: null };
+  try { entry.name = String(lang.name); } catch (e0) { /* bleibt null */ }
+  try { entry.untranslated_name = String(lang.untranslatedName); } catch (e1) { /* bleibt null */ }
+  try { entry.icu_locale = String(lang.icuLocaleName); } catch (e2) { /* bleibt null */ }
+  return entry;
+}
+
+function idcLanguageKey(text) {
+  return String(text).toLowerCase().replace(/-/g, '_');
+}
+
+/* Alle Sprachen: erst die der Anwendung (mit Anbietern), dann die des Dokuments. */
+function idcAllLanguages(doc) {
+  var out = [];
+  var seen = {};
+  var lists = [], i, j, list, lang, key;
+  try { if (app.languagesWithVendors) { lists.push(app.languagesWithVendors); } } catch (e0) { /* keine */ }
+  try { if (doc.languages) { lists.push(doc.languages); } } catch (e1) { /* keine */ }
+  for (i = 0; i < lists.length; i++) {
+    list = lists[i];
+    try {
+      for (j = 0; j < list.length; j++) {
+        lang = list.item(j);
+        try { key = String(lang.name); } catch (e2) { continue; }
+        if (IDC.hasOwn(seen, key)) { continue; }
+        seen[key] = true;
+        out.push(lang);
+      }
+    } catch (e3) { /* naechste Liste */ }
+  }
+  return out;
+}
+
+/* Sprache ueber Namen (lokalisiert), englischen Namen oder ICU-Kennung (de_DE, de-DE) finden. */
+function idcLanguageArg(doc, value, field) {
+  var wanted, all, i, lang, entry, available = [];
+  if (typeof value !== 'string' || value === '') {
+    IDC.fail('invalid_argument', field + ' must be a language name as InDesign shows it, its English name, or an ICU locale such as de_DE.', { value: value });
+  }
+  wanted = idcLanguageKey(value);
+  all = idcAllLanguages(doc);
+  for (i = 0; i < all.length; i++) {
+    lang = all[i];
+    entry = idcLanguageEntry(lang);
+    if ((entry.name !== null && idcLanguageKey(entry.name) === wanted) ||
+        (entry.untranslated_name !== null && idcLanguageKey(entry.untranslated_name) === wanted) ||
+        (entry.icu_locale !== null && entry.icu_locale !== '' && idcLanguageKey(entry.icu_locale) === wanted)) {
+      return lang;
+    }
+    if (available.length < 120) { available.push(entry); }
+  }
+  IDC.fail('not_found', 'No language "' + value + '" in this InDesign. Use a name from available (name as shown, English name or ICU locale).',
+    { language: value, available: available });
+  return null;
+}
+
+function idcReadLanguage(target) {
+  var lang = null;
+  try { lang = target.appliedLanguage; } catch (e0) { return null; }
+  if (lang === null || lang === undefined) { return null; }
+  if (typeof lang === 'string') { return { name: lang, untranslated_name: null, icu_locale: null }; }
+  return idcLanguageEntry(lang);
+}
+
+/* ------------------------------------------------ gemeinsame Anwendung */
+
+function idcIndentTabLanguageGiven(args) {
+  return idcGiven(args.left_indent_mm) || idcGiven(args.first_line_indent_mm) || idcGiven(args.right_indent_mm) ||
+    idcGiven(args.last_line_indent_mm) || idcGiven(args.tab_stops) || idcGiven(args.language);
+}
+
+/*
+ * Einzuege, Tabulatoren und Sprache an ein Format oder einen Absatz setzen.
+ * Erst pruefen (alle Argumente), dann schreiben. Liefert die Liste der
+ * gesetzten Felder.
+ */
+function idcApplyIndentTabLanguage(doc, target, args) {
+  var applied = [];
+  var left = null, first = null, right = null, last = null, tabs = null, lang = null;
+  var currentLeft = 0;
+
+  if (idcGiven(args.left_indent_mm)) { left = idcIndentArg(args.left_indent_mm, 'left_indent_mm', 0, IDC_INDENT_MAX_MM); }
+  if (idcGiven(args.right_indent_mm)) { right = idcIndentArg(args.right_indent_mm, 'right_indent_mm', 0, IDC_INDENT_MAX_MM); }
+  if (idcGiven(args.first_line_indent_mm)) { first = idcIndentArg(args.first_line_indent_mm, 'first_line_indent_mm', -IDC_INDENT_MAX_MM, IDC_INDENT_MAX_MM); }
+  if (idcGiven(args.last_line_indent_mm)) { last = idcIndentArg(args.last_line_indent_mm, 'last_line_indent_mm', -IDC_INDENT_MAX_MM, IDC_INDENT_MAX_MM); }
+  if (idcGiven(args.tab_stops)) { tabs = idcTabStopsArg(args.tab_stops); }
+  if (idcGiven(args.language)) { lang = idcLanguageArg(doc, args.language, 'language'); }
+
+  /* Ein haengender Einzug darf nicht weiter nach links als der linke Einzug reichen (InDesign lehnt das ab). */
+  if (first !== null) {
+    try { currentLeft = Number(target.leftIndent); } catch (e0) { currentLeft = 0; }
+    if (left !== null) { currentLeft = left; }
+    if (first < 0 && -first > currentLeft + 0.0001) {
+      IDC.fail('invalid_argument', 'first_line_indent_mm ' + first + ' reaches further left than the left indent (' + IDC.round(currentLeft) + ' mm); a hanging indent needs left_indent_mm >= -first_line_indent_mm.',
+        { first_line_indent_mm: first, left_indent_mm: currentLeft });
+    }
+  }
+
+  if (left !== null) { target.leftIndent = left; applied.push('left_indent_mm'); }
+  if (right !== null) { target.rightIndent = right; applied.push('right_indent_mm'); }
+  if (first !== null) { target.firstLineIndent = first; applied.push('first_line_indent_mm'); }
+  if (last !== null) { target.lastLineIndent = last; applied.push('last_line_indent_mm'); }
+  if (tabs !== null) { idcSetTabStops(target, tabs); applied.push('tab_stops'); }
+  if (lang !== null) { target.appliedLanguage = lang; applied.push('language'); }
+  return applied;
+}
+
+function idcReadIndentTabLanguage(target) {
+  return {
+    left_indent_mm: idcReadNumberLoose(target, 'leftIndent', 4),
+    first_line_indent_mm: idcReadNumberLoose(target, 'firstLineIndent', 4),
+    right_indent_mm: idcReadNumberLoose(target, 'rightIndent', 4),
+    last_line_indent_mm: idcReadNumberLoose(target, 'lastLineIndent', 4),
+    tab_stops: idcReadTabStops(target),
+    language: idcReadLanguage(target)
+  };
+}

package/indesign/commands/84-import-styles.js

@@ -0,0 +1,142 @@
+/* Wunschliste J2 Nr. 19 (Sitzung 8) – Formate aus einer Vorlage uebernehmen: import_styles. */
+
+var IDC_IMPORT_KINDS = ['paragraph', 'character', 'object', 'table', 'cell', 'swatches'];
+
+function idcImportFormatFor(kind) {
+  if (typeof ImportFormat === 'undefined') { return null; }
+  if (kind === 'paragraph') { return ImportFormat.PARAGRAPH_STYLES_FORMAT; }
+  if (kind === 'character') { return ImportFormat.CHARACTER_STYLES_FORMAT; }
+  if (kind === 'object') { return ImportFormat.OBJECT_STYLES_FORMAT; }
+  if (kind === 'table') { return ImportFormat.TABLE_STYLES_FORMAT; }
+  if (kind === 'cell') { return ImportFormat.CELL_STYLES_FORMAT; }
+  return null;
+}
+
+function idcClashStrategyFor(name) {
+  if (typeof GlobalClashResolutionStrategy === 'undefined') { return null; }
+  if (name === 'keep_existing') { return GlobalClashResolutionStrategy.DO_NOT_LOAD_THE_STYLE; }
+  if (name === 'overwrite') { return GlobalClashResolutionStrategy.LOAD_ALL_WITH_OVERWRITE; }
+  if (name === 'rename') { return GlobalClashResolutionStrategy.LOAD_ALL_WITH_RENAME; }
+  return null;
+}
+
+/* Namen einer Formatart im Dokument (Gruppen eingeschlossen). */
+function idcStyleNamesOfKind(doc, kind) {
+  var list = [], i, all = null, collection = null;
+  try {
+    if (kind === 'paragraph') { all = doc.allParagraphStyles; }
+    else if (kind === 'character') { all = doc.allCharacterStyles; }
+    else if (kind === 'object') { all = doc.allObjectStyles; }
+    else if (kind === 'table') { all = doc.allTableStyles; }
+    else if (kind === 'cell') { all = doc.allCellStyles; }
+  } catch (e0) { all = null; }
+  if (all !== null && all !== undefined) {
+    for (i = 0; i < all.length; i++) { try { list.push(String(all[i].name)); } catch (e1) { /* ohne */ } }
+    return list;
+  }
+  try {
+    if (kind === 'paragraph') { collection = doc.paragraphStyles; }
+    else if (kind === 'character') { collection = doc.characterStyles; }
+    else if (kind === 'object') { collection = doc.objectStyles; }
+    else if (kind === 'table') { collection = doc.tableStyles; }
+    else if (kind === 'cell') { collection = doc.cellStyles; }
+    else if (kind === 'swatches') { collection = doc.swatches; }
+    if (collection !== null && collection !== undefined) {
+      for (i = 0; i < collection.length; i++) { try { list.push(String(collection.item(i).name)); } catch (e2) { /* ohne */ } }
+    }
+  } catch (e3) { /* leer */ }
+  return list;
+}
+
+function idcNamesNotIn(after, before) {
+  var out = [], i, j, seen;
+  for (i = 0; i < after.length; i++) {
+    seen = false;
+    for (j = 0; j < before.length; j++) { if (before[j] === after[i]) { seen = true; break; } }
+    if (!seen) { out.push(after[i]); }
+  }
+  return out;
+}
+
+IDC.register('import_styles', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var path = args.file_path;
+    var kinds = args.kinds;
+    var onConflict = args.on_conflict === undefined || args.on_conflict === null ? 'keep_existing' : args.on_conflict;
+    var file, strategy, i, j, kind, format, before, after, added, results = {}, totalAdded = 0, lower;
+    var ownPath = '';
+
+    if (typeof path !== 'string' || path === '') {
+      IDC.fail('invalid_argument', 'file_path is required (.indd, .indt or .idml).', null);
+    }
+    lower = path.toLowerCase();
+    if (!/\.(indd|indt|idml)$/.test(lower)) {
+      IDC.fail('invalid_argument', 'file_path must end in .indd, .indt or .idml.', { file_path: path });
+    }
+    if (kinds === undefined || kinds === null) {
+      kinds = IDC_IMPORT_KINDS.slice();
+    }
+    if (!IDC.isArray(kinds) || kinds.length === 0) {
+      IDC.fail('invalid_argument', 'kinds must be a non-empty list of ' + IDC_IMPORT_KINDS.join(', ') + '.', null);
+    }
+    for (i = 0; i < kinds.length; i++) {
+      if (typeof kinds[i] !== 'string') { IDC.fail('invalid_argument', 'kinds must contain names.', { kinds: kinds }); }
+      for (j = 0; j < IDC_IMPORT_KINDS.length; j++) { if (IDC_IMPORT_KINDS[j] === kinds[i]) { break; } }
+      if (j === IDC_IMPORT_KINDS.length) {
+        IDC.fail('invalid_argument', 'Unknown kind "' + kinds[i] + '"; allowed: ' + IDC_IMPORT_KINDS.join(', ') + '.', { kind: kinds[i] });
+      }
+    }
+    if (onConflict !== 'keep_existing' && onConflict !== 'overwrite' && onConflict !== 'rename') {
+      IDC.fail('invalid_argument', 'on_conflict must be keep_existing, overwrite or rename.', { on_conflict: onConflict });
+    }
+    file = IDC.fileFor(path);
+    if (!file.exists) {
+      IDC.fail('not_found', 'File not found: ' + path, { file_path: path });
+    }
+    try { ownPath = idcDocumentPath(doc); } catch (e0) { ownPath = ''; }
+    if (ownPath !== '' && IDC.fsPath(file) === ownPath) {
+      IDC.fail('invalid_argument', 'file_path is the document itself.', { file_path: path });
+    }
+    strategy = idcClashStrategyFor(onConflict);
+    if (strategy === null) {
+      IDC.fail('invalid_state', 'This runtime has no GlobalClashResolutionStrategy enumeration.', null);
+    }
+
+    for (i = 0; i < kinds.length; i++) {
+      kind = kinds[i];
+      before = idcStyleNamesOfKind(doc, kind);
+      try {
+        if (kind === 'swatches') {
+          doc.loadSwatches(file);
+        } else {
+          format = idcImportFormatFor(kind);
+          if (format === null) { IDC.fail('invalid_state', 'This runtime has no ImportFormat enumeration.', null); }
+          doc.importStyles(format, file, strategy);
+        }
+      } catch (e1) {
+        if (e1 && e1.isIdcError) { throw e1; }
+        IDC.fail('io_error', 'InDesign could not import ' + kind + ' styles from ' + path + ': ' + String(e1.message ? e1.message : e1),
+          { file_path: path, kind: kind, imported_so_far: results });
+      }
+      after = idcStyleNamesOfKind(doc, kind);
+      added = idcNamesNotIn(after, before);
+      totalAdded += added.length;
+      results[kind] = { before: before.length, after: after.length, added: added };
+    }
+    if (kinds.length > 0 && totalAdded === 0) {
+      ctx.warn('No new styles or swatches were added – the file had none of the requested kinds, or all names existed already (on_conflict ' + onConflict + ').');
+    }
+    if (onConflict === 'overwrite') {
+      ctx.warn('on_conflict overwrite: existing styles with the same names were replaced; the counts cannot show which.');
+    }
+    ctx.changes = { modified_document_ids: [Number(doc.id)] };
+    return {
+      file_path: IDC.fsPath(file) || path,
+      kinds: kinds,
+      on_conflict: onConflict,
+      results: results,
+      total_added: totalAdded
+    };
+  });

package/indesign/commands/85-swatches.js

@@ -0,0 +1,112 @@
+/* Wunschliste J2 Nr. 18 (Sitzung 7) – Farbfelder auflisten: list_swatches. */
+
+function idcColorSpaceName(value) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof ColorSpace === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, ColorSpace.RGB)) { return 'RGB'; }
+  if (IDC.enumIs(value, ColorSpace.CMYK)) { return 'CMYK'; }
+  try { if (ColorSpace.LAB !== undefined && IDC.enumIs(value, ColorSpace.LAB)) { return 'LAB'; } } catch (e0) { /* kein LAB */ }
+  try { if (ColorSpace.MIXEDINK !== undefined && IDC.enumIs(value, ColorSpace.MIXEDINK)) { return 'MIXED_INK'; } } catch (e1) { /* kein MIXEDINK */ }
+  return String(value);
+}
+
+function idcColorModelName(value) {
+  if (value === undefined || value === null) { return null; }
+  if (typeof ColorModel === 'undefined') { return String(value); }
+  if (IDC.enumIs(value, ColorModel.PROCESS)) { return 'process'; }
+  if (IDC.enumIs(value, ColorModel.SPOT)) { return 'spot'; }
+  try { if (ColorModel.REGISTRATION !== undefined && IDC.enumIs(value, ColorModel.REGISTRATION)) { return 'registration'; } } catch (e0) { /* keine */ }
+  return String(value);
+}
+
+function idcNumberList(values) {
+  var out = [];
+  var i;
+  if (!values) { return out; }
+  for (i = 0; i < values.length; i++) { out.push(IDC.round(Number(values[i]), 3)); }
+  return out;
+}
+
+/* Sammlung (colors, tints, gradients, mixedInks) durchgehen; fehlt sie, leere Liste. */
+function idcEachIn(doc, collectionName, fn) {
+  var collection = null, i, item;
+  try { collection = doc[collectionName]; } catch (e0) { collection = null; }
+  if (collection === null || collection === undefined) { return; }
+  for (i = 0; i < collection.length; i++) {
+    try { item = collection.item(i); } catch (e1) { continue; }
+    fn(item);
+  }
+}
+
+function idcDescribeColor(color) {
+  var out = { swatch_id: null, name: null, kind: 'color', space: null, model: null, values: [], tint_percent: null, base_color: null, built_in: false };
+  try { out.swatch_id = Number(color.id); } catch (e0) { /* null */ }
+  try { out.name = String(color.name); } catch (e1) { /* null */ }
+  try { out.space = idcColorSpaceName(color.space); } catch (e2) { /* null */ }
+  try { out.model = idcColorModelName(color.model); } catch (e3) { /* null */ }
+  try { out.values = idcNumberList(color.colorValue); } catch (e4) { out.values = []; }
+  out.built_in = out.name !== null && (out.name === 'Black' || out.name === 'Paper' || out.name === 'Registration' || out.name === 'None' || out.name.charAt(0) === '[');
+  return out;
+}
+
+IDC.register('list_swatches', { needs_document: true, read_only: true, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var includeBuiltIn = args.include_built_in !== false;
+    var out = [];
+    var counts = { color: 0, tint: 0, gradient: 0, mixed_ink: 0 };
+    var unnamed = 0;
+    /* Unbenannte Farben (leerer Name, z. B. Verlaufsstufen) sind per Name nicht erreichbar – nur zaehlen (Live-Fund 05.09.2026). */
+    var skipUnnamed = function (entry) {
+      if (entry.name === null || entry.name === '') { unnamed += 1; return true; }
+      return false;
+    };
+    var noneSwatch = idcNoneSwatch(doc);
+
+    if (noneSwatch !== null && includeBuiltIn) {
+      out.push({ swatch_id: Number(noneSwatch.id), name: String(noneSwatch.name), kind: 'none', space: null, model: null, values: [], tint_percent: null, base_color: null, built_in: true });
+    }
+    idcEachIn(doc, 'colors', function (color) {
+      var entry = idcDescribeColor(color);
+      if (skipUnnamed(entry)) { return; }
+      if (entry.built_in && !includeBuiltIn) { return; }
+      counts.color += 1;
+      out.push(entry);
+    });
+    idcEachIn(doc, 'tints', function (tint) {
+      var entry = { swatch_id: null, name: null, kind: 'tint', space: null, model: null, values: [], tint_percent: null, base_color: null, built_in: false };
+      try { entry.swatch_id = Number(tint.id); } catch (e0) { /* null */ }
+      try { entry.name = String(tint.name); } catch (e1) { /* null */ }
+      try { entry.tint_percent = IDC.round(Number(tint.tintValue), 3); } catch (e2) { /* null */ }
+      try { entry.base_color = String(tint.baseColor.name); } catch (e3) { /* null */ }
+      try { entry.space = idcColorSpaceName(tint.space); } catch (e4) { /* null */ }
+      try { entry.values = idcNumberList(tint.colorValue); } catch (e5) { entry.values = []; }
+      if (skipUnnamed(entry)) { return; }
+      counts.tint += 1;
+      out.push(entry);
+    });
+    idcEachIn(doc, 'gradients', function (gradient) {
+      var entry = { swatch_id: null, name: null, kind: 'gradient', space: null, model: null, values: [], tint_percent: null, base_color: null, built_in: false, stop_count: null };
+      try { entry.swatch_id = Number(gradient.id); } catch (e0) { /* null */ }
+      try { entry.name = String(gradient.name); } catch (e1) { /* null */ }
+      try { entry.stop_count = Number(gradient.gradientStops.length); } catch (e2) { /* null */ }
+      /* A-8.4: Art und Stopps. */
+      entry.type = idcGradientTypeName((function () { try { return gradient.type; } catch (e3) { return null; } })());
+      entry.stops = idcReadGradientStops(gradient);
+      if (skipUnnamed(entry)) { return; }
+      counts.gradient += 1;
+      out.push(entry);
+    });
+    idcEachIn(doc, 'mixedInks', function (ink) {
+      var entry = { swatch_id: null, name: null, kind: 'mixed_ink', space: 'MIXED_INK', model: null, values: [], tint_percent: null, base_color: null, built_in: false };
+      try { entry.swatch_id = Number(ink.id); } catch (e0) { /* null */ }
+      try { entry.name = String(ink.name); } catch (e1) { /* null */ }
+      try { entry.values = idcNumberList(ink.inkPercentages); } catch (e2) { entry.values = []; }
+      if (skipUnnamed(entry)) { return; }
+      counts.mixed_ink += 1;
+      out.push(entry);
+    });
+
+    return { swatches: out, count: out.length, counts: counts, unnamed_skipped: unnamed, include_built_in: includeBuiltIn };
+  });

package/indesign/commands/86-gradients.js

@@ -0,0 +1,185 @@
+/*
+ * Auftrag A-8.4 (Sitzung 9) – create_gradient_swatch: Verlaufsfarbfeld
+ * anlegen, das an Flaechen und Konturen per fill_swatch_name /
+ * stroke_swatch_name verwendet wird. Adobe-DOM (Auftrag, geprueft
+ * 05.09.2026): Gradients.add(withProperties) -> Gradient {name, type
+ * (GradientType.LINEAR|RADIAL), gradientStops}; GradientStops.add() ->
+ * GradientStop {stopColor (Swatch-Objekt), location 0–100, midpoint 13–87}.
+ * Ob ein neuer Verlauf schon zwei Stopps traegt: live pruefen (Journal).
+ */
+
+function idcGradientTypeFor(name) {
+  if (typeof GradientType === 'undefined') {
+    IDC.fail('invalid_state', 'This runtime has no GradientType enumeration.', null);
+  }
+  if (name === 'linear') { return GradientType.LINEAR; }
+  if (name === 'radial') { return GradientType.RADIAL; }
+  IDC.fail('invalid_argument', 'type must be linear or radial.', { type: name });
+  return null;
+}
+
+function idcGradientTypeName(value) {
+  if (value === null || value === undefined || typeof GradientType === 'undefined') { return null; }
+  if (IDC.enumIs(value, GradientType.LINEAR)) { return 'linear'; }
+  if (IDC.enumIs(value, GradientType.RADIAL)) { return 'radial'; }
+  return String(value);
+}
+
+/* Stopps eines Verlaufs lesen: [{index, swatch_name, location, midpoint}]. */
+function idcReadGradientStops(gradient) {
+  var out = [], stops, i, stop, entry;
+  try { stops = gradient.gradientStops; } catch (e0) { return out; }
+  for (i = 0; i < stops.length; i++) {
+    entry = { index: i, swatch_name: null, location: null, midpoint: null };
+    try { stop = stops.item(i); } catch (e1) { continue; }
+    try { entry.swatch_name = String(stop.stopColor.name); } catch (e2) { /* null */ }
+    try { entry.location = IDC.round(Number(stop.location), 3); } catch (e3) { /* null */ }
+    try { entry.midpoint = IDC.round(Number(stop.midpoint), 3); } catch (e4) { /* null */ }
+    out.push(entry);
+  }
+  return out;
+}
+
+/* Stopp-Angabe pruefen und das Farbfeld dafuer beschaffen (Name, Hex oder CMYK). */
+function idcGradientStopArg(doc, spec, index, gradientName, created) {
+  var ways = 0, swatch = null, kind, hexName;
+  if (spec === null || typeof spec !== 'object' || IDC.isArray(spec)) {
+    IDC.fail('invalid_argument', 'stops[' + index + '] must be an object {swatch_name | hex | cmyk, location, midpoint}.', { value: spec });
+  }
+  if (idcGiven(spec.swatch_name)) { ways += 1; }
+  if (idcGiven(spec.hex)) { ways += 1; }
+  if (idcGiven(spec.cmyk)) { ways += 1; }
+  if (ways !== 1) {
+    IDC.fail('invalid_argument', 'stops[' + index + '] needs exactly one of swatch_name, hex or cmyk.', { value: spec });
+  }
+  if (typeof spec.location !== 'number' || !isFinite(spec.location) || spec.location < 0 || spec.location > 100) {
+    IDC.fail('invalid_argument', 'stops[' + index + '].location must be a number between 0 and 100.', { value: spec.location });
+  }
+  if (idcGiven(spec.midpoint) && (typeof spec.midpoint !== 'number' || !isFinite(spec.midpoint) || spec.midpoint < 13 || spec.midpoint > 87)) {
+    IDC.fail('invalid_argument', 'stops[' + index + '].midpoint must be a number between 13 and 87.', { value: spec.midpoint });
+  }
+  if (idcGiven(spec.swatch_name)) {
+    swatch = idcSwatchArg(doc, spec.swatch_name, 'stops[' + index + '].swatch_name');
+    kind = idcSwatchKind(swatch);
+    if (kind !== 'color' && kind !== 'tint') {
+      IDC.fail('invalid_argument', 'stops[' + index + '].swatch_name must be a colour or tint swatch, not a ' + kind + '.', { swatch_name: spec.swatch_name, kind: kind });
+    }
+  } else if (idcGiven(spec.hex)) {
+    swatch = idcSwatchForHex(doc, spec.hex, 'stops[' + index + '].hex', created);
+  } else {
+    hexName = gradientName + ' Stopp ' + (index + 1);
+    swatch = idcSwatchByName(doc, hexName);
+    if (swatch === null) {
+      try {
+        swatch = doc.colors.add({ name: hexName, model: ColorModel.PROCESS, space: ColorSpace.CMYK, colorValue: idcCmykArg(spec.cmyk) });
+        created.push(Number(swatch.id));
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not create the stop swatch "' + hexName + '": ' + String(e.message ? e.message : e), { name: hexName });
+      }
+    } else {
+      try { swatch.colorValue = idcCmykArg(spec.cmyk); } catch (e2) { /* Werte bleiben */ }
+    }
+  }
+  return { swatch: swatch, location: spec.location, midpoint: idcGiven(spec.midpoint) ? spec.midpoint : null };
+}
+
+/* Stopps in den Verlauf schreiben: vorhandene setzen, fehlende anlegen, ueberzaehlige entfernen. */
+function idcWriteGradientStops(gradient, stops) {
+  var collection = gradient.gradientStops;
+  var i, stop, count;
+  for (i = 0; i < stops.length; i++) {
+    try { count = Number(collection.length); } catch (e0) { count = 0; }
+    if (i < count) { stop = collection.item(i); }
+    else { stop = collection.add(); }
+    stop.stopColor = stops[i].swatch;
+    stop.location = stops[i].location;
+    if (stops[i].midpoint !== null) { stop.midpoint = stops[i].midpoint; }
+  }
+  try { count = Number(collection.length); } catch (e1) { count = stops.length; }
+  while (count > stops.length) {
+    try { collection.item(count - 1).remove(); } catch (e2) { break; }
+    count -= 1;
+  }
+}
+
+IDC.register('create_gradient_swatch', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var name = args.name;
+    var typeName = idcGiven(args.type) ? String(args.type) : 'linear';
+    var onCollision = idcCollisionArg(args.on_collision);
+    var created = [];
+    var stops = [], i, existing, existed, collision = 'none', chosenName, gradient = null, className, previous = null;
+
+    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 "[".', { name: name });
+    }
+    idcGradientTypeFor(typeName);
+    if (!IDC.isArray(args.stops) || args.stops.length < 2 || args.stops.length > 20) {
+      IDC.fail('invalid_argument', 'stops must be an array of 2 to 20 entries in order.', { count: IDC.isArray(args.stops) ? args.stops.length : null });
+    }
+    for (i = 0; i < args.stops.length; i++) {
+      stops.push(idcGradientStopArg(doc, args.stops[i], i, name, created));
+      if (i > 0 && stops[i].location < stops[i - 1].location) {
+        IDC.fail('invalid_argument', 'stops must be in ascending order of location (stop ' + i + ' is at ' + stops[i].location + ', the one before at ' + stops[i - 1].location + ').', null);
+      }
+    }
+    if (stops[0].location !== 0) { ctx.warn('The first stop is at ' + stops[0].location + ' %, not 0 % – the gradient starts with a flat area.'); }
+    if (stops[stops.length - 1].location !== 100) { ctx.warn('The last stop is at ' + stops[stops.length - 1].location + ' %, not 100 % – the gradient ends with a flat area.'); }
+
+    chosenName = name;
+    existing = idcSwatchByName(doc, name);
+    existed = idcPresent(existing);
+    if (existed) {
+      className = IDC.className(existing);
+      if (onCollision === 'error') {
+        IDC.fail('invalid_state', 'Swatch "' + name + '" exists already (' + className + '). 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') {
+        if (className !== 'Gradient') {
+          IDC.fail('invalid_state', 'Swatch "' + name + '" is a ' + className + ', not a gradient; it cannot be updated with stops.', { name: name, type: className });
+        }
+        gradient = existing;
+        collision = 'updated';
+        previous = { type: idcGradientTypeName(gradient.type), stops: idcReadGradientStops(gradient) };
+      } else {
+        chosenName = idcFreeName(doc, name, 'swatch');
+        collision = 'versioned';
+      }
+    }
+    if (gradient === null) {
+      try {
+        gradient = doc.gradients.add({ name: chosenName, type: idcGradientTypeFor(typeName) });
+      } catch (e2) {
+        IDC.fail('script_error', 'InDesign could not create the gradient "' + chosenName + '": ' + String(e2.message ? e2.message : e2), { name: chosenName });
+      }
+    } else {
+      try { gradient.type = idcGradientTypeFor(typeName); } catch (e3) { /* Art bleibt */ }
+    }
+    try {
+      idcWriteGradientStops(gradient, stops);
+    } catch (e4) {
+      IDC.fail('script_error', 'InDesign could not write the gradient stops of "' + chosenName + '": ' + String(e4.message ? e4.message : e4), { name: chosenName });
+    }
+
+    var changes = { created_swatch_ids: created.slice() };
+    if (collision === 'updated') { changes.modified_swatch_ids = [Number(gradient.id)]; }
+    else { changes.created_swatch_ids.push(Number(gradient.id)); }
+    ctx.changes = changes;
+    return {
+      name: String(gradient.name),
+      swatch_id: Number(gradient.id),
+      type: idcGradientTypeName(gradient.type),
+      stops: idcReadGradientStops(gradient),
+      stop_count: idcReadGradientStops(gradient).length,
+      collision: collision,
+      existed: existed,
+      previous: previous,
+      swatch_ids: created
+    };
+  });