@jikko/ai-camera 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MAKEITALL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# @jikko/ai-camera
+
+JIKKO AI Camera SDK입니다. 카메라 시리얼 프로토콜을 파싱하는 `core`와 브라우저 Web Serial API로 카메라에 연결하는 `web` 어댑터를 제공합니다.
+
+이 패키지는 게임 규칙을 포함하지 않습니다. `CLEAR`, `BATTERY`, `ANTENA`, `COOLANT` 같은 카드 의미는 각 프로젝트에서 `classId`를 받아 매핑해야 합니다.
+
+## 설치
+
+```bash
+npm install @jikko/ai-camera
+```
+
+## WebSerial 사용
+
+```js
+import { createWebSerialCamera } from '@jikko/ai-camera/web'
+
+const camera = createWebSerialCamera({
+  baudRate: 9600,
+  emitRawChunks: true
+})
+
+camera.on('classification', (event) => {
+  console.log(event.classId, event.score)
+})
+
+camera.on('detection', (event) => {
+  console.log(event.classId, event.centerX, event.centerY)
+})
+
+camera.on('packet', (packet) => {
+  console.log(packet.command, packet.length, packet.data)
+})
+
+camera.on('error', (event) => {
+  console.error(event.code, event.message)
+})
+
+await camera.connect()
+```
+
+Web Serial API는 Chrome/Edge 계열 브라우저와 HTTPS 또는 localhost 환경이 필요합니다.
+
+## Parser만 사용
+
+```js
+import { JikkoProtocolParser, parsePacketResults } from '@jikko/ai-camera/core'
+
+const parser = new JikkoProtocolParser()
+const packets = parser.feedChunk(bytes)
+
+for (const packet of packets) {
+  const parsed = parsePacketResults(packet)
+  console.log(parsed.classifications, parsed.detections)
+}
+```
+
+## 패킷 구조
+
+```txt
+START  CMD  LEN_L  LEN_H  DATA...  CRC_0  CRC_1  CRC_2  CRC_3  END
+0xFD   1B   1B     1B     LEN      4B little-endian          0xED
+```
+
+명령:
+
+```txt
+0x00 KEYPOINT_BOX_DETECTION
+0x01 CLASSIFICATION
+0x02 DETECTION
+```
+
+현재 v0.1은 CRC 값을 읽어서 `packet.crc`로 제공합니다. CRC 검증은 아직 수행하지 않습니다.
+
+## 개발
+
+```bash
+npm install
+npm test
+```

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@jikko/ai-camera",
+  "version": "0.1.0",
+  "description": "JIKKO AI Camera protocol parser and WebSerial adapter.",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./core": {
+      "types": "./src/core/index.d.ts",
+      "import": "./src/core/index.js"
+    },
+    "./web": {
+      "types": "./src/web/index.d.ts",
+      "import": "./src/web/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/makeitall-dev/JIKKO_AI_CAMERA_SDK.git"
+  },
+  "keywords": [
+    "jikko",
+    "ai-camera",
+    "webserial",
+    "serial"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/makeitall-dev/JIKKO_AI_CAMERA_SDK/issues"
+  },
+  "homepage": "https://github.com/makeitall-dev/JIKKO_AI_CAMERA_SDK#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/core/format.js

@@ -0,0 +1,33 @@
+import { getCommandName } from './protocol.js'
+
+export function formatByteHex(byte) {
+  return Number(byte).toString(16).padStart(2, '0').toUpperCase()
+}
+
+export function formatBytesAsHex(bytes) {
+  if (!bytes || bytes.length === 0) return ''
+  return Array.from(bytes, formatByteHex).join(' ')
+}
+
+export function formatBytesAsAscii(bytes) {
+  if (!bytes || bytes.length === 0) return ''
+
+  return Array.from(bytes, (byte) => {
+    if (byte >= 32 && byte <= 126) return String.fromCharCode(byte)
+    if (byte === 10) return '\\n'
+    if (byte === 13) return '\\r'
+    return '.'
+  }).join('')
+}
+
+export function formatCrc(value) {
+  return `0x${(Number(value) >>> 0).toString(16).padStart(8, '0').toUpperCase()}`
+}
+
+export function formatPacket(packet) {
+  if (!packet) return ''
+
+  const command = packet.command || getCommandName(packet.cmd)
+  return `${command} / len ${packet.length} / data ${formatBytesAsHex(packet.data)} / crc ${formatCrc(packet.crc)}`
+}
+

