@thermal-label/brother-ql-core 0.2.1 → 0.4.0

package/src/__tests__/preview.test.ts

@@ -32,7 +32,7 @@ describe('createPreviewOffline', () => {
     expect(preview.assumed).toBe(false);
   });
 
-  it('returns black + red planes for colorCapable media (DK-22251)', () => {
+  it('returns black + red planes for multi-ink media (DK-22251)', () => {
     const image = solidRgba(8, 8, [255, 0, 0, 255]);
     const preview = createPreviewOffline(image, MEDIA[251]!);
     expect(preview.planes.map(p => p.name)).toEqual(['black', 'red']);

package/src/__tests__/protocol.test.ts

@@ -13,8 +13,10 @@ import {
   buildVariousMode,
   buildExpandedMode,
   encodeJob,
+  encodeJobForEngine,
+  type EncoderEngine,
 } from '../protocol.js';
-import { type PageData } from '../types.js';
+import type { PageData } from '../types.js';
 import { MEDIA } from '../media.js';
 
 describe('buildInvalidate', () => {
@@ -170,6 +172,52 @@ describe('encodeJob', () => {
     }
     expect(found).toBe(true);
   });
+
+  it('compress option PackBits-encodes each raster row (LEN < uncompressed size)', () => {
+    // All-zero bitmap → every row is 90 zero bytes. PackBits collapses each
+    // row to 2 wire bytes (0xA7 0x00), so the LEN byte in the row header
+    // should be 2 instead of 90.
+    const page: PageData = { ...makePage(696, 3), options: { compress: true } };
+    const buf = encodeJob([page]);
+    // Find single-color row headers (0x67 0x00 LEN). With compression on,
+    // LEN should be 2 for each row, and the payload byte should be 0x00.
+    const rowHeaders: number[] = [];
+    for (let i = 0; i < buf.length - 4; i++) {
+      if (buf[i] === 0x67 && buf[i + 1] === 0x00) {
+        // Skip the byte sequence inside the 200-byte invalidate block
+        // (which is also all zeros, so 0x67 won't appear there). Heuristic:
+        // verify the next byte after LEN is the PackBits header 0xA7.
+        if (buf[i + 2] === 2 && buf[i + 3] === 0xa7 && buf[i + 4] === 0x00) {
+          rowHeaders.push(i);
+        }
+      }
+    }
+    expect(rowHeaders.length).toBe(3);
+  });
+
+  it('compress option two-color: both planes PackBits-encoded per row', () => {
+    const bitmap = createBitmap(696, 2);
+    const redBitmap = createBitmap(696, 2);
+    const page: PageData = {
+      bitmap,
+      redBitmap,
+      media: media62,
+      options: { compress: true },
+    };
+    const buf = encodeJob([page]);
+    const blackRows: number[] = [];
+    const redRows: number[] = [];
+    for (let i = 0; i < buf.length - 4; i++) {
+      // Each compressed row is [0x77 0x01|0x02 0x02 0xA7 0x00] for an empty
+      // 696-pin row (90 zero bytes → 2 PackBits bytes).
+      if (buf[i] === 0x77 && buf[i + 2] === 2 && buf[i + 3] === 0xa7 && buf[i + 4] === 0x00) {
+        if (buf[i + 1] === 0x01) blackRows.push(i);
+        if (buf[i + 1] === 0x02) redRows.push(i);
+      }
+    }
+    expect(blackRows.length).toBe(2);
+    expect(redRows.length).toBe(2);
+  });
 });
 
 describe('buildRasterMode', () => {
@@ -239,3 +287,210 @@ describe('buildCompression', () => {
     expect(Array.from(buildCompression(false))).toEqual([0x4d, 0x00]);
   });
 });
+
+describe('encodeJobForEngine — dispatch + invalidate-byte derivation', () => {
+  const TZE_12MM = MEDIA[404]!;
+  const DK_62MM = MEDIA[259]!;
+
+  const NARROW_PT_ENGINE: EncoderEngine = {
+    protocol: 'pt-raster',
+    headDots: 128,
+    capabilities: { autocut: true, mediaDetection: true, highResDpi: 360 },
+  };
+  const WIDE_PT_ENGINE: EncoderEngine = {
+    protocol: 'pt-raster',
+    headDots: 560,
+    capabilities: { autocut: true, mediaDetection: true, highResDpi: 720 },
+  };
+  const QL_TWO_COLOR_ENGINE: EncoderEngine = {
+    protocol: 'ql-raster',
+    headDots: 720,
+    capabilities: { autocut: true, mediaDetection: true, twoColor: true },
+  };
+  const QL_SINGLE_COLOR_ENGINE: EncoderEngine = {
+    protocol: 'ql-raster',
+    headDots: 720,
+    capabilities: { autocut: true, mediaDetection: true },
+  };
+
+  it('PT-raster job uses 200-byte invalidate', () => {
+    const bitmap = createBitmap(70, 5);
+    const out = encodeJobForEngine([{ bitmap, media: TZE_12MM }], {}, NARROW_PT_ENGINE);
+    // After buildRasterMode (4 bytes: 0x1B 0x69 0x61 0x01), invalidate begins.
+    expect(out.slice(0, 4)).toEqual(new Uint8Array([0x1b, 0x69, 0x61, 0x01]));
+    // Confirm the next 200 bytes are zero (PT invalidate).
+    for (let i = 4; i < 204; i++) expect(out[i]).toBe(0);
+    // The byte after the 200-zero invalidate should be 0x1B (start of buildInitialize),
+    // proving the invalidate is not 400 bytes.
+    expect(out[204]).toBe(0x1b);
+  });
+
+  it('QL two-colour engine bumps invalidate to 400 bytes', () => {
+    const bitmap = createBitmap(696, 5);
+    const out = encodeJobForEngine([{ bitmap, media: DK_62MM }], {}, QL_TWO_COLOR_ENGINE);
+    expect(out.slice(0, 4)).toEqual(new Uint8Array([0x1b, 0x69, 0x61, 0x01]));
+    for (let i = 4; i < 404; i++) expect(out[i]).toBe(0);
+    expect(out[404]).toBe(0x1b);
+  });
+
+  it('QL single-colour engine keeps invalidate at 200 bytes', () => {
+    const bitmap = createBitmap(696, 5);
+    const out = encodeJobForEngine([{ bitmap, media: DK_62MM }], {}, QL_SINGLE_COLOR_ENGINE);
+    for (let i = 4; i < 204; i++) expect(out[i]).toBe(0);
+    expect(out[204]).toBe(0x1b);
+  });
+
+  it('PT-raster expanded-mode uses bit 6 (0x40) for high-res', () => {
+    const bitmap = createBitmap(70, 5);
+    const out = encodeJobForEngine(
+      [{ bitmap, media: TZE_12MM, options: { highResolution: true } }],
+      {},
+      NARROW_PT_ENGINE,
+    );
+    // Locate the ESC i K command (0x1B 0x69 0x4B FLAGS).
+    let idx = -1;
+    for (let i = 0; i < out.length - 3; i++) {
+      if (out[i] === 0x1b && out[i + 1] === 0x69 && out[i + 2] === 0x4b) {
+        idx = i;
+        break;
+      }
+    }
+    expect(idx).toBeGreaterThanOrEqual(0);
+    expect((out[idx + 3] ?? 0) & 0x40).toBe(0x40);
+    expect((out[idx + 3] ?? 0) & 0x10).toBe(0x00);
+  });
+
+  it('PT-raster feed-margin defaults to 14 dots', () => {
+    const bitmap = createBitmap(70, 5);
+    const out = encodeJobForEngine([{ bitmap, media: TZE_12MM }], {}, NARROW_PT_ENGINE);
+    // Locate ESC i d (0x1B 0x69 0x64 LO HI).
+    let idx = -1;
+    for (let i = 0; i < out.length - 4; i++) {
+      if (out[i] === 0x1b && out[i + 1] === 0x69 && out[i + 2] === 0x64) {
+        idx = i;
+        break;
+      }
+    }
+    expect(idx).toBeGreaterThanOrEqual(0);
+    const lo = out[idx + 3] ?? 0;
+    const hi = out[idx + 4] ?? 0;
+    expect(lo | (hi << 8)).toBe(14);
+  });
+
+  it('QL feed-margin defaults to 35 dots', () => {
+    const bitmap = createBitmap(696, 5);
+    const out = encodeJobForEngine([{ bitmap, media: DK_62MM }], {}, QL_SINGLE_COLOR_ENGINE);
+    let idx = -1;
+    for (let i = 0; i < out.length - 4; i++) {
+      if (out[i] === 0x1b && out[i + 1] === 0x69 && out[i + 2] === 0x64) {
+        idx = i;
+        break;
+      }
+    }
+    expect(idx).toBeGreaterThanOrEqual(0);
+    const lo = out[idx + 3] ?? 0;
+    const hi = out[idx + 4] ?? 0;
+    expect(lo | (hi << 8)).toBe(35);
+  });
+
+  it('PT high-res duplicates each raster line', () => {
+    const bitmap = createBitmap(70, 3);
+    const noHighRes = encodeJobForEngine([{ bitmap, media: TZE_12MM }], {}, NARROW_PT_ENGINE);
+    const highRes = encodeJobForEngine(
+      [{ bitmap, media: TZE_12MM, options: { highResolution: true } }],
+      {},
+      NARROW_PT_ENGINE,
+    );
+    // Counting the 0x67 raster opcodes is the cleanest signal: 3 lines
+    // native vs 6 lines high-res.
+    const countOp = (buf: Uint8Array, op: number): number => {
+      let n = 0;
+      for (const b of buf) if (b === op) n++;
+      return n;
+    };
+    // 0x67 happens to also be present in invalidate-zero adjacency rare;
+    // we instead compare relative line counts (delta = doubled rows).
+    expect(countOp(highRes, 0x67) - countOp(noHighRes, 0x67)).toBe(3);
+  });
+
+  it('PT high-res doubles the feed-margin field', () => {
+    const bitmap = createBitmap(70, 3);
+    const out = encodeJobForEngine(
+      [{ bitmap, media: TZE_12MM, options: { highResolution: true } }],
+      {},
+      NARROW_PT_ENGINE,
+    );
+    let idx = -1;
+    for (let i = 0; i < out.length - 4; i++) {
+      if (out[i] === 0x1b && out[i + 1] === 0x69 && out[i + 2] === 0x64) {
+        idx = i;
+        break;
+      }
+    }
+    const lo = out[idx + 3] ?? 0;
+    const hi = out[idx + 4] ?? 0;
+    expect(lo | (hi << 8)).toBe(28);
+  });
+
+  it('encodeJobForEngine resolves narrow vs wide TZe geometry', () => {
+    const bitmap = createBitmap(70, 1);
+    const narrow = encodeJobForEngine([{ bitmap, media: TZE_12MM }], {}, NARROW_PT_ENGINE);
+    const bitmap2 = createBitmap(150, 1);
+    const wide = encodeJobForEngine([{ bitmap: bitmap2, media: TZE_12MM }], {}, WIDE_PT_ENGINE);
+    // narrow: 128 pin head → row payload 16 bytes per raster line.
+    // wide:    560 pin head → row payload 70 bytes per raster line.
+    // Find the 0x67 raster opcode and check the LEN byte.
+    const findRowLen = (buf: Uint8Array): number => {
+      for (let i = 0; i < buf.length - 2; i++) {
+        if (buf[i] === 0x67 && buf[i + 1] === 0x00) return buf[i + 2] ?? -1;
+      }
+      return -1;
+    };
+    expect(findRowLen(narrow)).toBe(16);
+    expect(findRowLen(wide)).toBe(70);
+  });
+
+  it('throws when high-res requested on an engine without highResDpi', () => {
+    const bitmap = createBitmap(696, 1);
+    expect(() =>
+      encodeJobForEngine(
+        [{ bitmap, media: DK_62MM, options: { highResolution: true } }],
+        {},
+        QL_SINGLE_COLOR_ENGINE,
+      ),
+    ).toThrow(/high-res/);
+  });
+
+  it('PT-E550W rejects autocut with compression disabled (cutter quirk)', () => {
+    const bitmap = createBitmap(70, 3);
+    expect(() =>
+      encodeJobForEngine(
+        [{ bitmap, media: TZE_12MM, options: { autoCut: true, compress: false } }],
+        {},
+        NARROW_PT_ENGINE,
+        'PT-E550W',
+      ),
+    ).toThrow(/PT-E550W/);
+  });
+
+  it('PT-P750W (same head family, different name) does NOT trigger the E550W cutter quirk', () => {
+    const bitmap = createBitmap(70, 3);
+    expect(() =>
+      encodeJobForEngine(
+        [{ bitmap, media: TZE_12MM, options: { autoCut: true, compress: false } }],
+        {},
+        NARROW_PT_ENGINE,
+        'PT-P750W',
+      ),
+    ).not.toThrow();
+  });
+});
+
+describe('encodeJob legacy entry point — back compat', () => {
+  it('still produces the original 200-byte single-colour invalidate', () => {
+    const bitmap = createBitmap(696, 1);
+    const out = encodeJob([{ bitmap, media: MEDIA[259]! }], {});
+    for (let i = 4; i < 204; i++) expect(out[i]).toBe(0);
+    expect(out[204]).toBe(0x1b);
+  });
+});

package/src/__tests__/status.test.ts

@@ -9,6 +9,7 @@ function makeStatusBytes(
     mediaLengthMm: number;
     mediaTypeByte: number;
     statusType: number;
+    byte25: number;
   }>,
 ): Uint8Array {
   const bytes = new Uint8Array(32);
@@ -22,9 +23,40 @@ function makeStatusBytes(
   bytes[11] = overrides?.mediaTypeByte ?? 0x0a;
   bytes[17] = overrides?.mediaLengthMm ?? 0;
   bytes[18] = overrides?.statusType ?? 0x00;
+  bytes[25] = overrides?.byte25 ?? 0;
   return bytes;
 }
 
+/**
+ * Verbatim 32-byte captures from scripts/STATUS-CAPTURE.md. These lock
+ * in the byte-25 two-color flag against the registry — without them,
+ * the DK-22251/DK-22205 detection ambiguity could silently regress.
+ */
+function captureBytes(values: readonly number[]): Uint8Array {
+  if (values.length !== 32) throw new Error(`expected 32 bytes, got ${values.length.toString()}`);
+  return Uint8Array.from(values);
+}
+
+const CAPTURE_DK_22251 = captureBytes([
+  0x80, 0x20, 0x42, 0x34, 0x41, 0x30, 0x04, 0x00, 0x00, 0x00, 0x3e, 0x0a, 0x00, 0x00, 0x23, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+]);
+
+const CAPTURE_DK_22205 = captureBytes([
+  0x80, 0x20, 0x42, 0x34, 0x41, 0x30, 0x04, 0x00, 0x00, 0x00, 0x3e, 0x0a, 0x00, 0x00, 0x15, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+]);
+
+const CAPTURE_DK_11201 = captureBytes([
+  0x80, 0x20, 0x42, 0x34, 0x41, 0x30, 0x04, 0x00, 0x00, 0x00, 0x1d, 0x0b, 0x00, 0x00, 0x01, 0x00,
+  0x00, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+]);
+
+const CAPTURE_DK_22214 = captureBytes([
+  0x80, 0x20, 0x42, 0x34, 0x41, 0x30, 0x04, 0x00, 0x00, 0x00, 0x0c, 0x0a, 0x00, 0x00, 0x1a, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+]);
+
 describe('parseStatus', () => {
   it('throws on short input', () => {
     expect(() => parseStatus(new Uint8Array(10))).toThrow('too short');
@@ -95,6 +127,61 @@ describe('parseStatus', () => {
     const status = parseStatus(makeStatusBytes());
     expect(status.editorLiteMode).toBe(false);
   });
+
+  it('byte 25 bit 7 set → twoColorRoll=true and resolves to DK-22251', () => {
+    const status = parseStatus(
+      makeStatusBytes({ mediaWidthMm: 62, mediaTypeByte: 0x0a, byte25: 0x81 }),
+    );
+    expect(status.twoColorRoll).toBe(true);
+    expect(status.detectedMedia?.id).toBe(251);
+  });
+
+  it('byte 25 bit 7 clear → twoColorRoll=false and resolves to DK-22205', () => {
+    const status = parseStatus(
+      makeStatusBytes({ mediaWidthMm: 62, mediaTypeByte: 0x0a, byte25: 0x01 }),
+    );
+    expect(status.twoColorRoll).toBe(false);
+    expect(status.detectedMedia?.id).toBe(259);
+  });
+
+  it('twoColorRoll is omitted when no media is loaded', () => {
+    const status = parseStatus(makeStatusBytes({ mediaWidthMm: 0, mediaTypeByte: 0 }));
+    expect(status.twoColorRoll).toBeUndefined();
+  });
+});
+
+describe('parseStatus — real hardware captures', () => {
+  it('DK-22251 (62mm two-color continuous) resolves to id 251', () => {
+    const status = parseStatus(CAPTURE_DK_22251);
+    expect(status.mediaLoaded).toBe(true);
+    expect(status.detectedMedia?.id).toBe(251);
+    expect(status.twoColorRoll).toBe(true);
+    expect(status.errors).toEqual([]);
+  });
+
+  it('DK-22205 (62mm single-color continuous) resolves to id 259, NOT 251', () => {
+    const status = parseStatus(CAPTURE_DK_22205);
+    expect(status.mediaLoaded).toBe(true);
+    expect(status.detectedMedia?.id).toBe(259);
+    expect(status.twoColorRoll).toBe(false);
+    expect(status.errors).toEqual([]);
+  });
+
+  it('DK-11201 (29×90mm die-cut) resolves to id 271', () => {
+    const status = parseStatus(CAPTURE_DK_11201);
+    expect(status.mediaLoaded).toBe(true);
+    expect(status.detectedMedia?.id).toBe(271);
+    expect(status.twoColorRoll).toBe(false);
+    expect(status.errors).toEqual([]);
+  });
+
+  it('DK-22214 (12mm continuous) resolves to id 257', () => {
+    const status = parseStatus(CAPTURE_DK_22214);
+    expect(status.mediaLoaded).toBe(true);
+    expect(status.detectedMedia?.id).toBe(257);
+    expect(status.twoColorRoll).toBe(false);
+    expect(status.errors).toEqual([]);
+  });
 });
 
 describe('STATUS_REQUEST', () => {