@ecobridge.xyz/devicemanager 3.1.1 → 3.2.0

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();

package/test/test.node.ts

@@ -32,6 +32,7 @@ tap.test('should export device factories', async () => {
 
 tap.test('should export protocol implementations', async () => {
   expect(devicemanager.EsclProtocol).toBeDefined();
+  expect(devicemanager.BrotherScanProtocol).toBeDefined();
   expect(devicemanager.SaneProtocol).toBeDefined();
   expect(devicemanager.IppProtocol).toBeDefined();
   expect(devicemanager.SnmpProtocol).toBeDefined();
@@ -153,6 +154,22 @@ tap.test('should create Scanner device using factory', async () => {
   expect(scanFeature.protocol).toEqual('escl');
 });
 
+tap.test('duplex-capable scanners default to duplex ADF', async () => {
+  const scanner = devicemanager.createScanner({
+    id: 'test:brother-scanner:1',
+    name: 'Brother Scanner',
+    address: '192.168.1.101',
+    port: 54921,
+    protocol: 'brother',
+    txtRecords: {},
+  });
+  const scanFeature = scanner.selectFeature<devicemanager.ScanFeature>('scan');
+  const defaults = (scanFeature as unknown as {
+    resolveOptions(options?: devicemanager.IScanOptions): Required<devicemanager.IScanOptions>;
+  }).resolveOptions();
+  expect(defaults.source).toEqual('adf-duplex');
+});
+
 // Test Printer creation using factory
 tap.test('should create Printer device using factory', async () => {
   const printer = devicemanager.createPrinter({

package/test/test.smb.node.ts

@@ -0,0 +1,123 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { filter, firstValueFrom, take, timeout, toArray } from 'rxjs';
+import {
+  DeviceManager,
+  type ISmbServerAdapter,
+  type ISmbShareProviderOptions,
+} from '../ts/index.js';
+
+class FakeSmbServer implements ISmbServerAdapter {
+  public running = false;
+
+  constructor(private readonly options: ISmbShareProviderOptions) {}
+
+  public async start() {
+    this.running = true;
+    return {
+      host: this.options.host ?? '127.0.0.1',
+      port: this.options.port ?? 445,
+      address: `smb://${this.options.host ?? '127.0.0.1'}:${this.options.port ?? 445}`,
+      shares: this.options.shares.map((share) => share.name),
+    };
+  }
+
+  public async stop(): Promise<void> {
+    this.running = false;
+  }
+
+  public async status() {
+    return {
+      running: this.running,
+      host: this.options.host,
+      port: this.options.port,
+      shares: this.options.shares.map((share) => share.name),
+    };
+  }
+
+  public getConnectionOptions() {
+    return {
+      host: this.options.host ?? '127.0.0.1',
+      port: this.options.port ?? 445,
+    };
+  }
+}
+
+tap.test('SMB provider emits settled documents through provider and manager RxJS streams', async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'devicemanager-smb-'));
+  const sharePath = path.join(tempRoot, 'scans');
+  const manager = new DeviceManager({ autoDiscovery: false });
+  const options: ISmbShareProviderOptions = {
+    host: '127.0.0.1',
+    port: 1445,
+    shares: [{ name: 'brother-scans', path: sharePath }],
+    pollIntervalMs: 20,
+    settleTimeMs: 60,
+  };
+
+  const provider = await manager.provideSmbShares(options, {
+    serverFactory: (serverOptions) => new FakeSmbServer({ ...options, ...serverOptions }),
+  });
+
+  try {
+    const providerEventPromise = firstValueFrom(provider.documents$.pipe(timeout({ first: 3000 })));
+    const managerEventPromise = firstValueFrom(manager.events$.pipe(
+      filter((event) => event.name === 'smb:document:arrived'),
+      timeout({ first: 3000 })
+    ));
+
+    const documentPath = path.join(sharePath, 'nested', 'scan.pdf');
+    await fs.mkdir(path.dirname(documentPath), { recursive: true });
+    await fs.writeFile(documentPath, 'first');
+    await new Promise((resolve) => setTimeout(resolve, 35));
+    await fs.appendFile(documentPath, '-complete');
+
+    const providerEvent = await providerEventPromise;
+    const managerEvent = await managerEventPromise;
+    expect(providerEvent.shareName).toEqual('brother-scans');
+    expect(providerEvent.relativePath).toEqual('nested/scan.pdf');
+    expect(providerEvent.size).toEqual('first-complete'.length);
+    expect((managerEvent.args[0] as { absolutePath: string }).absolutePath).toEqual(documentPath);
+  } finally {
+    await manager.stopSmbShareProvider(provider);
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+tap.test('SMB provider keeps document events distinct for shares with the same path', async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'devicemanager-smb-shares-'));
+  const manager = new DeviceManager({ autoDiscovery: false });
+  const options: ISmbShareProviderOptions = {
+    host: '127.0.0.1',
+    port: 1445,
+    shares: [
+      { name: 'scanner-a', path: tempRoot },
+      { name: 'scanner-b', path: tempRoot },
+    ],
+    pollIntervalMs: 20,
+    settleTimeMs: 40,
+  };
+
+  const provider = await manager.provideSmbShares(options, {
+    serverFactory: (serverOptions) => new FakeSmbServer({ ...options, ...serverOptions }),
+  });
+
+  try {
+    const eventsPromise = firstValueFrom(provider.documents$.pipe(
+      take(2),
+      toArray(),
+      timeout({ first: 3000 })
+    ));
+
+    await fs.writeFile(path.join(tempRoot, 'scan.pdf'), 'complete');
+    const events = await eventsPromise;
+    expect(events.map((event) => event.shareName).sort()).toEqual(['scanner-a', 'scanner-b']);
+  } finally {
+    await manager.stopSmbShareProvider(provider);
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+export default tap.start();

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@ecobridge.xyz/devicemanager',
-  version: '3.1.1',
+  version: '3.2.0',
   description: 'a device manager for talking to devices on network and over usb'
 }

package/ts/device/device.classes.device.ts

@@ -3,7 +3,6 @@
  * A device is a network endpoint that can have multiple features (capabilities)
  */
 
-import * as plugins from '../plugins.js';
 import type {
   TFeatureType,
   IFeatureInfo,
@@ -11,6 +10,7 @@ import type {
 } from '../interfaces/feature.interfaces.js';
 import type { TDeviceStatus, IRetryOptions } from '../interfaces/index.js';
 import { Feature, type TDeviceReference } from '../features/feature.abstract.js';
+import { ObservableEventEmitter } from '../events/index.js';
 
 // ============================================================================
 // Device Info Interface
@@ -69,7 +69,7 @@ export interface IDeviceCreateOptions {
  * }
  * ```
  */
-export class UniversalDevice extends plugins.events.EventEmitter {
+export class UniversalDevice extends ObservableEventEmitter {
   // ============================================================================
   // Properties
   // ============================================================================

package/ts/devicemanager.classes.devicemanager.ts

@@ -40,6 +40,12 @@ import type {
   TFeatureType,
   IDeviceSelector,
 } from './interfaces/index.js';
+import { ObservableEventEmitter } from './events/index.js';
+import {
+  SmbShareProvider,
+  type ISmbShareProviderDependencies,
+  type ISmbShareProviderOptions,
+} from './providers/index.js';
 
 /**
  * Default device manager options
@@ -132,10 +138,12 @@ function makeDeviceRef(address: string, port: number, name: string): { id: strin
  * via multiple methods (mDNS, SSDP, IP scan), features are merged into a
  * single UniversalDevice instance.
  */
-export class DeviceManager extends plugins.events.EventEmitter {
+export class DeviceManager extends ObservableEventEmitter {
   private mdnsDiscovery: MdnsDiscovery;
   private ssdpDiscovery: SsdpDiscovery;
   private _networkScanner: NetworkScanner | null = null;
+  private readonly smbProviders = new Set<SmbShareProvider>();
+  private readonly smbProviderSubscriptions = new Map<SmbShareProvider, plugins.rxjs.Subscription>();
 
   // Devices keyed by IP address for deduplication
   private devicesByIp: Map<string, UniversalDevice> = new Map();
@@ -772,6 +780,61 @@ export class DeviceManager extends plugins.events.EventEmitter {
     return this.getDevicesWithFeature('snmp');
   }
 
+  // ============================================================================
+  // Host-side SMB providers
+  // ============================================================================
+
+  /**
+   * Start an SMB server and forward its events through this manager as `smb:*`.
+   */
+  public async provideSmbShares(
+    options: ISmbShareProviderOptions,
+    dependencies?: ISmbShareProviderDependencies
+  ): Promise<SmbShareProvider> {
+    const provider = new SmbShareProvider(options, dependencies);
+    const subscription = provider.events$.subscribe((event) => {
+      this.emit(`smb:${event.name}`, ...event.args);
+    });
+
+    try {
+      await provider.start();
+      this.smbProviders.add(provider);
+      this.smbProviderSubscriptions.set(provider, subscription);
+      return provider;
+    } catch (error) {
+      subscription.unsubscribe();
+      throw error;
+    }
+  }
+
+  /** Stop one SMB provider created by this manager. */
+  public async stopSmbShareProvider(provider: SmbShareProvider): Promise<void> {
+    try {
+      await provider.stop();
+    } finally {
+      this.smbProviderSubscriptions.get(provider)?.unsubscribe();
+      this.smbProviderSubscriptions.delete(provider);
+      this.smbProviders.delete(provider);
+    }
+  }
+
+  /** Stop every SMB provider owned by this manager. */
+  public async stopAllSmbShareProviders(): Promise<void> {
+    const results = await Promise.allSettled(
+      [...this.smbProviders].map((provider) => this.stopSmbShareProvider(provider))
+    );
+    const failures = results
+      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+      .map((result) => result.reason as unknown);
+    if (failures.length > 0) {
+      throw new AggregateError(failures, 'One or more SMB providers failed to stop cleanly.');
+    }
+  }
+
+  public getSmbShareProviders(): SmbShareProvider[] {
+    return [...this.smbProviders];
+  }
+
   // ============================================================================
   // Manual Device Addition
   // ============================================================================
@@ -807,7 +870,7 @@ export class DeviceManager extends plugins.events.EventEmitter {
   public async addScanner(
     address: string,
     port: number,
-    protocol: 'escl' | 'sane' = 'escl',
+    protocol: 'brother' | 'escl' | 'sane' = 'escl',
     name?: string
   ): Promise<UniversalDevice> {
     const feature = new ScanFeature(
@@ -1071,7 +1134,7 @@ export class DeviceManager extends plugins.events.EventEmitter {
             device = await this.addScanner(
               result.address,
               deviceInfo.port,
-              deviceInfo.protocol as 'escl' | 'sane',
+              deviceInfo.protocol as 'brother' | 'escl' | 'sane',
               deviceInfo.name
             );
           } else if (deviceInfo.type === 'printer' && deviceInfo.protocol === 'ipp') {
@@ -1098,7 +1161,8 @@ export class DeviceManager extends plugins.events.EventEmitter {
 
   /**
    * Discover scanners in a subnet and add them to the manager.
-   * Convenience method that focuses discovery on scanner protocols only (eSCL, SANE).
+   * Convenience method that focuses discovery on scanner protocols only
+   * (Brother native, eSCL/AirScan, and SANE).
    *
    * @param subnet CIDR notation subnet (e.g., '192.168.1.0/24')
    * @param options Optional discovery settings
@@ -1118,6 +1182,7 @@ export class DeviceManager extends plugins.events.EventEmitter {
   ): Promise<UniversalDevice[]> {
     await this.scanNetwork({
       ipRange: subnet,
+      probeBrother: true,
       probeEscl: true,
       probeSane: true,
       probeIpp: false,
@@ -1145,6 +1210,7 @@ export class DeviceManager extends plugins.events.EventEmitter {
   ): Promise<UniversalDevice[]> {
     await this.scanNetwork({
       ipRange: subnet,
+      probeBrother: false,
       probeEscl: false,
       probeSane: false,
       probeIpp: true,
@@ -1217,10 +1283,19 @@ export class DeviceManager extends plugins.events.EventEmitter {
    * Stop discovery and disconnect all devices
    */
   public async shutdown(): Promise<void> {
-    await this.stopDiscovery();
-    await this.disconnectAll();
+    const results = await Promise.allSettled([
+      this.stopDiscovery(),
+      this.stopAllSmbShareProviders(),
+      this.disconnectAll(),
+    ]);
     this.devicesByIp.clear();
     this.nameSourceByIp.clear();
+    const failures = results
+      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+      .map((result) => result.reason as unknown);
+    if (failures.length > 0) {
+      throw new AggregateError(failures, 'DeviceManager shutdown was incomplete.');
+    }
   }
 }