feat(player): queue

protos/player.proto

@@ -6,16 +6,20 @@ import 'library.proto';
 package player;
 
 service Player {
-	rpc PlayTrack(PlayTrackRequest) returns (PlayTrackResponse);
+	rpc PlayTrack(TrackRequest) returns (PlayTrackResponse);
 	rpc ResumeTrack(google.protobuf.Empty) returns (PauseState);
 	rpc PauseTrack(google.protobuf.Empty) returns (PauseState);
 	rpc TogglePause(google.protobuf.Empty) returns (PauseState);
 	rpc GetStatus(google.protobuf.Empty) returns (stream PlayerStatus);
 	rpc SeekPosition(SeekPositionRequest) returns (SeekPositionResponse);
 	rpc SetVolume(SetVolumeRequest) returns (SetVolumeResponse);
+	rpc PlayTrackNext(TrackRequest) returns (Queue);
+	rpc AddTrackToQueue(TrackRequest) returns (Queue);
+	rpc SkipTrack(google.protobuf.Empty) returns (PlayerStatus);
+	rpc SkipToQueueIndex(SkipToQueueIndexRequest) returns (PlayerStatus);
 }
 
-message PlayTrackRequest {
+message TrackRequest {
 	string hash = 1;
 }
 
@@ -29,6 +33,11 @@ message PlayerStatus {
 	bool is_paused = 2;
 	float volume = 3;
 	uint64 progress = 4;
+	repeated library.Track queue = 5;
+}
+
+message Queue {
+	repeated library.Track tracks = 1;
 }
 
 message PauseState {
@@ -50,3 +59,7 @@ message SetVolumeRequest  {
 message SetVolumeResponse  {
 	float volume = 1;
 }
+
+message SkipToQueueIndexRequest {
+	uint32 index = 1;
+}

src/lib/components/groove/Footer.svelte

@@ -55,14 +55,22 @@
 		console.log(`SKIP TO QUEUE INDEX ${index}`);
 	}
 
-	const submitTogglePause: SubmitFunction = async () => {
+	const submitPlayerAction: SubmitFunction = async () => {
 		return async ({ update, result }) => {
 			await update({
 				invalidateAll: false
 			});
 
-			if (result.type === 'success' && result.data && 'isPaused' in result.data) {
+			if (result.type !== 'success' || !result.data) {
+				return;
+			}
+
+			if ('isPaused' in result.data) {
+				if (!('volume' in result.data)) {
 					player.isPaused = result.data.isPaused;
+				} else {
+					player.applyStatus(result.data);
+				}
 			}
 		};
 	};
@@ -93,9 +101,9 @@
 		<form
 			class="col-span-1 flex justify-center gap-1"
 			method="POST"
-			use:enhance={submitTogglePause}
+			use:enhance={submitPlayerAction}
 		>
-			<Button variant="outline" size="icon">
+			<Button variant="outline" size="icon" disabled>
 				<SkipBack />
 			</Button>
 			<Button type="submit" formaction="/player?/toggle-pause" variant="outline" size="icon">
@@ -105,7 +113,7 @@
 					<Pause />
 				{/if}
 			</Button>
-			<Button variant="outline" size="icon">
+			<Button type="submit" variant="outline" formaction="/player?/skip" size="icon">
 				<SkipForward />
 			</Button>
 		</form>
@@ -116,7 +124,7 @@
 						{#snippet child({ props })}
 							<Button {...props} variant="ghost" size="sm">
 								<List class="mr-2 size-4" />
-								<span>15</span>
+								<span>{player.queue.length}</span>
 							</Button>
 						{/snippet}
 					</Popover.Trigger>
@@ -125,34 +133,35 @@
 
 						<Separator class="my-1" />
 
-						<div class="flex h-full flex-col gap-1 overflow-y-auto pr-3">
+						<form
-							{#each [] as _track, i}
+							class="flex h-full flex-col gap-1 overflow-y-auto pr-3"
+							method="POST"
+							use:enhance={submitPlayerAction}
+						>
+							{#each player.queue as track, i}
 								<button
+									type="submit"
 									class="flex flex-row items-center gap-2 rounded-lg px-3 py-2 transition-all hover:bg-secondary"
-									onclick={() => skipToQueueIndex(i)}
+									formaction="/player?/skip-to-queue-index&index={i}"
 								>
 									<div class="min-w-8 overflow-hidden rounded-md">
-										<img
+										<img src={getCoverUrl(track.hash)} class="aspect-square size-8" alt="Cover" />
-											src="https://i.scdn.co/image/ab67616d0000b2732c0ead8ce0dd1c6e2fca817f"
-											class="aspect-square size-8"
-											alt="Cover"
-										/>
 									</div>
 									<div class="flex flex-col overflow-hidden">
 										<p
 											class="w-full self-start overflow-hidden text-ellipsis text-nowrap text-left text-sm text-foreground/80"
 										>
-											Track name
+											{track.name}
 										</p>
 										<p
 											class="w-full self-start overflow-hidden text-left text-xs text-muted-foreground"
 										>
-											Track artist
+											{track.artistName}
 										</p>
 									</div>
 								</button>
 							{/each}
-						</div>
+						</form>
 					</Popover.Content>
 				</Popover.Root>
 

src/lib/components/groove/TrackListing.svelte

@@ -2,11 +2,10 @@
 	import { enhance } from '$app/forms';
 	import { getCoverUrl } from '$lib/covers';
 	import { getPlayerState } from '$lib/player.svelte';
-
+	import { AudioLines, Music2, ListMusic, ListEnd } from 'lucide-svelte';
-	// import { AudioLines } from 'lucide-svelte';
-	import { AudioLines } from 'lucide-svelte';
 	import type { SubmitFunction } from '../../../routes/tracks/[hash]/$types';
 	import type { Track } from '$lib/proto/library';
+	import * as ContextMenu from '$lib/components/ui/context-menu';
 
 	interface Props {
 		track: Track;
@@ -14,21 +13,44 @@
 
 	let { track }: Props = $props();
 
+	let isOpen = $state(false);
+
 	const player = getPlayerState();
 
 	const submitPlayTrack: SubmitFunction = async () => {
 		return async ({ update, result }) => {
+			isOpen = false;
+
 			await update({
 				invalidateAll: false
 			});
 
-			if (result.type === 'success' && result.data) {
+			if (result.type === 'success' && result.data && 'track' in result.data) {
+				player.queue = [];
 				player.currentlyPlaying = result.data.track ?? null;
 				player.progress = result.data.position;
 				player.isPaused = false;
 			}
 		};
 	};
+
+	const submitEnqueue: SubmitFunction = async () => {
+		return async ({ update, result }) => {
+			isOpen = false;
+
+			await update({
+				invalidateAll: false
+			});
+
+			if (result.type === 'success' && result.data && 'tracks' in result.data) {
+				player.queue = result.data.tracks;
+			}
+		};
+	};
+
+	function contextMenuItemClicked(e: MouseEvent) {
+		e.stopPropagation();
+	}
 </script>
 
 <form
@@ -37,6 +59,8 @@
 	action="/tracks/{track.hash}?/play"
 	use:enhance={submitPlayTrack}
 >
+	<ContextMenu.Root bind:open={isOpen}>
+		<ContextMenu.Trigger>
 			<div class="relative">
 				<button type="submit" class="relative overflow-hidden rounded-lg">
 					<img
@@ -57,4 +81,59 @@
 				<h3 class="font-medium leading-none">{track.name}</h3>
 				<p class="text-xs text-muted-foreground">{track.artistName}</p>
 			</div>
+		</ContextMenu.Trigger>
+		<ContextMenu.Content>
+			<ContextMenu.Item class="!p-0">
+				<form
+					class="flex w-full"
+					method="POST"
+					action="/tracks/{track.hash}?/play"
+					use:enhance={submitPlayTrack}
+				>
+					<button
+						type="submit"
+						class="flex w-full items-center px-2 py-1.5 focus:outline-0"
+						onclick={contextMenuItemClicked}
+					>
+						<Music2 class="mr-1 size-4" />
+						Play
+					</button>
+				</form>
+			</ContextMenu.Item>
+			<ContextMenu.Item class="!p-0">
+				<form
+					class="flex w-full"
+					method="POST"
+					action="/tracks/{track.hash}?/play-next"
+					use:enhance={submitEnqueue}
+				>
+					<button
+						type="submit"
+						class="flex w-full items-center px-2 py-1.5 focus:outline-0"
+						onclick={contextMenuItemClicked}
+					>
+						<ListMusic class="mr-1 size-4" />
+						Play Next
+					</button>
+				</form>
+			</ContextMenu.Item>
+			<ContextMenu.Item class="!p-0">
+				<form
+					class="flex w-full"
+					method="POST"
+					action="/tracks/{track.hash}?/add-to-queue"
+					use:enhance={submitEnqueue}
+				>
+					<button
+						type="submit"
+						class="flex w-full items-center px-2 py-1.5 focus:outline-0"
+						onclick={contextMenuItemClicked}
+					>
+						<ListEnd class="mr-1 size-4" />
+						Add to Queue
+					</button>
+				</form>
+			</ContextMenu.Item>
+		</ContextMenu.Content>
+	</ContextMenu.Root>
 </form>

src/lib/player.svelte.ts

@@ -10,6 +10,7 @@ class PlayerState {
 	progress = $state<bigint>(0n);
 	isPaused = $state(false);
 	adjustingVolume = $state(false);
+	queue = $state<Track[]>([]);
 	#abortContoller: AbortController | null = null;
 
 	constructor() {
@@ -34,6 +35,7 @@ class PlayerState {
 		this.progress = status.progress;
 		this.currentlyPlaying = status.currentlyPlaying ?? null;
 		this.isPaused = status.isPaused;
+		this.queue = status.queue;
 	}
 
 	abort() {

src/lib/proto.ts

@@ -5,8 +5,19 @@ export function serializable<F, T extends object = object>(data: T): F {
 		const value = data[key];
 
 		if (typeof value === 'object') {
+			/// @ts-ignore
+			if ('length' in value) {
+				/// @ts-ignore
+				obj[key] =
+					value.length > 0
+						? value.map((v) => {
+								return typeof v === 'object' ? serializable(v) : v;
+							})
+						: [];
+			} else {
 				/// @ts-ignore
 				obj[key] = serializable(value);
+			}
 		} else {
 			/// @ts-ignore
 			obj[key] = value;

src/lib/proto/google/protobuf/empty.ts

@@ -32,14 +32,14 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from "@protobuf-ts/runtime";
-import type { PartialMessage } from '@protobuf-ts/runtime';
+import type { PartialMessage } from "@protobuf-ts/runtime";
-import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MessageType } from '@protobuf-ts/runtime';
+import { MessageType } from "@protobuf-ts/runtime";
 /**
  * A generic empty message that you can re-use to avoid defining duplicated
  * empty messages in your APIs. A typical example is to use it as the request
@@ -52,32 +52,26 @@ import { MessageType } from '@protobuf-ts/runtime';
  *
  * @generated from protobuf message google.protobuf.Empty
  */
-export interface Empty {}
+export interface Empty {
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class Empty$Type extends MessageType<Empty> {
     constructor() {
-		super('google.protobuf.Empty', []);
+        super("google.protobuf.Empty", []);
     }
     create(value?: PartialMessage<Empty>): Empty {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
-		if (value !== undefined) reflectionMergePartial<Empty>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<Empty>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Empty): Empty {
-		reader: IBinaryReader,
-		length: number,
-		options: BinaryReadOptions,
-		target?: Empty
-	): Empty {
         return target ?? this.create();
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: Empty, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: Empty,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }

src/lib/proto/library.client.ts

@@ -1,14 +1,14 @@
 // @generated by protobuf-ts 2.9.4
 // @generated from protobuf file "library.proto" (package "library", syntax proto3)
 // tslint:disable
-import type { RpcTransport } from '@protobuf-ts/runtime-rpc';
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
-import type { ServiceInfo } from '@protobuf-ts/runtime-rpc';
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
-import { Library } from './library';
+import { Library } from "./library";
-import { stackIntercept } from '@protobuf-ts/runtime-rpc';
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
-import type { TrackList } from './library';
+import type { TrackList } from "./library";
-import type { Empty } from './google/protobuf/empty';
+import type { Empty } from "./google/protobuf/empty";
-import type { UnaryCall } from '@protobuf-ts/runtime-rpc';
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
 /**
  * @generated from protobuf service library.Library
  */
@@ -25,13 +25,13 @@ export class LibraryClient implements ILibraryClient, ServiceInfo {
     typeName = Library.typeName;
     methods = Library.methods;
     options = Library.options;
-	constructor(private readonly _transport: RpcTransport) {}
+    constructor(private readonly _transport: RpcTransport) {
+    }
     /**
      * @generated from protobuf rpc: ListTracks(google.protobuf.Empty) returns (library.TrackList);
      */
     listTracks(input: Empty, options?: RpcOptions): UnaryCall<Empty, TrackList> {
-		const method = this.methods[0],
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
-			opt = this._transport.mergeOptions(options);
+        return stackIntercept<Empty, TrackList>("unary", this._transport, method, opt, input);
-		return stackIntercept<Empty, TrackList>('unary', this._transport, method, opt, input);
     }
 }

src/lib/proto/library.ts

@@ -1,17 +1,17 @@
 // @generated by protobuf-ts 2.9.4
 // @generated from protobuf file "library.proto" (package "library", syntax proto3)
 // tslint:disable
-import { Empty } from './google/protobuf/empty';
+import { Empty } from "./google/protobuf/empty";
-import { ServiceType } from '@protobuf-ts/runtime-rpc';
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
-import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import { WireType } from '@protobuf-ts/runtime';
+import { WireType } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from "@protobuf-ts/runtime";
-import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import type { PartialMessage } from '@protobuf-ts/runtime';
+import type { PartialMessage } from "@protobuf-ts/runtime";
-import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MessageType } from '@protobuf-ts/runtime';
+import { MessageType } from "@protobuf-ts/runtime";
 /**
  * @generated from protobuf message library.TrackList
  */
@@ -49,24 +49,19 @@ export interface Track {
 // @generated message type with reflection information, may provide speed optimized methods
 class TrackList$Type extends MessageType<TrackList> {
     constructor() {
-		super('library.TrackList', [
+        super("library.TrackList", [
-			{ no: 1, name: 'tracks', kind: 'message', repeat: 1 /*RepeatType.PACKED*/, T: () => Track }
+            { no: 1, name: "tracks", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Track }
         ]);
     }
     create(value?: PartialMessage<TrackList>): TrackList {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.tracks = [];
-		if (value !== undefined) reflectionMergePartial<TrackList>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<TrackList>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackList): TrackList {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: TrackList
-	): TrackList {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -75,37 +70,22 @@ class TrackList$Type extends MessageType<TrackList> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: TrackList, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: TrackList,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* repeated library.Track tracks = 1; */
         for (let i = 0; i < message.tracks.length; i++)
-			Track.internalBinaryWrite(
+            Track.internalBinaryWrite(message.tracks[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-				message.tracks[i],
-				writer.tag(1, WireType.LengthDelimited).fork(),
-				options
-			).join();
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -116,44 +96,27 @@ export const TrackList = new TrackList$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class Track$Type extends MessageType<Track> {
     constructor() {
-		super('library.Track', [
+        super("library.Track", [
-			{ no: 1, name: 'hash', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            { no: 1, name: "hash", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-			{ no: 2, name: 'name', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-			{ no: 3, name: 'artist_name', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "artist_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-			{
+            { no: 4, name: "artist_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
-				no: 4,
+            { no: 5, name: "duration", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
-				name: 'artist_id',
-				kind: 'scalar',
-				T: 4 /*ScalarType.UINT64*/,
-				L: 0 /*LongType.BIGINT*/
-			},
-			{
-				no: 5,
-				name: 'duration',
-				kind: 'scalar',
-				T: 4 /*ScalarType.UINT64*/,
-				L: 0 /*LongType.BIGINT*/
-			}
         ]);
     }
     create(value?: PartialMessage<Track>): Track {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
-		message.hash = '';
+        message.hash = "";
-		message.name = '';
+        message.name = "";
-		message.artistName = '';
+        message.artistName = "";
         message.artistId = 0n;
         message.duration = 0n;
-		if (value !== undefined) reflectionMergePartial<Track>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<Track>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Track): Track {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: Track
-	): Track {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -174,41 +137,34 @@ class Track$Type extends MessageType<Track> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: Track, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: Track,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* string hash = 1; */
-		if (message.hash !== '') writer.tag(1, WireType.LengthDelimited).string(message.hash);
+        if (message.hash !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.hash);
         /* string name = 2; */
-		if (message.name !== '') writer.tag(2, WireType.LengthDelimited).string(message.name);
+        if (message.name !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.name);
         /* string artist_name = 3; */
-		if (message.artistName !== '')
+        if (message.artistName !== "")
             writer.tag(3, WireType.LengthDelimited).string(message.artistName);
         /* uint64 artist_id = 4; */
-		if (message.artistId !== 0n) writer.tag(4, WireType.Varint).uint64(message.artistId);
+        if (message.artistId !== 0n)
+            writer.tag(4, WireType.Varint).uint64(message.artistId);
         /* uint64 duration = 5; */
-		if (message.duration !== 0n) writer.tag(5, WireType.Varint).uint64(message.duration);
+        if (message.duration !== 0n)
+            writer.tag(5, WireType.Varint).uint64(message.duration);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -219,6 +175,6 @@ export const Track = new Track$Type();
 /**
  * @generated ServiceType for protobuf service library.Library
  */
-export const Library = new ServiceType('library.Library', [
+export const Library = new ServiceType("library.Library", [
-	{ name: 'ListTracks', options: {}, I: Empty, O: TrackList }
+    { name: "ListTracks", options: {}, I: Empty, O: TrackList }
 ]);

src/lib/proto/player.client.ts

@@ -1,33 +1,32 @@
 // @generated by protobuf-ts 2.9.4
 // @generated from protobuf file "player.proto" (package "player", syntax proto3)
 // tslint:disable
-import type { RpcTransport } from '@protobuf-ts/runtime-rpc';
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
-import type { ServiceInfo } from '@protobuf-ts/runtime-rpc';
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
-import { Player } from './player';
+import { Player } from "./player";
-import type { SetVolumeResponse } from './player';
+import type { SkipToQueueIndexRequest } from "./player";
-import type { SetVolumeRequest } from './player';
+import type { Queue } from "./player";
-import type { SeekPositionResponse } from './player';
+import type { SetVolumeResponse } from "./player";
-import type { SeekPositionRequest } from './player';
+import type { SetVolumeRequest } from "./player";
-import type { PlayerStatus } from './player';
+import type { SeekPositionResponse } from "./player";
-import type { ServerStreamingCall } from '@protobuf-ts/runtime-rpc';
+import type { SeekPositionRequest } from "./player";
-import type { PauseState } from './player';
+import type { PlayerStatus } from "./player";
-import type { Empty } from './google/protobuf/empty';
+import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
-import { stackIntercept } from '@protobuf-ts/runtime-rpc';
+import type { PauseState } from "./player";
-import type { PlayTrackResponse } from './player';
+import type { Empty } from "./google/protobuf/empty";
-import type { PlayTrackRequest } from './player';
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
-import type { UnaryCall } from '@protobuf-ts/runtime-rpc';
+import type { PlayTrackResponse } from "./player";
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
+import type { TrackRequest } from "./player";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
 /**
  * @generated from protobuf service player.Player
  */
 export interface IPlayerClient {
     /**
-	 * @generated from protobuf rpc: PlayTrack(player.PlayTrackRequest) returns (player.PlayTrackResponse);
+     * @generated from protobuf rpc: PlayTrack(player.TrackRequest) returns (player.PlayTrackResponse);
      */
-	playTrack(
+    playTrack(input: TrackRequest, options?: RpcOptions): UnaryCall<TrackRequest, PlayTrackResponse>;
-		input: PlayTrackRequest,
-		options?: RpcOptions
-	): UnaryCall<PlayTrackRequest, PlayTrackResponse>;
     /**
      * @generated from protobuf rpc: ResumeTrack(google.protobuf.Empty) returns (player.PauseState);
      */
@@ -47,17 +46,27 @@ export interface IPlayerClient {
     /**
      * @generated from protobuf rpc: SeekPosition(player.SeekPositionRequest) returns (player.SeekPositionResponse);
      */
-	seekPosition(
+    seekPosition(input: SeekPositionRequest, options?: RpcOptions): UnaryCall<SeekPositionRequest, SeekPositionResponse>;
-		input: SeekPositionRequest,
-		options?: RpcOptions
-	): UnaryCall<SeekPositionRequest, SeekPositionResponse>;
     /**
      * @generated from protobuf rpc: SetVolume(player.SetVolumeRequest) returns (player.SetVolumeResponse);
      */
-	setVolume(
+    setVolume(input: SetVolumeRequest, options?: RpcOptions): UnaryCall<SetVolumeRequest, SetVolumeResponse>;
-		input: SetVolumeRequest,
+    /**
-		options?: RpcOptions
+     * @generated from protobuf rpc: PlayTrackNext(player.TrackRequest) returns (player.Queue);
-	): UnaryCall<SetVolumeRequest, SetVolumeResponse>;
+     */
+    playTrackNext(input: TrackRequest, options?: RpcOptions): UnaryCall<TrackRequest, Queue>;
+    /**
+     * @generated from protobuf rpc: AddTrackToQueue(player.TrackRequest) returns (player.Queue);
+     */
+    addTrackToQueue(input: TrackRequest, options?: RpcOptions): UnaryCall<TrackRequest, Queue>;
+    /**
+     * @generated from protobuf rpc: SkipTrack(google.protobuf.Empty) returns (player.PlayerStatus);
+     */
+    skipTrack(input: Empty, options?: RpcOptions): UnaryCall<Empty, PlayerStatus>;
+    /**
+     * @generated from protobuf rpc: SkipToQueueIndex(player.SkipToQueueIndexRequest) returns (player.PlayerStatus);
+     */
+    skipToQueueIndex(input: SkipToQueueIndexRequest, options?: RpcOptions): UnaryCall<SkipToQueueIndexRequest, PlayerStatus>;
 }
 /**
  * @generated from protobuf service player.Player
@@ -66,94 +75,83 @@ export class PlayerClient implements IPlayerClient, ServiceInfo {
     typeName = Player.typeName;
     methods = Player.methods;
     options = Player.options;
-	constructor(private readonly _transport: RpcTransport) {}
+    constructor(private readonly _transport: RpcTransport) {
+    }
     /**
-	 * @generated from protobuf rpc: PlayTrack(player.PlayTrackRequest) returns (player.PlayTrackResponse);
+     * @generated from protobuf rpc: PlayTrack(player.TrackRequest) returns (player.PlayTrackResponse);
      */
-	playTrack(
+    playTrack(input: TrackRequest, options?: RpcOptions): UnaryCall<TrackRequest, PlayTrackResponse> {
-		input: PlayTrackRequest,
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
-		options?: RpcOptions
+        return stackIntercept<TrackRequest, PlayTrackResponse>("unary", this._transport, method, opt, input);
-	): UnaryCall<PlayTrackRequest, PlayTrackResponse> {
-		const method = this.methods[0],
-			opt = this._transport.mergeOptions(options);
-		return stackIntercept<PlayTrackRequest, PlayTrackResponse>(
-			'unary',
-			this._transport,
-			method,
-			opt,
-			input
-		);
     }
     /**
      * @generated from protobuf rpc: ResumeTrack(google.protobuf.Empty) returns (player.PauseState);
      */
     resumeTrack(input: Empty, options?: RpcOptions): UnaryCall<Empty, PauseState> {
-		const method = this.methods[1],
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
-			opt = this._transport.mergeOptions(options);
+        return stackIntercept<Empty, PauseState>("unary", this._transport, method, opt, input);
-		return stackIntercept<Empty, PauseState>('unary', this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: PauseTrack(google.protobuf.Empty) returns (player.PauseState);
      */
     pauseTrack(input: Empty, options?: RpcOptions): UnaryCall<Empty, PauseState> {
-		const method = this.methods[2],
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
-			opt = this._transport.mergeOptions(options);
+        return stackIntercept<Empty, PauseState>("unary", this._transport, method, opt, input);
-		return stackIntercept<Empty, PauseState>('unary', this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: TogglePause(google.protobuf.Empty) returns (player.PauseState);
      */
     togglePause(input: Empty, options?: RpcOptions): UnaryCall<Empty, PauseState> {
-		const method = this.methods[3],
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
-			opt = this._transport.mergeOptions(options);
+        return stackIntercept<Empty, PauseState>("unary", this._transport, method, opt, input);
-		return stackIntercept<Empty, PauseState>('unary', this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: GetStatus(google.protobuf.Empty) returns (stream player.PlayerStatus);
      */
     getStatus(input: Empty, options?: RpcOptions): ServerStreamingCall<Empty, PlayerStatus> {
-		const method = this.methods[4],
+        const method = this.methods[4], opt = this._transport.mergeOptions(options);
-			opt = this._transport.mergeOptions(options);
+        return stackIntercept<Empty, PlayerStatus>("serverStreaming", this._transport, method, opt, input);
-		return stackIntercept<Empty, PlayerStatus>(
-			'serverStreaming',
-			this._transport,
-			method,
-			opt,
-			input
-		);
     }
     /**
      * @generated from protobuf rpc: SeekPosition(player.SeekPositionRequest) returns (player.SeekPositionResponse);
      */
-	seekPosition(
+    seekPosition(input: SeekPositionRequest, options?: RpcOptions): UnaryCall<SeekPositionRequest, SeekPositionResponse> {
-		input: SeekPositionRequest,
+        const method = this.methods[5], opt = this._transport.mergeOptions(options);
-		options?: RpcOptions
+        return stackIntercept<SeekPositionRequest, SeekPositionResponse>("unary", this._transport, method, opt, input);
-	): UnaryCall<SeekPositionRequest, SeekPositionResponse> {
-		const method = this.methods[5],
-			opt = this._transport.mergeOptions(options);
-		return stackIntercept<SeekPositionRequest, SeekPositionResponse>(
-			'unary',
-			this._transport,
-			method,
-			opt,
-			input
-		);
     }
     /**
      * @generated from protobuf rpc: SetVolume(player.SetVolumeRequest) returns (player.SetVolumeResponse);
      */
-	setVolume(
+    setVolume(input: SetVolumeRequest, options?: RpcOptions): UnaryCall<SetVolumeRequest, SetVolumeResponse> {
-		input: SetVolumeRequest,
+        const method = this.methods[6], opt = this._transport.mergeOptions(options);
-		options?: RpcOptions
+        return stackIntercept<SetVolumeRequest, SetVolumeResponse>("unary", this._transport, method, opt, input);
-	): UnaryCall<SetVolumeRequest, SetVolumeResponse> {
+    }
-		const method = this.methods[6],
+    /**
-			opt = this._transport.mergeOptions(options);
+     * @generated from protobuf rpc: PlayTrackNext(player.TrackRequest) returns (player.Queue);
-		return stackIntercept<SetVolumeRequest, SetVolumeResponse>(
+     */
-			'unary',
+    playTrackNext(input: TrackRequest, options?: RpcOptions): UnaryCall<TrackRequest, Queue> {
-			this._transport,
+        const method = this.methods[7], opt = this._transport.mergeOptions(options);
-			method,
+        return stackIntercept<TrackRequest, Queue>("unary", this._transport, method, opt, input);
-			opt,
+    }
-			input
+    /**
-		);
+     * @generated from protobuf rpc: AddTrackToQueue(player.TrackRequest) returns (player.Queue);
+     */
+    addTrackToQueue(input: TrackRequest, options?: RpcOptions): UnaryCall<TrackRequest, Queue> {
+        const method = this.methods[8], opt = this._transport.mergeOptions(options);
+        return stackIntercept<TrackRequest, Queue>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: SkipTrack(google.protobuf.Empty) returns (player.PlayerStatus);
+     */
+    skipTrack(input: Empty, options?: RpcOptions): UnaryCall<Empty, PlayerStatus> {
+        const method = this.methods[9], opt = this._transport.mergeOptions(options);
+        return stackIntercept<Empty, PlayerStatus>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: SkipToQueueIndex(player.SkipToQueueIndexRequest) returns (player.PlayerStatus);
+     */
+    skipToQueueIndex(input: SkipToQueueIndexRequest, options?: RpcOptions): UnaryCall<SkipToQueueIndexRequest, PlayerStatus> {
+        const method = this.methods[10], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SkipToQueueIndexRequest, PlayerStatus>("unary", this._transport, method, opt, input);
     }
 }

src/lib/proto/player.ts

@@ -1,22 +1,22 @@
 // @generated by protobuf-ts 2.9.4
 // @generated from protobuf file "player.proto" (package "player", syntax proto3)
 // tslint:disable
-import { Empty } from './google/protobuf/empty';
+import { Empty } from "./google/protobuf/empty";
-import { ServiceType } from '@protobuf-ts/runtime-rpc';
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
-import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import { WireType } from '@protobuf-ts/runtime';
+import { WireType } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from "@protobuf-ts/runtime";
-import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import type { PartialMessage } from '@protobuf-ts/runtime';
+import type { PartialMessage } from "@protobuf-ts/runtime";
-import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MessageType } from '@protobuf-ts/runtime';
+import { MessageType } from "@protobuf-ts/runtime";
-import { Track } from './library';
+import { Track } from "./library";
 /**
- * @generated from protobuf message player.PlayTrackRequest
+ * @generated from protobuf message player.TrackRequest
  */
-export interface PlayTrackRequest {
+export interface TrackRequest {
     /**
      * @generated from protobuf field: string hash = 1;
      */
@@ -55,6 +55,19 @@ export interface PlayerStatus {
      * @generated from protobuf field: uint64 progress = 4;
      */
     progress: bigint;
+    /**
+     * @generated from protobuf field: repeated library.Track queue = 5;
+     */
+    queue: Track[];
+}
+/**
+ * @generated from protobuf message player.Queue
+ */
+export interface Queue {
+    /**
+     * @generated from protobuf field: repeated library.Track tracks = 1;
+     */
+    tracks: Track[];
 }
 /**
  * @generated from protobuf message player.PauseState
@@ -101,27 +114,31 @@ export interface SetVolumeResponse {
      */
     volume: number;
 }
+/**
+ * @generated from protobuf message player.SkipToQueueIndexRequest
+ */
+export interface SkipToQueueIndexRequest {
+    /**
+     * @generated from protobuf field: uint32 index = 1;
+     */
+    index: number;
+}
 // @generated message type with reflection information, may provide speed optimized methods
-class PlayTrackRequest$Type extends MessageType<PlayTrackRequest> {
+class TrackRequest$Type extends MessageType<TrackRequest> {
     constructor() {
-		super('player.PlayTrackRequest', [
+        super("player.TrackRequest", [
-			{ no: 1, name: 'hash', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }
+            { no: 1, name: "hash", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
-	create(value?: PartialMessage<PlayTrackRequest>): PlayTrackRequest {
+    create(value?: PartialMessage<TrackRequest>): TrackRequest {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
-		message.hash = '';
+        message.hash = "";
-		if (value !== undefined) reflectionMergePartial<PlayTrackRequest>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<TrackRequest>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackRequest): TrackRequest {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: PlayTrackRequest
-	): PlayTrackRequest {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -130,67 +147,46 @@ class PlayTrackRequest$Type extends MessageType<PlayTrackRequest> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: TrackRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: PlayTrackRequest,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* string hash = 1; */
-		if (message.hash !== '') writer.tag(1, WireType.LengthDelimited).string(message.hash);
+        if (message.hash !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.hash);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
 /**
- * @generated MessageType for protobuf message player.PlayTrackRequest
+ * @generated MessageType for protobuf message player.TrackRequest
  */
-export const PlayTrackRequest = new PlayTrackRequest$Type();
+export const TrackRequest = new TrackRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class PlayTrackResponse$Type extends MessageType<PlayTrackResponse> {
     constructor() {
-		super('player.PlayTrackResponse', [
+        super("player.PlayTrackResponse", [
-			{ no: 1, name: 'track', kind: 'message', T: () => Track },
+            { no: 1, name: "track", kind: "message", T: () => Track },
-			{
+            { no: 2, name: "position", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
-				no: 2,
-				name: 'position',
-				kind: 'scalar',
-				T: 4 /*ScalarType.UINT64*/,
-				L: 0 /*LongType.BIGINT*/
-			}
         ]);
     }
     create(value?: PartialMessage<PlayTrackResponse>): PlayTrackResponse {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.position = 0n;
-		if (value !== undefined) reflectionMergePartial<PlayTrackResponse>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<PlayTrackResponse>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PlayTrackResponse): PlayTrackResponse {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: PlayTrackResponse
-	): PlayTrackResponse {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -202,39 +198,25 @@ class PlayTrackResponse$Type extends MessageType<PlayTrackResponse> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: PlayTrackResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: PlayTrackResponse,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* library.Track track = 1; */
         if (message.track)
-			Track.internalBinaryWrite(
+            Track.internalBinaryWrite(message.track, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-				message.track,
-				writer.tag(1, WireType.LengthDelimited).fork(),
-				options
-			).join();
         /* uint64 position = 2; */
-		if (message.position !== 0n) writer.tag(2, WireType.Varint).uint64(message.position);
+        if (message.position !== 0n)
+            writer.tag(2, WireType.Varint).uint64(message.position);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -245,45 +227,31 @@ export const PlayTrackResponse = new PlayTrackResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class PlayerStatus$Type extends MessageType<PlayerStatus> {
     constructor() {
-		super('player.PlayerStatus', [
+        super("player.PlayerStatus", [
-			{ no: 1, name: 'currently_playing', kind: 'message', T: () => Track },
+            { no: 1, name: "currently_playing", kind: "message", T: () => Track },
-			{ no: 2, name: 'is_paused', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "is_paused", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
-			{ no: 3, name: 'volume', kind: 'scalar', T: 2 /*ScalarType.FLOAT*/ },
+            { no: 3, name: "volume", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
-			{
+            { no: 4, name: "progress", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
-				no: 4,
+            { no: 5, name: "queue", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Track }
-				name: 'progress',
-				kind: 'scalar',
-				T: 4 /*ScalarType.UINT64*/,
-				L: 0 /*LongType.BIGINT*/
-			}
         ]);
     }
     create(value?: PartialMessage<PlayerStatus>): PlayerStatus {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.isPaused = false;
         message.volume = 0;
         message.progress = 0n;
-		if (value !== undefined) reflectionMergePartial<PlayerStatus>(this, message, value);
+        message.queue = [];
+        if (value !== undefined)
+            reflectionMergePartial<PlayerStatus>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PlayerStatus): PlayerStatus {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: PlayerStatus
-	): PlayerStatus {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
                 case /* optional library.Track currently_playing */ 1:
-					message.currentlyPlaying = Track.internalBinaryRead(
+                    message.currentlyPlaying = Track.internalBinaryRead(reader, reader.uint32(), options, message.currentlyPlaying);
-						reader,
-						reader.uint32(),
-						options,
-						message.currentlyPlaying
-					);
                     break;
                 case /* bool is_paused */ 2:
                     message.isPaused = reader.bool();
@@ -294,45 +262,39 @@ class PlayerStatus$Type extends MessageType<PlayerStatus> {
                 case /* uint64 progress */ 4:
                     message.progress = reader.uint64().toBigInt();
                     break;
+                case /* repeated library.Track queue */ 5:
+                    message.queue.push(Track.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: PlayerStatus, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: PlayerStatus,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* optional library.Track currently_playing = 1; */
         if (message.currentlyPlaying)
-			Track.internalBinaryWrite(
+            Track.internalBinaryWrite(message.currentlyPlaying, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-				message.currentlyPlaying,
-				writer.tag(1, WireType.LengthDelimited).fork(),
-				options
-			).join();
         /* bool is_paused = 2; */
-		if (message.isPaused !== false) writer.tag(2, WireType.Varint).bool(message.isPaused);
+        if (message.isPaused !== false)
+            writer.tag(2, WireType.Varint).bool(message.isPaused);
         /* float volume = 3; */
-		if (message.volume !== 0) writer.tag(3, WireType.Bit32).float(message.volume);
+        if (message.volume !== 0)
+            writer.tag(3, WireType.Bit32).float(message.volume);
         /* uint64 progress = 4; */
-		if (message.progress !== 0n) writer.tag(4, WireType.Varint).uint64(message.progress);
+        if (message.progress !== 0n)
+            writer.tag(4, WireType.Varint).uint64(message.progress);
+        /* repeated library.Track queue = 5; */
+        for (let i = 0; i < message.queue.length; i++)
+            Track.internalBinaryWrite(message.queue[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -341,26 +303,68 @@ class PlayerStatus$Type extends MessageType<PlayerStatus> {
  */
 export const PlayerStatus = new PlayerStatus$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class Queue$Type extends MessageType<Queue> {
+    constructor() {
+        super("player.Queue", [
+            { no: 1, name: "tracks", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Track }
+        ]);
+    }
+    create(value?: PartialMessage<Queue>): Queue {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.tracks = [];
+        if (value !== undefined)
+            reflectionMergePartial<Queue>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Queue): Queue {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated library.Track tracks */ 1:
+                    message.tracks.push(Track.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Queue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated library.Track tracks = 1; */
+        for (let i = 0; i < message.tracks.length; i++)
+            Track.internalBinaryWrite(message.tracks[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message player.Queue
+ */
+export const Queue = new Queue$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class PauseState$Type extends MessageType<PauseState> {
     constructor() {
-		super('player.PauseState', [
+        super("player.PauseState", [
-			{ no: 1, name: 'is_paused', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ }
+            { no: 1, name: "is_paused", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
         ]);
     }
     create(value?: PartialMessage<PauseState>): PauseState {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.isPaused = false;
-		if (value !== undefined) reflectionMergePartial<PauseState>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<PauseState>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PauseState): PauseState {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: PauseState
-	): PauseState {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -369,32 +373,22 @@ class PauseState$Type extends MessageType<PauseState> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: PauseState, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: PauseState,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* bool is_paused = 1; */
-		if (message.isPaused !== false) writer.tag(1, WireType.Varint).bool(message.isPaused);
+        if (message.isPaused !== false)
+            writer.tag(1, WireType.Varint).bool(message.isPaused);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -405,30 +399,19 @@ export const PauseState = new PauseState$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class SeekPositionRequest$Type extends MessageType<SeekPositionRequest> {
     constructor() {
-		super('player.SeekPositionRequest', [
+        super("player.SeekPositionRequest", [
-			{
+            { no: 1, name: "position", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
-				no: 1,
-				name: 'position',
-				kind: 'scalar',
-				T: 4 /*ScalarType.UINT64*/,
-				L: 0 /*LongType.BIGINT*/
-			}
         ]);
     }
     create(value?: PartialMessage<SeekPositionRequest>): SeekPositionRequest {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.position = 0n;
-		if (value !== undefined) reflectionMergePartial<SeekPositionRequest>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<SeekPositionRequest>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SeekPositionRequest): SeekPositionRequest {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: SeekPositionRequest
-	): SeekPositionRequest {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -437,32 +420,22 @@ class SeekPositionRequest$Type extends MessageType<SeekPositionRequest> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: SeekPositionRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: SeekPositionRequest,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* uint64 position = 1; */
-		if (message.position !== 0n) writer.tag(1, WireType.Varint).uint64(message.position);
+        if (message.position !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.position);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -473,30 +446,19 @@ export const SeekPositionRequest = new SeekPositionRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class SeekPositionResponse$Type extends MessageType<SeekPositionResponse> {
     constructor() {
-		super('player.SeekPositionResponse', [
+        super("player.SeekPositionResponse", [
-			{
+            { no: 1, name: "position", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
-				no: 1,
-				name: 'position',
-				kind: 'scalar',
-				T: 4 /*ScalarType.UINT64*/,
-				L: 0 /*LongType.BIGINT*/
-			}
         ]);
     }
     create(value?: PartialMessage<SeekPositionResponse>): SeekPositionResponse {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.position = 0n;
-		if (value !== undefined) reflectionMergePartial<SeekPositionResponse>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<SeekPositionResponse>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SeekPositionResponse): SeekPositionResponse {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: SeekPositionResponse
-	): SeekPositionResponse {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -505,32 +467,22 @@ class SeekPositionResponse$Type extends MessageType<SeekPositionResponse> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: SeekPositionResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: SeekPositionResponse,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* uint64 position = 1; */
-		if (message.position !== 0n) writer.tag(1, WireType.Varint).uint64(message.position);
+        if (message.position !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.position);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -541,24 +493,19 @@ export const SeekPositionResponse = new SeekPositionResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class SetVolumeRequest$Type extends MessageType<SetVolumeRequest> {
     constructor() {
-		super('player.SetVolumeRequest', [
+        super("player.SetVolumeRequest", [
-			{ no: 1, name: 'volume', kind: 'scalar', T: 2 /*ScalarType.FLOAT*/ }
+            { no: 1, name: "volume", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
         ]);
     }
     create(value?: PartialMessage<SetVolumeRequest>): SetVolumeRequest {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.volume = 0;
-		if (value !== undefined) reflectionMergePartial<SetVolumeRequest>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<SetVolumeRequest>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SetVolumeRequest): SetVolumeRequest {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: SetVolumeRequest
-	): SetVolumeRequest {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -567,32 +514,22 @@ class SetVolumeRequest$Type extends MessageType<SetVolumeRequest> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: SetVolumeRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: SetVolumeRequest,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* float volume = 1; */
-		if (message.volume !== 0) writer.tag(1, WireType.Bit32).float(message.volume);
+        if (message.volume !== 0)
+            writer.tag(1, WireType.Bit32).float(message.volume);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -603,24 +540,19 @@ export const SetVolumeRequest = new SetVolumeRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class SetVolumeResponse$Type extends MessageType<SetVolumeResponse> {
     constructor() {
-		super('player.SetVolumeResponse', [
+        super("player.SetVolumeResponse", [
-			{ no: 1, name: 'volume', kind: 'scalar', T: 2 /*ScalarType.FLOAT*/ }
+            { no: 1, name: "volume", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
         ]);
     }
     create(value?: PartialMessage<SetVolumeResponse>): SetVolumeResponse {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.volume = 0;
-		if (value !== undefined) reflectionMergePartial<SetVolumeResponse>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<SetVolumeResponse>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SetVolumeResponse): SetVolumeResponse {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: SetVolumeResponse
-	): SetVolumeResponse {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -629,32 +561,22 @@ class SetVolumeResponse$Type extends MessageType<SetVolumeResponse> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: SetVolumeResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: SetVolumeResponse,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* float volume = 1; */
-		if (message.volume !== 0) writer.tag(1, WireType.Bit32).float(message.volume);
+        if (message.volume !== 0)
+            writer.tag(1, WireType.Bit32).float(message.volume);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -662,15 +584,66 @@ class SetVolumeResponse$Type extends MessageType<SetVolumeResponse> {
  * @generated MessageType for protobuf message player.SetVolumeResponse
  */
 export const SetVolumeResponse = new SetVolumeResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SkipToQueueIndexRequest$Type extends MessageType<SkipToQueueIndexRequest> {
+    constructor() {
+        super("player.SkipToQueueIndexRequest", [
+            { no: 1, name: "index", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+    create(value?: PartialMessage<SkipToQueueIndexRequest>): SkipToQueueIndexRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.index = 0;
+        if (value !== undefined)
+            reflectionMergePartial<SkipToQueueIndexRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SkipToQueueIndexRequest): SkipToQueueIndexRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint32 index */ 1:
+                    message.index = reader.uint32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: SkipToQueueIndexRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint32 index = 1; */
+        if (message.index !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.index);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message player.SkipToQueueIndexRequest
+ */
+export const SkipToQueueIndexRequest = new SkipToQueueIndexRequest$Type();
 /**
  * @generated ServiceType for protobuf service player.Player
  */
-export const Player = new ServiceType('player.Player', [
+export const Player = new ServiceType("player.Player", [
-	{ name: 'PlayTrack', options: {}, I: PlayTrackRequest, O: PlayTrackResponse },
+    { name: "PlayTrack", options: {}, I: TrackRequest, O: PlayTrackResponse },
-	{ name: 'ResumeTrack', options: {}, I: Empty, O: PauseState },
+    { name: "ResumeTrack", options: {}, I: Empty, O: PauseState },
-	{ name: 'PauseTrack', options: {}, I: Empty, O: PauseState },
+    { name: "PauseTrack", options: {}, I: Empty, O: PauseState },
-	{ name: 'TogglePause', options: {}, I: Empty, O: PauseState },
+    { name: "TogglePause", options: {}, I: Empty, O: PauseState },
-	{ name: 'GetStatus', serverStreaming: true, options: {}, I: Empty, O: PlayerStatus },
+    { name: "GetStatus", serverStreaming: true, options: {}, I: Empty, O: PlayerStatus },
-	{ name: 'SeekPosition', options: {}, I: SeekPositionRequest, O: SeekPositionResponse },
+    { name: "SeekPosition", options: {}, I: SeekPositionRequest, O: SeekPositionResponse },
-	{ name: 'SetVolume', options: {}, I: SetVolumeRequest, O: SetVolumeResponse }
+    { name: "SetVolume", options: {}, I: SetVolumeRequest, O: SetVolumeResponse },
+    { name: "PlayTrackNext", options: {}, I: TrackRequest, O: Queue },
+    { name: "AddTrackToQueue", options: {}, I: TrackRequest, O: Queue },
+    { name: "SkipTrack", options: {}, I: Empty, O: PlayerStatus },
+    { name: "SkipToQueueIndex", options: {}, I: SkipToQueueIndexRequest, O: PlayerStatus }
 ]);

src/lib/proto/settings.client.ts

@@ -1,20 +1,20 @@
 // @generated by protobuf-ts 2.9.4
 // @generated from protobuf file "settings.proto" (package "settings", syntax proto3)
 // tslint:disable
-import type { RpcTransport } from '@protobuf-ts/runtime-rpc';
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
-import type { ServiceInfo } from '@protobuf-ts/runtime-rpc';
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
-import { Settings } from './settings';
+import { Settings } from "./settings";
-import type { RefreshPathResponse } from './settings';
+import type { RefreshPathResponse } from "./settings";
-import type { RefreshPathRequest } from './settings';
+import type { RefreshPathRequest } from "./settings";
-import type { DeletePathResponse } from './settings';
+import type { DeletePathResponse } from "./settings";
-import type { DeletePathRequest } from './settings';
+import type { DeletePathRequest } from "./settings";
-import type { AddPathResponse } from './settings';
+import type { AddPathResponse } from "./settings";
-import type { AddPathRequest } from './settings';
+import type { AddPathRequest } from "./settings";
-import { stackIntercept } from '@protobuf-ts/runtime-rpc';
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
-import type { SettingsData } from './settings';
+import type { SettingsData } from "./settings";
-import type { Empty } from './google/protobuf/empty';
+import type { Empty } from "./google/protobuf/empty";
-import type { UnaryCall } from '@protobuf-ts/runtime-rpc';
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
 /**
  * @generated from protobuf service settings.Settings
  */
@@ -30,17 +30,11 @@ export interface ISettingsClient {
     /**
      * @generated from protobuf rpc: DeletePath(settings.DeletePathRequest) returns (settings.DeletePathResponse);
      */
-	deletePath(
+    deletePath(input: DeletePathRequest, options?: RpcOptions): UnaryCall<DeletePathRequest, DeletePathResponse>;
-		input: DeletePathRequest,
-		options?: RpcOptions
-	): UnaryCall<DeletePathRequest, DeletePathResponse>;
     /**
      * @generated from protobuf rpc: RefreshPath(settings.RefreshPathRequest) returns (settings.RefreshPathResponse);
      */
-	refreshPath(
+    refreshPath(input: RefreshPathRequest, options?: RpcOptions): UnaryCall<RefreshPathRequest, RefreshPathResponse>;
-		input: RefreshPathRequest,
-		options?: RpcOptions
-	): UnaryCall<RefreshPathRequest, RefreshPathResponse>;
 }
 /**
  * @generated from protobuf service settings.Settings
@@ -49,61 +43,34 @@ export class SettingsClient implements ISettingsClient, ServiceInfo {
     typeName = Settings.typeName;
     methods = Settings.methods;
     options = Settings.options;
-	constructor(private readonly _transport: RpcTransport) {}
+    constructor(private readonly _transport: RpcTransport) {
+    }
     /**
      * @generated from protobuf rpc: ListPaths(google.protobuf.Empty) returns (settings.SettingsData);
      */
     listPaths(input: Empty, options?: RpcOptions): UnaryCall<Empty, SettingsData> {
-		const method = this.methods[0],
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
-			opt = this._transport.mergeOptions(options);
+        return stackIntercept<Empty, SettingsData>("unary", this._transport, method, opt, input);
-		return stackIntercept<Empty, SettingsData>('unary', this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: AddPath(settings.AddPathRequest) returns (settings.AddPathResponse);
      */
     addPath(input: AddPathRequest, options?: RpcOptions): UnaryCall<AddPathRequest, AddPathResponse> {
-		const method = this.methods[1],
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
-			opt = this._transport.mergeOptions(options);
+        return stackIntercept<AddPathRequest, AddPathResponse>("unary", this._transport, method, opt, input);
-		return stackIntercept<AddPathRequest, AddPathResponse>(
-			'unary',
-			this._transport,
-			method,
-			opt,
-			input
-		);
     }
     /**
      * @generated from protobuf rpc: DeletePath(settings.DeletePathRequest) returns (settings.DeletePathResponse);
      */
-	deletePath(
+    deletePath(input: DeletePathRequest, options?: RpcOptions): UnaryCall<DeletePathRequest, DeletePathResponse> {
-		input: DeletePathRequest,
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
-		options?: RpcOptions
+        return stackIntercept<DeletePathRequest, DeletePathResponse>("unary", this._transport, method, opt, input);
-	): UnaryCall<DeletePathRequest, DeletePathResponse> {
-		const method = this.methods[2],
-			opt = this._transport.mergeOptions(options);
-		return stackIntercept<DeletePathRequest, DeletePathResponse>(
-			'unary',
-			this._transport,
-			method,
-			opt,
-			input
-		);
     }
     /**
      * @generated from protobuf rpc: RefreshPath(settings.RefreshPathRequest) returns (settings.RefreshPathResponse);
      */
-	refreshPath(
+    refreshPath(input: RefreshPathRequest, options?: RpcOptions): UnaryCall<RefreshPathRequest, RefreshPathResponse> {
-		input: RefreshPathRequest,
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
-		options?: RpcOptions
+        return stackIntercept<RefreshPathRequest, RefreshPathResponse>("unary", this._transport, method, opt, input);
-	): UnaryCall<RefreshPathRequest, RefreshPathResponse> {
-		const method = this.methods[3],
-			opt = this._transport.mergeOptions(options);
-		return stackIntercept<RefreshPathRequest, RefreshPathResponse>(
-			'unary',
-			this._transport,
-			method,
-			opt,
-			input
-		);
     }
 }

src/lib/proto/settings.ts

@@ -1,17 +1,17 @@
 // @generated by protobuf-ts 2.9.4
 // @generated from protobuf file "settings.proto" (package "settings", syntax proto3)
 // tslint:disable
-import { Empty } from './google/protobuf/empty';
+import { Empty } from "./google/protobuf/empty";
-import { ServiceType } from '@protobuf-ts/runtime-rpc';
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
-import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import { WireType } from '@protobuf-ts/runtime';
+import { WireType } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from "@protobuf-ts/runtime";
-import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import type { PartialMessage } from '@protobuf-ts/runtime';
+import type { PartialMessage } from "@protobuf-ts/runtime";
-import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MessageType } from '@protobuf-ts/runtime';
+import { MessageType } from "@protobuf-ts/runtime";
 /**
  * @generated from protobuf message settings.SettingsData
  */
@@ -64,7 +64,8 @@ export interface DeletePathRequest {
 /**
  * @generated from protobuf message settings.DeletePathResponse
  */
-export interface DeletePathResponse {}
+export interface DeletePathResponse {
+}
 /**
  * @generated from protobuf message settings.RefreshPathRequest
  */
@@ -77,75 +78,48 @@ export interface RefreshPathRequest {
 /**
  * @generated from protobuf message settings.RefreshPathResponse
  */
-export interface RefreshPathResponse {}
+export interface RefreshPathResponse {
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class SettingsData$Type extends MessageType<SettingsData> {
     constructor() {
-		super('settings.SettingsData', [
+        super("settings.SettingsData", [
-			{
+            { no: 1, name: "library_paths", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => LibraryPath }
-				no: 1,
-				name: 'library_paths',
-				kind: 'message',
-				repeat: 1 /*RepeatType.PACKED*/,
-				T: () => LibraryPath
-			}
         ]);
     }
     create(value?: PartialMessage<SettingsData>): SettingsData {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.libraryPaths = [];
-		if (value !== undefined) reflectionMergePartial<SettingsData>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<SettingsData>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SettingsData): SettingsData {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: SettingsData
-	): SettingsData {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
                 case /* repeated settings.LibraryPath library_paths */ 1:
-					message.libraryPaths.push(
+                    message.libraryPaths.push(LibraryPath.internalBinaryRead(reader, reader.uint32(), options));
-						LibraryPath.internalBinaryRead(reader, reader.uint32(), options)
-					);
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: SettingsData, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: SettingsData,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* repeated settings.LibraryPath library_paths = 1; */
         for (let i = 0; i < message.libraryPaths.length; i++)
-			LibraryPath.internalBinaryWrite(
+            LibraryPath.internalBinaryWrite(message.libraryPaths[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-				message.libraryPaths[i],
-				writer.tag(1, WireType.LengthDelimited).fork(),
-				options
-			).join();
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -156,26 +130,21 @@ export const SettingsData = new SettingsData$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class LibraryPath$Type extends MessageType<LibraryPath> {
     constructor() {
-		super('settings.LibraryPath', [
+        super("settings.LibraryPath", [
-			{ no: 1, name: 'id', kind: 'scalar', T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 1, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
-			{ no: 2, name: 'path', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }
+            { no: 2, name: "path", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
     create(value?: PartialMessage<LibraryPath>): LibraryPath {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.id = 0n;
-		message.path = '';
+        message.path = "";
-		if (value !== undefined) reflectionMergePartial<LibraryPath>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<LibraryPath>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LibraryPath): LibraryPath {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: LibraryPath
-	): LibraryPath {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -187,34 +156,25 @@ class LibraryPath$Type extends MessageType<LibraryPath> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: LibraryPath, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: LibraryPath,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* uint64 id = 1; */
-		if (message.id !== 0n) writer.tag(1, WireType.Varint).uint64(message.id);
+        if (message.id !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.id);
         /* string path = 2; */
-		if (message.path !== '') writer.tag(2, WireType.LengthDelimited).string(message.path);
+        if (message.path !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.path);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -225,24 +185,19 @@ export const LibraryPath = new LibraryPath$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class AddPathRequest$Type extends MessageType<AddPathRequest> {
     constructor() {
-		super('settings.AddPathRequest', [
+        super("settings.AddPathRequest", [
-			{ no: 1, name: 'path', kind: 'scalar', T: 9 /*ScalarType.STRING*/ }
+            { no: 1, name: "path", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
     create(value?: PartialMessage<AddPathRequest>): AddPathRequest {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
-		message.path = '';
+        message.path = "";
-		if (value !== undefined) reflectionMergePartial<AddPathRequest>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<AddPathRequest>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddPathRequest): AddPathRequest {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: AddPathRequest
-	): AddPathRequest {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -251,32 +206,22 @@ class AddPathRequest$Type extends MessageType<AddPathRequest> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: AddPathRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: AddPathRequest,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* string path = 1; */
-		if (message.path !== '') writer.tag(1, WireType.LengthDelimited).string(message.path);
+        if (message.path !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.path);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -287,24 +232,19 @@ export const AddPathRequest = new AddPathRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class AddPathResponse$Type extends MessageType<AddPathResponse> {
     constructor() {
-		super('settings.AddPathResponse', [
+        super("settings.AddPathResponse", [
-			{ no: 1, name: 'id', kind: 'scalar', T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
+            { no: 1, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
         ]);
     }
     create(value?: PartialMessage<AddPathResponse>): AddPathResponse {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.id = 0n;
-		if (value !== undefined) reflectionMergePartial<AddPathResponse>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<AddPathResponse>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AddPathResponse): AddPathResponse {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: AddPathResponse
-	): AddPathResponse {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -313,32 +253,22 @@ class AddPathResponse$Type extends MessageType<AddPathResponse> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: AddPathResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: AddPathResponse,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* uint64 id = 1; */
-		if (message.id !== 0n) writer.tag(1, WireType.Varint).uint64(message.id);
+        if (message.id !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.id);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -349,24 +279,19 @@ export const AddPathResponse = new AddPathResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class DeletePathRequest$Type extends MessageType<DeletePathRequest> {
     constructor() {
-		super('settings.DeletePathRequest', [
+        super("settings.DeletePathRequest", [
-			{ no: 1, name: 'id', kind: 'scalar', T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
+            { no: 1, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
         ]);
     }
     create(value?: PartialMessage<DeletePathRequest>): DeletePathRequest {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.id = 0n;
-		if (value !== undefined) reflectionMergePartial<DeletePathRequest>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<DeletePathRequest>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeletePathRequest): DeletePathRequest {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: DeletePathRequest
-	): DeletePathRequest {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -375,32 +300,22 @@ class DeletePathRequest$Type extends MessageType<DeletePathRequest> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: DeletePathRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: DeletePathRequest,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* uint64 id = 1; */
-		if (message.id !== 0n) writer.tag(1, WireType.Varint).uint64(message.id);
+        if (message.id !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.id);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -411,28 +326,21 @@ export const DeletePathRequest = new DeletePathRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class DeletePathResponse$Type extends MessageType<DeletePathResponse> {
     constructor() {
-		super('settings.DeletePathResponse', []);
+        super("settings.DeletePathResponse", []);
     }
     create(value?: PartialMessage<DeletePathResponse>): DeletePathResponse {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
-		if (value !== undefined) reflectionMergePartial<DeletePathResponse>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<DeletePathResponse>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeletePathResponse): DeletePathResponse {
-		reader: IBinaryReader,
-		length: number,
-		options: BinaryReadOptions,
-		target?: DeletePathResponse
-	): DeletePathResponse {
         return target ?? this.create();
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: DeletePathResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: DeletePathResponse,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -443,24 +351,19 @@ export const DeletePathResponse = new DeletePathResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class RefreshPathRequest$Type extends MessageType<RefreshPathRequest> {
     constructor() {
-		super('settings.RefreshPathRequest', [
+        super("settings.RefreshPathRequest", [
-			{ no: 1, name: 'id', kind: 'scalar', T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
+            { no: 1, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
         ]);
     }
     create(value?: PartialMessage<RefreshPathRequest>): RefreshPathRequest {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
         message.id = 0n;
-		if (value !== undefined) reflectionMergePartial<RefreshPathRequest>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<RefreshPathRequest>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RefreshPathRequest): RefreshPathRequest {
-		reader: IBinaryReader,
+        let message = target ?? this.create(), end = reader.pos + length;
-		length: number,
-		options: BinaryReadOptions,
-		target?: RefreshPathRequest
-	): RefreshPathRequest {
-		let message = target ?? this.create(),
-			end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
@@ -469,32 +372,22 @@ class RefreshPathRequest$Type extends MessageType<RefreshPathRequest> {
                     break;
                 default:
                     let u = options.readUnknownField;
-					if (u === 'throw')
+                    if (u === "throw")
-						throw new globalThis.Error(
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-							`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
-						);
                     let d = reader.skip(wireType);
                     if (u !== false)
-						(u === true ? UnknownFieldHandler.onRead : u)(
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-							this.typeName,
-							message,
-							fieldNo,
-							wireType,
-							d
-						);
             }
         }
         return message;
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: RefreshPathRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: RefreshPathRequest,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         /* uint64 id = 1; */
-		if (message.id !== 0n) writer.tag(1, WireType.Varint).uint64(message.id);
+        if (message.id !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.id);
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -505,28 +398,21 @@ export const RefreshPathRequest = new RefreshPathRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class RefreshPathResponse$Type extends MessageType<RefreshPathResponse> {
     constructor() {
-		super('settings.RefreshPathResponse', []);
+        super("settings.RefreshPathResponse", []);
     }
     create(value?: PartialMessage<RefreshPathResponse>): RefreshPathResponse {
-		const message = globalThis.Object.create(this.messagePrototype!);
+        const message = globalThis.Object.create((this.messagePrototype!));
-		if (value !== undefined) reflectionMergePartial<RefreshPathResponse>(this, message, value);
+        if (value !== undefined)
+            reflectionMergePartial<RefreshPathResponse>(this, message, value);
         return message;
     }
-	internalBinaryRead(
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RefreshPathResponse): RefreshPathResponse {
-		reader: IBinaryReader,
-		length: number,
-		options: BinaryReadOptions,
-		target?: RefreshPathResponse
-	): RefreshPathResponse {
         return target ?? this.create();
     }
-	internalBinaryWrite(
+    internalBinaryWrite(message: RefreshPathResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-		message: RefreshPathResponse,
-		writer: IBinaryWriter,
-		options: BinaryWriteOptions
-	): IBinaryWriter {
         let u = options.writeUnknownFields;
-		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
         return writer;
     }
 }
@@ -537,9 +423,9 @@ export const RefreshPathResponse = new RefreshPathResponse$Type();
 /**
  * @generated ServiceType for protobuf service settings.Settings
  */
-export const Settings = new ServiceType('settings.Settings', [
+export const Settings = new ServiceType("settings.Settings", [
-	{ name: 'ListPaths', options: {}, I: Empty, O: SettingsData },
+    { name: "ListPaths", options: {}, I: Empty, O: SettingsData },
-	{ name: 'AddPath', options: {}, I: AddPathRequest, O: AddPathResponse },
+    { name: "AddPath", options: {}, I: AddPathRequest, O: AddPathResponse },
-	{ name: 'DeletePath', options: {}, I: DeletePathRequest, O: DeletePathResponse },
+    { name: "DeletePath", options: {}, I: DeletePathRequest, O: DeletePathResponse },
-	{ name: 'RefreshPath', options: {}, I: RefreshPathRequest, O: RefreshPathResponse }
+    { name: "RefreshPath", options: {}, I: RefreshPathRequest, O: RefreshPathResponse }
 ]);

src/routes/player/+page.server.ts

@@ -2,8 +2,30 @@ import { PlayerClient } from '$lib/proto/player.client';
 import { fail } from '@sveltejs/kit';
 import { protoTransport } from '../../hooks.server';
 import type { Actions } from './$types';
+import { serializable } from '$lib/proto';
+import type { PlayerStatus } from '$lib/proto/player';
 
 export const actions = {
+	skip: async () => {
+		const client = new PlayerClient(protoTransport);
+
+		const response = await client.skipTrack({});
+
+		return serializable<PlayerStatus>(response.response);
+	},
+	'skip-to-queue-index': async ({ url }) => {
+		const index = url.searchParams.get('index')?.toString();
+
+		if (!index) {
+			return fail(400);
+		}
+
+		const client = new PlayerClient(protoTransport);
+
+		const response = await client.skipToQueueIndex({ index: parseInt(index) });
+
+		return serializable<PlayerStatus>(response.response);
+	},
 	resume: async () => {
 		const client = new PlayerClient(protoTransport);
 

src/routes/tracks/[hash]/+page.server.ts

@@ -3,7 +3,7 @@ import { fail } from '@sveltejs/kit';
 import { protoTransport } from '../../../hooks.server';
 import type { Actions } from './$types';
 import { serializable } from '$lib/proto';
-import type { PlayTrackResponse } from '$lib/proto/player';
+import type { PlayTrackResponse, Queue } from '$lib/proto/player';
 
 export const actions = {
 	play: async ({ params }) => {
@@ -18,5 +18,23 @@ export const actions = {
 		}
 
 		return serializable<PlayTrackResponse>(response.response);
+	},
+	'add-to-queue': async ({ params }) => {
+		const client = new PlayerClient(protoTransport);
+
+		const response = await client.addTrackToQueue({
+			hash: params.hash
+		});
+
+		return serializable<Queue>(response.response);
+	},
+	'play-next': async ({ params }) => {
+		const client = new PlayerClient(protoTransport);
+
+		const response = await client.playTrackNext({
+			hash: params.hash
+		});
+
+		return serializable<Queue>(response.response);
 	}
 } satisfies Actions;