package/src/core/index.d.ts

@@ -0,0 +1,66 @@
+export const JIKKO_PACKET_START: 0xFD
+export const JIKKO_PACKET_END: 0xED
+
+export const JikkoCameraCommand: {
+  readonly KEYPOINT_BOX_DETECTION: 0x00
+  readonly CLASSIFICATION: 0x01
+  readonly DETECTION: 0x02
+}
+
+export type JikkoCommandName =
+  | 'KEYPOINT_BOX_DETECTION'
+  | 'CLASSIFICATION'
+  | 'DETECTION'
+  | 'UNKNOWN'
+
+export type JikkoPacket = {
+  start: 0xFD
+  cmd: number
+  command: JikkoCommandName
+  length: number
+  data: Uint8Array
+  crc: number
+  end: 0xED
+  receivedAt: number
+}
+
+export type ClassificationResult = {
+  type: number
+  classId: number
+  score: number
+  index: number
+}
+
+export type DetectionResult = {
+  type: number
+  classId: number
+  centerX: number
+  centerY: number
+  width: number
+  height: number
+  score: number
+  index: number
+}
+
+export type ParsedPacketResults = {
+  packet: JikkoPacket
+  classifications: ClassificationResult[]
+  detections: DetectionResult[]
+}
+
+export class JikkoProtocolParser {
+  feed(byte: number): JikkoPacket | null
+  feedChunk(bytes: Iterable<number>): JikkoPacket[]
+  reset(): void
+}
+
+export function getCommandName(cmd: number): JikkoCommandName
+export function parseClassificationResults(packet: JikkoPacket): ClassificationResult[]
+export function parseDetectionResults(packet: JikkoPacket): DetectionResult[]
+export function parsePacketResults(packet: JikkoPacket): ParsedPacketResults
+export function formatByteHex(byte: number): string
+export function formatBytesAsAscii(bytes: Iterable<number>): string
+export function formatBytesAsHex(bytes: Iterable<number>): string
+export function formatCrc(value: number): string
+export function formatPacket(packet: JikkoPacket): string
+

package/src/core/index.js

@@ -0,0 +1,20 @@
+export {
+  JIKKO_PACKET_END,
+  JIKKO_PACKET_START,
+  JikkoCameraCommand,
+  JikkoProtocolParser,
+  getCommandName
+} from './protocol.js'
+export {
+  parseClassificationResults,
+  parseDetectionResults,
+  parsePacketResults
+} from './results.js'
+export {
+  formatByteHex,
+  formatBytesAsAscii,
+  formatBytesAsHex,
+  formatCrc,
+  formatPacket
+} from './format.js'
+

package/src/core/protocol.js

