@kreiseck/kasseneck-api 0.13.2 → 0.15.0

package/dist/esm/receipt/epos.d.ts

@@ -1,11 +1,12 @@
 import type { ReceiptLayout } from './layout.js';
 import type { PosPaperSize } from '../printing/escpos.js';
-import { type QrModulGroesse } from '../printing/index.js';
+import { type QrModulGroesse, type RasterBild } from '../printing/index.js';
+import { type DruckLogo } from './layout-escpos.js';
 /**
  * ePOS-Print XML (Epson TM-Drucker: Server Direct Print, ePOS-Print ueber
  * HTTP) -- **aus dem Zeichenraster**: jede Rasterzeile wird eine <text>-Zeile
- * mit exakt N Zeichen und Zeilenumbruch, Aufdrucke doppelt hoch (Warnungen
- * invers), QR als <symbol>, Leerraum als <feed>, am Ende Schnitt. Kein
+ * mit exakt N Zeichen und Zeilenumbruch, Aufdrucke als Rahmen aus
+ * Rasterzeilen, QR als <symbol>, Leerraum als <feed>, am Ende Schnitt. Kein
  * eigenes Setzen -- was Bildschirm, ESC/POS und PDF zeigen, druckt der Epson
  * Zeile fuer Zeile genauso.
  *
@@ -22,16 +23,20 @@ export interface EposPrintXmlOptions {
      */
     qrBreite?: number;
     /**
-     * Deckel fuer die gerechnete QR-Modulgroesse; Vorgabe `mittel`.
+     * Deckel fuer die gerechnete QR-Modulgroesse; Vorgabe `auto` (hoechstens 6
+     * Punkte je Modul) -- wie ESC/POS, Blatt und der Flutter-Zwilling.
      *
-     * Warum `mittel` und nicht `auto`: `auto` deckelt beim Bestandswert des
-     * **ESC/POS**-Befehls dieses Pakets (4), dieser Weg druckt aber seit jeher
-     * mit 6. Die Vorgabe nennt den Bestandswert dieses Wegs also ausdruecklich,
-     * damit ohne Wahl kein Byte anders herauskommt.
+     * Bis 0.13 stand hier `mittel`, weil `auto` damals beim ESC/POS-Wert 4
+     * deckelte und dieser Weg seit jeher mit 6 druckt. Seit `auto` ueberall 6
+     * heisst, ist das derselbe Wert: ohne Wahl kommt kein Byte anders heraus.
      */
     qrGroesse?: QrModulGroesse;
     /** Papierschnitt am Ende, Vorgabe true. */
     cut?: boolean;
+    /** Firmenlogo; ohne Angabe kein Logo. */
+    logo?: DruckLogo | null;
+    /** "erstellt mit Kasseneck" am Ende. */
+    marke?: boolean;
 }
 /**
  * Das XML **samt** dem, was dem QR unterwegs zugestossen ist -- dieselbe
@@ -45,6 +50,8 @@ export interface EposPrintErgebnis {
     qrAusweich: string | null;
 }
 export declare function eposXmlEscape(text: string): string;
+/** Ein Rasterbild als ePOS-`<image>` (einfarbig, Punktmass, Rasterzeilen Base64). */
+export declare function eposBildXml(bild: RasterBild): string;
 /** Nur das XML; wer die QR-Meldungen braucht, nimmt [eposPrintXmlErgebnis]. */
 export declare function eposPrintXml(layout: ReceiptLayout, options?: EposPrintXmlOptions): string;
 /**
@@ -77,6 +84,10 @@ export interface EposDirectOptions {
     qrBreite?: number;
     /** Deckel fuer die gerechnete QR-Modulgroesse; siehe [EposPrintXmlOptions.qrGroesse]. */
     qrGroesse?: QrModulGroesse;
