Orbit-activity.rbxmx

<roblox xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.roblox.com/roblox.xsd" version="4">
	<Meta name="ExplicitAutoJoints">true</Meta>
	<External>null</External>
	<External>nil</External>
	<Item class="Script" referent="RBX97E7E2AD80E04B9E8A93A147C4CA28E2">
		<Properties>
			<ProtectedString name="Source"><![CDATA[-- Orbit Activity Tracker
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local DataStoreService  = game:GetService("DataStoreService")
local HttpService       = game:GetService("HttpService")
local Players           = game:GetService("Players")
local RunService        = game:GetService("RunService")
local GroupService      = game:GetService("GroupService")

local HttpQueue = require(script.Components.HttpQueue)

local TovyFolder = Instance.new("Folder", ReplicatedStorage)
TovyFolder.Name = "Orbit Assets"

local TovyEvent = Instance.new("RemoteEvent", TovyFolder)
TovyEvent.Name = "Activity"

local TovyClient = script:WaitForChild("Components"):WaitForChild("OrbitClient")
TovyClient.Event.Value = TovyEvent

local Configuration = {
	-- !! Do not touch !!
	url  = "<url>",
	auth = "<apikey>",

	privateEnabled = <privateenabled>,       -- Track private servers?
	studioEnabled  = <studioenabled>,       -- Track Studio sessions?

	-- Feature flags
	bansEnabled       = false,    -- Let Orbit handle bans?
	rankChecking      = true,     -- Only track members of the group?
	groupId           = <groupid>, -- Group ID for rank checks
	minTrackedRank    = <mintrackedrank>,       -- Minimum rank to be tracked (overridable via remote config)

	-- Timing
	cooldownPeriod       = 30,    -- Seconds between HTTP retries
	minutesTillAFK       = 1,     -- Idle minutes before AFK flag
	afkPollInterval      = 10,    -- Seconds between idle-time checks (AFK detection)
	scanInterval         = 300,   -- Seconds between full player scans (5 min)
	heartbeatInterval    = 60,    -- Seconds between lightweight heartbeats
	rankRefreshInterval  = 600,   -- Seconds between per-player rank re-checks (throttles GroupService)
	remoteEventCooldown  = 3,     -- Min seconds between accepted client Activity events per player

	-- Chat capture
	maxStoredChatLines  = 200,
	maxChatCharsPerLine = 512,

	-- Reliability
	deadLetterStoreName   = "OrbitFailedRequests",
	deadLetterFlushEvery  = 60,   -- Seconds between dead-letter retry sweeps
	deadLetterMaxAttempts = 10,   -- Give up (but keep for manual review) after this many failed retries
}

if not Configuration.studioEnabled and RunService:IsStudio() then
	return warn("Orbit: Tracking disabled in Studio. (studioEnabled = false)")
end

if not Configuration.privateEnabled then
	if game.PrivateServerId ~= "" and game.PrivateServerOwnerId ~= 0 then
		return warn("Orbit: Tracking disabled in private servers. (privateEnabled = false)")
	end
end

warn("Orbit: Module loaded — activity tracking active.")

local function log(level: string, msg: string)
	local prefix = string.format("[Orbit][%s] %s", level, msg)
	if level == "WARN" or level == "ERROR" then
		warn(prefix)
	else
		print(prefix)
	end
end

local function safeEncode(data: unknown): string?
	local ok, result = pcall(HttpService.JSONEncode, HttpService, data)
	return ok and result or nil
end

local function safeDecode(raw: string): unknown?
	local ok, result = pcall(HttpService.JSONDecode, HttpService, raw)
	return ok and result or nil
end

type PlayerState = {
	rank: number,
	chatLog: { string },
	sessionActive: boolean,
	lastActivity: number,
	afkStart: number?,
	isAFK: boolean,
	afkTimerInstance: NumberValue?,
	lastRankCheck: number,
	lastRemoteEventAccepted: number,
}

local PlayerData: { [number]: PlayerState } = {}

local function getState(Player: Player): PlayerState?
	return PlayerData[Player.UserId]
end

local function isPlayerOnline(Player: Player): boolean
	return Players:GetPlayerByUserId(Player.UserId) ~= nil
end

local function stripChat(text: string): string
	return (text:gsub("^%s+", ""):gsub("%s+$", ""))
end

local function setAFK(Player: Player, state: boolean)
	local st = getState(Player)
	if not st then return end

	if state and not st.isAFK then
		st.isAFK = true
		st.afkStart = os.clock()
	elseif not state and st.isAFK then
		st.isAFK = false
		st.afkStart = nil
		if st.afkTimerInstance then
			st.afkTimerInstance.Value = 0
		end
	end
end

local function bumpActivity(Player: Player)
	local st = getState(Player)
	if not st then return end
	st.lastActivity = os.clock()
	setAFK(Player, false)
end

local function appendChatLine(userId: number, raw: unknown)
	local st = PlayerData[userId]
	if not st then return end

	local text = type(raw) == "string" and raw or ""
	text = stripChat(text)
	if text == "" then return end

	local maxChars = Configuration.maxChatCharsPerLine
	if maxChars > 0 and #text > maxChars then
		text = text:sub(1, maxChars)
	end

	table.insert(st.chatLog, text)

	local cap = Configuration.maxStoredChatLines
	while cap > 0 and #st.chatLog > cap do
		table.remove(st.chatLog, 1)
	end
end

local function collectSessionEndRow(Player: Player): { [string]: unknown }
	local st = getState(Player)
	local log_t = st and st.chatLog or {}
	local idleMinutes = st and st.afkTimerInstance and st.afkTimerInstance.Value or 0

	local row: { [string]: unknown } = {
		userid   = Player.UserId,
		username = Player.Name,
		placeid  = game.GameId,
		idleTime = idleMinutes,
		messages = #log_t,
	}
	if #log_t > 0 then
		row.chatBodies = log_t
	end
	return row
end

local function fetchRank(Player: Player): number
	if not Configuration.rankChecking then return math.huge end
	local success, rankInfo = pcall(function()
		return GroupService:GetRolesInGroupAsync(Player.UserId, Configuration.groupId)
	end)
	if not success then return math.huge end
	if not rankInfo.IsMember then return math.huge end

	return rankInfo.Roles[1] and rankInfo.Roles[1].Rank or 0
end

local function isUserTracked(Player: Player): boolean
	if not Configuration.rankChecking then return true end
	local st = getState(Player)
	if not st then return false end
	return st.rank >= Configuration.minTrackedRank
end

local DeadLetterStore = DataStoreService:GetDataStore(Configuration.deadLetterStoreName)
local deadLetterCounter = 0

local function deadLetterKey(): string
	deadLetterCounter += 1
	return string.format("%d-%d-%d", game.JobId and #game.JobId or 0, os.time(), deadLetterCounter)
end

local function enqueueDeadLetter(endpoint: string, body: unknown)
	local key = deadLetterKey()
	local ok, err = pcall(function()
		DeadLetterStore:SetAsync(key, {
			endpoint = endpoint,
			body     = body,
			attempts = 0,
			queuedAt = os.time(),
		})
	end)
	if ok then
		log("WARN", "Queued failed request to dead-letter store: " .. endpoint)
	else
		log("ERROR", "Failed to enqueue dead-letter entry (" .. endpoint .. "): " .. tostring(err))
	end
end

local function rawPost(endpoint: string, encodedBody: string): (boolean, unknown?)
	local ok, result = pcall(HttpService.RequestAsync, HttpService, {
		Url     = Configuration.url .. endpoint,
		Method  = "POST",
		Headers = {
			["Content-Type"]  = "application/json",
			["authorization"] = Configuration.auth,
		},
		Body = encodedBody,
	})
	if not ok or not result.Success then return false, nil end
	return true, safeDecode(result.Body)
end

local function httpGet(endpoint: string, maxAttempts: number?): (boolean, unknown?)
	maxAttempts = maxAttempts or 2
	for attempt = 1, maxAttempts do
		local ok, result = pcall(HttpService.RequestAsync, HttpService, {
			Url     = Configuration.url .. endpoint,
			Method  = "GET",
			Headers = { ["authorization"] = Configuration.auth },
		})
		if ok and result.Success then
			local decoded = safeDecode(result.Body)
			if decoded ~= nil then
				return true, decoded
			end
		end
		if attempt < maxAttempts then
			task.wait(1)
		end
	end
	return false, nil
end

local function httpPost(endpoint: string, body: unknown, allowDeadLetter: boolean?): boolean
	local encoded = safeEncode(body)
	if not encoded then
		log("ERROR", "Failed to encode body for " .. endpoint)
		return false
	end

	local ok = rawPost(endpoint, encoded)
	if ok then
		return true
	end

	local queuedOk = pcall(function()
		HttpQueue.HttpRequest.new(Configuration.url .. endpoint, "POST", encoded, nil, {
			["Content-Type"]  = "application/json",
			["authorization"] = Configuration.auth,
		}):Send()
	end)

	if not queuedOk and allowDeadLetter ~= false then
		enqueueDeadLetter(endpoint, body)
	end

	return queuedOk
end

local function handlePossibleBan(Player: Player, response: unknown)
	if not Configuration.bansEnabled then return end
	if type(response) ~= "table" then return end

	if response.banned then
		local reason = type(response.reason) == "string" and response.reason or "Banned"
		log("WARN", string.format("%s is banned via Orbit (%s) — kicking.", Player.Name, reason))
		Player:Kick("You have been banned: " .. reason)
	end
end

local function checkRemoteSessionActive(Player: Player): boolean
	local ok, response = httpGet("/api/activity/session?id=" .. Player.UserId)
	if ok and type(response) == "table" and response.success then
		return true
	end
	return false
end

local function CreateSession(Player: Player)
	local st = getState(Player)
	if not st then return end

	if st.sessionActive then
		log("INFO", "Session already cached as active for " .. Player.Name .. ", skipping.")
		return
	end

	if checkRemoteSessionActive(Player) then
		log("WARN", "Remote session already exists for " .. Player.Name .. ", syncing local cache.")
		st.sessionActive = true
		return
	end

	local encoded = safeEncode({
		userid   = Player.UserId,
		username = Player.Name,
		placeid  = game.GameId,
	})
	local ok, response = false, nil
	if encoded then
		ok, response = rawPost("/api/activity/session?type=create", encoded)
	end

	if ok then
		st.sessionActive = true
		log("INFO", "Session created for " .. Player.Name)
		handlePossibleBan(Player, response)
	else
		local fallbackOk = httpPost("/api/activity/session?type=create", {
			userid   = Player.UserId,
			username = Player.Name,
			placeid  = game.GameId,
		})
		if fallbackOk then
			st.sessionActive = true
			log("INFO", "Session created for " .. Player.Name .. " (via retry path)")
		else
			log("ERROR", "Failed to create session for " .. Player.Name)
		end
	end
end

local function BulkCreateSessions(playersList: { Player })
	if #playersList == 0 then return end

	local rows = {}
	for _, Player in ipairs(playersList) do
		table.insert(rows, {
			userid   = Player.UserId,
			username = Player.Name,
			placeid  = game.GameId,
		})
	end

	local encoded = safeEncode({ sessions = rows })
	local bulkSucceeded: { [number]: boolean } = {}

	if encoded then
		local ok, response = rawPost("/api/activity/bulk-start", encoded)
		if ok and type(response) == "table" and type(response.started) == "table" then
			for _, userId in ipairs(response.started) do
				bulkSucceeded[userId] = true
			end
			log("INFO", string.format("Bulk-started %d/%d session(s).", #response.started, #playersList))
		end
	end

	for _, Player in ipairs(playersList) do
		local st = getState(Player)
		if st then
			if bulkSucceeded[Player.UserId] then
				st.sessionActive = true
			else
				CreateSession(Player)
			end
		end
	end
end

local function EndSession(Player: Player, reason: string?)
	local st = getState(Player)
	if not st then return end

	if not st.sessionActive then
		if not checkRemoteSessionActive(Player) then
			log("INFO", "No session to end for " .. Player.Name)
			return
		end
	end

	local row = collectSessionEndRow(Player)
	row.endReason = reason or "natural"

	local success = httpPost("/api/activity/session?type=end", row)
	if success then
		st.sessionActive = false
		log("INFO", string.format("Session ended for %s (reason: %s)", Player.Name, row.endReason))
	else
		log("ERROR", "Failed to end session for " .. Player.Name)
	end
end

local function MovementDetection(Player: Player)
	local Character = Player.Character or Player.CharacterAdded:Wait()
	local Humanoid  = Character:WaitForChild("Humanoid")

	local st = getState(Player)
	if not st then return end
	if not st.lastActivity then
		st.lastActivity = os.clock()
	end

	local connections: { RBXScriptConnection } = {}

	local function onActivity(speed: number)
		if speed > 0 then
			bumpActivity(Player)
		end
	end

	table.insert(connections, Humanoid.Running:Connect(onActivity))
	table.insert(connections, Humanoid.Swimming:Connect(onActivity))
	table.insert(connections, Humanoid.Climbing:Connect(onActivity))
	table.insert(connections, Humanoid.Jumping:Connect(function(isJumping)
		if isJumping then
			bumpActivity(Player)
		end
	end))

	local charRemovedConn
	charRemovedConn = Character.AncestryChanged:Connect(function()
		if not Character:IsDescendantOf(game) then
			for _, c in ipairs(connections) do
				c:Disconnect()
			end
			charRemovedConn:Disconnect()
		end
	end)
end

local function InputChange(Player: Player, isIdle: unknown)
	if typeof(isIdle) ~= "boolean" then
		log("WARN", "Rejected malformed Activity event from " .. Player.Name)
		return
	end

	local st = getState(Player)
	if not st then return end

	local now = os.clock()
	if now - (st.lastRemoteEventAccepted or 0) < Configuration.remoteEventCooldown then
		return
	end
	st.lastRemoteEventAccepted = now

	if not isIdle then
		bumpActivity(Player)
	else
		local idleSeconds = st.lastActivity and (now - st.lastActivity) or math.huge
		local threshold = 60 * Configuration.minutesTillAFK

		if idleSeconds >= threshold then
			setAFK(Player, true)
		end
	end
end

TovyEvent.OnServerEvent:Connect(InputChange)


local function InitiatePlayer(Player: Player): boolean
	local rank = fetchRank(Player)

	PlayerData[Player.UserId] = {
		rank                    = rank,
		chatLog                 = {},
		sessionActive           = false,
		lastActivity            = os.clock(),
		afkStart                = nil,
		isAFK                   = false,
		afkTimerInstance        = nil,
		lastRankCheck           = os.clock(),
		lastRemoteEventAccepted = 0,
	}

	if not isUserTracked(Player) then
		log("INFO", Player.Name .. " is not at a tracked rank — skipping session.")
		return false
	end

	local afkTimer = Instance.new("NumberValue")
	afkTimer.Name   = "Orbit AFK Timer"
	afkTimer.Parent = Player
	PlayerData[Player.UserId].afkTimerInstance = afkTimer

	local clientClone = TovyClient:Clone()
	clientClone.Parent = Player:WaitForChild("PlayerGui")

	task.spawn(MovementDetection, Player)
	return true
end

local function CleanupPlayer(Player: Player, reason: string?)
	EndSession(Player, reason)
	PlayerData[Player.UserId] = nil
end

Players.PlayerAdded:Connect(function(Player)
	local tracked = InitiatePlayer(Player)
	if tracked then
		CreateSession(Player)
	end

	Player.CharacterAdded:Connect(function()
		local st = getState(Player)
		if st then
			st.lastActivity = os.clock()
		end
		MovementDetection(Player)
	end)

	Player.Chatted:Connect(function(Message)
		if isUserTracked(Player) then
			appendChatLine(Player.UserId, Message)
			bumpActivity(Player)
		end
	end)
end)

Players.PlayerRemoving:Connect(function(Player)
	CleanupPlayer(Player, "player_left")
end)

game:BindToClose(function()
	local sessions = {}
	for _, Player in ipairs(Players:GetPlayers()) do
		local st = getState(Player)
		if st and isUserTracked(Player) and (st.sessionActive or checkRemoteSessionActive(Player)) then
			local row = collectSessionEndRow(Player)
			row.endReason = "server_shutdown"
			table.insert(sessions, row)
		end
	end

	if #sessions > 0 then
		local encoded = safeEncode({ sessions = sessions })
		if encoded then
			local ok = rawPost("/api/activity/bulk-end", encoded)
			if ok then
				log("INFO", string.format("Shutdown: bulk-ended %d session(s).", #sessions))
			else
				log("ERROR", "Shutdown: bulk-end request failed — queueing for dead-letter retry.")
				enqueueDeadLetter("/api/activity/bulk-end", { sessions = sessions })
			end
		end
	else
		log("INFO", "Shutdown: no active sessions to end.")
	end

	task.wait(5)
end)

local function fetchRemoteConfig()
	local ok, response = httpGet(`/api/activity/config?id={Configuration.groupId}`)
	if not ok or type(response.data) ~= "table" then
		log("WARN", "Could not fetch remote config — using local defaults.")
		return
	end

	local overridable = {"minTrackedRank", "privateEnabled", "studioEnabled"}
	local changed = {}
	for _, key in ipairs(overridable) do
		if response[key] ~= nil and response[key] ~= Configuration[key] then
			Configuration[key] = response[key]
			table.insert(changed, key)
		end
	end

	if #changed > 0 then
		log("INFO", "Applied remote config overrides: " .. table.concat(changed, ", "))
	end
end

task.spawn(function()
	while true do
		task.wait(Configuration.afkPollInterval)
		local threshold = 60 * Configuration.minutesTillAFK
		for userId, st in pairs(PlayerData) do
			local Player = Players:GetPlayerByUserId(userId)
			if Player and isPlayerOnline(Player) and isUserTracked(Player) and not st.isAFK then
				local idleFor = os.clock() - st.lastActivity
				if idleFor >= threshold then
					setAFK(Player, true)
					log("INFO", Player.Name .. " marked AFK (idle for " .. math.floor(idleFor) .. "s).")
				end
			end
		end
	end
end)

task.spawn(function()
	while true do
		task.wait(Configuration.heartbeatInterval)
		for userId, st in pairs(PlayerData) do
			if st.isAFK and st.afkStart and st.afkTimerInstance then
				local Player = Players:GetPlayerByUserId(userId)
				if Player and isPlayerOnline(Player) then
					st.afkTimerInstance.Value = math.floor((os.clock() - st.afkStart) / 60)
				end
			end
		end
	end
end)

task.spawn(function()
	while true do
		task.wait(Configuration.deadLetterFlushEvery)

		local ok, keysPage = pcall(function()
			return DeadLetterStore:ListKeysAsync()
		end)
		if not ok then continue end

		local currentPage = keysPage:GetCurrentPage()
		for _, keyInfo in ipairs(currentPage) do
			local key = keyInfo.KeyName
			local getOk, entry = pcall(function()
				local value = DeadLetterStore:GetAsync(key)
				return value
			end)

			if getOk and type(entry) == "table" then
				local encoded = safeEncode(entry.body)
				if encoded then
					local postOk = rawPost(entry.endpoint, encoded)
					if postOk then
						pcall(function() DeadLetterStore:RemoveAsync(key) end)
						log("INFO", "Dead-letter retry succeeded for " .. entry.endpoint)
					else
						entry.attempts = (entry.attempts or 0) + 1
						if entry.attempts >= Configuration.deadLetterMaxAttempts then
							log("ERROR", string.format(
								"Dead-letter entry %s exceeded max attempts (%d) — leaving in store for manual review.",
								key, entry.attempts))
						else
							pcall(function() DeadLetterStore:SetAsync(key, entry) end)
						end
					end
				end
			end
		end
	end
end)

task.spawn(function()
	while true do
		task.wait(Configuration.scanInterval)
		log("INFO", "Running full player scan...")

		local onlinePlayers = Players:GetPlayers()
		local onlineSet: { [number]: boolean } = {}
		for _, p in ipairs(onlinePlayers) do
			onlineSet[p.UserId] = true
		end

		for userId, st in pairs(PlayerData) do
			if st.sessionActive and not onlineSet[userId] then
				log("WARN", string.format(
					"Ghost session detected for userId %d — ending immediately.", userId))
				local ghostRow = {
					userid    = userId,
					idleTime  = 0,
					messages  = #st.chatLog,
					endReason = "ghost_cleanup",
				}
				if #st.chatLog > 0 then
					ghostRow.chatBodies = st.chatLog
				end
				httpPost("/api/activity/session?type=end", ghostRow)
				PlayerData[userId] = nil
			end
		end

		for _, Player in ipairs(onlinePlayers) do
			if isUserTracked(Player) then
				local st = getState(Player)
				if st and not st.sessionActive then
					local remoteActive = checkRemoteSessionActive(Player)
					if remoteActive then
						log("WARN", Player.Name .. " has remote session but no local cache — syncing.")
						st.sessionActive = true
					else
						log("WARN", Player.Name .. " has no active session — recreating.")
						if st.afkTimerInstance then st.afkTimerInstance.Value = 0 end
						CreateSession(Player)
					end
				end
			end
		end

		if Configuration.rankChecking then
			for i, Player in ipairs(onlinePlayers) do
				local st = getState(Player)
				if st then
					local dueForRecheck = (os.clock() - (st.lastRankCheck or 0)) >= Configuration.rankRefreshInterval
					if dueForRecheck then
						if i > 1 then task.wait(0.25) end

						local oldRank = st.rank
						local newRank = fetchRank(Player)
						st.rank = newRank
						st.lastRankCheck = os.clock()

						if newRank ~= oldRank then
							log("INFO", string.format("%s rank changed: %d → %d", Player.Name, oldRank, newRank))

							if oldRank >= Configuration.minTrackedRank
								and newRank < Configuration.minTrackedRank then
								log("WARN", Player.Name .. " fell below min rank, ending session.")
								EndSession(Player, "rank_below_minimum")

							elseif oldRank < Configuration.minTrackedRank
								and newRank >= Configuration.minTrackedRank then
								log("INFO", Player.Name .. " now meets min rank, starting session.")
								st.chatLog = {}
								st.lastActivity = os.clock()
								if not st.afkTimerInstance then
									local afkTimer = Instance.new("NumberValue")
									afkTimer.Name   = "Orbit AFK Timer"
									afkTimer.Parent = Player
									st.afkTimerInstance = afkTimer
								end
								CreateSession(Player)
							end
						end
					end
				end
			end
		end
		for userId, st in pairs(PlayerData) do
			if st.isAFK and not onlineSet[userId] then
				st.isAFK = false
				st.afkStart = nil
			end
		end
	end
end)

fetchRemoteConfig()

do
	local startupPlayers = Players:GetPlayers()
	local trackedForBulkStart = {}

	for _, Player in ipairs(startupPlayers) do
		local tracked = InitiatePlayer(Player)
		if tracked then
			table.insert(trackedForBulkStart, Player)
		end
	end

	BulkCreateSessions(trackedForBulkStart)
end]]></ProtectedString>
			<bool name="Disabled">false</bool>
			<Content name="LinkedSource"><null></null></Content>
			<token name="RunContext">0</token>
			<string name="ScriptGuid">{81740BB3-280D-4363-BA2A-0CE80C16A785}</string>
			<BinaryString name="AttributesSerialize"></BinaryString>
			<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
			<bool name="DefinesCapabilities">false</bool>
			<string name="Name">OrbitActivity</string>
			<int64 name="SourceAssetId">-1</int64>
			<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
		</Properties>
		<Item class="Folder" referent="RBX03E86216049E4E9189C6FE50204AFC10">
			<Properties>
				<BinaryString name="AttributesSerialize"></BinaryString>
				<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
				<bool name="DefinesCapabilities">false</bool>
				<string name="Name">Components</string>
				<int64 name="SourceAssetId">-1</int64>
				<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
			</Properties>
			<Item class="ModuleScript" referent="RBX5E7D8CB756C1427096B95E0140358B8A">
				<Properties>
					<Content name="LinkedSource"><null></null></Content>
					<ProtectedString name="Source"><![CDATA[--[[
    File: http-queue/init.lua
    Description: Front-end for the http-queue library

    SPDX-License-Identifier: MIT
]]

local exports = {
    HttpRequestPriority = require(script.HttpRequestPriority),
    HttpRequest = require(script.HttpRequest),
    HttpQueue = require(script.HttpQueue)
}

for name, guard in pairs(require(script.TypeGuards)) do
    exports[name] = guard
end

return exports
]]></ProtectedString>
					<string name="ScriptGuid">{FE2A771C-DD2C-45EB-B0B2-BA2830DA58B6}</string>
					<BinaryString name="AttributesSerialize"></BinaryString>
					<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
					<bool name="DefinesCapabilities">false</bool>
					<string name="Name">HttpQueue</string>
					<int64 name="SourceAssetId">-1</int64>
					<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
				</Properties>
				<Item class="ModuleScript" referent="RBX75F29D21BFBF4FB3BDF42B2133BFFCF2">
					<Properties>
						<Content name="LinkedSource"><null></null></Content>
						<ProtectedString name="Source"><![CDATA[--[[
    File: http-queue/DataUtils.lua
    Description: Data structures and basic synchronization utilities

    SPDX-License-Identifier: MIT
]]

local dataUtils = {}

-- Small linked list implementation
function dataUtils.newLLNode(item)
    return {Data = item, Prev = nil, Next = nil}
end

function dataUtils.addNodeToFirst(node, root)
    if not root.First then
        root.First = node
        root.Last = node
    else
        root.First.Prev = node
        node.Next = root.First
        node.Prev = nil
        root.First = node
    end
end

function dataUtils.addNodeToLast(node, root)
    if not root.Last then
        root.First = node
        root.Last = node
    else
        root.Last.Next = node
        node.Prev = root.Last
        node.Next = nil
        root.Last = node
    end
end

return dataUtils
]]></ProtectedString>
						<string name="ScriptGuid">{023794A1-6658-4BCB-92A9-5B9086A5DD23}</string>
						<BinaryString name="AttributesSerialize"></BinaryString>
						<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
						<bool name="DefinesCapabilities">false</bool>
						<string name="Name">DataUtils</string>
						<int64 name="SourceAssetId">-1</int64>
						<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
					</Properties>
				</Item>
				<Item class="ModuleScript" referent="RBX04FB9AC7D33842D4B89616FD10E0066B">
					<Properties>
						<Content name="LinkedSource"><null></null></Content>
						<ProtectedString name="Source"><![CDATA[--[[
    File: http-queue/HttpQueue.lua
    Description: Creates a self-regulating queue for rate-limited services

    SPDX-License-Identifier: MIT
]]

local Priority = require(script.Parent.HttpRequestPriority)
local newHttpResponse = require(script.Parent.HttpResponse)

local datautil = require(script.Parent.DataUtils)
local guards = require(script.Parent.TypeGuards)
local deps = require(script.Parent.DependencyLoader)

local Promise, t = deps.Promise, deps.t

local HttpQueue = {}

local validInt = t.intersection(t.integer, t.numberPositive)

local newHttpQueueCheck = t.strict(t.strictInterface({
    retryAfter = t.union(
        t.strictInterface({
            header = t.string
        }),
        t.strictInterface({
            cooldown = validInt
        }),
        t.strictInterface({
            callback = t.callback
        })
    ),
    maxSimultaneousSendOperations = t.optional(validInt)
}))

local pushCheck = t.strict(t.tuple(guards.isHttpRequest, t.optional(guards.isHttpRequestPriority)))

--[[**
    Creates an HttpQueue. It is a self-regulating queue for REST APIs that impose rate limits. When you push a request to the queue,
    the queue will send the ones added first to the remote server (unless you specify a priority). The queue automatically handles
    the rate limits in order to, as humanly as possible, respect the service's rate limits and Terms of Service.

    A queue is NOT A SILVER BULLET NEITHER A GUARANTEE of not spamming invalid requests, though. Depending on your game's
    playerbase/number of servers compared to the rate limit of the services, it might not scale well.

    @param options The options for the queue.
    @param [t:string|nil] options.retryAfter.header If the reqeuest is rate limited, look for this header to determine how long to wait (in seconds). If defined, don't provide options.retryAfter.cooldown
    @param [t:number|nil] options.retryAfter.cooldown Define a cooldown period directly. If defined, do not define options.retryAfter.header
    @param [t:number(HttpResponse)|nil] options.retryAfter.callback Pass a function that takes a rate-limited response and returns the cooldown period (in seconds). If defined, do not define options.retryAfter.header
    @param [t:number|nil] options.maxSimultaneousSendOperations How many requests should be sent at the same time (maximum). Defaults to 10.
**--]]
function HttpQueue.new(options)
    newHttpQueueCheck(options)

    local prioritaryQueue = {}
    local regularQueue = {}

    local queueSize = 0

    local queueExecutor = coroutine.create(function()
        local interrupted = false
        local restart = false
        local main = coroutine.running()
        local availableWorkers = options.maxSimultaneousSendOperations or 10
        local cooldown
        if options.retryAfter.header then
            local header = options.retryAfter.header
            cooldown = function(response)
                wait(response.Headers[header])
            end
        elseif options.retryAfter.cooldown then
            local cooldownPeriod = options.retryAfter.cooldown
            cooldown = function()
                wait(cooldownPeriod)
            end
        else
            local callback = options.retryAfter.callback
            cooldown = function(response)
                wait(callback(response))
            end
        end

        local function resolveNode(node)
            -- Resolve the request
            if node.Next then
                node.Next.Prev = nil
            end
            node.Next = nil

            -- Release resources
            queueSize = queueSize - 1
            availableWorkers = availableWorkers + 1
            if coroutine.status(main) == "suspended" then
                coroutine.resume(main)
            end
        end

        local function httpStall()
            -- HttpService stalled (number of requests exceeded)
            wait(30)
        end

        local function stall(stallMethod, response)
            interrupted = true
            restart = true
            stallMethod(response)
            interrupted = false
        end

        local function sendNode(node)
            return Promise.async(function(resolve)
                node.Data.Request:Send():andThen(function(response)
                    if response.StatusCode == 429 then
                        stall(cooldown, response)
                        sendNode(node) -- try again!
                    else
                        coroutine.resume(node.Data.Callback, response)
                    end

                    resolve(node)
                end):catch(function(err)
                    -- Did we exceed the HttpService limits?
                    if err:match("Number of requests exceeded limit") then
                        stall(httpStall)
                        sendNode(node) -- try again!
                    else
                        coroutine.resume(node.Data.Callback, err)
                    end

                    resolve(node)
                end)
            end)
        end

        local function doQueue(queue)
            while queue.First do
                while interrupted or availableWorkers == 0 do
                    coroutine.yield()
                end
                if restart then
                    break
                end

                local node = queue.First
                availableWorkers = availableWorkers - 1

                sendNode(node):andThen(resolveNode)

                queue.First = node.Next
                if not queue.First then
                    queue.Last = nil
                end
            end
        end

        while true do
            restart = false
            doQueue(prioritaryQueue)
            doQueue(regularQueue)

            if not restart then
                coroutine.yield()
            end
        end
    end)

    local httpQueue = {}

    --[[**
        Pushes a request to the queue to be sent whenever possible.

        @param [t:HttpRequest] request The request to be sent.
        @param [t:HttpRequestPriority] priority The priority of the request in relation to other requests in the same queue.

        @returns [t:Promise<HttpResponse>] A promise to a HttpResponse that is resolved when it is available.
    **--]]
    function httpQueue:Push(request, priority)
        pushCheck(request, priority)

        local requestBody = {Request = request}
        local promise = Promise.async(function(resolve, reject)
            requestBody.Callback = coroutine.running()
            local response = coroutine.yield()
            if guards.isHttpResponse(response) then
                resolve(response)
            else
                reject(response)
            end
        end)

        if not priority or priority == Priority.Normal then
            datautil.addNodeToLast(datautil.newLLNode(requestBody), regularQueue)
        elseif priority == Priority.Prioritary then
            datautil.addNodeToLast(datautil.newLLNode(requestBody), prioritaryQueue)
        elseif priority == Priority.First then
            datautil.addNodeToFirst(datautil.newLLNode(requestBody), prioritaryQueue)
        end
        queueSize = queueSize + 1

        coroutine.resume(queueExecutor)
        return promise
    end

    --[[**
        Pushes a request to the queue to be sent whenever possible.

        @param [t:HttpRequest] request The request to be sent.
        @param [t:HttpRequestPriority] priority The priority of the request in relation to other requests in the same queue.

        @returns [t:HttpResponse] The server's response to the request.
    **--]]
    function httpQueue:AwaitPush(request, priority)
        local resolved, response = self:Push(request, priority):await()
        return resolved and response or newHttpResponse(false, response)
    end

    --[[**
        @returns [t:number] The number of unsent requests in the queue.
    **--]]
    function httpQueue:QueueSize()
        return queueSize
    end

    return setmetatable(httpQueue, {
        __metatable = "HttpQueue",
        __index = function(_, index)
            error("Attempt to index non-existant value HttpQueue." .. tostring(index))
        end
    })
end

return setmetatable(HttpQueue, {
    __metatable = "HttpQueue",
    __index = function(_, index)
        error("Attempt to index non-existant value HttpQueue." .. tostring(index))
    end
})
]]></ProtectedString>
						<string name="ScriptGuid">{9C00AA1B-2A14-48E5-998E-9BE6EC807541}</string>
						<BinaryString name="AttributesSerialize"></BinaryString>
						<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
						<bool name="DefinesCapabilities">false</bool>
						<string name="Name">HttpQueue</string>
						<int64 name="SourceAssetId">-1</int64>
						<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
					</Properties>
				</Item>
				<Item class="ModuleScript" referent="RBXC78A8C757AB344D4B43C47117867B28F">
					<Properties>
						<Content name="LinkedSource"><null></null></Content>
						<ProtectedString name="Source"><![CDATA[--[[
    File: http-queue/HttpRequest.lua
    Description: Wrapper for an HttpService request

    SPDX-License-Identifier: MIT
]]

local deps = require(script.Parent.DependencyLoader)
local newHttpResponse = require(script.Parent.HttpResponse)
local HttpService, Promise, t = deps.HttpService, deps.Promise, deps.t

local HttpRequest = {}

local requestCheck = t.strict(
    t.tuple(t.string, t.string, t.optional(t.string),
        t.optional(t.map(t.string, t.union(t.string, t.number, t.boolean))),
        t.optional(t.map(t.string, t.string))
    )
)

--[[**
    Creates an HttpRequest.

    @param [t:String] Url The url endpoint the request is being sent to.
    @param [t:String] Method A string containing the method/verb being used in the request.
    @param [t:String|nil] Body The body of the request. Only applicable if you're going to send data (POST, PUT, etc.)
    @param [t:Dictionary<string,string|bool|number>|nil] Query Url query options (which are then appended to the url)
    @param [t:Dictionary<string,string>|nil] Headers Additional headers to be included in the request
**--]]
function HttpRequest.new(Url, Method, Body, Query, Headers)
    requestCheck(Url, Method, Body, Query, Headers)

    -- Now we can assume type-safety!
    local endpoint = Url

    local url = Url:split("://")
    if url[1] == Url then
        error("\"" .. Url .. "\" doesn't look like a valid Url!")
    end

    -- Never hurts to check for this and correct
    -- https://example.org?query1=a is invalid
    -- https://example.org/?query1=a is not!
    -- We also need to check if there's already a path in the URL
    -- e.g https://example.com/file is different from https://example.com/file/
    if not url[2]:find("/") then
        endpoint = endpoint .. "/"
    end

    if t.table(Query) then
        local queryString = "?"
        for i, v in pairs (Query) do
            queryString = queryString .. HttpService:UrlEncode(i) .. "=" .. HttpService:UrlEncode(tostring(v)) .. "&"
        end
        endpoint = endpoint .. queryString:sub(1, -2)
    end

    local httpRequest = {}

    httpRequest.Url = endpoint

    --[[**
        Sends the request to the specified Url.

        @returns [t:HttpResponse] The server's response to the request.
    **--]]
    function httpRequest:AwaitSend()
        -- Placeholder
        local success, result = pcall(function()
            return HttpService:RequestAsync({
                Url = endpoint,
                Method = Method,
                Headers = Headers,
                Body = if (Method == "GET" or Method == "HEAD") then nil else Body
            })
		end)
		
        return newHttpResponse(success, result)
    end

    --[[**
        Sends the request to the specified Url.

        @returns [t:Promise<HttpResponse>] A promise to a HttpResponse that is resolved when it is available.
    **--]]
    function httpRequest:Send()
        return Promise.async(function(resolve, reject)
            local response = self:AwaitSend()
            if response.ConnectionSuccessful then
                resolve(response)
            else
                reject(response.StatusMessage)
            end
        end)
    end

    return setmetatable(httpRequest, {
        __metatable = "HttpRequest",
        __index = function(_, index)
            error("Attempt to index non-existant value HttpRequest." .. tostring(index))
        end
    })
end

return setmetatable(HttpRequest, {
    __metatable = "HttpRequest",
    __index = function(_, index)
        error("Attempt to index non-existant value HttpRequest." .. tostring(index))
    end
})
]]></ProtectedString>
						<string name="ScriptGuid">{FB8696F6-C420-4A0B-A3F1-67434876F8E3}</string>
						<BinaryString name="AttributesSerialize"></BinaryString>
						<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
						<bool name="DefinesCapabilities">false</bool>
						<string name="Name">HttpRequest</string>
						<int64 name="SourceAssetId">-1</int64>
						<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
					</Properties>
				</Item>
				<Item class="ModuleScript" referent="RBX7F1CA8443F2640B9B84D1291F912CDA9">
					<Properties>
						<Content name="LinkedSource"><null></null></Content>
						<ProtectedString name="Source"><![CDATA[--[[
    File: http-queue/HttpRequestPriority.lua
    Description: Enum to determine how a request should be queued.

    SPDX-License-Identifier: MIT
]]

local PriorityMeta = {
    __metatable = "HttpRequestPriority",
    __index = function(_, index)
        error("Attempt to index non-existant value HttpRequestPriority." .. tostring(index))
    end,
    __eq = function(me, other)
        return getmetatable(me) == getmetatable(other) and me.Value == other.Value
    end
}

return setmetatable({
    First = setmetatable({ Value = 1 }, PriorityMeta),
    Prioritary = setmetatable({ Value = 2 }, PriorityMeta),
    Normal = setmetatable({ Value = 3 }, PriorityMeta)
}, {
    __index = function(_, index)
        error(tostring(index) .. " is not a valid HttpRequestPriority!")
    end
})
]]></ProtectedString>
						<string name="ScriptGuid">{D32001E5-379D-461F-8EE8-561C788CD8A0}</string>
						<BinaryString name="AttributesSerialize"></BinaryString>
						<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
						<bool name="DefinesCapabilities">false</bool>
						<string name="Name">HttpRequestPriority</string>
						<int64 name="SourceAssetId">-1</int64>
						<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
					</Properties>
				</Item>
				<Item class="ModuleScript" referent="RBX8677B616FDDE4670AF8BAF04F5EB81C6">
					<Properties>
						<Content name="LinkedSource"><null></null></Content>
						<ProtectedString name="Source"><![CDATA[--[[
    File: http-queue/HttpResponse.lua
    Description: Private wrapper for an HttpService response

    SPDX-License-Identifier: MIT
]]

local function newHttpResponse(success, result)
    local HttpResponse = {}

    HttpResponse.ConnectionSuccessful = success
    HttpResponse.RequestSuccessful = success and result.Success
    HttpResponse.StatusCode = success and result.StatusCode or 0
    HttpResponse.StatusMessage = success and (result.StatusCode .. " " .. result.StatusMessage) or result
    HttpResponse.Headers = success and result.Headers or {}
    HttpResponse.Body = success and (result.Body or "") or nil

    return setmetatable(HttpResponse, {
        __metatable = "HttpResponse",
        __index = function(_, index)
            error("Attempt to index non-existant value HttpResponse." .. tostring(index))
        end
    })
end

return newHttpResponse
]]></ProtectedString>
						<string name="ScriptGuid">{6852466C-23CA-4C7A-B4A1-D361FCD8FBA7}</string>
						<BinaryString name="AttributesSerialize"></BinaryString>
						<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
						<bool name="DefinesCapabilities">false</bool>
						<string name="Name">HttpResponse</string>
						<int64 name="SourceAssetId">-1</int64>
						<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
					</Properties>
				</Item>
				<Item class="ModuleScript" referent="RBX4CFC94F3BAF145CEB15207CA65631B76">
					<Properties>
						<Content name="LinkedSource"><null></null></Content>
						<ProtectedString name="Source"><![CDATA[--[[
    File: https-queue/TypeGuards.lua
    Description: Type guards to validate http-queue interfaces

    SPDX-License-Identifier: MIT
]]

local t = require(script.Parent.DependencyLoader).t

local guards = {}

guards.isHttpRequest = t.intersection(t.strictInterface({
    Url = t.string,
    Send = t.callback,
    AwaitSend = t.callback
}), function(o)
    return getmetatable(o) == "HttpRequest"
end)

guards.isHttpRequestPriority = t.intersection(t.strictInterface({
    Value = t.number,
}), function(o)
    return getmetatable(o) == "HttpRequestPriority"
end)

guards.isHttpResponse = t.intersection(t.strictInterface({
    ConnectionSuccessful = t.boolean,
    RequestSuccessful = t.boolean,
    StatusCode = t.number,
    StatusMessage = t.string,
    Headers = t.map(t.string, t.string),
    Body = t.string
}), function(o)
    return getmetatable(o) == "HttpResponse"
end)

guards.isHttpQueue = t.intersection(t.strictInterface({
    __metatable = t.literal("HttpQueue"),
    QueueSize = t.callback,
    Push = t.callback,
    AwaitPush = t.callback
}), function(o)
    return getmetatable(o) == "HttpQueue"
end)

return guards
]]></ProtectedString>
						<string name="ScriptGuid">{1D92F075-DDEE-4908-82EB-2D4C5B267F5F}</string>
						<BinaryString name="AttributesSerialize"></BinaryString>
						<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
						<bool name="DefinesCapabilities">false</bool>
						<string name="Name">TypeGuards</string>
						<int64 name="SourceAssetId">-1</int64>
						<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
					</Properties>
				</Item>
				<Item class="ModuleScript" referent="RBX77D5B4EF1F3F4914896A46DD513B57DC">
					<Properties>
						<Content name="LinkedSource"><null></null></Content>
						<ProtectedString name="Source"><![CDATA[--[[
    File: http-queue/DependencyLoader.lua
    Description: Loads runtime dependencies

    SPDX-License-Identifier: MIT
]]

--[[
    EXTERNAL DEPENDENCIES:
    - evaera/roblox-lua-promise (Built in the roblox-ts runtime)
    - osyrisrblx/t (@rbxts/t)
]]

local dependencies = {}
local TS = _G[script.Parent]

if TS then
    -- Module was loaded via Roblox-TS
    dependencies.Promise = TS.Promise
    dependencies.t = TS.import(script.Parent, TS.getModule(script.Parent, "t").lib.ts).t
else
    -- Load dependencies locally
    dependencies.Promise = require(script.Promise)
    dependencies.t = require(script.t)
end

dependencies.HttpService = game:GetService("HttpService")

return dependencies
]]></ProtectedString>
						<string name="ScriptGuid">{79511612-AC4E-4893-BDD8-E1AC2BCA9E0D}</string>
						<BinaryString name="AttributesSerialize"></BinaryString>
						<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
						<bool name="DefinesCapabilities">false</bool>
						<string name="Name">DependencyLoader</string>
						<int64 name="SourceAssetId">-1</int64>
						<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
					</Properties>
					<Item class="ModuleScript" referent="RBXB60E5F68AEBD4741BB0DF7E9EE92F8CF">
						<Properties>
							<Content name="LinkedSource"><null></null></Content>
							<ProtectedString name="Source"><![CDATA[--[[
	An implementation of Promises similar to Promise/A+.
]]

local ERROR_NON_PROMISE_IN_LIST = "Non-promise value passed into %s at index %s"
local ERROR_NON_LIST = "Please pass a list of promises to %s"
local ERROR_NON_FUNCTION = "Please pass a handler function to %s!"
local MODE_KEY_METATABLE = {__mode = "k"}

--[[
	Creates an enum dictionary with some metamethods to prevent common mistakes.
]]
local function makeEnum(enumName, members)
	local enum = {}

	for _, memberName in ipairs(members) do
		enum[memberName] = memberName
	end

	return setmetatable(enum, {
		__index = function(_, k)
			error(string.format("%s is not in %s!", k, enumName), 2)
		end,
		__newindex = function()
			error(string.format("Creating new members in %s is not allowed!", enumName), 2)
		end,
	})
end

--[[
	An object to represent runtime errors that occur during execution.
	Promises that experience an error like this will be rejected with
	an instance of this object.
]]
local Error do
	Error = {
		Kind = makeEnum("Promise.Error.Kind", {
			"ExecutionError",
			"AlreadyCancelled",
			"NotResolvedInTime",
			"TimedOut",
		}),
	}
	Error.__index = Error

	function Error.new(options, parent)
		options = options or {}
		return setmetatable({
			error = tostring(options.error) or "[This error has no error text.]",
			trace = options.trace,
			context = options.context,
			kind = options.kind,
			parent = parent,
			createdTick = os.clock(),
			createdTrace = debug.traceback(),
		}, Error)
	end

	function Error.is(anything)
		if type(anything) == "table" then
			local metatable = getmetatable(anything)

			if type(metatable) == "table" then
				return rawget(anything, "error") ~= nil and type(rawget(metatable, "extend")) == "function"
			end
		end

		return false
	end

	function Error.isKind(anything, kind)
		assert(kind ~= nil, "Argument #2 to Promise.Error.isKind must not be nil")

		return Error.is(anything) and anything.kind == kind
	end

	function Error:extend(options)
		options = options or {}

		options.kind = options.kind or self.kind

		return Error.new(options, self)
	end

	function Error:getErrorChain()
		local runtimeErrors = { self }

		while runtimeErrors[#runtimeErrors].parent do
			table.insert(runtimeErrors, runtimeErrors[#runtimeErrors].parent)
		end

		return runtimeErrors
	end

	function Error:__tostring()
		local errorStrings = {
			string.format("-- Promise.Error(%s) --", self.kind or "?"),
		}

		for _, runtimeError in ipairs(self:getErrorChain()) do
			table.insert(errorStrings, table.concat({
				runtimeError.trace or runtimeError.error,
				runtimeError.context,
			}, "\n"))
		end

		return table.concat(errorStrings, "\n")
	end
end

--[[
	Packs a number of arguments into a table and returns its length.

	Used to cajole varargs without dropping sparse values.
]]
local function pack(...)
	return select("#", ...), { ... }
end

--[[
	Returns first value (success), and packs all following values.
]]
local function packResult(success, ...)
	return success, select("#", ...), { ... }
end


local function makeErrorHandler(traceback)
	assert(traceback ~= nil)

	return function(err)
		-- If the error object is already a table, forward it directly.
		-- Should we extend the error here and add our own trace?

		if type(err) == "table" then
			return err
		end

		return Error.new({
			error = err,
			kind = Error.Kind.ExecutionError,
			trace = debug.traceback(tostring(err), 2),
			context = "Promise created at:\n\n" .. traceback,
		})
	end
end

--[[
	Calls a Promise executor with error handling.
]]
local function runExecutor(traceback, callback, ...)
	return packResult(xpcall(callback, makeErrorHandler(traceback), ...))
end

--[[
	Creates a function that invokes a callback with correct error handling and
	resolution mechanisms.
]]
local function createAdvancer(traceback, callback, resolve, reject)
	return function(...)
		local ok, resultLength, result = runExecutor(traceback, callback, ...)

		if ok then
			resolve(unpack(result, 1, resultLength))
		else
			reject(result[1])
		end
	end
end

local function isEmpty(t)
	return next(t) == nil
end

local Promise = {
	Error = Error,
	Status = makeEnum("Promise.Status", {"Started", "Resolved", "Rejected", "Cancelled"}),
	_getTime = os.clock,
	_timeEvent = game:GetService("RunService").Heartbeat,
}
Promise.prototype = {}
Promise.__index = Promise.prototype

--[[
	Constructs a new Promise with the given initializing callback.

	This is generally only called when directly wrapping a non-promise API into
	a promise-based version.

	The callback will receive 'resolve' and 'reject' methods, used to start
	invoking the promise chain.

	Second parameter, parent, is used internally for tracking the "parent" in a
	promise chain. External code shouldn't need to worry about this.
]]
function Promise._new(traceback, callback, parent)
	if parent ~= nil and not Promise.is(parent) then
		error("Argument #2 to Promise.new must be a promise or nil", 2)
	end

	local self = {
		-- Used to locate where a promise was created
		_source = traceback,

		_status = Promise.Status.Started,

		-- A table containing a list of all results, whether success or failure.
		-- Only valid if _status is set to something besides Started
		_values = nil,

		-- Lua doesn't like sparse arrays very much, so we explicitly store the
		-- length of _values to handle middle nils.
		_valuesLength = -1,

		-- Tracks if this Promise has no error observers..
		_unhandledRejection = true,

		-- Queues representing functions we should invoke when we update!
		_queuedResolve = {},
		_queuedReject = {},
		_queuedFinally = {},

		-- The function to run when/if this promise is cancelled.
		_cancellationHook = nil,

		-- The "parent" of this promise in a promise chain. Required for
		-- cancellation propagation upstream.
		_parent = parent,

		-- Consumers are Promises that have chained onto this one.
		-- We track them for cancellation propagation downstream.
		_consumers = setmetatable({}, MODE_KEY_METATABLE),
	}

	if parent and parent._status == Promise.Status.Started then
		parent._consumers[self] = true
	end

	setmetatable(self, Promise)

	local function resolve(...)
		self:_resolve(...)
	end

	local function reject(...)
		self:_reject(...)
	end

	local function onCancel(cancellationHook)
		if cancellationHook then
			if self._status == Promise.Status.Cancelled then
				cancellationHook()
			else
				self._cancellationHook = cancellationHook
			end
		end

		return self._status == Promise.Status.Cancelled
	end

	coroutine.wrap(function()
		local ok, _, result = runExecutor(
			self._source,
			callback,
			resolve,
			reject,
			onCancel
		)

		if not ok then
			reject(result[1])
		end
	end)()

	return self
end

function Promise.new(executor)
	return Promise._new(debug.traceback(nil, 2), executor)
end

function Promise:__tostring()
	return string.format("Promise(%s)", self:getStatus())
end

--[[
	Promise.new, except pcall on a new thread is automatic.
]]
function Promise.defer(callback)
	local traceback = debug.traceback(nil, 2)
	local promise
	promise = Promise._new(traceback, function(resolve, reject, onCancel)
		local connection
		connection = Promise._timeEvent:Connect(function()
			connection:Disconnect()
			local ok, _, result = runExecutor(traceback, callback, resolve, reject, onCancel)

			if not ok then
				reject(result[1])
			end
		end)
	end)

	return promise
end

-- Backwards compatibility
Promise.async = Promise.defer

--[[
	Create a promise that represents the immediately resolved value.
]]
function Promise.resolve(...)
	local length, values = pack(...)
	return Promise._new(debug.traceback(nil, 2), function(resolve)
		resolve(unpack(values, 1, length))
	end)
end

--[[
	Create a promise that represents the immediately rejected value.
]]
function Promise.reject(...)
	local length, values = pack(...)
	return Promise._new(debug.traceback(nil, 2), function(_, reject)
		reject(unpack(values, 1, length))
	end)
end

--[[
	Runs a non-promise-returning function as a Promise with the
  given arguments.
]]
function Promise._try(traceback, callback, ...)
	local valuesLength, values = pack(...)

	return Promise._new(traceback, function(resolve)
		resolve(callback(unpack(values, 1, valuesLength)))
	end)
end

--[[
	Begins a Promise chain, turning synchronous errors into rejections.
]]
function Promise.try(...)
	return Promise._try(debug.traceback(nil, 2), ...)
end

--[[
	Returns a new promise that:
		* is resolved when all input promises resolve
		* is rejected if ANY input promises reject
]]
function Promise._all(traceback, promises, amount)
	if type(promises) ~= "table" then
		error(string.format(ERROR_NON_LIST, "Promise.all"), 3)
	end

	-- We need to check that each value is a promise here so that we can produce
	-- a proper error rather than a rejected promise with our error.
	for i, promise in pairs(promises) do
		if not Promise.is(promise) then
			error(string.format(ERROR_NON_PROMISE_IN_LIST, "Promise.all", tostring(i)), 3)
		end
	end

	-- If there are no values then return an already resolved promise.
	if #promises == 0 or amount == 0 then
		return Promise.resolve({})
	end

	return Promise._new(traceback, function(resolve, reject, onCancel)
		-- An array to contain our resolved values from the given promises.
		local resolvedValues = {}
		local newPromises = {}

		-- Keep a count of resolved promises because just checking the resolved
		-- values length wouldn't account for promises that resolve with nil.
		local resolvedCount = 0
		local rejectedCount = 0
		local done = false

		local function cancel()
			for _, promise in ipairs(newPromises) do
				promise:cancel()
			end
		end

		-- Called when a single value is resolved and resolves if all are done.
		local function resolveOne(i, ...)
			if done then
				return
			end

			resolvedCount = resolvedCount + 1

			if amount == nil then
				resolvedValues[i] = ...
			else
				resolvedValues[resolvedCount] = ...
			end

			if resolvedCount >= (amount or #promises) then
				done = true
				resolve(resolvedValues)
				cancel()
			end
		end

		onCancel(cancel)

		-- We can assume the values inside `promises` are all promises since we
		-- checked above.
		for i, promise in ipairs(promises) do
			newPromises[i] = promise:andThen(
				function(...)
					resolveOne(i, ...)
				end,
				function(...)
					rejectedCount = rejectedCount + 1

					if amount == nil or #promises - rejectedCount < amount then
						cancel()
						done = true

						reject(...)
					end
				end
			)
		end

		if done then
			cancel()
		end
	end)
end

function Promise.all(promises)
	return Promise._all(debug.traceback(nil, 2), promises)
end

function Promise.fold(list, callback, initialValue)
	assert(type(list) == "table", "Bad argument #1 to Promise.fold: must be a table")
	assert(type(callback) == "function", "Bad argument #2 to Promise.fold: must be a function")

	local accumulator = Promise.resolve(initialValue)
	return Promise.each(list, function(resolvedElement, i)
		accumulator = accumulator:andThen(function(previousValueResolved)
			return callback(previousValueResolved, resolvedElement, i)
		end)
	end):andThenReturn(accumulator)
end

function Promise.some(promises, amount)
	assert(type(amount) == "number", "Bad argument #2 to Promise.some: must be a number")

	return Promise._all(debug.traceback(nil, 2), promises, amount)
end

function Promise.any(promises)
	return Promise._all(debug.traceback(nil, 2), promises, 1):andThen(function(values)
		return values[1]
	end)
end

function Promise.allSettled(promises)
	if type(promises) ~= "table" then
		error(string.format(ERROR_NON_LIST, "Promise.allSettled"), 2)
	end

	-- We need to check that each value is a promise here so that we can produce
	-- a proper error rather than a rejected promise with our error.
	for i, promise in pairs(promises) do
		if not Promise.is(promise) then
			error(string.format(ERROR_NON_PROMISE_IN_LIST, "Promise.allSettled", tostring(i)), 2)
		end
	end

	-- If there are no values then return an already resolved promise.
	if #promises == 0 then
		return Promise.resolve({})
	end

	return Promise._new(debug.traceback(nil, 2), function(resolve, _, onCancel)
		-- An array to contain our resolved values from the given promises.
		local fates = {}
		local newPromises = {}

		-- Keep a count of resolved promises because just checking the resolved
		-- values length wouldn't account for promises that resolve with nil.
		local finishedCount = 0

		-- Called when a single value is resolved and resolves if all are done.
		local function resolveOne(i, ...)
			finishedCount = finishedCount + 1

			fates[i] = ...

			if finishedCount >= #promises then
				resolve(fates)
			end
		end

		onCancel(function()
			for _, promise in ipairs(newPromises) do
				promise:cancel()
			end
		end)

		-- We can assume the values inside `promises` are all promises since we
		-- checked above.
		for i, promise in ipairs(promises) do
			newPromises[i] = promise:finally(
				function(...)
					resolveOne(i, ...)
				end
			)
		end
	end)
end

--[[
	Races a set of Promises and returns the first one that resolves,
	cancelling the others.
]]
function Promise.race(promises)
	assert(type(promises) == "table", string.format(ERROR_NON_LIST, "Promise.race"))

	for i, promise in pairs(promises) do
		assert(Promise.is(promise), string.format(ERROR_NON_PROMISE_IN_LIST, "Promise.race", tostring(i)))
	end

	return Promise._new(debug.traceback(nil, 2), function(resolve, reject, onCancel)
		local newPromises = {}
		local finished = false

		local function cancel()
			for _, promise in ipairs(newPromises) do
				promise:cancel()
			end
		end

		local function finalize(callback)
			return function (...)
				cancel()
				finished = true
				return callback(...)
			end
		end

		if onCancel(finalize(reject)) then
			return
		end

		for i, promise in ipairs(promises) do
			newPromises[i] = promise:andThen(finalize(resolve), finalize(reject))
		end

		if finished then
			cancel()
		end
	end)
end

--[[
	Iterates serially over the given an array of values, calling the predicate callback on each before continuing.
	If the predicate returns a Promise, we wait for that Promise to resolve before continuing to the next item
	in the array. If the Promise the predicate returns rejects, the Promise from Promise.each is also rejected with
	the same value.

	Returns a Promise containing an array of the return values from the predicate for each item in the original list.
]]
function Promise.each(list, predicate)
	assert(type(list) == "table", string.format(ERROR_NON_LIST, "Promise.each"))
	assert(type(predicate) == "function", string.format(ERROR_NON_FUNCTION, "Promise.each"))

	return Promise._new(debug.traceback(nil, 2), function(resolve, reject, onCancel)
		local results = {}
		local promisesToCancel = {}

		local cancelled = false

		local function cancel()
			for _, promiseToCancel in ipairs(promisesToCancel) do
				promiseToCancel:cancel()
			end
		end

		onCancel(function()
			cancelled = true

			cancel()
		end)

		-- We need to preprocess the list of values and look for Promises.
		-- If we find some, we must register our andThen calls now, so that those Promises have a consumer
		-- from us registered. If we don't do this, those Promises might get cancelled by something else
		-- before we get to them in the series because it's not possible to tell that we plan to use it
		-- unless we indicate it here.

		local preprocessedList = {}

		for index, value in ipairs(list) do
			if Promise.is(value) then
				if value:getStatus() == Promise.Status.Cancelled then
					cancel()
					return reject(Error.new({
						error = "Promise is cancelled",
						kind = Error.Kind.AlreadyCancelled,
						context = string.format(
							"The Promise that was part of the array at index %d passed into Promise.each was already cancelled when Promise.each began.\n\nThat Promise was created at:\n\n%s",
							index,
							value._source
						),
					}))
				elseif value:getStatus() == Promise.Status.Rejected then
					cancel()
					return reject(select(2, value:await()))
				end

				-- Chain a new Promise from this one so we only cancel ours
				local ourPromise = value:andThen(function(...)
					return ...
				end)

				table.insert(promisesToCancel, ourPromise)
				preprocessedList[index] = ourPromise
			else
				preprocessedList[index] = value
			end
		end

		for index, value in ipairs(preprocessedList) do
			if Promise.is(value) then
				local success
				success, value = value:await()

				if not success then
					cancel()
					return reject(value)
				end
			end

			if cancelled then
				return
			end

			local predicatePromise = Promise.resolve(predicate(value, index))

			table.insert(promisesToCancel, predicatePromise)

			local success, result = predicatePromise:await()

			if not success then
				cancel()
				return reject(result)
			end

			results[index] = result
		end

		resolve(results)
	end)
end

--[[
	Is the given object a Promise instance?
]]
function Promise.is(object)
	if type(object) ~= "table" then
		return false
	end

	local objectMetatable = getmetatable(object)

	if objectMetatable == Promise then
		-- The Promise came from this library.
		return true
	elseif objectMetatable == nil then
		-- No metatable, but we should still chain onto tables with andThen methods
		return type(object.andThen) == "function"
	elseif
		type(objectMetatable) == "table"
		and type(rawget(objectMetatable, "__index")) == "table"
		and type(rawget(rawget(objectMetatable, "__index"), "andThen")) == "function"
	then
		-- Maybe this came from a different or older Promise library.
		return true
	end

	return false
end

--[[
	Converts a yielding function into a Promise-returning one.
]]
function Promise.promisify(callback)
	return function(...)
		return Promise._try(debug.traceback(nil, 2), callback, ...)
	end
end

--[[
	Creates a Promise that resolves after given number of seconds.
]]
do
	-- uses a sorted doubly linked list (queue) to achieve O(1) remove operations and O(n) for insert

	-- the initial node in the linked list
	local first
	local connection

	function Promise.delay(seconds)
		assert(type(seconds) == "number", "Bad argument #1 to Promise.delay, must be a number.")
		-- If seconds is -INF, INF, NaN, or less than 1 / 60, assume seconds is 1 / 60.
		-- This mirrors the behavior of wait()
		if not (seconds >= 1 / 60) or seconds == math.huge then
			seconds = 1 / 60
		end

		return Promise._new(debug.traceback(nil, 2), function(resolve, _, onCancel)
			local startTime = Promise._getTime()
			local endTime = startTime + seconds

			local node = {
				resolve = resolve,
				startTime = startTime,
				endTime = endTime,
			}

			if connection == nil then -- first is nil when connection is nil
				first = node
				connection = Promise._timeEvent:Connect(function()
					local threadStart = Promise._getTime()

					while first ~= nil and first.endTime < threadStart do
						local current = first
						first = current.next

						if first == nil then
							connection:Disconnect()
							connection = nil
						else
							first.previous = nil
						end

						current.resolve(Promise._getTime() - current.startTime)
					end
				end)
			else -- first is non-nil
				if first.endTime < endTime then -- if `node` should be placed after `first`
					-- we will insert `node` between `current` and `next`
					-- (i.e. after `current` if `next` is nil)
					local current = first
					local next = current.next

					while next ~= nil and next.endTime < endTime do
						current = next
						next = current.next
					end

					-- `current` must be non-nil, but `next` could be `nil` (i.e. last item in list)
					current.next = node
					node.previous = current

					if next ~= nil then
						node.next = next
						next.previous = node
					end
				else
					-- set `node` to `first`
					node.next = first
					first.previous = node
					first = node
				end
			end

			onCancel(function()
				-- remove node from queue
				local next = node.next

				if first == node then
					if next == nil then -- if `node` is the first and last
						connection:Disconnect()
						connection = nil
					else -- if `node` is `first` and not the last
						next.previous = nil
					end
					first = next
				else
					local previous = node.previous
					-- since `node` is not `first`, then we know `previous` is non-nil
					previous.next = next

					if next ~= nil then
						next.previous = previous
					end
				end
			end)
		end)
	end
end

--[[
	Rejects the promise after `seconds` seconds.
]]
function Promise.prototype:timeout(seconds, rejectionValue)
	local traceback = debug.traceback(nil, 2)

	return Promise.race({
		Promise.delay(seconds):andThen(function()
			return Promise.reject(rejectionValue == nil and Error.new({
				kind = Error.Kind.TimedOut,
				error = "Timed out",
				context = string.format(
					"Timeout of %d seconds exceeded.\n:timeout() called at:\n\n%s",
					seconds,
					traceback
				),
			}) or rejectionValue)
		end),
		self,
	})
end

function Promise.prototype:getStatus()
	return self._status
end

--[[
	Creates a new promise that receives the result of this promise.

	The given callbacks are invoked depending on that result.
]]
function Promise.prototype:_andThen(traceback, successHandler, failureHandler)
	self._unhandledRejection = false

	-- Create a new promise to follow this part of the chain
	return Promise._new(traceback, function(resolve, reject)
		-- Our default callbacks just pass values onto the next promise.
		-- This lets success and failure cascade correctly!

		local successCallback = resolve
		if successHandler then
			successCallback = createAdvancer(
				traceback,
				successHandler,
				resolve,
				reject
			)
		end

		local failureCallback = reject
		if failureHandler then
			failureCallback = createAdvancer(
				traceback,
				failureHandler,
				resolve,
				reject
			)
		end

		if self._status == Promise.Status.Started then
			-- If we haven't resolved yet, put ourselves into the queue
			table.insert(self._queuedResolve, successCallback)
			table.insert(self._queuedReject, failureCallback)
		elseif self._status == Promise.Status.Resolved then
			-- This promise has already resolved! Trigger success immediately.
			successCallback(unpack(self._values, 1, self._valuesLength))
		elseif self._status == Promise.Status.Rejected then
			-- This promise died a terrible death! Trigger failure immediately.
			failureCallback(unpack(self._values, 1, self._valuesLength))
		elseif self._status == Promise.Status.Cancelled then
			-- We don't want to call the success handler or the failure handler,
			-- we just reject this promise outright.
			reject(Error.new({
				error = "Promise is cancelled",
				kind = Error.Kind.AlreadyCancelled,
				context = "Promise created at\n\n" .. traceback,
			}))
		end
	end, self)
end

function Promise.prototype:andThen(successHandler, failureHandler)
	assert(
		successHandler == nil or type(successHandler) == "function",
		string.format(ERROR_NON_FUNCTION, "Promise:andThen")
	)
	assert(
		failureHandler == nil or type(failureHandler) == "function",
		string.format(ERROR_NON_FUNCTION, "Promise:andThen")
	)

	return self:_andThen(debug.traceback(nil, 2), successHandler, failureHandler)
end

--[[
	Used to catch any errors that may have occurred in the promise.
]]
function Promise.prototype:catch(failureCallback)
	assert(
		failureCallback == nil or type(failureCallback) == "function",
		string.format(ERROR_NON_FUNCTION, "Promise:catch")
	)
	return self:_andThen(debug.traceback(nil, 2), nil, failureCallback)
end

--[[
	Like andThen, but the value passed into the handler is also the
	value returned from the handler.
]]
function Promise.prototype:tap(tapCallback)
	assert(type(tapCallback) == "function", string.format(ERROR_NON_FUNCTION, "Promise:tap"))
	return self:_andThen(debug.traceback(nil, 2), function(...)
		local callbackReturn = tapCallback(...)

		if Promise.is(callbackReturn) then
			local length, values = pack(...)
			return callbackReturn:andThen(function()
				return unpack(values, 1, length)
			end)
		end

		return ...
	end)
end

--[[
	Calls a callback on `andThen` with specific arguments.
]]
function Promise.prototype:andThenCall(callback, ...)
	assert(type(callback) == "function", string.format(ERROR_NON_FUNCTION, "Promise:andThenCall"))
	local length, values = pack(...)
	return self:_andThen(debug.traceback(nil, 2), function()
		return callback(unpack(values, 1, length))
	end)
end

--[[
	Shorthand for an andThen handler that returns the given value.
]]
function Promise.prototype:andThenReturn(...)
	local length, values = pack(...)
	return self:_andThen(debug.traceback(nil, 2), function()
		return unpack(values, 1, length)
	end)
end

--[[
	Cancels the promise, disallowing it from rejecting or resolving, and calls
	the cancellation hook if provided.
]]
function Promise.prototype:cancel()
	if self._status ~= Promise.Status.Started then
		return
	end

	self._status = Promise.Status.Cancelled

	if self._cancellationHook then
		self._cancellationHook()
	end

	if self._parent then
		self._parent:_consumerCancelled(self)
	end

	for child in pairs(self._consumers) do
		child:cancel()
	end

	self:_finalize()
end

--[[
	Used to decrease the number of consumers by 1, and if there are no more,
	cancel this promise.
]]
function Promise.prototype:_consumerCancelled(consumer)
	if self._status ~= Promise.Status.Started then
		return
	end

	self._consumers[consumer] = nil

	if next(self._consumers) == nil then
		self:cancel()
	end
end

--[[
	Used to set a handler for when the promise resolves, rejects, or is
	cancelled. Returns a new promise chained from this promise.
]]
function Promise.prototype:_finally(traceback, finallyHandler, onlyOk)
	if not onlyOk then
		self._unhandledRejection = false
	end

	-- Return a promise chained off of this promise
	return Promise._new(traceback, function(resolve, reject)
		local finallyCallback = resolve
		if finallyHandler then
			finallyCallback = createAdvancer(
				traceback,
				finallyHandler,
				resolve,
				reject
			)
		end

		if onlyOk then
			local callback = finallyCallback
			finallyCallback = function(...)
				if self._status == Promise.Status.Rejected then
					return resolve(self)
				end

				return callback(...)
			end
		end

		if self._status == Promise.Status.Started then
			-- The promise is not settled, so queue this.
			table.insert(self._queuedFinally, finallyCallback)
		else
			-- The promise already settled or was cancelled, run the callback now.
			finallyCallback(self._status)
		end
	end, self)
end

function Promise.prototype:finally(finallyHandler)
	assert(
		finallyHandler == nil or type(finallyHandler) == "function",
		string.format(ERROR_NON_FUNCTION, "Promise:finally")
	)
	return self:_finally(debug.traceback(nil, 2), finallyHandler)
end

--[[
	Calls a callback on `finally` with specific arguments.
]]
function Promise.prototype:finallyCall(callback, ...)
	assert(type(callback) == "function", string.format(ERROR_NON_FUNCTION, "Promise:finallyCall"))
	local length, values = pack(...)
	return self:_finally(debug.traceback(nil, 2), function()
		return callback(unpack(values, 1, length))
	end)
end

--[[
	Shorthand for a finally handler that returns the given value.
]]
function Promise.prototype:finallyReturn(...)
	local length, values = pack(...)
	return self:_finally(debug.traceback(nil, 2), function()
		return unpack(values, 1, length)
	end)
end

--[[
	Similar to finally, except rejections are propagated through it.
]]
function Promise.prototype:done(finallyHandler)
	assert(
		finallyHandler == nil or type(finallyHandler) == "function",
		string.format(ERROR_NON_FUNCTION, "Promise:done")
	)
	return self:_finally(debug.traceback(nil, 2), finallyHandler, true)
end

--[[
	Calls a callback on `done` with specific arguments.
]]
function Promise.prototype:doneCall(callback, ...)
	assert(type(callback) == "function", string.format(ERROR_NON_FUNCTION, "Promise:doneCall"))
	local length, values = pack(...)
	return self:_finally(debug.traceback(nil, 2), function()
		return callback(unpack(values, 1, length))
	end, true)
end

--[[
	Shorthand for a done handler that returns the given value.
]]
function Promise.prototype:doneReturn(...)
	local length, values = pack(...)
	return self:_finally(debug.traceback(nil, 2), function()
		return unpack(values, 1, length)
	end, true)
end

--[[
	Yield until the promise is completed.

	This matches the execution model of normal Roblox functions.
]]
function Promise.prototype:awaitStatus()
	self._unhandledRejection = false

	if self._status == Promise.Status.Started then
		local bindable = Instance.new("BindableEvent")

		self:finally(function()
			bindable:Fire()
		end)

		bindable.Event:Wait()
		bindable:Destroy()
	end

	if self._status == Promise.Status.Resolved then
		return self._status, unpack(self._values, 1, self._valuesLength)
	elseif self._status == Promise.Status.Rejected then
		return self._status, unpack(self._values, 1, self._valuesLength)
	end

	return self._status
end

local function awaitHelper(status, ...)
	return status == Promise.Status.Resolved, ...
end

--[[
	Calls awaitStatus internally, returns (isResolved, values...)
]]
function Promise.prototype:await()
	return awaitHelper(self:awaitStatus())
end

local function expectHelper(status, ...)
	if status ~= Promise.Status.Resolved then
		error((...) == nil and "Expected Promise rejected with no value." or (...), 3)
	end

	return ...
end

--[[
	Calls await and only returns if the Promise resolves.
	Throws if the Promise rejects or gets cancelled.
]]
function Promise.prototype:expect()
	return expectHelper(self:awaitStatus())
end

-- Backwards compatibility
Promise.prototype.awaitValue = Promise.prototype.expect

--[[
	Intended for use in tests.

	Similar to await(), but instead of yielding if the promise is unresolved,
	_unwrap will throw. This indicates an assumption that a promise has
	resolved.
]]
function Promise.prototype:_unwrap()
	if self._status == Promise.Status.Started then
		error("Promise has not resolved or rejected.", 2)
	end

	local success = self._status == Promise.Status.Resolved

	return success, unpack(self._values, 1, self._valuesLength)
end

function Promise.prototype:_resolve(...)
	if self._status ~= Promise.Status.Started then
		if Promise.is((...)) then
			(...):_consumerCancelled(self)
		end
		return
	end

	-- If the resolved value was a Promise, we chain onto it!
	if Promise.is((...)) then
		-- Without this warning, arguments sometimes mysteriously disappear
		if select("#", ...) > 1 then
			local message = string.format(
				"When returning a Promise from andThen, extra arguments are " ..
				"discarded! See:\n\n%s",
				self._source
			)
			warn(message)
		end

		local chainedPromise = ...

		local promise = chainedPromise:andThen(
			function(...)
				self:_resolve(...)
			end,
			function(...)
				local maybeRuntimeError = chainedPromise._values[1]

				-- Backwards compatibility < v2
				if chainedPromise._error then
					maybeRuntimeError = Error.new({
						error = chainedPromise._error,
						kind = Error.Kind.ExecutionError,
						context = "[No stack trace available as this Promise originated from an older version of the Promise library (< v2)]",
					})
				end

				if Error.isKind(maybeRuntimeError, Error.Kind.ExecutionError) then
					return self:_reject(maybeRuntimeError:extend({
						error = "This Promise was chained to a Promise that errored.",
						trace = "",
						context = string.format(
							"The Promise at:\n\n%s\n...Rejected because it was chained to the following Promise, which encountered an error:\n",
							self._source
						),
					}))
				end

				self:_reject(...)
			end
		)

		if promise._status == Promise.Status.Cancelled then
			self:cancel()
		elseif promise._status == Promise.Status.Started then
			-- Adopt ourselves into promise for cancellation propagation.
			self._parent = promise
			promise._consumers[self] = true
		end

		return
	end

	self._status = Promise.Status.Resolved
	self._valuesLength, self._values = pack(...)

	-- We assume that these callbacks will not throw errors.
	for _, callback in ipairs(self._queuedResolve) do
		coroutine.wrap(callback)(...)
	end

	self:_finalize()
end

function Promise.prototype:_reject(...)
	if self._status ~= Promise.Status.Started then
		return
	end

	self._status = Promise.Status.Rejected
	self._valuesLength, self._values = pack(...)

	-- If there are any rejection handlers, call those!
	if not isEmpty(self._queuedReject) then
		-- We assume that these callbacks will not throw errors.
		for _, callback in ipairs(self._queuedReject) do
			coroutine.wrap(callback)(...)
		end
	else
		-- At this point, no one was able to observe the error.
		-- An error handler might still be attached if the error occurred
		-- synchronously. We'll wait one tick, and if there are still no
		-- observers, then we should put a message in the console.

		local err = tostring((...))

		coroutine.wrap(function()
			Promise._timeEvent:Wait()

			-- Someone observed the error, hooray!
			if not self._unhandledRejection then
				return
			end

			-- Build a reasonable message
			local message = string.format(
				"Unhandled Promise rejection:\n\n%s\n\n%s",
				err,
				self._source
			)

			if Promise.TEST then
				-- Don't spam output when we're running tests.
				return
			end

			warn(message)
		end)()
	end

	self:_finalize()
end

--[[
	Calls any :finally handlers. We need this to be a separate method and
	queue because we must call all of the finally callbacks upon a success,
	failure, *and* cancellation.
]]
function Promise.prototype:_finalize()
	for _, callback in ipairs(self._queuedFinally) do
		-- Purposefully not passing values to callbacks here, as it could be the
		-- resolved values, or rejected errors. If the developer needs the values,
		-- they should use :andThen or :catch explicitly.
		coroutine.wrap(callback)(self._status)
	end

	self._queuedFinally = nil
	self._queuedReject = nil
	self._queuedResolve = nil

	-- Clear references to other Promises to allow gc
	if not Promise.TEST then
		self._parent = nil
		self._consumers = nil
	end
end

--[[
	Chains a Promise from this one that is resolved if this Promise is
	resolved, and rejected if it is not resolved.
]]
function Promise.prototype:now(rejectionValue)
	local traceback = debug.traceback(nil, 2)
	if self:getStatus() == Promise.Status.Resolved then
		return self:_andThen(traceback, function(...)
			return ...
		end)
	else
		return Promise.reject(rejectionValue == nil and Error.new({
			kind = Error.Kind.NotResolvedInTime,
			error = "This Promise was not resolved in time for :now()",
			context = ":now() was called at:\n\n" .. traceback,
		}) or rejectionValue)
	end
end

--[[
	Retries a Promise-returning callback N times until it succeeds.
]]
function Promise.retry(callback, times, ...)
	assert(type(callback) == "function", "Parameter #1 to Promise.retry must be a function")
	assert(type(times) == "number", "Parameter #2 to Promise.retry must be a number")

	local args, length = {...}, select("#", ...)

	return Promise.resolve(callback(...)):catch(function(...)
		if times > 0 then
			return Promise.retry(callback, times - 1, unpack(args, 1, length))
		else
			return Promise.reject(...)
		end
	end)
end

--[[
	Converts an event into a Promise with an optional predicate
]]
function Promise.fromEvent(event, predicate)
	predicate = predicate or function()
		return true
	end

	return Promise._new(debug.traceback(nil, 2), function(resolve, reject, onCancel)
		local connection
		local shouldDisconnect = false

		local function disconnect()
			connection:Disconnect()
			connection = nil
		end

		-- We use shouldDisconnect because if the callback given to Connect is called before
		-- Connect returns, connection will still be nil. This happens with events that queue up
		-- events when there's nothing connected, such as RemoteEvents

		connection = event:Connect(function(...)
			local callbackValue = predicate(...)

			if callbackValue == true then
				resolve(...)

				if connection then
					disconnect()
				else
					shouldDisconnect = true
				end
			elseif type(callbackValue) ~= "boolean" then
				error("Promise.fromEvent predicate should always return a boolean")
			end
		end)

		if shouldDisconnect and connection then
			return disconnect()
		end

		onCancel(function()
			disconnect()
		end)
	end)
end

return Promise
]]></ProtectedString>
							<string name="ScriptGuid">{B5558958-ED24-4D82-A4C2-8823C8DEDFA4}</string>
							<BinaryString name="AttributesSerialize"></BinaryString>
							<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
							<bool name="DefinesCapabilities">false</bool>
							<string name="Name">Promise</string>
							<int64 name="SourceAssetId">-1</int64>
							<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
						</Properties>
					</Item>
					<Item class="ModuleScript" referent="RBX07398AD830EE4E66908038085AB9BE55">
						<Properties>
							<Content name="LinkedSource"><null></null></Content>
							<ProtectedString name="Source"><![CDATA[-- t: a runtime typechecker for Roblox

-- regular lua compatibility
local typeof = typeof or type

local function primitive(typeName)
	return function(value)
		local valueType = typeof(value)
		if valueType == typeName then
			return true
		else
			return false, string.format("%s expected, got %s", typeName, valueType)
		end
	end
end

local t = {}

--[[**
	matches any type except nil

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.any(value)
	if value ~= nil then
		return true
	else
		return false, "any expected, got nil"
	end
end

--Lua primitives

--[[**
	ensures Lua primitive boolean type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.boolean = primitive("boolean")

--[[**
	ensures Lua primitive thread type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.thread = primitive("thread")

--[[**
	ensures Lua primitive callback type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.callback = primitive("function")
t["function"] = t.callback

--[[**
	ensures Lua primitive none type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.none = primitive("nil")
t["nil"] = t.none

--[[**
	ensures Lua primitive string type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.string = primitive("string")

--[[**
	ensures Lua primitive table type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.table = primitive("table")

--[[**
	ensures Lua primitive userdata type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.userdata = primitive("userdata")

--[[**
	ensures value is a number and non-NaN

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.number(value)
	local valueType = typeof(value)
	if valueType == "number" then
		if value == value then
			return true
		else
			return false, "unexpected NaN value"
		end
	else
		return false, string.format("number expected, got %s", valueType)
	end
end

--[[**
	ensures value is NaN

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.nan(value)
	if value ~= value then
		return true
	else
		return false, "unexpected non-NaN value"
	end
end

-- roblox types

--[[**
	ensures Roblox Axes type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Axes = primitive("Axes")

--[[**
	ensures Roblox BrickColor type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.BrickColor = primitive("BrickColor")

--[[**
	ensures Roblox CFrame type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.CFrame = primitive("CFrame")

--[[**
	ensures Roblox Color3 type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Color3 = primitive("Color3")

--[[**
	ensures Roblox ColorSequence type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.ColorSequence = primitive("ColorSequence")

--[[**
	ensures Roblox ColorSequenceKeypoint type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.ColorSequenceKeypoint = primitive("ColorSequenceKeypoint")

--[[**
	ensures Roblox DockWidgetPluginGuiInfo type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.DockWidgetPluginGuiInfo = primitive("DockWidgetPluginGuiInfo")

--[[**
	ensures Roblox Faces type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Faces = primitive("Faces")

--[[**
	ensures Roblox Instance type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Instance = primitive("Instance")

--[[**
	ensures Roblox NumberRange type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.NumberRange = primitive("NumberRange")

--[[**
	ensures Roblox NumberSequence type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.NumberSequence = primitive("NumberSequence")

--[[**
	ensures Roblox NumberSequenceKeypoint type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.NumberSequenceKeypoint = primitive("NumberSequenceKeypoint")

--[[**
	ensures Roblox PathWaypoint type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.PathWaypoint = primitive("PathWaypoint")

--[[**
	ensures Roblox PhysicalProperties type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.PhysicalProperties = primitive("PhysicalProperties")

--[[**
	ensures Roblox Random type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Random = primitive("Random")

--[[**
	ensures Roblox Ray type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Ray = primitive("Ray")

--[[**
	ensures Roblox Rect type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Rect = primitive("Rect")

--[[**
	ensures Roblox Region3 type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Region3 = primitive("Region3")

--[[**
	ensures Roblox Region3int16 type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Region3int16 = primitive("Region3int16")

--[[**
	ensures Roblox TweenInfo type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.TweenInfo = primitive("TweenInfo")

--[[**
	ensures Roblox UDim type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.UDim = primitive("UDim")

--[[**
	ensures Roblox UDim2 type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.UDim2 = primitive("UDim2")

--[[**
	ensures Roblox Vector2 type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Vector2 = primitive("Vector2")

--[[**
	ensures Roblox Vector3 type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Vector3 = primitive("Vector3")

--[[**
	ensures Roblox Vector3int16 type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Vector3int16 = primitive("Vector3int16")

-- roblox enum types

--[[**
	ensures Roblox Enum type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.Enum = primitive("Enum")

--[[**
	ensures Roblox EnumItem type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.EnumItem = primitive("EnumItem")

--[[**
	ensures Roblox RBXScriptSignal type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.RBXScriptSignal = primitive("RBXScriptSignal")

--[[**
	ensures Roblox RBXScriptConnection type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.RBXScriptConnection = primitive("RBXScriptConnection")

--[[**
	ensures value is a given literal value

	@param literal The literal to use

	@returns A function that will return true iff the condition is passed
**--]]
function t.literal(...)
	local size = select("#", ...)
	if size == 1 then
		local literal = ...
		return function(value)
			if value ~= literal then
				return false, string.format("expected %s, got %s", tostring(literal), tostring(value))
			end

			return true
		end
	else
		local literals = {}
		for i = 1, size do
			local value = select(i, ...)
			literals[i] = t.literal(value)
		end

		return t.union(table.unpack(literals, 1, size))
	end
end

--[[**
	DEPRECATED
	Please use t.literal
**--]]
t.exactly = t.literal

--[[**
	Returns a t.union of each key in the table as a t.literal

	@param keyTable The table to get keys from

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.keyOf(keyTable)
	local keys = {}
	local length = 0
	for key in pairs(keyTable) do
		length = length + 1
		keys[length] = key
	end

	return t.literal(table.unpack(keys, 1, length))
end

--[[**
	Returns a t.union of each value in the table as a t.literal

	@param valueTable The table to get values from

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.valueOf(valueTable)
	local values = {}
	local length = 0
	for _, value in pairs(valueTable) do
		length = length + 1
		values[length] = value
	end

	return t.literal(table.unpack(values, 1, length))
end

--[[**
	ensures value is an integer

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.integer(value)
	local success, errMsg = t.number(value)
	if not success then
		return false, errMsg or ""
	end

	if value % 1 == 0 then
		return true
	else
		return false, string.format("integer expected, got %s", value)
	end
end

--[[**
	ensures value is a number where min <= value

	@param min The minimum to use

	@returns A function that will return true iff the condition is passed
**--]]
function t.numberMin(min)
	return function(value)
		local success, errMsg = t.number(value)
		if not success then
			return false, errMsg or ""
		end

		if value >= min then
			return true
		else
			return false, string.format("number >= %s expected, got %s", min, value)
		end
	end
end

--[[**
	ensures value is a number where value <= max

	@param max The maximum to use

	@returns A function that will return true iff the condition is passed
**--]]
function t.numberMax(max)
	return function(value)
		local success, errMsg = t.number(value)
		if not success then
			return false, errMsg
		end

		if value <= max then
			return true
		else
			return false, string.format("number <= %s expected, got %s", max, value)
		end
	end
end

--[[**
	ensures value is a number where min < value

	@param min The minimum to use

	@returns A function that will return true iff the condition is passed
**--]]
function t.numberMinExclusive(min)
	return function(value)
		local success, errMsg = t.number(value)
		if not success then
			return false, errMsg or ""
		end

		if min < value then
			return true
		else
			return false, string.format("number > %s expected, got %s", min, value)
		end
	end
end

--[[**
	ensures value is a number where value < max

	@param max The maximum to use

	@returns A function that will return true iff the condition is passed
**--]]
function t.numberMaxExclusive(max)
	return function(value)
		local success, errMsg = t.number(value)
		if not success then
			return false, errMsg or ""
		end

		if value < max then
			return true
		else
			return false, string.format("number < %s expected, got %s", max, value)
		end
	end
end

--[[**
	ensures value is a number where value > 0

	@returns A function that will return true iff the condition is passed
**--]]
t.numberPositive = t.numberMinExclusive(0)

--[[**
	ensures value is a number where value < 0

	@returns A function that will return true iff the condition is passed
**--]]
t.numberNegative = t.numberMaxExclusive(0)

--[[**
	ensures value is a number where min <= value <= max

	@param min The minimum to use
	@param max The maximum to use

	@returns A function that will return true iff the condition is passed
**--]]
function t.numberConstrained(min, max)
	assert(t.number(min))
	assert(t.number(max))
	local minCheck = t.numberMin(min)
	local maxCheck = t.numberMax(max)

	return function(value)
		local minSuccess, minErrMsg = minCheck(value)
		if not minSuccess then
			return false, minErrMsg or ""
		end

		local maxSuccess, maxErrMsg = maxCheck(value)
		if not maxSuccess then
			return false, maxErrMsg or ""
		end

		return true
	end
end

--[[**
	ensures value is a number where min < value < max

	@param min The minimum to use
	@param max The maximum to use

	@returns A function that will return true iff the condition is passed
**--]]
function t.numberConstrainedExclusive(min, max)
	assert(t.number(min))
	assert(t.number(max))
	local minCheck = t.numberMinExclusive(min)
	local maxCheck = t.numberMaxExclusive(max)

	return function(value)
		local minSuccess, minErrMsg = minCheck(value)
		if not minSuccess then
			return false, minErrMsg or ""
		end

		local maxSuccess, maxErrMsg = maxCheck(value)
		if not maxSuccess then
			return false, maxErrMsg or ""
		end

		return true
	end
end

--[[**
	ensures value matches string pattern

	@param string pattern to check against

	@returns A function that will return true iff the condition is passed
**--]]
function t.match(pattern)
	assert(t.string(pattern))
	return function(value)
		local stringSuccess, stringErrMsg = t.string(value)
		if not stringSuccess then
			return false, stringErrMsg
		end

		if string.match(value, pattern) == nil then
			return false, string.format("%q failed to match pattern %q", value, pattern)
		end

		return true
	end
end

--[[**
	ensures value is either nil or passes check

	@param check The check to use

	@returns A function that will return true iff the condition is passed
**--]]
function t.optional(check)
	assert(t.callback(check))
	return function(value)
		if value == nil then
			return true
		end

		local success, errMsg = check(value)
		if success then
			return true
		else
			return false, string.format("(optional) %s", errMsg or "")
		end
	end
end

--[[**
	matches given tuple against tuple type definition

	@param ... The type definition for the tuples

	@returns A function that will return true iff the condition is passed
**--]]
function t.tuple(...)
	local checks = { ... }
	return function(...)
		local args = { ... }
		for i, check in ipairs(checks) do
			local success, errMsg = check(args[i])
			if success == false then
				return false, string.format("Bad tuple index #%s:\n\t%s", i, errMsg or "")
			end
		end

		return true
	end
end

--[[**
	ensures all keys in given table pass check

	@param check The function to use to check the keys

	@returns A function that will return true iff the condition is passed
**--]]
function t.keys(check)
	assert(t.callback(check))
	return function(value)
		local tableSuccess, tableErrMsg = t.table(value)
		if tableSuccess == false then
			return false, tableErrMsg or ""
		end

		for key in pairs(value) do
			local success, errMsg = check(key)
			if success == false then
				return false, string.format("bad key %s:\n\t%s", tostring(key), errMsg or "")
			end
		end

		return true
	end
end

--[[**
	ensures all values in given table pass check

	@param check The function to use to check the values

	@returns A function that will return true iff the condition is passed
**--]]
function t.values(check)
	assert(t.callback(check))
	return function(value)
		local tableSuccess, tableErrMsg = t.table(value)
		if tableSuccess == false then
			return false, tableErrMsg or ""
		end

		for key, val in pairs(value) do
			local success, errMsg = check(val)
			if success == false then
				return false, string.format("bad value for key %s:\n\t%s", tostring(key), errMsg or "")
			end
		end

		return true
	end
end

--[[**
	ensures value is a table and all keys pass keyCheck and all values pass valueCheck

	@param keyCheck The function to use to check the keys
	@param valueCheck The function to use to check the values

	@returns A function that will return true iff the condition is passed
**--]]
function t.map(keyCheck, valueCheck)
	assert(t.callback(keyCheck))
	assert(t.callback(valueCheck))
	local keyChecker = t.keys(keyCheck)
	local valueChecker = t.values(valueCheck)

	return function(value)
		local keySuccess, keyErr = keyChecker(value)
		if not keySuccess then
			return false, keyErr or ""
		end

		local valueSuccess, valueErr = valueChecker(value)
		if not valueSuccess then
			return false, valueErr or ""
		end

		return true
	end
end

--[[**
	ensures value is a table and all keys pass valueCheck and all values are true

	@param valueCheck The function to use to check the values

	@returns A function that will return true iff the condition is passed
**--]]
function t.set(valueCheck)
	return t.map(valueCheck, t.literal(true))
end

do
	local arrayKeysCheck = t.keys(t.integer)
--[[**
		ensures value is an array and all values of the array match check

		@param check The check to compare all values with

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.array(check)
		assert(t.callback(check))
		local valuesCheck = t.values(check)

		return function(value)
			local keySuccess, keyErrMsg = arrayKeysCheck(value)
			if keySuccess == false then
				return false, string.format("[array] %s", keyErrMsg or "")
			end

			-- # is unreliable for sparse arrays
			-- Count upwards using ipairs to avoid false positives from the behavior of #
			local arraySize = 0

			for _ in ipairs(value) do
				arraySize = arraySize + 1
			end

			for key in pairs(value) do
				if key < 1 or key > arraySize then
					return false, string.format("[array] key %s must be sequential", tostring(key))
				end
			end

			local valueSuccess, valueErrMsg = valuesCheck(value)
			if not valueSuccess then
				return false, string.format("[array] %s", valueErrMsg or "")
			end

			return true
		end
	end

--[[**
		ensures value is an array of a strict makeup and size

		@param check The check to compare all values with

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.strictArray(...)
		local valueTypes = { ... }
		assert(t.array(t.callback)(valueTypes))

		return function(value)
			local keySuccess, keyErrMsg = arrayKeysCheck(value)
			if keySuccess == false then
				return false, string.format("[strictArray] %s", keyErrMsg or "")
			end

			-- If there's more than the set array size, disallow
			if #valueTypes < #value then
				return false, string.format("[strictArray] Array size exceeds limit of %d", #valueTypes)
			end

			for idx, typeFn in pairs(valueTypes) do
				local typeSuccess, typeErrMsg = typeFn(value[idx])
				if not typeSuccess then
					return false, string.format("[strictArray] Array index #%d - %s", idx, typeErrMsg)
				end
			end

			return true
		end
	end
end

do
	local callbackArray = t.array(t.callback)
--[[**
		creates a union type

		@param ... The checks to union

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.union(...)
		local checks = { ... }
		assert(callbackArray(checks))

		return function(value)
			for _, check in ipairs(checks) do
				if check(value) then
					return true
				end
			end

			return false, "bad type for union"
		end
	end

--[[**
		Alias for t.union
	**--]]
	t.some = t.union

--[[**
		creates an intersection type

		@param ... The checks to intersect

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.intersection(...)
		local checks = { ... }
		assert(callbackArray(checks))

		return function(value)
			for _, check in ipairs(checks) do
				local success, errMsg = check(value)
				if not success then
					return false, errMsg or ""
				end
			end

			return true
		end
	end

--[[**
		Alias for t.intersection
	**--]]
	t.every = t.intersection
end

do
	local checkInterface = t.map(t.any, t.callback)
--[[**
		ensures value matches given interface definition

		@param checkTable The interface definition

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.interface(checkTable)
		assert(checkInterface(checkTable))
		return function(value)
			local tableSuccess, tableErrMsg = t.table(value)
			if tableSuccess == false then
				return false, tableErrMsg or ""
			end

			for key, check in pairs(checkTable) do
				local success, errMsg = check(value[key])
				if success == false then
					return false, string.format("[interface] bad value for %s:\n\t%s", tostring(key), errMsg or "")
				end
			end

			return true
		end
	end

--[[**
		ensures value matches given interface definition strictly

		@param checkTable The interface definition

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.strictInterface(checkTable)
		assert(checkInterface(checkTable))
		return function(value)
			local tableSuccess, tableErrMsg = t.table(value)
			if tableSuccess == false then
				return false, tableErrMsg or ""
			end

			for key, check in pairs(checkTable) do
				local success, errMsg = check(value[key])
				if success == false then
					return false, string.format("[interface] bad value for %s:\n\t%s", tostring(key), errMsg or "")
				end
			end

			for key in pairs(value) do
				if not checkTable[key] then
					return false, string.format("[interface] unexpected field %q", tostring(key))
				end
			end

			return true
		end
	end
end

--[[**
	ensure value is an Instance and it's ClassName matches the given ClassName

	@param className The class name to check for

	@returns A function that will return true iff the condition is passed
**--]]
function t.instanceOf(className, childTable)
	assert(t.string(className))

	local childrenCheck
	if childTable ~= nil then
		childrenCheck = t.children(childTable)
	end

	return function(value)
		local instanceSuccess, instanceErrMsg = t.Instance(value)
		if not instanceSuccess then
			return false, instanceErrMsg or ""
		end

		if value.ClassName ~= className then
			return false, string.format("%s expected, got %s", className, value.ClassName)
		end

		if childrenCheck then
			local childrenSuccess, childrenErrMsg = childrenCheck(value)
			if not childrenSuccess then
				return false, childrenErrMsg
			end
		end

		return true
	end
end

t.instance = t.instanceOf

--[[**
	ensure value is an Instance and it's ClassName matches the given ClassName by an IsA comparison

	@param className The class name to check for

	@returns A function that will return true iff the condition is passed
**--]]
function t.instanceIsA(className, childTable)
	assert(t.string(className))

	local childrenCheck
	if childTable ~= nil then
		childrenCheck = t.children(childTable)
	end

	return function(value)
		local instanceSuccess, instanceErrMsg = t.Instance(value)
		if not instanceSuccess then
			return false, instanceErrMsg or ""
		end

		if not value:IsA(className) then
			return false, string.format("%s expected, got %s", className, value.ClassName)
		end

		if childrenCheck then
			local childrenSuccess, childrenErrMsg = childrenCheck(value)
			if not childrenSuccess then
				return false, childrenErrMsg
			end
		end

		return true
	end
end

--[[**
	ensures value is an enum of the correct type

	@param enum The enum to check

	@returns A function that will return true iff the condition is passed
**--]]
function t.enum(enum)
	assert(t.Enum(enum))
	return function(value)
		local enumItemSuccess, enumItemErrMsg = t.EnumItem(value)
		if not enumItemSuccess then
			return false, enumItemErrMsg
		end

		if value.EnumType == enum then
			return true
		else
			return false, string.format("enum of %s expected, got enum of %s", tostring(enum), tostring(value.EnumType))
		end
	end
end

do
	local checkWrap = t.tuple(t.callback, t.callback)

--[[**
		wraps a callback in an assert with checkArgs

		@param callback The function to wrap
		@param checkArgs The functon to use to check arguments in the assert

		@returns A function that first asserts using checkArgs and then calls callback
	**--]]
	function t.wrap(callback, checkArgs)
		assert(checkWrap(callback, checkArgs))
		return function(...)
			assert(checkArgs(...))
			return callback(...)
		end
	end
end

--[[**
	asserts a given check

	@param check The function to wrap with an assert

	@returns A function that simply wraps the given check in an assert
**--]]
function t.strict(check)
	return function(...)
		assert(check(...))
	end
end

do
	local checkChildren = t.map(t.string, t.callback)

--[[**
		Takes a table where keys are child names and values are functions to check the children against.
		Pass an instance tree into the function.
		If at least one child passes each check, the overall check passes.

		Warning! If you pass in a tree with more than one child of the same name, this function will always return false

		@param checkTable The table to check against

		@returns A function that checks an instance tree
	**--]]
	function t.children(checkTable)
		assert(checkChildren(checkTable))

		return function(value)
			local instanceSuccess, instanceErrMsg = t.Instance(value)
			if not instanceSuccess then
				return false, instanceErrMsg or ""
			end

			local childrenByName = {}
			for _, child in ipairs(value:GetChildren()) do
				local name = child.Name
				if checkTable[name] then
					if childrenByName[name] then
						return false, string.format("Cannot process multiple children with the same name %q", name)
					end

					childrenByName[name] = child
				end
			end

			for name, check in pairs(checkTable) do
				local success, errMsg = check(childrenByName[name])
				if not success then
					return false, string.format("[%s.%s] %s", value:GetFullName(), name, errMsg or "")
				end
			end

			return true
		end
	end
end

return t
]]></ProtectedString>
							<string name="ScriptGuid">{7425151D-C0F2-43DF-BB72-48FFEAA57BA2}</string>
							<BinaryString name="AttributesSerialize"></BinaryString>
							<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
							<bool name="DefinesCapabilities">false</bool>
							<string name="Name">t</string>
							<int64 name="SourceAssetId">-1</int64>
							<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
						</Properties>
					</Item>
				</Item>
			</Item>
			<Item class="LocalScript" referent="RBX3020D6EEA291429F8F0CF4D1B12E9EA1">
				<Properties>
					<ProtectedString name="Source"><![CDATA[--[[

█▀▀█ █░░ █▀▀█ █▀▀ █▀▀█ █▀▀▄ █░░█ █▀▀ █▀▀█ █▀▀▄ █▀▀ 
█▄▄█ █░░ █▄▄▀ █▀▀ █▄▄█ █░░█ █▄▄█ █▀▀ █▄▄█ █░░█ ▀▀█ 
▀░░▀ ▀▀▀ ▀░▀▀ ▀▀▀ ▀░░▀ ▀▀▀░ ▄▄▄█ ▀░░ ▀░░▀ ▀░░▀ ▀▀▀

Author: alreadyfans
For: Orbit
Description: Handles Orbit activity tracking

]]

local UserInputService = game:GetService("UserInputService")
local Event = script:WaitForChild("Event").Value

UserInputService.WindowFocusReleased:Connect(function()
	Event:FireServer(true)
end)

UserInputService.WindowFocused:Connect(function()
	Event:FireServer(false)
end)]]></ProtectedString>
					<bool name="Disabled">false</bool>
					<Content name="LinkedSource"><null></null></Content>
					<token name="RunContext">0</token>
					<string name="ScriptGuid">{BC7BD4DB-5FE1-4C9C-B8A4-1CE5E63FCAD8}</string>
					<BinaryString name="AttributesSerialize"></BinaryString>
					<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
					<bool name="DefinesCapabilities">false</bool>
					<string name="Name">OrbitClient</string>
					<int64 name="SourceAssetId">-1</int64>
					<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
				</Properties>
				<Item class="ObjectValue" referent="RBX78A2452CE05045F7881AE4A9EA44F1D0">
					<Properties>
						<Ref name="Value">null</Ref>
						<BinaryString name="AttributesSerialize"></BinaryString>
						<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
						<bool name="DefinesCapabilities">false</bool>
						<string name="Name">Event</string>
						<int64 name="SourceAssetId">-1</int64>
						<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
					</Properties>
				</Item>
			</Item>
			<Item class="ModuleScript" referent="RBX74A84F7609B54C2E8852FF9A66521DFD">
				<Properties>
					<Content name="LinkedSource"><null></null></Content>
					<ProtectedString name="Source"><![CDATA[local RunService = game:GetService("RunService")
local threads = {}

RunService.Stepped:Connect(function ()
	local now = tick()
	local resumePool

	for thread, resumeTime in pairs(threads) do
		-- Resume if we're reasonably close enough.
		local diff = (resumeTime - now)

		if diff < 0.005 then
			if not resumePool then
				resumePool = {}
			end

			table.insert(resumePool, thread)
		end
	end

	if resumePool then
		for _,thread in pairs(resumePool) do
			threads[thread] = nil
			coroutine.resume(thread, now)
		end
	end
end)

local function fastWait(t)
	local t = tonumber(t) or 1 / 30
	local start = tick()

	local thread = coroutine.running()
	threads[thread] = start + t

	-- Wait for the thread to resume.
	local now = coroutine.yield()
	return now - start, elapsedTime()
end

return fastWait]]></ProtectedString>
					<string name="ScriptGuid">{84CDACAC-F18A-46DA-B9DF-C1258CA2406A}</string>
					<BinaryString name="AttributesSerialize"></BinaryString>
					<SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
					<bool name="DefinesCapabilities">false</bool>
					<string name="Name">FastWait</string>
					<int64 name="SourceAssetId">-1</int64>
					<SharedString name="Tags">yuZpQdnvvUBOTYh1jqZ2cA==</SharedString>
				</Properties>
			</Item>
		</Item>
	</Item>
	<SharedStrings>
		<SharedString md5="yuZpQdnvvUBOTYh1jqZ2cA=="></SharedString>
	</SharedStrings>
</roblox>