layoutbridge-light 0.0.0-stage → 1.0.1

package/dist/src/mcp/typography-rules.js

@@ -0,0 +1,70 @@
+/**
+ * Regelkatalog fuer check_typography (A-7.6): eine Datentabelle im Repo
+ * (rules/typography-rules.json), kein Code je Regel. Der Server liest sie
+ * einmal, waehlt nach Sprache und Kennungen aus und reicht die Zeilen als
+ * Befehlsargument an den Interpreter; der kennt keine Regel von sich aus.
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const TYPOGRAPHY_LOCALES = ['de', 'de-CH', 'en'];
+export const SEVERITY_RANK = { info: 0, warning: 1, error: 2 };
+/* Diese Datei laeuft aus dist/src/mcp/ – drei Ebenen ueber ihr liegt das Repo bzw. Paket. */
+export function typographyRulesPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'rules', 'typography-rules.json');
+}
+function isRule(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const r = value;
+    return (typeof r['id'] === 'string' &&
+        Array.isArray(r['locales']) &&
+        typeof r['category'] === 'string' &&
+        typeof r['severity'] === 'string' &&
+        (r['kind'] === 'grep' || r['kind'] === 'lines' || r['kind'] === 'language') &&
+        (r['kind'] === 'grep' ? typeof r['pattern'] === 'string' : typeof r['check'] === 'string') &&
+        typeof r['message'] === 'string' &&
+        typeof r['suggestion'] === 'string' &&
+        typeof r['source'] === 'string');
+}
+export function parseTypographyRules(text) {
+    const raw = JSON.parse(text);
+    if (!Array.isArray(raw.rules))
+        throw new Error('typography-rules.json: "rules" must be an array');
+    const out = [];
+    raw.rules.forEach((entry, index) => {
+        if (!isRule(entry))
+            throw new Error(`typography-rules.json: rule ${index} is malformed`);
+        out.push(entry);
+    });
+    return out;
+}
+let cache = null;
+export function loadTypographyRules(path = typographyRulesPath()) {
+    if (cache === null)
+        cache = parseTypographyRules(readFileSync(path, 'utf8'));
+    return cache;
+}
+/** Alle Kennungen des Katalogs (ohne Doppelte, in Katalogreihenfolge). */
+export function typographyRuleIds(rules = loadTypographyRules()) {
+    const out = [];
+    for (const rule of rules)
+        if (!out.includes(rule.id))
+            out.push(rule.id);
+    return out;
+}
+/**
+ * Zeilen fuer einen Aufruf: Sprache, gewuenschte und ausgeschlossene
+ * Kennungen. Unbekannte Kennungen bleiben in unknown[] – der Interpreter
+ * meldet sie als invalid_argument, damit der Fehler wie alle anderen im
+ * Ergebnisumschlag steht.
+ */
+export function selectTypographyRules(locale, wanted, excluded, rules = loadTypographyRules()) {
+    const ids = typographyRuleIds(rules);
+    const unknown = [...(wanted ?? []), ...(excluded ?? [])].filter((id) => !ids.includes(id));
+    const chosen = rules.filter((rule) => rule.locales.includes(locale) &&
+        (wanted === undefined || wanted.length === 0 || wanted.includes(rule.id)) &&
+        !(excluded ?? []).includes(rule.id));
+    return { rules: chosen, unknown };
+}
+//# sourceMappingURL=typography-rules.js.map

package/dist/src/transport/com.js