+    /** Firmenlogo; ohne Angabe kein Logo. */
+    logo?: DruckLogo | null;
+    /** "erstellt mit Kasseneck" am Ende. */
+    marke?: boolean;
     timeoutMs?: number;
 }
 export interface EposResponse {

package/dist/esm/receipt/epos.js

@@ -1,8 +1,13 @@
-import { QR_DRUCK_PUNKTE, QR_MINDEST_PUNKTE, QR_MODUL_DECKEL, qrGroesseFuer, } from '../printing/index.js';
-import { renderReceiptGrid, ZEICHEN_JE_PAPIER } from './grid.js';
+import { QR_DRUCK_PUNKTE, QR_MINDEST_PUNKTE, QR_MODUL_DECKEL, qrGroesseFuer, qrPasstInVersion, rasterZeilenBase64, } from '../printing/index.js';
+import { ZEICHEN_JE_PAPIER } from './grid.js';
+import { blattFuerDruck } from './layout-escpos.js';
 export function eposXmlEscape(text) {
     return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
 }
+/** Ein Rasterbild als ePOS-`<image>` (einfarbig, Punktmass, Rasterzeilen Base64). */
+export function eposBildXml(bild) {
+    return `<image width="${bild.breite}" height="${bild.hoehe}" color="color_1" mode="mono">${rasterZeilenBase64(bild)}</image>`;
+}
 const NS = 'http://www.epson-pos.com/schemas/2011/03/epos-print';
 /** Nur das XML; wer die QR-Meldungen braucht, nimmt [eposPrintXmlErgebnis]. */
 export function eposPrintXml(layout, options = {}) {
@@ -19,8 +24,9 @@ export function eposPrintXml(layout, options = {}) {
  * laesst es weg; genau daran fehlte am echten Beleg der QR.
  */
 export function eposPrintXmlErgebnis(layout, options = {}) {
-    const grid = renderReceiptGrid(layout, { zeichen: options.zeichen ?? ZEICHEN_JE_PAPIER[layout.paperSize] });
-    const deckel = options.qrGroesse ?? 'mittel';
+    const zeichen = options.zeichen ?? ZEICHEN_JE_PAPIER[layout.paperSize];
+    const deckel = options.qrGroesse ?? 'auto';
+    const blatt = blattFuerDruck(layout, { zeichen, logo: options.logo, marke: options.marke, qrGroesse: deckel });
     const fest = options.qrBreite === undefined
         ? null
         : Math.min(16, Math.max(3, Math.floor(options.qrBreite)));
@@ -39,6 +45,12 @@ export function eposPrintXmlErgebnis(layout, options = {}) {
             return fest;
         if (nutzlast === '')
             return QR_MODUL_DECKEL[deckel];
+        // Passt der Inhalt in keine QR-Version, gibt es kein Symbol, das der
+        // Drucker setzen koennte -- wie beim Blatt (Anteil 0) geht der Beleg ohne QR.
+        if (!qrPasstInVersion(nutzlast)) {
+            qrFehler = 'QR-Inhalt passt in keine QR-Version -- Beleg ohne QR';
+            return null;
+        }
         const mass = qrGroesseFuer({
             nutzlast,
             papierbreitePunkte: QR_DRUCK_PUNKTE[layout.paperSize],
@@ -63,32 +75,34 @@ export function eposPrintXmlErgebnis(layout, options = {}) {
     out.push('<text font="font_a"/>');
     out.push('<text align="left"/>');
     out.push('<text width="1" height="1" reverse="false" em="false"/>');
-    for (const z of grid.lines) {
-        switch (z.kind) {
-            case 'space':
-                out.push('<feed line="1"/>');
+    for (const block of blatt.bloecke) {
+        switch (block.art) {
+            case 'zeile':
+                if (block.leer)
+                    out.push('<feed line="1"/>');
+                else if (block.fett) {
+                    out.push(`<text em="true">${eposXmlEscape(block.text)}&#10;</text>`);
+                    out.push('<text em="false"/>');
+                }
+                else
+                    out.push(`<text>${eposXmlEscape(block.text)}&#10;</text>`);
+                break;
+            case 'logo':
+                if (options.logo) {
+                    out.push('<text align="center"/>');
+                    out.push(eposBildXml(options.logo.raster));
+                    out.push('<text align="left"/>');
+                }
                 break;
             case 'qr': {
-                const breite = qrBreiteFuer(z.qr ?? '');
+                const breite = qrBreiteFuer(block.nutzlast);
                 if (breite === null)
                     break;
                 out.push('<text align="center"/>');
-                out.push(`<symbol type="qrcode_model_2" level="level_m" width="${breite}" height="0" size="0">${eposXmlEscape(z.qr ?? '')}</symbol>`);
+                out.push(`<symbol type="qrcode_model_2" level="level_m" width="${breite}" height="0" size="0">${eposXmlEscape(block.nutzlast)}</symbol>`);
                 out.push('<text align="left"/>');
                 break;
             }
-            case 'banner':
-                out.push(`<text width="1" height="2" reverse="${z.ton === 'warnung' ? 'true' : 'false'}" em="true">${eposXmlEscape(z.text)}&#10;</text>`);
-                out.push('<text width="1" height="1" reverse="false" em="false"/>');
-                break;
-            default:
-                if (z.bold)
-                    out.push(`<text em="true">${eposXmlEscape(z.text)}&#10;</text>`);
-                else
-                    out.push(`<text>${eposXmlEscape(z.text)}&#10;</text>`);
-                if (z.bold)
-                    out.push('<text em="false"/>');
-                break;
         }
     }
     if (options.cut !== false) {
@@ -208,6 +222,10 @@ export function eposDirectPrint(layout, o, fetchFn = fetch) {
         xmlOptionen.qrBreite = o.qrBreite;
     if (o.qrGroesse !== undefined)
         xmlOptionen.qrGroesse = o.qrGroesse;
+    if (o.logo)
+        xmlOptionen.logo = o.logo;
+    if (o.marke !== undefined)
+        xmlOptionen.marke = o.marke;
     return eposDirectSend(eposPrintXml({ ...layout, paperSize: papier }, xmlOptionen), o, fetchFn);
 }
 /** Verbindungstest: leeres Dokument, druckt nichts, liefert den Druckerstatus. */

package/dist/esm/receipt/grid.d.ts

@@ -27,7 +27,7 @@ export interface GridLine {
     text: string;
     kind: GridLineKind;
     bold: boolean;
-    /** Bei `banner`: `warnung` = invers/auffaellig, `belegart` = Rahmen. */
+    /** Bei `banner` (Rahmen- und Textzeilen): `warnung` = Test/Ausfall, `belegart` = Storno, Nullbeleg … */
     ton?: 'belegart' | 'warnung';
     /** Bei `qr`: die Nutzlast. */
     qr?: string;

package/dist/esm/receipt/grid.js

@@ -61,10 +61,18 @@ export function renderReceiptGrid(layout, options = {}) {
                 for (const t of wortzeilenText(z.text, zeichen))
                     lines.push({ text: ausrichten(t, zeichen, z.align), kind: 'text', bold: z.bold });
                 break;
-            case 'banner':
+            case 'banner': {
+                // Der Rahmen ist Teil des Rasters: eine Zeile '=' ueber die volle Breite
+                // davor und danach. So setzt ihn jeder Weg -- Bildschirm, Bon, ePOS, PDF,
+                // myPOS -- Zeichen fuer Zeichen gleich. Vorher zeichnete jeder Weg seinen
+                // eigenen Rahmen (Rechteck, doppelt hoch, invers, gefuellt).
+                const rahmen = '='.repeat(zeichen);
+                lines.push({ text: rahmen, kind: 'banner', bold: true, ton: z.ton });
                 for (const t of wortzeilenText(z.text, zeichen))
                     lines.push({ text: ausrichten(t, zeichen, 'center'), kind: 'banner', bold: true, ton: z.ton });
+                lines.push({ text: rahmen, kind: 'banner', bold: true, ton: z.ton });
                 break;
+            }
             case 'rule':
                 lines.push({ text: (z.char || '-').charAt(0).repeat(zeichen), kind: 'rule', bold: false });
                 break;

package/dist/esm/receipt/index.d.ts

@@ -1,4 +1,6 @@
 export { type LayoutAlign, type LayoutColumn, type LayoutTextLine, type LayoutColumnsLine, type LayoutRuleLine, type LayoutSpaceLine, type LayoutQrLine, type LayoutLine, type ReceiptLayout, type BuildReceiptLayoutOptions, buildReceiptLayout, receiptSignatureFailed, receiptSignatureIsTest, receiptIsZero, receiptAmountsAreZero, receiptIsSmallBusinessConsistent, receiptZdaText, type Pruefangaben, AKTUELLES_REGELWERK, type LayoutBannerLine, type LayoutRegelwerk, SMALL_BUSINESS_NOTICE, formatCents, } from './layout.js';
-export { type EscPosLayoutOptions, type EscPosLayoutErgebnis, type QrPrintMode, escPosLayoutBytes, escPosLayoutErgebnis, } from './layout-escpos.js';
+export { type EscPosLayoutOptions, type EscPosLayoutErgebnis, type QrPrintMode, type DruckLogo, pruefeLogoRaster, escPosLayoutBytes, escPosLayoutErgebnis, } from './layout-escpos.js';
 export { type GridLine, type GridLineKind, type ReceiptGrid, type RenderReceiptGridOptions, renderReceiptGrid, gridSpaltenBreiten, gridAlsText, ZEICHEN_JE_PAPIER, } from './grid.js';
-export { type EposPrintXmlOptions, type EposPrintErgebnis, type EposDirectOptions, type EposResponse, EposConnectionError, eposPrintXml, eposPrintXmlErgebnis, eposXmlEscape, eposServiceUrl, eposSoapEnvelope, eposParseResponse, eposDirectPrint, eposDirectStatus } from './epos.js';
+export { type EposPrintXmlOptions, type EposPrintErgebnis, type EposDirectOptions, type EposResponse, EposConnectionError, eposPrintXml, eposPrintXmlErgebnis, eposXmlEscape, eposBildXml, eposServiceUrl, eposSoapEnvelope, eposParseResponse, eposDirectPrint, eposDirectStatus } from './epos.js';
+export { type LogoStufe, type BlattLogo, type LogoMass, type BlattBlock, type BelegBlatt, type BelegBlattOptionen, LOGO_STUFEN, LOGO_PIXEL_MAX, PUNKTE_JE_ZEICHEN, PUNKTE_JE_ZEILE, MARKE_TEXT, papierFuerZeichen, logoMass, logoPixelZulaessig, logoRasterMass, qrBlattAnteil, belegBlatt, } from './blatt.js';
+export { logoRaster } from './bild.js';

package/dist/esm/receipt/index.js

@@ -1,4 +1,6 @@
 export { buildReceiptLayout, receiptSignatureFailed, receiptSignatureIsTest, receiptIsZero, receiptAmountsAreZero, receiptIsSmallBusinessConsistent, receiptZdaText, AKTUELLES_REGELWERK, SMALL_BUSINESS_NOTICE, formatCents, } from './layout.js';
-export { escPosLayoutBytes, escPosLayoutErgebnis, } from './layout-escpos.js';
+export { pruefeLogoRaster, escPosLayoutBytes, escPosLayoutErgebnis, } from './layout-escpos.js';
 export { renderReceiptGrid, gridSpaltenBreiten, gridAlsText, ZEICHEN_JE_PAPIER, } from './grid.js';
-export { EposConnectionError, eposPrintXml, eposPrintXmlErgebnis, eposXmlEscape, eposServiceUrl, eposSoapEnvelope, eposParseResponse, eposDirectPrint, eposDirectStatus } from './epos.js';
+export { EposConnectionError, eposPrintXml, eposPrintXmlErgebnis, eposXmlEscape, eposBildXml, eposServiceUrl, eposSoapEnvelope, eposParseResponse, eposDirectPrint, eposDirectStatus } from './epos.js';
+export { LOGO_STUFEN, LOGO_PIXEL_MAX, PUNKTE_JE_ZEICHEN, PUNKTE_JE_ZEILE, MARKE_TEXT, papierFuerZeichen, logoMass, logoPixelZulaessig, logoRasterMass, qrBlattAnteil, belegBlatt, } from './blatt.js';
+export { logoRaster } from './bild.js';

package/dist/esm/receipt/layout-escpos.d.ts

@@ -1,5 +1,6 @@
-import { type PosCodeTable, type PosCutMode, type PosPaperSize, type QrCorrection, type QrMatrix, type QrModulGroesse, type QrSize } from '../printing/index.js';
+import { type PosCodeTable, type PosCutMode, type PosPaperSize, type QrCorrection, type QrMatrix, type QrModulGroesse, type QrSize, type RasterBild } from '../printing/index.js';
 import type { ReceiptLayout } from './layout.js';
+import { type BelegBlatt, type LogoStufe, type LogoMass } from './blatt.js';
 /**
  * Bruecke vom Layout-Modell zu ESC/POS-Bytes — der Bondrucker-Ausgabeweg.
  *
@@ -28,6 +29,29 @@ import type { ReceiptLayout } from './layout.js';
  *                   (`qrMatrix`), weil dieses Paket keine QR-Codes rechnet.
  */
 export type QrPrintMode = 'native' | 'nativeModel1' | 'imageRaster';
+/** Firmenlogo fuer den Druck: Stufe, Pixelmass des Originals und das fertige Rasterbild (`logoRaster`). */
+export interface DruckLogo {
+    stufe: LogoStufe;
+    pxBreite: number;
+    pxHoehe: number;
+    raster: RasterBild;
+}
+/** Das Rasterbild muss genau so gross sein, wie das Blatt das Logo setzt -- sonst stuende am Bon ein anderes Logo als am Schirm. */
+export declare function pruefeLogoRaster(logo: DruckLogo, mass: LogoMass, zeichen: number): void;
+/**
+ * Baut das Blatt fuer einen Druckweg (ESC/POS, ePOS) an EINER Stelle: die
+ * Zuordnung `DruckLogo` -> `BlattLogo` und die Groessenpruefung des mitgebrachten
+ * Rasterbilds teilen sich beide Wege -- ohne das muesste eine Aenderung daran an
+ * zwei Stellen nachgezogen werden. Wirft VOR jeder Ausgabe (also bevor der
+ * Aufrufer auch nur ein Byte/Zeichen geschrieben hat), wenn das Rasterbild nicht
+ * zur Logo-Stufe passt.
+ */
+export declare function blattFuerDruck(layout: ReceiptLayout, optionen: {
+    zeichen: number;
+    logo?: DruckLogo | null;
+    marke?: boolean;
+    qrGroesse: QrModulGroesse;
+}): BelegBlatt;
 export interface EscPosLayoutOptions {
     /** Papierbreite; Vorgabe ist die des Layouts (dessen Spaltenbreiten daran haengen). */
     paperSize?: PosPaperSize;
@@ -40,9 +64,9 @@ export interface EscPosLayoutOptions {
      * dann passt der Aufrufer selbst auf, dass das Symbol aufs Papier geht.
      */
     qrSize?: QrSize;
-    /** Fehlerkorrekturstufe des QR-Codes. */
+    /** Fehlerkorrekturstufe des QR-Codes; Vorgabe `M` (wie ePOS, Bildweg und Blatt). */
     qrCorrection?: QrCorrection;
-    /** Deckel fuer die gerechnete Modulgroesse; Vorgabe `auto`. */
+    /** Deckel fuer die gerechnete Modulgroesse; Vorgabe `auto` (hoechstens 6 Punkte je Modul). */
     qrGroesse?: QrModulGroesse;
     /** Druckweg des QR; Vorgabe `native` (der Bestandsweg). */
     qrModus?: QrPrintMode;
@@ -54,6 +78,10 @@ export interface EscPosLayoutOptions {
      * aus der QR-Bibliothek, die er ohnehin fuer den Bildschirm benutzt.
      */
     qrMatrix?: (nutzlast: string) => QrMatrix;
+    /** Firmenlogo; ohne Angabe kein Logo (Bestand). */
+    logo?: DruckLogo | null;
+    /** "erstellt mit Kasseneck" am Ende (Konto-Flag `kreiseck_logo`). */
+    marke?: boolean;
 }
 /**
  * Der Bytestrom **samt** dem, was dem QR unterwegs zugestossen ist.

package/dist/esm/receipt/layout-escpos.js

@@ -1,5 +1,35 @@
-import { createEscPosDocument, escPosBytes, escPosCut, escPosFeed, escPosPrintableText, escPosQrCode, escPosQrRaster, escPosReset, escPosText, QR_DRUCK_PUNKTE, qrGroesseFuer, } from '../printing/index.js';
-import { renderReceiptGrid, ZEICHEN_JE_PAPIER } from './grid.js';
+import { createEscPosDocument, escPosBytes, escPosCut, escPosFeed, escPosPrintableText, escPosQrCode, escPosQrRaster, escPosRasterBild, escPosReset, escPosText, QR_DRUCK_PUNKTE, qrGroesseFuer, qrPasstInVersion, } from '../printing/index.js';
+import { belegBlatt, logoRasterMass } from './blatt.js';
+import { ZEICHEN_JE_PAPIER } from './grid.js';
+/** Das Rasterbild muss genau so gross sein, wie das Blatt das Logo setzt -- sonst stuende am Bon ein anderes Logo als am Schirm. */
+export function pruefeLogoRaster(logo, mass, zeichen) {
+    const soll = logoRasterMass(mass, zeichen);
+    if (logo.raster.breite !== soll.breite || logo.raster.hoehe !== soll.hoehe) {
+        throw new Error(`Logo-Raster ${logo.raster.breite}x${logo.raster.hoehe} passt nicht zum Blatt (${soll.breite}x${soll.hoehe})`);
+    }
+}
+/**
+ * Baut das Blatt fuer einen Druckweg (ESC/POS, ePOS) an EINER Stelle: die
+ * Zuordnung `DruckLogo` -> `BlattLogo` und die Groessenpruefung des mitgebrachten
+ * Rasterbilds teilen sich beide Wege -- ohne das muesste eine Aenderung daran an
+ * zwei Stellen nachgezogen werden. Wirft VOR jeder Ausgabe (also bevor der
+ * Aufrufer auch nur ein Byte/Zeichen geschrieben hat), wenn das Rasterbild nicht
+ * zur Logo-Stufe passt.
+ */
+export function blattFuerDruck(layout, optionen) {
+    const blattOptionen = {
+        zeichen: optionen.zeichen,
+        marke: optionen.marke === true,
+        qrGroesse: optionen.qrGroesse,
+    };
+    if (optionen.logo)
+        blattOptionen.logo = { stufe: optionen.logo.stufe, pxBreite: optionen.logo.pxBreite, pxHoehe: optionen.logo.pxHoehe };
+    const blatt = belegBlatt(layout, blattOptionen);
+    const logoBlock = blatt.bloecke.find((b) => b.art === 'logo');
+    if (optionen.logo && logoBlock && logoBlock.art === 'logo')
+        pruefeLogoRaster(optionen.logo, logoBlock, blatt.zeichen);
+    return blatt;
+}
 /**
  * Druckbar gemachtes Layout: Texte durch [escPosPrintableText] (Codepage,
  * "EUR" statt "€", Striche), damit das Raster mit den Zeichen rechnet, die
@@ -68,6 +98,13 @@ export function escPosLayoutErgebnis(layout, options = {}) {
      * `qrFehler` aus `escPosQrCode`, und der Beleg geht ohne QR hinaus.
      */
     const qrZeile = (nutzlast) => {
+        // Ein Inhalt, der in keine QR-Version passt, laesst sich weder als Befehl
+        // noch als Bild drucken -- beide Wege wuerfen. Der Beleg geht ohne QR
+        // hinaus und sagt es ueber `qrFehler`, wie das Blatt (Anteil 0).
+        if (nutzlast !== '' && !qrPasstInVersion(nutzlast)) {
+            doc.qrFehler = 'QR-Inhalt passt in keine QR-Version -- Beleg ohne QR';
+            return;
+        }
         const raster = options.qrMatrix;
         if (nutzlast !== '' && raster !== undefined) {
             if (modus === 'imageRaster') {
@@ -94,27 +131,28 @@ export function escPosLayoutErgebnis(layout, options = {}) {
         }
         escPosQrCode(doc, nutzlast, qrOptionen);
     };
-    const grid = renderReceiptGrid(druckbaresLayout(layout), { zeichen: ZEICHEN_JE_PAPIER[paperSize] });
-    for (const zeile of grid.lines) {
-        switch (zeile.kind) {
-            case 'space':
-                escPosFeed(doc, 1);
-                break;
+    // `blattFuerDruck` prueft das Logo-Raster bereits VOR der Rueckgabe -- die
+    // Schleife unten schreibt darum nie ein Byte auf ein falsch grosses Logo.
+    const blatt = blattFuerDruck(druckbaresLayout(layout), {
+        zeichen: ZEICHEN_JE_PAPIER[paperSize],
+        logo: options.logo,
+        marke: options.marke,
+        qrGroesse: options.qrGroesse ?? 'auto',
+    });
+    for (const block of blatt.bloecke) {
+        switch (block.art) {
             case 'qr':
-                qrZeile(zeile.qr ?? '');
+                qrZeile(block.nutzlast);
                 break;
-            case 'banner': {
-                // Belegart/Warnung: fett zwischen zwei Volllinien — derselbe Rahmen-
-                // Stil wie im Beleg-Viewer und im PDF (frueher druckte der Bon invers
-                // weiss-auf-schwarz und sah damit anders aus als jede Anzeige).
-                const rahmen = '='.repeat(ZEICHEN_JE_PAPIER[paperSize]);
-                escPosText(doc, rahmen, { styles: { align: 'left', bold: true } });
-                escPosText(doc, zeile.text.trimEnd(), { styles: { align: 'left', bold: true, height: 2 } });
-                escPosText(doc, rahmen, { styles: { align: 'left', bold: true } });
+            case 'logo':
+                if (options.logo)
+                    escPosRasterBild(doc, options.logo.raster, { align: 'center' });
                 break;
-            }
-            default:
-                escPosText(doc, zeile.text.trimEnd(), { styles: { align: 'left', bold: zeile.bold } });
+            case 'zeile':
+                if (block.leer)
+                    escPosFeed(doc, 1);
+                else
+                    escPosText(doc, block.text.trimEnd(), { styles: { align: 'left', bold: block.fett } });
                 break;
         }
     }

package/dist/esm/rechnung/api.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Fassade ueber den Aufrufen der Rechnungs-API: Schluessel einmal binden, dann rufen.
+ *
+ * Wie [createPartnerApi] bewusst **keine** Klasse — die Aufrufe sind freie
+ * Funktionen (endpunkte.ts) und bleiben einzeln importierbar.
+ */
+import { type FetchLike } from '../client/transport.js';
+import type { EInvoiceFormat } from './vertrag.js';
+import type { CancelInvoiceRequest, CancelResult, CreditNoteRequest, CreditNoteResult, Customer, CustomerInput, CustomerPage, CustomerSearch, InvoiceDetail, InvoiceListQuery, InvoicePage, IssueInvoiceRequest, IssueResult } from './typen.js';
+export interface RechnungApiOptions {
+    /** `api_key` des Kontos (`kr_live_…` / `kr_test_…`). Gehoert auf einen Server. */
+    apiKey: string;
+    /** Abweichende Basis-URL; Vorgabe `https://api.kasseneck.at/v1`. */
+    baseUrl?: string;
+    /** Zeitlimit je Aufruf in Millisekunden. */
+    timeoutMs?: number;
+    /** Eigene `fetch`-Umsetzung (Tests, Proxys). */
+    fetch?: FetchLike;
+}
+export interface RechnungApi {
+    createCustomer(customer: CustomerInput, optionen?: {
+        idempotencyKey?: string;
+    }): Promise<Customer>;
+    getCustomer(kennung: {
+        customerId: string;
+    } | {
+        externalId: string;
+    }): Promise<Customer>;
+    updateCustomer(customerId: string, patch: Partial<CustomerInput>): Promise<Customer>;
+    searchCustomers(suche: CustomerSearch): Promise<CustomerPage>;
+    issueInvoice(anfrage: IssueInvoiceRequest): Promise<IssueResult>;
+    cancelInvoice(anfrage: CancelInvoiceRequest): Promise<CancelResult>;
+    createCreditNote(anfrage: CreditNoteRequest): Promise<CreditNoteResult>;
+    getInvoice(kennung: {
+        invoiceId: string;
+    } | {
+        number: string;
+    }): Promise<InvoiceDetail>;
+    listInvoices(abfrage?: InvoiceListQuery): Promise<InvoicePage>;
+    getInvoicePdf(invoiceId: string): Promise<Uint8Array>;
+    getInvoiceXml(invoiceId: string, format?: EInvoiceFormat): Promise<string>;
+}
+export declare function createRechnungApi(optionen: RechnungApiOptions): RechnungApi;

package/dist/esm/rechnung/api.js

@@ -0,0 +1,32 @@
+/**
+ * Fassade ueber den Aufrufen der Rechnungs-API: Schluessel einmal binden, dann rufen.
+ *
+ * Wie [createPartnerApi] bewusst **keine** Klasse — die Aufrufe sind freie
+ * Funktionen (endpunkte.ts) und bleiben einzeln importierbar.
+ */
+import { createBinaryTransport, createTransport } from '../client/transport.js';
+import { rechnungKeyAuth } from './auth.js';
+import { cancelInvoice, createCreditNote, createCustomer, getCustomer, getInvoice, getInvoicePdf, getInvoiceXml, issueInvoice, listInvoices, searchCustomers, updateCustomer, } from './endpunkte.js';
+export function createRechnungApi(optionen) {
+    const transportOptionen = {
+        auth: rechnungKeyAuth({ apiKey: optionen.apiKey }),
+        baseUrl: optionen.baseUrl,
+        timeoutMs: optionen.timeoutMs,
+        fetch: optionen.fetch,
+    };
+    const rufen = createTransport(transportOptionen);
+    const rufenBinaer = createBinaryTransport(transportOptionen);
+    return {
+        createCustomer: (customer, o) => createCustomer(rufen, customer, o),
+        getCustomer: (kennung) => getCustomer(rufen, kennung),
+        updateCustomer: (id, patch) => updateCustomer(rufen, id, patch),
+        searchCustomers: (suche) => searchCustomers(rufen, suche),
+        issueInvoice: (anfrage) => issueInvoice(rufen, anfrage),
+        cancelInvoice: (anfrage) => cancelInvoice(rufen, anfrage),
+        createCreditNote: (anfrage) => createCreditNote(rufen, anfrage),
+        getInvoice: (kennung) => getInvoice(rufen, kennung),
+        listInvoices: (abfrage) => listInvoices(rufen, abfrage),
+        getInvoicePdf: (id) => getInvoicePdf(rufenBinaer, id),
+        getInvoiceXml: (id, format) => getInvoiceXml(rufen, id, format),
+    };
+}

package/dist/esm/rechnung/auth.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Anmeldung fuer die Rechnungs-API: der `api_key` des Kontos als Bearer.
+ *
+ * Anders als `apiKeyAuth` **ohne** `cashregister-token` — eine Rechnung
+ * entsteht nicht an einer Kasse, sondern am Konto.
+ *
+ * **Der Schluessel gehoert auf einen Server.** Mit ihm entstehen festgeschriebene
+ * Rechnungen mit fortlaufender Nummer, die sich nur noch per Gutschrift
+ * korrigieren lassen.
+ *
+ * Geprueft wird nur, was ohne Netz sicher falsch ist: ein leerer Wert, ein
+ * Partner-Schluessel (`pk_…`) oder ein Kassen-Token (`cb_…`). Die Form des
+ * Kontoschluessels selbst bleibt offen, weil das Backend neben `kr_<env>_…`
+ * weiterhin aeltere Formen annimmt. Die Meldung nennt nie den Wert, nur seine Art.
+ */
+import type { KasseneckAuth } from '../client/auth.js';
+export interface RechnungKeyAuthOptions {
+    /** `api_key` des Kontos, z. B. `kr_live_…` oder `kr_test_…`. */
+    apiKey: string;
+}
+export declare function rechnungKeyAuth(options: RechnungKeyAuthOptions): KasseneckAuth;

package/dist/esm/rechnung/auth.js

@@ -0,0 +1,33 @@
+/**
+ * Anmeldung fuer die Rechnungs-API: der `api_key` des Kontos als Bearer.
+ *
+ * Anders als `apiKeyAuth` **ohne** `cashregister-token` — eine Rechnung
+ * entsteht nicht an einer Kasse, sondern am Konto.
+ *
+ * **Der Schluessel gehoert auf einen Server.** Mit ihm entstehen festgeschriebene
+ * Rechnungen mit fortlaufender Nummer, die sich nur noch per Gutschrift
+ * korrigieren lassen.
+ *
+ * Geprueft wird nur, was ohne Netz sicher falsch ist: ein leerer Wert, ein
+ * Partner-Schluessel (`pk_…`) oder ein Kassen-Token (`cb_…`). Die Form des
+ * Kontoschluessels selbst bleibt offen, weil das Backend neben `kr_<env>_…`
+ * weiterhin aeltere Formen annimmt. Die Meldung nennt nie den Wert, nur seine Art.
+ */
+import { KasseneckAuthError } from '../client/errors.js';
+export function rechnungKeyAuth(options) {
+    const schluessel = typeof options?.apiKey === 'string' ? options.apiKey.trim() : '';
+    if (!schluessel) {
+        throw new KasseneckAuthError('rechnungKeyAuth: apiKey fehlt');
+    }
+    if (/^pk_(live|test)_/i.test(schluessel)) {
+        throw new KasseneckAuthError('rechnungKeyAuth: das ist ein Partner-Schluessel (pk_…) — die Rechnungs-API nimmt den api_key des Kontos (kr_…)');
+    }
+    if (/^cb_(live|test)_/i.test(schluessel)) {
+        throw new KasseneckAuthError('rechnungKeyAuth: das ist ein Kassen-Token (cb_…) — die Rechnungs-API nimmt den api_key des Kontos (kr_…)');
+    }
+    // Pro Aufruf ein frisches Objekt, wie bei den anderen Anmeldungen.
+    return () => ({
+        headers: { Authorization: `Bearer ${schluessel}` },
+        params: {},
+    });
+}

package/dist/esm/rechnung/endpunkte.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Die Aufrufe der Rechnungs-API — Kunden, Rechnungen, Gutschriften, Dateien.
+ *
+ * Jede Funktion nimmt den Transport als ersten Parameter und ist einzeln
+ * importierbar; die Fassade [createRechnungApi] bindet ihn nur einmal.
+ *
+ * **Geprueft wird hier nichts Fachliches.** Die Anfrage geht unveraendert an
+ * das Backend, das sie gegen denselben Vertrag prueft (`vertrag.ts`) und einen
+ * Formfehler als `validation` mit `errors[]` zurueckgibt — zwei Pruefungen
+ * hiessen zwei Wahrheiten, von denen eine veraltet.
+ *
+ * **Nicht automatisch wiederholen.** Wer nach einem Zeitlimit erneut
+ * ausstellt, tut das mit **demselben** `idempotencyKey`: dann kommt die schon
+ * ausgestellte Rechnung zurueck (`replayed: true`) statt einer zweiten.
+ *
+ * Nach dem Senden wird nichts hart gecastet: fehlt ein zugesagtes Feld, wirft
+ * der Aufruf `KasseneckValidationError` mit `scope:'response'`.
+ */
+import type { InternerBinaerTransport, InternerTransport } from '../client/aufrufe.js';
+import type { EInvoiceFormat } from './vertrag.js';
+import type { CancelInvoiceRequest, CancelResult, CreditNoteRequest, CreditNoteResult, Customer, CustomerInput, CustomerPage, CustomerSearch, InvoiceDetail, InvoiceListQuery, InvoicePage, IssueInvoiceRequest, IssueResult } from './typen.js';
+export declare function createCustomer(rufen: InternerTransport, customer: CustomerInput, optionen?: {
+    idempotencyKey?: string;
+}): Promise<Customer>;
+export declare function getCustomer(rufen: InternerTransport, kennung: {
+    customerId: string;
+} | {
+    externalId: string;
+}): Promise<Customer>;
+export declare function updateCustomer(rufen: InternerTransport, customerId: string, patch: Partial<CustomerInput>): Promise<Customer>;
+export declare function searchCustomers(rufen: InternerTransport, suche: CustomerSearch): Promise<CustomerPage>;
+export declare function issueInvoice(rufen: InternerTransport, anfrage: IssueInvoiceRequest): Promise<IssueResult>;
+export declare function cancelInvoice(rufen: InternerTransport, anfrage: CancelInvoiceRequest): Promise<CancelResult>;
+export declare function createCreditNote(rufen: InternerTransport, anfrage: CreditNoteRequest): Promise<CreditNoteResult>;
+export declare function getInvoice(rufen: InternerTransport, kennung: {
+    invoiceId: string;
+} | {
+    number: string;
+}): Promise<InvoiceDetail>;
+export declare function listInvoices(rufen: InternerTransport, abfrage?: InvoiceListQuery): Promise<InvoicePage>;
+/** Das PDF der Rechnung (bei Gutschriften: der Gutschrift), mit eingebetteter Factur-X-Datei. */
+export declare function getInvoicePdf(rufenBinaer: InternerBinaerTransport, invoiceId: string): Promise<Uint8Array>;
+/**
+ * Die E-Rechnung als XML-Text. Sie kommt im gewohnten Umschlag (`data.xml`)
+ * und nicht als rohe Datei: so bleibt ein fachlicher Fehler
+ * (`einvoice_incomplete` mit `missing[]`) ein gewoehnlicher Fehler.
+ */
+export declare function getInvoiceXml(rufen: InternerTransport, invoiceId: string, format?: EInvoiceFormat): Promise<string>;