@ecobridge.xyz/devicemanager 3.1.0 → 3.2.0

package/ts/protocols/protocol.escl.ts

@@ -1,4 +1,5 @@
 import * as plugins from '../plugins.js'; // Used for smartdelay
+import { XMLBuilder, XMLParser } from 'fast-xml-parser';
 import type {
   IEsclCapabilities,
   IEsclScanStatus,
@@ -36,6 +37,113 @@ const FORMAT_MIME_MAP: Record<TScanFormat, string> = {
   tiff: 'image/tiff',
 };
 
+const STATUS_POLL_INTERVAL_MS = 500;
+const MAX_STATUS_POLLS = 240;
+const MAX_SCAN_DOCUMENTS = 500;
+const CONTROL_REQUEST_TIMEOUT_MS = 30_000;
+const DOCUMENT_REQUEST_TIMEOUT_MS = 10 * 60_000;
+
+type TXmlRecord = Record<string, unknown>;
+
+const xmlParser = new XMLParser({
+  ignoreAttributes: true,
+  removeNSPrefix: true,
+  trimValues: true,
+  parseTagValue: false,
+  processEntities: false,
+});
+
+const xmlBuilder = new XMLBuilder({
+  ignoreAttributes: false,
+  format: true,
+  suppressEmptyNode: false,
+});
+
+function asRecord(value: unknown): TXmlRecord {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value as TXmlRecord
+    : {};
+}
+
+function asArray<T>(value: T | T[] | undefined): T[] {
+  if (value === undefined) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function asText(value: unknown): string {
+  return typeof value === 'string' || typeof value === 'number' ? String(value).trim() : '';
+}
+
+function asInteger(value: unknown, fallback: number = 0): number {
+  const parsed = Number.parseInt(asText(value), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function unique<T>(values: T[]): T[] {
+  return [...new Set(values)];
+}
+
+function collectValues(value: unknown, key: string): unknown[] {
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => collectValues(item, key));
+  }
+  if (value === null || typeof value !== 'object') return [];
+  const record = value as TXmlRecord;
+  return Object.entries(record).flatMap(([entryKey, entryValue]) =>
+    entryKey === key ? asArray(entryValue) : collectValues(entryValue, key)
+  );
+}
+
+function esclUnitsToMillimetres(value: unknown, fallback: number): number {
+  const units = asInteger(value);
+  return units > 0 ? (units / 300) * 25.4 : fallback;
+}
+
+function formatFromMimeType(mimeType: string, fallback: TScanFormat): TScanFormat {
+  const normalized = mimeType.split(';', 1)[0].trim().toLowerCase();
+  if (normalized === 'application/pdf') return 'pdf';
+  if (normalized === 'image/jpeg') return 'jpeg';
+  if (normalized === 'image/png') return 'png';
+  if (normalized === 'image/tiff') return 'tiff';
+  return fallback;
+}
+
+function readJpegMetadata(data: Buffer): { width?: number; height?: number; resolution?: number } {
+  if (data.length < 4 || data[0] !== 0xff || data[1] !== 0xd8) return {};
+  const metadata: { width?: number; height?: number; resolution?: number } = {};
+  const startOfFrameMarkers = new Set([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf]);
+  let offset = 2;
+  while (offset + 4 <= data.length) {
+    while (offset < data.length && data[offset] === 0xff) offset++;
+    const marker = data[offset++];
+    if (marker === 0xd9 || marker === 0xda) break;
+    if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) continue;
+    if (offset + 2 > data.length) break;
+    const length = data.readUInt16BE(offset);
+    if (length < 2 || offset + length > data.length) break;
+    const content = offset + 2;
+    if (marker === 0xe0 && length >= 16 && data.toString('ascii', content, content + 5) === 'JFIF\0') {
+      const units = data[content + 7];
+      const density = data.readUInt16BE(content + 8);
+      if (units === 1 && density > 0) metadata.resolution = density;
+      if (units === 2 && density > 0) metadata.resolution = Math.round(density * 2.54);
+    }
+    if (startOfFrameMarkers.has(marker) && length >= 7) {
+      metadata.height = data.readUInt16BE(content + 1);
+      metadata.width = data.readUInt16BE(content + 3);
+    }
+    offset += length;
+  }
+  return metadata;
+}
+
+export class EsclScanError extends Error {
+  constructor(message: string, public readonly partialResult?: IScanResult) {
+    super(message);
+    this.name = 'EsclScanError';
+  }
+}
+
 /**
  * Helper to make HTTP requests using native fetch (available in Node.js 18+)
  */
@@ -44,7 +152,10 @@ async function httpRequest(
   method: 'GET' | 'POST' | 'DELETE',
   body?: string
 ): Promise<{ status: number; headers: Record<string, string>; body: string }> {
-  const options: RequestInit = { method };
+  const options: RequestInit = {
+    method,
+    signal: AbortSignal.timeout(CONTROL_REQUEST_TIMEOUT_MS),
+  };
 
   if (body) {
     options.headers = { 'Content-Type': 'text/xml; charset=utf-8' };
@@ -72,6 +183,7 @@ async function httpRequest(
 export class EsclProtocol {
   private baseUrl: string;
   private capabilities: IEsclCapabilities | null = null;
+  private activeJobUri: string | null = null;
 
   constructor(address: string, port: number, secure: boolean = false) {
     const protocol = secure ? 'https' : 'http';
@@ -118,13 +230,14 @@ export class EsclProtocol {
   public async submitScanJob(options: IScanOptions): Promise<string> {
     const scanSettings = this.buildScanSettings(options);
 
-    // Use fetch for POST with body since SmartRequest API may not support raw body
+    // Use fetch for the raw XML request body.
     const response = await fetch(`${this.baseUrl}/ScanJobs`, {
       method: 'POST',
       headers: {
-        'Content-Type': 'text/xml; charset=utf-8',
+        'Content-Type': 'text/xml',
       },
       body: scanSettings,
+      signal: AbortSignal.timeout(CONTROL_REQUEST_TIMEOUT_MS),
     });
 
     if (response.status !== 201) {
@@ -137,7 +250,7 @@ export class EsclProtocol {
       throw new Error('No job location returned from scanner');
     }
 
-    return location;
+    return this.resolveJobUri(location);
   }
 
   /**
@@ -150,77 +263,136 @@ export class EsclProtocol {
   public async waitForScanComplete(
     jobUri: string,
     options: IScanOptions,
-    pollInterval: number = 500
+    pollInterval: number = STATUS_POLL_INTERVAL_MS
   ): Promise<IScanResult> {
-    // Try direct download first - this triggers the scan on many scanners
-    // (including Brother) and blocks until the scan completes
-    try {
-      const result = await this.downloadScan(jobUri, options);
-      if (result.data.length > 0) {
-        return result;
-      }
-    } catch (err) {
-      // Direct download failed, fall back to polling
-    }
+    const pages: IScanResult[] = [];
+    let emptyPolls = 0;
 
-    // Fall back to polling for scanners that need it
-    let attempts = 0;
-    const maxAttempts = 120; // 60 seconds max
+    while (pages.length < MAX_SCAN_DOCUMENTS) {
+      let next: IScanResult | null;
+      const requestStartedAt = Date.now();
+      try {
+        next = await this.downloadNextDocument(jobUri, options);
+      } catch (error) {
+        if (pages.length === 0) throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        throw new EsclScanError(message, this.combinePages(pages, false, message));
+      }
+      if (next) {
+        pages.push(next);
+        emptyPolls = 0;
+        const delay = this.nextDocumentDelay(options.source, Date.now() - requestStartedAt);
+        if (delay > 0) await plugins.smartdelay.delayFor(delay);
+        continue;
+      }
 
-    while (attempts < maxAttempts) {
       const status = await this.getStatus();
-      const job = status.jobs?.find((j) => jobUri.includes(j.jobUuid) || j.jobUri === jobUri);
-
-      if (job) {
-        if (job.jobState === 'Completed') {
-          break;
-        } else if (job.jobState === 'Canceled' || job.jobState === 'Aborted') {
-          throw new Error(`Scan job ${job.jobState}: ${job.jobStateReason || 'Unknown reason'}`);
-        }
+      const job = this.findJob(status, jobUri);
+      if (job?.jobState === 'Canceled' || job?.jobState === 'Aborted') {
+        const reason = job.jobStateReason || 'Unknown reason';
+        const message = `Scan job ${job.jobState}: ${reason}`;
+        throw new EsclScanError(
+          message,
+          pages.length > 0 ? this.combinePages(pages, false, reason) : undefined
+        );
+      }
+      if (job?.jobState === 'Completed' || (!job && pages.length > 0)) {
+        break;
+      }
+      if (status.state === 'Stopped') {
+        const message = 'Scanner stopped before the scan completed';
+        throw new EsclScanError(
+          message,
+          pages.length > 0 ? this.combinePages(pages, false, message) : undefined
+        );
+      }
+      if (++emptyPolls >= MAX_STATUS_POLLS) {
+        const message = `Scan job timed out after ${MAX_STATUS_POLLS * pollInterval} ms`;
+        throw new EsclScanError(
+          message,
+          pages.length > 0 ? this.combinePages(pages, false, message) : undefined
+        );
       }
-
       await plugins.smartdelay.delayFor(pollInterval);
-      attempts++;
     }
 
-    if (attempts >= maxAttempts) {
-      throw new Error('Scan job timed out');
+    if (pages.length === MAX_SCAN_DOCUMENTS) {
+      const message = `Scan exceeded the safety limit of ${MAX_SCAN_DOCUMENTS} documents`;
+      throw new EsclScanError(message, this.combinePages(pages, false, message));
+    }
+    if (pages.length === 0) {
+      throw new Error('Scan completed without returning a document');
     }
 
-    // Download the scanned document
-    return this.downloadScan(jobUri, options);
+    return this.combinePages(pages, true);
+  }
+
+  private combinePages(pages: IScanResult[], isComplete: boolean, jobStateReason?: string): IScanResult {
+    const first = pages[0];
+    return {
+      ...first,
+      pageCount: pages.length,
+      pages: pages.map((page) => ({
+        data: page.data,
+        width: page.width,
+        height: page.height,
+        mimeType: page.mimeType,
+      })),
+      isComplete,
+      jobStateReason,
+      settingsWarnings: unique(pages.flatMap((page) => page.settingsWarnings ?? [])),
+    };
   }
 
   /**
    * Download scanned document
    */
   public async downloadScan(jobUri: string, options: IScanOptions): Promise<IScanResult> {
-    const downloadUrl = `${jobUri}/NextDocument`;
-
-    const response = await fetch(downloadUrl, { method: 'GET' });
-
-    if (response.status !== 200) {
-      throw new Error(`Failed to download scan: HTTP ${response.status}`);
-    }
+    const result = await this.downloadNextDocument(jobUri, options);
+    if (!result) throw new Error('No scanned document is available');
+    return result;
+  }
 
-    const format = options.format ?? 'jpeg';
-    const contentType = response.headers.get('content-type') ?? FORMAT_MIME_MAP[format];
+  private async downloadNextDocument(jobUri: string, options: IScanOptions): Promise<IScanResult | null> {
+    const downloadUrl = new URL('NextDocument', this.resolveJobUri(jobUri).replace(/\/?$/, '/'));
+    const response = await fetch(downloadUrl, {
+      method: 'GET',
+      signal: AbortSignal.timeout(DOCUMENT_REQUEST_TIMEOUT_MS),
+    });
 
-    // Get image dimensions from headers if available
-    const width = parseInt(response.headers.get('x-image-width') || '0') || 0;
-    const height = parseInt(response.headers.get('x-image-height') || '0') || 0;
+    if ([404, 409, 410, 503].includes(response.status)) return null;
+    if (response.status !== 200) throw new Error(`Failed to download scan: HTTP ${response.status}`);
 
     const arrayBuffer = await response.arrayBuffer();
     const data = Buffer.from(arrayBuffer);
+    const requestedFormat = options.format ?? 'jpeg';
+    const contentType = response.headers.get('content-type') ?? FORMAT_MIME_MAP[requestedFormat];
+    const format = formatFromMimeType(contentType, requestedFormat);
+    const jpeg = format === 'jpeg' ? readJpegMetadata(data) : {};
+    const width = parseInt(response.headers.get('x-image-width') || '0') || jpeg.width || 0;
+    const height = parseInt(response.headers.get('x-image-height') || '0') || jpeg.height || 0;
+    const reportedResolution = parseInt(response.headers.get('x-image-resolution') || '0')
+      || jpeg.resolution;
+    const resolution = reportedResolution || options.resolution || 300;
+    const settingsWarnings: string[] = [];
+    if (format !== requestedFormat) {
+      settingsWarnings.push(`Requested ${requestedFormat} output but scanner returned ${format}`);
+    }
+    if (reportedResolution && options.resolution && reportedResolution !== options.resolution) {
+      settingsWarnings.push(`Requested ${options.resolution} dpi but scanner returned ${reportedResolution} dpi`);
+    }
 
     return {
       data: data,
       format: format,
       width: width,
       height: height,
-      resolution: options.resolution ?? 300,
+      resolution,
       colorMode: options.colorMode ?? 'color',
       mimeType: contentType,
+      settingsWarnings,
+      pageCount: 1,
+      pages: [{ data, width, height, mimeType: contentType }],
     };
   }
 
@@ -228,7 +400,10 @@ export class EsclProtocol {
    * Cancel a scan job
    */
   public async cancelJob(jobUri: string): Promise<void> {
-    const response = await fetch(jobUri, { method: 'DELETE' });
+    const response = await fetch(this.resolveJobUri(jobUri), {
+      method: 'DELETE',
+      signal: AbortSignal.timeout(CONTROL_REQUEST_TIMEOUT_MS),
+    });
 
     // 204 No Content or 200 OK are both acceptable
     if (response.status !== 200 && response.status !== 204) {
@@ -236,6 +411,10 @@ export class EsclProtocol {
     }
   }
 
+  public async cancelCurrentScan(): Promise<void> {
+    if (this.activeJobUri) await this.cancelJob(this.activeJobUri);
+  }
+
   /**
    * Build XML scan settings
    */
@@ -243,131 +422,108 @@ export class EsclProtocol {
     const resolution = options.resolution ?? 300;
     const colorMode = COLOR_MODE_MAP[options.colorMode ?? 'color'];
     const format = FORMAT_MIME_MAP[options.format ?? 'jpeg'];
-    const source = this.mapSource(options.source ?? 'flatbed');
-    const intent = options.intent ?? 'TextAndPhoto';
-
-    let xml = `<?xml version="1.0" encoding="UTF-8"?>
-<scan:ScanSettings xmlns:scan="${NAMESPACES.scan}" xmlns:pwg="${NAMESPACES.pwg}">
-  <pwg:Version>2.0</pwg:Version>
-  <scan:Intent>${intent}</scan:Intent>
-  <pwg:ScanRegions>
-    <pwg:ScanRegion>`;
-
-    if (options.area) {
-      // Convert mm to 300ths of an inch (eSCL uses 300dpi as base unit)
-      const toUnits = (mm: number) => Math.round((mm / 25.4) * 300);
-      xml += `
-      <pwg:XOffset>${toUnits(options.area.x)}</pwg:XOffset>
-      <pwg:YOffset>${toUnits(options.area.y)}</pwg:YOffset>
-      <pwg:Width>${toUnits(options.area.width)}</pwg:Width>
-      <pwg:Height>${toUnits(options.area.height)}</pwg:Height>`;
-    } else {
-      // Full page (A4 default: 210x297mm)
-      xml += `
-      <pwg:XOffset>0</pwg:XOffset>
-      <pwg:YOffset>0</pwg:YOffset>
-      <pwg:Width>2480</pwg:Width>
-      <pwg:Height>3508</pwg:Height>`;
-    }
-
-    xml += `
-      <pwg:ContentRegionUnits>escl:ThreeHundredthsOfInches</pwg:ContentRegionUnits>
-    </pwg:ScanRegion>
-  </pwg:ScanRegions>
-  <scan:DocumentFormatExt>${format}</scan:DocumentFormatExt>
-  <scan:XResolution>${resolution}</scan:XResolution>
-  <scan:YResolution>${resolution}</scan:YResolution>
-  <scan:ColorMode>${colorMode}</scan:ColorMode>
-  <scan:InputSource>${source}</scan:InputSource>`;
-
+    const scanSource = options.source ?? 'flatbed';
+    const source = scanSource === 'flatbed' ? 'Platen' : 'Feeder';
+    const intent = this.mapIntent(options.intent ?? 'document');
+    const toUnits = (mm: number) => Math.round((mm / 25.4) * 300);
+    const sourceCapabilities = scanSource === 'flatbed'
+      ? this.capabilities?.platen
+      : scanSource === 'adf-duplex'
+        ? this.capabilities?.adfDuplex
+        : this.capabilities?.adf;
+    const requestedArea = options.area ?? { x: 0, y: 0, width: 210, height: 297 };
+    const maxWidth = sourceCapabilities?.maxWidth ?? 215.9;
+    const maxHeight = sourceCapabilities?.maxHeight ?? (scanSource === 'flatbed' ? 296.926 : 355.6);
+    const area = {
+      x: Math.max(0, requestedArea.x),
+      y: Math.max(0, requestedArea.y),
+      width: Math.min(requestedArea.width, maxWidth - Math.max(0, requestedArea.x)),
+      height: Math.min(requestedArea.height, maxHeight - Math.max(0, requestedArea.y)),
+    };
+    const settings: TXmlRecord = {
+      '@_xmlns:scan': NAMESPACES.scan,
+      '@_xmlns:pwg': NAMESPACES.pwg,
+      'pwg:Version': '2.0',
+      'scan:Intent': intent,
+      'pwg:ScanRegions': {
+        'pwg:ScanRegion': {
+          'pwg:ContentRegionUnits': 'escl:ThreeHundredthsOfInches',
+          'pwg:XOffset': toUnits(area.x),
+          'pwg:YOffset': toUnits(area.y),
+          'pwg:Width': toUnits(area.width),
+          'pwg:Height': toUnits(area.height),
+        },
+      },
+      'pwg:InputSource': source,
+      'scan:ColorMode': colorMode,
+      'pwg:DocumentFormat': format,
+      'scan:DocumentFormatExt': format,
+      'scan:XResolution': resolution,
+      'scan:YResolution': resolution,
+    };
+    if (scanSource !== 'flatbed') settings['scan:Duplex'] = scanSource === 'adf-duplex';
     if (options.format === 'jpeg' && options.quality) {
-      xml += `
-  <scan:CompressionFactor>${100 - options.quality}</scan:CompressionFactor>`;
+      settings['scan:CompressionFactor'] = 100 - options.quality;
     }
+    return `<?xml version="1.0" encoding="UTF-8"?>\n${xmlBuilder.build({ 'scan:ScanSettings': settings })}`;
+  }
 
-    xml += `
-</scan:ScanSettings>`;
-
-    return xml;
+  private mapIntent(intent: IScanOptions['intent']): string {
+    if (intent === 'photo') return 'Photo';
+    if (intent === 'preview') return 'Preview';
+    return 'Document';
   }
 
-  /**
-   * Map source to eSCL format
-   */
-  private mapSource(source: string): string {
-    switch (source) {
-      case 'flatbed':
-        return 'Platen';
-      case 'adf':
-        return 'Feeder';
-      case 'adf-duplex':
-        return 'Duplex';
-      default:
-        return 'Platen';
-    }
+  private nextDocumentDelay(source: IScanOptions['source'], requestDuration: number): number {
+    const isBrother = this.capabilities?.makeAndModel.toLowerCase().startsWith('brother ');
+    if (!isBrother || source === 'flatbed') return 0;
+    return Math.min(Math.round(requestDuration * 0.5), 1000);
   }
 
   /**
    * Parse capabilities XML response
    */
   private parseCapabilities(body: string): IEsclCapabilities {
-    const xml = body;
+    const document = asRecord(xmlParser.parse(body));
+    const root = asRecord(document.ScannerCapabilities);
+    const platen = asRecord(asRecord(root.Platen).PlatenInputCaps);
+    const adfRoot = asRecord(root.Adf);
+    const adf = asRecord(adfRoot.AdfSimplexInputCaps);
+    const adfDuplex = asRecord(adfRoot.AdfDuplexInputCaps);
 
-    // Simple XML parsing without full XML parser
-    const getTagContent = (tag: string): string => {
-      const regex = new RegExp(`<[^:]*:?${tag}[^>]*>([^<]*)<`, 'i');
-      const match = xml.match(regex);
-      return match?.[1]?.trim() ?? '';
-    };
-
-    const getAllTagContents = (tag: string): string[] => {
-      const regex = new RegExp(`<[^:]*:?${tag}[^>]*>([^<]*)<`, 'gi');
-      const matches: string[] = [];
-      let match;
-      while ((match = regex.exec(xml)) !== null) {
-        if (match[1]?.trim()) {
-          matches.push(match[1].trim());
-        }
-      }
-      return matches;
-    };
-
-    const parseResolutions = (): number[] => {
-      const resolutions = getAllTagContents('XResolution');
-      return [...new Set(resolutions.map((r) => parseInt(r)).filter((r) => !isNaN(r)))];
+    return {
+      version: asText(root.Version) || '2.0',
+      makeAndModel: asText(root.MakeAndModel) || asText(root.Make) || 'Unknown',
+      serialNumber: asText(root.SerialNumber) || undefined,
+      uuid: asText(root.UUID) || undefined,
+      adminUri: asText(root.AdminURI) || undefined,
+      iconUri: asText(root.IconURI) || undefined,
+      platen: Object.keys(platen).length > 0 ? this.parseInputSource(platen, 215.9, 297) : undefined,
+      adf: Object.keys(adf).length > 0 ? this.parseInputSource(adf, 215.9, 355.6) : undefined,
+      adfDuplex: Object.keys(adfDuplex).length > 0
+        ? this.parseInputSource(adfDuplex, 215.9, 355.6)
+        : undefined,
     };
+  }
 
+  private parseInputSource(source: TXmlRecord, defaultWidth: number, defaultHeight: number) {
+    const resolutions = collectValues(source, 'XResolution')
+      .map((value) => asInteger(value))
+      .filter((value) => value > 0);
+    const colorModes = collectValues(source, 'ColorMode').map(asText).filter(Boolean);
+    const documentFormats = [
+      ...collectValues(source, 'DocumentFormat'),
+      ...collectValues(source, 'DocumentFormatExt'),
+    ].map(asText).filter(Boolean);
     return {
-      version: getTagContent('Version') || '2.0',
-      makeAndModel: getTagContent('MakeAndModel') || getTagContent('Make') || 'Unknown',
-      serialNumber: getTagContent('SerialNumber') || undefined,
-      uuid: getTagContent('UUID') || undefined,
-      adminUri: getTagContent('AdminURI') || undefined,
-      iconUri: getTagContent('IconURI') || undefined,
-      platen: xml.includes('Platen')
-        ? {
-            minWidth: parseInt(getTagContent('MinWidth')) || 0,
-            maxWidth: parseInt(getTagContent('MaxWidth')) || 2550,
-            minHeight: parseInt(getTagContent('MinHeight')) || 0,
-            maxHeight: parseInt(getTagContent('MaxHeight')) || 3508,
-            maxScanRegions: parseInt(getTagContent('MaxScanRegions')) || 1,
-            supportedResolutions: parseResolutions(),
-            colorModes: getAllTagContents('ColorMode'),
-            documentFormats: getAllTagContents('DocumentFormatExt'),
-          }
-        : undefined,
-      adf: xml.includes('Adf') || xml.includes('ADF') || xml.includes('Feeder')
-        ? {
-            minWidth: 0,
-            maxWidth: 2550,
-            minHeight: 0,
-            maxHeight: 4200,
-            maxScanRegions: 1,
-            supportedResolutions: parseResolutions(),
-            colorModes: getAllTagContents('ColorMode'),
-            documentFormats: getAllTagContents('DocumentFormatExt'),
-          }
-        : undefined,
+      minWidth: esclUnitsToMillimetres(source.MinWidth, 0),
+      maxWidth: esclUnitsToMillimetres(source.MaxWidth, defaultWidth),
+      minHeight: esclUnitsToMillimetres(source.MinHeight, 0),
+      maxHeight: esclUnitsToMillimetres(source.MaxHeight, defaultHeight),
+      maxScanRegions: asInteger(source.MaxScanRegions, 1),
+      supportedResolutions: unique(resolutions),
+      colorModes: unique(colorModes),
+      documentFormats: unique(documentFormats),
     };
   }
 
@@ -375,53 +531,52 @@ export class EsclProtocol {
    * Parse status XML response
    */
   private parseStatus(body: string): IEsclScanStatus {
-    const xml = body;
-
-    const getTagContent = (tag: string): string => {
-      const regex = new RegExp(`<[^:]*:?${tag}[^>]*>([^<]*)<`, 'i');
-      const match = xml.match(regex);
-      return match?.[1]?.trim() ?? '';
-    };
-
-    const state = getTagContent('State') || getTagContent('ScannerState') || 'Idle';
-    const adfState = getTagContent('AdfState') || undefined;
-
-    // Parse jobs if present
-    const jobs: IEsclJobInfo[] = [];
-    const jobMatches = xml.match(/<[^:]*:?JobInfo[^>]*>[\s\S]*?<\/[^:]*:?JobInfo>/gi);
-    if (jobMatches) {
-      for (const jobXml of jobMatches) {
-        const getJobTag = (tag: string): string => {
-          const regex = new RegExp(`<[^:]*:?${tag}[^>]*>([^<]*)<`, 'i');
-          const match = jobXml.match(regex);
-          return match?.[1]?.trim() ?? '';
-        };
-
-        jobs.push({
-          jobUri: getJobTag('JobUri') || getJobTag('JobURI') || '',
-          jobUuid: getJobTag('JobUuid') || getJobTag('JobUUID') || '',
-          age: parseInt(getJobTag('Age')) || 0,
-          imagesCompleted: parseInt(getJobTag('ImagesCompleted')) || 0,
-          imagesToTransfer: parseInt(getJobTag('ImagesToTransfer')) || 0,
-          jobState: (getJobTag('JobState') as IEsclJobInfo['jobState']) || 'Pending',
-          jobStateReason: getJobTag('JobStateReason') || undefined,
-        });
-      }
-    }
+    const document = asRecord(xmlParser.parse(body));
+    const root = asRecord(document.ScannerStatus);
+    const state = asText(root.State) || asText(root.ScannerState) || 'Idle';
+    const rawAdfState = asText(root.AdfState).replace(/^ScannerAdf/, '');
+    const jobsRoot = asRecord(root.Jobs);
+    const jobs = asArray(jobsRoot.JobInfo).map((value): IEsclJobInfo => {
+      const job = asRecord(value);
+      const reason = collectValues(job.JobStateReasons, 'JobStateReason').map(asText).find(Boolean);
+      return {
+        jobUri: asText(job.JobUri) || asText(job.JobURI),
+        jobUuid: asText(job.JobUuid) || asText(job.JobUUID),
+        age: asInteger(job.Age),
+        imagesCompleted: asInteger(job.ImagesCompleted),
+        imagesToTransfer: asInteger(job.ImagesToTransfer),
+        jobState: (asText(job.JobState) as IEsclJobInfo['jobState']) || 'Pending',
+        jobStateReason: reason || undefined,
+      };
+    });
 
     return {
       state: state as IEsclScanStatus['state'],
-      adfState: adfState as IEsclScanStatus['adfState'],
+      adfState: rawAdfState ? rawAdfState as IEsclScanStatus['adfState'] : undefined,
       jobs: jobs.length > 0 ? jobs : undefined,
     };
   }
 
+  private resolveJobUri(jobUri: string): string {
+    return new URL(jobUri, `${this.baseUrl}/`).toString();
+  }
+
+  private findJob(status: IEsclScanStatus, jobUri: string): IEsclJobInfo | undefined {
+    const resolved = new URL(this.resolveJobUri(jobUri));
+    const uuid = resolved.pathname.split('/').filter(Boolean).at(-1) || '';
+    return status.jobs?.find((job) => {
+      const candidate = new URL(job.jobUri, `${this.baseUrl}/`);
+      return candidate.pathname === resolved.pathname || job.jobUuid.endsWith(uuid);
+    });
+  }
+
   /**
    * Perform a complete scan operation
    */
   public async scan(options: IScanOptions): Promise<IScanResult> {
     // Submit the job
     const jobUri = await this.submitScanJob(options);
+    this.activeJobUri = jobUri;
 
     try {
       // Wait for completion and download
@@ -434,6 +589,8 @@ export class EsclProtocol {
         // Ignore cancel errors
       }
       throw error;
+    } finally {
+      this.activeJobUri = null;
     }
   }
 }