@@ -0,0 +1,132 @@
+export const JIKKO_PACKET_START = 0xFD
+export const JIKKO_PACKET_END = 0xED
+
+export const JikkoCameraCommand = Object.freeze({
+  KEYPOINT_BOX_DETECTION: 0x00,
+  CLASSIFICATION: 0x01,
+  DETECTION: 0x02
+})
+
+const commandNames = Object.freeze({
+  [JikkoCameraCommand.KEYPOINT_BOX_DETECTION]: 'KEYPOINT_BOX_DETECTION',
+  [JikkoCameraCommand.CLASSIFICATION]: 'CLASSIFICATION',
+  [JikkoCameraCommand.DETECTION]: 'DETECTION'
+})
+
+const ReceiveState = Object.freeze({
+  WAIT_START: 0,
+  HEAD: 1,
+  DATA: 2,
+  CRC: 3,
+  END: 4
+})
+
+export function getCommandName(cmd) {
+  return commandNames[cmd] || 'UNKNOWN'
+}
+
+function readUint32LE(bytes) {
+  return (
+    (bytes[0] |
+      (bytes[1] << 8) |
+      (bytes[2] << 16) |
+      (bytes[3] << 24)) >>> 0
+  )
+}
+
+export class JikkoProtocolParser {
+  constructor() {
+    this.reset()
+  }
+
+  feed(byte) {
+    const normalizedByte = Number(byte) & 0xFF
+
+    switch (this.state) {
+      case ReceiveState.WAIT_START:
+        if (normalizedByte === JIKKO_PACKET_START) {
+          this.currentPacket = {
+            start: normalizedByte,
+            cmd: 0,
+            command: 'UNKNOWN',
+            length: 0,
+            data: new Uint8Array(),
+            crc: 0,
+            end: 0,
+            receivedAt: Date.now()
+          }
+          this.receiveBuffer = []
+          this.state = ReceiveState.HEAD
+        }
+        break
+
+      case ReceiveState.HEAD:
+        this.receiveBuffer.push(normalizedByte)
+        if (this.receiveBuffer.length === 3) {
+          const cmd = this.receiveBuffer[0]
+          this.currentPacket.cmd = cmd
+          this.currentPacket.command = getCommandName(cmd)
+          this.currentPacket.length = this.receiveBuffer[1] | (this.receiveBuffer[2] << 8)
+          this.receiveBuffer = []
+          this.state = this.currentPacket.length === 0 ? ReceiveState.CRC : ReceiveState.DATA
+        }
+        break
+
+      case ReceiveState.DATA:
+        this.receiveBuffer.push(normalizedByte)
+        if (this.receiveBuffer.length === this.currentPacket.length) {
+          this.currentPacket.data = Uint8Array.from(this.receiveBuffer)
+          this.receiveBuffer = []
+          this.state = ReceiveState.CRC
+        }
+        break
+
+      case ReceiveState.CRC:
+        this.receiveBuffer.push(normalizedByte)
+        if (this.receiveBuffer.length === 4) {
+          this.currentPacket.crc = readUint32LE(this.receiveBuffer)
+          this.receiveBuffer = []
+          this.state = ReceiveState.END
+        }
+        break
+
+      case ReceiveState.END:
+        if (normalizedByte === JIKKO_PACKET_END) {
+          const packet = {
+            ...this.currentPacket,
+            end: normalizedByte,
+            receivedAt: Date.now()
+          }
+          this.reset()
+          return packet
+        }
+        this.reset()
+        break
+
+      default:
+        this.reset()
+        break
+    }
+
+    return null
+  }
+
+  feedChunk(bytes) {
+    const packets = []
+    if (!bytes) return packets
+
+    for (const byte of bytes) {
+      const packet = this.feed(byte)
+      if (packet) packets.push(packet)
+    }
+
+    return packets
+  }
+
+  reset() {
+    this.state = ReceiveState.WAIT_START
+    this.currentPacket = null
+    this.receiveBuffer = []
+  }
+}
+

package/src/core/results.js

