layoutbridge-light 1.0.0 → 1.0.1

package/indesign/commands/25-export.js

@@ -114,7 +114,7 @@ function idcCountPagesInRange(doc, rangeText) {
  * app.pdfExportPreferences.useDocumentBleedWithPDF gesetzt und zurueckgestellt.
  * bleed null = wie die Vorgabe.
  */
-function idcExportPdfOnce(doc, file, preset, rangeText, bleed) {
+function idcExportPdfOnce(doc, file, preset, rangeText, bleed, access) {
   var prefs = app.pdfExportPreferences;
   var prevRange = null;
   var prevView = null;
@@ -124,21 +124,35 @@ function idcExportPdfOnce(doc, file, preset, rangeText, bleed) {
   var bleedSet = false;
   var temp = null;
   var used = preset;
+  var settings = idcPdfAccessSettings(access);
+  var prevAccess = null;
+  var key;
 
   try {
-    if (bleed !== null && preset !== null) {
+    if ((bleed !== null || settings !== null) && preset !== null) {
       try {
         temp = preset.duplicate();
-        temp.useDocumentBleedWithPDF = bleed;
+        if (bleed !== null) { temp.useDocumentBleedWithPDF = bleed; }
+        if (settings !== null) {
+          for (key in settings) { if (IDC.hasOwn(settings, key)) { temp[key] = settings[key]; } }
+        }
         used = temp;
       } catch (eDup) {
-        IDC.fail('script_error', 'Could not prepare the preset with use_document_bleed: ' + String(eDup.message ? eDup.message : eDup),
+        IDC.fail('script_error', 'Could not prepare the preset with ' + (bleed !== null ? 'use_document_bleed' : 'the accessibility settings') + ': ' + String(eDup.message ? eDup.message : eDup),
           { preset: String(preset.name) });
       }
-    } else if (bleed !== null) {
-      prevBleed = prefs.useDocumentBleedWithPDF;
-      prefs.useDocumentBleedWithPDF = bleed;
-      bleedSet = true;
+    } else {
+      if (bleed !== null) {
+        prevBleed = prefs.useDocumentBleedWithPDF;
+        prefs.useDocumentBleedWithPDF = bleed;
+        bleedSet = true;
+      }
+      if (settings !== null) {
+        prevAccess = {};
+        for (key in settings) {
+          if (IDC.hasOwn(settings, key)) { prevAccess[key] = prefs[key]; prefs[key] = settings[key]; }
+        }
+      }
     }
     try {
       prevView = prefs.viewPDF;
@@ -158,6 +172,9 @@ function idcExportPdfOnce(doc, file, preset, rangeText, bleed) {
     if (rangeSet) { try { prefs.pageRange = prevRange; } catch (e1) { /* egal */ } }
     if (viewSet) { try { prefs.viewPDF = prevView; } catch (e2) { /* egal */ } }
     if (bleedSet) { try { prefs.useDocumentBleedWithPDF = prevBleed; } catch (e3) { /* egal */ } }
+    if (prevAccess !== null) {
+      for (key in prevAccess) { if (IDC.hasOwn(prevAccess, key)) { try { prefs[key] = prevAccess[key]; } catch (e5) { /* egal */ } } }
+    }
     if (temp !== null) { try { temp.remove(); } catch (e4) { /* bleibt als Kopie stehen */ } }
   }
   /*
@@ -227,7 +244,10 @@ IDC.register('export_pdf', { needs_document: true, read_only: false, ruler: 'non
       ctx.warn('use_document_bleed is true, but the document bleed (Anschnitt) is 0 mm on every edge – set_document_bleed first.');
     }
 
-    bytes = idcExportPdfOnce(doc, file, preset, rangeText, bleed);
+    var access = idcPdfAccessArgs(args, false);
+    var accessResult = access.any ? idcPrepareAccessibleExport(ctx, doc, access, preset, false) : null;
+
+    bytes = idcExportPdfOnce(doc, file, preset, rangeText, bleed, access);
 
     fallbackName = args.fallback_preset === undefined || args.fallback_preset === null
       ? '' : String(args.fallback_preset);
@@ -238,9 +258,14 @@ IDC.register('export_pdf', { needs_document: true, read_only: false, ruler: 'non
       fallback = idcPdfPresetByName(fallbackName);
       if (fallback === null) {
         ctx.warn('PDF is ' + bytes + ' bytes (over ' + threshold + '), but fallback preset "' + fallbackName + '" was not found; first export kept.');
+      } else if (access.tagged === true && idcPresetIsAcrobat4(fallback)) {
+        ctx.warn('PDF is ' + bytes + ' bytes (over ' + threshold + '), but fallback preset "' + fallbackName + '" writes PDF 1.3 (Acrobat 4) without tags; the first, tagged export is kept.');
+        fallback = null;
       } else {
         ctx.warn('PDF was ' + bytes + ' bytes (over ' + threshold + '); exported again with "' + fallbackName + '". A spread preset turns single pages into spreads (Doppelseiten) – check exported_page_count.');
-        bytes = idcExportPdfOnce(doc, file, fallback, rangeText, bleed);
+      }
+      if (fallback !== null) {
+        bytes = idcExportPdfOnce(doc, file, fallback, rangeText, bleed, access);
         preset = fallback;
         presetUsed = fallbackName;
         if (bytes !== null && bytes > threshold) {
@@ -251,7 +276,7 @@ IDC.register('export_pdf', { needs_document: true, read_only: false, ruler: 'non
 
     ctx.changes = { exported_files: [IDC.fsPath(file)] };
 
-    return {
+    var answer = {
       path: IDC.fsPath(file),
       page_count: exportedCount,
       exported_page_count: exportedCount,
@@ -262,6 +287,8 @@ IDC.register('export_pdf', { needs_document: true, read_only: false, ruler: 'non
       document_bleed_used: idcBleedInEffect(preset, bleed),
       document_bleed_mm: docBleed
     };
+    if (accessResult !== null) { idcAddAccessAnswer(answer, accessResult); }
+    return answer;
   });
 
 /* Anschnitt des Dokuments in mm (innen/links, aussen/rechts wie InDesign). */
@@ -446,3 +473,223 @@ IDC.register('preflight_document', { needs_document: true, read_only: true, rule
       findings: capped
     };
   });
+
+/* ------------------------------------- Barrierefreiheit beim Export (A-80, Sitzung 82) */
+
+/*
+ * Neue, optionale Parameter an export_pdf und export_interactive_pdf (E-117,
+ * E-120, E-121). Ohne sie bleibt jeder Aufruf wie bisher. Die Werte gelten
+ * nur fuer den Aufruf: an einer Kopie der Vorgabe (wie use_document_bleed)
+ * oder an den Exporteinstellungen, die danach zurueckgestellt werden
+ * (Beleg 10 der Vorabpruefung: Vorgabe und Einstellungen danach unveraendert).
+ */
+function idcAccBoolArg(args, field) {
+  if (!idcGiven(args[field])) { return null; }
+  if (args[field] !== true && args[field] !== false) {
+    IDC.fail('invalid_argument', field + ' must be true or false.', { value: args[field] });
+  }
+  return args[field];
+}
+
+function idcPdfAccessArgs(args, interactive) {
+  var a = { any: false, tagged: null, bookmarks: null, tab_order: null, display_title: null, language: null, title: null, pdfua: false, artifact_paths: false };
+  a.tagged = idcAccBoolArg(args, 'tagged');
+  if (!interactive) { a.bookmarks = idcAccBoolArg(args, 'bookmarks'); }
+  if (interactive) { a.tab_order = idcAccBoolArg(args, 'tab_order_from_structure'); }
+  if (idcGiven(args.display_title)) {
+    if (args.display_title !== 'document_title' && args.display_title !== 'file_name') {
+      IDC.fail('invalid_argument', 'display_title must be document_title or file_name.', { value: args.display_title });
+    }
+    a.display_title = args.display_title;
+  }
+  if (idcGiven(args.pdf_language)) { a.language = idcPdfLanguageArg(args.pdf_language, 'pdf_language'); }
+  if (idcGiven(args.title)) {
+    if (typeof args.title !== 'string' || idcTrim(args.title) === '') { IDC.fail('invalid_argument', 'title must be a non-empty text.', null); }
+    a.title = String(args.title);
+  }
+  if (idcAccBoolArg(args, 'pdfua_identifier') === true) {
+    if (a.tagged === false) {
+      IDC.fail('invalid_argument', 'pdfua_identifier needs a tagged PDF; leave tagged out or pass true.', { code: 'pdfua_needs_tags' });
+    }
+    if (a.display_title === 'file_name') {
+      IDC.fail('invalid_argument', 'pdfua_identifier needs display_title document_title (PDF/UA shows the document title).', { code: 'pdfua_needs_document_title' });
+    }
+    a.tagged = true;
+    if (a.display_title === null) { a.display_title = 'document_title'; }
+    a.pdfua = true;
+  }
+  /*
+   * Entscheidung des Anbieters 11.11.2026 (Rueckfrage 1 b, E-120 Nachtrag): mit
+   * tagged true (auch ueber pdfua_identifier) schliesst der Server die
+   * ungetaggten Rahmen- und Tabellenkonturen automatisch als Artefakt ein;
+   * artifact_untagged_paths false schaltet es ab, true geht auch ohne tagged.
+   */
+  a.artifact_explicit = idcAccBoolArg(args, 'artifact_untagged_paths');
+  if (a.artifact_explicit === true && a.tagged === false) {
+    IDC.fail('invalid_argument', 'artifact_untagged_paths belongs to a tagged PDF; it is pointless with tagged false.', { code: 'artifact_paths_needs_tags' });
+  }
+  a.artifact_paths = a.artifact_explicit === true || (a.artifact_explicit === null && a.tagged === true);
+  if (interactive && a.tagged === true && a.tab_order === null) { a.tab_order = true; }
+  a.any = a.tagged !== null || a.bookmarks !== null || a.tab_order !== null || a.display_title !== null || a.language !== null || a.title !== null || a.pdfua || a.artifact_paths || a.artifact_explicit !== null;
+  return a;
+}
+
+function idcDisplayTitleEnum(name) {
+  if (typeof PdfDisplayTitleOptions === 'undefined') {
+    IDC.fail('invalid_state', 'This InDesign has no display title setting (PdfDisplayTitleOptions).', null);
+  }
+  return name === 'document_title' ? PdfDisplayTitleOptions.DISPLAY_DOCUMENT_TITLE : PdfDisplayTitleOptions.DISPLAY_FILE_NAME;
+}
+
+/* Einstellungen fuer den Druck-PDF-Export, null wenn keine. */
+function idcPdfAccessSettings(access) {
+  var s = {}, any = false;
+  if (access === undefined || access === null || !access.any) { return null; }
+  if (access.tagged !== null) { s.includeStructure = access.tagged; any = true; }
+  if (access.bookmarks !== null) { s.includeBookmarks = access.bookmarks; any = true; }
+  if (access.display_title !== null) { s.pdfDisplayTitle = idcDisplayTitleEnum(access.display_title); any = true; }
+  if (access.language !== null) { s.defaultDocumentLanguage = access.language.value; any = true; }
+  return any ? s : null;
+}
+
+function idcPresetIsAcrobat4(preset) {
+  try {
+    if (typeof AcrobatCompatibility === 'undefined') { return false; }
+    if (preset === null) { return IDC.enumIs(app.pdfExportPreferences.acrobatCompatibility, AcrobatCompatibility.ACROBAT_4); }
+    return IDC.enumIs(preset.acrobatCompatibility, AcrobatCompatibility.ACROBAT_4);
+  } catch (e) { return false; }
+}
+
+/* Sprache, mit der exportiert wird: Aufruf, sonst Vorgabe bzw. Exporteinstellung. */
+function idcExportLanguage(access, preset, interactive) {
+  if (access.language !== null) { return { value: access.language.value, source: 'call' }; }
+  try {
+    if (interactive) { return { value: String(app.interactivePDFExportPreferences.defaultDocumentLanguage), source: 'interactive export settings' }; }
+    if (preset !== null) { return { value: String(preset.defaultDocumentLanguage), source: 'preset "' + String(preset.name) + '"' }; }
+    return { value: String(app.pdfExportPreferences.defaultDocumentLanguage), source: 'export settings' };
+  } catch (e) { return { value: null, source: 'unknown' }; }
+}
+
+/*
+ * Vor dem Export: Kompatibilitaet, Titel, Pruefung fuer die PDF/UA-Kennung
+ * (Entscheidung des Anbieters 11.11.2026, Mittelweg: Kennung nur nach fehlerfreiem
+ * check_accessibility; sonst invalid_state mit den Befunden, E-121).
+ */
+function idcPrepareAccessibleExport(ctx, doc, access, preset, interactive) {
+  var r = { access: access, title_set: null, pdfua_check: null, language: null };
+  var previous = null, check, errors = [], warnings = 0, i;
+
+  if (!interactive && access.tagged === true && idcPresetIsAcrobat4(preset)) {
+    IDC.fail('invalid_argument', 'The preset ' + (preset === null ? '(current export settings)' : '"' + String(preset.name) + '"') + ' writes PDF 1.3 (Acrobat 4), which has no tags. Choose a preset with Acrobat 5 or later for tagged true.',
+      { code: 'preset_without_tags', preset: preset === null ? null : String(preset.name) });
+  }
+  r.language = idcExportLanguage(access, preset, interactive);
+  if (access.pdfua) {
+    /* Live-Fund Sitzung 82: documentTitle = "" laesst InDesign 21.6 unbeachtet – deshalb erst pruefen, dann den Titel schreiben. */
+    check = idcAccessibilityFindings(doc, { pdf_language: r.language.value, pdf_language_source: r.language.source, artifact_untagged_paths: access.artifact_paths, planned_title: access.title });
+    for (i = 0; i < check.findings.length; i++) {
+      if (check.findings[i].severity === 'error') { errors.push(check.findings[i]); } else { warnings += 1; }
+    }
+    if (errors.length > 0) {
+      IDC.fail('invalid_state', 'No PDF/UA identifier: check_accessibility reports ' + errors.length + ' error(s) for this document and these export settings; nothing was exported. Fix them, or export without pdfua_identifier.',
+        { code: 'accessibility_check_failed', errors: errors.length, warnings: warnings, findings: errors.length > 50 ? errors.slice(0, 50) : errors });
+    }
+    r.pdfua_check = { passed: true, errors: 0, warnings: warnings };
+  }
+  if (access.title !== null) {
+    try { previous = String(doc.metadataPreferences.documentTitle); } catch (e0) { previous = null; }
+    try { doc.metadataPreferences.documentTitle = access.title; } catch (e1) {
+      IDC.fail('script_error', 'InDesign could not set the document title: ' + String(e1.message ? e1.message : e1), null);
+    }
+    r.title_set = { value: access.title, previous: previous };
+  }
+  if ((access.tagged === true) && doc.articles.length > 0 && idcStructureOrderIsArticles(doc) === false) {
+    ctx.warn('The document has articles, but the tagged PDF does not use them for the reading order (define_article use_for_tagged_pdf true).');
+  }
+  if (r.title_set !== null) { ctx.warn('title was written into the document (File Info) and stays there; save or close without saving as you wish.'); }
+  return r;
+}
+
+function idcAddAccessAnswer(answer, r) {
+  answer.tagged = r.access.tagged;
+  answer.display_title = r.access.display_title;
+  answer.pdf_language_used = r.language.value;
+  answer.pdf_language_source = r.language.source;
+  answer.title_set = r.title_set;
+  answer.pdfua_check = r.pdfua_check;
+  answer.pdfua_identifier_requested = r.access.pdfua;
+  answer.artifact_untagged_paths_requested = r.access.artifact_paths;
+}
+
+/* ----------------------------------------------------- export_interactive_pdf */
+
+IDC.register('export_interactive_pdf', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var file, rangeText, exportedCount, access, r, prefs, keys, prev = {}, set = {}, i, bytes, used = {};
+
+    if (typeof args.path !== 'string' || args.path.length === 0) {
+      IDC.fail('invalid_argument', 'path is required (the target file path).', null);
+    }
+    file = IDC.fileFor(args.path);
+    if (!IDC.fileParentExists(file)) {
+      IDC.fail('io_error', 'The folder for the target path does not exist: ' + args.path, { path: args.path });
+    }
+    if (typeof ExportFormat === 'undefined' || ExportFormat.INTERACTIVE_PDF === undefined) {
+      IDC.fail('invalid_state', 'This InDesign has no interactive PDF export.', null);
+    }
+    rangeText = null;
+    if (args.page_range !== undefined && args.page_range !== null && idcTrim(args.page_range) !== ''
+      && idcTrim(args.page_range).toLowerCase() !== 'all') {
+      rangeText = idcTrim(args.page_range);
+      exportedCount = idcCountPagesInRange(doc, rangeText);
+    } else {
+      exportedCount = doc.pages.length;
+    }
+    access = idcPdfAccessArgs(args, true);
+    r = idcPrepareAccessibleExport(ctx, doc, access, null, true);
+
+    prefs = app.interactivePDFExportPreferences;
+    set.pageRange = rangeText === null ? PageRange.ALL_PAGES : rangeText;
+    set.viewPDF = false;
+    if (access.tagged !== null) { set.includeStructure = access.tagged; }
+    if (access.tab_order !== null) { set.usePDFStructureForTabOrder = access.tab_order; }
+    if (access.display_title !== null) { set.pdfDisplayTitle = idcDisplayTitleEnum(access.display_title); }
+    if (access.language !== null) { set.defaultDocumentLanguage = access.language.value; }
+    keys = [];
+    for (i in set) { if (IDC.hasOwn(set, i)) { keys.push(i); } }
+    try {
+      for (i = 0; i < keys.length; i++) {
+        try { prev[keys[i]] = prefs[keys[i]]; } catch (eRead) { /* Eigenschaft fehlt */ }
+        prefs[keys[i]] = set[keys[i]];
+      }
+      try { used.tagged = prefs.includeStructure === true; } catch (eU1) { used.tagged = null; }
+      try { used.tab_order_from_structure = prefs.usePDFStructureForTabOrder === true; } catch (eU2) { used.tab_order_from_structure = null; }
+      try {
+        used.display_title = IDC.enumIs(prefs.pdfDisplayTitle, PdfDisplayTitleOptions.DISPLAY_DOCUMENT_TITLE) ? 'document_title' : 'file_name';
+      } catch (eU3) { used.display_title = null; }
+      try { used.pdf_language = String(prefs.defaultDocumentLanguage); } catch (eU4) { used.pdf_language = null; }
+      doc.exportFile(ExportFormat.INTERACTIVE_PDF, file, false);
+    } catch (e) {
+      if (e && e.isIdcError) { throw e; }
+      IDC.fail('io_error', 'Interactive PDF export failed: ' + String(e.message ? e.message : e), { path: IDC.fsPath(file) });
+    } finally {
+      for (i = 0; i < keys.length; i++) {
+        if (IDC.hasOwn(prev, keys[i])) { try { prefs[keys[i]] = prev[keys[i]]; } catch (eBack) { /* egal */ } }
+      }
+    }
+    bytes = IDC.fileSize(IDC.fileFor(IDC.fsPath(file)));
+    ctx.changes = { exported_files: [IDC.fsPath(file)] };
+    var answer = {
+      path: IDC.fsPath(file),
+      exported_page_count: exportedCount,
+      document_page_count: doc.pages.length,
+      bytes: bytes,
+      page_range_used: rangeText === null ? 'all' : rangeText,
+      settings_used: used
+    };
+    idcAddAccessAnswer(answer, r);
+    answer.tagged = used.tagged;
+    return answer;
+  });

package/indesign/commands/26-export-image.js

@@ -123,7 +123,7 @@ IDC.register('export_page_image', { needs_document: true, read_only: false, rule
     pages = idcPagesForExport(doc, args);
     file = IDC.fileFor(path);
     if (!IDC.fileParentExists(file)) {
-      IDC.fail('io_error', 'The folder for ' + path + ' does not exist.', { path: path });
+      IDC.fail('io_error', 'The folder for ' + path + ' does not exist (pass create_folder true to create it).', { path: path });
     }
 
     prefs = format === 'png' ? app.pngExportPreferences : app.jpegExportPreferences;

package/indesign/commands/31-view.js

@@ -208,3 +208,103 @@ IDC.register('show_page', { needs_document: true, read_only: false, ruler: 'none
       previous_view: { active_page_id: before.active_page_id, active_page_name: before.active_page_name, zoom_percentage: before.zoom_percentage }
     };
   });
+
+/* ------------------------------------------------------- set_view_options */
+
+/*
+ * A-68 (10), Sitzung 81 – Ansichtsoptionen fuer Bildschirmaufnahmen und
+ * Sichtpruefung. Grundlage Probe InDesign 21.6 am 11.11.2026:
+ * guidePreferences.guidesShown, viewPreferences.showFrameEdges und
+ * showTextThreads, gridPreferences.baselineGridShown und documentGridShown,
+ * textPreferences.showInvisibles (Dokument), LayoutWindow.screenMode
+ * (ScreenModeOptions PREVIEW_OFF, PREVIEW_TO_PAGE, PREVIEW_TO_BLEED,
+ * PREVIEW_TO_SLUG, PRESENTATION_PREVIEW). Aendert nur die Ansicht.
+ */
+var IDC_VIEW_FLAGS = [
+  ['guides_shown', 'guidePreferences', 'guidesShown'],
+  ['frame_edges_shown', 'viewPreferences', 'showFrameEdges'],
+  ['text_threads_shown', 'viewPreferences', 'showTextThreads'],
+  ['baseline_grid_shown', 'gridPreferences', 'baselineGridShown'],
+  ['document_grid_shown', 'gridPreferences', 'documentGridShown'],
+  ['hidden_characters_shown', 'textPreferences', 'showInvisibles']
+];
+var IDC_SCREEN_MODES = [
+  ['normal', 'PREVIEW_OFF'], ['preview', 'PREVIEW_TO_PAGE'], ['bleed', 'PREVIEW_TO_BLEED'],
+  ['slug', 'PREVIEW_TO_SLUG'], ['presentation', 'PRESENTATION_PREVIEW']
+];
+
+function idcScreenModeName(value) {
+  var i;
+  if (value === undefined || value === null || typeof ScreenModeOptions === 'undefined') { return null; }
+  for (i = 0; i < IDC_SCREEN_MODES.length; i++) {
+    try { if (IDC.enumIs(value, ScreenModeOptions[IDC_SCREEN_MODES[i][1]])) { return IDC_SCREEN_MODES[i][0]; } } catch (e) { /* weiter */ }
+  }
+  return String(value);
+}
+
+function idcReadViewOptions(doc, win) {
+  var out = {}, i, prefs;
+  for (i = 0; i < IDC_VIEW_FLAGS.length; i++) {
+    out[IDC_VIEW_FLAGS[i][0]] = null;
+    try {
+      prefs = doc[IDC_VIEW_FLAGS[i][1]];
+      out[IDC_VIEW_FLAGS[i][0]] = prefs[IDC_VIEW_FLAGS[i][2]] === true;
+    } catch (e) { /* bleibt null */ }
+  }
+  out.screen_mode = null;
+  if (win !== null) {
+    try { out.screen_mode = idcScreenModeName(win.screenMode); } catch (e2) { /* bleibt null */ }
+  }
+  return out;
+}
+
+IDC.register('set_view_options', { needs_document: true, read_only: false, ruler: 'none' },
+  function (ctx) {
+    var args = ctx.args;
+    var doc = ctx.doc;
+    var win = idcLayoutWindowOf(doc);
+    var given = false, i, key, mode = null, before, after, problems = [];
+
+    for (i = 0; i < IDC_VIEW_FLAGS.length; i++) {
+      key = IDC_VIEW_FLAGS[i][0];
+      if (idcGiven(args[key])) {
+        given = true;
+        if (typeof args[key] !== 'boolean') { IDC.fail('invalid_argument', key + ' must be true or false.', { field: key, value: args[key] }); }
+      }
+    }
+    if (idcGiven(args.screen_mode)) {
+      given = true;
+      if (typeof ScreenModeOptions === 'undefined') { IDC.fail('invalid_state', 'This runtime has no ScreenModeOptions enumeration.', null); }
+      for (i = 0; i < IDC_SCREEN_MODES.length; i++) {
+        if (IDC_SCREEN_MODES[i][0] === args.screen_mode) { mode = ScreenModeOptions[IDC_SCREEN_MODES[i][1]]; }
+      }
+      if (mode === null) {
+        IDC.fail('invalid_argument', 'screen_mode must be normal, preview, bleed, slug or presentation.', { screen_mode: args.screen_mode });
+      }
+      if (win === null) {
+        IDC.fail('invalid_state', 'The document has no layout window (opened with show_window false); screen_mode needs one.', { code: 'no_layout_window' });
+      }
+    }
+    if (!given) {
+      IDC.fail('invalid_argument', 'Pass at least one of guides_shown, frame_edges_shown, text_threads_shown, baseline_grid_shown, document_grid_shown, hidden_characters_shown or screen_mode.', null);
+    }
+
+    before = idcReadViewOptions(doc, win);
+    for (i = 0; i < IDC_VIEW_FLAGS.length; i++) {
+      key = IDC_VIEW_FLAGS[i][0];
+      if (!idcGiven(args[key])) { continue; }
+      try { doc[IDC_VIEW_FLAGS[i][1]][IDC_VIEW_FLAGS[i][2]] = args[key]; } catch (e) {
+        problems.push(key + ': ' + String(e.message ? e.message : e));
+      }
+    }
+    if (mode !== null) {
+      try { win.screenMode = mode; } catch (e2) { problems.push('screen_mode: ' + String(e2.message ? e2.message : e2)); }
+    }
+    if (problems.length > 0) { ctx.warn('Some view options could not be set: ' + problems.join('; ')); }
+    after = idcReadViewOptions(doc, win);
+    return {
+      has_window: win !== null,
+      view_options: after,
+      previous: before
+    };
+  });

package/indesign/commands/35-parents.js

@@ -306,41 +306,61 @@ IDC.register('apply_parent_to_page', { needs_document: true, read_only: false, r
   function (ctx) {
     var args = ctx.args;
     var doc = ctx.doc;
-    var found, page, spread;
+    var found, spread = null, ids = [], pages = [], out = [], i, j, seen, noParent;
 
-    if (args.page_id === undefined || args.page_id === null) {
-      IDC.fail('invalid_argument', 'page_id is required.', null);
+    /* A-68 (5), Sitzung 81: page_ids fuer mehrere Seiten auf einmal; page_id allein wie bisher. */
+    if (args.page_id !== undefined && args.page_id !== null) { ids.push(args.page_id); }
+    if (args.page_ids !== undefined && args.page_ids !== null) {
+      if (!IDC.isArray(args.page_ids) || args.page_ids.length === 0) {
+        IDC.fail('invalid_argument', 'page_ids must be a non-empty list of page ids.', { page_ids: args.page_ids });
+      }
+      for (i = 0; i < args.page_ids.length; i++) {
+        seen = false;
+        for (j = 0; j < ids.length; j++) { if (Number(ids[j]) === Number(args.page_ids[i])) { seen = true; } }
+        if (!seen) { ids.push(args.page_ids[i]); }
+      }
+    }
+    if (ids.length === 0) {
+      IDC.fail('invalid_argument', 'page_id or page_ids is required.', null);
     }
     if (args.parent_name === undefined || args.parent_name === null) {
       IDC.fail('invalid_argument', 'parent_name is required (full name such as "A-Grundlayout", or "[None]" to detach).', null);
     }
-    found = IDC.pageById(doc, args.page_id);
-    if (found === null) {
-      IDC.fail('not_found', 'No page with page_id ' + args.page_id + ' in this document.', { page_id: args.page_id });
+    /* Erst alle Seiten und die Musterseite pruefen, dann schreiben (nichts Halbfertiges). */
+    for (i = 0; i < ids.length; i++) {
+      found = IDC.pageById(doc, ids[i]);
+      if (found === null) {
+        IDC.fail('not_found', 'No page with page_id ' + ids[i] + ' in this document.', { page_id: ids[i] });
+      }
+      pages.push(found.page);
+    }
+    noParent = idcMeansNoParent(args.parent_name);
+    if (!noParent) {
+      spread = idcMasterSpreadByName(doc, args.parent_name);
+      if (spread === null) {
+        IDC.fail('not_found', 'No master page named "' + args.parent_name + '". Use the full name with prefix.',
+          { parent_name: String(args.parent_name), available: idcMasterSpreadNames(doc) });
+      }
     }
-    page = found.page;
 
-    try {
-      if (idcMeansNoParent(args.parent_name)) {
-        page.appliedMaster = NothingEnum.NOTHING;
-      } else {
-        spread = idcMasterSpreadByName(doc, args.parent_name);
-        if (spread === null) {
-          IDC.fail('not_found', 'No master page named "' + args.parent_name + '". Use the full name with prefix.',
-            { parent_name: String(args.parent_name), available: idcMasterSpreadNames(doc) });
-        }
-        page.appliedMaster = spread;
+    for (i = 0; i < pages.length; i++) {
+      try {
+        if (noParent) { pages[i].appliedMaster = NothingEnum.NOTHING; }
+        else { pages[i].appliedMaster = spread; }
+      } catch (e) {
+        IDC.fail('script_error', 'InDesign could not apply the master page: ' + String(e.message ? e.message : e),
+          { page_id: Number(pages[i].id), parent_name: String(args.parent_name), pages_done: i });
       }
-    } catch (e) {
-      if (e && e.isIdcError) { throw e; }
-      IDC.fail('script_error', 'InDesign could not apply the master page: ' + String(e.message ? e.message : e),
-        { page_id: args.page_id, parent_name: String(args.parent_name) });
     }
 
-    ctx.changes = { modified_page_ids: [Number(page.id)] };
+    for (i = 0; i < pages.length; i++) {
+      out.push({ page_id: Number(pages[i].id), parent_applied: idcAppliedParentName(pages[i]) });
+    }
+    ctx.changes = { modified_page_ids: (function () { var a = [], k; for (k = 0; k < out.length; k++) { a.push(out[k].page_id); } return a; })() };
     return {
-      page_id: Number(page.id),
-      parent_applied: idcAppliedParentName(page)
+      page_id: out[0].page_id,
+      parent_applied: out[0].parent_applied,
+      pages: out
     };
   });
 

package/indesign/commands/40-frames.js

@@ -666,6 +666,35 @@ IDC.register('create_line', { needs_document: true, read_only: false, ruler: 'pa
 
 /* ---------------------------------------------------------- duplicate_frame */
 
+/*
+ * A-73 (Sitzung 80): allPageItems liefert auch die platzierten Grafiken in
+ * einem Rahmen (Bild, PDF, EPS ...). Deren ID ist kein Seitenobjekt; ein
+ * Befehl daran (z. B. move() einer Grafik auf eine Seite) kann InDesign
+ * beenden (09.11.2026, InDesign 21.6). Deshalb not_found mit der gefundenen
+ * Objektart und der ID des Rahmens. In einen Rahmen eingefuegte Rahmen
+ * (Rechteck, Textrahmen, Gruppe ...) bleiben wie bisher erlaubt.
+ */
+var IDC_FRAME_CLASSES = ['TextFrame', 'Rectangle', 'Oval', 'Polygon', 'GraphicLine', 'Group', 'Button', 'MultiStateObject', 'FormField', 'EPSText'];
+
+function idcRejectPlacedGraphic(item, field, id) {
+  var className = IDC.className(item);
+  var parentName = '';
+  var parentId = null;
+  var i;
+  for (i = 0; i < IDC_FRAME_CLASSES.length; i++) {
+    if (IDC_FRAME_CLASSES[i] === className) { return; }
+  }
+  try { parentName = IDC.className(item.parent); } catch (e) { parentName = ''; }
+  if (parentName !== 'Rectangle' && parentName !== 'Oval' && parentName !== 'Polygon' && parentName !== 'GraphicLine' && parentName !== 'TextFrame') {
+    return;
+  }
+  try { parentId = Number(item.parent.id); } catch (e2) { parentId = null; }
+  IDC.fail('not_found',
+    'No object with ' + field + ' ' + id + ' in this document – ' + id + ' is the ' + className +
+      ' placed inside frame ' + String(parentId) + '; pass the id of the frame (get_page_state lists it).',
+    { frame_id: id, found_class: className, container_frame_id: parentId });
+}
+
 function idcFrameArg(doc, args, field) {
   var found;
   if (args[field] === undefined || args[field] === null) {
@@ -673,8 +702,14 @@ function idcFrameArg(doc, args, field) {
   }
   found = IDC.itemById(doc, args[field], 'any');
   if (found === null) {
+    if (IDC.rejectedClass !== null && IDC.rejectedClass !== undefined && IDC.rejectedClass !== '') {
+      /* A-73: die ID gehoert einem Objekt, das kein Seitenobjekt ist (z. B. einer Story). */
+      IDC.fail('not_found', 'No object with ' + field + ' ' + args[field] + ' in this document – ' + args[field] + ' is a ' + IDC.rejectedClass + ', not a frame or other page object.',
+        { frame_id: args[field], found_class: IDC.rejectedClass });
+    }
     IDC.fail('not_found', 'No object with ' + field + ' ' + args[field] + ' in this document.', { frame_id: args[field] });
   }
+  idcRejectPlacedGraphic(found.item, field, args[field]);
   /*
    * Schreibende Befehle scheitern an gesperrten Ebenen und gesperrten
    * Objekten – frueher mit nacktem InDesign-Fehler oder gar nicht sichtbar