@kreiseck/kasseneck-api 0.31.0 → 1.0.0-rc.2

package/dist/esm/receipt/grid.js

@@ -1,4 +1,4 @@
-import { wortzeilenText } from '../printing/escpos.js';
+import { wrapText } from '../printing/escpos.js';
 /**
  * Zeichenraster: der Beleg als Zeilen mit **exakt N Zeichen** -- die einzige
  * Wahrheit fuer Bildschirm, Bondruck und PDF. Kein Ausgabeweg rechnet
@@ -10,7 +10,7 @@ import { wortzeilenText } from '../printing/escpos.js';
  *   letzte Spalte, jede mindestens 1. Zwischen zwei Spalten steht immer
  *   mindestens ein Leerzeichen (letztes Zeichen jeder nicht-letzten Spalte).
  *   Die letzte Spalte endet buendig am rechten Rand.
- * - Text/Aufdruck/Spalteninhalt bricht **wortweise** um (`wortzeilenText`,
+ * - Text/Aufdruck/Spalteninhalt bricht **wortweise** um (`wrapText`,
  *   dieselbe Regel wie der ESC/POS-Kern); ueberlange Woerter nach einem
  *   Bindestrich, sonst hart; geschuetztes Leerzeichen bricht nie.
  * - Fliessregel: laeuft in einer Spaltenzeile nur eine Spalte ueber die erste
@@ -19,14 +19,14 @@ import { wortzeilenText } from '../printing/escpos.js';
  * - Trennlinie ueber die volle Breite, Leerraum als Leerzeilen, QR als eigene
  *   Zeile mit Nutzlast (der Zeichner setzt das Bild).
  */
-export const ZEICHEN_JE_PAPIER = { mm58: 32, mm80: 48 };
+export const CHARS_PER_PAPER_SIZE = { mm58: 32, mm80: 48 };
 /** Zwoelftel -> Zeichen je Spalte (ganze Zeichen, Rest an die letzte, mindestens 1). */
