@thermal-label/brother-ql-core 0.0.1 → 0.3.0

package/src/media.ts

@@ -1,13 +1,34 @@
-import { type MediaDescriptor, type MediaType } from './types.js';
+import type { BrotherQLMedia, MediaType } from './types.js';
 
-export const MEDIA: Record<number, MediaDescriptor> = {
+/**
+ * Registry of supported Brother QL consumables.
+ *
+ * Entries are keyed by the firmware media id — the same number the
+ * printer reports in the 32-byte status response. `heightMm` is omitted
+ * for continuous media (variable length) and set for die-cut labels
+ * (fixed length).
+ *
+ * `palette` is set on multi-ink media (DK-22251, today's only entry) —
+ * the driver routes those through `renderMultiPlaneImage` and emits the
+ * second plane in the raster job. Single-ink rolls leave it undefined
+ * and route through `renderImage` (dithered single-plane).
+ *
+ * Rectangular die-cut entries declare `defaultOrientation: 'horizontal'`
+ * so landscape input auto-rotates to read along the tape feed direction.
+ * Continuous wide tape leaves the hint undefined — users may go either
+ * way.
+ *
+ * `cornerRadiusMm` is informational; previews use it to render the
+ * actual paper outline. Round die-cut labels set the radius to
+ * `widthMm / 2` so the rounded rectangle degenerates to a circle.
+ */
+export const MEDIA: Record<number, BrotherQLMedia> = {
   // Continuous length tape
   257: {
     id: 257,
     name: '12mm continuous',
     type: 'continuous',
     widthMm: 12,
-    lengthMm: 0,
     printAreaDots: 106,
     leftMarginPins: 585,
     rightMarginPins: 29,
@@ -17,7 +38,6 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '29mm continuous (DK-22210)',
     type: 'continuous',
     widthMm: 29,
-    lengthMm: 0,
     printAreaDots: 306,
     leftMarginPins: 408,
     rightMarginPins: 6,
@@ -27,7 +47,6 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '38mm continuous (DK-22225)',
     type: 'continuous',
     widthMm: 38,
-    lengthMm: 0,
     printAreaDots: 413,
     leftMarginPins: 295,
     rightMarginPins: 12,
@@ -37,7 +56,6 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '50mm continuous (DK-22246)',
     type: 'continuous',
     widthMm: 50,
-    lengthMm: 0,
     printAreaDots: 554,
     leftMarginPins: 154,
     rightMarginPins: 12,
@@ -47,7 +65,6 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '54mm continuous (DK-22214)',
     type: 'continuous',
     widthMm: 54,
-    lengthMm: 0,
     printAreaDots: 590,
     leftMarginPins: 130,
     rightMarginPins: 0,
@@ -57,7 +74,6 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '62mm continuous (DK-22205)',
     type: 'continuous',
     widthMm: 62,
-    lengthMm: 0,
     printAreaDots: 696,
     leftMarginPins: 12,
     rightMarginPins: 12,
@@ -67,18 +83,19 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '62mm continuous two-color (DK-22251)',
     type: 'continuous',
     widthMm: 62,
-    lengthMm: 0,
+    palette: [
+      { name: 'black', rgb: [0, 0, 0] },
+      { name: 'red', rgb: [255, 0, 0] },
+    ],
     printAreaDots: 696,
     leftMarginPins: 12,
     rightMarginPins: 12,
-    twoColorTape: true,
   },
   260: {
     id: 260,
     name: '102mm continuous (DK-22243)',
     type: 'continuous',
     widthMm: 102,
-    lengthMm: 0,
     printAreaDots: 1164,
     leftMarginPins: 76,
     rightMarginPins: 56,
@@ -90,7 +107,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '17×54mm die-cut (DK-11204)',
     type: 'die-cut',
     widthMm: 17,
-    lengthMm: 54,
+    heightMm: 54,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 165,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -101,7 +120,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '17×87mm die-cut (DK-11203)',
     type: 'die-cut',
     widthMm: 17,
-    lengthMm: 87,
+    heightMm: 87,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 165,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -112,7 +133,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '23×23mm die-cut',
     type: 'die-cut',
     widthMm: 23,
-    lengthMm: 23,
+    heightMm: 23,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 236,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -123,7 +146,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '29×90mm die-cut (DK-11201)',
     type: 'die-cut',
     widthMm: 29,
-    lengthMm: 90,
+    heightMm: 90,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 306,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -134,7 +159,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '38×90mm die-cut (DK-11218)',
     type: 'die-cut',
     widthMm: 38,
-    lengthMm: 90,
+    heightMm: 90,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 413,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -145,7 +172,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '39×48mm die-cut (DK-11219)',
     type: 'die-cut',
     widthMm: 39,
-    lengthMm: 48,
+    heightMm: 48,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 425,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -156,7 +185,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '52×29mm die-cut',
     type: 'die-cut',
     widthMm: 52,
-    lengthMm: 29,
+    heightMm: 29,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 578,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -167,7 +198,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '62×29mm die-cut (DK-11209)',
     type: 'die-cut',
     widthMm: 62,
-    lengthMm: 29,
+    heightMm: 29,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 696,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -178,7 +211,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '62×100mm die-cut (DK-11202)',
     type: 'die-cut',
     widthMm: 62,
-    lengthMm: 100,
+    heightMm: 100,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 696,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -189,7 +224,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '102×51mm die-cut (DK-11240)',
     type: 'die-cut',
     widthMm: 102,
-    lengthMm: 51,
+    heightMm: 51,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 1164,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -200,7 +237,9 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '102×152mm die-cut (DK-11241)',
     type: 'die-cut',
     widthMm: 102,
-    lengthMm: 152,
+    heightMm: 152,
+    defaultOrientation: 'horizontal',
+    cornerRadiusMm: 3,
     printAreaDots: 1164,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -211,7 +250,8 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '12mm Ø die-cut',
     type: 'die-cut',
     widthMm: 12,
-    lengthMm: 12,
+    heightMm: 12,
+    cornerRadiusMm: 6,
     printAreaDots: 94,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -222,7 +262,8 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '24mm Ø die-cut (DK-11221)',
     type: 'die-cut',
     widthMm: 24,
-    lengthMm: 24,
+    heightMm: 24,
+    cornerRadiusMm: 12,
     printAreaDots: 236,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -233,7 +274,8 @@ export const MEDIA: Record<number, MediaDescriptor> = {
     name: '58mm Ø die-cut (DK-11207)',
     type: 'die-cut',
     widthMm: 58,
-    lengthMm: 58,
+    heightMm: 58,
+    cornerRadiusMm: 29,
     printAreaDots: 618,
     leftMarginPins: 0,
     rightMarginPins: 0,
@@ -241,10 +283,46 @@ export const MEDIA: Record<number, MediaDescriptor> = {
   },
 };
 
-export function findMedia(id: number): MediaDescriptor | undefined {
+/**
+ * Default media when `createPreview()` is called without media and
+ * without a detected roll. 62mm continuous (DK-22205) is the common
+ * single-colour shipping roll.
+ */
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DK-22205 is a hard-coded registry key
+export const DEFAULT_MEDIA: BrotherQLMedia = MEDIA[259]!;
+
+export function findMedia(id: number): BrotherQLMedia | undefined {
   return MEDIA[id];
 }
 
-export function findMediaByWidth(widthMm: number, type: MediaType): MediaDescriptor[] {
+export function findMediaByWidth(widthMm: number, type: MediaType): BrotherQLMedia[] {
   return Object.values(MEDIA).filter(m => m.widthMm === widthMm && m.type === type);
 }
+
+/**
+ * Match status-response dimensions to a media registry entry.
+ *
+ * @param widthMm     media width in mm (status byte 10)
+ * @param heightMm    media length in mm (status byte 17) — 0 = continuous
+ * @param twoColorMode true when the status response indicates the
+ *                     printer is configured for two-colour media. When
+ *                     both DK-22205 (259) and DK-22251 (251) match the
+ *                     dimensions, the flag picks the right one.
+ */
+export function findMediaByDimensions(
+  widthMm: number,
+  heightMm: number,
+  twoColorMode = false,
+): BrotherQLMedia | undefined {
+  if (heightMm === 0) {
+    const continuousMatches = Object.values(MEDIA).filter(
+      m => m.type === 'continuous' && m.widthMm === widthMm,
+    );
+    if (continuousMatches.length === 0) return undefined;
+    const preferred = continuousMatches.find(m => (m.palette !== undefined) === twoColorMode);
+    return preferred ?? continuousMatches[0];
+  }
+  return Object.values(MEDIA).find(
+    m => m.type === 'die-cut' && m.widthMm === widthMm && m.heightMm === heightMm,
+  );
+}

package/src/orientation.ts

@@ -0,0 +1,11 @@
+import type { RotateDirection } from '@thermal-label/contracts';
+
+/**
+ * Direction the Brother QL print head rotates landscape input.
+ *
+ * `90` = clockwise. Verified once on hardware with a die-cut "F"
+ * landscape print (see plan §6 step 1). Identical across every QL
+ * model — this is a print-head/leading-edge mechanical fact, not a
+ * per-media setting.
+ */
+export const ROTATE_DIRECTION: RotateDirection = 90;

package/src/pack-bits.ts

@@ -0,0 +1,64 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion --
+ *   `noUncheckedIndexedAccess` types Uint8Array reads as `number | undefined`
+ *   but every index in this file is bounded by `i < input.length` or
+ *   `runEnd < input.length` checks. The `!` assertions collapse the
+ *   unreachable `undefined` branches so branch coverage doesn't count them.
+ */
+
+/**
+ * TIFF-style PackBits row encoder used by Brother QL when compression
+ * mode (`M 02`, emitted by `buildCompression(true)`) is enabled for a job.
+ *
+ * Header byte `n` (interpreted as a signed int8):
+ *   n in [0, 127]:    literal run — the next `n + 1` bytes follow verbatim.
+ *   n in [-127, -1]:  repeat run — the next byte is repeated `1 - n` times.
+ *   n = -128:         no-op. Unused by this encoder.
+ *
+ * The encoder switches to repeat mode for runs of two or more identical
+ * bytes (a 2-byte repeat costs 2 wire bytes; the equivalent 2-byte literal
+ * would cost 3). Both run kinds are capped at 128 bytes to fit the header.
+ *
+ * For a typical Brother QL raster row (90 bytes, mostly zeros in margins
+ * and long runs of `0x00` / `0xff` in print area), this compresses to 5–15
+ * bytes — a 6–18× reduction. Worst-case for highly random input is one
+ * extra byte per 128 (the literal-mode header), i.e. < 1 % expansion.
+ */
+export function packBits(input: Uint8Array): Uint8Array {
+  if (input.length === 0) return new Uint8Array(0);
+
+  const out: number[] = [];
+  let i = 0;
+
+  while (i < input.length) {
+    // How many identical bytes start at position i (cap at 128).
+    let runEnd = i + 1;
+    while (runEnd < input.length && runEnd - i < 128 && input[runEnd] === input[i]) {
+      runEnd++;
+    }
+    const runLen = runEnd - i;
+
+    if (runLen >= 2) {
+      // Repeat run: header is signed -(runLen - 1).
+      out.push((1 - runLen) & 0xff);
+      out.push(input[i]!);
+      i = runEnd;
+      continue;
+    }
+
+    // Otherwise emit a literal run. Stop at 128 bytes, or right before a
+    // 2+ repeat run starts (cheaper to encode that separately).
+    let litEnd = i + 1;
+    while (litEnd < input.length && litEnd - i < 128) {
+      if (litEnd + 1 < input.length && input[litEnd] === input[litEnd + 1]) {
+        break;
+      }
+      litEnd++;
+    }
+    const litLen = litEnd - i;
+    out.push(litLen - 1);
+    for (let x = i; x < litEnd; x++) out.push(input[x]!);
+    i = litEnd;
+  }
+
+  return new Uint8Array(out);
+}

package/src/preview.ts

@@ -0,0 +1,35 @@
+import { renderImage, renderMultiPlaneImage } from '@mbtech-nl/bitmap';
+import type { LabelBitmap, RawImageData } from '@mbtech-nl/bitmap';
+import type { PreviewResult } from '@thermal-label/contracts';
+import type { BrotherQLMedia } from './types.js';
+
+/**
+ * Offline preview without a live printer connection.
+ *
+ * Multi-ink aware: when `media.palette` is defined (DK-22251 today),
+ * the image is split per-plane via `renderMultiPlaneImage()` — the
+ * same code path `print()` takes for that media. Single-ink media
+ * returns one black plane via dithered `renderImage`.
+ */
+export function createPreviewOffline(image: RawImageData, media: BrotherQLMedia): PreviewResult {
+  if (media.palette) {
+    const planes = renderMultiPlaneImage(image, {
+      palette: media.palette,
+    }) as Record<'black' | 'red', LabelBitmap>;
+    return {
+      planes: [
+        { name: 'black', bitmap: planes.black, displayColor: '#000000' },
+        { name: 'red', bitmap: planes.red, displayColor: '#ff0000' },
+      ],
+      media,
+      assumed: false,
+    };
+  }
+
+  const bitmap = renderImage(image, { dither: true });
+  return {
+    planes: [{ name: 'black', bitmap, displayColor: '#000000' }],
+    media,
+    assumed: false,
+  };
+}

package/src/protocol.ts

@@ -1,5 +1,6 @@
 import { getRow, createBitmap } from '@mbtech-nl/bitmap';
-import { type MediaDescriptor, type PageData, type JobOptions, type PageOptions } from './types.js';
+import { packBits } from './pack-bits.js';
+import type { BrotherQLMedia, PageData, JobOptions, PageOptions } from './types.js';
 
 export function buildInvalidate(): Uint8Array {
   return new Uint8Array(200);
@@ -22,7 +23,7 @@ export function buildStatusNotification(enabled: boolean): Uint8Array {
 }
 
 export function buildPrintInfo(
-  media: MediaDescriptor,
+  media: BrotherQLMedia,
   rowCount: number,
   pageIndex: number,
 ): Uint8Array {
@@ -38,7 +39,7 @@ export function buildPrintInfo(
   buf[3] = validFlags;
   buf[4] = mediaType;
   buf[5] = media.widthMm;
-  buf[6] = media.lengthMm;
+  buf[6] = media.heightMm ?? 0;
   // rowCount little-endian at bytes 7-8 (offsets 4-5 in param block)
   buf[7] = rowCount & 0xff;
   buf[8] = (rowCount >> 8) & 0xff;
@@ -161,12 +162,12 @@ export function encodeJob(pages: PageData[], options: JobOptions = {}): Uint8Arr
     const compress = opts.compress ?? false;
     const { bitmap, media } = page;
 
-    // twoColorTape media (e.g. DK-22251) requires two-color mode even for black-only jobs.
+    // Multi-ink media (e.g. DK-22251) requires two-color mode even for black-only jobs.
     // Auto-create an empty red plane when the tape demands it but caller didn't supply one.
-    const twoColor = page.redBitmap !== undefined || media.twoColorTape === true;
+    const multiInk = media.palette !== undefined;
+    const twoColor = page.redBitmap !== undefined || multiInk;
     const redBitmap =
-      page.redBitmap ??
-      (media.twoColorTape ? createBitmap(bitmap.widthPx, bitmap.heightPx) : undefined);
+      page.redBitmap ?? (multiInk ? createBitmap(bitmap.widthPx, bitmap.heightPx) : undefined);
 
     if (twoColor && redBitmap !== undefined) {
       if (bitmap.widthPx !== redBitmap.widthPx || bitmap.heightPx !== redBitmap.heightPx) {
@@ -192,17 +193,23 @@ export function encodeJob(pages: PageData[], options: JobOptions = {}): Uint8Arr
 
     // Rows interleaved per raster line (matches Python brother_ql behaviour).
     // Two-color: black row then red row for each line. Single-color: black only.
+    // When `compress` is on, each row's bytes are PackBits-encoded and the
+    // raster-row LEN byte carries the compressed length. The printer was
+    // already switched into compression mode by `buildCompression(true)`
+    // above, so it expects every subsequent row to be PackBits.
     for (let r = 0; r < rowCount; r++) {
       const blackSrc = getRow(bitmap, r);
       const blackBytes = new Uint8Array(rowByteLen);
       placeBits(blackSrc, bitmap.widthPx, blackBytes, media.leftMarginPins);
-      chunks.push(buildRasterRow(blackBytes, 'black', twoColor));
+      const blackPayload = compress ? packBits(blackBytes) : blackBytes;
+      chunks.push(buildRasterRow(blackPayload, 'black', twoColor));
 
       if (twoColor && redBitmap !== undefined) {
         const redSrc = getRow(redBitmap, r);
         const redBytes = new Uint8Array(rowByteLen);
         placeBits(redSrc, redBitmap.widthPx, redBytes, media.leftMarginPins);
-        chunks.push(buildRasterRow(redBytes, 'red', twoColor));
+        const redPayload = compress ? packBits(redBytes) : redBytes;
+        chunks.push(buildRasterRow(redPayload, 'red', twoColor));
       }
     }
 

package/src/status.ts

@@ -1,67 +1,82 @@
-import { type PrinterStatus, type MediaType } from './types.js';
+import type { PrinterError } from '@thermal-label/contracts';
+import type { BrotherQLStatus } from './types.js';
+import { findMediaByDimensions } from './media.js';
 
-const ERROR_INFO_1: Record<number, string> = {
-  0: 'No media',
-  1: 'End of media',
-  2: 'Cutter jam',
-  3: 'Weak battery',
-  4: 'Printer in use',
-  6: 'High voltage adapter',
-  7: 'Fan motor error',
-};
+export const STATUS_REQUEST = new Uint8Array([0x1b, 0x69, 0x53]);
+
+/** Error-info 1 bit → structured PrinterError code + human message. */
+const ERROR_INFO_1: { bit: number; code: string; message: string }[] = [
+  { bit: 0, code: 'no_media', message: 'No media' },
+  { bit: 1, code: 'media_end', message: 'End of media' },
+  { bit: 2, code: 'cutter_jam', message: 'Cutter jam' },
+  { bit: 3, code: 'system_error', message: 'Weak battery' },
+  { bit: 4, code: 'not_ready', message: 'Printer in use' },
+  { bit: 6, code: 'system_error', message: 'High voltage adapter' },
+  { bit: 7, code: 'system_error', message: 'Fan motor error' },
+];
 
-const ERROR_INFO_2: Record<number, string> = {
-  0: 'Replace media',
-  1: 'Expansion buffer full',
-  2: 'Transmission error',
-  3: 'Communication buffer full',
-  4: 'Cover open',
-  5: 'Cancel key',
-  6: 'Media cannot be fed',
-  7: 'System error',
-};
+/** Error-info 2 bit → structured PrinterError code + human message. */
+const ERROR_INFO_2: { bit: number; code: string; message: string }[] = [
+  { bit: 0, code: 'wrong_media', message: 'Replace media' },
+  { bit: 1, code: 'system_error', message: 'Expansion buffer full' },
+  { bit: 2, code: 'system_error', message: 'Transmission error' },
+  { bit: 3, code: 'system_error', message: 'Communication buffer full' },
+  { bit: 4, code: 'cover_open', message: 'Cover open' },
+  { bit: 5, code: 'not_ready', message: 'Cancel key pressed' },
+  { bit: 6, code: 'media_end', message: 'Media cannot be fed' },
+  { bit: 7, code: 'system_error', message: 'System error' },
+];
 
-export function parseStatus(bytes: Uint8Array): PrinterStatus {
-  if (bytes.length < 32)
+/**
+ * Parse a Brother QL 32-byte status response.
+ *
+ * Fields:
+ *   byte 8  — error info 1 (bit mask, see ERROR_INFO_1)
+ *   byte 9  — error info 2 (bit mask, see ERROR_INFO_2)
+ *   byte 10 — media width (mm)
+ *   byte 11 — media type (0x0A continuous, 0x0B die-cut)
+ *   byte 17 — media length (mm), 0 for continuous
+ *   byte 18 — status type (0x02 = error response)
+ *
+ * `detectedMedia` is resolved against the media registry via
+ * `findMediaByDimensions`. `editorLiteMode` is a driver-specific
+ * extension on `BrotherQLStatus` — the status-type byte doesn't
+ * actually report it, but keeping the field here means callers can
+ * set it from other signals (e.g. mass-storage PID detected during
+ * discovery) without changing the return type.
+ */
+export function parseStatus(bytes: Uint8Array): BrotherQLStatus {
+  if (bytes.length < 32) {
     throw new Error(`Status response too short: ${bytes.length.toString()} bytes`);
+  }
 
-  // noUncheckedIndexedAccess forces `?? 0` fallbacks that are unreachable after
-  // the length check above. DataView avoids the issue: getUint8 returns number.
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-
-  const errors: string[] = [];
   const errInfo1 = view.getUint8(8);
   const errInfo2 = view.getUint8(9);
-
-  for (const [bitStr, msg] of Object.entries(ERROR_INFO_1)) {
-    if (errInfo1 & (1 << Number(bitStr))) errors.push(msg);
-  }
-  for (const [bitStr, msg] of Object.entries(ERROR_INFO_2)) {
-    if (errInfo2 & (1 << Number(bitStr))) errors.push(msg);
-  }
-
   const mediaWidthMm = view.getUint8(10);
   const mediaTypeByte = view.getUint8(11);
   const mediaLengthMm = view.getUint8(17);
+  const statusType = view.getUint8(18);
 
-  let mediaType: MediaType | null = null;
-  if (mediaTypeByte === 0x0a) mediaType = 'continuous';
-  else if (mediaTypeByte === 0x0b) mediaType = 'die-cut';
+  const errors: PrinterError[] = [];
+  for (const { bit, code, message } of ERROR_INFO_1) {
+    if (errInfo1 & (1 << bit)) errors.push({ code, message });
+  }
+  for (const { bit, code, message } of ERROR_INFO_2) {
+    if (errInfo2 & (1 << bit)) errors.push({ code, message });
+  }
 
-  // Status type is at byte 18, not 14. Byte 14 is an undocumented media-type
-  // code that carries non-zero values and is not the status type field.
-  const statusType = view.getUint8(18);
-  const ready = errors.length === 0 && statusType !== 0x02;
+  const mediaLoaded = mediaWidthMm > 0 && mediaTypeByte !== 0;
+  const detected = mediaLoaded
+    ? findMediaByDimensions(mediaWidthMm, mediaLengthMm, false)
+    : undefined;
 
   return {
-    ready,
-    mediaWidthMm,
-    mediaLengthMm,
-    mediaType,
+    ready: errors.length === 0 && statusType !== 0x02,
+    mediaLoaded,
+    ...(detected === undefined ? {} : { detectedMedia: detected }),
     errors,
     editorLiteMode: false,
     rawBytes: bytes,
   };
 }
-
-export const STATUS_REQUEST = new Uint8Array([0x1b, 0x69, 0x53]);