alphatheta-connect 0.15.0

package/lib/remotedb/message/types.d.ts

@@ -0,0 +1,227 @@
+/**
+ * Used for control messages with the remote database
+ */
+export declare enum ControlRequest {
+    Introduce = 0,
+    Disconnect = 256,
+    RenderMenu = 12288
+}
+/**
+ * Used to setup renders for specific Menus
+ */
+export declare enum MenuRequest {
+    MenuRoot = 4096,
+    MenuGenre = 4097,
+    MenuArtist = 4098,
+    MenuAlbum = 4099,
+    MenuTrack = 4100,
+    MenuBPM = 4102,
+    MenuRating = 4103,
+    MenuYear = 4104,
+    MenuLabel = 4106,
+    MenuColor = 4109,
+    MenuTime = 4112,
+    MenuBitrate = 4113,
+    MenuHistory = 4114,
+    MenuFilename = 4115,
+    MenuKey = 4116,
+    MenuOriginalArtist = 4866,
+    MenuRemixer = 5634,
+    MenuPlaylist = 4357,
+    MenuArtistsOfGenre = 4353,
+    MenuAlbumsOfArtist = 4354,
+    MenuTracksOfAlbum = 4355,
+    MenuTracksOfRating = 4359,
+    MenuYearsOfDecade = 4360,
+    MenuArtistsOfLabel = 4362,
+    MenuTracksOfColor = 4365,
+    MenuTracksOfTime = 4368,
+    MenuTracksOfHistory = 4370,
+    MenuDistancesOfKey = 4372,
+    MenuAlbumsOfOriginalArtist = 5122,
+    MenuAlbumsOfRemixer = 5890,
+    MenuAlbumsOfGenreAndArtist = 4609,
+    MenuTracksOfArtistAndAlbum = 4610,
+    MenuTracksOfBPMPercentRange = 4614,
+    MenuTracksOfDecadeAndYear = 4616,
+    MenuAlbumsOfLabelAndArtist = 4618,
+    MenuTracksNearKey = 4628,
+    MenuTracksOfOriginalArtistAndAlbum = 5378,
+    MenuTracksOfRemixerAndAlbum = 6146,
+    MenuTracksOfGenreArtistAndAlbum = 4865,
+    MenuTracksOfLabelArtistAndAlbum = 4874,
+    MenuSearch = 4864,
+    MenuFolder = 8198
+}
+/**
+ * Request message types used to obtain specfiic track information
+ */
+export declare enum DataRequest {
+    GetMetadata = 8194,
+    GetArtwork = 8195,
+    GetWaveformPreview = 8196,
+    GetTrackInfo = 8450,
+    GetGenericMetadata = 8706,
+    GetCueAndLoops = 8452,
+    GetBeatGrid = 8708,
+    GetWaveformDetailed = 10500,
+    GetAdvCueAndLoops = 11012,
+    GetWaveformHD = 11268
+}
+/**
+ * Response message types for messages sent back by the server.
+ */
+export declare enum Response {
+    Success = 16384,
+    Error = 16387,
+    Artwork = 16386,
+    MenuItem = 16641,
+    MenuHeader = 16385,
+    MenuFooter = 16897,
+    BeatGrid = 17922,
+    CueAndLoop = 18178,
+    WaveformPreview = 17410,
+    WaveformDetailed = 18946,
+    AdvCueAndLoops = 19970,
+    WaveformHD = 20226
+}
+/**
+ * Request message types, only sent to the device.
+ */
+export type Request = ControlRequest | MenuRequest | DataRequest;
+export declare const Request: {
+    readonly [x: number]: string;
+    readonly GetMetadata: DataRequest.GetMetadata;
+    readonly GetArtwork: DataRequest.GetArtwork;
+    readonly GetWaveformPreview: DataRequest.GetWaveformPreview;
+    readonly GetTrackInfo: DataRequest.GetTrackInfo;
+    readonly GetGenericMetadata: DataRequest.GetGenericMetadata;
+    readonly GetCueAndLoops: DataRequest.GetCueAndLoops;
+    readonly GetBeatGrid: DataRequest.GetBeatGrid;
+    readonly GetWaveformDetailed: DataRequest.GetWaveformDetailed;
+    readonly GetAdvCueAndLoops: DataRequest.GetAdvCueAndLoops;
+    readonly GetWaveformHD: DataRequest.GetWaveformHD;
+    readonly MenuRoot: MenuRequest.MenuRoot;
+    readonly MenuGenre: MenuRequest.MenuGenre;
+    readonly MenuArtist: MenuRequest.MenuArtist;
+    readonly MenuAlbum: MenuRequest.MenuAlbum;
+    readonly MenuTrack: MenuRequest.MenuTrack;
+    readonly MenuBPM: MenuRequest.MenuBPM;
+    readonly MenuRating: MenuRequest.MenuRating;
+    readonly MenuYear: MenuRequest.MenuYear;
+    readonly MenuLabel: MenuRequest.MenuLabel;
+    readonly MenuColor: MenuRequest.MenuColor;
+    readonly MenuTime: MenuRequest.MenuTime;
+    readonly MenuBitrate: MenuRequest.MenuBitrate;
+    readonly MenuHistory: MenuRequest.MenuHistory;
+    readonly MenuFilename: MenuRequest.MenuFilename;
+    readonly MenuKey: MenuRequest.MenuKey;
+    readonly MenuOriginalArtist: MenuRequest.MenuOriginalArtist;
+    readonly MenuRemixer: MenuRequest.MenuRemixer;
+    readonly MenuPlaylist: MenuRequest.MenuPlaylist;
+    readonly MenuArtistsOfGenre: MenuRequest.MenuArtistsOfGenre;
+    readonly MenuAlbumsOfArtist: MenuRequest.MenuAlbumsOfArtist;
+    readonly MenuTracksOfAlbum: MenuRequest.MenuTracksOfAlbum;
+    readonly MenuTracksOfRating: MenuRequest.MenuTracksOfRating;
+    readonly MenuYearsOfDecade: MenuRequest.MenuYearsOfDecade;
+    readonly MenuArtistsOfLabel: MenuRequest.MenuArtistsOfLabel;
+    readonly MenuTracksOfColor: MenuRequest.MenuTracksOfColor;
+    readonly MenuTracksOfTime: MenuRequest.MenuTracksOfTime;
+    readonly MenuTracksOfHistory: MenuRequest.MenuTracksOfHistory;
+    readonly MenuDistancesOfKey: MenuRequest.MenuDistancesOfKey;
+    readonly MenuAlbumsOfOriginalArtist: MenuRequest.MenuAlbumsOfOriginalArtist;
+    readonly MenuAlbumsOfRemixer: MenuRequest.MenuAlbumsOfRemixer;
+    readonly MenuAlbumsOfGenreAndArtist: MenuRequest.MenuAlbumsOfGenreAndArtist;
+    readonly MenuTracksOfArtistAndAlbum: MenuRequest.MenuTracksOfArtistAndAlbum;
+    readonly MenuTracksOfBPMPercentRange: MenuRequest.MenuTracksOfBPMPercentRange;
+    readonly MenuTracksOfDecadeAndYear: MenuRequest.MenuTracksOfDecadeAndYear;
+    readonly MenuAlbumsOfLabelAndArtist: MenuRequest.MenuAlbumsOfLabelAndArtist;
+    readonly MenuTracksNearKey: MenuRequest.MenuTracksNearKey;
+    readonly MenuTracksOfOriginalArtistAndAlbum: MenuRequest.MenuTracksOfOriginalArtistAndAlbum;
+    readonly MenuTracksOfRemixerAndAlbum: MenuRequest.MenuTracksOfRemixerAndAlbum;
+    readonly MenuTracksOfGenreArtistAndAlbum: MenuRequest.MenuTracksOfGenreArtistAndAlbum;
+    readonly MenuTracksOfLabelArtistAndAlbum: MenuRequest.MenuTracksOfLabelArtistAndAlbum;
+    readonly MenuSearch: MenuRequest.MenuSearch;
+    readonly MenuFolder: MenuRequest.MenuFolder;
+    readonly Introduce: ControlRequest.Introduce;
+    readonly Disconnect: ControlRequest.Disconnect;
+    readonly RenderMenu: ControlRequest.RenderMenu;
+};
+/**
+ * All Known message types. These are used for both request and response messages.
+ */
+export type MessageType = ControlRequest | MenuRequest | DataRequest | Response;
+export declare const MessageType: {
+    readonly [x: number]: string;
+    readonly Success: Response.Success;
+    readonly Error: Response.Error;
+    readonly Artwork: Response.Artwork;
+    readonly MenuItem: Response.MenuItem;
+    readonly MenuHeader: Response.MenuHeader;
+    readonly MenuFooter: Response.MenuFooter;
+    readonly BeatGrid: Response.BeatGrid;
+    readonly CueAndLoop: Response.CueAndLoop;
+    readonly WaveformPreview: Response.WaveformPreview;
+    readonly WaveformDetailed: Response.WaveformDetailed;
+    readonly AdvCueAndLoops: Response.AdvCueAndLoops;
+    readonly WaveformHD: Response.WaveformHD;
+    readonly GetMetadata: DataRequest.GetMetadata;
+    readonly GetArtwork: DataRequest.GetArtwork;
+    readonly GetWaveformPreview: DataRequest.GetWaveformPreview;
+    readonly GetTrackInfo: DataRequest.GetTrackInfo;
+    readonly GetGenericMetadata: DataRequest.GetGenericMetadata;
+    readonly GetCueAndLoops: DataRequest.GetCueAndLoops;
+    readonly GetBeatGrid: DataRequest.GetBeatGrid;
+    readonly GetWaveformDetailed: DataRequest.GetWaveformDetailed;
+    readonly GetAdvCueAndLoops: DataRequest.GetAdvCueAndLoops;
+    readonly GetWaveformHD: DataRequest.GetWaveformHD;
+    readonly MenuRoot: MenuRequest.MenuRoot;
+    readonly MenuGenre: MenuRequest.MenuGenre;
+    readonly MenuArtist: MenuRequest.MenuArtist;
+    readonly MenuAlbum: MenuRequest.MenuAlbum;
+    readonly MenuTrack: MenuRequest.MenuTrack;
+    readonly MenuBPM: MenuRequest.MenuBPM;
+    readonly MenuRating: MenuRequest.MenuRating;
+    readonly MenuYear: MenuRequest.MenuYear;
+    readonly MenuLabel: MenuRequest.MenuLabel;
+    readonly MenuColor: MenuRequest.MenuColor;
+    readonly MenuTime: MenuRequest.MenuTime;
+    readonly MenuBitrate: MenuRequest.MenuBitrate;
+    readonly MenuHistory: MenuRequest.MenuHistory;
+    readonly MenuFilename: MenuRequest.MenuFilename;
+    readonly MenuKey: MenuRequest.MenuKey;
+    readonly MenuOriginalArtist: MenuRequest.MenuOriginalArtist;
+    readonly MenuRemixer: MenuRequest.MenuRemixer;
+    readonly MenuPlaylist: MenuRequest.MenuPlaylist;
+    readonly MenuArtistsOfGenre: MenuRequest.MenuArtistsOfGenre;
+    readonly MenuAlbumsOfArtist: MenuRequest.MenuAlbumsOfArtist;
+    readonly MenuTracksOfAlbum: MenuRequest.MenuTracksOfAlbum;
+    readonly MenuTracksOfRating: MenuRequest.MenuTracksOfRating;
+    readonly MenuYearsOfDecade: MenuRequest.MenuYearsOfDecade;
+    readonly MenuArtistsOfLabel: MenuRequest.MenuArtistsOfLabel;
+    readonly MenuTracksOfColor: MenuRequest.MenuTracksOfColor;
+    readonly MenuTracksOfTime: MenuRequest.MenuTracksOfTime;
+    readonly MenuTracksOfHistory: MenuRequest.MenuTracksOfHistory;
+    readonly MenuDistancesOfKey: MenuRequest.MenuDistancesOfKey;
+    readonly MenuAlbumsOfOriginalArtist: MenuRequest.MenuAlbumsOfOriginalArtist;
+    readonly MenuAlbumsOfRemixer: MenuRequest.MenuAlbumsOfRemixer;
+    readonly MenuAlbumsOfGenreAndArtist: MenuRequest.MenuAlbumsOfGenreAndArtist;
+    readonly MenuTracksOfArtistAndAlbum: MenuRequest.MenuTracksOfArtistAndAlbum;
+    readonly MenuTracksOfBPMPercentRange: MenuRequest.MenuTracksOfBPMPercentRange;
+    readonly MenuTracksOfDecadeAndYear: MenuRequest.MenuTracksOfDecadeAndYear;
+    readonly MenuAlbumsOfLabelAndArtist: MenuRequest.MenuAlbumsOfLabelAndArtist;
+    readonly MenuTracksNearKey: MenuRequest.MenuTracksNearKey;
+    readonly MenuTracksOfOriginalArtistAndAlbum: MenuRequest.MenuTracksOfOriginalArtistAndAlbum;
+    readonly MenuTracksOfRemixerAndAlbum: MenuRequest.MenuTracksOfRemixerAndAlbum;
+    readonly MenuTracksOfGenreArtistAndAlbum: MenuRequest.MenuTracksOfGenreArtistAndAlbum;
+    readonly MenuTracksOfLabelArtistAndAlbum: MenuRequest.MenuTracksOfLabelArtistAndAlbum;
+    readonly MenuSearch: MenuRequest.MenuSearch;
+    readonly MenuFolder: MenuRequest.MenuFolder;
+    readonly Introduce: ControlRequest.Introduce;
+    readonly Disconnect: ControlRequest.Disconnect;
+    readonly RenderMenu: ControlRequest.RenderMenu;
+};
+/**
+ * Returns a string representation of a message type
+ */
+export declare function getMessageName(type: MessageType): string;