@@ -0,0 +1,112 @@
+import { JikkoCameraCommand } from './protocol.js'
+
+function toByteArray(data) {
+  if (!data) return []
+  return Array.from(data, (byte) => Number(byte) & 0xFF)
+}
+
+function readUint16LE(data, offset) {
+  return (data[offset] ?? 0) | ((data[offset + 1] ?? 0) << 8)
+}
+
+export function parseClassificationResults(packet) {
+  if (!packet || packet.cmd !== JikkoCameraCommand.CLASSIFICATION) return []
+
+  const data = toByteArray(packet.data)
+  const results = []
+
+  if (data.length >= 3 && data.length % 3 === 0) {
+    for (let offset = 0; offset + 2 < data.length; offset += 3) {
+      results.push({
+        type: data[offset],
+        classId: data[offset + 1],
+        score: data[offset + 2],
+        index: results.length
+      })
+    }
+    return results
+  }
+
+  if (typeof data[1] !== 'undefined') {
+    results.push({
+      type: data[0] ?? 0,
+      classId: data[1],
+      score: data[2] ?? 0,
+      index: 0
+    })
+  }
+
+  for (let offset = 3; offset < data.length; offset += 2) {
+    results.push({
+      type: data[offset - 1] ?? 0,
+      classId: data[offset],
+      score: data[offset + 1] ?? 0,
+      index: results.length
+    })
+  }
+
+  return results
+}
+
+export function parseDetectionResults(packet) {
+  if (!packet || packet.cmd !== JikkoCameraCommand.DETECTION) return []
+
+  const data = toByteArray(packet.data)
+  const results = []
+
+  if (data.length >= 11 && data.length % 11 === 0) {
+    for (let offset = 0; offset + 10 < data.length; offset += 11) {
+      results.push({
+        type: data[offset],
+        classId: data[offset + 1],
+        centerX: readUint16LE(data, offset + 2),
+        centerY: readUint16LE(data, offset + 4),
+        width: readUint16LE(data, offset + 6),
+        height: readUint16LE(data, offset + 8),
+        score: data[offset + 10],
+        index: results.length
+      })
+    }
+    return results
+  }
+
+  if (data.length >= 11 && (data.length - 1) % 10 === 0) {
+    for (let offset = 1; offset + 9 < data.length; offset += 10) {
+      results.push({
+        type: data[0],
+        classId: data[offset],
+        centerX: readUint16LE(data, offset + 1),
+        centerY: readUint16LE(data, offset + 3),
+        width: readUint16LE(data, offset + 5),
+        height: readUint16LE(data, offset + 7),
+        score: data[offset + 9],
+        index: results.length
+      })
+    }
+    return results
+  }
+
+  for (let offset = 1; offset + 5 < data.length; offset += 6) {
+    results.push({
+      type: data[offset - 1] ?? 0,
+      classId: data[offset],
+      centerX: data[offset + 1],
+      centerY: data[offset + 2],
+      width: data[offset + 3],
+      height: data[offset + 4],
+      score: data[offset + 5],
+      index: results.length
+    })
+  }
+
+  return results
+}
+
+export function parsePacketResults(packet) {
+  return {
+    packet,
+    classifications: parseClassificationResults(packet),
+    detections: parseDetectionResults(packet)
+  }
+}
+

package/src/index.d.ts

@@ -0,0 +1,19 @@
+export * from './core/index.js'
+export {
+  WebSerialCamera,
+  createWebSerialCamera,
+  isWebSerialSupported
+} from './web/index.js'
+export type {
+  CameraErrorCode,
+  CameraErrorEvent,
+  CameraEventMap,
+  CameraStatus,
+  CameraStatusEvent,
+  ClassificationEvent,
+  ClassificationsEvent,
+  DetectionEvent,
+  DetectionsEvent,
+  RawChunkEvent,
+  WebSerialCameraOptions
+} from './web/index.js'

package/src/index.js

@@ -0,0 +1,6 @@
+export * from './core/index.js'
+export {
+  WebSerialCamera,
+  createWebSerialCamera,
+  isWebSerialSupported
+} from './web/index.js'

package/src/web/index.d.ts

@@ -0,0 +1,95 @@
+import type {
+  ClassificationResult,
+  DetectionResult,
+  JikkoPacket
+} from '../core/index.js'
+
+export type CameraStatus =
+  | 'idle'
+  | 'unsupported'
+  | 'connecting'
+  | 'connected'
+  | 'disconnecting'
+  | 'disconnected'
+  | 'error'
+
+export type CameraErrorCode =
+  | 'UNSUPPORTED'
+  | 'PERMISSION_DENIED'
+  | 'PORT_OPEN_FAILED'
+  | 'READ_FAILED'
+
+export type CameraStatusEvent = {
+  status: CameraStatus
+  isConnected: boolean
+  receivedAt: number
+}
+
+export type CameraErrorEvent = {
+  code: CameraErrorCode
+  message: string
+  cause?: unknown
+  receivedAt: number
+}
+
+export type RawChunkEvent = {
+  bytes: Uint8Array
+  receivedAt: number
+}
+
+export type ClassificationEvent = ClassificationResult & {
+  packet: JikkoPacket
+  receivedAt: number
+}
+
+export type ClassificationsEvent = {
+  results: ClassificationResult[]
+  packet: JikkoPacket
+  receivedAt: number
+}
+
+export type DetectionEvent = DetectionResult & {
+  packet: JikkoPacket
+  receivedAt: number
+}
+
+export type DetectionsEvent = {
+  results: DetectionResult[]
+  packet: JikkoPacket
+  receivedAt: number
+}
+
+export type CameraEventMap = {
+  status: CameraStatusEvent
+  error: CameraErrorEvent
+  raw: RawChunkEvent
+  packet: JikkoPacket
+  classification: ClassificationEvent
+  classifications: ClassificationsEvent
+  detection: DetectionEvent
+  detections: DetectionsEvent
+}
+
+export type WebSerialCameraOptions = {
+  baudRate?: number
+  emitRawChunks?: boolean
+  filters?: SerialPortFilter[]
+  serial?: Serial
+}
+
+export class WebSerialCamera {
+  constructor(options?: WebSerialCameraOptions)
+  connect(): Promise<void>
+  disconnect(): Promise<void>
+  getStatus(): CameraStatus
+  isConnected(): boolean
+  getLastPacket(): JikkoPacket | null
+  on<EventName extends keyof CameraEventMap>(
+    eventName: EventName,
+    handler: (event: CameraEventMap[EventName]) => void
+  ): () => void
+}
+
+export function createWebSerialCamera(options?: WebSerialCameraOptions): WebSerialCamera
+export function isWebSerialSupported(serial?: Serial | null): boolean
+

