layoutbridge-spm 0.0.1 → 1.0.0

package/indesign/interpreter.js

@@ -0,0 +1,758 @@
+/*
+ * layoutbridge-spm – Befehlsinterpreter (bis 04.09.2026: indesign-connector-spm)
+ *
+ * Laeuft in InDesign. Nimmt einen Befehl {cmd, args} als JavaScript-Objekt,
+ * fuehrt ihn aus und liefert ein Ergebnisobjekt zurueck.
+ *
+ * Sprachumfang: gemeinsamer Nenner von ExtendScript (ES3) und UXP (ES6).
+ * Verboten und deshalb hier nicht benutzt: $-Objekt, #include, E4X, ScriptUI,
+ * UnitValue, globales document, JSON, Array.forEach/map/indexOf,
+ * Object.keys, String.trim, eckige Klammern auf DOM-Sammlungen,
+ * verschachtelte ?:-Ausdruecke ohne Klammern (ExtendScript klammert links).
+ *
+ * Diese Datei definiert nur den Kern. Die Handler stehen in commands/*.js und
+ * tragen sich ueber IDC.register() ein. Der Transport haengt Kern und Handler
+ * zu einem Skript zusammen; #include gibt es nicht.
+ */
+
+var IDC = (function () {
+  var api = {};
+
+  api.version = '0.1.0';
+  api.commands = {};
+  /* Der gerade laufende Befehlseintrag (name, read_only ...), sonst null. */
+  api.currentCommand = null;
+
+  /* ---------------------------------------------------------------- Fehler */
+
+  var KINDS = {
+    app_not_available: 1,
+    invalid_argument: 1,
+    not_found: 1,
+    invalid_state: 1,
+    io_error: 1,
+    timeout: 1,
+    script_error: 1
+  };
+
+  function IdcError(kind, message, details) {
+    this.isIdcError = true;
+    this.kind = KINDS[kind] ? kind : 'script_error';
+    this.message = String(message);
+    this.details = details === undefined ? null : details;
+  }
+
+  api.fail = function (kind, message, details) {
+    throw new IdcError(kind, message, details);
+  };
+
+  /* ------------------------------------------------------------- Werkzeuge */
+
+  function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  }
+
+  function isArray(v) {
+    return Object.prototype.toString.call(v) === '[object Array]';
+  }
+
+  api.hasOwn = hasOwn;
+  api.isArray = isArray;
+
+  /* Enumeratoren vergleichen: ExtendScript liefert Zahlen, UXP teils Text. */
+  function enumIs(value, expected) {
+    if (value === expected) { return true; }
+    var a = Number(value);
+    var b = Number(expected);
+    if (!isNaN(a) && !isNaN(b)) { return a === b; }
+    return String(value) === String(expected);
+  }
+  api.enumIs = enumIs;
+
+  /* Rundet Fliesskommarauschen weg (InDesign rechnet intern in Punkt). */
+  function round(value, digits) {
+    var d = digits === undefined ? 4 : digits;
+    var f = Math.pow(10, d);
+    var n = Number(value);
+    if (isNaN(n)) { return null; }
+    return Math.round(n * f) / f;
+  }
+  api.round = round;
+
+  /* --------------------------------------------------------- JSON-Ausgabe */
+
+  function pad4(hex) {
+    while (hex.length < 4) { hex = '0' + hex; }
+    return hex;
+  }
+
+  function quote(text) {
+    var out = '"';
+    var i, ch, code;
+    for (i = 0; i < text.length; i++) {
+      ch = text.charAt(i);
+      code = text.charCodeAt(i);
+      if (ch === '"') { out += '\\"'; }
+      else if (ch === '\\') { out += '\\\\'; }
+      else if (code === 8) { out += '\\b'; }
+      else if (code === 9) { out += '\\t'; }
+      else if (code === 10) { out += '\\n'; }
+      else if (code === 12) { out += '\\f'; }
+      else if (code === 13) { out += '\\r'; }
+      else if (code < 32 || code > 126) { out += '\\u' + pad4(code.toString(16)); }
+      else { out += ch; }
+    }
+    return out + '"';
+  }
+
+  /*
+   * Eigener JSON-Schreiber: ES3 kennt kein JSON-Objekt. Alles ausserhalb von
+   * ASCII wird als \uXXXX geschrieben, damit die Ergebnisdatei reines ASCII
+   * ist und keine Zeichensatzfrage offen bleibt.
+   */
+  function stringify(value) {
+    var t = typeof value;
+    var i, parts, keys, k;
+    if (value === null || value === undefined) { return 'null'; }
+    if (t === 'boolean') { return value ? 'true' : 'false'; }
+    if (t === 'number') { return isFinite(value) ? String(value) : 'null'; }
+    if (t === 'string') { return quote(value); }
+    if (isArray(value)) {
+      parts = [];
+      for (i = 0; i < value.length; i++) { parts.push(stringify(value[i])); }
+      return '[' + parts.join(',') + ']';
+    }
+    if (t === 'object') {
+      parts = [];
+      for (k in value) {
+        if (hasOwn(value, k) && typeof value[k] !== 'function') {
+          parts.push(quote(String(k)) + ':' + stringify(value[k]));
+        }
+      }
+      return '{' + parts.join(',') + '}';
+    }
+    return 'null';
+  }
+  api.stringify = stringify;
+
+  /* ------------------------------------------------------------ Handhabung */
+
+  /*
+   * options:
+   *   needs_document  true  = ein Dokument muss aufloesbar sein
+   *   read_only       true  = aendert nichts
+   *   ruler           'page' (Vorgabe) | 'spread' | 'none'
+   */
+  api.register = function (name, options, handler) {
+    var opt = options || {};
+    api.commands[name] = {
+      name: name,
+      needs_document: opt.needs_document === true,
+      read_only: opt.read_only === true,
+      ruler: opt.ruler || 'page',
+      handler: handler
+    };
+  };
+
+  /* ------------------------------------------------- Anwendung und Dokument */
+
+  function appIsReady() {
+    try {
+      if (typeof app === 'undefined' || app === null) { return false; }
+      var probe = app.name;
+      return probe !== undefined;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  api.documentById = function (id) {
+    var i, d;
+    for (i = 0; i < app.documents.length; i++) {
+      d = app.documents.item(i);
+      if (Number(d.id) === Number(id)) { return d; }
+    }
+    return null;
+  };
+
+  api.resolveDocument = function (args) {
+    var wanted = args && args.document_id !== undefined && args.document_id !== null
+      ? args.document_id : null;
+    var doc;
+    if (wanted !== null) {
+      doc = api.documentById(wanted);
+      if (doc === null) {
+        api.fail('not_found', 'No open document with document_id ' + wanted + '.',
+          { document_id: wanted });
+      }
+      return doc;
+    }
+    if (app.documents.length === 0) {
+      api.fail('not_found', 'No document is open. Open one first or pass document_id.', null);
+    }
+    try {
+      return app.activeDocument;
+    } catch (e) {
+      return app.documents.item(0);
+    }
+  };
+
+  /* Seite (auch Musterseite) ueber ihre ID finden. */
+  api.pageById = function (doc, id) {
+    var i, j, spread, page;
+    for (i = 0; i < doc.pages.length; i++) {
+      page = doc.pages.item(i);
+      if (Number(page.id) === Number(id)) {
+        return { page: page, is_parent_page: false };
+      }
+    }
+    for (i = 0; i < doc.masterSpreads.length; i++) {
+      spread = doc.masterSpreads.item(i);
+      for (j = 0; j < spread.pages.length; j++) {
+        page = spread.pages.item(j);
+        if (Number(page.id) === Number(id)) {
+          return { page: page, is_parent_page: true };
+        }
+      }
+    }
+    return null;
+  };
+
+  /* --------------------------------------------------- Masseinheiten-Klammer */
+
+  /*
+   * Fuehrt fn aus, waehrend die Skript-Masseinheit auf unit steht, und stellt
+   * sie danach zurueck. Fuer Punktwerte (Konturstaerke, Schriftgrad) genau um
+   * diese eine Zuweisung legen.
+   */
+  api.withUnit = function (unit, fn) {
+    var prev = app.scriptPreferences.measurementUnit;
+    app.scriptPreferences.measurementUnit = unit;
+    try {
+      return fn();
+    } finally {
+      app.scriptPreferences.measurementUnit = prev;
+    }
+  };
+
+  api.inPoints = function (fn) {
+    return api.withUnit(MeasurementUnits.POINTS, fn);
+  };
+
+  /*
+   * Konkretes Objekt zu einem Sammlungsverweis.
+   *
+   * ExtendScript liefert aus pageItems.item(i) nur einen allgemeinen
+   * "PageItem"-Verweis; erst getElements()[0] ist der TextFrame, das Rectangle
+   * usw. Ohne diesen Schritt kennt niemand die Art des Objekts. Am lebenden
+   * Dokument am 04.09.2026 beobachtet. Objekte ohne getElements() kommen
+   * unveraendert zurueck.
+   */
+  api.concrete = function (item) {
+    var elements;
+    try {
+      if (item && item.getElements) {
+        elements = item.getElements();
+        if (elements && elements.length > 0) { return elements[0]; }
+      }
+    } catch (e) { /* dann eben der Verweis selbst */ }
+    return item;
+  };
+
+  /* ------------------------------------------------ Klassen und Objektarten */
+
+  /*
+   * Klassenname eines DOM-Objekts.
+   *
+   * ExtendScript liefert ueber constructor.name nichts Brauchbares; dort steht
+   * die Art in "[object TextFrame]". UXP kann es umgekehrt halten. Deshalb
+   * alle Wege, in dieser Reihenfolge; reflect.name ist der rein
+   * ExtendScript-seitige Rueckfall.
+   */
+  api.className = function (item) {
+    var name = '';
+    var text, match;
+
+    try {
+      if (item.constructor && item.constructor.name) { name = String(item.constructor.name); }
+    } catch (e) { name = ''; }
+    if (name !== '' && name !== 'Object') { return name; }
+
+    try {
+      text = Object.prototype.toString.call(item);
+      match = text.match(/^\[object (.+)\]$/);
+      if (match) { return String(match[1]); }
+    } catch (e2) { /* naechster Versuch */ }
+
+    try {
+      text = String(item);
+      match = text.match(/^\[object (.+)\]$/);
+      if (match) { return String(match[1]); }
+    } catch (e3) { /* naechster Versuch */ }
+
+    try {
+      if (item.reflect && item.reflect.name) { return String(item.reflect.name); }
+    } catch (e4) { /* aufgeben */ }
+
+    return name;
+  };
+
+  /*
+   * Objektart nach Spezifikation: text|image|rectangle|line|group|other;
+   * seit A-8.9 (Sitzung 9) auch ellipse|polygon fuer leere Ovale und
+   * Polygone (mit Grafik bleiben sie image). Ein Rechteck mit Eckenoptionen
+   * bleibt rectangle.
+   */
+  api.itemType = function (item) {
+    var className = api.className(item);
+    var hasGraphic = false;
+
+    if (className === 'TextFrame') { return 'text'; }
+    if (className === 'Group') { return 'group'; }
+    if (className === 'GraphicLine') { return 'line'; }
+
+    if (className === 'Rectangle' || className === 'Oval' || className === 'Polygon') {
+      try { hasGraphic = item.allGraphics.length > 0; } catch (e) { hasGraphic = false; }
+      if (hasGraphic) { return 'image'; }
+      if (className === 'Rectangle') { return 'rectangle'; }
+      if (className === 'Oval') { return 'ellipse'; }
+      return 'polygon';
+    }
+    return 'other';
+  };
+
+  api.isTextFrame = function (item) {
+    return api.className(item) === 'TextFrame';
+  };
+
+  /*
+   * Druckbogen (Spread oder MasterSpread), auf dem ein Objekt liegt. Der
+   * parent eines Objekts ist der Bogen, bei Gruppenmitgliedern die Gruppe,
+   * bei verankerten Objekten die Textstelle – deshalb nach oben laufen.
+   */
+  api.spreadOfItem = function (item) {
+    var current = item;
+    var step, name;
+    for (step = 0; step < 12; step++) {
+      try {
+        name = api.className(current);
+        if (name === 'Spread' || name === 'MasterSpread') { return current; }
+        current = current.parent;
+        if (current === null || current === undefined) { return null; }
+      } catch (e) { return null; }
+    }
+    return null;
+  };
+
+  api.isOnParentSpread = function (item) {
+    var spread = api.spreadOfItem(item);
+    return spread !== null && api.className(spread) === 'MasterSpread';
+  };
+
+  function findInCollection(collection, wanted) {
+    var item;
+    try {
+      item = collection.itemByID(wanted);
+      if (item && item.isValid === true) { return api.concrete(item); }
+    } catch (e) { /* nicht hier */ }
+    return null;
+  }
+
+  /* allPageItems ist ein Array (kein DOM-Sammlungsobjekt), auch in Gruppen. */
+  function findInArray(array, wanted) {
+    var i;
+    try {
+      for (i = 0; i < array.length; i++) {
+        if (Number(array[i].id) === wanted) { return api.concrete(array[i]); }
+      }
+    } catch (e) { /* nicht hier */ }
+    return null;
+  }
+
+  /*
+   * Objekt (Rahmen, Linie, Gruppe) ueber seine ID finden.
+   * where: 'any' (Vorgabe) | 'document' (nur Dokumentseiten) | 'parent'
+   * (nur Musterseiten). Liefert { item, on_parent } oder null.
+   */
+  api.itemById = function (doc, id, where) {
+    var wanted = Number(id);
+    var scope = where || 'any';
+    var found = null;
+    var i, spread;
+
+    if (scope !== 'parent') {
+      found = findInCollection(doc.pageItems, wanted);
+      if (found === null) {
+        try { found = findInArray(doc.allPageItems, wanted); } catch (e) { found = null; }
+      }
+      if (found !== null) {
+        if (scope === 'document' && api.isOnParentSpread(found)) { return null; }
+        return { item: found, on_parent: api.isOnParentSpread(found) };
+      }
+    }
+    if (scope !== 'document') {
+      for (i = 0; i < doc.masterSpreads.length; i++) {
+        spread = doc.masterSpreads.item(i);
+        found = findInCollection(spread.pageItems, wanted);
+        if (found === null) {
+          try { found = findInArray(spread.allPageItems, wanted); } catch (e2) { found = null; }
+        }
+        if (found !== null) { return { item: found, on_parent: true }; }
+      }
+    }
+    return null;
+  };
+
+  /* Absatzformat ueber den Namen, auch in Formatgruppen. */
+  api.paragraphStyleByName = function (doc, name) {
+    var style, all, i;
+    try {
+      style = doc.paragraphStyles.itemByName(name);
+      if (style && style.isValid === true) { return style; }
+    } catch (e) { /* weiter */ }
+    try {
+      all = doc.allParagraphStyles;
+      for (i = 0; i < all.length; i++) {
+        if (String(all[i].name) === String(name)) { return all[i]; }
+      }
+    } catch (e2) { /* weiter */ }
+    return null;
+  };
+
+  /* ------------------------------------------------------ Seiten und Boegen */
+
+  api.spreadIndex = function (spread) {
+    try { return Number(spread.index); } catch (e) { return null; }
+  };
+
+  api.pageSide = function (page) {
+    var side;
+    try { side = page.side; } catch (e) { return 'SINGLE_SIDED'; }
+    if (enumIs(side, PageSideOptions.LEFT_HAND)) { return 'LEFT_HAND'; }
+    if (enumIs(side, PageSideOptions.RIGHT_HAND)) { return 'RIGHT_HAND'; }
+    return 'SINGLE_SIDED';
+  };
+
+  /* Seitenzahl je Druckbogen des Dokuments. */
+  api.spreadPageCounts = function (doc) {
+    var counts = [];
+    var i;
+    for (i = 0; i < doc.spreads.length; i++) {
+      counts.push(doc.spreads.item(i).pages.length);
+    }
+    return counts;
+  };
+
+  /*
+   * "Seiten neu anordnen" (allowPageShuffle) nur fuer die Dauer von fn
+   * umstellen. value null/undefined = unveraendert lassen.
+   */
+  api.withShuffle = function (doc, value, fn) {
+    var prev = null;
+    var set = false;
+    if (value !== null && value !== undefined) {
+      prev = doc.documentPreferences.allowPageShuffle;
+      doc.documentPreferences.allowPageShuffle = value === true;
+      set = true;
+    }
+    try {
+      return fn();
+    } finally {
+      if (set) { doc.documentPreferences.allowPageShuffle = prev; }
+    }
+  };
+
+  /*
+   * Lineal-Nullpunkt (Seite/Bogen) nur fuer die Dauer von fn umstellen –
+   * fuer coordinate_space "spread" innerhalb eines Aufrufs, der sonst auf
+   * "page" laeuft.
+   */
+  api.withRulerOrigin = function (doc, origin, fn) {
+    var prev = doc.viewPreferences.rulerOrigin;
+    doc.viewPreferences.rulerOrigin = origin;
+    try {
+      return fn();
+    } finally {
+      doc.viewPreferences.rulerOrigin = prev;
+    }
+  };
+
+  /*
+   * Wo ist ein Objekt gelandet? parentPage ist die Seite, auf der InDesign
+   * das Objekt fuehrt (null = Montageflaeche). Liefert
+   * { page_id, page_name, on_pasteboard }.
+   */
+  api.landing = function (item) {
+    var page = null;
+    try { page = item.parentPage; } catch (e) { page = null; }
+    var valid = false;
+    try { valid = page !== null && page !== undefined && page.isValid === true; } catch (e2) { valid = false; }
+    if (!valid) {
+      return { page_id: null, page_name: '', on_pasteboard: true };
+    }
+    return { page_id: Number(page.id), page_name: String(page.name), on_pasteboard: false };
+  };
+
+  /* Seitengroesse in mm ueber die Seitenbegrenzung (unter dem aktuellen Lineal). */
+  api.pageSize = function (page) {
+    var b = page.bounds;
+    return { width: round(b[3] - b[1]), height: round(b[2] - b[0]) };
+  };
+
+  /* Versatz einer Seite vom Anfang ihres Bogens in mm (Breiten der Seiten davor). */
+  api.spreadOffsetOfPage = function (page) {
+    var spread = null;
+    var i, other, offset = 0;
+    try { spread = page.parent; } catch (e) { return 0; }
+    if (spread === null || spread === undefined) { return 0; }
+    for (i = 0; i < spread.pages.length; i++) {
+      other = spread.pages.item(i);
+      if (Number(other.id) === Number(page.id)) { return offset; }
+      offset += api.pageSize(other).width;
+    }
+    return 0;
+  };
+
+  /*
+   * Begrenzung eines Objekts relativ zur linken oberen Ecke von page.
+   *
+   * InDesign liest geometricBounds unter Seiten-Nullpunkt relativ zur ersten
+   * Seite, die das Objekt beruehrt – ein Rahmen mit 3 mm Anschnitt auf der
+   * rechten Seite eines Bogens steht dann bei x = 207 der linken Seite (am
+   * lebenden InDesign 21.5 am 04.09.2026 gesehen). Deshalb unter Bogen-
+   * Nullpunkt lesen und selbst um den Seitenversatz verschieben. page null
+   * (Montageflaeche): Bogenkoordinaten.
+   */
+  api.boundsOnPage = function (doc, item, page) {
+    var bounds = api.withRulerOrigin(doc, RulerOrigin.SPREAD_ORIGIN, function () {
+      return item.geometricBounds;
+    });
+    var dx = page ? api.spreadOffsetOfPage(page) : 0;
+    return {
+      x: round(bounds[1] - dx),
+      y: round(bounds[0]),
+      width: round(bounds[3] - bounds[1]),
+      height: round(bounds[2] - bounds[0])
+    };
+  };
+
+  /* Begrenzung relativ zur Seite, auf der InDesign das Objekt fuehrt. */
+  api.boundsOnOwnPage = function (doc, item) {
+    var page = null;
+    try { page = item.parentPage; } catch (e) { page = null; }
+    var valid = false;
+    try { valid = page !== null && page !== undefined && page.isValid === true; } catch (e2) { valid = false; }
+    return api.boundsOnPage(doc, item, valid ? page : null);
+  };
+
+  /* geometricBounds ist [y1, x1, y2, x2]. */
+  api.boundsToRect = function (bounds) {
+    return {
+      x: round(bounds[1]),
+      y: round(bounds[0]),
+      width: round(bounds[3] - bounds[1]),
+      height: round(bounds[2] - bounds[0])
+    };
+  };
+
+  /* ------------------------------------------------------------- Ausfuehrung */
+
+  function restore(state) {
+    var problems = [];
+    if (state.docRulerSet) {
+      try { state.doc.viewPreferences.rulerOrigin = state.prevRulerOrigin; }
+      catch (e1) { problems.push('ruler origin: ' + String(e1)); }
+    }
+    if (state.zeroPointSet) {
+      try { state.doc.zeroPoint = state.prevZeroPoint; }
+      catch (e1b) { problems.push('zero point: ' + String(e1b)); }
+    }
+    if (state.unitSet) {
+      try { app.scriptPreferences.measurementUnit = state.prevUnit; }
+      catch (e2) { problems.push('measurement unit: ' + String(e2)); }
+    }
+    if (state.interactionSet) {
+      try { app.scriptPreferences.userInteractionLevel = state.prevInteraction; }
+      catch (e3) { problems.push('user interaction level: ' + String(e3)); }
+    }
+    return problems;
+  }
+
+  function toError(e) {
+    if (e && e.isIdcError) {
+      return { kind: e.kind, message: e.message, details: e.details };
+    }
+    var msg;
+    try { msg = String(e && e.message ? e.message : e); } catch (x) { msg = 'unknown error'; }
+    var details = null;
+    try {
+      if (e && e.line !== undefined) {
+        details = { line: e.line, file: e.fileName ? String(e.fileName) : null };
+      }
+    } catch (y) { details = null; }
+    return { kind: 'script_error', message: msg, details: details };
+  }
+
+  api.execute = function (command) {
+    var state = {
+      doc: null,
+      unitSet: false,
+      interactionSet: false,
+      docRulerSet: false,
+      zeroPointSet: false,
+      prevZeroPoint: null,
+      prevUnit: null,
+      prevInteraction: null,
+      prevRulerOrigin: null
+    };
+    var warnings = [];
+    var result;
+
+    try {
+      if (!command || typeof command.cmd !== 'string') {
+        api.fail('invalid_argument', 'Command must be an object with a "cmd" string.', null);
+      }
+      if (!hasOwn(api.commands, command.cmd)) {
+        api.fail('not_found', 'Unknown command: ' + command.cmd, { cmd: command.cmd });
+      }
+      if (!appIsReady()) {
+        api.fail('app_not_available', 'InDesign is not available or not ready.', null);
+      }
+
+      var entry = api.commands[command.cmd];
+      var args = command.args || {};
+
+      state.prevUnit = app.scriptPreferences.measurementUnit;
+      app.scriptPreferences.measurementUnit = MeasurementUnits.MILLIMETERS;
+      state.unitSet = true;
+
+      state.prevInteraction = app.scriptPreferences.userInteractionLevel;
+      app.scriptPreferences.userInteractionLevel = UserInteractionLevels.NEVER_INTERACT;
+      state.interactionSet = true;
+
+      var doc = null;
+      if (entry.needs_document) {
+        doc = api.resolveDocument(args);
+        state.doc = doc;
+        if (entry.ruler !== 'none') {
+          state.prevRulerOrigin = doc.viewPreferences.rulerOrigin;
+          doc.viewPreferences.rulerOrigin = (entry.ruler === 'spread')
+            ? RulerOrigin.SPREAD_ORIGIN
+            : RulerOrigin.PAGE_ORIGIN;
+          state.docRulerSet = true;
+          /*
+           * Der Nullpunkt kann vom Anwender verschoben sein; dann waeren alle
+           * Koordinaten um diesen Versatz falsch. Fuer die Dauer des Aufrufs
+           * auf [0, 0] und danach zurueck.
+           */
+          try {
+            state.prevZeroPoint = doc.zeroPoint;
+            if (state.prevZeroPoint && (Number(state.prevZeroPoint[0]) !== 0 || Number(state.prevZeroPoint[1]) !== 0)) {
+              doc.zeroPoint = [0, 0];
+              state.zeroPointSet = true;
+            }
+          } catch (ez) { state.zeroPointSet = false; }
+        }
+      }
+
+      var ctx = {
+        args: args,
+        doc: doc,
+        warnings: warnings,
+        changes: null,
+        warn: function (text) { warnings.push(String(text)); },
+        idc: api
+      };
+
+      /* Fuer Helfer, die wissen muessen, ob der laufende Befehl schreibt (Ebenensperre). */
+      api.currentCommand = entry;
+      var data = entry.handler(ctx);
+      if (data === null || data === undefined) { data = {}; }
+
+      result = { ok: true, warnings: warnings };
+      var key;
+      for (key in data) {
+        if (hasOwn(data, key)) { result[key] = data[key]; }
+      }
+      if (ctx.changes !== null) { result.changes = ctx.changes; }
+      if (doc !== null && result.document_id === undefined) {
+        try { result.document_id = Number(doc.id); } catch (eid) { /* egal */ }
+      }
+    } catch (err) {
+      result = { ok: false, warnings: warnings, error: toError(err) };
+    }
+
+    api.currentCommand = null;
+    var restoreProblems = restore(state);
+    var r;
+    for (r = 0; r < restoreProblems.length; r++) {
+      warnings.push('Could not restore setting – ' + restoreProblems[r]);
+    }
+    result.warnings = warnings;
+    return result;
+  };
+
+  api.run = function (command) {
+    var out;
+    try {
+      out = api.execute(command);
+    } catch (e) {
+      out = { ok: false, warnings: [], error: toError(e) };
+    }
+    return stringify(out);
+  };
+
+  return api;
+})();
+
+/*
+ * Kompatibilitaetsschicht fuer die bekannten Unterschiede zwischen
+ * ExtendScript und UXP. Bewusst klein gehalten und an einer Stelle gebuendelt.
+ */
+
+/* Dateiobjekt zu einem Pfad. ExtendScript kennt File, UXP nicht. */
+IDC.fileFor = function (path) {
+  if (typeof File !== 'undefined' && File !== null) {
+    return new File(String(path));
+  }
+  IDC.fail('invalid_state',
+    'This runtime has no ExtendScript File object; the UXP transport must hand over file entries.',
+    { path: String(path) });
+  return null;
+};
+
+/* Ordnerobjekt zu einem Pfad. ExtendScript kennt Folder, UXP nicht. */
+IDC.folderFor = function (path) {
+  if (typeof Folder !== 'undefined' && Folder !== null) {
+    return new Folder(String(path));
+  }
+  IDC.fail('invalid_state',
+    'This runtime has no ExtendScript Folder object; the UXP transport must hand over folder entries.',
+    { path: String(path) });
+  return null;
+};
+
+/* Betriebssystempfad eines Dateiobjekts, leer wenn nicht ermittelbar. */
+IDC.fsPath = function (fileObject) {
+  try {
+    if (fileObject && fileObject.fsName) { return String(fileObject.fsName); }
+  } catch (e) { /* faellt auf leer zurueck */ }
+  return '';
+};
+
+/* Groesse einer Datei in Bytes, null wenn nicht ermittelbar. */
+IDC.fileSize = function (fileObject) {
+  try {
+    if (fileObject && fileObject.exists && fileObject.length !== undefined) {
+      return Number(fileObject.length);
+    }
+  } catch (e) { /* null */ }
+  return null;
+};
+
+/* Gibt es den Ordner, in dem die Datei liegen soll? */
+IDC.fileParentExists = function (fileObject) {
+  try {
+    return fileObject && fileObject.parent && fileObject.parent.exists === true;
+  } catch (e) { return false; }
+};