package/lib/remotedb/queries.d.ts

@@ -0,0 +1,99 @@
+import * as entities from "../entities";
+import { TelemetrySpan as Span } from "../utils/telemetry";
+import { Item, ItemType } from './message/item';
+import { Connection, LookupDescriptor, Query } from '.';
+/**
+ * This module contains logic for each type of query to understand what
+ * arguments are required, and how to transform the resulting Items into
+ * something useful.
+ */
+interface HandlerOpts<A extends Record<string, unknown> = Record<string, unknown>> {
+    conn: Connection;
+    lookupDescriptor: LookupDescriptor;
+    span: Span;
+    args: A;
+}
+type TrackQueryOpts = HandlerOpts<{
+    /**
+     * The ID of the track to query for
+     */
+    trackId: number;
+}>;
+/**
+ * Lookup track metadata from rekordbox and coerce it into a Track entity
+ */
+declare function getMetadata(opts: TrackQueryOpts): Promise<entities.Track<entities.EntityFK.WithRelations>>;
+/**
+ * Lookup generic metadata for an unanalyzed track
+ */
+declare function getGenericMetadata(opts: TrackQueryOpts): Promise<entities.Track<entities.EntityFK.WithRelations>>;
+/**
+ * Lookup the artwork image given the artworkId obtained from a track
+ */
+declare function getArtwork(opts: HandlerOpts<{
+    artworkId: number;
+}>): Promise<Buffer<ArrayBufferLike>>;
+/**
+ * Lookup the beatgrid for the specified trackId
+ */
+declare function getBeatgrid(opts: TrackQueryOpts): Promise<import("..").BeatGrid>;
+/**
+ * Lookup the waveform preview for the specified trackId
+ */
+declare function getWaveformPreview(opts: TrackQueryOpts): Promise<import("..").WaveformPreview>;
+/**
+ * Lookup the detailed waveform for the specified trackId
+ */
+declare function getWaveformDetailed(opts: TrackQueryOpts): Promise<import("..").WaveformDetailed>;
+/**
+ * Lookup the HD (nexus2) waveform for the specified trackId
+ */
+declare function getWaveformHD(opts: TrackQueryOpts): Promise<import("..").WaveformHD>;
+/**
+ * Lookup the [hot]cue points and [hot]loops for a track
+ */
+declare function getCueAndLoops(opts: TrackQueryOpts): Promise<import("..").CueAndLoop[]>;
+/**
+ * Lookup the "advanced" (nexus2) [hot]cue points and [hot]loops for a track
+ */
+declare function getCueAndLoopsAdv(opts: TrackQueryOpts): Promise<import("..").CueAndLoop[]>;
+/**
+ * Lookup the track information, currently just returns the track path
+ */
+declare function getTrackInfo(opts: TrackQueryOpts): Promise<string>;
+type PlaylistQueryOpts = HandlerOpts<{
+    /**
+     * The ID of the playlist to query for. May be left blank to query the root
+     * playlist folder.
+     */
+    id?: number;
+    /**
+     * When querying for a playlist folder this must be true.
+     */
+    isFolderRequest: boolean;
+}>;
+/**
+ * Lookup playlist entries
+ */
+declare function getPlaylist(opts: PlaylistQueryOpts): Promise<{
+    folders: entities.Playlist[];
+    playlists: entities.Playlist[];
+    trackEntries: Item<ItemType.TrackTitle>[];
+}>;
+export declare const queryHandlers: {
+    8194: typeof getMetadata;
+    8195: typeof getArtwork;
+    8196: typeof getWaveformPreview;
+    8450: typeof getTrackInfo;
+    8706: typeof getGenericMetadata;
+    8452: typeof getCueAndLoops;
+    8708: typeof getBeatgrid;
+    10500: typeof getWaveformDetailed;
+    11012: typeof getCueAndLoopsAdv;
+    11268: typeof getWaveformHD;
+    4357: typeof getPlaylist;
+};
+export type Handler<T extends Query> = (typeof queryHandlers)[T];
+export type HandlerArgs<T extends Query> = Parameters<Handler<T>>[0]['args'];
+export type HandlerReturn<T extends Query> = ReturnType<Handler<T>>;
+export {};

