layoutbridge-spm 0.0.1 → 1.0.0

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'] === '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,250 @@
+/**
+ * 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:
+ *  1. Interpreter und Handler zu einem Skript zusammensetzen, den Befehl als
+ *     ASCII-JSON hineinschreiben und in eine temporaere .jsx-Datei legen.
+ *  2. Eine .ps1-Datei danebenlegen, die sich die Anwendung ueber COM holt und
+ *     ihr das Skript per doScript uebergibt. 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 { 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';
+/** 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:';
+/** Text in einem PowerShell-Literal mit einfachen Anfuehrungszeichen. */
+export function escapeForPowerShell(text) {
+    return text.replace(/'/g, "''");
+}
+/** Text in einem JavaScript-Literal mit doppelten Anfuehrungszeichen. */
+function escapeForJsString(text) {
+    return text.replace(/\\/g, '\\\\').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(':', '');
+}
+export class ComTransport {
+    name = 'com';
+    progIds;
+    powershellPath;
+    defaultTimeoutMs;
+    keepTempFiles;
+    runner;
+    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;
+    }
+    /** 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 com-Transports (ExtendScript, Windows) ---- */',
+            '(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;
+    }
+    /**
+     * Das PowerShell-Skript: Anwendung ueber COM holen (GetActiveObject, sonst
+     * New-Object -ComObject), Skripttext lesen, doScript aufrufen. Bricht es selbst ab, meldet es sich mit einer
+     * Markerzeile, damit die Fehlerart nicht aus Fremdtexten geraten wird.
+     */
+    buildPowerShell(scriptPath) {
+        const ids = this.progIds.map((id) => "'" + escapeForPowerShell(id) + "'").join(', ');
+        return [
+            '$ErrorActionPreference = ' + "'Stop'",
+            '$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)',
+            '    }',
+            '  }',
+            '}',
+            'if ($null -eq $app) {',
+            '  [Console]::Error.WriteLine(' + "'" + APP_NOT_AVAILABLE_MARKER +
+                " ' + ($reasons -join '; '))",
+            '  exit 3',
+            '}',
+            '$scriptText = [IO.File]::ReadAllText(' + "'" + escapeForPowerShell(scriptPath) +
+                "', [Text.Encoding]::UTF8)",
+            'try {',
+            '  $null = $app.DoScript($scriptText, ' + SCRIPT_LANGUAGE_JAVASCRIPT + ')',
+            '} catch {',
+            '  [Console]::Error.WriteLine(' + "'" + SCRIPT_ERROR_MARKER +
+                " ' + $_.Exception.Message)",
+            '  exit 4',
+            '}',
+            'exit 0',
+            '',
+        ].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 powerShellPath = join(directory, 'command.ps1');
+        try {
+            writeFileSync(scriptPath, this.buildScript(command, resultPath), 'utf8');
+            writeFileSync(powerShellPath, this.buildPowerShell(scriptPath), 'utf8');
+            const outcome = await this.runner(this.powershellPath, ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', powerShellPath], timeoutMs);
+            let raw = null;
+            try {
+                raw = readFileSync(resultPath, 'utf8');
+            }
+            catch {
+                raw = null;
+            }
+            return interpretOutcome(outcome, raw, command, timeoutMs);
+        }
+        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=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

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,30 @@
+/**
+ * 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',
+];
+/** 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) };
+  });