-export function gridSpaltenBreiten(zwoelftel, zeichen) {
+export function gridColumnWidths(twelfths, chars) {
     const out = [];
     let vergeben = 0;
-    zwoelftel.forEach((w, i) => {
-        const letzte = i === zwoelftel.length - 1;
-        const b = letzte ? Math.max(1, zeichen - vergeben) : Math.max(1, Math.floor((zeichen * w) / 12));
+    twelfths.forEach((w, i) => {
+        const letzte = i === twelfths.length - 1;
+        const b = letzte ? Math.max(1, chars - vergeben) : Math.max(1, Math.floor((chars * w) / 12));
         out.push(b);
         vergeben += b;
     });
@@ -52,13 +52,13 @@ function restNach(text, erste) {
     return text.slice(i);
 }
 export function renderReceiptGrid(layout, options = {}) {
-    const zeichen = Math.max(8, Math.floor(options.zeichen ?? ZEICHEN_JE_PAPIER[layout.paperSize] ?? 32));
+    const zeichen = Math.max(8, Math.floor(options.charsPerLine ?? CHARS_PER_PAPER_SIZE[layout.paperSize] ?? 32));
     const leer = ' '.repeat(zeichen);
     const lines = [];
     for (const z of layout.lines) {
         switch (z.kind) {
             case 'text':
-                for (const t of wortzeilenText(z.text, zeichen))
+                for (const t of wrapText(z.text, zeichen))
                     lines.push({ text: ausrichten(t, zeichen, z.align), kind: 'text', bold: z.bold });
                 break;
             case 'banner': {
@@ -67,10 +67,10 @@ export function renderReceiptGrid(layout, options = {}) {
                 // 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 });
+                lines.push({ text: rahmen, kind: 'banner', bold: true, tone: z.tone });
+                for (const t of wrapText(z.text, zeichen))
+                    lines.push({ text: ausrichten(t, zeichen, 'center'), kind: 'banner', bold: true, tone: z.tone });
+                lines.push({ text: rahmen, kind: 'banner', bold: true, tone: z.tone });
                 break;
             }
             case 'rule':
@@ -84,10 +84,10 @@ export function renderReceiptGrid(layout, options = {}) {
                 lines.push({ text: ausrichten(QR_PLATZHALTER, zeichen, 'center'), kind: 'qr', bold: false, qr: z.data });
                 break;
             case 'columns': {
-                const breiten = gridSpaltenBreiten(z.columns.map((c) => c.width), zeichen);
+                const breiten = gridColumnWidths(z.columns.map((c) => c.width), zeichen);
                 // Inhalt jeder nicht-letzten Spalte um 1 Zeichen schmaler: garantierter Abstand.
                 const inhalt = breiten.map((b, i) => (i < breiten.length - 1 ? Math.max(1, b - 1) : b));
-                const teile = z.columns.map((c, i) => wortzeilenText(c.text, inhalt[i]));
+                const teile = z.columns.map((c, i) => wrapText(c.text, inhalt[i]));
                 // Fliessregel: laeuft nach der ersten Zeile nur noch EINE Spalte weiter (die anderen sind
                 // fertig), bekommt ihr Rest die volle Breite -- auf 58 mm sonst 18-Zeichen-Schnipsel.
                 // Laufen mehrere weiter, bleibt das Raster (sonst verschoeben sich die Nachbarn).
@@ -107,7 +107,7 @@ export function renderReceiptGrid(layout, options = {}) {
                     // Rest aus dem Originaltext (nicht aus den schmal umbrochenen Stuecken), damit
                     // Bindestrich-/Hartbrueche der schmalen Spalte nicht als Leerzeichen zurueckbleiben.
                     const rest = restNach(z.columns[i].text, teile[i][0]);
-                    for (const t of wortzeilenText(rest, zeichen))
+                    for (const t of wrapText(rest, zeichen))
                         lines.push({ text: ausrichten(t, zeichen, z.columns[i].align), kind: 'columns', bold: false });
                 }
                 break;
@@ -116,9 +116,9 @@ export function renderReceiptGrid(layout, options = {}) {
                 break;
         }
     }
-    return { lines, zeichen };
+    return { lines, charsPerLine: zeichen };
 }
 /** Klartext (eine Zeile je Rasterzeile) -- fuer Golden-Dateien und Logs. QR als Platzhalter. */
-export function gridAlsText(grid) {
+export function gridToText(grid) {
     return grid.lines.map((z) => z.text).join('\n');
 }

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

@@ -1,8 +1,9 @@
-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, 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, 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, papierFuerZeichen, logoMass, logoPixelZulaessig, logoRasterMass, qrBlattAnteil, belegBlatt, } from './blatt.js';
-export { logoRaster } from './bild.js';
-export { type MarkeRasterDaten, MARKE_RASTER, MARKE_PFADE } from './marke-daten.js';
-export { markeBild } from './marke.js';
+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, CURRENT_LAYOUT_RULESET, type LayoutBannerLine, type LayoutBannerTone, type LayoutRuleset, SMALL_BUSINESS_NOTICE, formatCents, } from './layout.js';
+export { type EscPosLayoutOptions, type EscPosLayoutResult, type QrPrintMode, type PrintLogo, assertLogoRaster, escPosLayoutBytes, escPosLayoutResult, } from './layout-escpos.js';
+export { type GridLine, type GridLineKind, type ReceiptGrid, type RenderReceiptGridOptions, renderReceiptGrid, gridColumnWidths, gridToText, CHARS_PER_PAPER_SIZE, } from './grid.js';
+export { type EposPrintXmlOptions, type EposPrintResult, type EposDirectOptions, type EposResponse, EposConnectionError, eposPrintXml, eposPrintXmlResult, eposXmlEscape, eposImageXml, eposServiceUrl, eposSoapEnvelope, eposParseResponse, eposDirectPrint, eposDirectStatus } from './epos.js';
+export { type SheetLogoSize, type SheetLogo, type LogoDimensions, type SheetBlock, type ReceiptSheet, type ReceiptSheetOptions, SHEET_LOGO_SIZES, LOGO_MAX_PIXELS, DOTS_PER_CHAR, DOTS_PER_LINE, paperSizeForChars, logoDimensions, isLogoPixelSizeAllowed, logoRasterSize, qrSheetWidthFraction, receiptSheet, } from './blatt.js';
+export { rasterizeLogo } from './bild.js';
+export { type BrandMarkRaster, BRAND_MARK_RASTERS, BRAND_MARK_PATHS } from './marke-daten.js';
+export { brandMarkImage } from './marke.js';
+export { type ReceiptDueTip, type ReceiptDueTipRecipient, type ReceiptDueOptions, type ReceiptDueBuckets, type ReceiptDueBreakdown, receiptDueCents, receiptDueBreakdown, } from './due.js';

package/dist/esm/receipt/index.js

@@ -1,8 +1,9 @@
-export { buildReceiptLayout, receiptSignatureFailed, receiptSignatureIsTest, receiptIsZero, receiptAmountsAreZero, receiptIsSmallBusinessConsistent, receiptZdaText, AKTUELLES_REGELWERK, SMALL_BUSINESS_NOTICE, formatCents, } from './layout.js';
-export { pruefeLogoRaster, escPosLayoutBytes, escPosLayoutErgebnis, } from './layout-escpos.js';
-export { renderReceiptGrid, gridSpaltenBreiten, gridAlsText, ZEICHEN_JE_PAPIER, } from './grid.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, papierFuerZeichen, logoMass, logoPixelZulaessig, logoRasterMass, qrBlattAnteil, belegBlatt, } from './blatt.js';
-export { logoRaster } from './bild.js';
-export { MARKE_RASTER, MARKE_PFADE } from './marke-daten.js';
-export { markeBild } from './marke.js';
+export { buildReceiptLayout, receiptSignatureFailed, receiptSignatureIsTest, receiptIsZero, receiptAmountsAreZero, receiptIsSmallBusinessConsistent, receiptZdaText, CURRENT_LAYOUT_RULESET, SMALL_BUSINESS_NOTICE, formatCents, } from './layout.js';
+export { assertLogoRaster, escPosLayoutBytes, escPosLayoutResult, } from './layout-escpos.js';
+export { renderReceiptGrid, gridColumnWidths, gridToText, CHARS_PER_PAPER_SIZE, } from './grid.js';
+export { EposConnectionError, eposPrintXml, eposPrintXmlResult, eposXmlEscape, eposImageXml, eposServiceUrl, eposSoapEnvelope, eposParseResponse, eposDirectPrint, eposDirectStatus } from './epos.js';
+export { SHEET_LOGO_SIZES, LOGO_MAX_PIXELS, DOTS_PER_CHAR, DOTS_PER_LINE, paperSizeForChars, logoDimensions, isLogoPixelSizeAllowed, logoRasterSize, qrSheetWidthFraction, receiptSheet, } from './blatt.js';
+export { rasterizeLogo } from './bild.js';
+export { BRAND_MARK_RASTERS, BRAND_MARK_PATHS } from './marke-daten.js';
+export { brandMarkImage } from './marke.js';
+export { receiptDueCents, receiptDueBreakdown, } from './due.js';

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

@@ -1,6 +1,6 @@
-import { type PosCodeTable, type PosCutMode, type PosPaperSize, type QrCorrection, type QrMatrix, type QrModulGroesse, type QrSize, type RasterBild } from '../printing/index.js';
+import { type PosCodeTable, type PosCutMode, type PosPaperSize, type QrCorrection, type QrMatrix, type QrModuleSize, type QrSize, type RasterImage } from '../printing/index.js';
 import type { ReceiptLayout } from './layout.js';
-import { type BelegBlatt, type LogoStufe, type LogoMass } from './blatt.js';
+import { type ReceiptSheet, type SheetLogoSize, type LogoDimensions } from './blatt.js';
 /**
  * Bruecke vom Layout-Modell zu ESC/POS-Bytes — der Bondrucker-Ausgabeweg.
  *
@@ -29,18 +29,18 @@ import { type BelegBlatt, type LogoStufe, type LogoMass } from './blatt.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;
+/** Firmenlogo fuer den Druck: Stufe, Pixelmass des Originals und das fertige Rasterbild (`rasterizeLogo`). */
+export interface PrintLogo {
+    size: SheetLogoSize;
+    pixelWidth: number;
+    pixelHeight: number;
+    raster: RasterImage;
 }
 /** 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;
+export declare function assertLogoRaster(logo: PrintLogo, dimensions: LogoDimensions, chars: number): void;
 /**
  * Baut das Blatt fuer einen Druckweg (ESC/POS, ePOS) an EINER Stelle: die
- * Zuordnung `DruckLogo` -> `BlattLogo` und die Groessenpruefung des mitgebrachten
+ * Zuordnung `PrintLogo` -> `SheetLogo` 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
@@ -48,10 +48,10 @@ export declare function pruefeLogoRaster(logo: DruckLogo, mass: LogoMass, zeiche
  */
 export declare function blattFuerDruck(layout: ReceiptLayout, optionen: {
     zeichen: number;
-    logo?: DruckLogo | null;
+    logo?: PrintLogo | null;
     marke?: boolean;
-    qrGroesse: QrModulGroesse;
-}): BelegBlatt;
+    qrGroesse: QrModuleSize;
+}): ReceiptSheet;
 export interface EscPosLayoutOptions {
     /** Papierbreite; Vorgabe ist die des Layouts (dessen Spaltenbreiten daran haengen). */
     paperSize?: PosPaperSize;
@@ -67,9 +67,9 @@ export interface EscPosLayoutOptions {
     /** Fehlerkorrekturstufe des QR-Codes; Vorgabe `M` (wie ePOS, Bildweg und Blatt). */
     qrCorrection?: QrCorrection;
     /** Deckel fuer die gerechnete Modulgroesse; Vorgabe `auto` (hoechstens 6 Punkte je Modul). */
-    qrGroesse?: QrModulGroesse;
+    qrModuleSize?: QrModuleSize;
     /** Druckweg des QR; Vorgabe `native` (der Bestandsweg). */
-    qrModus?: QrPrintMode;
+    qrMode?: QrPrintMode;
     /**
      * Raster fuer den Bildweg — ohne das gibt es keinen Notausgang.
      *
@@ -77,24 +77,24 @@ export interface EscPosLayoutOptions {
      * Kopf von `layout.ts`); der Aufrufer bringt das fertige Raster mit, etwa
      * aus der QR-Bibliothek, die er ohnehin fuer den Bildschirm benutzt.
      */
-    qrMatrix?: (nutzlast: string) => QrMatrix;
+    qrMatrix?: (payload: string) => QrMatrix;
     /** Firmenlogo; ohne Angabe kein Logo (Bestand). */
-    logo?: DruckLogo | null;
+    logo?: PrintLogo | null;
     /** Das Kasseneck-Logo am Ende (Konto-Flag `kreiseck_logo`). */
-    marke?: boolean;
+    brandMark?: boolean;
 }
 /**
  * Der Bytestrom **samt** dem, was dem QR unterwegs zugestossen ist.
  *
- * Zwilling von `KeckPrintResult`: `qrFehler` heisst "Beleg ohne QR,
- * nachdrucken oder elektronisch ausgeben", `qrAusweich` heisst "gedruckt,
+ * Zwilling von `KeckPrintResult`: `qrError` heisst "Beleg ohne QR,
+ * nachdrucken oder elektronisch ausgeben", `qrFallback` heisst "gedruckt,
  * aber der eingestellte Weg taugt fuer dieses Geraet nicht" — das eine gehoert
  * dem Kunden gesagt, das andere dem Chef.
  */
-export interface EscPosLayoutErgebnis {
+export interface EscPosLayoutResult {
     bytes: Uint8Array;
-    qrFehler: string | null;
-    qrAusweich: string | null;
+    qrError: string | null;
+    qrFallback: string | null;
 }
 /**
  * Bytes fuer den Bondrucker -- **aus dem Zeichenraster** ([renderReceiptGrid]):
@@ -108,4 +108,4 @@ export declare function escPosLayoutBytes(layout: ReceiptLayout, options?: EscPo
  * zugestossen ist. Die Bytes sind dieselben; wer die Meldungen braucht, nimmt
  * diesen Weg.
  */
-export declare function escPosLayoutErgebnis(layout: ReceiptLayout, options?: EscPosLayoutOptions): EscPosLayoutErgebnis;
+export declare function escPosLayoutResult(layout: ReceiptLayout, options?: EscPosLayoutOptions): EscPosLayoutResult;

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

@@ -1,17 +1,17 @@
-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';
-import { markeBild } from './marke.js';
+import { createEscPosDocument, escPosBytes, escPosCut, escPosFeed, escPosPrintableText, escPosQrCode, escPosQrRaster, escPosRasterImage, escPosReset, escPosText, QR_PRINT_WIDTH_DOTS, qrSizingFor, qrFitsInVersion, } from '../printing/index.js';
+import { receiptSheet, logoRasterSize } from './blatt.js';
+import { CHARS_PER_PAPER_SIZE } from './grid.js';
+import { brandMarkImage } from './marke.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})`);
+export function assertLogoRaster(logo, dimensions, chars) {
+    const soll = logoRasterSize(dimensions, chars);
+    if (logo.raster.width !== soll.width || logo.raster.height !== soll.height) {
+        throw new Error(`Logo-Raster ${logo.raster.width}x${logo.raster.height} passt nicht zum Blatt (${soll.width}x${soll.height})`);
     }
 }
 /**
  * Baut das Blatt fuer einen Druckweg (ESC/POS, ePOS) an EINER Stelle: die
- * Zuordnung `DruckLogo` -> `BlattLogo` und die Groessenpruefung des mitgebrachten
+ * Zuordnung `PrintLogo` -> `SheetLogo` 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
@@ -19,16 +19,16 @@ export function pruefeLogoRaster(logo, mass, zeichen) {
  */
 export function blattFuerDruck(layout, optionen) {
     const blattOptionen = {
-        zeichen: optionen.zeichen,
-        marke: optionen.marke === true,
-        qrGroesse: optionen.qrGroesse,
+        charsPerLine: optionen.zeichen,
+        brandMark: optionen.marke === true,
+        qrModuleSize: 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);
+        blattOptionen.logo = { size: optionen.logo.size, pixelWidth: optionen.logo.pixelWidth, pixelHeight: optionen.logo.pixelHeight };
+    const blatt = receiptSheet(layout, blattOptionen);
+    const logoBlock = blatt.blocks.find((b) => b.kind === 'logo');
+    if (optionen.logo && logoBlock && logoBlock.kind === 'logo')
+        assertLogoRaster(optionen.logo, logoBlock, blatt.charsPerLine);
     return blatt;
 }
 /**
@@ -57,14 +57,14 @@ function druckbaresLayout(layout) {
  * zeigt, druckt der Drucker (Monospace, Font A: 32/48 Zeichen).
  */
 export function escPosLayoutBytes(layout, options = {}) {
-    return escPosLayoutErgebnis(layout, options).bytes;
+    return escPosLayoutResult(layout, options).bytes;
 }
 /**
  * Wie [escPosLayoutBytes], gibt aber zusaetzlich zurueck, was dem QR
  * zugestossen ist. Die Bytes sind dieselben; wer die Meldungen braucht, nimmt
  * diesen Weg.
  */
-export function escPosLayoutErgebnis(layout, options = {}) {
+export function escPosLayoutResult(layout, options = {}) {
     const paperSize = options.paperSize ?? layout.paperSize;
     const dokumentOptionen = { paperSize };
     if (options.codeTable !== undefined) {
@@ -72,38 +72,38 @@ export function escPosLayoutErgebnis(layout, options = {}) {
     }
     const doc = createEscPosDocument(dokumentOptionen);
     escPosReset(doc);
-    const modus = options.qrModus ?? 'native';
+    const modus = options.qrMode ?? 'native';
     const qrOptionen = { align: 'center' };
     if (options.qrSize !== undefined)
         qrOptionen.size = options.qrSize;
     if (options.qrCorrection !== undefined)
         qrOptionen.correction = options.qrCorrection;
-    if (options.qrGroesse !== undefined)
-        qrOptionen.groesse = options.qrGroesse;
+    if (options.qrModuleSize !== undefined)
+        qrOptionen.moduleSize = options.qrModuleSize;
     if (modus === 'nativeModel1')
-        qrOptionen.modell1 = true;
+        qrOptionen.model1 = true;
     if (modus === 'imageRaster' && options.qrMatrix === undefined) {
         throw new Error("qrModus 'imageRaster' braucht ein qrMatrix -- dieses Paket rastert nicht selbst");
     }
     const rasterOptionen = { align: 'center' };
-    if (options.qrGroesse !== undefined)
-        rasterOptionen.groesse = options.qrGroesse;
+    if (options.qrModuleSize !== undefined)
+        rasterOptionen.moduleSize = options.qrModuleSize;
     /**
      * Eine QR-Zeile des Rasters. Hier sitzt der **Notausgang**: passt das Symbol
      * nativ auch mit der Ausnahmegroesse nicht aufs Papier, druckt der Drucker
      * es GAR NICHT -- er schneidet nicht ab, er laesst weg. Ein Pflichtbeleg
      * ohne QR ist der schlechteste aller Ausgaenge, also geht der QR dann als
-     * Bild hinaus, und der Aufrufer erfaehrt es ueber `qrAusweich`.
+     * Bild hinaus, und der Aufrufer erfaehrt es ueber `qrFallback`.
      *
      * Ohne `qrMatrix` gibt es diesen Weg nicht -- dann bleibt nur die Meldung
-     * `qrFehler` aus `escPosQrCode`, und der Beleg geht ohne QR hinaus.
+     * `qrError` 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';
+        // hinaus und sagt es ueber `qrError`, wie das Blatt (Anteil 0).
+        if (nutzlast !== '' && !qrFitsInVersion(nutzlast)) {
+            doc.qrError = 'QR-Inhalt passt in keine QR-Version -- Beleg ohne QR';
             return;
         }
         const raster = options.qrMatrix;
@@ -115,15 +115,15 @@ export function escPosLayoutErgebnis(layout, options = {}) {
             // Feste `qrSize` heisst: der Aufrufer weiss, was er tut -- dann wird
             // weder gerechnet noch ausgewichen.
             if (options.qrSize === undefined) {
-                const mass = qrGroesseFuer({
-                    nutzlast,
-                    papierbreitePunkte: QR_DRUCK_PUNKTE[paperSize],
-                    groesse: options.qrGroesse ?? 'auto',
+                const mass = qrSizingFor({
+                    payload: nutzlast,
+                    paperWidthDots: QR_PRINT_WIDTH_DOTS[paperSize],
+                    moduleSize: options.qrModuleSize ?? 'auto',
                 });
-                if (!mass.passt) {
-                    doc.qrAusweich =
-                        `QR mit ${mass.module} Modulen passt nativ nicht auf ` +
-                            `${paperSize === 'mm58' ? 58 : 80} mm (${QR_DRUCK_PUNKTE[paperSize]} Punkte) ` +
+                if (!mass.fits) {
+                    doc.qrFallback =
+                        `QR mit ${mass.modules} Modulen passt nativ nicht auf ` +
+                            `${paperSize === 'mm58' ? 58 : 80} mm (${QR_PRINT_WIDTH_DOTS[paperSize]} Punkte) ` +
                             `-- als Bild gedruckt`;
                     escPosQrRaster(doc, raster(nutzlast), rasterOptionen);
                     return;
@@ -135,33 +135,33 @@ export function escPosLayoutErgebnis(layout, options = {}) {
     // `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],
+        zeichen: CHARS_PER_PAPER_SIZE[paperSize],
         logo: options.logo,
-        marke: options.marke,
-        qrGroesse: options.qrGroesse ?? 'auto',
+        marke: options.brandMark,
+        qrGroesse: options.qrModuleSize ?? 'auto',
     });
-    for (const block of blatt.bloecke) {
-        switch (block.art) {
+    for (const block of blatt.blocks) {
+        switch (block.kind) {
             case 'qr':
-                qrZeile(block.nutzlast);
+                qrZeile(block.payload);
                 break;
             case 'logo':
                 if (options.logo)
-                    escPosRasterBild(doc, options.logo.raster, { align: 'center' });
+                    escPosRasterImage(doc, options.logo.raster, { align: 'center' });
                 break;
-            case 'marke':
-                escPosRasterBild(doc, markeBild(paperSize), { align: 'center' });
+            case 'brandMark':
+                escPosRasterImage(doc, brandMarkImage(paperSize), { align: 'center' });
                 break;
-            case 'zeile':
-                if (block.leer)
+            case 'line':
+                if (block.blank)
                     escPosFeed(doc, 1);
                 else
-                    escPosText(doc, block.text.trimEnd(), { styles: { align: 'left', bold: block.fett } });
+                    escPosText(doc, block.text.trimEnd(), { styles: { align: 'left', bold: block.bold } });
                 break;
         }
     }
     if (options.cut !== false) {
         escPosCut(doc, options.cut === 'partial' ? 'partial' : 'full');
     }
-    return { bytes: escPosBytes(doc), qrFehler: doc.qrFehler, qrAusweich: doc.qrAusweich };
+    return { bytes: escPosBytes(doc), qrError: doc.qrError, qrFallback: doc.qrFallback };
 }

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

@@ -1,4 +1,4 @@
-import { type Receipt, type ReceiptCompany } from '../models/index.js';
+import { type Receipt, type ReceiptCompany, type RegistrationInfo } from '../models/index.js';
 import type { PosPaperSize } from '../printing/escpos.js';
 /**
  * Beleg-Layout — der Bauplan eines Kasseneck-Belegs als reines Datenmodell.
@@ -76,9 +76,14 @@ export interface LayoutQrLine {
 export interface LayoutBannerLine {
     kind: 'banner';
     text: string;
-    /** `warnung` fuer Testkasse/Testsignatur (nicht gueltiger Beleg), sonst `belegart`. */
-    ton: 'belegart' | 'warnung';
+    /**
+     * `warning` fuer Testkasse/Testsignatur (kein gueltiger Beleg), sonst
+     * `receipt_type` (Belegart). Werte wie am `/v3`-Draht (Katalog `LAYOUT_TON`).
+     */
+    tone: LayoutBannerTone;
 }
+/** Ton einer hervorgehobenen Zeile, wie am `/v3`-Draht. */
+export type LayoutBannerTone = 'receipt_type' | 'warning';
 export type LayoutLine = LayoutTextLine | LayoutColumnsLine | LayoutRuleLine | LayoutSpaceLine | LayoutQrLine | LayoutBannerLine;
 /**
  * Version des Layout-Regelwerks. Alte Belege werden mit ihrer gespeicherten
@@ -88,25 +93,15 @@ export type LayoutLine = LayoutTextLine | LayoutColumnsLine | LayoutRuleLine | L
  *   Signaturkarte, Zertifizierungsdienst, Registrierdaten); reduziert nur,
  *   wenn alle Betraege wirklich 0 sind. Vollbelege unveraendert.
  */
-export type LayoutRegelwerk = 1 | 2;
-export declare const AKTUELLES_REGELWERK: LayoutRegelwerk;
-/**
- * Registrierdaten fuer den Block „Prüfangaben“ auf Nullbelegen (Regelwerk 2).
- * Kennt sie nur das Backend (FinanzOnline-Registrierung der Signaturkarte und
- * der Kasse); fehlen sie, entfallen die Zeilen. Datum als „YYYY-MM-DD“ oder
- * ISO-Zeitstempel (Wiener Kalendertag).
- */
-export interface Pruefangaben {
-    karteRegistriertAm?: string | null;
-    kasseRegistriertAm?: string | null;
-}
+export type LayoutRuleset = 1 | 2;
+export declare const CURRENT_LAYOUT_RULESET: LayoutRuleset;
 /** Der fertige Bauplan eines Belegs. */
 export interface ReceiptLayout {
     lines: LayoutLine[];
     /** Papierbreite, nach der die Spaltenbreiten gewaehlt wurden. */
     paperSize: PosPaperSize;
     /** Regelwerk, nach dem gesetzt wurde. */
-    regelwerk: LayoutRegelwerk;
+    ruleset: LayoutRuleset;
 }
 export interface BuildReceiptLayoutOptions {
     /**
@@ -115,17 +110,27 @@ export interface BuildReceiptLayoutOptions {
      */
     paperSize?: PosPaperSize;
     /** Layout-Regelwerk (Vorgabe: aktuelles). Unbekannt -> Fehler, nie stumm anders setzen. */
-    regelwerk?: LayoutRegelwerk;
-    /** Beleg einer Testumgebung: Rahmen „TESTKASSE — kein gültiger Beleg“ oben und unten. */
-    testKasse?: boolean;
+    ruleset?: LayoutRuleset;
+    /**
+     * Beleg einer Testumgebung: Rahmen „TESTKASSE — kein gültiger Beleg“ oben
+     * und unten. Aus einer Antwort: `ReceiptWithCompany.testCashregister`.
+     */
+    testCashregister?: boolean;
     /**
      * Produktionskonto hat mit einer Test-Signatureinheit signiert: Rahmen
      * „TESTSIGNATUR — kein gültiger Beleg“. Der Aufrufer entscheidet (er kennt
-     * das Konto); [receiptSignatureIsTest] sagt nur, OB die Signatur eine Testsignatur ist.
+     * das Konto); [receiptSignatureIsTest] sagt nur, OB die Signatur eine
+     * Testsignatur ist. Aus einer Antwort: `ReceiptWithCompany.testSignature`.
+     */
+    testSignature?: boolean;
+    /**
+     * Registrierdaten fuer den Block „Prüfangaben“ (nur Nullbelege, Regelwerk 2).
+     * Kennt sie nur das Backend (FinanzOnline-Registrierung der Signaturkarte
+     * und der Kasse); fehlen sie, entfallen die Zeilen. Datum als „YYYY-MM-DD“
+     * oder ISO-Zeitstempel (Wiener Kalendertag). Aus einer Antwort:
+     * `ReceiptWithCompany.registrationInfo`.
      */
-    testSignatur?: boolean;
-    /** Registrierdaten fuer den Block „Prüfangaben“ (nur Nullbelege, Regelwerk 2). */
-    pruefangaben?: Pruefangaben | null;
+    registrationInfo?: RegistrationInfo | null;
 }
 /**
  * Cent-Betrag als Anzeigetext: `1234` -> `"12,34"`. Die **einzige** Stelle, an