package/lib/remotedb/utils.d.ts

@@ -0,0 +1,23 @@
+import { TelemetrySpan as Span } from "../utils/telemetry";
+import { Items, ItemType } from './message/item';
+import { Message } from './message';
+import { Connection, LookupDescriptor } from '.';
+export declare const fieldFromDescriptor: ({ hostDevice, menuTarget, trackSlot, trackType, }: LookupDescriptor) => {
+    value: number;
+    get buffer(): Buffer<ArrayBuffer>;
+    constructor: typeof import("./fields").BaseField;
+    data: Buffer;
+};
+export declare const makeRenderMessage: (descriptor: LookupDescriptor, offset: number, count: number, total: number) => Message<import("./message/types").ControlRequest.RenderMenu>;
+/**
+ * Async generator to page through menu results after a successful lookup
+ * request.
+ */
+export declare function renderItems<T extends ItemType = ItemType>(conn: Connection, descriptor: LookupDescriptor, total: number, span: Span): AsyncGenerator<Items[T], void, unknown>;
+declare const colors: readonly [ItemType.ColorNone, ItemType.ColorPink, ItemType.ColorRed, ItemType.ColorOrange, ItemType.ColorYellow, ItemType.ColorGreen, ItemType.ColorAqua, ItemType.ColorBlue, ItemType.ColorPurple];
+type ColorType = (typeof colors)[number];
+/**
+ * Locate the color item in an item list
+ */
+export declare const findColor: (items: Array<Items[ItemType]>) => Items[ColorType];
+export {};

