roport 1.0.0 → 1.0.1

package/templates/default/src/server/modules/ProfileService.lua

@@ -0,0 +1,2414 @@
+-- local Madwork = _G.Madwork
+--[[
+{Madwork}
+
+-[ProfileService]---------------------------------------
+	(STANDALONE VERSION)
+	DataStore profiles - universal session-locked savable table API
+	
+	Official documentation:
+		https://madstudioroblox.github.io/ProfileService/
+
+	DevForum discussion:
+		https://devforum.roblox.com/t/ProfileService/667805
+	
+	WARNINGS FOR "Profile.Data" VALUES:
+	 	! Do not create numeric tables with gaps - attempting to replicate such tables will result in an error;
+		! Do not create mixed tables (some values indexed by number and others by string key), as only
+		     the data indexed by number will be replicated.
+		! Do not index tables by anything other than numbers and strings.
+		! Do not reference Roblox Instances
+		! Do not reference userdata (Vector3, Color3, CFrame...) - Serialize userdata before referencing
+		! Do not reference functions
+		
+	WARNING: Calling ProfileStore:LoadProfileAsync() with a "profile_key" which wasn't released in the SAME SESSION will result
+		in an error! If you want to "ProfileStore:LoadProfileAsync()" instead of using the already loaded profile, :Release()
+		the old Profile object.
+		
+	Members:
+	
+		ProfileService.ServiceLocked         [bool]
+		
+		ProfileService.IssueSignal           [ScriptSignal] (error_message, profile_store_name, profile_key)
+		ProfileService.CorruptionSignal      [ScriptSignal] (profile_store_name, profile_key)
+		ProfileService.CriticalStateSignal   [ScriptSignal] (is_critical_state)
+	
+	Functions:
+	
+		ProfileService.GetProfileStore(profile_store_index, profile_template) --> [ProfileStore]
+			profile_store_index   [string] -- DataStore name
+			OR
+			profile_store_index   [table]: -- Allows the developer to define more GlobalDataStore variables
+				{
+					Name = "StoreName", -- [string] -- DataStore name
+					-- Optional arguments:
+					Scope = "StoreScope", -- [string] -- DataStore scope
+				}
+			profile_template      [table] -- Profiles will default to given table (hard-copy) when no data was saved previously
+
+		ProfileService.IsLive() --> [bool] -- (CAN YIELD!!!)
+			-- Returns true if ProfileService is connected to live Roblox DataStores
+				
+	Members [ProfileStore]:
+	
+		ProfileStore.Mock   [ProfileStore] -- Reflection of ProfileStore methods, but the methods will use a mock DataStore
+		
+	Methods [ProfileStore]:
+	
+		ProfileStore:LoadProfileAsync(profile_key, not_released_handler) --> [Profile] or nil -- not_released_handler(place_id, game_job_id)
+			profile_key            [string] -- DataStore key
+			not_released_handler   nil or []: -- Defaults to "ForceLoad"
+				[string] "ForceLoad" -- Force loads profile on first call
+				OR
+				[string] "Steal" -- Steals the profile ignoring it's session lock
+				OR
+				[function] (place_id, game_job_id) --> [string] "Repeat", "Cancel", "ForceLoad" or "Steal"
+					place_id      [number] or nil
+					game_job_id   [string] or nil
+
+				-- not_released_handler [function] will be triggered in cases where the profile is not released by a session. This
+				--	function may yield for as long as desirable and must return one of three string values:
+
+						["Repeat"] - ProfileService will repeat the profile loading proccess and may trigger the release handler again
+						["Cancel"] - ProfileStore:LoadProfileAsync() will immediately return nil
+						["ForceLoad"] - ProfileService will repeat the profile loading call, but will return Profile object afterwards
+							and release the profile for another session that has loaded the profile
+						["Steal"] - The profile will usually be loaded immediately, ignoring an existing remote session lock and applying
+							a session lock for this session.
+
+		ProfileStore:GlobalUpdateProfileAsync(profile_key, update_handler) --> [GlobalUpdates] or nil
+			-- Returns GlobalUpdates object if update was successful, otherwise returns nil
+			profile_key      [string] -- DataStore key
+			update_handler   [function] (global_updates [GlobalUpdates])
+			
+		ProfileStore:ViewProfileAsync(profile_key, version) --> [Profile] or nil
+			-- Reads profile without requesting a session lock; Data will not be saved and profile doesn't need to be released
+			profile_key   [string] -- DataStore key
+			version       nil or [string] -- DataStore key version
+
+		ProfileStore:ProfileVersionQuery(profile_key, sort_direction, min_date, max_date) --> [ProfileVersionQuery]
+			profile_key      [string]
+			sort_direction   nil or [Enum.SortDirection]
+			min_date         nil or [DateTime]
+			max_date         nil or [DateTime]
+			
+		ProfileStore:WipeProfileAsync(profile_key) --> is_wipe_successful [bool]
+			-- Completely wipes out profile data from the DataStore / mock DataStore with no way to recover it.
+						
+		* Parameter description for "ProfileStore:GlobalUpdateProfileAsync()":
+		
+			profile_key      [string] -- DataStore key
+			update_handler   [function] (GlobalUpdates) -- This function gains access to GlobalUpdates object methods
+				(update_handler can't yield)
+
+	Methods [ProfileVersionQuery]:
+
+		ProfileVersionQuery:NextAsync() --> [Profile] or nil -- (Yields)
+			-- Returned profile has the same rules as profile returned by :ViewProfileAsync()
+		
+	Members [Profile]:
+	
+		Profile.Data              [table] -- Writable table that gets saved automatically and once the profile is released
+		Profile.MetaData          [table] (Read-only) -- Information about this profile
+		
+			Profile.MetaData.ProfileCreateTime   [number] (Read-only) -- os.time() timestamp of profile creation
+			Profile.MetaData.SessionLoadCount    [number] (Read-only) -- Amount of times the profile was loaded
+			Profile.MetaData.ActiveSession       [table] (Read-only) {place_id, game_job_id} / nil -- Set to a session link if a
+				game session is currently having this profile loaded; nil if released
+			Profile.MetaData.MetaTags            [table] {["tag_name"] = tag_value, ...} -- Saved and auto-saved just like Profile.Data
+			Profile.MetaData.MetaTagsLatest      [table] (Read-only) -- Latest version of MetaData.MetaTags that was definetly saved to DataStore
+				(You can use Profile.MetaData.MetaTagsLatest for product purchase save confirmation, but create a system to clear old tags after
+				they pile up)
+
+		Profile.MetaTagsUpdated   [ScriptSignal] (meta_tags_latest) -- Fires after every auto-save, after
+			--	Profile.MetaData.MetaTagsLatest has been updated with the version that's guaranteed to be saved;
+			--  .MetaTagsUpdated will fire regardless of whether .MetaTagsLatest changed after update;
+			--	.MetaTagsUpdated may fire after the Profile is released - changes to Profile.Data are not saved
+			--	after release.
+
+		Profile.RobloxMetaData    [table] -- Writable table that gets saved automatically and once the profile is released
+		Profile.UserIds           [table] -- (Read-only) -- {user_id [number], ...} -- User ids associated with this profile
+
+		Profile.KeyInfo           [DataStoreKeyInfo]
+		Profile.KeyInfoUpdated    [ScriptSignal] (key_info [DataStoreKeyInfo])
+		
+		Profile.GlobalUpdates     [GlobalUpdates]
+		
+	Methods [Profile]:
+	
+		-- SAFE METHODS - Will not error after profile expires:
+		Profile:IsActive() --> [bool] -- Returns true while the profile is active and can be written to
+			
+		Profile:GetMetaTag(tag_name) --> value [any]
+			tag_name   [string]
+		
+		Profile:Reconcile() -- Fills in missing (nil) [string_key] = [value] pairs to the Profile.Data structure
+		
+		Profile:ListenToRelease(listener) --> [ScriptConnection] (place_id / nil, game_job_id / nil)
+			-- WARNING: Profiles can be released externally if another session force-loads
+			--	this profile - use :ListenToRelease() to handle player leaving cleanup.
+			
+		Profile:Release() -- Call after the session has finished working with this profile
+			e.g., after the player leaves (Profile object will become expired) (Does not yield)
+
+		Profile:ListenToHopReady(listener) --> [ScriptConnection] () -- Passed listener will be executed after the releasing UpdateAsync call finishes;
+			--	Wrap universe teleport requests with this method AFTER releasing the profile to improve session lock sharing between universe places;
+			--  :ListenToHopReady() will usually call the listener in around a second, but may ocassionally take up to 7 seconds when a release happens
+			--	next to an auto-update in regular usage scenarios.
+
+		Profile:AddUserId(user_id) -- Associates user_id with profile (GDPR compliance)
+			user_id   [number]
+
+		Profile:RemoveUserId(user_id) -- Unassociates user_id with profile (safe function)
+			user_id   [number]
+
+		Profile:Identify() --> [string] -- Returns a string containing DataStore name, scope and key; Used for debug;
+			-- Example return: "[Store:"GameData";Scope:"Live";Key:"Player_2312310"]"
+		
+		Profile:SetMetaTag(tag_name, value) -- Equivalent of Profile.MetaData.MetaTags[tag_name] = value
+			tag_name   [string]
+			value      [any]
+		
+		Profile:Save() -- Call to quickly progress global update state or to speed up save validation processes (Does not yield)
+
+		-- VIEW-MODE ONLY:
+
+		Profile:ClearGlobalUpdates() -- Clears all global updates data from a profile payload
+
+		Profile:OverwriteAsync() -- (Yields) Saves the profile payload to the DataStore and removes the session lock
+		
+	Methods [GlobalUpdates]:
+	
+	-- ALWAYS PUBLIC:
+		GlobalUpdates:GetActiveUpdates() --> [table] {{update_id, update_data [table]}, ...}
+		GlobalUpdates:GetLockedUpdates() --> [table] {{update_id, update_data [table]}, ...}
+		
+	-- ONLY WHEN FROM "Profile.GlobalUpdates":
+		GlobalUpdates:ListenToNewActiveUpdate(listener) --> [ScriptConnection] (update_id, update_data)
+			update_data   [table]
+		GlobalUpdates:ListenToNewLockedUpdate(listener) --> [ScriptConnection] (update_id, update_data)
+			update_data   [table]
+		GlobalUpdates:LockActiveUpdate(update_id)  -- WARNING: will error after profile expires
+		GlobalUpdates:ClearLockedUpdate(update_id) -- WARNING: will error after profile expires
+		
+	-- EXPOSED TO "update_handler" DURING ProfileStore:GlobalUpdateProfileAsync() CALL
+		GlobalUpdates:AddActiveUpdate(update_data)
+			update_data   [table]
+		GlobalUpdates:ChangeActiveUpdate(update_id, update_data)
+			update_data   [table]
+		GlobalUpdates:ClearActiveUpdate(update_id)
+		
+--]]
+
+local SETTINGS = {
+
+	AutoSaveProfiles = 30, -- Seconds (This value may vary - ProfileService will split the auto save load evenly in the given time)
+	RobloxWriteCooldown = 7, -- Seconds between successive DataStore calls for the same key
+	ForceLoadMaxSteps = 8, -- Steps taken before ForceLoad request steals the active session for a profile
+	AssumeDeadSessionLock = 30 * 60, -- (seconds) If a profile hasn't been updated for 30 minutes, assume the session lock is dead
+		-- As of writing, os.time() is not completely reliable, so we can only assume session locks are dead after a significant amount of time.
+	
+	IssueCountForCriticalState = 5, -- Issues to collect to announce critical state
+	IssueLast = 120, -- Seconds
+	CriticalStateLast = 120, -- Seconds
+	
+	MetaTagsUpdatedValues = { -- Technical stuff - do not alter
+		ProfileCreateTime = true,
+		SessionLoadCount = true,
+		ActiveSession = true,
+		ForceLoadSession = true,
+		LastUpdate = true,
+	},
+	
+}
+
+local Madwork -- Standalone Madwork reference for portable version of ProfileService
+do
+
+	local MadworkScriptSignal = {}
+
+	local FreeRunnerThread = nil
+	
+	local function AcquireRunnerThreadAndCallEventHandler(fn, ...)
+		local acquired_runner_thread = FreeRunnerThread
+		FreeRunnerThread = nil
+		fn(...)
+		FreeRunnerThread = acquired_runner_thread
+	end
+	
+	local function RunEventHandlerInFreeThread(...)
+		AcquireRunnerThreadAndCallEventHandler(...)
+		while true do
+			AcquireRunnerThreadAndCallEventHandler(coroutine.yield())
+		end
+	end
+	
+	-- ScriptConnection object:
+
+	local ScriptConnection = {
+		--[[
+			_listener = listener,
+			_script_signal = script_signal,
+			_disconnect_listener = disconnect_listener,
+			_disconnect_param = disconnect_param,
+			
+			_next = next_script_connection,
+			_is_connected = is_connected,
+		--]]
+	}
+	ScriptConnection.__index = ScriptConnection
+
+	function ScriptConnection:Disconnect()
+
+		if self._is_connected == false then
+			return
+		end
+
+		self._is_connected = false
+		self._script_signal._listener_count -= 1
+
+		if self._script_signal._head == self then
+			self._script_signal._head = self._next
+		else
+			local prev = self._script_signal._head
+			while prev ~= nil and prev._next ~= self do
+				prev = prev._next
+			end
+			if prev ~= nil then
+				prev._next = self._next
+			end
+		end
+
+		if self._disconnect_listener ~= nil then
+			if not FreeRunnerThread then
+				FreeRunnerThread = coroutine.create(RunEventHandlerInFreeThread)
+			end
+			task.spawn(FreeRunnerThread, self._disconnect_listener, self._disconnect_param)
+			self._disconnect_listener = nil
+		end
+
+	end
+	
+	-- ScriptSignal object:
+
+	local ScriptSignal = {
+		--[[
+			_head = nil,
+			_listener_count = 0,
+		--]]
+	}
+	ScriptSignal.__index = ScriptSignal
+
+	function ScriptSignal:Connect(listener, disconnect_listener, disconnect_param) --> [ScriptConnection]
+
+		local script_connection = {
+			_listener = listener,
+			_script_signal = self,
+			_disconnect_listener = disconnect_listener,
+			_disconnect_param = disconnect_param,
+
+			_next = self._head,
+			_is_connected = true,
+		}
+		setmetatable(script_connection, ScriptConnection)
+
+		self._head = script_connection
+		self._listener_count += 1
+
+		return script_connection
+
+	end
+
+	function ScriptSignal:GetListenerCount() --> [number]
+		return self._listener_count
+	end
+
+	function ScriptSignal:Fire(...)
+		local item = self._head
+		while item ~= nil do
+			if item._is_connected == true then
+				if not FreeRunnerThread then
+					FreeRunnerThread = coroutine.create(RunEventHandlerInFreeThread)
+				end
+				task.spawn(FreeRunnerThread, item._listener, ...)
+			end
+			item = item._next
+		end
+	end
+
+	function ScriptSignal:FireUntil(continue_callback, ...)
+		local item = self._head
+		while item ~= nil do
+			if item._is_connected == true then
+				item._listener(...)
+				if continue_callback() ~= true then
+					return
+				end
+			end
+			item = item._next
+		end
+	end
+
+	function MadworkScriptSignal.NewScriptSignal() --> [ScriptSignal]
+		return {
+			_head = nil,
+			_listener_count = 0,
+			Connect = ScriptSignal.Connect,
+			GetListenerCount = ScriptSignal.GetListenerCount,
+			Fire = ScriptSignal.Fire,
+			FireUntil = ScriptSignal.FireUntil,
+		}
+	end
+
+	-- Madwork framework namespace:
+	
+	Madwork = {
+		NewScriptSignal = MadworkScriptSignal.NewScriptSignal,
+		ConnectToOnClose = function(task, run_in_studio_mode)
+			if game:GetService("RunService"):IsStudio() == false or run_in_studio_mode == true then
+				game:BindToClose(task)
+			end
+		end,
+	}
+
+end
+
+----- Service Table -----
+
+local ProfileService = {
+
+	ServiceLocked = false, -- Set to true once the server is shutting down
+
+	IssueSignal = Madwork.NewScriptSignal(), -- (error_message, profile_store_name, profile_key) -- Fired when a DataStore API call throws an error
+	CorruptionSignal = Madwork.NewScriptSignal(), -- (profile_store_name, profile_key) -- Fired when DataStore key returns a value that has
+	-- all or some of it's profile components set to invalid data types. E.g., accidentally setting Profile.Data to a noon table value
+
+	CriticalState = false, -- Set to true while DataStore service is throwing too many errors
+	CriticalStateSignal = Madwork.NewScriptSignal(), -- (is_critical_state) -- Fired when CriticalState is set to true
+	-- (You may alert players with this, or set up analytics)
+
+	ServiceIssueCount = 0,
+
+	_active_profile_stores = {}, -- {profile_store, ...}
+
+	_auto_save_list = {}, -- {profile, ...} -- loaded profile table which will be circularly auto-saved
+
+	_issue_queue = {}, -- [table] {issue_time, ...}
+	_critical_state_start = 0, -- [number] 0 = no critical state / os.clock() = critical state start
+
+	-- Debug:
+	_mock_data_store = {},
+	_user_mock_data_store = {},
+
+	_use_mock_data_store = false,
+
+}
+
+--[[
+	Saved profile structure:
+	
+	DataStoreProfile = {
+		Data = {},
+		MetaData = {
+			ProfileCreateTime = 0,
+			SessionLoadCount = 0,
+			ActiveSession = {place_id, game_job_id} / nil,
+			ForceLoadSession = {place_id, game_job_id} / nil,
+			MetaTags = {},
+			LastUpdate = 0, -- os.time()
+		},
+		RobloxMetaData = {},
+		UserIds = {},
+		GlobalUpdates = {
+			update_index,
+			{
+				{update_id, version_id, update_locked, update_data},
+				...
+			}
+		},
+	}
+	
+	OR
+	
+	DataStoreProfile = {
+		GlobalUpdates = {
+			update_index,
+			{
+				{update_id, version_id, update_locked, update_data},
+				...
+			}
+		},
+	}
+--]]
+
+----- Private Variables -----
+
+local ActiveProfileStores = ProfileService._active_profile_stores
+local AutoSaveList = ProfileService._auto_save_list
+local IssueQueue = ProfileService._issue_queue
+
+local DataStoreService = game:GetService("DataStoreService")
+local RunService = game:GetService("RunService")
+
+local PlaceId = game.PlaceId
+local JobId = game.JobId
+
+local AutoSaveIndex = 1 -- Next profile to auto save
+local LastAutoSave = os.clock()
+
+local LoadIndex = 0
+
+local ActiveProfileLoadJobs = 0 -- Number of active threads that are loading in profiles
+local ActiveProfileSaveJobs = 0 -- Number of active threads that are saving profiles
+
+local CriticalStateStart = 0 -- os.clock()
+
+local IsStudio = RunService:IsStudio()
+local IsLiveCheckActive = false
+
+local UseMockDataStore = false
+local MockDataStore = ProfileService._mock_data_store -- Mock data store used when API access is disabled
+
+local UserMockDataStore = ProfileService._user_mock_data_store -- Separate mock data store accessed via ProfileStore.Mock
+local UseMockTag = {}
+
+local CustomWriteQueue = {
+	--[[
+		[store] = {
+			[key] = {
+				LastWrite = os.clock(),
+				Queue = {callback, ...},
+				CleanupJob = nil,
+			},
+			...
+		},
+		...
+	--]]
+}
+
+----- Utils -----
+
+local function DeepCopyTable(t)
+	local copy = {}
+	for key, value in pairs(t) do
+		if type(value) == "table" then
+			copy[key] = DeepCopyTable(value)
+		else
+			copy[key] = value
+		end
+	end
+	return copy
+end
+
+local function ReconcileTable(target, template)
+	for k, v in pairs(template) do
+		if type(k) == "string" then -- Only string keys will be reconciled
+			if target[k] == nil then
+				if type(v) == "table" then
+					target[k] = DeepCopyTable(v)
+				else
+					target[k] = v
+				end
+			elseif type(target[k]) == "table" and type(v) == "table" then
+				ReconcileTable(target[k], v)
+			end
+		end
+	end
+end
+
+----- Private functions -----
+
+local function IdentifyProfile(store_name, store_scope, key)
+	return string.format(
+		"[Store:\"%s\";%sKey:\"%s\"]",
+		store_name,
+		store_scope ~= nil and string.format("Scope:\"%s\";", store_scope) or "",
+		key
+	)
+end
+
+local function CustomWriteQueueCleanup(store, key)
+	if CustomWriteQueue[store] ~= nil then
+		CustomWriteQueue[store][key] = nil
+		if next(CustomWriteQueue[store]) == nil then
+			CustomWriteQueue[store] = nil
+		end
+	end
+end
+
+local function CustomWriteQueueMarkForCleanup(store, key)
+	if CustomWriteQueue[store] ~= nil then
+		if CustomWriteQueue[store][key] ~= nil then
+
+			local queue_data = CustomWriteQueue[store][key]
+			local queue = queue_data.Queue
+
+			if queue_data.CleanupJob == nil then
+
+				queue_data.CleanupJob = RunService.Heartbeat:Connect(function()
+					if os.clock() - queue_data.LastWrite > SETTINGS.RobloxWriteCooldown and #queue == 0 then
+						queue_data.CleanupJob:Disconnect()
+						CustomWriteQueueCleanup(store, key)
+					end
+				end)
+
+			end
+
+		elseif next(CustomWriteQueue[store]) == nil then
+			CustomWriteQueue[store] = nil
+		end
+	end
+end
+
+local function CustomWriteQueueAsync(callback, store, key) --> ... -- Passed return from callback
+
+	if CustomWriteQueue[store] == nil then
+		CustomWriteQueue[store] = {}
+	end
+	if CustomWriteQueue[store][key] == nil then
+		CustomWriteQueue[store][key] = {LastWrite = 0, Queue = {}, CleanupJob = nil}
+	end
+
+	local queue_data = CustomWriteQueue[store][key]
+	local queue = queue_data.Queue
+
+	-- Cleanup job:
+
+	if queue_data.CleanupJob ~= nil then
+		queue_data.CleanupJob:Disconnect()
+		queue_data.CleanupJob = nil
+	end
+
+	-- Queue logic:
+
+	if os.clock() - queue_data.LastWrite > SETTINGS.RobloxWriteCooldown and #queue == 0 then
+		queue_data.LastWrite = os.clock()
+		return callback()
+	else
+		table.insert(queue, callback)
+		while true do
+			if os.clock() - queue_data.LastWrite > SETTINGS.RobloxWriteCooldown and queue[1] == callback then
+				table.remove(queue, 1)
+				queue_data.LastWrite = os.clock()
+				return callback()
+			end
+			task.wait()
+		end
+	end
+
+end
+
+local function IsCustomWriteQueueEmptyFor(store, key) --> is_empty [bool]
+	local lookup = CustomWriteQueue[store]
+	if lookup ~= nil then
+		lookup = lookup[key]
+		return lookup == nil or #lookup.Queue == 0
+	end
+	return true
+end
+
+local function WaitForLiveAccessCheck() -- This function was created to prevent the ProfileService module yielding execution when required
+	while IsLiveCheckActive == true do
+		task.wait()
+	end
+end
+
+local function WaitForPendingProfileStore(profile_store)
+	while profile_store._is_pending == true do
+		task.wait()
+	end
+end
+
+local function RegisterIssue(error_message, store_name, store_scope, profile_key) -- Called when a DataStore API call errors
+	warn("[ProfileService]: DataStore API error " .. IdentifyProfile(store_name, store_scope, profile_key) .. " - \"" .. tostring(error_message) .. "\"")
+	table.insert(IssueQueue, os.clock()) -- Adding issue time to queue
+	ProfileService.IssueSignal:Fire(tostring(error_message), store_name, profile_key)
+end
+
+local function RegisterCorruption(store_name, store_scope, profile_key) -- Called when a corrupted profile is loaded
+	warn("[ProfileService]: Resolved profile corruption " .. IdentifyProfile(store_name, store_scope, profile_key))
+	ProfileService.CorruptionSignal:Fire(store_name, profile_key)
+end
+
+local function NewMockDataStoreKeyInfo(params)
+
+	local version_id_string = tostring(params.VersionId or 0)
+	local meta_data = params.MetaData or {}
+	local user_ids = params.UserIds or {}
+
+	return {
+		CreatedTime = params.CreatedTime,
+		UpdatedTime = params.UpdatedTime,
+		Version = string.rep("0", 16) .. "."
+			.. string.rep("0", 10 - string.len(version_id_string)) .. version_id_string
+			.. "." .. string.rep("0", 16) .. "." .. "01",
+
+		GetMetadata = function()
+			return DeepCopyTable(meta_data)
+		end,
+
+		GetUserIds = function()
+			return DeepCopyTable(user_ids)
+		end,
+	}
+
+end
+
+local function MockUpdateAsync(mock_data_store, profile_store_name, key, transform_function, is_get_call) --> loaded_data, key_info
+
+	local profile_store = mock_data_store[profile_store_name]
+
+	if profile_store == nil then
+		profile_store = {}
+		mock_data_store[profile_store_name] = profile_store
+	end
+
+	local epoch_time = math.floor(os.time() * 1000)
+	local mock_entry = profile_store[key]
+	local mock_entry_was_nil = false
+
+	if mock_entry == nil then
+		mock_entry_was_nil = true
+		if is_get_call ~= true then
+			mock_entry = {
+				Data = nil,
+				CreatedTime = epoch_time,
+				UpdatedTime = epoch_time,
+				VersionId = 0,
+				UserIds = {},
+				MetaData = {},
+			}
+			profile_store[key] = mock_entry
+		end
+	end
+
+	local mock_key_info = mock_entry_was_nil == false and NewMockDataStoreKeyInfo(mock_entry) or nil
+
+	local transform, user_ids, roblox_meta_data = transform_function(mock_entry and mock_entry.Data, mock_key_info)
+
+	if transform == nil then
+		return nil
+	else
+		if mock_entry ~= nil and is_get_call ~= true then
+			mock_entry.Data = transform
+			mock_entry.UserIds = DeepCopyTable(user_ids or {})
+			mock_entry.MetaData = DeepCopyTable(roblox_meta_data or {})
+			mock_entry.VersionId += 1
+			mock_entry.UpdatedTime = epoch_time
+		end
+
+		return DeepCopyTable(transform), mock_entry ~= nil and NewMockDataStoreKeyInfo(mock_entry) or nil
+	end
+
+end
+
+local function IsThisSession(session_tag)
+	return session_tag[1] == PlaceId and session_tag[2] == JobId
+end
+
+--[[
+update_settings = {
+	ExistingProfileHandle = function(latest_data),
+	MissingProfileHandle = function(latest_data),
+	EditProfile = function(lastest_data),
+}
+--]]
+local function StandardProfileUpdateAsyncDataStore(profile_store, profile_key, update_settings, is_user_mock, is_get_call, version) --> loaded_data, key_info
+	local loaded_data, key_info
+	local success, error_message = pcall(function()
+		local transform_function = function(latest_data)
+
+			local missing_profile = false
+			local data_corrupted = false
+			local global_updates_data = {0, {}}
+
+			if latest_data == nil then
+				missing_profile = true
+			elseif type(latest_data) ~= "table" then
+				missing_profile = true
+				data_corrupted = true
+			end
+
+			if type(latest_data) == "table" then
+				-- Case #1: Profile was loaded
+				if type(latest_data.Data) == "table"
+					and type(latest_data.MetaData) == "table"
+					and type(latest_data.GlobalUpdates) == "table" then
+
+					latest_data.WasCorrupted = false -- Must be set to false if set previously
+					global_updates_data = latest_data.GlobalUpdates
+					if update_settings.ExistingProfileHandle ~= nil then
+						update_settings.ExistingProfileHandle(latest_data)
+					end
+					-- Case #2: Profile was not loaded but GlobalUpdate data exists
+				elseif latest_data.Data == nil
+					and latest_data.MetaData == nil
+					and type(latest_data.GlobalUpdates) == "table" then
+
+					latest_data.WasCorrupted = false -- Must be set to false if set previously
+					global_updates_data = latest_data.GlobalUpdates or global_updates_data
+					missing_profile = true
+				else
+					missing_profile = true
+					data_corrupted = true
+				end
+			end
+
+			-- Case #3: Profile was not created or corrupted and no GlobalUpdate data exists
+			if missing_profile == true then
+				latest_data = {
+					-- Data = nil,
+					-- MetaData = nil,
+					GlobalUpdates = global_updates_data,
+				}
+				if update_settings.MissingProfileHandle ~= nil then
+					update_settings.MissingProfileHandle(latest_data)
+				end
+			end
+
+			-- Editing profile:
+			if update_settings.EditProfile ~= nil then
+				update_settings.EditProfile(latest_data)
+			end
+
+			-- Data corruption handling (Silently override with empty profile) (Also run Case #1)
+			if data_corrupted == true then
+				latest_data.WasCorrupted = true -- Temporary tag that will be removed on first save
+			end
+
+			return latest_data, latest_data.UserIds, latest_data.RobloxMetaData
+		end
+		if is_user_mock == true then -- Used when the profile is accessed through ProfileStore.Mock
+			loaded_data, key_info = MockUpdateAsync(UserMockDataStore, profile_store._profile_store_lookup, profile_key, transform_function, is_get_call)
+			task.wait() -- Simulate API call yield
+		elseif UseMockDataStore == true then -- Used when API access is disabled
+			loaded_data, key_info = MockUpdateAsync(MockDataStore, profile_store._profile_store_lookup, profile_key, transform_function, is_get_call)
+			task.wait() -- Simulate API call yield
+		else
+			loaded_data, key_info = CustomWriteQueueAsync(
+				function() -- Callback
+					if is_get_call == true then
+						local get_data, get_key_info
+						if version ~= nil then
+							local success, error_message = pcall(function()
+								get_data, get_key_info = profile_store._global_data_store:GetVersionAsync(profile_key, version)
+							end)
+							if success == false and type(error_message) == "string" and string.find(error_message, "not valid") ~= nil then
+								warn("[ProfileService]: Passed version argument is not valid; Traceback:\n" .. debug.traceback())
+							end
+						else
+							get_data, get_key_info = profile_store._global_data_store:GetAsync(profile_key)
+						end
+						get_data = transform_function(get_data)
+						return get_data, get_key_info
+					else
+						return profile_store._global_data_store:UpdateAsync(profile_key, transform_function)
+					end
+				end,
+				profile_store._profile_store_lookup, -- Store
+				profile_key -- Key
+			)
+		end
+	end)
+	if success == true and type(loaded_data) == "table" then
+		-- Corruption handling:
+		if loaded_data.WasCorrupted == true and is_get_call ~= true then
+			RegisterCorruption(
+				profile_store._profile_store_name,
+				profile_store._profile_store_scope,
+				profile_key
+			)
+		end
+		-- Return loaded_data:
+		return loaded_data, key_info
+	else
+		RegisterIssue(
+			(error_message ~= nil) and error_message or "Undefined error",
+			profile_store._profile_store_name,
+			profile_store._profile_store_scope,
+			profile_key
+		)
+		-- Return nothing:
+		return nil
+	end
+end
+
+local function RemoveProfileFromAutoSave(profile)
+	local auto_save_index = table.find(AutoSaveList, profile)
+	if auto_save_index ~= nil then
+		table.remove(AutoSaveList, auto_save_index)
+		if auto_save_index < AutoSaveIndex then
+			AutoSaveIndex = AutoSaveIndex - 1 -- Table contents were moved left before AutoSaveIndex so move AutoSaveIndex left as well
+		end
+		if AutoSaveList[AutoSaveIndex] == nil then -- AutoSaveIndex was at the end of the AutoSaveList - reset to 1
+			AutoSaveIndex = 1
+		end
+	end
+end
+
+local function AddProfileToAutoSave(profile) -- Notice: Makes sure this profile isn't auto-saved too soon
+	-- Add at AutoSaveIndex and move AutoSaveIndex right:
+	table.insert(AutoSaveList, AutoSaveIndex, profile)
+	if #AutoSaveList > 1 then
+		AutoSaveIndex = AutoSaveIndex + 1
+	elseif #AutoSaveList == 1 then
+		-- First profile created - make sure it doesn't get immediately auto saved:
+		LastAutoSave = os.clock()
+	end
+end
+
+local function ReleaseProfileInternally(profile)
+	-- 1) Remove profile object from ProfileService references: --
+	-- Clear reference in ProfileStore:
+	local profile_store = profile._profile_store
+	local loaded_profiles = profile._is_user_mock == true and profile_store._mock_loaded_profiles or profile_store._loaded_profiles
+	loaded_profiles[profile._profile_key] = nil
+	if next(profile_store._loaded_profiles) == nil and next(profile_store._mock_loaded_profiles) == nil then -- ProfileStore has turned inactive
+		local index = table.find(ActiveProfileStores, profile_store)
+		if index ~= nil then
+			table.remove(ActiveProfileStores, index)
+		end
+	end
+	-- Clear auto update reference:
+	RemoveProfileFromAutoSave(profile)
+	-- 2) Trigger release listeners: --
+	local place_id
+	local game_job_id
+	local active_session = profile.MetaData.ActiveSession
+	if active_session ~= nil then
+		place_id = active_session[1]
+		game_job_id = active_session[2]
+	end
+	profile._release_listeners:Fire(place_id, game_job_id)
+end
+
+local function CheckForNewGlobalUpdates(profile, old_global_updates_data, new_global_updates_data)
+	local global_updates_object = profile.GlobalUpdates -- [GlobalUpdates]
+	local pending_update_lock = global_updates_object._pending_update_lock -- {update_id, ...}
+	local pending_update_clear = global_updates_object._pending_update_clear -- {update_id, ...}
+	-- "old_" or "new_" global_updates_data = {update_index, {{update_id, version_id, update_locked, update_data}, ...}}
+	for _, new_global_update in ipairs(new_global_updates_data[2]) do
+		-- Find old global update with the same update_id:
+		local old_global_update
+		for _, global_update in ipairs(old_global_updates_data[2]) do
+			if global_update[1] == new_global_update[1] then
+				old_global_update = global_update
+				break
+			end
+		end
+		-- A global update is new when it didn't exist before or its version_id or update_locked state changed:
+		local is_new = false
+		if old_global_update == nil or new_global_update[2] > old_global_update[2] or new_global_update[3] ~= old_global_update[3] then
+			is_new = true
+		end
+		if is_new == true then
+			-- Active global updates:
+			if new_global_update[3] == false then
+				-- Check if update is not pending to be locked: (Preventing firing new active update listeners more than necessary)
+				local is_pending_lock = false
+				for _, update_id in ipairs(pending_update_lock) do
+					if new_global_update[1] == update_id then
+						is_pending_lock = true
+						break
+					end
+				end
+				if is_pending_lock == false then
+					-- Trigger new active update listeners:
+					global_updates_object._new_active_update_listeners:Fire(new_global_update[1], new_global_update[4])
+				end
+			end
+			-- Locked global updates:
+			if new_global_update[3] == true then
+				-- Check if update is not pending to be cleared: (Preventing firing new locked update listeners after marking a locked update for clearing)
+				local is_pending_clear = false
+				for _, update_id in ipairs(pending_update_clear) do
+					if new_global_update[1] == update_id then
+						is_pending_clear = true
+						break
+					end
+				end
+				if is_pending_clear == false then
+					-- Trigger new locked update listeners:
+
+					global_updates_object._new_locked_update_listeners:FireUntil(
+						function()
+							-- Check if listener marked the update to be cleared:
+							-- Normally there should be only one listener per profile for new locked global updates, but
+							-- in case several listeners are connected we will not trigger more listeners after one listener
+							-- marks the locked global update to be cleared.
+							return table.find(pending_update_clear, new_global_update[1]) == nil
+						end,
+						new_global_update[1], new_global_update[4]
+					)
+
+				end
+			end
+		end
+	end
+end
+
+local function SaveProfileAsync(profile, release_from_session, is_overwriting)
+	if type(profile.Data) ~= "table" then
+		RegisterCorruption(
+			profile._profile_store._profile_store_name,
+			profile._profile_store._profile_store_scope,
+			profile._profile_key
+		)
+		error("[ProfileService]: PROFILE DATA CORRUPTED DURING RUNTIME! Profile: " .. profile:Identify())
+	end
+	if release_from_session == true and is_overwriting ~= true then
+		ReleaseProfileInternally(profile)
+	end
+	ActiveProfileSaveJobs = ActiveProfileSaveJobs + 1
+	local last_session_load_count = profile.MetaData.SessionLoadCount
+	-- Compare "SessionLoadCount" when writing to profile to prevent a rare case of repeat last save when the profile is loaded on the same server again
+	local repeat_save_flag = true -- Released Profile save calls have to repeat until they succeed
+	while repeat_save_flag == true do
+		if release_from_session ~= true then
+			repeat_save_flag = false
+		end
+		local loaded_data, key_info = StandardProfileUpdateAsyncDataStore(
+			profile._profile_store,
+			profile._profile_key,
+			{
+				ExistingProfileHandle = nil,
+				MissingProfileHandle = nil,
+				EditProfile = function(latest_data)
+
+					local session_owns_profile = false
+					local force_load_pending = false
+
+					if is_overwriting ~= true then
+						-- 1) Check if this session still owns the profile: --
+						local active_session = latest_data.MetaData.ActiveSession
+						local force_load_session = latest_data.MetaData.ForceLoadSession
+						local session_load_count = latest_data.MetaData.SessionLoadCount
+
+						if type(active_session) == "table" then
+							session_owns_profile = IsThisSession(active_session) and session_load_count == last_session_load_count
+						end
+						if type(force_load_session) == "table" then
+							force_load_pending = not IsThisSession(force_load_session)
+						end
+					else
+						session_owns_profile = true
+					end
+
+					if session_owns_profile == true then -- We may only edit the profile if this session has ownership of the profile
+
+						if is_overwriting ~= true then
+							-- 2) Manage global updates: --
+							local latest_global_updates_data = latest_data.GlobalUpdates -- {update_index, {{update_id, version_id, update_locked, update_data}, ...}}
+							local latest_global_updates_list = latest_global_updates_data[2]
+
+							local global_updates_object = profile.GlobalUpdates -- [GlobalUpdates]
+							local pending_update_lock = global_updates_object._pending_update_lock -- {update_id, ...}
+							local pending_update_clear = global_updates_object._pending_update_clear -- {update_id, ...}
+							-- Active update locking:
+							for i = 1, #latest_global_updates_list do
+								for _, lock_id in ipairs(pending_update_lock) do
+									if latest_global_updates_list[i][1] == lock_id then
+										latest_global_updates_list[i][3] = true
+										break
+									end
+								end
+							end
+							-- Locked update clearing:
+							for _, clear_id in ipairs(pending_update_clear) do
+								for i = 1, #latest_global_updates_list do
+									if latest_global_updates_list[i][1] == clear_id and latest_global_updates_list[i][3] == true then
+										table.remove(latest_global_updates_list, i)
+										break
+									end
+								end
+							end
+						end
+
+						-- 3) Save profile data: --
+						latest_data.Data = profile.Data
+						latest_data.RobloxMetaData = profile.RobloxMetaData
+						latest_data.UserIds = profile.UserIds
+
+						if is_overwriting ~= true then
+							latest_data.MetaData.MetaTags = profile.MetaData.MetaTags -- MetaData.MetaTags is the only actively savable component of MetaData
+							latest_data.MetaData.LastUpdate = os.time()
+							if release_from_session == true or force_load_pending == true then
+								latest_data.MetaData.ActiveSession = nil
+							end
+						else
+							latest_data.MetaData = profile.MetaData
+							latest_data.MetaData.ActiveSession = nil
+							latest_data.MetaData.ForceLoadSession = nil
+							latest_data.GlobalUpdates = profile.GlobalUpdates._updates_latest
+						end
+
+					end
+				end,
+			},
+			profile._is_user_mock
+		)
+		if loaded_data ~= nil and key_info ~= nil then
+			if is_overwriting == true then
+				break
+			end
+			repeat_save_flag = false
+			-- 4) Set latest data in profile: --
+			-- Updating DataStoreKeyInfo:
+			profile.KeyInfo = key_info
+			-- Setting global updates:
+			local global_updates_object = profile.GlobalUpdates -- [GlobalUpdates]
+			local old_global_updates_data = global_updates_object._updates_latest
+			local new_global_updates_data = loaded_data.GlobalUpdates
+			global_updates_object._updates_latest = new_global_updates_data
+			-- Setting MetaData:
+			local session_meta_data = profile.MetaData
+			local latest_meta_data = loaded_data.MetaData
+			for key in pairs(SETTINGS.MetaTagsUpdatedValues) do
+				session_meta_data[key] = latest_meta_data[key]
+			end
+			session_meta_data.MetaTagsLatest = latest_meta_data.MetaTags
+			-- 5) Check if session still owns the profile: --
+			local active_session = loaded_data.MetaData.ActiveSession
+			local session_load_count = loaded_data.MetaData.SessionLoadCount
+			local session_owns_profile = false
+			if type(active_session) == "table" then
+				session_owns_profile = IsThisSession(active_session) and session_load_count == last_session_load_count
+			end
+			local is_active = profile:IsActive()
+			if session_owns_profile == true then
+				-- 6) Check for new global updates: --
+				if is_active == true then -- Profile could've been released before the saving thread finished
+					CheckForNewGlobalUpdates(profile, old_global_updates_data, new_global_updates_data)
+				end
+			else
+				-- Session no longer owns the profile:
+				-- 7) Release profile if it hasn't been released yet: --
+				if is_active == true then
+					ReleaseProfileInternally(profile)
+				end
+				-- Cleanup reference in custom write queue:
+				CustomWriteQueueMarkForCleanup(profile._profile_store._profile_store_lookup, profile._profile_key)
+				-- Hop ready listeners:
+				if profile._hop_ready == false then
+					profile._hop_ready = true
+					profile._hop_ready_listeners:Fire()
+				end
+			end
+			-- Signaling MetaTagsUpdated listeners after a possible external profile release was handled:
+			profile.MetaTagsUpdated:Fire(profile.MetaData.MetaTagsLatest)
+			-- Signaling KeyInfoUpdated listeners:
+			profile.KeyInfoUpdated:Fire(key_info)
+		elseif repeat_save_flag == true then
+			task.wait() -- Prevent infinite loop in case DataStore API does not yield
+		end
+	end
+	ActiveProfileSaveJobs = ActiveProfileSaveJobs - 1
+end
+
+----- Public functions -----
+
+-- GlobalUpdates object:
+
+local GlobalUpdates = {
+	--[[
+		_updates_latest = {}, -- [table] {update_index, {{update_id, version_id, update_locked, update_data}, ...}}
+		_pending_update_lock = {update_id, ...} / nil, -- [table / nil]
+		_pending_update_clear = {update_id, ...} / nil, -- [table / nil]
+		
+		_new_active_update_listeners = [ScriptSignal] / nil, -- [table / nil]
+		_new_locked_update_listeners = [ScriptSignal] / nil, -- [table / nil]
+		
+		_profile = Profile / nil, -- [Profile / nil]
+		
+		_update_handler_mode = true / nil, -- [bool / nil]
+	--]]
+}
+GlobalUpdates.__index = GlobalUpdates
+
+-- ALWAYS PUBLIC:
+function GlobalUpdates:GetActiveUpdates() --> [table] {{update_id, update_data}, ...}
+	local query_list = {}
+	for _, global_update in ipairs(self._updates_latest[2]) do
+		if global_update[3] == false then
+			local is_pending_lock = false
+			if self._pending_update_lock ~= nil then
+				for _, update_id in ipairs(self._pending_update_lock) do
+					if global_update[1] == update_id then
+						is_pending_lock = true -- Exclude global updates pending to be locked
+						break
+					end
+				end
+			end
+			if is_pending_lock == false then
+				table.insert(query_list, {global_update[1], global_update[4]})
+			end
+		end
+	end
+	return query_list
+end
+
+function GlobalUpdates:GetLockedUpdates() --> [table] {{update_id, update_data}, ...}
+	local query_list = {}
+	for _, global_update in ipairs(self._updates_latest[2]) do
+		if global_update[3] == true then
+			local is_pending_clear = false
+			if self._pending_update_clear ~= nil then
+				for _, update_id in ipairs(self._pending_update_clear) do
+					if global_update[1] == update_id then
+						is_pending_clear = true -- Exclude global updates pending to be cleared
+						break
+					end
+				end
+			end
+			if is_pending_clear == false then
+				table.insert(query_list, {global_update[1], global_update[4]})
+			end
+		end
+	end
+	return query_list
+end
+
+-- ONLY WHEN FROM "Profile.GlobalUpdates":
+function GlobalUpdates:ListenToNewActiveUpdate(listener) --> [ScriptConnection] listener(update_id, update_data)
+	if type(listener) ~= "function" then
+		error("[ProfileService]: Only a function can be set as listener in GlobalUpdates:ListenToNewActiveUpdate()")
+	end
+	local profile = self._profile
+	if self._update_handler_mode == true then
+		error("[ProfileService]: Can't listen to new global updates in ProfileStore:GlobalUpdateProfileAsync()")
+	elseif self._new_active_update_listeners == nil then
+		error("[ProfileService]: Can't listen to new global updates in view mode")
+	elseif profile:IsActive() == false then -- Check if profile is expired
+		return { -- Do not connect listener if the profile is expired
+			Disconnect = function() end,
+		}
+	end
+	-- Connect listener:
+	return self._new_active_update_listeners:Connect(listener)
+end
+
+function GlobalUpdates:ListenToNewLockedUpdate(listener) --> [ScriptConnection] listener(update_id, update_data)
+	if type(listener) ~= "function" then
+		error("[ProfileService]: Only a function can be set as listener in GlobalUpdates:ListenToNewLockedUpdate()")
+	end
+	local profile = self._profile
+	if self._update_handler_mode == true then
+		error("[ProfileService]: Can't listen to new global updates in ProfileStore:GlobalUpdateProfileAsync()")
+	elseif self._new_locked_update_listeners == nil then
+		error("[ProfileService]: Can't listen to new global updates in view mode")
+	elseif profile:IsActive() == false then -- Check if profile is expired
+		return { -- Do not connect listener if the profile is expired
+			Disconnect = function() end,
+		}
+	end
+	-- Connect listener:
+	return self._new_locked_update_listeners:Connect(listener)
+end
+
+function GlobalUpdates:LockActiveUpdate(update_id)
+	if type(update_id) ~= "number" then
+		error("[ProfileService]: Invalid update_id")
+	end
+	local profile = self._profile
+	if self._update_handler_mode == true then
+		error("[ProfileService]: Can't lock active global updates in ProfileStore:GlobalUpdateProfileAsync()")
+	elseif self._pending_update_lock == nil then
+		error("[ProfileService]: Can't lock active global updates in view mode")
+	elseif profile:IsActive() == false then -- Check if profile is expired
+		error("[ProfileService]: PROFILE EXPIRED - Can't lock active global updates")
+	end
+	-- Check if global update exists with given update_id
+	local global_update_exists = nil
+	for _, global_update in ipairs(self._updates_latest[2]) do
+		if global_update[1] == update_id then
+			global_update_exists = global_update
+			break
+		end
+	end
+	if global_update_exists ~= nil then
+		local is_pending_lock = false
+		for _, lock_update_id in ipairs(self._pending_update_lock) do
+			if update_id == lock_update_id then
+				is_pending_lock = true -- Exclude global updates pending to be locked
+				break
+			end
+		end
+		if is_pending_lock == false and global_update_exists[3] == false then -- Avoid id duplicates in _pending_update_lock
+			table.insert(self._pending_update_lock, update_id)
+		end
+	else
+		error("[ProfileService]: Passed non-existant update_id")
+	end
+end
+
+function GlobalUpdates:ClearLockedUpdate(update_id)
+	if type(update_id) ~= "number" then
+		error("[ProfileService]: Invalid update_id")
+	end
+	local profile = self._profile
+	if self._update_handler_mode == true then
+		error("[ProfileService]: Can't clear locked global updates in ProfileStore:GlobalUpdateProfileAsync()")
+	elseif self._pending_update_clear == nil then
+		error("[ProfileService]: Can't clear locked global updates in view mode")
+	elseif profile:IsActive() == false then -- Check if profile is expired
+		error("[ProfileService]: PROFILE EXPIRED - Can't clear locked global updates")
+	end
+	-- Check if global update exists with given update_id
+	local global_update_exists = nil
+	for _, global_update in ipairs(self._updates_latest[2]) do
+		if global_update[1] == update_id then
+			global_update_exists = global_update
+			break
+		end
+	end
+	if global_update_exists ~= nil then
+		local is_pending_clear = false
+		for _, clear_update_id in ipairs(self._pending_update_clear) do
+			if update_id == clear_update_id then
+				is_pending_clear = true -- Exclude global updates pending to be cleared
+				break
+			end
+		end
+		if is_pending_clear == false and global_update_exists[3] == true then -- Avoid id duplicates in _pending_update_clear
+			table.insert(self._pending_update_clear, update_id)
+		end
+	else
+		error("[ProfileService]: Passed non-existant update_id")
+	end
+end
+
+-- EXPOSED TO "update_handler" DURING ProfileStore:GlobalUpdateProfileAsync() CALL
+function GlobalUpdates:AddActiveUpdate(update_data)
+	if type(update_data) ~= "table" then
+		error("[ProfileService]: Invalid update_data")
+	end
+	if self._new_active_update_listeners ~= nil then
+		error("[ProfileService]: Can't add active global updates in loaded Profile; Use ProfileStore:GlobalUpdateProfileAsync()")
+	elseif self._update_handler_mode ~= true then
+		error("[ProfileService]: Can't add active global updates in view mode; Use ProfileStore:GlobalUpdateProfileAsync()")
+	end
+	-- self._updates_latest = {}, -- [table] {update_index, {{update_id, version_id, update_locked, update_data}, ...}}
+	local updates_latest = self._updates_latest
+	local update_index = updates_latest[1] + 1 -- Incrementing global update index
+	updates_latest[1] = update_index
+	-- Add new active global update:
+	table.insert(updates_latest[2], {update_index, 1, false, update_data})
+end
+
+function GlobalUpdates:ChangeActiveUpdate(update_id, update_data)
+	if type(update_id) ~= "number" then
+		error("[ProfileService]: Invalid update_id")
+	end
+	if type(update_data) ~= "table" then
+		error("[ProfileService]: Invalid update_data")
+	end
+	if self._new_active_update_listeners ~= nil then
+		error("[ProfileService]: Can't change active global updates in loaded Profile; Use ProfileStore:GlobalUpdateProfileAsync()")
+	elseif self._update_handler_mode ~= true then
+		error("[ProfileService]: Can't change active global updates in view mode; Use ProfileStore:GlobalUpdateProfileAsync()")
+	end
+	-- self._updates_latest = {}, -- [table] {update_index, {{update_id, version_id, update_locked, update_data}, ...}}
+	local updates_latest = self._updates_latest
+	local get_global_update = nil
+	for _, global_update in ipairs(updates_latest[2]) do
+		if update_id == global_update[1] then
+			get_global_update = global_update
+			break
+		end
+	end
+	if get_global_update ~= nil then
+		if get_global_update[3] == true then
+			error("[ProfileService]: Can't change locked global update")
+		end
+		get_global_update[2] = get_global_update[2] + 1 -- Increment version id
+		get_global_update[4] = update_data -- Set new global update data
+	else
+		error("[ProfileService]: Passed non-existant update_id")
+	end
+end
+
+function GlobalUpdates:ClearActiveUpdate(update_id)
+	if type(update_id) ~= "number" then
+		error("[ProfileService]: Invalid update_id argument")
+	end
+	if self._new_active_update_listeners ~= nil then
+		error("[ProfileService]: Can't clear active global updates in loaded Profile; Use ProfileStore:GlobalUpdateProfileAsync()")
+	elseif self._update_handler_mode ~= true then
+		error("[ProfileService]: Can't clear active global updates in view mode; Use ProfileStore:GlobalUpdateProfileAsync()")
+	end
+	-- self._updates_latest = {}, -- [table] {update_index, {{update_id, version_id, update_locked, update_data}, ...}}
+	local updates_latest = self._updates_latest
+	local get_global_update_index = nil
+	local get_global_update = nil
+	for index, global_update in ipairs(updates_latest[2]) do
+		if update_id == global_update[1] then
+			get_global_update_index = index
+			get_global_update = global_update
+			break
+		end
+	end
+	if get_global_update ~= nil then
+		if get_global_update[3] == true then
+			error("[ProfileService]: Can't clear locked global update")
+		end
+		table.remove(updates_latest[2], get_global_update_index) -- Remove active global update
+	else
+		error("[ProfileService]: Passed non-existant update_id")
+	end
+end
+
+-- Profile object:
+
+local Profile = {
+	--[[
+		Data = {}, -- [table] -- Loaded once after ProfileStore:LoadProfileAsync() finishes
+		MetaData = {}, -- [table] -- Updated with every auto-save
+		GlobalUpdates = GlobalUpdates, -- [GlobalUpdates]
+		
+		_profile_store = ProfileStore, -- [ProfileStore]
+		_profile_key = "", -- [string]
+		
+		_release_listeners = [ScriptSignal] / nil, -- [table / nil]
+		_hop_ready_listeners = [ScriptSignal] / nil, -- [table / nil]
+		_hop_ready = false,
+		
+		_view_mode = true / nil, -- [bool] or nil
+		
+		_load_timestamp = os.clock(),
+		
+		_is_user_mock = false, -- ProfileStore.Mock
+		_mock_key_info = {},
+	--]]
+}
+Profile.__index = Profile
+
+function Profile:IsActive() --> [bool]
+	local loaded_profiles = self._is_user_mock == true and self._profile_store._mock_loaded_profiles or self._profile_store._loaded_profiles
+	return loaded_profiles[self._profile_key] == self
+end
+
+function Profile:GetMetaTag(tag_name) --> value
+	local meta_data = self.MetaData
+	if meta_data == nil then
+		return nil
+		-- error("[ProfileService]: This Profile hasn't been loaded before - MetaData not available")
+	end
+	return self.MetaData.MetaTags[tag_name]
+end
+
+function Profile:SetMetaTag(tag_name, value)
+	if type(tag_name) ~= "string" then
+		error("[ProfileService]: tag_name must be a string")
+	elseif string.len(tag_name) == 0 then
+		error("[ProfileService]: Invalid tag_name")
+	end
+	self.MetaData.MetaTags[tag_name] = value
+end
+
+function Profile:Reconcile()
+	ReconcileTable(self.Data, self._profile_store._profile_template)
+end
+
+function Profile:ListenToRelease(listener) --> [ScriptConnection] (place_id / nil, game_job_id / nil)
+	if type(listener) ~= "function" then
+		error("[ProfileService]: Only a function can be set as listener in Profile:ListenToRelease()")
+	end
+	if self._view_mode == true then
+		return {Disconnect = function() end}
+	end
+	if self:IsActive() == false then
+		-- Call release listener immediately if profile is expired
+		local place_id
+		local game_job_id
+		local active_session = self.MetaData.ActiveSession
+		if active_session ~= nil then
+			place_id = active_session[1]
+			game_job_id = active_session[2]
+		end
+		listener(place_id, game_job_id)
+		return {Disconnect = function() end}
+	else
+		return self._release_listeners:Connect(listener)
+	end
+end
+
+function Profile:Save()
+	if self._view_mode == true then
+		error("[ProfileService]: Can't save Profile in view mode - Should you be calling :OverwriteAsync() instead?")
+	end
+	if self:IsActive() == false then
+		warn("[ProfileService]: Attempted saving an inactive profile "
+			.. self:Identify() .. "; Traceback:\n" .. debug.traceback())
+		return
+	end
+	-- Reject save request if a save is already pending in the queue - this will prevent the user from
+	--	unecessary API request spam which we could not meaningfully execute anyways!
+	if IsCustomWriteQueueEmptyFor(self._profile_store._profile_store_lookup, self._profile_key) == true then
+		-- We don't want auto save to trigger too soon after manual saving - this will reset the auto save timer:
+		RemoveProfileFromAutoSave(self)
+		AddProfileToAutoSave(self)
+		-- Call save function in a new thread:
+		task.spawn(SaveProfileAsync, self)
+	end
+end
+
+function Profile:Release()
+	if self._view_mode == true then
+		return
+	end
+	if self:IsActive() == true then
+		task.spawn(SaveProfileAsync, self, true) -- Call save function in a new thread with release_from_session = true
+	end
+end
+
+function Profile:ListenToHopReady(listener) --> [ScriptConnection] ()
+	if type(listener) ~= "function" then
+		error("[ProfileService]: Only a function can be set as listener in Profile:ListenToHopReady()")
+	end
+	if self._view_mode == true then
+		return {Disconnect = function() end}
+	end
+	if self._hop_ready == true then
+		task.spawn(listener)
+		return {Disconnect = function() end}
+	else
+		return self._hop_ready_listeners:Connect(listener)
+	end
+end
+
+function Profile:AddUserId(user_id) -- Associates user_id with profile (GDPR compliance)
+
+	if type(user_id) ~= "number" or user_id % 1 ~= 0 then
+		warn("[ProfileService]: Invalid UserId argument for :AddUserId() ("
+			.. tostring(user_id) .. "); Traceback:\n" .. debug.traceback())
+		return
+	end
+
+	if user_id < 0 and self._is_user_mock ~= true and UseMockDataStore ~= true then
+		return -- Avoid giving real Roblox APIs negative UserId's
+	end
+
+	if table.find(self.UserIds, user_id) == nil then
+		table.insert(self.UserIds, user_id)
+	end
+	
+end
+
+function Profile:RemoveUserId(user_id) -- Unassociates user_id with profile (safe function)
+
+	if type(user_id) ~= "number" or user_id % 1 ~= 0 then
+		warn("[ProfileService]: Invalid UserId argument for :RemoveUserId() ("
+			.. tostring(user_id) .. "); Traceback:\n" .. debug.traceback())
+		return
+	end
+	
+	local index = table.find(self.UserIds, user_id)
+
+	if index ~= nil then
+		table.remove(self.UserIds, index)
+	end
+
+end
+
+function Profile:Identify() --> [string]
+	return IdentifyProfile(
+		self._profile_store._profile_store_name,
+		self._profile_store._profile_store_scope,
+		self._profile_key
+	)
+end
+
+function Profile:ClearGlobalUpdates() -- Clears all global updates data from a profile payload
+
+	if self._view_mode ~= true then
+		error("[ProfileService]: :ClearGlobalUpdates() can only be used in view mode")
+	end
+
+	local global_updates_object = {
+		_updates_latest = {0, {}},
+		_profile = self,
+	}
+	setmetatable(global_updates_object, GlobalUpdates)
+
+	self.GlobalUpdates = global_updates_object
+
+end
+
+function Profile:OverwriteAsync() -- Saves the profile to the DataStore and removes the session lock
+
+	if self._view_mode ~= true then
+		error("[ProfileService]: :OverwriteAsync() can only be used in view mode")
+	end
+
+	SaveProfileAsync(self, nil, true)
+
+end
+
+-- ProfileVersionQuery object:
+
+local ProfileVersionQuery = {
+	--[[
+		_profile_store = profile_store,
+		_profile_key = profile_key,
+		_sort_direction = sort_direction,
+		_min_date = min_date,
+		_max_date = max_date,
+
+		_query_pages = pages, -- [DataStoreVersionPages]
+		_query_index = index, -- [number]
+		_query_failure = false,
+
+		_is_query_yielded = false,
+		_query_queue = {},
+	--]]
+}
+ProfileVersionQuery.__index = ProfileVersionQuery
+
+function ProfileVersionQuery:_MoveQueue()
+	while #self._query_queue > 0 do
+		local queue_entry = table.remove(self._query_queue, 1)
+		task.spawn(queue_entry)
+		if self._is_query_yielded == true then
+			break
+		end
+	end
+end
+
+function ProfileVersionQuery:NextAsync(_is_stacking) --> [Profile] or nil
+
+	if self._profile_store == nil then
+		return nil
+	end
+
+	local profile
+	local is_finished = false
+
+	local function query_job()
+
+		if self._query_failure == true then
+			is_finished = true
+			return
+		end
+
+		-- First "next" call loads version pages:
+
+		if self._query_pages == nil then
+
+			self._is_query_yielded = true
+			task.spawn(function()
+				profile = self:NextAsync(true)
+				is_finished = true
+			end)
+			
+			local list_success, error_message = pcall(function()
+				self._query_pages = self._profile_store._global_data_store:ListVersionsAsync(
+					self._profile_key,
+					self._sort_direction,
+					self._min_date,
+					self._max_date
+				)
+				self._query_index = 0
+			end)
+
+			if list_success == false or self._query_pages == nil then
+				warn("[ProfileService]: Version query fail - " .. tostring(error_message))
+				self._query_failure = true
+			end
+
+			self._is_query_yielded = false
+			self:_MoveQueue()
+
+			return
+
+		end
+
+		local current_page = self._query_pages:GetCurrentPage()
+		local next_item = current_page[self._query_index + 1]
+
+		-- No more entries:
+		
+		if self._query_pages.IsFinished == true and next_item == nil then
+			is_finished = true
+			return
+		end
+
+		-- Load next page when this page is over:
+
+		if next_item == nil then
+
+			self._is_query_yielded = true
+			task.spawn(function()
+				profile = self:NextAsync(true)
+				is_finished = true
+			end)
+
+			local success = pcall(function()
+				self._query_pages:AdvanceToNextPageAsync()
+				self._query_index = 0
+			end)
+
+			if success == false or #self._query_pages:GetCurrentPage() == 0 then
+				self._query_failure = true
+			end
+
+			self._is_query_yielded = false
+			self:_MoveQueue()
+
+			return
+
+		end
+
+		-- Next page item:
+
+		self._query_index += 1
+		profile = self._profile_store:ViewProfileAsync(self._profile_key, next_item.Version)
+		is_finished = true
+
+	end
+
+	if self._is_query_yielded == false then
+		query_job()
+	else
+		if _is_stacking == true then
+			table.insert(self._query_queue, 1, query_job)
+		else
+			table.insert(self._query_queue, query_job)
+		end
+	end
+
+	while is_finished == false do
+		task.wait()
+	end
+
+	return profile
+
+end
+
+-- ProfileStore object:
+
+local ProfileStore = {
+	--[[
+		Mock = {},
+	
+		_profile_store_name = "", -- [string] -- DataStore name
+		_profile_store_scope = nil, -- [string] or [nil] -- DataStore scope
+		_profile_store_lookup = "", -- [string] -- _profile_store_name .. "\0" .. (_profile_store_scope or "")
+		
+		_profile_template = {}, -- [table]
+		_global_data_store = global_data_store, -- [GlobalDataStore] -- Object returned by DataStoreService:GetDataStore(_profile_store_name)
+		
+		_loaded_profiles = {[profile_key] = Profile, ...},
+		_profile_load_jobs = {[profile_key] = {load_id, loaded_data}, ...},
+		
+		_mock_loaded_profiles = {[profile_key] = Profile, ...},
+		_mock_profile_load_jobs = {[profile_key] = {load_id, loaded_data}, ...},
+	--]]
+}
+ProfileStore.__index = ProfileStore
+
+function ProfileStore:LoadProfileAsync(profile_key, not_released_handler, _use_mock) --> [Profile / nil] not_released_handler(place_id, game_job_id)
+
+	not_released_handler = not_released_handler or "ForceLoad"
+
+	if self._profile_template == nil then
+		error("[ProfileService]: Profile template not set - ProfileStore:LoadProfileAsync() locked for this ProfileStore")
+	end
+	if type(profile_key) ~= "string" then
+		error("[ProfileService]: profile_key must be a string")
+	elseif string.len(profile_key) == 0 then
+		error("[ProfileService]: Invalid profile_key")
+	end
+	if type(not_released_handler) ~= "function" and not_released_handler ~= "ForceLoad" and not_released_handler ~= "Steal" then
+		error("[ProfileService]: Invalid not_released_handler")
+	end
+
+	if ProfileService.ServiceLocked == true then
+		return nil
+	end
+
+	WaitForPendingProfileStore(self)
+
+	local is_user_mock = _use_mock == UseMockTag
+
+	-- Check if profile with profile_key isn't already loaded in this session:
+	for _, profile_store in ipairs(ActiveProfileStores) do
+		if profile_store._profile_store_lookup == self._profile_store_lookup then
+			local loaded_profiles = is_user_mock == true and profile_store._mock_loaded_profiles or profile_store._loaded_profiles
+			if loaded_profiles[profile_key] ~= nil then
+				error("[ProfileService]: Profile " .. IdentifyProfile(self._profile_store_name, self._profile_store_scope, profile_key) .. " is already loaded in this session")
+				-- Are you using Profile:Release() properly?
+			end
+		end
+	end
+
+	ActiveProfileLoadJobs = ActiveProfileLoadJobs + 1
+	local force_load = not_released_handler == "ForceLoad"
+	local force_load_steps = 0
+	local request_force_load = force_load -- First step of ForceLoad
+	local steal_session = false -- Second step of ForceLoad
+	local aggressive_steal = not_released_handler == "Steal" -- Developer invoked steal
+	while ProfileService.ServiceLocked == false do
+		-- Load profile:
+		-- SPECIAL CASE - If LoadProfileAsync is called for the same key before another LoadProfileAsync finishes,
+		-- yoink the DataStore return for the new call. The older call will return nil. This would prevent very rare
+		-- game breaking errors where a player rejoins the server super fast.
+		local profile_load_jobs = is_user_mock == true and self._mock_profile_load_jobs or self._profile_load_jobs
+		local loaded_data, key_info
+		local load_id = LoadIndex + 1
+		LoadIndex = load_id
+		local profile_load_job = profile_load_jobs[profile_key] -- {load_id, {loaded_data, key_info} or nil}
+		if profile_load_job ~= nil then
+			profile_load_job[1] = load_id -- Yoink load job
+			while profile_load_job[2] == nil do -- Wait for job to finish
+				task.wait()
+			end
+			if profile_load_job[1] == load_id then -- Load job hasn't been double-yoinked
+				loaded_data, key_info = table.unpack(profile_load_job[2])
+				profile_load_jobs[profile_key] = nil
+			else
+				ActiveProfileLoadJobs = ActiveProfileLoadJobs - 1
+				return nil
+			end
+		else
+			profile_load_job = {load_id, nil}
+			profile_load_jobs[profile_key] = profile_load_job
+			profile_load_job[2] = table.pack(StandardProfileUpdateAsyncDataStore(
+				self,
+				profile_key,
+				{
+					ExistingProfileHandle = function(latest_data)
+						if ProfileService.ServiceLocked == false then
+							local active_session = latest_data.MetaData.ActiveSession
+							local force_load_session = latest_data.MetaData.ForceLoadSession
+							-- IsThisSession(active_session)
+							if active_session == nil then
+								latest_data.MetaData.ActiveSession = {PlaceId, JobId}
+								latest_data.MetaData.ForceLoadSession = nil
+							elseif type(active_session) == "table" then
+								if IsThisSession(active_session) == false then
+									local last_update = latest_data.MetaData.LastUpdate
+									if last_update ~= nil then
+										if os.time() - last_update > SETTINGS.AssumeDeadSessionLock then
+											latest_data.MetaData.ActiveSession = {PlaceId, JobId}
+											latest_data.MetaData.ForceLoadSession = nil
+											return
+										end
+									end
+									if steal_session == true or aggressive_steal == true then
+										local force_load_uninterrupted = false
+										if force_load_session ~= nil then
+											force_load_uninterrupted = IsThisSession(force_load_session)
+										end
+										if force_load_uninterrupted == true or aggressive_steal == true then
+											latest_data.MetaData.ActiveSession = {PlaceId, JobId}
+											latest_data.MetaData.ForceLoadSession = nil
+										end
+									elseif request_force_load == true then
+										latest_data.MetaData.ForceLoadSession = {PlaceId, JobId}
+									end
+								else
+									latest_data.MetaData.ForceLoadSession = nil
+								end
+							end
+						end
+					end,
+					MissingProfileHandle = function(latest_data)
+						latest_data.Data = DeepCopyTable(self._profile_template)
+						latest_data.MetaData = {
+							ProfileCreateTime = os.time(),
+							SessionLoadCount = 0,
+							ActiveSession = {PlaceId, JobId},
+							ForceLoadSession = nil,
+							MetaTags = {},
+						}
+					end,
+					EditProfile = function(latest_data)
+						if ProfileService.ServiceLocked == false then
+							local active_session = latest_data.MetaData.ActiveSession
+							if active_session ~= nil and IsThisSession(active_session) == true then
+								latest_data.MetaData.SessionLoadCount = latest_data.MetaData.SessionLoadCount + 1
+								latest_data.MetaData.LastUpdate = os.time()
+							end
+						end
+					end,
+				},
+				is_user_mock
+			))
+			if profile_load_job[1] == load_id then -- Load job hasn't been yoinked
+				loaded_data, key_info = table.unpack(profile_load_job[2])
+				profile_load_jobs[profile_key] = nil
+			else
+				ActiveProfileLoadJobs = ActiveProfileLoadJobs - 1
+				return nil -- Load job yoinked
+			end
+		end
+		-- Handle load_data:
+		if loaded_data ~= nil and key_info ~= nil then
+			local active_session = loaded_data.MetaData.ActiveSession
+			if type(active_session) == "table" then
+				if IsThisSession(active_session) == true then
+					-- Special component in MetaTags:
+					loaded_data.MetaData.MetaTagsLatest = DeepCopyTable(loaded_data.MetaData.MetaTags)
+					-- Case #1: Profile is now taken by this session:
+					-- Create Profile object:
+					local global_updates_object = {
+						_updates_latest = loaded_data.GlobalUpdates,
+						_pending_update_lock = {},
+						_pending_update_clear = {},
+
+						_new_active_update_listeners = Madwork.NewScriptSignal(),
+						_new_locked_update_listeners = Madwork.NewScriptSignal(),
+
+						_profile = nil,
+					}
+					setmetatable(global_updates_object, GlobalUpdates)
+					local profile = {
+						Data = loaded_data.Data,
+						MetaData = loaded_data.MetaData,
+						MetaTagsUpdated = Madwork.NewScriptSignal(),
+
+						RobloxMetaData = loaded_data.RobloxMetaData or {},
+						UserIds = loaded_data.UserIds or {},
+						KeyInfo = key_info,
+						KeyInfoUpdated = Madwork.NewScriptSignal(),
+
+						GlobalUpdates = global_updates_object,
+
+						_profile_store = self,
+						_profile_key = profile_key,
+
+						_release_listeners = Madwork.NewScriptSignal(),
+						_hop_ready_listeners = Madwork.NewScriptSignal(),
+						_hop_ready = false,
+
+						_load_timestamp = os.clock(),
+
+						_is_user_mock = is_user_mock,
+					}
+					setmetatable(profile, Profile)
+					global_updates_object._profile = profile
+					-- Referencing Profile object in ProfileStore:
+					if next(self._loaded_profiles) == nil and next(self._mock_loaded_profiles) == nil then -- ProfileStore object was inactive
+						table.insert(ActiveProfileStores, self)
+					end
+					if is_user_mock == true then
+						self._mock_loaded_profiles[profile_key] = profile
+					else
+						self._loaded_profiles[profile_key] = profile
+					end
+					-- Adding profile to AutoSaveList;
+					AddProfileToAutoSave(profile)
+					-- Special case - finished loading profile, but session is shutting down:
+					if ProfileService.ServiceLocked == true then
+						SaveProfileAsync(profile, true) -- Release profile and yield until the DataStore call is finished
+						profile = nil -- nil will be returned by this call
+					end
+					-- Return Profile object:
+					ActiveProfileLoadJobs = ActiveProfileLoadJobs - 1
+					return profile
+				else
+					-- Case #2: Profile is taken by some other session:
+					if force_load == true then
+						local force_load_session = loaded_data.MetaData.ForceLoadSession
+						local force_load_uninterrupted = false
+						if force_load_session ~= nil then
+							force_load_uninterrupted = IsThisSession(force_load_session)
+						end
+						if force_load_uninterrupted == true then
+							if request_force_load == false then
+								force_load_steps = force_load_steps + 1
+								if force_load_steps == SETTINGS.ForceLoadMaxSteps then
+									steal_session = true
+								end
+							end
+							task.wait() -- Overload prevention
+						else
+							-- Another session tried to force load this profile:
+							ActiveProfileLoadJobs = ActiveProfileLoadJobs - 1
+							return nil
+						end
+						request_force_load = false -- Only request a force load once
+					elseif aggressive_steal == true then
+						task.wait() -- Overload prevention
+					else
+						local handler_result = not_released_handler(active_session[1], active_session[2])
+						if handler_result == "Repeat" then
+							task.wait() -- Overload prevention
+						elseif handler_result == "Cancel" then
+							ActiveProfileLoadJobs = ActiveProfileLoadJobs - 1
+							return nil
+						elseif handler_result == "ForceLoad" then
+							force_load = true
+							request_force_load = true
+							task.wait() -- Overload prevention
+						elseif handler_result == "Steal" then
+							aggressive_steal = true
+							task.wait() -- Overload prevention
+						else
+							error(
+								"[ProfileService]: Invalid return from not_released_handler (\"" .. tostring(handler_result) .. "\")(" .. type(handler_result) .. ");" ..
+									"\n" .. IdentifyProfile(self._profile_store_name, self._profile_store_scope, profile_key) ..
+									" Traceback:\n" .. debug.traceback()
+							)
+						end
+					end
+				end
+			else
+				ActiveProfileLoadJobs = ActiveProfileLoadJobs - 1
+				return nil -- In this scenario it is likely the ProfileService.ServiceLocked flag was raised
+			end
+		else
+			task.wait() -- Overload prevention
+		end
+	end
+	ActiveProfileLoadJobs = ActiveProfileLoadJobs - 1
+	return nil -- If loop breaks return nothing
+end
+
+function ProfileStore:GlobalUpdateProfileAsync(profile_key, update_handler, _use_mock) --> [GlobalUpdates / nil] (update_handler(GlobalUpdates))
+	if type(profile_key) ~= "string" or string.len(profile_key) == 0 then
+		error("[ProfileService]: Invalid profile_key")
+	end
+	if type(update_handler) ~= "function" then
+		error("[ProfileService]: Invalid update_handler")
+	end
+
+	if ProfileService.ServiceLocked == true then
+		return nil
+	end
+
+	WaitForPendingProfileStore(self)
+
+	while ProfileService.ServiceLocked == false do
+		-- Updating profile:
+		local loaded_data = StandardProfileUpdateAsyncDataStore(
+			self,
+			profile_key,
+			{
+				ExistingProfileHandle = nil,
+				MissingProfileHandle = nil,
+				EditProfile = function(latest_data)
+					-- Running update_handler:
+					local global_updates_object = {
+						_updates_latest = latest_data.GlobalUpdates,
+						_update_handler_mode = true,
+					}
+					setmetatable(global_updates_object, GlobalUpdates)
+					update_handler(global_updates_object)
+				end,
+			},
+			_use_mock == UseMockTag
+		)
+		CustomWriteQueueMarkForCleanup(self._profile_store_lookup, profile_key)
+		-- Handling loaded_data:
+		if loaded_data ~= nil then
+			-- Return GlobalUpdates object (Update successful):
+			local global_updates_object = {
+				_updates_latest = loaded_data.GlobalUpdates,
+			}
+			setmetatable(global_updates_object, GlobalUpdates)
+			return global_updates_object
+		else
+			task.wait() -- Overload prevention
+		end
+	end
+	return nil -- Return nothing (Update unsuccessful)
+end
+
+function ProfileStore:ViewProfileAsync(profile_key, version, _use_mock) --> [Profile / nil]
+	if type(profile_key) ~= "string" or string.len(profile_key) == 0 then
+		error("[ProfileService]: Invalid profile_key")
+	end
+
+	if ProfileService.ServiceLocked == true then
+		return nil
+	end
+
+	WaitForPendingProfileStore(self)
+
+	if version ~= nil and (_use_mock == UseMockTag or UseMockDataStore == true) then
+		return nil -- No version support in mock mode
+	end
+
+	while ProfileService.ServiceLocked == false do
+		-- Load profile:
+		local loaded_data, key_info = StandardProfileUpdateAsyncDataStore(
+			self,
+			profile_key,
+			{
+				ExistingProfileHandle = nil,
+				MissingProfileHandle = function(latest_data)
+					latest_data.Data = DeepCopyTable(self._profile_template)
+					latest_data.MetaData = {
+						ProfileCreateTime = os.time(),
+						SessionLoadCount = 0,
+						ActiveSession = nil,
+						ForceLoadSession = nil,
+						MetaTags = {},
+					}
+				end,
+				EditProfile = nil,
+			},
+			_use_mock == UseMockTag,
+			true, -- Use :GetAsync()
+			version -- DataStore key version
+		)
+		CustomWriteQueueMarkForCleanup(self._profile_store_lookup, profile_key)
+		-- Handle load_data:
+		if loaded_data ~= nil then
+			if key_info == nil then
+				return nil -- Load was successful, but the key was empty - return no profile object
+			end
+			-- Create Profile object:
+			local global_updates_object = {
+				_updates_latest = loaded_data.GlobalUpdates, -- {0, {}}
+				_profile = nil,
+			}
+			setmetatable(global_updates_object, GlobalUpdates)
+			local profile = {
+				Data = loaded_data.Data,
+				MetaData = loaded_data.MetaData,
+				MetaTagsUpdated = Madwork.NewScriptSignal(),
+
+				RobloxMetaData = loaded_data.RobloxMetaData or {},
+				UserIds = loaded_data.UserIds or {},
+				KeyInfo = key_info,
+				KeyInfoUpdated = Madwork.NewScriptSignal(),
+
+				GlobalUpdates = global_updates_object,
+
+				_profile_store = self,
+				_profile_key = profile_key,
+
+				_view_mode = true,
+
+				_load_timestamp = os.clock(),
+			}
+			setmetatable(profile, Profile)
+			global_updates_object._profile = profile
+			-- Returning Profile object:
+			return profile
+		else
+			task.wait() -- Overload prevention
+		end
+	end
+	return nil -- If loop breaks return nothing
+end
+
+function ProfileStore:ProfileVersionQuery(profile_key, sort_direction, min_date, max_date, _use_mock) --> [ProfileVersionQuery]
+	if type(profile_key) ~= "string" or string.len(profile_key) == 0 then
+		error("[ProfileService]: Invalid profile_key")
+	end
+
+	if ProfileService.ServiceLocked == true then
+		return setmetatable({}, ProfileVersionQuery) -- Silently fail :Next() requests
+	end
+
+	WaitForPendingProfileStore(self)
+
+	if _use_mock == UseMockTag or UseMockDataStore == true then
+		error("[ProfileService]: :ProfileVersionQuery() is not supported in mock mode")
+	end
+
+	-- Type check:
+	if sort_direction ~= nil and (typeof(sort_direction) ~= "EnumItem"
+		or sort_direction.EnumType ~= Enum.SortDirection) then
+		error("[ProfileService]: Invalid sort_direction (" .. tostring(sort_direction) .. ")")
+	end
+
+	if min_date ~= nil and typeof(min_date) ~= "DateTime" and typeof(min_date) ~= "number" then
+		error("[ProfileService]: Invalid min_date (" .. tostring(min_date) .. ")")
+	end
+
+	if max_date ~= nil and typeof(max_date) ~= "DateTime" and typeof(max_date) ~= "number" then
+		error("[ProfileService]: Invalid max_date (" .. tostring(max_date) .. ")")
+	end
+
+	min_date = typeof(min_date) == "DateTime" and min_date.UnixTimestampMillis or min_date
+	max_date = typeof(max_date) == "DateTime" and max_date.UnixTimestampMillis or max_date
+
+	local profile_version_query = {
+		_profile_store = self,
+		_profile_key = profile_key,
+		_sort_direction = sort_direction,
+		_min_date = min_date,
+		_max_date = max_date,
+
+		_query_pages = nil,
+		_query_index = 0,
+		_query_failure = false,
+
+		_is_query_yielded = false,
+		_query_queue = {},
+	}
+	setmetatable(profile_version_query, ProfileVersionQuery)
+
+	return profile_version_query
+
+end
+
+function ProfileStore:WipeProfileAsync(profile_key, _use_mock) --> is_wipe_successful [bool]
+	if type(profile_key) ~= "string" or string.len(profile_key) == 0 then
+		error("[ProfileService]: Invalid profile_key")
+	end
+
+	if ProfileService.ServiceLocked == true then
+		return false
+	end
+
+	WaitForPendingProfileStore(self)
+
+	local wipe_status = false
+
+	if _use_mock == UseMockTag then -- Used when the profile is accessed through ProfileStore.Mock
+		local mock_data_store = UserMockDataStore[self._profile_store_lookup]
+		if mock_data_store ~= nil then
+			mock_data_store[profile_key] = nil
+		end
+		wipe_status = true
+		task.wait() -- Simulate API call yield
+	elseif UseMockDataStore == true then -- Used when API access is disabled
+		local mock_data_store = MockDataStore[self._profile_store_lookup]
+		if mock_data_store ~= nil then
+			mock_data_store[profile_key] = nil
+		end
+		wipe_status = true
+		task.wait() -- Simulate API call yield
+	else
+		wipe_status = pcall(function()
+			self._global_data_store:RemoveAsync(profile_key)
+		end)
+	end
+
+	CustomWriteQueueMarkForCleanup(self._profile_store_lookup, profile_key)
+
+	return wipe_status
+end
+
+-- New ProfileStore:
+
+function ProfileService.GetProfileStore(profile_store_index, profile_template) --> [ProfileStore]
+
+	local profile_store_name
+	local profile_store_scope = nil
+
+	-- Parsing profile_store_index:
+	if type(profile_store_index) == "string" then
+		-- profile_store_index as string:
+		profile_store_name = profile_store_index
+	elseif type(profile_store_index) == "table" then
+		-- profile_store_index as table:
+		profile_store_name = profile_store_index.Name
+		profile_store_scope = profile_store_index.Scope
+	else
+		error("[ProfileService]: Invalid or missing profile_store_index")
+	end
+
+	-- Type checking:
+	if profile_store_name == nil or type(profile_store_name) ~= "string" then
+		error("[ProfileService]: Missing or invalid \"Name\" parameter")
+	elseif string.len(profile_store_name) == 0 then
+		error("[ProfileService]: ProfileStore name cannot be an empty string")
+	end
+
+	if profile_store_scope ~= nil and (type(profile_store_scope) ~= "string" or string.len(profile_store_scope) == 0) then
+		error("[ProfileService]: Invalid \"Scope\" parameter")
+	end
+
+	if type(profile_template) ~= "table" then
+		error("[ProfileService]: Invalid profile_template")
+	end
+
+	local profile_store
+	profile_store = {
+		Mock = {
+			LoadProfileAsync = function(_, profile_key, not_released_handler)
+				return profile_store:LoadProfileAsync(profile_key, not_released_handler, UseMockTag)
+			end,
+			GlobalUpdateProfileAsync = function(_, profile_key, update_handler)
+				return profile_store:GlobalUpdateProfileAsync(profile_key, update_handler, UseMockTag)
+			end,
+			ViewProfileAsync = function(_, profile_key, version)
+				return profile_store:ViewProfileAsync(profile_key, version, UseMockTag)
+			end,
+			FindProfileVersionAsync = function(_, profile_key, sort_direction, min_date, max_date)
+				return profile_store:FindProfileVersionAsync(profile_key, sort_direction, min_date, max_date, UseMockTag)
+			end,
+			WipeProfileAsync = function(_, profile_key)
+				return profile_store:WipeProfileAsync(profile_key, UseMockTag)
+			end
+		},
+
+		_profile_store_name = profile_store_name,
+		_profile_store_scope = profile_store_scope,
+		_profile_store_lookup = profile_store_name .. "\0" .. (profile_store_scope or ""),
+
+		_profile_template = profile_template,
+		_global_data_store = nil,
+		_loaded_profiles = {},
+		_profile_load_jobs = {},
+		_mock_loaded_profiles = {},
+		_mock_profile_load_jobs = {},
+		_is_pending = false,
+	}
+	setmetatable(profile_store, ProfileStore)
+
+	if IsLiveCheckActive == true then
+		profile_store._is_pending = true
+		task.spawn(function()
+			WaitForLiveAccessCheck()
+			if UseMockDataStore == false then
+				profile_store._global_data_store = DataStoreService:GetDataStore(profile_store_name, profile_store_scope)
+			end
+			profile_store._is_pending = false
+		end)
+	else
+		if UseMockDataStore == false then
+			profile_store._global_data_store = DataStoreService:GetDataStore(profile_store_name, profile_store_scope)
+		end
+	end
+
+	return profile_store
+end
+
+function ProfileService.IsLive() --> [bool] -- (CAN YIELD!!!)
+
+	WaitForLiveAccessCheck()
+
+	return UseMockDataStore == false
+
+end
+
+----- Initialize -----
+
+if IsStudio == true then
+	IsLiveCheckActive = true
+	task.spawn(function()
+		local status, message = pcall(function()
+			-- This will error if current instance has no Studio API access:
+			DataStoreService:GetDataStore("____PS"):SetAsync("____PS", os.time())
+		end)
+		local no_internet_access = status == false and string.find(message, "ConnectFail", 1, true) ~= nil
+		if no_internet_access == true then
+			warn("[ProfileService]: No internet access - check your network connection")
+		end
+		if status == false and
+			(string.find(message, "403", 1, true) ~= nil or -- Cannot write to DataStore from studio if API access is not enabled
+				string.find(message, "must publish", 1, true) ~= nil or -- Game must be published to access live keys
+				no_internet_access == true) then -- No internet access
+
+			UseMockDataStore = true
+			ProfileService._use_mock_data_store = true
+			print("[ProfileService]: Roblox API services unavailable - data will not be saved")
+		else
+			print("[ProfileService]: Roblox API services available - data will be saved")
+		end
+		IsLiveCheckActive = false
+	end)
+end
+
+----- Connections -----
+
+-- Auto saving and issue queue managing:
+RunService.Heartbeat:Connect(function()
+	-- 1) Auto saving: --
+	local auto_save_list_length = #AutoSaveList
+	if auto_save_list_length > 0 then
+		local auto_save_index_speed = SETTINGS.AutoSaveProfiles / auto_save_list_length
+		local os_clock = os.clock()
+		while os_clock - LastAutoSave > auto_save_index_speed do
+			LastAutoSave = LastAutoSave + auto_save_index_speed
+			local profile = AutoSaveList[AutoSaveIndex]
+			if os_clock - profile._load_timestamp < SETTINGS.AutoSaveProfiles then
+				-- This profile is freshly loaded - auto-saving immediately after loading will cause a warning in the log:
+				profile = nil
+				for _ = 1, auto_save_list_length - 1 do
+					-- Move auto save index to the right:
+					AutoSaveIndex = AutoSaveIndex + 1
+					if AutoSaveIndex > auto_save_list_length then
+						AutoSaveIndex = 1
+					end
+					profile = AutoSaveList[AutoSaveIndex]
+					if os_clock - profile._load_timestamp >= SETTINGS.AutoSaveProfiles then
+						break
+					else
+						profile = nil
+					end
+				end
+			end
+			-- Move auto save index to the right:
+			AutoSaveIndex = AutoSaveIndex + 1
+			if AutoSaveIndex > auto_save_list_length then
+				AutoSaveIndex = 1
+			end
+			-- Perform save call:
+			if profile ~= nil then
+				task.spawn(SaveProfileAsync, profile) -- Auto save profile in new thread
+			end
+		end
+	end
+	-- 2) Issue queue: --
+	-- Critical state handling:
+	if ProfileService.CriticalState == false then
+		if #IssueQueue >= SETTINGS.IssueCountForCriticalState then
+			ProfileService.CriticalState = true
+			ProfileService.CriticalStateSignal:Fire(true)
+			CriticalStateStart = os.clock()
+			warn("[ProfileService]: Entered critical state")
+		end
+	else
+		if #IssueQueue >= SETTINGS.IssueCountForCriticalState then
+			CriticalStateStart = os.clock()
+		elseif os.clock() - CriticalStateStart > SETTINGS.CriticalStateLast then
+			ProfileService.CriticalState = false
+			ProfileService.CriticalStateSignal:Fire(false)
+			warn("[ProfileService]: Critical state ended")
+		end
+	end
+	-- Issue queue:
+	while true do
+		local issue_time = IssueQueue[1]
+		if issue_time == nil then
+			break
+		elseif os.clock() - issue_time > SETTINGS.IssueLast then
+			table.remove(IssueQueue, 1)
+		else
+			break
+		end
+	end
+end)
+
+-- Release all loaded profiles when the server is shutting down:
+task.spawn(function()
+	WaitForLiveAccessCheck()
+	Madwork.ConnectToOnClose(
+		function()
+			ProfileService.ServiceLocked = true
+			-- 1) Release all active profiles: --
+			-- Clone AutoSaveList to a new table because AutoSaveList changes when profiles are released:
+			local on_close_save_job_count = 0
+			local active_profiles = {}
+			for index, profile in ipairs(AutoSaveList) do
+				active_profiles[index] = profile
+			end
+			-- Release the profiles; Releasing profiles can trigger listeners that release other profiles, so check active state:
+			for _, profile in ipairs(active_profiles) do
+				if profile:IsActive() == true then
+					on_close_save_job_count = on_close_save_job_count + 1
+					task.spawn(function() -- Save profile on new thread
+						SaveProfileAsync(profile, true)
+						on_close_save_job_count = on_close_save_job_count - 1
+					end)
+				end
+			end
+			-- 2) Yield until all active profile jobs are finished: --
+			while on_close_save_job_count > 0 or ActiveProfileLoadJobs > 0 or ActiveProfileSaveJobs > 0 do
+				task.wait()
+			end
+			return -- We're done!
+		end,
+		UseMockDataStore == false -- Always run this OnClose task if using Roblox API services
+	)
+end)
+
+return ProfileService