@@ -0,0 +1,436 @@
+/**
+ * Transport fuer Windows: PowerShell -> COM -> InDesign doScript.
+ *
+ * Gegenstueck zu osascript.ts. Nur diese Datei weiss, dass hier ein
+ * Windows-Rechner steht; der Interpreter und das Befehlsformat {cmd, args}
+ * bleiben unveraendert.
+ *
+ * Ablauf je Aufruf (seit Sitzung 80, A-74):
+ *  1. Interpreter und Handler samt festem Rahmen liegen als Skriptdatei in
+ *     einem festen Arbeitsordner (`%LOCALAPPDATA%\layoutbridge-spm\com`),
+ *     einmal je Buendelstand geschrieben (Pruefsumme im Namen). Daneben ein
+ *     festes PowerShell-Skript. Je Aufruf entstehen nur Datendateien: der
+ *     Befehl als ASCII-JSON und das Ergebnis. Vorher entstanden je Aufruf
+ *     zwei neue Skriptdateien (.jsx mit ~0,9 MB, .ps1) in einem neuen
+ *     Temp-Ordner; ein Virenschutz mit Echtzeitpruefung (beim Kunden Avira,
+ *     per Test bestaetigt 10.11.2026) hielt jede davon an – Aufrufe 12 s bis
+ *     122 s statt unter einer Sekunde. Ein fester Ordner laesst sich zudem
+ *     gezielt als Ausnahme eintragen.
+ *  2. PowerShell holt sich die Anwendung ueber COM und uebergibt ihr das
+ *     Skript per doScript, den Befehl und den Ergebnispfad ueber
+ *     withArguments (im Skript `arguments`). Erst GetActiveObject (Running
+ *     Object Table), dann CoCreateInstance (New-Object -ComObject): InDesign
+ *     traegt sich nicht in die Running Object Table ein, CoCreateInstance
+ *     verbindet aber mit der laufenden Instanz und startet sie sonst - wie
+ *     `tell application` beim Mac-Transport (Vermerk E-70, 15.09.2026).
+ *  3. Das Skript schreibt sein Ergebnis in eine Datei; der Server liest sie.
+ *     Umweg ueber die Datei wie beim Mac-Transport: die Rueckgabe ueber COM
+ *     ist in Laenge und Zeichensatz unzuverlaessig.
+ *
+ * Gebaut ohne Windows-Rechner gegen eine Attrappe des Prozessstarts
+ * (Vermerk E-67). Transportweg am 15.09.2026 mit InDesign CS5 (7.0.0.355)
+ * auf Windows 11 ARM64 nachgewiesen (Vermerk E-70). Abgenommen am
+ * 15.09.2026 (Vermerk E-71): Integrationssuite 108/108 ueber diesen
+ * Transport mit InDesign 21.5.1.73 auf Windows 11 x64 (Build 26200,
+ * Windows 365 Cloud-PC, Node 24.21.0); scripts/com-test.ps1 Exit 0,
+ * scripts/win-smoke.mjs 7/7. Auch das aktuelle InDesign traegt sich nicht
+ * in die Running Object Table ein (GetActiveObject: MK_E_UNAVAILABLE),
+ * der Rueckfall auf CoCreateInstance traegt.
+ */
+import { spawn } from 'node:child_process';
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildScriptBundle, toAsciiJson } from './script-bundle.js';
+import { attachTiming, transportError, } from './transport.js';
+/** ScriptLanguage.javascript im Objektmodell – als Zahl, weil COM keine Aufzaehlung kennt. */
+export const SCRIPT_LANGUAGE_JAVASCRIPT = 1246973031;
+/** Zeilen, mit denen sich das PowerShell-Skript meldet, wenn es selbst abbricht. */
+export const APP_NOT_AVAILABLE_MARKER = 'IDC-COM-ERROR app_not_available:';
+export const SCRIPT_ERROR_MARKER = 'IDC-COM-ERROR script_error:';
+/** Zeile mit den Zeitanteilen aus PowerShell (nur Protokoll, A-74). */
+export const TIMING_MARKER = 'IDC-COM-TIMING';
+/** Aufgeraeumt wird, was laenger als einen Tag im Arbeitsordner liegt. */
+const STALE_MS = 24 * 60 * 60 * 1000;
+/**
+ * Fester Arbeitsordner des Windows-Transports:
+ * `%LOCALAPPDATA%\<produkt>\com`, ohne LOCALAPPDATA im Temp-Ordner.
+ */
+export function defaultComWorkDir(dataDirName = 'layoutbridge-spm', env = process.env) {
+    const local = env['LOCALAPPDATA'];
+    const base = local !== undefined && local.length > 0 ? local : tmpdir();
+    return join(base, dataDirName, 'com');
+}
+/** Text in einem PowerShell-Literal mit einfachen Anfuehrungszeichen. */
+export function escapeForPowerShell(text) {
+    return text.replace(/'/g, "''");
+}
+/**
+ * Wertet den Ausgang eines Aufrufs aus. Reine Funktion ohne Dateisystem und
+ * ohne Prozess, damit die Einheitstests jede Fehlerart ohne Windows pruefen.
+ */
+export function interpretOutcome(outcome, raw, command, timeoutMs) {
+    if (outcome.spawnError !== null) {
+        return transportError('app_not_available', 'Could not run PowerShell – this transport needs Windows: ' + outcome.spawnError.message, null);
+    }
+    if (outcome.timedOut) {
+        return transportError('timeout', 'InDesign did not answer within ' + timeoutMs +
+            ' ms. The script may still be running inside InDesign – check the document before repeating the call.', { command: command.cmd, timeout_ms: timeoutMs });
+    }
+    const stderr = outcome.stderr.trim();
+    const marked = markedMessage(stderr, APP_NOT_AVAILABLE_MARKER);
+    if (marked !== null) {
+        return transportError('app_not_available', marked, { exit_code: outcome.code });
+    }
+    const scriptMarked = markedMessage(stderr, SCRIPT_ERROR_MARKER);
+    if (scriptMarked !== null) {
+        return transportError('script_error', scriptMarked, { exit_code: outcome.code });
+    }
+    if (raw === null || raw.length === 0) {
+        return transportError('script_error', stderr.length > 0
+            ? 'InDesign did not return a result: ' + stderr
+            : 'InDesign did not return a result and reported nothing.', { exit_code: outcome.code, stdout: outcome.stdout.trim() });
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.warnings))
+            parsed.warnings = [];
+        return parsed;
+    }
+    catch (error) {
+        return transportError('script_error', 'The result of the script is not valid JSON: ' + String(error), {
+            raw: raw.slice(0, 2000),
+        });
+    }
+}
+/** Sucht die Markerzeile und gibt den Text dahinter zurueck, sonst null. */
+function markedMessage(stderr, marker) {
+    const at = stderr.indexOf(marker);
+    if (at < 0)
+        return null;
+    const rest = stderr.slice(at + marker.length);
+    const end = rest.indexOf('\n');
+    const line = (end < 0 ? rest : rest.slice(0, end)).trim();
+    return line.length > 0 ? line : marker.replace(':', '');
+}
+/** Zieht die Zeitzeile aus stderr: Zeitanteile und der uebrige Text. */
+export function splitTiming(stderr) {
+    const timing = {};
+    const kept = [];
+    for (const line of stderr.split(/\r?\n/)) {
+        const at = line.indexOf(TIMING_MARKER);
+        if (at < 0) {
+            kept.push(line);
+            continue;
+        }
+        for (const pair of line.slice(at + TIMING_MARKER.length).trim().split(/\s+/)) {
+            const eq = pair.indexOf('=');
+            if (eq <= 0)
+                continue;
+            const value = Number(pair.slice(eq + 1));
+            if (Number.isFinite(value))
+                timing['ps_' + pair.slice(0, eq)] = value;
+        }
+    }
+    return { timing, rest: kept.join('\n') };
+}
+/** Kurze Pruefsumme eines Textes fuer Dateinamen. */
+function shortHash(text) {
+    return createHash('sha256').update(text, 'utf8').digest('hex').slice(0, 16);
+}
+/**
+ * Schreibt eine Datei nur, wenn sie mit diesem Inhalt noch nicht da ist
+ * (Pruefsumme im Namen, Groesse als Vollstaendigkeitsprobe). Erst unter
+ * eigenem Namen, dann umbenennen: Mehrere Serverinstanzen koennen
+ * gleichzeitig starten, keine liest eine halb geschriebene Datei.
+ * Liefert true, wenn geschrieben wurde.
+ */
+export function ensureFile(path, content) {
+    const size = Buffer.byteLength(content, 'utf8');
+    try {
+        if (existsSync(path) && statSync(path).size === size)
+            return false;
+    }
+    catch {
+        /* dann neu schreiben */
+    }
+    const temporary = path + '.' + process.pid + '.' + randomBytes(4).toString('hex') + '.tmp';
+    writeFileSync(temporary, content, 'utf8');
+    try {
+        renameSync(temporary, path);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        /* Eine andere Instanz war schneller und haelt die Datei offen. */
+        if (!(existsSync(path) && statSync(path).size === size))
+            throw error;
+    }
+    return true;
+}
+export class ComTransport {
+    name = 'com';
+    progIds;
+    powershellPath;
+    defaultTimeoutMs;
+    keepTempFiles;
+    runner;
+    workDir;
+    sequence = 0;
+    cleaned = false;
+    /** Zuletzt bereitgelegtes Buendel (gleiches Objekt = gleicher Stand). */
+    preparedBundle = null;
+    preparedScriptPath = '';
+    preparedPowerShellPath = '';
+    constructor(options = {}) {
+        this.progIds = options.progIds ?? ['InDesign.Application'];
+        this.powershellPath = options.powershellPath ?? 'powershell.exe';
+        this.defaultTimeoutMs = options.defaultTimeoutMs ?? 120_000;
+        this.keepTempFiles = options.keepTempFiles ?? false;
+        this.runner = options.runner ?? runProcess;
+        this.workDir = options.workDir ?? defaultComWorkDir(options.dataDirName);
+    }
+    /**
+     * Das vollstaendige Skript: Buendel plus fester Rahmen. Der Befehl steht
+     * nicht darin – er kommt ueber withArguments (arguments[0] Befehl als
+     * ASCII-JSON, arguments[1] Ergebnispfad). So bleibt die Datei je
+     * Buendelstand gleich.
+     */
+    buildScript(bundle = buildScriptBundle()) {
+        const frame = [
+            '',
+            '/* ---- Rahmen des com-Transports (ExtendScript, Windows) ---- */',
+            'var __idcArgs = (typeof arguments !== "undefined" && arguments !== null) ? arguments : [];',
+            '(function (commandText, resultPath) {',
+            '  var __text, __file;',
+            '  if (commandText === undefined || commandText === null || resultPath === undefined || resultPath === null) {',
+            '    return "missing arguments";',
+            '  }',
+            '  __text = IDC.run(eval("(" + String(commandText) + ")"));',
+            '  __file = new File(String(resultPath));',
+            '  __file.encoding = "UTF-8";',
+            '  __file.lineFeed = "Unix";',
+            '  __file.open("w");',
+            '  __file.write(__text);',
+            '  __file.close();',
+            '  return "ok";',
+            '})(__idcArgs[0], __idcArgs[1]);',
+            '',
+        ].join('\n');
+        return bundle + '\n' + frame;
+    }
+    /**
+     * Das feste PowerShell-Skript: Anwendung ueber COM holen (GetActiveObject,
+     * sonst New-Object -ComObject), Skript- und Befehlsdatei lesen, doScript
+     * mit withArguments aufrufen. Pfade kommen als Parameter. Bricht es selbst
+     * ab, meldet es sich mit einer Markerzeile, damit die Fehlerart nicht aus
+     * Fremdtexten geraten wird. Zeitanteile stehen in einer eigenen Zeile.
+     */
+    buildPowerShell() {
+        const ids = this.progIds.map((id) => "'" + escapeForPowerShell(id) + "'").join(', ');
+        return [
+            'param([string]$ScriptPath, [string]$CommandPath, [string]$ResultPath)',
+            '$ErrorActionPreference = ' + "'Stop'",
+            '$watch = [Diagnostics.Stopwatch]::StartNew()',
+            '$marks = @{}',
+            'function Write-IdcTiming {',
+            "  $line = '" + TIMING_MARKER + "'",
+            '  foreach ($key in $marks.Keys) { $line += (" " + $key + "=" + $marks[$key]) }',
+            '  [Console]::Error.WriteLine($line)',
+            '}',
+            '$progIds = @(' + ids + ')',
+            '$app = $null',
+            '$reasons = @()',
+            'foreach ($id in $progIds) {',
+            '  try {',
+            '    $app = [Runtime.InteropServices.Marshal]::GetActiveObject($id)',
+            '    break',
+            '  } catch {',
+            '    $reasons += ($id + " (GetActiveObject): " + $_.Exception.Message)',
+            '  }',
+            '}',
+            'if ($null -eq $app) {',
+            '  foreach ($id in $progIds) {',
+            '    try {',
+            '      $app = New-Object -ComObject $id',
+            '      break',
+            '    } catch {',
+            '      $reasons += ($id + " (New-Object): " + $_.Exception.Message)',
+            '    }',
+            '  }',
+            '}',
+            "$marks['connect'] = $watch.ElapsedMilliseconds",
+            'if ($null -eq $app) {',
+            '  Write-IdcTiming',
+            '  [Console]::Error.WriteLine(' + "'" + APP_NOT_AVAILABLE_MARKER +
+                " ' + ($reasons -join '; '))",
+            '  exit 3',
+            '}',
+            '$scriptText = [IO.File]::ReadAllText($ScriptPath, [Text.Encoding]::UTF8)',
+            '$commandText = [IO.File]::ReadAllText($CommandPath, [Text.Encoding]::UTF8)',
+            "$marks['read'] = $watch.ElapsedMilliseconds - $marks['connect']",
+            'try {',
+            '  $null = $app.DoScript($scriptText, ' + SCRIPT_LANGUAGE_JAVASCRIPT +
+                ', [object[]]@($commandText, $ResultPath))',
+            '} catch {',
+            "  $marks['doscript'] = $watch.ElapsedMilliseconds - $marks['connect'] - $marks['read']",
+            '  Write-IdcTiming',
+            '  [Console]::Error.WriteLine(' + "'" + SCRIPT_ERROR_MARKER +
+                " ' + $_.Exception.Message)",
+            '  exit 4',
+            '}',
+            "$marks['doscript'] = $watch.ElapsedMilliseconds - $marks['connect'] - $marks['read']",
+            "$marks['total'] = $watch.ElapsedMilliseconds",
+            'Write-IdcTiming',
+            'exit 0',
+            '',
+        ].join('\n');
+    }
+    /**
+     * Legt Skript- und PowerShell-Datei in den Arbeitsordner, falls noetig.
+     * Liefert true, wenn in diesem Aufruf eine davon geschrieben wurde.
+     */
+    prepare() {
+        const bundle = buildScriptBundle();
+        if (bundle === this.preparedBundle && existsSync(this.preparedScriptPath) && existsSync(this.preparedPowerShellPath)) {
+            return false;
+        }
+        mkdirSync(this.workDir, { recursive: true });
+        const script = this.buildScript(bundle);
+        const powerShell = this.buildPowerShell();
+        const scriptPath = join(this.workDir, 'script-' + shortHash(script) + '.jsx');
+        const powerShellPath = join(this.workDir, 'run-' + shortHash(powerShell) + '.ps1');
+        let written = ensureFile(scriptPath, script);
+        written = ensureFile(powerShellPath, powerShell) || written;
+        this.preparedBundle = bundle;
+        this.preparedScriptPath = scriptPath;
+        this.preparedPowerShellPath = powerShellPath;
+        if (!this.cleaned) {
+            this.cleaned = true;
+            this.removeStale([scriptPath, powerShellPath]);
+        }
+        return written;
+    }
+    /** Alte Dateien frueherer Staende und liegengebliebener Aufrufe entfernen. */
+    removeStale(keep) {
+        const now = Date.now();
+        let names = [];
+        try {
+            names = readdirSync(this.workDir);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            const path = join(this.workDir, name);
+            if (keep.includes(path))
+                continue;
+            if (!/^(script-.*\.jsx|run-.*\.ps1|call-.*\.json|.*\.tmp)$/.test(name))
+                continue;
+            try {
+                if (now - statSync(path).mtimeMs > STALE_MS)
+                    rmSync(path, { force: true });
+            }
+            catch {
+                /* Aufraeumen darf keinen Aufruf scheitern lassen. */
+            }
+        }
+    }
+    async send(command, options = {}) {
+        const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+        const timing = { begin: Date.now() };
+        let mark = Date.now();
+        const lap = (key) => {
+            const now = Date.now();
+            timing[key] = now - mark;
+            mark = now;
+        };
+        this.sequence += 1;
+        const stem = 'call-' + process.pid + '-' + this.sequence + '-' + randomBytes(4).toString('hex');
+        const commandPath = join(this.workDir, stem + '.command.json');
+        const resultPath = join(this.workDir, stem + '.result.json');
+        try {
+            timing['script_written'] = this.prepare() ? 1 : 0;
+            writeFileSync(commandPath, toAsciiJson(command), 'utf8');
+        }
+        catch (error) {
+            return transportError('io_error', 'Could not prepare the script files of the Windows transport.', String(error));
+        }
+        lap('prepare');
+        try {
+            const outcome = await this.runner(this.powershellPath, [
+                '-NoProfile',
+                '-NonInteractive',
+                '-ExecutionPolicy',
+                'Bypass',
+                '-File',
+                this.preparedPowerShellPath,
+                '-ScriptPath',
+                this.preparedScriptPath,
+                '-CommandPath',
+                commandPath,
+                '-ResultPath',
+                resultPath,
+            ], timeoutMs);
+            lap('process');
+            const split = splitTiming(outcome.stderr);
+            Object.assign(timing, split.timing);
+            if (split.timing['ps_total'] !== undefined && timing['process'] !== undefined) {
+                timing['ps_start'] = Math.max(0, timing['process'] - split.timing['ps_total']);
+            }
+            let raw = null;
+            try {
+                raw = readFileSync(resultPath, 'utf8');
+            }
+            catch {
+                raw = null;
+            }
+            lap('read_result');
+            return attachTiming(interpretOutcome({ ...outcome, stderr: split.rest }, raw, command, timeoutMs), timing);
+        }
+        finally {
+            if (!this.keepTempFiles) {
+                try {
+                    rmSync(commandPath, { force: true });
+                    rmSync(resultPath, { force: true });
+                }
+                catch {
+                    /* Aufraeumen darf keinen Aufruf scheitern lassen. */
+                }
+            }
+            lap('cleanup');
+        }
+    }
+    async close() {
+        /* Kein dauerhafter Zustand: nichts zu schliessen. */
+    }
+}
+function runProcess(command, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let settled = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+        });
+        const finish = (code, spawnError) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr, timedOut, spawnError });
+        };
+        child.on('error', (error) => finish(null, error));
+        child.on('close', (code) => finish(code, null));
+    });
+}
+//# sourceMappingURL=com.js.map