package/lib/status/index.d.ts

@@ -0,0 +1,39 @@
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { Socket } from 'dgram';
+import { EventEmitter } from 'events';
+import { CDJStatus, MediaSlotInfo } from "../types";
+import { makeMediaSlotRequest } from './media';
+interface StatusEvents {
+    /**
+     * Fired each time the CDJ reports its status
+     */
+    status: (status: CDJStatus.State) => void;
+    /**
+     * Fired when the CDJ reports its media slot status
+     */
+    mediaSlot: (info: MediaSlotInfo) => void;
+    /**
+     * Fired when the mixer broadcasts on-air channel status
+     */
+    onAir: (status: CDJStatus.OnAirStatus) => void;
+}
+type Emitter = StrictEventEmitter<EventEmitter, StatusEvents>;
+type MediaSlotOptions = Parameters<typeof makeMediaSlotRequest>[0];
+/**
+ * The status emitter will report every time a device status is received
+ */
+declare class StatusEmitter {
+    #private;
+    /**
+     * @param statusSocket A UDP socket to receive CDJ status packets on
+     */
+    constructor(statusSocket: Socket);
+    on: Emitter['on'];
+    off: Emitter['off'];
+    once: Emitter['once'];
+    /**
+     * Retrieve media slot status information.
+     */
+    queryMediaSlot(options: MediaSlotOptions): Promise<MediaSlotInfo>;
+}
+export default StatusEmitter;

