layoutbridge-light 0.0.0-stage → 1.0.1

package/dist/src/transport/queue.js

@@ -0,0 +1,19 @@
+export class SerialTransport {
+    inner;
+    chain = Promise.resolve();
+    constructor(inner) {
+        this.inner = inner;
+    }
+    get name() {
+        return this.inner.name;
+    }
+    send(command, options) {
+        const run = this.chain.then(() => this.inner.send(command, options), () => this.inner.send(command, options));
+        this.chain = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    close() {
+        return this.inner.close();
+    }
+}
+//# sourceMappingURL=queue.js.map

package/dist/src/transport/script-bundle.js

@@ -0,0 +1,92 @@
+/**
+ * Setzt das Skript zusammen, das in InDesign laeuft: Interpreter-Kern plus
+ * alle Handler aus indesign/commands. Der Interpreter darf kein #include
+ * benutzen (ExtendScript-eigen, in UXP nicht vorhanden), deshalb haengt der
+ * Server die Dateien aneinander.
+ */
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+let cached = null;
+/** Dateiliste mit Aenderungszeiten, mit der das Buendel gebaut wurde. */
+let cachedSignature = '';
+/** Handler-Dateien alphabetisch, wie sie ins Buendel kommen. */
+function commandFiles(root) {
+    return readdirSync(join(root, 'commands'))
+        .filter((name) => name.endsWith('.js'))
+        .sort();
+}
+/*
+ * Signatur aus Pfaden und Aenderungszeiten. Aendert sich eine Handler-Datei
+ * (Bausitzung mit laufendem Server), wird das Buendel beim naechsten Aufruf
+ * neu gelesen – ohne Neustart von Claude Desktop. Ein Stat je Datei und
+ * Aufruf ist gegen die Laufzeit eines InDesign-Skripts vernachlaessigbar.
+ */
+export function bundleSignature(root = findScriptRoot()) {
+    return signature(root, commandFiles(root));
+}
+function signature(root, files) {
+    const parts = [root + ':' + statSync(join(root, 'interpreter.js')).mtimeMs];
+    for (const name of files) {
+        parts.push(name + ':' + statSync(join(root, 'commands', name)).mtimeMs);
+    }
+    return parts.join('|');
+}
+/** Sucht aufwaerts nach dem Repo-/Paketwurzelordner mit indesign/interpreter.js. */
+export function findScriptRoot(startDir) {
+    let dir = startDir ?? dirname(fileURLToPath(import.meta.url));
+    for (let step = 0; step < 12; step += 1) {
+        if (existsSync(join(dir, 'indesign', 'interpreter.js'))) {
+            return join(dir, 'indesign');
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error('indesign/interpreter.js not found – package layout is broken.');
+}
+/** Interpreter und Handler in fester Reihenfolge, Dateinamen alphabetisch. */
+export function buildScriptBundle(force = false) {
+    const root = findScriptRoot();
+    const files = commandFiles(root);
+    let current = '';
+    try {
+        current = signature(root, files);
+    }
+    catch {
+        current = '';
+    }
+    if (cached !== null && !force && current !== '' && current === cachedSignature)
+        return cached;
+    const parts = [];
+    parts.push('/* layoutbridge-spm – zusammengesetztes Skript */');
+    parts.push(readFileSync(join(root, 'interpreter.js'), 'utf8'));
+    const commandDir = join(root, 'commands');
+    for (const name of files) {
+        parts.push('\n/* ---- commands/' + name + ' ---- */\n');
+        parts.push(readFileSync(join(commandDir, name), 'utf8'));
+    }
+    cached = parts.join('\n');
+    cachedSignature = current;
+    return cached;
+}
+/**
+ * JSON, in dem jedes Zeichen ausserhalb von ASCII als \uXXXX steht. So ist das
+ * erzeugte Skript reines ASCII und die Zeichensatzfrage stellt sich nicht.
+ */
+export function toAsciiJson(value) {
+    const json = JSON.stringify(value ?? null);
+    let out = '';
+    for (let i = 0; i < json.length; i += 1) {
+        const code = json.charCodeAt(i);
+        if (code < 0x20 || code > 0x7e) {
+            out += '\\u' + code.toString(16).padStart(4, '0');
+        }
+        else {
+            out += json.charAt(i);
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=script-bundle.js.map

package/dist/src/transport/transport.js

@@ -0,0 +1,52 @@
+/**
+ * Transportschnittstelle.
+ *
+ * Der Transport ist die einzige Stelle mit Plattformwissen. Alles darueber
+ * kennt nur diese Schnittstelle: einen Befehl hinschicken, ein Ergebnis
+ * zurueckbekommen.
+ */
+/**
+ * Fehlerarten nach Spezifikation, allgemeine Anforderung 5; dazu "license"
+ * fuer die Lizenzschranke (Auftrag A-6, E-60, Spezifikation S11) – sie
+ * greift vor dem Transport, InDesign ist nicht beteiligt.
+ */
+export const ERROR_KINDS = [
+    'app_not_available',
+    'invalid_argument',
+    'not_found',
+    'invalid_state',
+    'io_error',
+    'timeout',
+    'script_error',
+    'license',
+];
+/**
+ * Zeitanteile eines Aufrufs fuer das Protokoll (A-74, Sitzung 80). Haengt
+ * unter einem Symbol am Ergebnis: JSON.stringify und Object.keys sehen es
+ * nicht, die Antwort an den Client bleibt also unveraendert. Der Aufrufer
+ * nimmt es mit takeTiming() ab.
+ */
+export const TIMING = Symbol('idc.timing');
+export function attachTiming(result, timing) {
+    Object.defineProperty(result, TIMING, { value: timing, enumerable: false, configurable: true });
+    return result;
+}
+/** Liest die Zeitanteile und entfernt sie vom Ergebnis; null, wenn keine da sind. */
+export function takeTiming(result) {
+    if (result === null || typeof result !== 'object')
+        return null;
+    const holder = result;
+    const timing = holder[TIMING];
+    if (timing === undefined)
+        return null;
+    delete holder[TIMING];
+    return timing;
+}
+/** Baut einen Fehlerumschlag, ohne dass InDesign beteiligt war. */
+export function transportError(kind, message, details = null) {
+    return { ok: false, warnings: [], error: { kind, message, details } };
+}
+export function isErrorKind(value) {
+    return typeof value === 'string' && ERROR_KINDS.includes(value);
+}
+//# sourceMappingURL=transport.js.map

package/indesign/commands/10-app.js

@@ -0,0 +1,6 @@
+/* Bereich A – Anwendung. */
+
+IDC.register('get_app_version', { needs_document: false, read_only: true, ruler: 'none' },
+  function () {
+    return { version: String(app.version) };
+  });

package/indesign/commands/20-documents.js

@@ -0,0 +1,517 @@
+/* Bereich A – Dokumente. */
+
+/* Pfad eines Dokuments, leer wenn nie gespeichert. */
+function idcDocumentPath(doc) {
+  try {
+    if (doc.saved) { return IDC.fsPath(doc.fullName); }
+  } catch (e) { /* leer */ }
+  return '';
+}
+
+/* Fehlende und veraltete Verknuepfungen sowie fehlende Schriften. */
+function idcDocumentIssues(doc) {
+  var missingLinks = [];
+  var outOfDateLinks = [];
+  var missingFonts = [];
+  var i, link, font, name;
+
+  try {
+    for (i = 0; i < doc.links.length; i++) {
+      link = doc.links.item(i);
+      if (IDC.enumIs(link.status, LinkStatus.LINK_MISSING)) {
+        missingLinks.push(String(link.name));
+      } else if (IDC.enumIs(link.status, LinkStatus.LINK_OUT_OF_DATE)) {
+        outOfDateLinks.push(String(link.name));
+      }
+    }
+  } catch (e1) { /* Liste bleibt so weit, wie sie kam */ }
+
+  try {
+    for (i = 0; i < doc.fonts.length; i++) {
+      font = doc.fonts.item(i);
+      if (!IDC.enumIs(font.status, FontStatus.INSTALLED)) {
+        name = String(font.name);
+        missingFonts.push(name);
+      }
+    }
+  } catch (e2) { /* dito */ }
+
+  return {
+    missing_links: missingLinks,
+    out_of_date_links: outOfDateLinks,
+    missing_fonts: missingFonts
+  };
+}
+
+IDC.register('list_documents', { needs_document: false, read_only: true, ruler: 'none' },
+  function () {
+    var documents = [];
+    var activeId = null;
+    var i, doc, isActive;
+
+    /*
+     * Ueber die ID vergleichen, nicht ueber equals(): equals() lieferte am
+     * lebenden Dokument false, obwohl nur ein Dokument offen war.
+     */
+    try {
+      if (app.documents.length > 0) { activeId = Number(app.activeDocument.id); }
+    } catch (e) { activeId = null; }
+
+    for (i = 0; i < app.documents.length; i++) {
+      doc = app.documents.item(i);
+      isActive = false;
+      try {
+        if (activeId !== null) { isActive = Number(doc.id) === activeId; }
+      } catch (e2) { isActive = false; }
+      documents.push({
+        document_id: Number(doc.id),
+        name: String(doc.name),
+        saved: doc.saved === true,
+        path: idcDocumentPath(doc),
+        page_count: doc.pages.length,
+        is_active: isActive,
+        managed_story_count: idcManagedStoryCount(doc)
+      });
+    }
+    return { documents: documents, count: documents.length };
+  });
+
+IDC.register('open_document', { needs_document: false, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    if (typeof args.path !== 'string' || args.path.length === 0) {
+      IDC.fail('invalid_argument', 'path is required and must be a file path.', null);
+    }
+
+    var file = IDC.fileFor(args.path);
+    if (!file.exists) {
+      IDC.fail('not_found', 'File does not exist: ' + args.path, { path: args.path });
+    }
+    var wantedPath = IDC.fsPath(file);
+
+    var isTemplate = /\.indt$/i.test(args.path);
+    var openCopy = args.open_copy === true || (args.open_copy !== false && isTemplate);
+
+    /*
+     * Schon offen? Dann nicht doppelt oeffnen – ausser jemand will ausdruecklich
+     * eine Kopie: die ist ein neues, unbenanntes Dokument und kollidiert mit
+     * nichts.
+     */
+    var i, candidate, doc = null;
+    if (!openCopy) {
+      for (i = 0; i < app.documents.length; i++) {
+        candidate = app.documents.item(i);
+        if (idcDocumentPath(candidate) === wantedPath && wantedPath !== '') {
+          doc = candidate;
+          break;
+        }
+      }
+    }
+
+    var alreadyOpen = doc !== null;
+    if (!alreadyOpen) {
+      var showWindow = args.show_window === false ? false : true;
+      var openOption = openCopy ? OpenOptions.OPEN_COPY : OpenOptions.OPEN_ORIGINAL;
+      try {
+        doc = app.open(file, showWindow, openOption);
+      } catch (e) {
+        IDC.fail('io_error', 'InDesign could not open the file: ' + String(e.message ? e.message : e),
+          { path: args.path });
+      }
+      if (IDC.isArray(doc)) { doc = doc[0]; }
+    } else {
+      ctx.warn('Document was already open; it was not opened a second time.');
+    }
+
+    var issues = idcDocumentIssues(doc);
+    if (issues.missing_links.length > 0) {
+      ctx.warn('Missing links (fehlende Verknuepfungen): ' + issues.missing_links.join(', '));
+    }
+    if (issues.out_of_date_links.length > 0) {
+      ctx.warn('Out of date links (veraltete Verknuepfungen): ' + issues.out_of_date_links.join(', '));
+    }
+    if (issues.missing_fonts.length > 0) {
+      ctx.warn('Missing fonts (fehlende Schriften): ' + issues.missing_fonts.join(', '));
+    }
+
+    ctx.changes = { opened_document_ids: alreadyOpen ? [] : [Number(doc.id)] };
+
+    return {
+      document_id: Number(doc.id),
+      name: String(doc.name),
+      page_count: doc.pages.length,
+      facing_pages: doc.documentPreferences.facingPages === true,
+      already_open: alreadyOpen,
+      path: idcDocumentPath(doc),
+      missing_links: issues.missing_links,
+      out_of_date_links: issues.out_of_date_links,
+      missing_fonts: issues.missing_fonts,
+      managed_story_count: idcManagedStoryCount(doc)
+    };
+  });
+
+IDC.register('close_document', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+
+    if (args.save_changes !== 'yes' && args.save_changes !== 'no') {
+      IDC.fail('invalid_argument',
+        'save_changes is required and must be "yes" or "no" (InDesign save dialogs are suppressed).',
+        { save_changes: args.save_changes === undefined ? null : String(args.save_changes) });
+    }
+
+    var documentId = Number(doc.id);
+    var name = String(doc.name);
+    var hadUnsavedChanges = doc.modified === true;
+    var currentPath = idcDocumentPath(doc);
+    var savedTo = '';
+    var target = null;
+
+    if (args.save_changes === 'yes') {
+      if (typeof args.path === 'string' && args.path.length > 0) {
+        target = IDC.fileFor(args.path);
+        savedTo = String(args.path);
+      } else if (currentPath === '') {
+        IDC.fail('invalid_argument',
+          'This document has never been saved; path is required when save_changes is "yes".', null);
+      } else {
+        savedTo = currentPath;
+      }
+    }
+
+    try {
+      if (args.save_changes === 'yes') {
+        if (target !== null) { doc.close(SaveOptions.YES, target); }
+        else { doc.close(SaveOptions.YES); }
+      } else {
+        doc.close(SaveOptions.NO);
+      }
+    } catch (e) {
+      IDC.fail('io_error', 'InDesign could not close the document: ' + String(e.message ? e.message : e),
+        { document_id: documentId });
+    }
+
+    var remaining = [];
+    var i;
+    for (i = 0; i < app.documents.length; i++) {
+      remaining.push(Number(app.documents.item(i).id));
+    }
+
+    ctx.changes = { closed_document_ids: [documentId] };
+
+    return {
+      document_id: documentId,
+      name: name,
+      saved_to: savedTo,
+      had_unsaved_changes: hadUnsavedChanges,
+      remaining_document_ids: remaining
+    };
+  });
+
+/* ------------------------------------------------------- create_document */
+
+var IDC_PAGE_PRESETS = {
+  A4: { width: 210, height: 297 },
+  Letter: { width: 215.9, height: 279.4 },
+  Legal: { width: 215.9, height: 355.6 },
+  Tabloid: { width: 279.4, height: 431.8 }
+};
+
+function idcIsNumber(value) {
+  return typeof value === 'number' && isFinite(value);
+}
+
+/* Seitenformat aus preset oder width_mm/height_mm, Ausrichtung beachten. */
+function idcPageSize(args) {
+  var width = null;
+  var height = null;
+  var preset;
+  var swap;
+
+  if (args.preset !== undefined && args.preset !== null) {
+    preset = IDC_PAGE_PRESETS[String(args.preset)];
+    if (!preset) {
+      IDC.fail('invalid_argument', 'preset must be one of A4, Letter, Legal, Tabloid.',
+        { preset: String(args.preset) });
+    }
+    width = preset.width;
+    height = preset.height;
+  }
+  if (idcIsNumber(args.width_mm)) { width = args.width_mm; }
+  if (idcIsNumber(args.height_mm)) { height = args.height_mm; }
+  if (width === null || height === null) {
+    IDC.fail('invalid_argument', 'Pass preset or both width_mm and height_mm.', null);
+  }
+  if (width <= 0 || height <= 0) {
+    IDC.fail('invalid_argument', 'width_mm and height_mm must be greater than 0.',
+      { width_mm: width, height_mm: height });
+  }
+
+  if (args.orientation === 'landscape') { swap = width < height; }
+  else if (args.orientation === 'portrait' || args.orientation === undefined) { swap = args.orientation === 'portrait' && width > height; }
+  else {
+    IDC.fail('invalid_argument', 'orientation must be "portrait" or "landscape".',
+      { orientation: String(args.orientation) });
+  }
+  if (swap) { return { width: height, height: width }; }
+  return { width: width, height: height };
+}
+
+/*
+ * Stege. InDesign kennt in der Skriptschnittstelle nur left/right; bei
+ * Doppelseiten bedeutet left "innen" und right "aussen" (Bund- und
+ * Aussensteg). inside/outside werden deshalb darauf abgebildet.
+ */
+function idcMargins(spec, facing, ctx) {
+  var out = { top: null, bottom: null, left: null, right: null };
+  var hasLR, hasIO;
+
+  if (!spec || typeof spec !== 'object') {
+    IDC.fail('invalid_argument',
+      'margins_mm is required: { top, bottom, left, right } or { top, bottom, inside, outside }.', null);
+  }
+  hasLR = idcIsNumber(spec.left) && idcIsNumber(spec.right);
+  hasIO = idcIsNumber(spec.inside) && idcIsNumber(spec.outside);
+  if (!idcIsNumber(spec.top) || !idcIsNumber(spec.bottom) || (!hasLR && !hasIO)) {
+    IDC.fail('invalid_argument',
+      'margins_mm needs top, bottom and either left/right or inside/outside, all numbers.', spec);
+  }
+  out.top = spec.top;
+  out.bottom = spec.bottom;
+  if (hasIO) {
+    out.left = spec.inside;
+    out.right = spec.outside;
+    if (!facing) { ctx.warn('inside/outside given for single pages: inside is used as left, outside as right.'); }
+  } else {
+    out.left = spec.left;
+    out.right = spec.right;
+    if (facing) { ctx.warn('left/right given for facing pages: left is the inside margin (Bundsteg), right the outside margin.'); }
+  }
+  var k;
+  for (k in out) {
+    if (IDC.hasOwn(out, k) && out[k] < 0) {
+      IDC.fail('invalid_argument', 'margins_mm.' + k + ' must not be negative.', spec);
+    }
+  }
+  return out;
+}
+
+function idcApplyMargins(target, margins, columns) {
+  var prefs = target.marginPreferences;
+  prefs.top = margins.top;
+  prefs.bottom = margins.bottom;
+  prefs.left = margins.left;
+  prefs.right = margins.right;
+  if (columns !== null) {
+    prefs.columnCount = columns.count;
+    prefs.columnGutter = columns.gutter_mm;
+  }
+}
+
+IDC.register('create_document', { needs_document: false, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var size = idcPageSize(args);
+    var facing = args.facing_pages === undefined ? true : args.facing_pages === true;
+    var pages = args.pages === undefined ? 1 : args.pages;
+    var columns = null;
+    var margins;
+    var doc, prefs, i, j, spread, page;
+    var pageIds = [];
+
+    if (!idcIsNumber(pages) || pages < 1 || Math.floor(pages) !== pages || pages > 9999) {
+      IDC.fail('invalid_argument', 'pages must be a whole number from 1 to 9999.', { pages: args.pages });
+    }
+    margins = idcMargins(args.margins_mm, facing, ctx);
+    if (args.columns !== undefined && args.columns !== null) {
+      if (typeof args.columns !== 'object' || !idcIsNumber(args.columns.count) || args.columns.count < 1) {
+        IDC.fail('invalid_argument', 'columns must be { count, gutter_mm } with count >= 1.', args.columns);
+      }
+      columns = {
+        count: Math.floor(args.columns.count),
+        gutter_mm: idcIsNumber(args.columns.gutter_mm) ? args.columns.gutter_mm : 4.233
+      };
+    }
+
+    try {
+      doc = app.documents.add();
+    } catch (e) {
+      IDC.fail('script_error', 'InDesign could not create a document: ' + String(e.message ? e.message : e), null);
+    }
+
+    try {
+      prefs = doc.documentPreferences;
+      prefs.facingPages = facing;
+      prefs.pageWidth = size.width;
+      prefs.pageHeight = size.height;
+      prefs.pagesPerDocument = pages;
+
+      /* Vorgabe fuer kuenftige Seiten, dann Musterseiten, dann die Seiten selbst. */
+      idcApplyMargins(doc, margins, columns);
+      for (i = 0; i < doc.masterSpreads.length; i++) {
+        spread = doc.masterSpreads.item(i);
+        for (j = 0; j < spread.pages.length; j++) {
+          idcApplyMargins(spread.pages.item(j), margins, columns);
+        }
+      }
+      for (i = 0; i < doc.pages.length; i++) {
+        page = doc.pages.item(i);
+        idcApplyMargins(page, margins, columns);
+        pageIds.push(Number(page.id));
+      }
+    } catch (e2) {
+      IDC.fail('script_error', 'Document was created but could not be set up: ' + String(e2.message ? e2.message : e2),
+        { document_id: Number(doc.id) });
+    }
+
+    ctx.changes = { created_document_ids: [Number(doc.id)] };
+
+    return {
+      document_id: Number(doc.id),
+      name: String(doc.name),
+      page_ids: pageIds,
+      page_count: doc.pages.length,
+      page_width_mm: IDC.round(prefs.pageWidth),
+      page_height_mm: IDC.round(prefs.pageHeight),
+      facing_pages: prefs.facingPages === true
+    };
+  });
+
+/* --------------------------------------------------------- save_document */
+
+IDC.register('save_document', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var target = null;
+
+    if (args.path !== undefined && args.path !== null) {
+      if (typeof args.path !== 'string' || args.path.length === 0) {
+        IDC.fail('invalid_argument', 'path must be a non-empty file path.', null);
+      }
+      target = IDC.fileFor(args.path);
+      if (!IDC.fileParentExists(target)) {
+        IDC.fail('io_error', 'The folder for the target path does not exist: ' + args.path, { path: args.path });
+      }
+    } else if (doc.saved !== true) {
+      IDC.fail('io_error',
+        'This document has never been saved; path is required for the first save.', null);
+    }
+
+    try {
+      if (target !== null) { doc.save(target); }
+      else { doc.save(); }
+    } catch (e) {
+      IDC.fail('io_error', 'InDesign could not save the document: ' + String(e.message ? e.message : e),
+        { path: target === null ? idcDocumentPath(doc) : args.path });
+    }
+
+    idcManagedSaveWarning(ctx, doc, target === null ? 'Only the layout file was saved.' :
+      'The document now continues under the new file and still links to the same story files.');
+    ctx.changes = { saved_document_ids: [Number(doc.id)] };
+    return {
+      document_id: Number(doc.id),
+      name: String(doc.name),
+      path: idcDocumentPath(doc)
+    };
+  });
+
+/* ---------------------------------------------------- set_document_bleed */
+
+/* Zahl = alle Kanten; Objekt = nur die genannten Kanten; Grenzen pruefen. */
+function idcEdges(value, field, max) {
+  var out = { top: null, left: null, bottom: null, right: null };
+  var keys = ['top', 'left', 'bottom', 'right'];
+  var i, k, any = false;
+
+  if (idcIsNumber(value)) {
+    for (i = 0; i < keys.length; i++) { out[keys[i]] = value; }
+    any = true;
+  } else if (value && typeof value === 'object') {
+    for (i = 0; i < keys.length; i++) {
+      k = keys[i];
+      if (value[k] !== undefined && value[k] !== null) {
+        if (!idcIsNumber(value[k])) {
+          IDC.fail('invalid_argument', field + '.' + k + ' must be a number.', value);
+        }
+        out[k] = value[k];
+        any = true;
+      }
+    }
+  } else {
+    IDC.fail('invalid_argument', field + ' must be a number or an object with top/left/bottom/right.', null);
+  }
+  if (!any) {
+    IDC.fail('invalid_argument', field + ' names no edge.', value);
+  }
+  for (i = 0; i < keys.length; i++) {
+    k = keys[i];
+    if (out[k] !== null && (out[k] < 0 || out[k] > max)) {
+      IDC.fail('invalid_argument', field + '.' + k + ' must be between 0 and ' + max + ' mm.', value);
+    }
+  }
+  return out;
+}
+
+function idcAllEqual(edges) {
+  return edges.top !== null && edges.left !== null && edges.bottom !== null && edges.right !== null
+    && edges.top === edges.left && edges.top === edges.bottom && edges.top === edges.right;
+}
+
+IDC.register('set_document_bleed', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var prefs = ctx.doc.documentPreferences;
+    var bleed = null;
+    var slug = null;
+    var changed = false;
+
+    if (args.bleed_mm !== undefined && args.bleed_mm !== null) { bleed = idcEdges(args.bleed_mm, 'bleed_mm', 50); }
+    if (args.slug_mm !== undefined && args.slug_mm !== null) { slug = idcEdges(args.slug_mm, 'slug_mm', 50); }
+
+    if (bleed !== null) {
+      prefs.documentBleedUniformSize = false;
+      if (bleed.top !== null) { prefs.documentBleedTopOffset = bleed.top; }
+      if (bleed.bottom !== null) { prefs.documentBleedBottomOffset = bleed.bottom; }
+      if (bleed.left !== null) { prefs.documentBleedInsideOrLeftOffset = bleed.left; }
+      if (bleed.right !== null) { prefs.documentBleedOutsideOrRightOffset = bleed.right; }
+      /* uniform nach dem, was jetzt wirklich steht – auch wenn nur eine Kante genannt war */
+      if (idcAllEqual({
+        top: prefs.documentBleedTopOffset, left: prefs.documentBleedInsideOrLeftOffset,
+        bottom: prefs.documentBleedBottomOffset, right: prefs.documentBleedOutsideOrRightOffset
+      })) { prefs.documentBleedUniformSize = true; }
+      changed = true;
+    }
+    if (slug !== null) {
+      prefs.documentSlugUniformSize = false;
+      if (slug.top !== null) { prefs.slugTopOffset = slug.top; }
+      if (slug.bottom !== null) { prefs.slugBottomOffset = slug.bottom; }
+      if (slug.left !== null) { prefs.slugInsideOrLeftOffset = slug.left; }
+      if (slug.right !== null) { prefs.slugRightOrOutsideOffset = slug.right; }
+      if (idcAllEqual({
+        top: prefs.slugTopOffset, left: prefs.slugInsideOrLeftOffset,
+        bottom: prefs.slugBottomOffset, right: prefs.slugRightOrOutsideOffset
+      })) { prefs.documentSlugUniformSize = true; }
+      changed = true;
+    }
+    if (!changed) { ctx.warn('Neither bleed_mm nor slug_mm given; nothing changed, current values returned.'); }
+    else { ctx.changes = { modified_document_ids: [Number(ctx.doc.id)] }; }
+
+    return {
+      bleed_mm: {
+        top: IDC.round(prefs.documentBleedTopOffset),
+        left: IDC.round(prefs.documentBleedInsideOrLeftOffset),
+        bottom: IDC.round(prefs.documentBleedBottomOffset),
+        right: IDC.round(prefs.documentBleedOutsideOrRightOffset)
+      },
+      slug_mm: {
+        top: IDC.round(prefs.slugTopOffset),
+        left: IDC.round(prefs.slugInsideOrLeftOffset),
+        bottom: IDC.round(prefs.slugBottomOffset),
+        right: IDC.round(prefs.slugRightOrOutsideOffset)
+      },
+      bleed_uniform: prefs.documentBleedUniformSize === true,
+      slug_uniform: prefs.documentSlugUniformSize === true
+    };
+  });