@quenty/soundplayer 7.30.0-canary.644.d3040d7.0 → 7.30.1-canary.45a29f2.0

package/CHANGELOG.md

@@ -3,7 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-# [7.30.0-canary.644.d3040d7.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/soundplayer@7.29.0...@quenty/soundplayer@7.30.0-canary.644.d3040d7.0) (2026-01-16)
+## [7.30.1-canary.45a29f2.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/soundplayer@7.30.0...@quenty/soundplayer@7.30.1-canary.45a29f2.0) (2026-01-18)
+
+
+### Bug Fixes
+
+* Push sound order priority ([45a29f2](https://github.com/Quenty/NevermoreEngine/commit/45a29f21a00d72d7971299695e28129d5b9d0cfb))
+
+
+### Features
+
+* Make hiding work ([8203ae4](https://github.com/Quenty/NevermoreEngine/commit/8203ae460bd4e5866f7328c54ac48f62addfd637))
+* Route sound player into stack ([8ec445b](https://github.com/Quenty/NevermoreEngine/commit/8ec445bc4d3cd60b247f78b37f19ba902e2e477a))
+
+
+
+
+
+# [7.30.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/soundplayer@7.29.0...@quenty/soundplayer@7.30.0) (2026-01-16)
 
 **Note:** Version bump only for package @quenty/soundplayer
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/soundplayer",
-  "version": "7.30.0-canary.644.d3040d7.0",
+  "version": "7.30.1-canary.45a29f2.0",
   "description": "Sound playback helper",
   "keywords": [
     "Roblox",
@@ -30,26 +30,28 @@
   "dependencies": {
     "@quenty/adorneeutils": "3.3.5",
     "@quenty/baseobject": "10.9.3",
-    "@quenty/blend": "12.27.0-canary.644.d3040d7.0",
-    "@quenty/brio": "14.23.0",
-    "@quenty/instanceutils": "13.23.0",
+    "@quenty/blend": "12.27.1-canary.45a29f2.0",
+    "@quenty/brio": "14.23.1-canary.45a29f2.0",
+    "@quenty/instanceutils": "13.23.1-canary.45a29f2.0",
     "@quenty/loader": "10.9.3",
     "@quenty/maid": "3.5.3",
     "@quenty/numberrangeutils": "3.1.3",
+    "@quenty/observablecollection": "12.29.1-canary.45a29f2.0",
     "@quenty/promise": "10.13.0",
     "@quenty/promisemaid": "5.13.0",
     "@quenty/randomutils": "6.12.2",
     "@quenty/rbxasset": "5.10.3",
-    "@quenty/rx": "13.22.0",
+    "@quenty/rx": "13.22.1-canary.45a29f2.0",
     "@quenty/signal": "7.11.5",
+    "@quenty/soundgroup": "1.31.1-canary.45a29f2.0",
     "@quenty/sounds": "10.16.0",
     "@quenty/table": "3.9.2",
-    "@quenty/transitionmodel": "7.29.0-canary.644.d3040d7.0",
-    "@quenty/valueobject": "13.24.0",
+    "@quenty/transitionmodel": "7.29.1-canary.45a29f2.0",
+    "@quenty/valueobject": "13.24.1-canary.45a29f2.0",
     "@quentystudios/t": "^3.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d3040d7a07ae7b2586bb982399b401fe19f1eb3f"
+  "gitHead": "45a29f21a00d72d7971299695e28129d5b9d0cfb"
 }

package/src/Client/Loops/Layered/LayeredLoopedSoundPlayer.lua

@@ -9,8 +9,11 @@
 
 local require = require(script.Parent.loader).load(script)
 
+local LayeredSoundHelper = require("LayeredSoundHelper")
 local LoopedSoundPlayer = require("LoopedSoundPlayer")
 local Maid = require("Maid")
+local Promise = require("Promise")
+local PromiseUtils = require("PromiseUtils")
 local Rx = require("Rx")
 local SoundLoopScheduleUtils = require("SoundLoopScheduleUtils")
 local SoundUtils = require("SoundUtils")
@@ -25,13 +28,13 @@ LayeredLoopedSoundPlayer.__index = LayeredLoopedSoundPlayer
 export type LayeredLoopedSoundPlayer =
 	typeof(setmetatable(
 		{} :: {
-			_layerMaid: Maid.Maid,
-			_soundParent: ValueObject.ValueObject<Instance?>,
-			_soundGroup: ValueObject.ValueObject<SoundGroup?>,
-			_bpm: ValueObject.ValueObject<number?>,
+			_defaultSoundParent: ValueObject.ValueObject<Instance?>,
+			_defaultSoundGroup: ValueObject.ValueObject<SoundGroup?>,
+			_defaultBPM: ValueObject.ValueObject<number?>,
 			_defaultCrossFadeTime: ValueObject.ValueObject<number>,
 			_volumeMultiplier: ValueObject.ValueObject<number>,
-			_layers: { [string]: LoopedSoundPlayer.LoopedSoundPlayer },
+
+			_layeredSoundHelper: LayeredSoundHelper.LayeredSoundHelper<LoopedSoundPlayer.LoopedSoundPlayer>,
 		},
 		{} :: typeof({ __index = LayeredLoopedSoundPlayer })
 	))
@@ -46,15 +49,17 @@ export type LayeredLoopedSoundPlayer =
 function LayeredLoopedSoundPlayer.new(soundParent: Instance?): LayeredLoopedSoundPlayer
 	local self: LayeredLoopedSoundPlayer = setmetatable(SpringTransitionModel.new() :: any, LayeredLoopedSoundPlayer)
 
-	self._layerMaid = self._maid:Add(Maid.new())
-
-	self._soundParent = self._maid:Add(ValueObject.new(nil, t.optional(t.Instance)))
-	self._soundGroup = self._maid:Add(ValueObject.new(nil, t.optional(t.Instance)))
-	self._bpm = self._maid:Add(ValueObject.new(nil, t.optional(t.number)))
+	self._defaultSoundParent = self._maid:Add(ValueObject.new(nil, t.optional(t.Instance)))
+	self._defaultSoundGroup = self._maid:Add(ValueObject.new(nil, t.optional(t.Instance)))
+	self._defaultBPM = self._maid:Add(ValueObject.new(nil, t.optional(t.number)))
 	self._defaultCrossFadeTime = self._maid:Add(ValueObject.new(0.5, "number"))
 	self._volumeMultiplier = self._maid:Add(ValueObject.new(1, "number"))
 
-	self._layers = {}
+	self._layeredSoundHelper = self._maid:Add(LayeredSoundHelper.new(function(maid): any
+		local layer = maid:Add(LoopedSoundPlayer.new())
+		self:_handleNewLayer(maid, layer)
+		return layer
+	end))
 
 	if soundParent then
 		self:SetSoundParent(soundParent)
@@ -87,7 +92,7 @@ end
 	Sets the BPM for syncing sound playback.
 ]=]
 function LayeredLoopedSoundPlayer.SetBPM(self: LayeredLoopedSoundPlayer, bpm: ValueObject.Mountable<number?>): () -> ()
-	return self._bpm:Mount(bpm)
+	return self._defaultBPM:Mount(bpm)
 end
 
 --[=[
@@ -96,7 +101,7 @@ end
 function LayeredLoopedSoundPlayer.SetSoundParent(self: LayeredLoopedSoundPlayer, soundParent: Instance?): ()
 	assert(typeof(soundParent) == "Instance" or soundParent == nil, "Bad soundParent")
 
-	self._soundParent.Value = soundParent
+	self._defaultSoundParent.Value = soundParent
 end
 
 --[=[
@@ -106,7 +111,7 @@ function LayeredLoopedSoundPlayer.SetSoundGroup(
 	self: LayeredLoopedSoundPlayer,
 	soundGroup: ValueObject.Mountable<SoundGroup?>
 ): () -> ()
-	return self._soundGroup:Mount(soundGroup)
+	return self._defaultSoundGroup:Mount(soundGroup)
 end
 
 --[=[
@@ -122,7 +127,7 @@ function LayeredLoopedSoundPlayer.Swap(
 	assert(SoundUtils.isConvertableToRbxAsset(soundId) or soundId == nil, "Bad soundId")
 	assert(SoundLoopScheduleUtils.isLoopedSchedule(scheduleOptions) or scheduleOptions == nil, "Bad scheduleOptions")
 
-	local layer = self:_getOrCreateLayer(layerId)
+	local layer = self._layeredSoundHelper:GetOrCreateLayer(layerId)
 	layer:Swap(soundId, scheduleOptions)
 end
 
@@ -138,7 +143,7 @@ function LayeredLoopedSoundPlayer.SwapOnLoop(
 	assert(type(layerId) == "string", "Bad layerId")
 	assert(SoundUtils.isConvertableToRbxAsset(soundId) or soundId == nil, "Bad soundId")
 
-	local layer = self:_getOrCreateLayer(layerId)
+	local layer = self._layeredSoundHelper:GetOrCreateLayer(layerId)
 	layer:SwapOnLoop(soundId, scheduleOptions)
 end
 
@@ -155,7 +160,7 @@ function LayeredLoopedSoundPlayer.SwapToSamples(
 	assert(type(soundIdList) == "table", "Bad soundIdList")
 	assert(SoundLoopScheduleUtils.isLoopedSchedule(scheduleOptions) or scheduleOptions == nil, "Bad scheduleOptions")
 
-	local layer = self:_getOrCreateLayer(layerId)
+	local layer = self._layeredSoundHelper:GetOrCreateLayer(layerId)
 	layer:SwapToSamples(soundIdList, scheduleOptions)
 end
 
@@ -172,7 +177,7 @@ function LayeredLoopedSoundPlayer.SwapToChoice(
 	assert(type(soundIdList) == "table", "Bad soundIdList")
 	assert(SoundLoopScheduleUtils.isLoopedSchedule(scheduleOptions) or scheduleOptions == nil, "Bad scheduleOptions")
 
-	local layer = self:_getOrCreateLayer(layerId)
+	local layer = self._layeredSoundHelper:GetOrCreateLayer(layerId)
 	layer:SwapToChoice(soundIdList, scheduleOptions)
 end
 
@@ -188,7 +193,7 @@ function LayeredLoopedSoundPlayer.PlayOnce(
 	assert(type(layerId) == "string", "Bad layerId")
 	assert(SoundLoopScheduleUtils.isLoopedSchedule(scheduleOptions) or scheduleOptions == nil, "Bad scheduleOptions")
 
-	local layer = self:_getOrCreateLayer(layerId)
+	local layer = self._layeredSoundHelper:GetOrCreateLayer(layerId)
 	layer:PlayOnce(soundId, scheduleOptions)
 end
 
@@ -203,41 +208,25 @@ function LayeredLoopedSoundPlayer.PlayOnceOnLoop(
 ): ()
 	assert(type(layerId) == "string", "Bad layerId")
 
-	local layer = self:_getOrCreateLayer(layerId)
+	local layer = self._layeredSoundHelper:GetOrCreateLayer(layerId)
 	layer:PlayOnceOnLoop(soundId, scheduleOptions)
 end
 
-function LayeredLoopedSoundPlayer._getOrCreateLayer(
+function LayeredLoopedSoundPlayer._handleNewLayer(
 	self: LayeredLoopedSoundPlayer,
-	layerId: string
-): LoopedSoundPlayer.LoopedSoundPlayer
-	if self._layers[layerId] then
-		return self._layers[layerId]
-	end
-
-	local maid = Maid.new()
-
-	local layer = maid:Add(LoopedSoundPlayer.new())
+	maid: Maid.Maid,
+	layer: LoopedSoundPlayer.LoopedSoundPlayer
+): ()
 	layer:SetDoSyncSoundPlayback(true)
-
-	maid:GiveTask(self._soundGroup:Observe():Subscribe(function(soundGroup)
-		layer:SetSoundGroup(soundGroup)
-	end))
-
+	maid:GiveTask(layer:SetSoundGroup(self._defaultSoundGroup:Observe()))
 	maid:GiveTask(layer:SetCrossFadeTime(self._defaultCrossFadeTime:Observe()))
-
-	maid:GiveTask(self._bpm:Observe():Subscribe(function(bpm)
-		layer:SetBPM(bpm)
-	end))
+	maid:GiveTask(layer:SetBPM(self._defaultBPM:Observe()))
+	maid:GiveTask(layer:SetSoundParent(self._defaultSoundParent:Observe()))
 
 	maid:GiveTask(self:ObserveVisible():Subscribe(function(isVisible, doNotAnimate)
 		layer:SetVisible(isVisible, doNotAnimate)
 	end))
 
-	maid:GiveTask(self._soundParent:Observe():Subscribe(function(parent)
-		layer:SetSoundParent(parent)
-	end))
-
 	maid:GiveTask(Rx.combineLatest({
 		visible = self:ObserveRenderStepped(),
 		multiplier = self._volumeMultiplier:Observe(),
@@ -245,29 +234,33 @@ function LayeredLoopedSoundPlayer._getOrCreateLayer(
 		layer:SetVolumeMultiplier(state.multiplier * state.visible)
 	end))
 
-	self._layers[layerId] = layer
-	maid:GiveTask(function()
-		if self._layers[layerId] == layer then
-			self._layers[layerId] = nil
-		end
-	end)
-
-	self._layerMaid[layerId] = maid
-
 	return layer
 end
 
 --[=[
 	Stops playback on the given layer.
 ]=]
-function LayeredLoopedSoundPlayer.StopLayer(self: LayeredLoopedSoundPlayer, layerId: string): ()
+function LayeredLoopedSoundPlayer.StopLayer(
+	self: LayeredLoopedSoundPlayer,
+	layerId: string,
+	doNotAnimate: boolean?
+): Promise.Promise<()>
 	assert(type(layerId) == "string", "Bad layerId")
 
-	self._layerMaid[layerId] = nil
+	local found = self._layeredSoundHelper:FindLayer(layerId)
+	if not found then
+		return Promise.resolved()
+	end
+
+	return found:PromiseHide(doNotAnimate)
 end
 
-function LayeredLoopedSoundPlayer.StopAll(self: LayeredLoopedSoundPlayer): ()
-	self._layerMaid:DoCleaning()
+function LayeredLoopedSoundPlayer.StopAll(self: LayeredLoopedSoundPlayer, doNotAnimate: boolean?): ()
+	local promises: { Promise.Promise<()> } = {}
+	for _, layer: any in self._layeredSoundHelper:GetAllLayers() do
+		table.insert(promises, layer:PromiseHide(doNotAnimate))
+	end
+	return PromiseUtils.all(promises)
 end
 
 return LayeredLoopedSoundPlayer

package/src/Client/Loops/Layered/LayeredSoundHelper.lua

@@ -0,0 +1,83 @@
+--!strict
+--[=[
+    @class LayeredSoundHelper
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local Maid = require("Maid")
+
+local LayeredSoundHelper = setmetatable({}, BaseObject)
+LayeredSoundHelper.ClassName = "LayeredSoundHelper"
+LayeredSoundHelper.__index = LayeredSoundHelper
+
+export type CreateSoundPlayer<T> = (maid: Maid.Maid, layerId: string) -> T
+
+export type LayeredSoundHelper<T> =
+	typeof(setmetatable(
+		{} :: {
+			_layerMaid: Maid.Maid,
+			_createSoundPlayer: CreateSoundPlayer<T>,
+			_layers: { [string]: T },
+		},
+		{} :: typeof({ __index = LayeredSoundHelper })
+	))
+	& BaseObject.BaseObject
+
+function LayeredSoundHelper.new<T>(createSoundPlayer: CreateSoundPlayer<T>): LayeredSoundHelper<T>
+	local self: LayeredSoundHelper<T> = setmetatable(BaseObject.new() :: any, LayeredSoundHelper)
+
+	self._createSoundPlayer = assert(createSoundPlayer, "No createSoundPlayer")
+
+	self._layerMaid = self._maid:Add(Maid.new())
+	self._layers = {}
+
+	return self
+end
+
+function LayeredSoundHelper.GetOrCreateLayer<T>(self: LayeredSoundHelper<T>, layerId: string): T
+	if self._layers[layerId] then
+		return self._layers[layerId]
+	end
+
+	local maid = Maid.new()
+
+	local layer = maid:Add(self._createSoundPlayer(maid, layerId))
+
+	self._layers[layerId] = layer
+	maid:GiveTask(function()
+		if self._layers[layerId] == layer then
+			self._layers[layerId] = nil
+		end
+	end)
+
+	self._layerMaid[layerId] = maid
+
+	-- Generic typing wasn't happy with enforcing inheritance
+	maid:GiveTask((layer :: any).HidingComplete:Connect(function()
+		self._layerMaid[layerId] = nil
+	end))
+
+	return layer
+end
+
+function LayeredSoundHelper.FindLayer<T>(self: LayeredSoundHelper<T>, layerId: string): T?
+	return self._layers[layerId]
+end
+
+function LayeredSoundHelper.GetAllLayers<T>(self: LayeredSoundHelper<T>): { [string]: T }
+	return self._layers
+end
+
+function LayeredSoundHelper.RemovePlayer<T>(self: LayeredSoundHelper<T>, layerId: string): ()
+	assert(type(layerId) == "string", "Bad layerId")
+
+	self._layerMaid[layerId] = nil
+end
+
+function LayeredSoundHelper.RemoveAllPlayers<T>(self: LayeredSoundHelper<T>): ()
+	self._layerMaid:DoCleaning()
+end
+
+return LayeredSoundHelper

package/src/Client/Loops/LoopedSoundPlayer.lua

@@ -22,11 +22,18 @@ local SoundPromiseUtils = require("SoundPromiseUtils")
 local SoundUtils = require("SoundUtils")
 local SpringTransitionModel = require("SpringTransitionModel")
 local ValueObject = require("ValueObject")
+local t = require("t")
 
 local LoopedSoundPlayer = setmetatable({}, SpringTransitionModel)
 LoopedSoundPlayer.ClassName = "LoopedSoundPlayer"
 LoopedSoundPlayer.__index = LoopedSoundPlayer
 
+type TimePositionData = {
+	SoundId: SoundUtils.SoundId,
+	TimePosition: number,
+	Timestamp: number,
+}
+
 export type LoopedSoundPlayer =
 	typeof(setmetatable(
 		{} :: {
@@ -38,10 +45,12 @@ export type LoopedSoundPlayer =
 			_crossFadeTime: ValueObject.ValueObject<number>,
 			_volumeMultiplier: ValueObject.ValueObject<number>,
 			_doSyncSoundPlayback: ValueObject.ValueObject<boolean>,
+			_restoreTimePosition: ValueObject.ValueObject<boolean>,
 			_currentActiveSound: ValueObject.ValueObject<Sound?>,
 			_currentSoundId: ValueObject.ValueObject<SoundUtils.SoundId?>,
 			_defaultScheduleOptions: SoundLoopScheduleUtils.SoundLoopSchedule,
 			_currentLoopSchedule: ValueObject.ValueObject<SoundLoopScheduleUtils.SoundLoopSchedule>,
+			_lastTimePositionData: TimePositionData?,
 		},
 		{} :: typeof({ __index = LoopedSoundPlayer })
 	))
@@ -57,14 +66,16 @@ function LoopedSoundPlayer.new(soundId: SoundUtils.SoundId?, soundParent: Instan
 
 	self:SetSpeed(10)
 
-	self._bpm = self._maid:Add(ValueObject.new(nil))
-	self._soundParent = self._maid:Add(ValueObject.new(nil))
-	self._soundGroup = self._maid:Add(ValueObject.new(nil))
+	self._bpm = self._maid:Add(ValueObject.new(nil, t.optional(t.number :: any)))
+	self._soundParent = self._maid:Add(ValueObject.new(nil, t.optional(t.Instance :: any)))
+	self._soundGroup = self._maid:Add(ValueObject.new(nil, t.optional(t.Instance :: any)))
 	self._crossFadeTime = self._maid:Add(ValueObject.new(0.5, "number"))
 	self._volumeMultiplier = self._maid:Add(ValueObject.new(1, "number"))
 	self._doSyncSoundPlayback = self._maid:Add(ValueObject.new(false, "boolean"))
-	self._currentActiveSound = self._maid:Add(ValueObject.new(nil))
+	self._restoreTimePosition = self._maid:Add(ValueObject.new(true, "boolean"))
+	self._currentActiveSound = self._maid:Add(ValueObject.new(nil, t.optional(t.Instance :: any)))
 	self._currentSoundId = self._maid:Add(ValueObject.new(soundId))
+	self._lastTimePositionData = nil
 
 	self._defaultScheduleOptions = SoundLoopScheduleUtils.default()
 	self._currentLoopSchedule = self._maid:Add(ValueObject.new(self._defaultScheduleOptions))
@@ -114,25 +125,23 @@ end
 --[=[
 	Sets the BPM for syncing sound playback.
 ]=]
-function LoopedSoundPlayer.SetBPM(self: LoopedSoundPlayer, bpm: number?): ()
-	assert(type(bpm) == "number" or bpm == nil, "Bad bpm")
-
-	self._bpm.Value = bpm
+function LoopedSoundPlayer.SetBPM(self: LoopedSoundPlayer, bpm: ValueObject.Mountable<number?>): () -> ()
+	return self._bpm:Mount(bpm)
 end
 
 --[=[
 	Sets the parent instance for the sound.
 ]=]
-function LoopedSoundPlayer.SetSoundParent(self: LoopedSoundPlayer, parent: Instance?): ()
-	self._soundParent.Value = parent
+function LoopedSoundPlayer.SetSoundParent(self: LoopedSoundPlayer, parent: ValueObject.Mountable<Instance?>): () -> ()
+	return self._soundParent:Mount(parent)
 end
 
 function LoopedSoundPlayer.Swap(
 	self: LoopedSoundPlayer,
-	soundId: SoundUtils.SoundId,
+	soundId: SoundUtils.SoundId?,
 	loopSchedule: SoundLoopScheduleUtils.SoundLoopSchedule?
 ): ()
-	assert(SoundUtils.isConvertableToRbxAsset(soundId) or soundId == nil, "Bad soundId")
+	assert(soundId == nil or SoundUtils.isConvertableToRbxAsset(soundId), "Bad soundId")
 	loopSchedule = self:_convertToLoopedSchedule(loopSchedule)
 	assert(loopSchedule ~= nil, "Bad loopSchedule")
 
@@ -153,6 +162,10 @@ function LoopedSoundPlayer.SetDoSyncSoundPlayback(self: LoopedSoundPlayer, doSyn
 	self._doSyncSoundPlayback.Value = doSyncSoundPlayback
 end
 
+function LoopedSoundPlayer.SetDoRestoreTimePosition(self: LoopedSoundPlayer, doRestoreTimePosition: boolean): ()
+	self._restoreTimePosition.Value = doRestoreTimePosition
+end
+
 function LoopedSoundPlayer._setupRender(self: LoopedSoundPlayer): ()
 	self._maid:GiveTask(self._currentSoundId
 		:ObserveBrio(function(value)
@@ -170,6 +183,18 @@ function LoopedSoundPlayer._setupRender(self: LoopedSoundPlayer): ()
 		end))
 end
 
+function LoopedSoundPlayer._captureTimePositionData(
+	self: LoopedSoundPlayer,
+	soundId: SoundUtils.SoundId,
+	timePosition: number
+): ()
+	self._lastTimePositionData = {
+		SoundId = soundId,
+		TimePosition = timePosition,
+		Timestamp = os.clock(),
+	}
+end
+
 function LoopedSoundPlayer._renderSoundPlayer(self: LoopedSoundPlayer, soundId: SoundUtils.SoundId): Maid.Maid
 	local maid = Maid.new()
 
@@ -177,6 +202,7 @@ function LoopedSoundPlayer._renderSoundPlayer(self: LoopedSoundPlayer, soundId:
 	local soundPlayer: SimpleLoopedSoundPlayer.SimpleLoopedSoundPlayer =
 		renderMaid:Add(SimpleLoopedSoundPlayer.new(soundId))
 	soundPlayer:SetTransitionTime(self._crossFadeTime)
+	soundPlayer.Sound:Play()
 
 	renderMaid:GiveTask(self._soundGroup:Observe():Subscribe(function(soundGroup)
 		soundPlayer:SetSoundGroup(soundGroup)
@@ -185,11 +211,22 @@ function LoopedSoundPlayer._renderSoundPlayer(self: LoopedSoundPlayer, soundId:
 	renderMaid:GiveTask(Rx.combineLatest({
 		bpm = self._bpm:Observe(),
 		isLoaded = Rx.fromPromise(SoundPromiseUtils.promiseLoaded(soundPlayer.Sound)),
+		restoreTimePosition = self._restoreTimePosition:Observe(),
 		doSyncSoundPlayback = self._doSyncSoundPlayback:Observe(),
 		timeLength = RxInstanceUtils.observeProperty(soundPlayer.Sound, "TimeLength"),
 	}):Subscribe(function(state: any)
 		local syncMaid = Maid.new()
 
+		if state.restoreTimePosition then
+			local data = self._lastTimePositionData
+			if data and data.SoundId == soundId then
+				local ourFinalPosition = (data.TimePosition + (os.clock() - data.Timestamp)) % state.timeLength
+				soundPlayer.Sound.TimePosition = ourFinalPosition
+			end
+		end
+
+		self:_captureTimePositionData(soundId, soundPlayer.Sound.TimePosition)
+
 		if state.doSyncSoundPlayback then
 			if state.bpm then
 				local bps = state.bpm / 60
@@ -470,6 +507,10 @@ function LoopedSoundPlayer.StopAfterLoop(self: LoopedSoundPlayer): ()
 	self._maid._swappingTo = swapMaid
 end
 
+function LoopedSoundPlayer.GetCurrentSoundId(self: LoopedSoundPlayer): SoundUtils.SoundId?
+	return self._currentSoundId.Value
+end
+
 function LoopedSoundPlayer._observeActiveSoundFinishLoop(
 	self: LoopedSoundPlayer,
 	maxWaitTime: number

package/src/Client/Loops/SimpleLoopedSoundPlayer.lua

@@ -47,12 +47,6 @@ function SimpleLoopedSoundPlayer.new(soundId: SoundUtils.SoundId): SimpleLoopedS
 		self.Sound.Volume = state.visible * self._maxVolume * state.multiplier
 	end))
 
-	self._maid:GiveTask(self.VisibleChanged:Connect(function(isVisible)
-		if isVisible then
-			self.Sound:Play()
-		end
-	end))
-
 	return self
 end
 

package/src/Client/Loops/SimpleLoopedSoundPlayer.story.lua

@@ -18,6 +18,7 @@ return function(target)
 	simpleLoopedSoundPlayer:SetTransitionTime(1)
 
 	simpleLoopedSoundPlayer.Sound.Parent = target
+	simpleLoopedSoundPlayer.Sound:Play()
 
 	simpleLoopedSoundPlayer:Show()
 

package/src/Client/Service/SoundPlayerServiceClient.lua

@@ -0,0 +1,71 @@
+--!strict
+--[=[
+    @class SoundPlayerServiceClient
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local LayeredSoundHelper = require("LayeredSoundHelper")
+local LoopedSoundPlayer = require("LoopedSoundPlayer")
+local Maid = require("Maid")
+local Observable = require("Observable")
+local ServiceBag = require("ServiceBag")
+local SoundPlayerStack = require("SoundPlayerStack")
+
+local SoundPlayerServiceClient = {}
+SoundPlayerServiceClient.ServiceName = "SoundPlayerServiceClient"
+
+export type SoundPlayerServiceClient = typeof(setmetatable(
+	{} :: {
+		_serviceBag: ServiceBag.ServiceBag,
+		_soundGroupService: any,
+		_soundPlayerHelper: LayeredSoundHelper.LayeredSoundHelper<SoundPlayerStack.SoundPlayerStack>,
+		_maid: Maid.Maid,
+	},
+	{} :: typeof({ __index = SoundPlayerServiceClient })
+))
+
+function SoundPlayerServiceClient.Init(self: SoundPlayerServiceClient, serviceBag: ServiceBag.ServiceBag)
+	assert(not (self :: any)._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._maid = Maid.new()
+
+	-- External
+	self._serviceBag:GetService(require("SoundGroupServiceClient"))
+
+	self._soundPlayerHelper = self._maid:Add(LayeredSoundHelper.new(function(maid)
+		local layer: SoundPlayerStack.SoundPlayerStack = maid:Add(SoundPlayerStack.new())
+
+		return layer
+	end))
+end
+
+--[=[
+    Gets a sound group player for the given sound group path
+
+    @param layerId string
+    @return SoundPlayerStack
+]=]
+function SoundPlayerServiceClient.GetOrCreateSoundPlayerStack(
+	self: SoundPlayerServiceClient,
+	layerId: string
+): SoundPlayerStack.SoundPlayerStack
+	return self._soundPlayerHelper:GetOrCreateLayer(layerId)
+end
+
+function SoundPlayerServiceClient.PushSoundPlayer(
+	self: SoundPlayerServiceClient,
+	layerId: string,
+	soundPlayer: LoopedSoundPlayer.LoopedSoundPlayer,
+	priority: (number | Observable.Observable<number>)?
+): () -> ()
+	local layer = self._soundPlayerHelper:GetOrCreateLayer(layerId)
+	return layer:PushSoundPlayer(soundPlayer, priority)
+end
+
+function SoundPlayerServiceClient.Destroy(self: SoundPlayerServiceClient): ()
+	self._maid:DoCleaning()
+	self._soundPlayerHelper = nil :: any
+end
+
+return SoundPlayerServiceClient

package/src/Client/Stack/SoundPlayerStack.lua

@@ -0,0 +1,71 @@
+--!strict
+--[=[
+    @class SoundPlayerStack
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local LoopedSoundPlayer = require("LoopedSoundPlayer")
+local Maid = require("Maid")
+local Observable = require("Observable")
+local ObservableSortedList = require("ObservableSortedList")
+local Signal = require("Signal")
+
+local SoundPlayerStack = setmetatable({}, BaseObject)
+SoundPlayerStack.ClassName = "SoundPlayerStack"
+SoundPlayerStack.__index = SoundPlayerStack
+
+export type SoundPlayerStack =
+	typeof(setmetatable(
+		{} :: {
+			_stack: any, --ObservableSortedList.ObservableSortedList<LoopedSoundPlayer.LoopedSoundPlayer>,
+			HidingComplete: Signal.Signal<()>,
+		},
+		{} :: typeof({ __index = SoundPlayerStack })
+	))
+	& BaseObject.BaseObject
+
+function SoundPlayerStack.new(): SoundPlayerStack
+	local self: SoundPlayerStack = setmetatable(BaseObject.new() :: any, SoundPlayerStack)
+
+	self._stack = self._maid:Add(ObservableSortedList.new())
+
+	-- Used to notify the LayeredSoundHelper that we've finished hiding
+	-- and have no more sound players to play.
+	self.HidingComplete = self._maid:Add(Signal.new())
+
+	-- TODO: connect to visible + fire hiding finished when our stack is empty
+
+	self._maid:GiveTask(self._stack:ObserveAtIndex(-1):Subscribe(function(soundPlayer)
+		if soundPlayer then
+			local maid = Maid.new()
+			soundPlayer:Show()
+
+			maid:GiveTask(function()
+				if not soundPlayer.Destroy then
+					return
+				end
+
+				soundPlayer:Hide()
+			end)
+
+			self._maid._playing = maid
+		else
+			self._maid._playing = nil
+			self.HidingComplete:Fire()
+		end
+	end))
+
+	return self
+end
+
+function SoundPlayerStack.PushSoundPlayer(
+	self: SoundPlayerStack,
+	soundPlayer: LoopedSoundPlayer.LoopedSoundPlayer,
+	priority: (Observable.Observable<number> | number)?
+): () -> ()
+	return self._stack:Add(soundPlayer, priority or 0)
+end
+
+return SoundPlayerStack

package/src/Server/SoundPlayerService.lua

@@ -0,0 +1,27 @@
+--!strict
+--[=[
+    @class SoundPlayerService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local ServiceBag = require("ServiceBag")
+
+local SoundPlayerService = {}
+SoundPlayerService.ServiceName = "SoundPlayerService"
+
+export type SoundPlayerService = typeof(setmetatable(
+	{} :: {
+		_serviceBag: ServiceBag.ServiceBag,
+	},
+	{} :: typeof({ __index = SoundPlayerService })
+))
+
+function SoundPlayerService.Init(self: SoundPlayerService, serviceBag: ServiceBag.ServiceBag)
+	assert(not (self :: any)._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	self._serviceBag:GetService(require("SoundGroupService"))
+end
+
+return SoundPlayerService