package/lib/status/media.d.ts

@@ -0,0 +1,22 @@
+import { Device, MediaSlot } from "../types";
+interface Options {
+    /**
+     * The device asking for media info
+     */
+    hostDevice: Device;
+    /**
+     * The target device. This is the device we'll be querying for details of
+     * it's media slot.
+     */
+    device: Device;
+    /**
+     * The specific slot
+     */
+    slot: MediaSlot;
+}
+/**
+ * Get information about the media connected to the specified slot on the
+ * device.
+ */
+export declare const makeMediaSlotRequest: ({ hostDevice, device, slot }: Options) => Uint8Array<ArrayBuffer>;
+export {};

package/lib/status/position.d.ts

@@ -0,0 +1,29 @@
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { Socket } from 'dgram';
+import { EventEmitter } from 'events';
+import { CDJStatus } from "../types";
+interface PositionEvents {
+    /**
+     * Fired when an absolute position packet is received from a CDJ-3000+.
+     * These packets are sent approximately every 30ms while a track is loaded.
+     */
+    position: (position: CDJStatus.PositionState) => void;
+}
+type Emitter = StrictEventEmitter<EventEmitter, PositionEvents>;
+/**
+ * The position emitter reports absolute playhead position updates from CDJ-3000+ devices.
+ * These packets provide precise track position independent of beat grids, enabling
+ * accurate timecode, lighting cue, and video synchronization even during scratching,
+ * reverse play, loops, and needle jumps.
+ */
+declare class PositionEmitter {
+    #private;
+    /**
+     * @param beatSocket A UDP socket to receive position packets on port 50001
+     */
+    constructor(beatSocket: Socket);
+    on: Emitter['on'];
+    off: Emitter['off'];
+    once: Emitter['once'];
+}
+export default PositionEmitter;

