@ecobridge.xyz/devicemanager 3.1.0 → 3.2.0

package/test/test.brother.node.ts

@@ -0,0 +1,306 @@
+import * as net from 'node:net';
+
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import {
+  BrotherScanError,
+  BrotherScanProtocol,
+} from '../ts/protocols/protocol.brother.js';
+
+function makeJpeg(width: number, height: number, resolution: number): Buffer {
+  const padding = Buffer.alloc(80, 0x41);
+  return Buffer.concat([
+    Buffer.from([
+      0xff, 0xd8,
+      0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x02, 0x01,
+      (resolution >> 8) & 0xff, resolution & 0xff,
+      (resolution >> 8) & 0xff, resolution & 0xff, 0x00, 0x00,
+      0xff, 0xfe, 0x00, 0x52,
+    ]),
+    padding,
+    Buffer.from([
+      0xff, 0xc0, 0x00, 0x0b, 0x08,
+      (height >> 8) & 0xff, height & 0xff,
+      (width >> 8) & 0xff, width & 0xff,
+      0x01, 0x01, 0x11, 0x00,
+      0xff, 0xd9,
+    ]),
+  ]);
+}
+
+function simpleFrame(payload: Buffer): Buffer {
+  const length = Buffer.alloc(2);
+  length.writeUInt16LE(payload.length);
+  return Buffer.concat([Buffer.from([0x40]), length, payload]);
+}
+
+function wrappedFrame(payload: Buffer, imageNumber: number = 1): Buffer {
+  const header = Buffer.alloc(12, 0);
+  header[0] = 0x40;
+  header.writeUInt16LE(7, 1);
+  header.writeUInt16LE(imageNumber, 3);
+  header.writeUInt16LE(payload.length, 10);
+  return Buffer.concat([header, payload]);
+}
+
+function endOfImage(imageNumber: number): Buffer {
+  const header = Buffer.alloc(10, 0);
+  header[0] = 0x82;
+  header.writeUInt16LE(7, 1);
+  header.writeUInt16LE(imageNumber, 3);
+  return header;
+}
+
+function readCommands(socket: net.Socket, onCommand: (command: Buffer) => void): void {
+  let input = Buffer.alloc(0);
+  socket.on('data', (data) => {
+    input = Buffer.concat([input, data]);
+    while (true) {
+      const end = input.indexOf(0x80);
+      if (end < 0) return;
+      const command = input.subarray(0, end + 1);
+      input = input.subarray(end + 1);
+      onCommand(command);
+    }
+  });
+}
+
+tap.test('Brother native scan supports variable-length ADF leases and drains every page', async () => {
+  const commands: string[] = [];
+  const firstPage = makeJpeg(5052, 8400, 600);
+  const secondPage = makeJpeg(5052, 8400, 600);
+  const secondPageWithoutEndMarker = secondPage.subarray(0, -2);
+  const server = net.createServer((socket) => {
+    socket.write('+OK 200\r\n');
+    readCommands(socket, (command) => {
+      const text = command.toString('latin1');
+      commands.push(text);
+      if (text.startsWith('\x1bS\n')) {
+        socket.write(Buffer.from([0x80]));
+      } else if (text.startsWith('\x1bI\n')) {
+        socket.write(Buffer.concat([
+          Buffer.from([0x1a, 0x00]),
+          Buffer.from('600,600,1,213,5052,0,0', 'ascii'),
+        ]));
+      } else if (text.includes('D=DUP')) {
+        socket.write(Buffer.concat([
+          wrappedFrame(firstPage.subarray(0, Math.floor(firstPage.length / 2)), 1),
+          wrappedFrame(secondPageWithoutEndMarker.subarray(0, Math.floor(secondPageWithoutEndMarker.length / 2)), 2),
+          wrappedFrame(firstPage.subarray(Math.floor(firstPage.length / 2)), 1),
+          endOfImage(1),
+          wrappedFrame(secondPageWithoutEndMarker.subarray(Math.floor(secondPageWithoutEndMarker.length / 2)), 2),
+          endOfImage(2),
+          Buffer.from([0x80]),
+        ]));
+      }
+    });
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as net.AddressInfo;
+  const client = new BrotherScanProtocol('127.0.0.1', address.port, { timeout: 1000, scanTimeout: 1000 });
+
+  try {
+    await client.connect();
+    const result = await client.scan({
+      source: 'adf-duplex',
+      resolution: 600,
+      format: 'jpeg',
+      colorMode: 'color',
+      quality: 90,
+      area: { x: 0, y: 0, width: 215.9, height: 355.6 },
+    });
+
+    expect(result.pageCount).toEqual(2);
+    expect(result.pages?.[0]?.data.equals(firstPage)).toEqual(true);
+    expect(result.pages?.[1]?.data.equals(secondPage)).toEqual(true);
+    expect(result.width).toEqual(5052);
+    expect(result.height).toEqual(8400);
+    expect(result.resolution).toEqual(600);
+    expect(commands[0]).toEqual('\x1bS\nAUTO\n\x80');
+    expect(commands[1]).toContain('R=600,600');
+    expect(commands[2]).toContain('D=DUP');
+    expect(commands[2]).toContain('C=JPEG\nJ=MID');
+    expect(commands[2]).toContain('A=0,0,5052,8400');
+    expect(commands).toHaveLength(3);
+  } finally {
+    await client.disconnect();
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+tap.test('Brother native scan uses FB and bottom-right scan coordinates', async () => {
+  const commands: string[] = [];
+  const page = makeJpeg(1181, 1417, 300);
+  const server = net.createServer((socket) => {
+    socket.write('+OK 200\r\n');
+    readCommands(socket, (command) => {
+      const text = command.toString('latin1');
+      commands.push(text);
+      if (text.startsWith('\x1bS\n')) {
+        socket.write(Buffer.from([0x80]));
+      } else if (text.startsWith('\x1bI\n')) {
+        socket.write(Buffer.concat([
+          Buffer.from([0x1a, 0x00]),
+          Buffer.from('300,300,0,216,2551,356,4205', 'ascii'),
+        ]));
+      } else if (text.startsWith('\x1bX\n')) {
+        socket.write(Buffer.concat([wrappedFrame(page), endOfImage(1), Buffer.from([0x80])]));
+      }
+    });
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as net.AddressInfo;
+  const client = new BrotherScanProtocol('127.0.0.1', address.port, {
+    timeout: 1000,
+    scanTimeout: 1000,
+  });
+
+  try {
+    await client.connect();
+    const result = await client.scan({
+      source: 'flatbed',
+      resolution: 300,
+      format: 'jpeg',
+      colorMode: 'color',
+      area: { x: 10, y: 20, width: 100, height: 120 },
+    });
+
+    expect(result.pageCount).toEqual(1);
+    expect(commands[0]).toEqual('\x1bS\nFB\n\x80');
+    expect(commands[2]).toContain('A=118,236,1299,1653');
+    expect(commands[2]).not.toContain('U=OFF');
+    expect(commands[2]).not.toContain('P=OFF');
+  } finally {
+    await client.disconnect();
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+tap.test('Brother legacy page boundaries request the next page', async () => {
+  const commands: string[] = [];
+  const firstPage = makeJpeg(2480, 3507, 300);
+  const secondPage = makeJpeg(2480, 3507, 300);
+  const server = net.createServer((socket) => {
+    socket.write('+OK 200\r\n');
+    readCommands(socket, (command) => {
+      const text = command.toString('latin1');
+      commands.push(text);
+      if (text.startsWith('\x1bS\n')) {
+        socket.write(Buffer.from([0x80]));
+      } else if (text.startsWith('\x1bI\n')) {
+        socket.write(Buffer.concat([
+          Buffer.from([0x1a, 0x00]),
+          Buffer.from('300,300,2,210,2480,297,3507', 'ascii'),
+        ]));
+      } else if (text.includes('C=JPEG')) {
+        socket.write(Buffer.concat([simpleFrame(firstPage), Buffer.from([0x81])]));
+      } else if (text === '\x1bX\n\x80') {
+        socket.write(Buffer.concat([simpleFrame(secondPage), Buffer.from([0x80])]));
+      }
+    });
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as net.AddressInfo;
+  const client = new BrotherScanProtocol('127.0.0.1', address.port, {
+    timeout: 1000,
+    scanTimeout: 1000,
+  });
+
+  try {
+    await client.connect();
+    const result = await client.scan({
+      source: 'adf', resolution: 300, format: 'jpeg', colorMode: 'color',
+      area: { x: 0, y: 0, width: 210, height: 297 },
+    });
+    expect(result.pageCount).toEqual(2);
+    expect(commands[3]).toEqual('\x1bX\n\x80');
+  } finally {
+    await client.disconnect();
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+tap.test('Brother native scan rejects a silently downgraded resolution', async () => {
+  const server = net.createServer((socket) => {
+    socket.write('+OK 200\r\n');
+    readCommands(socket, (command) => {
+      const text = command.toString('latin1');
+      if (text.startsWith('\x1bS\n')) socket.write(Buffer.from([0x80]));
+      if (text.startsWith('\x1bI\n')) {
+        socket.write(Buffer.concat([
+          Buffer.from([0x1a, 0x00]),
+          Buffer.from('300,300,2,210,2480,297,3507', 'ascii'),
+        ]));
+      }
+    });
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as net.AddressInfo;
+  const client = new BrotherScanProtocol('127.0.0.1', address.port, { timeout: 1000 });
+
+  try {
+    await client.connect();
+    let scanError: BrotherScanError | undefined;
+    try {
+      await client.scan({
+        source: 'adf', resolution: 600, format: 'jpeg', colorMode: 'color',
+        area: { x: 0, y: 0, width: 210, height: 297 },
+      });
+    } catch (error) {
+      if (error instanceof BrotherScanError) scanError = error;
+    }
+    expect(scanError?.code).toEqual('settings-rejected');
+    expect(scanError?.message).toContain('offered 300x300 dpi');
+  } finally {
+    await client.disconnect();
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+tap.test('Brother native scan retries a temporarily busy device', async () => {
+  let connections = 0;
+  const server = net.createServer((socket) => {
+    connections++;
+    if (connections < 3) socket.end('-NG 401\r\n');
+    else socket.write('+OK 200\r\n');
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as net.AddressInfo;
+  const client = new BrotherScanProtocol('127.0.0.1', address.port, {
+    timeout: 1000,
+    busyRetryInterval: 5,
+    busyTimeout: 100,
+  });
+
+  try {
+    await client.connect();
+    expect(connections).toEqual(3);
+  } finally {
+    await client.disconnect();
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+tap.test('Brother native scan reports a persistently occupied device as busy', async () => {
+  const server = net.createServer((socket) => socket.end('-NG 401\r\n'));
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as net.AddressInfo;
+  const client = new BrotherScanProtocol('127.0.0.1', address.port, {
+    timeout: 1000,
+    busyTimeout: 0,
+  });
+
+  try {
+    let connectError: BrotherScanError | undefined;
+    try {
+      await client.connect();
+    } catch (error) {
+      if (error instanceof BrotherScanError) connectError = error;
+    }
+    expect(connectError?.code).toEqual('busy');
+  } finally {
+    await client.disconnect();
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+export default tap.start();

package/test/test.escl.node.ts

@@ -0,0 +1,233 @@
+import * as http from 'node:http';
+
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import { EsclProtocol, EsclScanError } from '../ts/protocols/protocol.escl.js';
+
+const capabilitiesXml = `<?xml version="1.0" encoding="UTF-8"?>
+<scan:ScannerCapabilities xmlns:scan="http://schemas.hp.com/imaging/escl/2011/05/03" xmlns:pwg="http://www.pwg.org/schemas/2010/12/sm">
+  <pwg:Version>2.62</pwg:Version>
+  <pwg:MakeAndModel>Brother MFC-J5730DW</pwg:MakeAndModel>
+  <pwg:SerialNumber>test-serial</pwg:SerialNumber>
+  <scan:Platen><scan:PlatenInputCaps>
+    <scan:MinWidth>16</scan:MinWidth><scan:MaxWidth>2550</scan:MaxWidth>
+    <scan:MinHeight>16</scan:MinHeight><scan:MaxHeight>3507</scan:MaxHeight>
+    <scan:MaxScanRegions>1</scan:MaxScanRegions>
+    <scan:SettingProfiles><scan:SettingProfile>
+      <scan:ColorModes><scan:ColorMode>RGB24</scan:ColorMode><scan:ColorMode>Grayscale8</scan:ColorMode></scan:ColorModes>
+      <scan:DocumentFormats><pwg:DocumentFormat>application/pdf</pwg:DocumentFormat><scan:DocumentFormatExt>image/jpeg</scan:DocumentFormatExt></scan:DocumentFormats>
+      <scan:SupportedResolutions><scan:DiscreteResolutions>
+        <scan:DiscreteResolution><scan:XResolution>300</scan:XResolution><scan:YResolution>300</scan:YResolution></scan:DiscreteResolution>
+        <scan:DiscreteResolution><scan:XResolution>600</scan:XResolution><scan:YResolution>600</scan:YResolution></scan:DiscreteResolution>
+      </scan:DiscreteResolutions></scan:SupportedResolutions>
+    </scan:SettingProfile></scan:SettingProfiles>
+  </scan:PlatenInputCaps></scan:Platen>
+  <scan:Adf>
+    <scan:AdfSimplexInputCaps>
+      <scan:MaxWidth>2550</scan:MaxWidth><scan:MaxHeight>4200</scan:MaxHeight>
+      <scan:SettingProfiles><scan:SettingProfile><scan:ColorModes><scan:ColorMode>RGB24</scan:ColorMode></scan:ColorModes><scan:DocumentFormats><pwg:DocumentFormat>application/pdf</pwg:DocumentFormat></scan:DocumentFormats><scan:SupportedResolutions><scan:DiscreteResolutions><scan:DiscreteResolution><scan:XResolution>600</scan:XResolution></scan:DiscreteResolution></scan:DiscreteResolutions></scan:SupportedResolutions></scan:SettingProfile></scan:SettingProfiles>
+    </scan:AdfSimplexInputCaps>
+    <scan:AdfDuplexInputCaps>
+      <scan:MaxWidth>2550</scan:MaxWidth><scan:MaxHeight>4200</scan:MaxHeight>
+      <scan:SettingProfiles><scan:SettingProfile><scan:ColorModes><scan:ColorMode>BlackAndWhite1</scan:ColorMode></scan:ColorModes><scan:DocumentFormats><pwg:DocumentFormat>application/pdf</pwg:DocumentFormat></scan:DocumentFormats><scan:SupportedResolutions><scan:DiscreteResolutions><scan:DiscreteResolution><scan:XResolution>600</scan:XResolution></scan:DiscreteResolution></scan:DiscreteResolutions></scan:SupportedResolutions></scan:SettingProfile></scan:SettingProfiles>
+    </scan:AdfDuplexInputCaps>
+  </scan:Adf>
+</scan:ScannerCapabilities>`;
+
+const statusXml = `<?xml version="1.0" encoding="UTF-8"?>
+<scan:ScannerStatus xmlns:scan="http://schemas.hp.com/imaging/escl/2011/05/03" xmlns:pwg="http://www.pwg.org/schemas/2010/12/sm">
+  <pwg:State>Idle</pwg:State><scan:AdfState>ScannerAdfLoaded</scan:AdfState>
+  <scan:Jobs><scan:JobInfo>
+    <pwg:JobUri>/eSCL/ScanJobs/test-job</pwg:JobUri><pwg:JobUuid>urn:uuid:test-job</pwg:JobUuid>
+    <scan:Age>3</scan:Age><pwg:ImagesCompleted>2</pwg:ImagesCompleted><pwg:ImagesToTransfer>0</pwg:ImagesToTransfer>
+    <pwg:JobState>Completed</pwg:JobState><pwg:JobStateReasons><pwg:JobStateReason>JobCompletedSuccessfully</pwg:JobStateReason></pwg:JobStateReasons>
+  </scan:JobInfo></scan:Jobs>
+</scan:ScannerStatus>`;
+
+tap.test('eSCL parses namespaced Brother capabilities and status', async () => {
+  const server = http.createServer((request, response) => {
+    if (request.url === '/eSCL/ScannerCapabilities') {
+      response.writeHead(200, { 'content-type': 'text/xml' });
+      response.end(capabilitiesXml);
+      return;
+    }
+    if (request.url === '/eSCL/ScannerStatus') {
+      response.writeHead(200, { 'content-type': 'text/xml' });
+      response.end(statusXml);
+      return;
+    }
+    response.writeHead(404).end();
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as import('node:net').AddressInfo;
+  try {
+    const client = new EsclProtocol('127.0.0.1', address.port);
+    const capabilities = await client.getCapabilities();
+    const status = await client.getStatus();
+
+    expect(capabilities.version).toEqual('2.62');
+    expect(capabilities.makeAndModel).toEqual('Brother MFC-J5730DW');
+    expect(capabilities.platen?.supportedResolutions).toEqual([300, 600]);
+    expect(capabilities.platen?.colorModes).toEqual(['RGB24', 'Grayscale8']);
+    expect(capabilities.platen?.documentFormats).toEqual(['application/pdf', 'image/jpeg']);
+    expect(Math.round((capabilities.platen?.maxWidth ?? 0) * 10) / 10).toEqual(215.9);
+    expect(capabilities.adfDuplex?.colorModes).toEqual(['BlackAndWhite1']);
+    expect(status.adfState).toEqual('Loaded');
+    expect(status.jobs?.[0]?.jobStateReason).toEqual('JobCompletedSuccessfully');
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+tap.test('eSCL resolves relative jobs and drains every feeder document', async () => {
+  const pageOne = Buffer.from('%PDF-1.4\npage one');
+  const pageTwo = Buffer.from('%PDF-1.4\npage two');
+  const documents = [pageOne, pageTwo];
+  let settings = '';
+  let contentType = '';
+  let nextDocumentCalls = 0;
+  const server = http.createServer((request, response) => {
+    if (request.method === 'POST' && request.url === '/eSCL/ScanJobs') {
+      contentType = request.headers['content-type'] ?? '';
+      request.setEncoding('utf8');
+      request.on('data', (chunk) => { settings += chunk; });
+      request.on('end', () => {
+        response.writeHead(201, { location: '/eSCL/ScanJobs/test-job' });
+        response.end();
+      });
+      return;
+    }
+    if (request.url === '/eSCL/ScanJobs/test-job/NextDocument') {
+      const document = documents[nextDocumentCalls++];
+      if (!document) {
+        response.writeHead(404).end();
+        return;
+      }
+      response.writeHead(200, {
+        'content-type': 'application/pdf',
+        'x-image-width': '4960',
+        'x-image-height': '7014',
+      });
+      response.end(document);
+      return;
+    }
+    if (request.url === '/eSCL/ScannerStatus') {
+      response.writeHead(200, { 'content-type': 'text/xml' });
+      response.end(statusXml);
+      return;
+    }
+    if (request.method === 'DELETE' && request.url === '/eSCL/ScanJobs/test-job') {
+      response.writeHead(204).end();
+      return;
+    }
+    response.writeHead(404).end();
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as import('node:net').AddressInfo;
+  try {
+    const client = new EsclProtocol('127.0.0.1', address.port);
+    const result = await client.scan({
+      source: 'adf-duplex', format: 'pdf', resolution: 600, colorMode: 'color',
+      area: { x: 0, y: 0, width: 210, height: 297 }, intent: 'document',
+    });
+
+    expect(result.data.equals(pageOne)).toEqual(true);
+    expect(result.pageCount).toEqual(2);
+    expect(result.pages?.map((page) => page.data.toString())).toEqual([
+      pageOne.toString(), pageTwo.toString(),
+    ]);
+    expect(nextDocumentCalls).toEqual(3);
+    expect(settings).toContain('<pwg:InputSource>Feeder</pwg:InputSource>');
+    expect(settings).toContain('<scan:Duplex>true</scan:Duplex>');
+    expect(settings).toContain('<scan:Intent>Document</scan:Intent>');
+    expect(settings).toContain('<pwg:DocumentFormat>application/pdf</pwg:DocumentFormat>');
+    expect(settings).toContain('<pwg:Height>3508</pwg:Height>');
+    expect(contentType).toEqual('text/xml');
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+tap.test('eSCL preserves transferred documents when the scanner times out', async () => {
+  const page = Buffer.from('%PDF-1.4\npartial page');
+  let nextDocumentCalls = 0;
+  const timedOutStatus = statusXml
+    .replace('<pwg:JobState>Completed</pwg:JobState>', '<pwg:JobState>Canceled</pwg:JobState>')
+    .replace('JobCompletedSuccessfully', 'JobTimedOut');
+  const server = http.createServer((request, response) => {
+    if (request.method === 'POST' && request.url === '/eSCL/ScanJobs') {
+      response.writeHead(201, { location: '/eSCL/ScanJobs/test-job' }).end();
+      return;
+    }
+    if (request.url === '/eSCL/ScanJobs/test-job/NextDocument') {
+      if (nextDocumentCalls++ === 0) {
+        response.writeHead(200, { 'content-type': 'application/pdf' }).end(page);
+      } else {
+        response.writeHead(404).end();
+      }
+      return;
+    }
+    if (request.url === '/eSCL/ScannerStatus') {
+      response.writeHead(200, { 'content-type': 'text/xml' }).end(timedOutStatus);
+      return;
+    }
+    if (request.method === 'DELETE') {
+      response.writeHead(204).end();
+      return;
+    }
+    response.writeHead(404).end();
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as import('node:net').AddressInfo;
+  try {
+    const client = new EsclProtocol('127.0.0.1', address.port);
+    let scanError: EsclScanError | undefined;
+    try {
+      await client.scan({ source: 'adf-duplex', format: 'pdf' });
+    } catch (error) {
+      if (error instanceof EsclScanError) scanError = error;
+    }
+    expect(scanError?.message).toContain('JobTimedOut');
+    expect(scanError?.partialResult?.pageCount).toEqual(1);
+    expect(scanError?.partialResult?.pages?.[0]?.data.equals(page)).toEqual(true);
+    expect(scanError?.partialResult?.isComplete).toEqual(false);
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+tap.test('eSCL reports the response format and JPEG metadata actually returned', async () => {
+  const jpeg = Buffer.from([
+    0xff, 0xd8,
+    0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x02, 0x01, 0x01, 0x2c, 0x01, 0x2c, 0x00, 0x00,
+    0xff, 0xc0, 0x00, 0x0b, 0x08, 0x08, 0x91, 0x06, 0x90, 0x01, 0x01, 0x11, 0x00,
+    0xff, 0xd9,
+  ]);
+  const server = http.createServer((request, response) => {
+    if (request.url === '/eSCL/ScanJobs/jpeg-job/NextDocument') {
+      response.writeHead(200, { 'content-type': 'image/jpeg' }).end(jpeg);
+      return;
+    }
+    response.writeHead(404).end();
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as import('node:net').AddressInfo;
+  try {
+    const client = new EsclProtocol('127.0.0.1', address.port);
+    const result = await client.downloadScan('/eSCL/ScanJobs/jpeg-job', {
+      format: 'pdf', resolution: 600, colorMode: 'color',
+    });
+    expect(result.format).toEqual('jpeg');
+    expect(result.mimeType).toEqual('image/jpeg');
+    expect(result.width).toEqual(1680);
+    expect(result.height).toEqual(2193);
+    expect(result.resolution).toEqual(300);
+    expect(result.settingsWarnings).toEqual([
+      'Requested pdf output but scanner returned jpeg',
+      'Requested 600 dpi but scanner returned 300 dpi',
+    ]);
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+export default tap.start();

package/test/test.ipp.node.ts

@@ -0,0 +1,75 @@
+import * as http from 'node:http';
+
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import { IppProtocol } from '../ts/protocols/protocol.ipp.js';
+
+function ippAttribute(tag: number, name: string, value: Buffer): Buffer {
+  const nameBuffer = Buffer.from(name, 'utf-8');
+  const header = Buffer.alloc(5);
+  header[0] = tag;
+  header.writeUInt16BE(nameBuffer.length, 1);
+  header.writeUInt16BE(value.length, 3);
+  return Buffer.concat([header.subarray(0, 3), nameBuffer, header.subarray(3), value]);
+}
+
+function languageTaggedValue(language: string, text: string): Buffer {
+  const languageBuffer = Buffer.from(language, 'utf-8');
+  const textBuffer = Buffer.from(text, 'utf-8');
+  const lengths = Buffer.alloc(4);
+  lengths.writeUInt16BE(languageBuffer.length, 0);
+  lengths.writeUInt16BE(textBuffer.length, 2);
+  return Buffer.concat([lengths.subarray(0, 2), languageBuffer, lengths.subarray(2), textBuffer]);
+}
+
+function int32(value: number): Buffer {
+  const result = Buffer.alloc(4);
+  result.writeInt32BE(value);
+  return result;
+}
+
+tap.test('IPP decodes language-tagged model names and reports AirPrint raster support', async () => {
+  const resolution = Buffer.alloc(9);
+  resolution.writeInt32BE(300, 0);
+  resolution.writeInt32BE(300, 4);
+  resolution[8] = 3;
+
+  const responseBody = Buffer.concat([
+    Buffer.from([0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]),
+    Buffer.from([0x04]),
+    ippAttribute(0x42, 'printer-name', Buffer.from('BRWF889D2A3B017')),
+    ippAttribute(0x35, 'printer-make-and-model', languageTaggedValue('en', 'Brother MFC-J5730DW')),
+    ippAttribute(0x23, 'printer-state', int32(3)),
+    ippAttribute(0x22, 'printer-is-accepting-jobs', Buffer.from([1])),
+    ippAttribute(0x49, 'document-format-supported', Buffer.from('image/urf')),
+    ippAttribute(0x49, '', Buffer.from('image/pwg-raster')),
+    ippAttribute(0x44, 'sides-supported', Buffer.from('one-sided')),
+    ippAttribute(0x44, '', Buffer.from('two-sided-long-edge')),
+    ippAttribute(0x32, 'printer-resolution-supported', resolution),
+    ippAttribute(0x46, 'ipp-versions-supported', Buffer.from('2.0')),
+    Buffer.from([0x03]),
+  ]);
+
+  const server = http.createServer((request, response) => {
+    request.resume();
+    response.writeHead(200, { 'content-type': 'application/ipp' });
+    response.end(responseBody);
+  });
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const address = server.address() as import('node:net').AddressInfo;
+
+  try {
+    const client = new IppProtocol('127.0.0.1', address.port, '/ipp/print');
+    const capabilities = await client.getPrinterAttributes();
+    expect(capabilities.printerMakeAndModel).toEqual('Brother MFC-J5730DW');
+    expect(capabilities.airPrintSupported).toEqual(true);
+    expect(capabilities.documentFormatSupported).toEqual(['image/urf', 'image/pwg-raster']);
+    expect(capabilities.sidesSupported).toEqual(['one-sided', 'two-sided-long-edge']);
+    expect(capabilities.resolutionsSupported).toEqual([
+      { crossFeed: 300, feed: 300, units: 'dpi' },
+    ]);
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  }
+});
+
+export default tap.start();