layoutbridge-light 0.0.0-stage → 1.0.1

package/dist/src/mcp/license/polar-ids.js

@@ -0,0 +1,100 @@
+/**
+ * Hinterlegte Kennungen des Zahlungsdienstes Polar (Auftrag A-15 Nr. 2,
+ * 23.09.2026).
+ *
+ * Polar arbeitet mit UUIDs statt Zahlen: die Organisation
+ * (organization_id) gehoert in jeden Aufruf, der Benefit (benefit_id)
+ * benennt den Lizenzschluessel-Vorteil des Produkts. Store, Produkt und
+ * Variante wie bei lemonsqueezy gibt es hier nicht; die Kennungen von
+ * lemonsqueezy in product-ids.ts bleiben davon unberuehrt.
+ *
+ * Hinterlegt sind die Kennungen des Live-Kontos (Organisation "MCP
+ * Interfaces"), wie sie das Auftragsdokument unter A-15a Teil 2
+ * (23.09.2026, 07:14 Uhr) nennt: organization_id aus Settings >
+ * Preferences (Feld "Identifier"), benefit_id aus der Adresse der
+ * Benefit-Seite (Vermerk E-85). Bestaetigt durch die erste validate-Antwort
+ * mit dem Live-Schluessel fuer den Arbeitsplatz des Anbieters (Nachtrag 23.09.2026,
+ * 08:29 Uhr) und die Live-Probe von A-9 (Vermerk E-86): beide Werte
+ * stimmen mit der Antwort ueberein.
+ *
+ * Fuer die Sandbox-Probe lassen sie sich von aussen ueberschreiben – ueber
+ * Umgebungsvariablen und ausschliesslich in der Bauphase, nie ueber
+ * config.json: config.json ist Kundenkonfiguration und koennte damit den
+ * Produktabgleich aushebeln.
+ */
+import { envName, PRODUCT, PRODUCTS } from '../product.js';
+/** Kennungen des Live-Kontos (A-15a Teil 2, 23.09.2026) – Vollprodukt. */
+export const POLAR_IDS = {
+    organization_id: 'e8d80621-fb90-45e2-b0b6-73a94271fe18',
+    benefit_id: 'e9b61756-779b-4d65-83b9-f398346f6184',
+};
+/**
+ * Kennungen von LayoutBridge Light (A-70, E-109): dieselbe Organisation,
+ * eigener Benefit des eigenen Polar-Produkts ("LayoutBridge Light licence
+ * key", Schluesselpraefix LBL, 1 Aktivierung, kein Ablauf; Angabe des Anbieters
+ * 01.11.2026, Nachtrag E-109). Ohne Benefit wiese Light jeden Schluessel ab
+ * (requireBenefit im Verifier), und scripts/light-package.mjs baute kein
+ * Paket.
+ */
+export const LIGHT_POLAR_IDS = {
+    organization_id: 'e8d80621-fb90-45e2-b0b6-73a94271fe18',
+    benefit_id: 'ce5f2f90-9ed9-4306-8928-f010db5ad740',
+};
+/** Hinterlegte Kennungen je Produkt. */
+export function polarIdsFor(product = PRODUCT) {
+    return product.id === 'light' ? LIGHT_POLAR_IDS : POLAR_IDS;
+}
+/** Name der Umgebungsvariablen der Bauphase (Vollprodukt; Light mit eigenem Praefix). */
+export const POLAR_ORG_ID_ENV = 'LAYOUTBRIDGE_SPM_LICENSE_POLAR_ORG_ID';
+export const POLAR_BENEFIT_ID_ENV = 'LAYOUTBRIDGE_SPM_LICENSE_POLAR_BENEFIT_ID';
+export function polarOrgIdEnv(product = PRODUCT) {
+    return envName('LICENSE_POLAR_ORG_ID', product);
+}
+export function polarBenefitIdEnv(product = PRODUCT) {
+    return envName('LICENSE_POLAR_BENEFIT_ID', product);
+}
+/**
+ * Benefits der jeweils anderen Produkte. Eine Umgebungsvariable der
+ * Bauphase darf nie auf einen davon zeigen – sonst schaltete ein Schluessel
+ * von Light ueber die Variable das Vollprodukt frei (E-109).
+ */
+export function foreignBenefitIds(product = PRODUCT) {
+    return PRODUCTS.filter((other) => other.id !== product.id)
+        .map((other) => polarIdsFor(other).benefit_id)
+        .filter((id) => id !== null)
+        .map((id) => id.toLowerCase());
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Nur eine UUID zaehlt als Kennung; alles andere gilt als nicht gesetzt. */
+function uuidFromEnv(value) {
+    if (value === undefined)
+        return null;
+    const trimmed = value.trim();
+    if (!UUID.test(trimmed))
+        return null;
+    return trimmed.toLowerCase();
+}
+/**
+ * Kennungen fuer diesen Lauf: die hinterlegten Konstanten, einzeln
+ * ueberschreibbar durch Umgebungsvariablen der Bauphase.
+ */
+export function resolvePolarIds(env = process.env, base, product = PRODUCT, foreign = foreignBenefitIds(product)) {
+    const hinterlegt = base ?? polarIdsFor(product);
+    const benefitOverride = uuidFromEnv(env[polarBenefitIdEnv(product)]);
+    const allowedBenefit = benefitOverride !== null && !foreign.map((id) => id.toLowerCase()).includes(benefitOverride) ? benefitOverride : null;
+    return {
+        organization_id: uuidFromEnv(env[polarOrgIdEnv(product)]) ?? hinterlegt.organization_id,
+        benefit_id: allowedBenefit ?? hinterlegt.benefit_id,
+    };
+}
+/** Ist ueberhaupt eine Kennung hinterlegt? */
+export function polarIdsConfigured(ids) {
+    return ids.organization_id !== null || ids.benefit_id !== null;
+}
+/** Kurzfassung fuer Startzeile und Protokoll. */
+export function describePolarIds(ids) {
+    if (!polarIdsConfigured(ids))
+        return 'not set';
+    return `organization ${ids.organization_id ?? '-'}, benefit ${ids.benefit_id ?? '-'}`;
+}
+//# sourceMappingURL=polar-ids.js.map

package/dist/src/mcp/license/polar-verifier.js

@@ -0,0 +1,285 @@
+/**
+ * Prueffunktion des Zahlungsdienstes Polar (Auftrag A-15, 23.09.2026;
+ * Beobachtungen aus der Sandbox in Polar-Pruefung_2026-09-23.md, 3b).
+ *
+ * Gebaut wie lemonsqueezy-verifier.ts und **neben** dieser Klasse: drei
+ * Endpunkte des Kundenportals – activate, validate, deactivate –, alle ohne
+ * Anmeldung und damit ohne Geheimnis im Connector, Rumpf JSON, kein
+ * Authorization-Header. Kein SDK, keine neue Laufzeitabhaengigkeit; der
+ * Aufruf geht ueber fetch aus Node ab Version 20, Zeitueberschreitung 10 s.
+ *
+ * Unterschiede zu lemonsqueezy, die den Bau bestimmen:
+ * - Kennungen sind UUIDs (organization_id, benefit_id) statt Zahlen.
+ * - Zustaende heissen granted / revoked / disabled.
+ * - Die Aktivierung kommt bei activate als `id` (nicht `instance.id`);
+ *   validate traegt die Felder des Schluessels unmittelbar im Rumpf und die
+ *   Aktivierung in `activation`.
+ * - Gesperrt oder gekuendigt kommt als HTTP 404 mit eigenem Wortlaut, nicht
+ *   als Zustand; deactivate antwortet mit HTTP 204 ohne Rumpf.
+ * - Ohne Anmeldung gelten 3 Aufrufe je Sekunde; HTTP 429 zaehlt als
+ *   "nicht erreichbar", und zwischen zwei eigenen Aufrufen liegt eine Pause.
+ *
+ * Aufrufmuster (A-15 Nr. 4): ohne gespeicherte Aktivierung aktivieren, sonst
+ * mit activation_id pruefen. Kommt 404 "Not found" (die Aktivierung wurde
+ * beim Haendler oder vom Kunden im Portal entfernt), genau einmal neu
+ * aktivieren; scheitert das, bleibt es beim Ergebnis dieses Versuchs.
+ *
+ * Die Antworten enthalten Kundendaten (`customer`, `user`). Sie werden
+ * weder uebernommen noch protokolliert (A-8); nach aussen gehen nur
+ * Zustand, Ablauf und die Aktivierungskennung. Der Lizenzschluessel
+ * erscheint in keiner Meldung.
+ */
+import { describePolarIds, polarIdsConfigured, } from './polar-ids.js';
+import { SUPPORT_EMAIL } from '../product-info.js';
+import { envName, PRODUCT } from '../product.js';
+export const DEFAULT_BASE_URL = 'https://api.polar.sh';
+/** Sandbox; nur in der Bauphase, ueber die Umgebungsvariable unten. */
+export const SANDBOX_BASE_URL = 'https://sandbox-api.polar.sh';
+export const POLAR_SANDBOX_ENV = 'LAYOUTBRIDGE_SPM_LICENSE_POLAR_SANDBOX';
+export function polarSandboxEnv(product = PRODUCT) {
+    return envName('LICENSE_POLAR_SANDBOX', product);
+}
+export const DEFAULT_TIMEOUT_MS = 10_000;
+/** Abstand vor einem zweiten eigenen Aufruf (Grenze des Dienstes: 3/s). */
+export const DEFAULT_RETRY_DELAY_MS = 1_000;
+function record(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    return value;
+}
+function text(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+/** Einen Satz sauber abschliessen, damit zwei Saetze nicht zusammenlaufen. */
+function sentence(value) {
+    const trimmed = value.trimEnd();
+    return /[.!?]$/.test(trimmed) ? trimmed : trimmed + '.';
+}
+/** Den Schluessel aus jedem Text entfernen, der nach aussen geht. */
+export function redactKey(message, key) {
+    if (key.length === 0)
+        return message;
+    return message.split(key).join('<key>');
+}
+/** Basisadresse fuer diesen Lauf: live, in der Bauphase auf Wunsch Sandbox. */
+export function resolvePolarBaseUrl(env = process.env, product = PRODUCT) {
+    return env[polarSandboxEnv(product)] === '1' ? SANDBOX_BASE_URL : DEFAULT_BASE_URL;
+}
+export class PolarVerifier {
+    name = 'polar';
+    ids;
+    baseUrl;
+    timeoutMs;
+    fetchImpl;
+    now;
+    retryDelayMs;
+    requireBenefit;
+    constructor(options) {
+        this.ids = options.ids;
+        this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
+        this.now = options.now ?? (() => new Date());
+        this.retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+        this.requireBenefit = options.requireBenefit === true;
+    }
+    /** Eine Zeile fuer die Startmeldung des Servers. */
+    describe() {
+        return `${this.name} (${this.baseUrl}, ids: ${describePolarIds(this.ids)})`;
+    }
+    async verify(key, context) {
+        if (this.requireBenefit && this.ids.benefit_id === null) {
+            return this.outcome('product_mismatch', 'This build has no product identification for the licence service, so no key can be accepted.', key, null, context.instance_id);
+        }
+        if (context.instance_id === null) {
+            return this.interpret(await this.activate(key, context.instance_name), key);
+        }
+        const validated = await this.call('validate', { key, activation_id: context.instance_id });
+        const outcome = this.interpret(validated, key, context.instance_id);
+        if (outcome.status !== 'invalid' || !this.activationLikelyGone(validated))
+            return outcome;
+        /* Aktivierung entfernt: genau ein Aktivierungsversuch, mit Abstand. */
+        await this.pause();
+        return this.interpret(await this.activate(key, context.instance_name), key);
+    }
+    async deactivate(key, instanceId) {
+        const answer = await this.call('deactivate', { key, activation_id: instanceId });
+        if (answer.httpStatus === 204)
+            return;
+        if (answer.body === null) {
+            throw new Error('The licence service could not be reached: ' + answer.reason);
+        }
+        const reason = text(answer.body['detail']) ??
+            text(answer.body['error']) ??
+            'the service refused the deactivation (HTTP ' + String(answer.httpStatus) + ')';
+        throw new Error(redactKey(reason, key));
+    }
+    activate(key, label) {
+        return this.call('activate', { key, label });
+    }
+    /**
+     * Der Schluessel selbst ist noch brauchbar, nur die Aktivierung nicht
+     * mehr: HTTP 404 mit dem Wortlaut "Not found" (Sandbox 23.09.2026). Der
+     * eigene Wortlaut fuer einen erloschenen Schluessel ("no longer active")
+     * gehoert nicht dazu – dort waere ein zweiter Aufruf sinnlos.
+     */
+    activationLikelyGone(answer) {
+        if (answer.httpStatus !== 404 || answer.body === null)
+            return false;
+        if (this.keyGone(answer.body))
+            return false;
+        return true;
+    }
+    /** 404 mit dem Hinweis, dass der Schluessel selbst erloschen ist. */
+    keyGone(body) {
+        const detail = text(body['detail']);
+        return detail !== null && /no longer active/i.test(detail);
+    }
+    pause() {
+        if (this.retryDelayMs <= 0)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            setTimeout(resolve, this.retryDelayMs);
+        });
+    }
+    async call(endpoint, fields) {
+        /* organization_id gehoert in jeden Aufruf, sobald sie hinterlegt ist. */
+        const payload = { ...fields };
+        if (this.ids.organization_id !== null)
+            payload['organization_id'] = this.ids.organization_id;
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.baseUrl}/v1/customer-portal/license-keys/${endpoint}`, {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(this.timeoutMs),
+            });
+        }
+        catch (error) {
+            return { body: null, httpStatus: null, endpoint, reason: 'request failed (' + String(error) + ')' };
+        }
+        const httpStatus = response.status;
+        /* Erfolg ohne Rumpf: deactivate antwortet mit 204. */
+        if (httpStatus === 204) {
+            return { body: {}, httpStatus, endpoint, reason: '' };
+        }
+        if (httpStatus >= 500 || httpStatus === 429) {
+            return { body: null, httpStatus, endpoint, reason: 'the service answered HTTP ' + httpStatus };
+        }
+        let parsed;
+        try {
+            parsed = await response.json();
+        }
+        catch {
+            return { body: null, httpStatus, endpoint, reason: 'the answer was not readable JSON (HTTP ' + httpStatus + ')' };
+        }
+        const asRecord = record(parsed);
+        if (asRecord === null) {
+            return { body: null, httpStatus, endpoint, reason: 'the answer was not a JSON object (HTTP ' + httpStatus + ')' };
+        }
+        return { body: asRecord, httpStatus, endpoint, reason: '' };
+    }
+    /** Antwort des Dienstes auf die Ergebnisse aus S11 abbilden (A-15 Nr. 4). */
+    interpret(answer, key, storedActivationId = null) {
+        if (answer.body === null) {
+            return { status: 'unreachable', message: 'The licence service could not be reached: ' + answer.reason };
+        }
+        const body = answer.body;
+        /* activate antwortet mit einem license_key-Block, validate mit den
+           Feldern des Schluessels unmittelbar im Rumpf. */
+        const licenseKey = record(body['license_key']) ?? body;
+        const detail = text(body['detail']);
+        const expiresAt = text(licenseKey['expires_at']);
+        const activationId = this.activationId(answer, storedActivationId);
+        /* 1. Produkt vor allem anderen – auch wenn der Dienst "gueltig" sagt. */
+        const mismatch = this.productMismatch(licenseKey, answer.httpStatus);
+        if (mismatch !== null) {
+            return this.outcome('product_mismatch', mismatch, key, expiresAt, activationId);
+        }
+        /* 2. Abgelaufen, gesperrt oder erloschen. */
+        const status = text(licenseKey['status']);
+        if (status === 'revoked' || this.expiryPassed(expiresAt) || this.keyGone(body)) {
+            const reason = detail ?? 'The licence has expired.';
+            return this.outcome('expired', reason, key, expiresAt, activationId);
+        }
+        /* 3. Erfolg. */
+        if (answer.httpStatus === 200 && status === 'granted') {
+            return this.outcome('valid', 'The licence key is valid.', key, expiresAt, activationId);
+        }
+        /* 4. Alles Uebrige. */
+        let reason = detail ?? text(body['error']) ?? 'The service did not confirm the licence key (HTTP ' + String(answer.httpStatus) + ').';
+        if (answer.httpStatus === 403 || /activation limit/i.test(reason)) {
+            /* Der Wortlaut des Dienstes endet ohne Punkt (Sandbox 23.09.2026). */
+            reason =
+                sentence(reason) +
+                    ' Release the licence on the machine that uses it (run the server with --deactivate there) or ask LayoutBridge support (' + SUPPORT_EMAIL + ') to free the activation.';
+        }
+        else if (answer.httpStatus === 200 && status !== null && status !== 'granted') {
+            reason = 'The service confirmed the key but reports the state "' + status + '".';
+        }
+        return this.outcome('invalid', reason, key, expiresAt, activationId);
+    }
+    /**
+     * activate liefert die Aktivierung als `id` im Rumpf, validate als
+     * `activation.id`; sonst bleibt die gespeicherte Kennung stehen.
+     */
+    activationId(answer, storedActivationId) {
+        const body = answer.body;
+        if (body === null)
+            return storedActivationId;
+        if (answer.endpoint === 'activate')
+            return text(body['id']) ?? storedActivationId;
+        const activation = record(body['activation']);
+        const fromActivation = activation === null ? null : text(activation['id']);
+        return fromActivation ?? storedActivationId;
+    }
+    outcome(status, message, key, expiresAt, activationId) {
+        return {
+            status,
+            message: redactKey(message, key),
+            expires_at: expiresAt,
+            instance_id: activationId,
+        };
+    }
+    expiryPassed(expiresAt) {
+        if (expiresAt === null)
+            return false;
+        const ms = Date.parse(expiresAt);
+        if (Number.isNaN(ms))
+            return false;
+        return ms <= this.now().getTime();
+    }
+    /**
+     * null = in Ordnung; sonst der Klartext der Abweichung. Verglichen wird
+     * nur, was hinterlegt ist und was die Antwort auch nennt. Mit
+     * requireBenefit gilt eine Antwort ohne benefit_id nur dann als fremd,
+     * wenn sie einen Schluessel beschreibt (HTTP 200); eine Fehlerantwort
+     * (unbekannter Schluessel, Aktivierungslimit) bleibt "invalid" mit dem
+     * Wortlaut des Dienstes – gueltig wird sie ohnehin nie (E-109, Nachtrag
+     * 01.11.2026).
+     */
+    productMismatch(licenseKey, httpStatus) {
+        const organizationId = text(licenseKey['organization_id']);
+        const benefitId = text(licenseKey['benefit_id']);
+        if (this.requireBenefit && this.ids.benefit_id === null) {
+            return 'The licence key belongs to another product.';
+        }
+        if (this.requireBenefit && benefitId === null && httpStatus === 200) {
+            return 'The licence key belongs to another product.';
+        }
+        if (!polarIdsConfigured(this.ids))
+            return null;
+        if (this.ids.organization_id !== null && organizationId !== null && organizationId.toLowerCase() !== this.ids.organization_id) {
+            return 'The licence key belongs to another organisation.';
+        }
+        if (this.ids.benefit_id !== null && benefitId !== null && benefitId.toLowerCase() !== this.ids.benefit_id) {
+            return 'The licence key belongs to another product.';
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=polar-verifier.js.map

package/dist/src/mcp/license/product-ids.js

@@ -0,0 +1,73 @@
+/**
+ * Hinterlegte Produktkennungen des Zahlungsdienstes (A-6 Ergaenzung
+ * 06.09.2026, Nr. 4).
+ *
+ * Der Dienst kennt keine Versionsangabe. Es gibt genau ein Produkt mit den
+ * Varianten Monatsabo und Jahresabo; der Connector haelt store_id,
+ * product_id und die zulaessigen variant_id-Werte fest und vergleicht sie
+ * mit dem meta-Block der Antwort. product_version aus dem Kontext wird
+ * nicht gegen die Antwort geprueft, weil der Dienst dazu nichts liefert.
+ *
+ * Solange kein Store besteht, sind die Konstanten leer (null bzw. leere
+ * Liste). Fuer die Live-Probe lassen sie sich von aussen setzen – ueber
+ * Umgebungsvariablen und ausschliesslich in der Bauphase, nie ueber
+ * config.json: config.json ist Kundenkonfiguration und koennte damit den
+ * Produktabgleich aushebeln.
+ */
+import { envName, PRODUCT } from '../product.js';
+/** Kennungen des Live-Stores. Traegt das Vermarktungsprojekt nach. */
+export const PRODUCT_IDS = {
+    store_id: null,
+    product_id: null,
+    variant_ids: [],
+};
+function numberFromEnv(value) {
+    if (value === undefined)
+        return null;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return null;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function numberListFromEnv(value) {
+    if (value === undefined)
+        return null;
+    const parts = value
+        .split(',')
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+    if (parts.length === 0)
+        return null;
+    const numbers = [];
+    for (const part of parts) {
+        const parsed = Number(part);
+        if (!Number.isFinite(parsed))
+            return null;
+        numbers.push(parsed);
+    }
+    return numbers;
+}
+/**
+ * Kennungen fuer diesen Lauf: die hinterlegten Konstanten, einzeln
+ * ueberschreibbar durch Umgebungsvariablen der Bauphase.
+ */
+export function resolveProductIds(env = process.env, base = PRODUCT_IDS, product = PRODUCT) {
+    return {
+        store_id: numberFromEnv(env[envName('LICENSE_STORE_ID', product)]) ?? base.store_id,
+        product_id: numberFromEnv(env[envName('LICENSE_PRODUCT_ID', product)]) ?? base.product_id,
+        variant_ids: numberListFromEnv(env[envName('LICENSE_VARIANT_IDS', product)]) ?? base.variant_ids,
+    };
+}
+/** Ist ueberhaupt eine Kennung hinterlegt? */
+export function productIdsConfigured(ids) {
+    return ids.store_id !== null || ids.product_id !== null || ids.variant_ids.length > 0;
+}
+/** Kurzfassung fuer Startzeile und Protokoll. */
+export function describeProductIds(ids) {
+    if (!productIdsConfigured(ids))
+        return 'not set';
+    const variants = ids.variant_ids.length > 0 ? ids.variant_ids.join('/') : '-';
+    return `store ${ids.store_id ?? '-'}, product ${ids.product_id ?? '-'}, variant ${variants}`;
+}
+//# sourceMappingURL=product-ids.js.map

package/dist/src/mcp/license/state-store.js

@@ -0,0 +1,91 @@
+/**
+ * Speicher fuer das letzte Pruefergebnis (E-60): eine kleine JSON-Datei
+ * neben der Serverkonfiguration. Fehlt sie oder ist sie unlesbar, gilt
+ * "kein Ergebnis" – nie ein Absturz.
+ */
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+const STATUSES = ['valid', 'invalid', 'expired', 'product_mismatch', 'unreachable'];
+function optionalString(value) {
+    return typeof value === 'string' ? value : null;
+}
+/** Text der Speicherdatei pruefen; alles Unbrauchbare ergibt null. */
+export function parseLicenseState(text) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return null;
+    const record = raw;
+    const fp = record['key_fingerprint'];
+    const status = record['status'];
+    const checkedAt = record['checked_at'];
+    if (typeof fp !== 'string' || fp.length === 0)
+        return null;
+    if (typeof status !== 'string' || !STATUSES.includes(status))
+        return null;
+    if (typeof checkedAt !== 'string' || Number.isNaN(Date.parse(checkedAt)))
+        return null;
+    return {
+        key_fingerprint: fp,
+        status: status,
+        checked_at: checkedAt,
+        last_valid_at: optionalString(record['last_valid_at']),
+        expires_at: optionalString(record['expires_at']),
+        instance_id: optionalString(record['instance_id']),
+        /*
+         * A-8 (13.09.2026, E-64): das fruehere Feld customer trug die
+         * E-Mail-Adresse des Kunden. Es wird nicht mehr gelesen und beim
+         * naechsten Schreiben ueberschrieben – so verschwindet es von selbst.
+         */
+        verifier: typeof record['verifier'] === 'string' ? record['verifier'] : '',
+        message: typeof record['message'] === 'string' ? record['message'] : '',
+    };
+}
+export class FileLicenseStateStore {
+    location;
+    constructor(location) {
+        this.location = location;
+    }
+    load() {
+        let text;
+        try {
+            text = readFileSync(this.location, 'utf8');
+        }
+        catch {
+            return null;
+        }
+        return parseLicenseState(text);
+    }
+    save(state) {
+        mkdirSync(dirname(this.location), { recursive: true });
+        writeFileSync(this.location, JSON.stringify(state, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+    }
+    clear() {
+        try {
+            unlinkSync(this.location);
+        }
+        catch {
+            /* schon weg */
+        }
+    }
+}
+/** Speicher im Arbeitsspeicher – fuer Tests. */
+export class MemoryLicenseStateStore {
+    location = 'memory';
+    state = null;
+    load() {
+        return this.state === null ? null : { ...this.state };
+    }
+    save(state) {
+        this.state = { ...state };
+    }
+    clear() {
+        this.state = null;
+    }
+}
+//# sourceMappingURL=state-store.js.map

package/dist/src/mcp/license/types.js

@@ -0,0 +1,11 @@
+/**
+ * Lizenzschranke (Auftrag A-6 mit Nachtrag 05.09.2026, E-60): Typen.
+ *
+ * Diese Schicht kennt weder InDesign noch den Transport. Sie kennt nur den
+ * Schluessel, ein gespeichertes Pruefergebnis und eine austauschbare
+ * Prueffunktion (LicenseVerifier). Der eigentliche Aufruf beim
+ * Zahlungsdienst kommt als eigene Klasse an diese Schnittstelle, sobald der
+ * Dienst mit Endpunkten beauftragt ist.
+ */
+export {};
+//# sourceMappingURL=types.js.map