package/lib/status/types.d.ts

@@ -0,0 +1,170 @@
+import { DeviceID, MediaSlot, TrackType } from "../types";
+/**
+ * Status flag bitmasks
+ */
+export declare enum StatusFlag {
+    OnAir = 8,
+    Sync = 16,
+    Master = 32,
+    Playing = 64
+}
+/**
+ * Play state flags
+ */
+export declare enum PlayState {
+    Empty = 0,
+    Loading = 2,
+    Playing = 3,
+    Looping = 4,
+    Paused = 5,
+    Cued = 6,
+    Cuing = 7,
+    PlatterHeld = 8,
+    Searching = 9,
+    SpunDown = 14,
+    Ended = 17
+}
+/**
+ * Represents various details about the current state of the CDJ.
+ */
+export interface State {
+    /**
+     * The device reporting this status.
+     */
+    deviceId: number;
+    /**
+     * The ID of the track loaded on the device.
+     *
+     * 0 When no track is loaded.
+     */
+    trackId: number;
+    /**
+     * The device ID the track is loaded from.
+     *
+     * For example if you have two CDJs and you've loaded a track over the 'LINK',
+     * this will be the ID of the player with the USB media device connected to it.
+     */
+    trackDeviceId: DeviceID;
+    /**
+     * The MediaSlot the track is loaded from. For example a SD card or USB device.
+     */
+    trackSlot: MediaSlot;
+    /**
+     * The TrackType of the track, for example a CD or Rekordbox analyzed track.
+     */
+    trackType: TrackType;
+    /**
+     * The current play state of the CDJ.
+     */
+    playState: PlayState;
+    /**
+     * Whether the CDJ is currently reporting itself as 'on-air'.
+     *
+     * This is indicated by the red ring around the platter on the CDJ Nexus models.
+     * A DJM mixer must be ont he network for the CDJ to report this as true.
+     */
+    isOnAir: boolean;
+    /**
+     * Whether the CDJ is synced.
+     */
+    isSync: boolean;
+    /**
+     * Whether the CDJ is the master player.
+     */
+    isMaster: boolean;
+    /**
+     * Whether the CDJ is in an emergency state (emergecy loop / emergency mode
+     * on newer players)
+     */
+    isEmergencyMode: boolean;
+    /**
+     * The BPM of the loaded track. null if no track is loaded or the BPM is unknown.
+     */
+    trackBPM: number | null;
+    /**
+     * The "effective" pitch of the plyaer. This is reported anytime the jogwheel is
+     * nudged, the CDJ spins down by pausing with the vinyl stop knob not at 0, or
+     * by holding the platter.
+     */
+    effectivePitch: number;
+    /**
+     * The current slider pitch
+     */
+    sliderPitch: number;
+    /**
+     * The current beat within the measure. 1-4. 0 when no track is loaded.
+     */
+    beatInMeasure: number;
+    /**
+     * Number of beats remaining until the next cue point is reached. Null if there
+     * is no next cue point
+     */
+    beatsUntilCue: number | null;
+    /**
+     * The beat 'timestamp' of the track. Can be used to compute absolute track time
+     * given the slider pitch.
+     */
+    beat: number | null;
+    /**
+     * A counter that increments for every status packet sent.
+     */
+    packetNum: number;
+}
+/**
+ * Absolute position information from CDJ-3000+ devices.
+ * Sent every 30ms on port 50001 while a track is loaded.
+ * Provides precise playhead position independent of beat grid.
+ */
+export interface PositionState {
+    /**
+     * The device ID sending this position update.
+     */
+    deviceId: number;
+    /**
+     * Track length in seconds (rounded down to nearest second).
+     */
+    trackLength: number;
+    /**
+     * Absolute playhead position in milliseconds.
+     */
+    playhead: number;
+    /**
+     * Pitch slider value as shown on screen.
+     * For example, 3.26% is represented as 3.26.
+     */
+    pitch: number;
+    /**
+     * Effective BPM (track BPM adjusted by pitch) as shown on screen.
+     * null if BPM is unknown.
+     */
+    bpm: number | null;
+}
+/**
+ * On-Air status from DJM mixer.
+ * Broadcast by the mixer to indicate which channels are currently audible.
+ * Supports both 4-channel (DJM-900/1000) and 6-channel (DJM-V10) mixers.
+ */
+export interface OnAirStatus {
+    /**
+     * The mixer device ID (typically 33 / 0x21).
+     */
+    deviceId: number;
+    /**
+     * On-air flags for channels 1-4 (always present).
+     * 0x00 = channel is off-air (silenced)
+     * 0x01 = channel is on-air (audible)
+     */
+    channels: {
+        1: boolean;
+        2: boolean;
+        3: boolean;
+        4: boolean;
+        5?: boolean;
+        6?: boolean;
+    };
+    /**
+     * Whether this is a 6-channel variant (CDJ-3000 + DJM-V10).
+     * Determined by packet subtype (0x00 = 4-channel, 0x03 = 6-channel).
+     */
+    isSixChannel: boolean;
+}