package/dist/src/transport/osascript.js

@@ -0,0 +1,171 @@
+/**
+ * Transport fuer den Mac: osascript -> AppleScript -> InDesign do script.
+ *
+ * Nur diese Datei weiss, dass hier ein Mac steht. Der Interpreter bleibt frei
+ * von Plattformannahmen.
+ *
+ * Ablauf je Aufruf:
+ *  1. Interpreter und Handler zu einem Skript zusammensetzen, den Befehl als
+ *     ASCII-JSON hineinschreiben und in eine temporaere .jsx-Datei legen.
+ *  2. AppleScript-Datei danebenlegen, die InDesign dieses Skript ausfuehren
+ *     laesst.
+ *  3. Das Skript schreibt sein Ergebnis in eine Datei; der Server liest sie.
+ *     Umweg ueber die Datei, weil die Rueckgabe ueber AppleScript in Laenge
+ *     und Zeichensatz unzuverlaessig ist.
+ *
+ * Der kleine Rahmen in Schritt 1 benutzt das ExtendScript-Objekt File. Das ist
+ * bewusst hier und nicht im Interpreter: Dateizugriff ist Transportsache.
+ */
+import { spawn } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildScriptBundle, toAsciiJson } from './script-bundle.js';
+import { transportError, } from './transport.js';
+const APP_NOT_AVAILABLE_HINTS = [
+    '-1728',
+    '-600',
+    '-609',
+    '-10814',
+    "isn't running",
+    'is not running',
+    'Application isn',
+];
+function escapeForJsString(text) {
+    return text.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+export class OsascriptTransport {
+    name = 'osascript';
+    appBundleId;
+    defaultTimeoutMs;
+    keepTempFiles;
+    constructor(options = {}) {
+        this.appBundleId = options.appBundleId ?? 'com.adobe.InDesign';
+        this.defaultTimeoutMs = options.defaultTimeoutMs ?? 120_000;
+        this.keepTempFiles = options.keepTempFiles ?? false;
+    }
+    /** Das vollstaendige Skript inklusive Rahmen, der das Ergebnis wegschreibt. */
+    buildScript(command, resultPath) {
+        const bundle = buildScriptBundle();
+        const commandLiteral = toAsciiJson(command);
+        const target = escapeForJsString(resultPath);
+        const frame = [
+            '',
+            '/* ---- Rahmen des osascript-Transports (ExtendScript, Mac) ---- */',
+            '(function () {',
+            '  var __text = IDC.run(' + commandLiteral + ');',
+            '  var __file = new File("' + target + '");',
+            '  __file.encoding = "UTF-8";',
+            '  __file.lineFeed = "Unix";',
+            '  __file.open("w");',
+            '  __file.write(__text);',
+            '  __file.close();',
+            '  return "ok";',
+            '})();',
+            '',
+        ].join('\n');
+        return bundle + '\n' + frame;
+    }
+    buildAppleScript(scriptPath, timeoutMs) {
+        const seconds = Math.max(5, Math.ceil(timeoutMs / 1000) + 5);
+        return [
+            'with timeout of ' + seconds + ' seconds',
+            '\ttell application id "' + this.appBundleId + '"',
+            '\t\tdo script (POSIX file "' + escapeForJsString(scriptPath) + '") language javascript',
+            '\tend tell',
+            'end timeout',
+        ].join('\n');
+    }
+    async send(command, options = {}) {
+        const timeoutMs = options.timeoutMs ?? this.defaultTimeoutMs;
+        let directory;
+        try {
+            directory = mkdtempSync(join(tmpdir(), 'idc-spm-'));
+        }
+        catch (error) {
+            return transportError('io_error', 'Could not create a temporary directory.', String(error));
+        }
+        const scriptPath = join(directory, 'command.jsx');
+        const resultPath = join(directory, 'result.json');
+        const appleScriptPath = join(directory, 'command.applescript');
+        try {
+            writeFileSync(scriptPath, this.buildScript(command, resultPath), 'utf8');
+            writeFileSync(appleScriptPath, this.buildAppleScript(scriptPath, timeoutMs), 'utf8');
+            const outcome = await runProcess('osascript', [appleScriptPath], timeoutMs);
+            if (outcome.spawnError !== null) {
+                return transportError('app_not_available', 'Could not run osascript – this transport needs macOS: ' + outcome.spawnError.message, null);
+            }
+            if (outcome.timedOut) {
+                return transportError('timeout', 'InDesign did not answer within ' + timeoutMs +
+                    ' ms. The script may still be running inside InDesign – check the document before repeating the call.', { command: command.cmd, timeout_ms: timeoutMs });
+            }
+            let raw = null;
+            try {
+                raw = readFileSync(resultPath, 'utf8');
+            }
+            catch {
+                raw = null;
+            }
+            if (raw === null || raw.length === 0) {
+                const stderr = outcome.stderr.trim();
+                const kind = APP_NOT_AVAILABLE_HINTS.some((hint) => stderr.includes(hint))
+                    ? 'app_not_available'
+                    : 'script_error';
+                return transportError(kind, stderr.length > 0
+                    ? 'InDesign did not return a result: ' + stderr
+                    : 'InDesign did not return a result and reported nothing.', { exit_code: outcome.code, stdout: outcome.stdout.trim() });
+            }
+            try {
+                const parsed = JSON.parse(raw);
+                if (!Array.isArray(parsed.warnings))
+                    parsed.warnings = [];
+                return parsed;
+            }
+            catch (error) {
+                return transportError('script_error', 'The result of the script is not valid JSON: ' + String(error), { raw: raw.slice(0, 2000) });
+            }
+        }
+        finally {
+            if (!this.keepTempFiles) {
+                try {
+                    rmSync(directory, { recursive: true, force: true });
+                }
+                catch {
+                    /* Aufraeumen darf keinen Aufruf scheitern lassen. */
+                }
+            }
+        }
+    }
+    async close() {
+        /* Kein dauerhafter Zustand: nichts zu schliessen. */
+    }
+}
+function runProcess(command, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let settled = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+        });
+        const finish = (code, spawnError) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr, timedOut, spawnError });
+        };
+        child.on('error', (error) => finish(null, error));
+        child.on('close', (code) => finish(code, null));
+    });
+}
+//# sourceMappingURL=osascript.js.map