package/src/web/index.js

@@ -0,0 +1,6 @@
+export {
+  WebSerialCamera,
+  createWebSerialCamera,
+  isWebSerialSupported
+} from './web-serial.js'
+

package/src/web/web-serial.js

@@ -0,0 +1,282 @@
+import { JikkoProtocolParser } from '../core/protocol.js'
+import { parsePacketResults } from '../core/results.js'
+
+const DEFAULT_BAUD_RATE = 9600
+
+class EventEmitter {
+  constructor() {
+    this.listeners = new Map()
+  }
+
+  on(eventName, handler) {
+    if (!this.listeners.has(eventName)) {
+      this.listeners.set(eventName, new Set())
+    }
+
+    this.listeners.get(eventName).add(handler)
+
+    return () => {
+      this.listeners.get(eventName)?.delete(handler)
+    }
+  }
+
+  emit(eventName, event) {
+    const handlers = this.listeners.get(eventName)
+    if (!handlers) return
+
+    for (const handler of handlers) {
+      try {
+        handler(event)
+      } catch (error) {
+        setTimeout(() => {
+          throw error
+        }, 0)
+      }
+    }
+  }
+
+  clear() {
+    this.listeners.clear()
+  }
+}
+
+function getDefaultSerial() {
+  return globalThis.navigator?.serial ?? null
+}
+
+function cloneBytes(bytes) {
+  return Uint8Array.from(bytes)
+}
+
+export function isWebSerialSupported(serial = getDefaultSerial()) {
+  return !!serial
+}
+
+export function createWebSerialCamera(options = {}) {
+  return new WebSerialCamera(options)
+}
+
+export class WebSerialCamera {
+  constructor(options = {}) {
+    this.options = {
+      baudRate: DEFAULT_BAUD_RATE,
+      emitRawChunks: false,
+      filters: undefined,
+      serial: undefined,
+      ...options
+    }
+    this.serial = Object.prototype.hasOwnProperty.call(options, 'serial')
+      ? options.serial
+      : getDefaultSerial()
+    this.parser = new JikkoProtocolParser()
+    this.emitter = new EventEmitter()
+    this.port = null
+    this.reader = null
+    this.status = isWebSerialSupported(this.serial) ? 'idle' : 'unsupported'
+    this.lastPacket = null
+    this.readLoopPromise = null
+    this.disconnecting = false
+  }
+
+  on(eventName, handler) {
+    return this.emitter.on(eventName, handler)
+  }
+
+  getStatus() {
+    return this.status
+  }
+
+  isConnected() {
+    return this.status === 'connected'
+  }
+
+  getLastPacket() {
+    return this.lastPacket
+  }
+
+  async connect() {
+    if (!isWebSerialSupported(this.serial)) {
+      const error = new Error('Web Serial API is not supported.')
+      this.setStatus('unsupported')
+      this.emitError('UNSUPPORTED', error.message, error)
+      throw error
+    }
+
+    if (this.isConnected()) return
+
+    this.disconnecting = false
+    this.setStatus('connecting')
+
+    try {
+      const requestOptions = this.options.filters
+        ? { filters: this.options.filters }
+        : undefined
+      const port = await this.serial.requestPort(requestOptions)
+      await port.open({ baudRate: this.options.baudRate })
+
+      this.port = port
+      this.parser.reset()
+      this.setStatus('connected')
+      this.readLoopPromise = this.startReadLoop(port)
+    } catch (error) {
+      this.setStatus('error')
+      this.emitError(
+        error?.name === 'NotFoundError' ? 'PERMISSION_DENIED' : 'PORT_OPEN_FAILED',
+        error?.message || 'Failed to open serial port.',
+        error
+      )
+      throw error
+    }
+  }
+
+  async disconnect() {
+    this.disconnecting = true
+    this.setStatus('disconnecting')
+
+    const reader = this.reader
+    this.reader = null
+    if (reader) {
+      try {
+        await reader.cancel()
+      } catch {
+        // Some browsers reject cancel after the stream has already closed.
+      }
+      this.releaseReader(reader)
+    }
+
+    if (this.readLoopPromise) {
+      try {
+        await this.readLoopPromise
+      } catch {
+        // Read loop errors are already emitted through the error event.
+      }
+      this.readLoopPromise = null
+    }
+
+    if (this.port) {
+      try {
+        await this.port.close()
+      } catch {
+        // The OS or browser can close the port first.
+      }
+      this.port = null
+    }
+
+    this.parser.reset()
+    this.setStatus('disconnected')
+  }
+
+  async startReadLoop(port) {
+    if (!port?.readable) return
+
+    let reader = null
+
+    try {
+      reader = port.readable.getReader()
+      this.reader = reader
+
+      while (true) {
+        const { value, done } = await reader.read()
+        if (done) break
+        if (!value) continue
+
+        this.handleChunk(value)
+      }
+    } catch (error) {
+      if (!this.disconnecting && error?.name !== 'AbortError') {
+        this.setStatus('error')
+        this.emitError('READ_FAILED', error?.message || 'Failed to read serial data.', error)
+      }
+    } finally {
+      if (this.reader === reader) {
+        this.reader = null
+      }
+      this.releaseReader(reader)
+
+      if (!this.disconnecting && this.status === 'connected') {
+        this.setStatus('disconnected')
+      }
+    }
+  }
+
+  handleChunk(chunk) {
+    const bytes = cloneBytes(chunk)
+
+    if (this.options.emitRawChunks) {
+      this.emitter.emit('raw', {
+        bytes,
+        receivedAt: Date.now()
+      })
+    }
+
+    const packets = this.parser.feedChunk(bytes)
+
+    for (const packet of packets) {
+      this.lastPacket = packet
+      this.emitter.emit('packet', packet)
+
+      const parsed = parsePacketResults(packet)
+
+      if (parsed.classifications.length > 0) {
+        const event = {
+          results: parsed.classifications,
+          packet,
+          receivedAt: packet.receivedAt
+        }
+        this.emitter.emit('classifications', event)
+        for (const result of parsed.classifications) {
+          this.emitter.emit('classification', {
+            ...result,
+            packet,
+            receivedAt: packet.receivedAt
+          })
+        }
+      }
+
+      if (parsed.detections.length > 0) {
+        const event = {
+          results: parsed.detections,
+          packet,
+          receivedAt: packet.receivedAt
+        }
+        this.emitter.emit('detections', event)
+        for (const result of parsed.detections) {
+          this.emitter.emit('detection', {
+            ...result,
+            packet,
+            receivedAt: packet.receivedAt
+          })
+        }
+      }
+    }
+  }
+
+  setStatus(status) {
+    this.status = status
+    this.emitter.emit('status', {
+      status,
+      isConnected: this.isConnected(),
+      receivedAt: Date.now()
+    })
+  }
+
+  emitError(code, message, cause) {
+    this.emitter.emit('error', {
+      code,
+      message,
+      cause,
+      receivedAt: Date.now()
+    })
+  }
+
+  releaseReader(reader) {
+    if (!reader) return
+
+    try {
+      reader.releaseLock()
+    } catch {
+      // Ignore if the stream lock has already been released.
+    }
+  }
+}
+