package/lib/status/utils.d.ts

@@ -0,0 +1,19 @@
+import { CDJStatus, MediaSlotInfo } from "../types";
+export declare function statusFromPacket(packet: Buffer): CDJStatus.State | undefined;
+export declare function mediaSlotFromPacket(packet: Buffer): MediaSlotInfo | undefined;
+/**
+ * Parse absolute position packet from CDJ-3000+ devices.
+ * These packets are sent every 30ms on port 50001 while a track is loaded.
+ * Packet structure: subtype 0x00, lenr varies based on device.
+ */
+export declare function positionFromPacket(packet: Buffer): CDJStatus.PositionState | undefined;
+/**
+ * Parse on-air status packet from DJM mixer.
+ * The mixer broadcasts which channels are currently audible.
+ * Supports both 4-channel (subtype 0x00) and 6-channel (subtype 0x03) variants.
+ *
+ * Packet structure:
+ * - 4-channel: subtype 0x00, length 0x0009 (9 data bytes: F1 F2 F3 F4 00 00 00 00 00)
+ * - 6-channel: subtype 0x03, length 0x0011 (17 data bytes: F1 F2 F3 F4 00 00 00 00 00 F5 F6 00 30 00 00 00 00 00)
+ */
+export declare function onAirFromPacket(packet: Buffer): CDJStatus.OnAirStatus | undefined;