@ecobridge.xyz/devicemanager 3.1.1 → 3.2.0

package/ts/discovery/discovery.classes.networkscanner.ts

@@ -1,5 +1,5 @@
 import * as plugins from '../plugins.js';
-import { EsclProtocol } from '../protocols/index.js';
+import { BrotherScanProtocol, EsclProtocol } from '../protocols/index.js';
 import {
   cidrToIps,
   ipRangeToIps,
@@ -19,6 +19,7 @@ const DEFAULT_PORTS = [
   631,   // IPP printers
   80,    // eSCL scanners (HTTP)
   443,   // eSCL scanners (HTTPS)
+  54921, // Brother native network scanners
   6566,  // SANE scanners
   9100,  // JetDirect printers
   7000,  // AirPlay speakers
@@ -35,6 +36,7 @@ const DEFAULT_OPTIONS: Required<Omit<INetworkScanOptions, 'ipRange' | 'startIp'
   concurrency: 50,
   timeout: 2000,
   ports: DEFAULT_PORTS,
+  probeBrother: true,
   probeEscl: true,
   probeIpp: true,
   probeSane: true,
@@ -205,6 +207,15 @@ export class NetworkScanner extends plugins.events.EventEmitter {
     const probePromises: Promise<void>[] = [];
 
     for (const port of openPorts) {
+      // Brother native scan service
+      if (opts.probeBrother && port === 54921) {
+        probePromises.push(
+          this.probeBrother(ip, port, timeout).then((device) => {
+            if (device) devices.push(device);
+          })
+        );
+      }
+
       // IPP probe (port 631)
       if (opts.probeIpp && port === 631) {
         probePromises.push(
@@ -282,6 +293,17 @@ export class NetworkScanner extends plugins.events.EventEmitter {
 
     await Promise.all(probePromises);
 
+    // Prefer a vendor transport that enforces scan settings over standards
+    // endpoints whose firmware may silently downgrade those settings.
+    const protocolPriority: Partial<Record<INetworkScanDevice['protocol'], number>> = {
+      brother: 0,
+      escl: 1,
+      sane: 2,
+    };
+    devices.sort((left, right) =>
+      (protocolPriority[left.protocol] ?? 10) - (protocolPriority[right.protocol] ?? 10)
+    );
+
     return devices;
   }
 
@@ -330,6 +352,33 @@ export class NetworkScanner extends plugins.events.EventEmitter {
     });
   }
 
+  /**
+   * Probe for Brother's native network scan service.
+   */
+  private async probeBrother(
+    ip: string,
+    port: number,
+    timeout: number
+  ): Promise<INetworkScanDevice | null> {
+    const brother = new BrotherScanProtocol(ip, port, { timeout, busyTimeout: 0 });
+    try {
+      await brother.connect();
+      return {
+        type: 'scanner',
+        protocol: 'brother',
+        port,
+        name: `Brother Scanner at ${ip}`,
+        model: undefined,
+      };
+    } catch {
+      // A busy endpoint is not selected because connection would fail; eSCL
+      // can still be discovered as a fallback on the same device.
+      return null;
+    } finally {
+      await brother.disconnect();
+    }
+  }
+
   /**
    * Probe for IPP printer using a simple HTTP check
    * Use a minimal request instead of an external IPP client for discovery probing.

package/ts/events/events.observable.ts

@@ -0,0 +1,31 @@
+import * as plugins from '../plugins.js';
+
+export interface IObservableEvent<TName extends string = string> {
+  name: TName;
+  args: readonly unknown[];
+  emittedAt: Date;
+}
+
+/**
+ * EventEmitter-compatible base that mirrors every named event to RxJS.
+ */
+export class ObservableEventEmitter extends plugins.events.EventEmitter {
+  private readonly eventSubject = new plugins.rxjs.Subject<IObservableEvent>();
+
+  public readonly events$ = this.eventSubject.asObservable();
+
+  public override emit(eventName: string | symbol, ...args: unknown[]): boolean {
+    if (typeof eventName === 'string') {
+      this.eventSubject.next({
+        name: eventName,
+        args,
+        emittedAt: new Date(),
+      });
+    }
+    return super.emit(eventName, ...args);
+  }
+
+  protected completeEventStream(): void {
+    this.eventSubject.complete();
+  }
+}

package/ts/events/index.ts

@@ -0,0 +1,4 @@
+export {
+  ObservableEventEmitter,
+  type IObservableEvent,
+} from './events.observable.js';

package/ts/factories/index.ts

@@ -43,10 +43,12 @@ export function createScanner(
   const isSecure = info.txtRecords['TLS'] === '1' || (protocol === 'escl' && info.port === 443);
 
   // Parse capabilities from TXT records
-  const formats = parseScanFormats(info.txtRecords);
-  const resolutions = parseScanResolutions(info.txtRecords);
-  const colorModes = parseScanColorModes(info.txtRecords);
-  const sources = parseScanSources(info.txtRecords);
+  const formats = protocol === 'brother' ? ['jpeg' as const] : parseScanFormats(info.txtRecords);
+  const resolutions = protocol === 'brother' ? [100, 150, 200, 300, 600] : parseScanResolutions(info.txtRecords);
+  const colorModes = protocol === 'brother' ? ['color' as const] : parseScanColorModes(info.txtRecords);
+  const sources = protocol === 'brother'
+    ? ['flatbed' as const, 'adf' as const, 'adf-duplex' as const]
+    : parseScanSources(info.txtRecords);
 
   const device = new UniversalDevice(info.address, info.port, {
     name: info.name,
@@ -60,7 +62,7 @@ export function createScanner(
 
   // Add scan feature
   const scanFeature = new ScanFeature(device.getDeviceReference(), info.port, {
-    protocol: protocol as 'escl' | 'sane',
+    protocol: protocol as 'brother' | 'escl' | 'sane',
     secure: isSecure,
     supportedFormats: formats,
     supportedResolutions: resolutions,

package/ts/features/feature.abstract.ts

@@ -3,7 +3,6 @@
  * Features are composable capabilities that can be attached to devices
  */
 
-import * as plugins from '../plugins.js';
 import type {
   TFeatureType,
   TFeatureState,
@@ -13,6 +12,7 @@ import type {
 } from '../interfaces/feature.interfaces.js';
 import type { IRetryOptions } from '../interfaces/index.js';
 import { withRetry } from '../helpers/helpers.retry.js';
+import { ObservableEventEmitter } from '../events/index.js';
 
 /**
  * Forward reference to Device to avoid circular dependency
@@ -29,7 +29,7 @@ export type TDeviceReference = {
  * Abstract base class for all features
  * Provides common functionality for connection management, state tracking, and retry logic
  */
-export abstract class Feature extends plugins.events.EventEmitter implements IFeature {
+export abstract class Feature extends ObservableEventEmitter implements IFeature {
   /**
    * The feature type identifier
    */

package/ts/features/feature.print.ts

@@ -58,6 +58,9 @@ export class PrintFeature extends Feature {
   // Capabilities
   public supportsColor: boolean = true;
   public supportsDuplex: boolean = false;
+  public airPrintSupported: boolean = false;
+  public supportedDocumentFormats: string[] = [];
+  public supportedResolutions: number[] = [300, 600];
   public supportedMediaSizes: string[] = ['iso_a4_210x297mm', 'na_letter_8.5x11in'];
   public supportedMediaTypes: string[] = ['stationery'];
   public maxCopies: number = 99;
@@ -119,11 +122,13 @@ export class PrintFeature extends Feature {
    */
   public async getCapabilities(): Promise<IPrintCapabilities> {
     return {
+      airPrintSupported: this.airPrintSupported,
       colorSupported: this.supportsColor,
       duplexSupported: this.supportsDuplex,
+      documentFormats: this.supportedDocumentFormats,
       mediaSizes: this.supportedMediaSizes,
       mediaTypes: this.supportedMediaTypes,
-      resolutions: [300, 600],
+      resolutions: this.supportedResolutions,
       maxCopies: this.maxCopies,
       sidesSupported: this.supportedSides,
       qualitySupported: this.supportedQualities,
@@ -212,6 +217,8 @@ export class PrintFeature extends Feature {
   // ============================================================================
 
   private updateCapabilitiesFromIpp(caps: IIppPrinterCapabilities): void {
+    this.airPrintSupported = caps.airPrintSupported;
+    this.supportedDocumentFormats = caps.documentFormatSupported;
     this.supportsColor = caps.colorSupported;
     // Derive duplexSupported from sidesSupported
     this.supportsDuplex = caps.sidesSupported?.some(s =>
@@ -219,6 +226,12 @@ export class PrintFeature extends Feature {
     ) ?? false;
     // Get max copies from range
     this.maxCopies = caps.copiesSupported?.upper ?? 99;
+    const resolutions = caps.resolutionsSupported
+      .filter((resolution) => resolution.units === 'dpi' && resolution.crossFeed === resolution.feed)
+      .map((resolution) => resolution.crossFeed);
+    if (resolutions.length > 0) {
+      this.supportedResolutions = [...new Set(resolutions)].sort((left, right) => left - right);
+    }
 
     if (caps.mediaSizeSupported && caps.mediaSizeSupported.length > 0) {
       this.supportedMediaSizes = caps.mediaSizeSupported;
@@ -274,8 +287,10 @@ export class PrintFeature extends Feature {
       ...this.getBaseFeatureInfo(),
       type: 'print',
       protocol: this.protocol,
+      airPrintSupported: this.airPrintSupported,
       supportsColor: this.supportsColor,
       supportsDuplex: this.supportsDuplex,
+      supportedDocumentFormats: this.supportedDocumentFormats,
       supportedMediaSizes: this.supportedMediaSizes,
     };
   }

package/ts/features/feature.scan.ts

@@ -1,10 +1,11 @@
 /**
  * Scan Feature
- * Provides document scanning capability using eSCL or SANE protocols
+ * Provides document scanning capability using Brother native, eSCL, or SANE protocols
  */
 
 import { Feature, type TDeviceReference } from './feature.abstract.js';
-import { EsclProtocol, SaneProtocol } from '../protocols/index.js';
+import { BrotherScanProtocol, EsclProtocol, SaneProtocol } from '../protocols/index.js';
+import type { IEsclCapabilities } from '../interfaces/index.js';
 import type {
   TScanProtocol,
   TScanFormat,
@@ -35,7 +36,7 @@ export interface IScanFeatureOptions extends IFeatureOptions {
 /**
  * Scan Feature - provides document scanning capability
  *
- * Wraps eSCL (AirScan) or SANE protocols to provide a unified scanning interface.
+ * Wraps Brother native, eSCL (AirScan), or SANE protocols behind one interface.
  *
  * @example
  * ```typescript
@@ -52,6 +53,7 @@ export class ScanFeature extends Feature {
   public readonly protocol: TScanProtocol;
 
   // Protocol clients
+  private brotherClient: BrotherScanProtocol | null = null;
   private esclClient: EsclProtocol | null = null;
   private saneClient: SaneProtocol | null = null;
 
@@ -95,7 +97,11 @@ export class ScanFeature extends Feature {
   // ============================================================================
 
   protected async doConnect(): Promise<void> {
-    if (this.protocol === 'escl') {
+    if (this.protocol === 'brother') {
+      this.brotherClient = new BrotherScanProtocol(this.address, this._port);
+      await this.brotherClient.connect();
+      this.updateCapabilitiesFromBrother(this.brotherClient.getCapabilities());
+    } else if (this.protocol === 'escl') {
       this.esclClient = new EsclProtocol(this.address, this._port, this.isSecure);
       // Fetch capabilities to verify connection
       const caps = await this.esclClient.getCapabilities();
@@ -111,6 +117,10 @@ export class ScanFeature extends Feature {
   }
 
   protected async doDisconnect(): Promise<void> {
+    if (this.brotherClient) {
+      await this.brotherClient.disconnect();
+      this.brotherClient = null;
+    }
     if (this.saneClient) {
       try {
         await this.saneClient.close();
@@ -153,7 +163,9 @@ export class ScanFeature extends Feature {
 
     const opts = this.resolveOptions(options);
 
-    if (this.protocol === 'escl' && this.esclClient) {
+    if (this.protocol === 'brother' && this.brotherClient) {
+      return this.scanWithBrother(opts);
+    } else if (this.protocol === 'escl' && this.esclClient) {
       return this.scanWithEscl(opts);
     } else if (this.protocol === 'sane' && this.saneClient) {
       return this.scanWithSane(opts);
@@ -166,10 +178,13 @@ export class ScanFeature extends Feature {
    * Cancel an ongoing scan
    */
   public async cancelScan(): Promise<void> {
-    if (this.protocol === 'sane' && this.saneClient) {
+    if (this.protocol === 'brother' && this.brotherClient) {
+      await this.brotherClient.cancel();
+    } else if (this.protocol === 'escl' && this.esclClient) {
+      await this.esclClient.cancelCurrentScan();
+    } else if (this.protocol === 'sane' && this.saneClient) {
       await this.saneClient.cancel();
     }
-    // eSCL cancellation is handled by deleting the job
     this.emit('scan:cancelled');
   }
 
@@ -177,6 +192,17 @@ export class ScanFeature extends Feature {
   // Protocol-Specific Scanning
   // ============================================================================
 
+  private async scanWithBrother(options: Required<IScanOptions>): Promise<IScanResult> {
+    if (!this.brotherClient) {
+      throw new Error('Brother scan client not initialized');
+    }
+
+    this.emit('scan:started', options);
+    const result = await this.brotherClient.scan(options);
+    this.emit('scan:completed', result);
+    return result;
+  }
+
   private async scanWithEscl(options: Required<IScanOptions>): Promise<IScanResult> {
     if (!this.esclClient) {
       throw new Error('eSCL client not initialized');
@@ -229,7 +255,9 @@ export class ScanFeature extends Feature {
       resolution: options?.resolution ?? 300,
       format: options?.format ?? 'jpeg',
       colorMode: options?.colorMode ?? 'color',
-      source: options?.source ?? 'flatbed',
+      source: options?.source ?? (
+        this.hasDuplex ? 'adf-duplex' : this.hasAdf ? 'adf' : 'flatbed'
+      ),
       area: options?.area ?? {
         x: 0,
         y: 0,
@@ -241,26 +269,43 @@ export class ScanFeature extends Feature {
     };
   }
 
-  private updateCapabilitiesFromEscl(caps: any): void {
-    if (caps.platen) {
-      this.supportedResolutions = caps.platen.supportedResolutions || this.supportedResolutions;
-      this.maxWidth = caps.platen.maxWidth || this.maxWidth;
-      this.maxHeight = caps.platen.maxHeight || this.maxHeight;
-      this.minWidth = caps.platen.minWidth || this.minWidth;
-      this.minHeight = caps.platen.minHeight || this.minHeight;
-    }
-    if (caps.adf) {
-      this.hasAdf = true;
-      if (!this.supportedSources.includes('adf')) {
-        this.supportedSources.push('adf');
-      }
-    }
-    if (caps.adfDuplex) {
-      this.hasDuplex = true;
-      if (!this.supportedSources.includes('adf-duplex')) {
-        this.supportedSources.push('adf-duplex');
-      }
+  private updateCapabilitiesFromBrother(caps: IScanCapabilities): void {
+    this.supportedResolutions = caps.resolutions;
+    this.supportedFormats = caps.formats;
+    this.supportedColorModes = caps.colorModes;
+    this.supportedSources = caps.sources;
+    this.hasAdf = caps.sources.includes('adf') || caps.sources.includes('adf-duplex');
+    this.hasDuplex = caps.sources.includes('adf-duplex');
+    this.maxWidth = caps.maxWidth;
+    this.maxHeight = caps.maxHeight;
+    this.minWidth = caps.minWidth;
+    this.minHeight = caps.minHeight;
+  }
+
+  private updateCapabilitiesFromEscl(caps: IEsclCapabilities): void {
+    const sources = [caps.platen, caps.adf, caps.adfDuplex].filter((source) => source !== undefined);
+    if (sources.length > 0) {
+      this.supportedResolutions = [...new Set(
+        sources.flatMap((source) => source.supportedResolutions)
+      )].sort((left, right) => left - right);
+      this.maxWidth = Math.max(...sources.map((source) => source.maxWidth));
+      this.maxHeight = Math.max(...sources.map((source) => source.maxHeight));
+      this.minWidth = Math.min(...sources.map((source) => source.minWidth));
+      this.minHeight = Math.min(...sources.map((source) => source.minHeight));
     }
+
+    const supportedSources: TScanSource[] = [];
+    if (caps.platen) supportedSources.push('flatbed');
+    if (caps.adf) supportedSources.push('adf');
+    if (caps.adfDuplex) supportedSources.push('adf-duplex');
+    if (supportedSources.length > 0) this.supportedSources = supportedSources;
+    this.hasAdf = Boolean(caps.adf || caps.adfDuplex);
+    this.hasDuplex = Boolean(caps.adfDuplex);
+
+    const formats = mapDocumentFormats(sources.flatMap((source) => source.documentFormats));
+    const colorModes = mapColorModes(sources.flatMap((source) => source.colorModes));
+    if (formats.length > 0) this.supportedFormats = formats;
+    if (colorModes.length > 0) this.supportedColorModes = colorModes;
   }
 
   private colorModeToSane(mode: TColorMode): string {
@@ -329,6 +374,27 @@ export class ScanFeature extends Feature {
   }
 }
 
+function mapDocumentFormats(formats: string[]): TScanFormat[] {
+  const mapped = formats.flatMap((format): TScanFormat[] => {
+    if (format === 'application/pdf') return ['pdf'];
+    if (format === 'image/jpeg') return ['jpeg'];
+    if (format === 'image/png') return ['png'];
+    if (format === 'image/tiff') return ['tiff'];
+    return [];
+  });
+  return [...new Set(mapped)];
+}
+
+function mapColorModes(modes: string[]): TColorMode[] {
+  const mapped = modes.flatMap((mode): TColorMode[] => {
+    if (mode.startsWith('RGB')) return ['color'];
+    if (mode.startsWith('Grayscale')) return ['grayscale'];
+    if (mode.startsWith('BlackAndWhite')) return ['blackwhite'];
+    return [];
+  });
+  return [...new Set(mapped)];
+}
+
 // ============================================================================
 // Parsing Helpers
 // ============================================================================

package/ts/index.ts

@@ -17,6 +17,19 @@ export {
   SSDP_SERVICE_TYPES,
 } from './devicemanager.classes.devicemanager.js';
 
+export {
+  ObservableEventEmitter,
+  type IObservableEvent,
+} from './events/index.js';
+
+export {
+  SmbShareProvider,
+  type ISmbDocumentEvent,
+  type ISmbServerAdapter,
+  type ISmbShareProviderDependencies,
+  type ISmbShareProviderOptions,
+} from './providers/index.js';
+
 // ============================================================================
 // Universal Device & Features
 // ============================================================================
@@ -99,6 +112,9 @@ export {
 
 export {
   EsclProtocol,
+  EsclScanError,
+  BrotherScanProtocol,
+  BrotherScanError,
   SaneProtocol,
   IppProtocol,
   SnmpProtocol,
@@ -114,6 +130,10 @@ export {
   // Home Assistant protocol
   HomeAssistantProtocol,
   type ISnmpOptions,
+  type IBrotherScanLease,
+  type IBrotherScanOptions,
+  type IBrotherScanProtocolOptions,
+  type TBrotherScanErrorCode,
   type ISnmpVarbind,
   type TSnmpValueType,
   type TNutStatusFlag,

package/ts/interfaces/feature.interfaces.ts

@@ -79,7 +79,7 @@ export interface IFeatureInfo {
 // Scan Feature
 // ============================================================================
 
-export type TScanProtocol = 'escl' | 'sane' | 'wia';
+export type TScanProtocol = 'brother' | 'escl' | 'sane' | 'wia';
 export type TScanFormat = 'png' | 'jpeg' | 'pdf' | 'tiff';
 export type TColorMode = 'color' | 'grayscale' | 'blackwhite';
 export type TScanSource = 'flatbed' | 'adf' | 'adf-duplex';
@@ -120,6 +120,23 @@ export interface IScanResult {
   resolution: number;
   colorMode: TColorMode;
   mimeType: string;
+  /** Number of documents returned by a multipage-capable scanner transport */
+  pageCount?: number;
+  /** All returned documents, including the first document exposed as data */
+  pages?: IScanPage[];
+  /** Whether the scanner reported a cleanly completed job */
+  isComplete?: boolean;
+  /** Scanner reason when a partial result is returned with an error */
+  jobStateReason?: string;
+  /** Differences detected between requested and returned scan settings */
+  settingsWarnings?: string[];
+}
+
+export interface IScanPage {
+  data: Buffer;
+  width: number;
+  height: number;
+  mimeType: string;
 }
 
 export interface IScanFeatureInfo extends IFeatureInfo {
@@ -143,8 +160,10 @@ export type TPrintQuality = 'draft' | 'normal' | 'high';
 export type TPrintColorMode = 'color' | 'monochrome';
 
 export interface IPrintCapabilities {
+  airPrintSupported: boolean;
   colorSupported: boolean;
   duplexSupported: boolean;
+  documentFormats: string[];
   mediaSizes: string[];
   mediaTypes: string[];
   resolutions: number[];
@@ -177,8 +196,10 @@ export interface IPrintJob {
 export interface IPrintFeatureInfo extends IFeatureInfo {
   type: 'print';
   protocol: TPrintProtocol;
+  airPrintSupported: boolean;
   supportsColor: boolean;
   supportsDuplex: boolean;
+  supportedDocumentFormats: string[];
   supportedMediaSizes: string[];
 }
 

package/ts/interfaces/index.ts

@@ -14,7 +14,7 @@ export type TConnectionState = 'disconnected' | 'connecting' | 'connected' | 'er
 // Scanner Types
 // ============================================================================
 
-export type TScannerProtocol = 'sane' | 'escl';
+export type TScannerProtocol = 'brother' | 'sane' | 'escl';
 export type TScanFormat = 'png' | 'jpeg' | 'pdf' | 'tiff';
 export type TColorMode = 'color' | 'grayscale' | 'blackwhite';
 export type TScanSource = 'flatbed' | 'adf' | 'adf-duplex';
@@ -105,6 +105,23 @@ export interface IScanResult {
   colorMode: TColorMode;
   /** MIME type */
   mimeType: string;
+  /** Number of documents returned by a multipage-capable scanner transport */
+  pageCount?: number;
+  /** All returned documents, including the first document exposed as data */
+  pages?: IScanPage[];
+  /** Whether the scanner reported a cleanly completed job */
+  isComplete?: boolean;
+  /** Scanner reason when a partial result is returned with an error */
+  jobStateReason?: string;
+  /** Differences detected between requested and returned scan settings */
+  settingsWarnings?: string[];
+}
+
+export interface IScanPage {
+  data: Buffer;
+  width: number;
+  height: number;
+  mimeType: string;
 }
 
 export interface IScannerCapabilities {
@@ -321,8 +338,10 @@ export interface INetworkScanOptions {
   concurrency?: number;
   /** Timeout per probe in milliseconds (default: 2000) */
   timeout?: number;
-  /** Ports to probe (default: [80, 443, 631, 6566, 9100, 7000, 1400, 8009]) */
+  /** Ports to probe (includes Brother native scan on 54921 by default) */
   ports?: number[];
+  /** Check for Brother native network scanners (default: true) */
+  probeBrother?: boolean;
   /** Check for eSCL scanners (default: true) */
   probeEscl?: boolean;
   /** Check for IPP printers (default: true) */
@@ -339,7 +358,7 @@ export interface INetworkScanOptions {
 
 export interface INetworkScanDevice {
   type: 'scanner' | 'printer' | 'speaker';
-  protocol: 'escl' | 'sane' | 'ipp' | 'jetdirect' | 'airplay' | 'sonos' | 'chromecast';
+  protocol: 'brother' | 'escl' | 'sane' | 'ipp' | 'jetdirect' | 'airplay' | 'sonos' | 'chromecast';
   port: number;
   name?: string;
   model?: string;

package/ts/plugins.ts

@@ -17,5 +17,6 @@ export { smartpath, smartdelay };
 import * as bonjourService from 'bonjour-service';
 import * as netSnmp from 'net-snmp';
 import WebSocket from 'ws';
+import * as rxjs from 'rxjs';
 
-export { bonjourService, netSnmp, WebSocket };
+export { bonjourService, netSnmp, WebSocket, rxjs };

package/ts/protocols/index.ts

@@ -4,7 +4,17 @@
  */
 
 // eSCL/AirScan scanner protocol
-export { EsclProtocol } from './protocol.escl.js';
+export { EsclProtocol, EsclScanError } from './protocol.escl.js';
+
+// Brother native network scanner protocol
+export {
+  BrotherScanProtocol,
+  BrotherScanError,
+  type IBrotherScanLease,
+  type IBrotherScanOptions,
+  type IBrotherScanProtocolOptions,
+  type TBrotherScanErrorCode,
+} from './protocol.brother.js';
 
 // SANE network scanner protocol
 export { SaneProtocol } from './protocol.sane.js';