g -- that reads back exactly (a float32 channel needs up to 17 digits). local function exactNumber(value) if value == math.floor(value) and math.abs(value) < 2 ^ 53 then return ("%d"):format(value) end for precision = 1, 17 do local text = ("%." .. precision .. "g"):format(value) if tonumber(text) == value then return text end end return ("%.17g"):format(value) end local function show(value) if value == nil then return "" end if typeof(value) == "Color3" then -- LuaText's rule (plan B0, planning decision 9): fromRGB only when -- every channel is exactly a whole 1/255 step as fromRGB makes it (a -- float32), else Color3.new with each channel's exact value. local channels, steps = { value.R, value.G, value.B }, {} for index, channel in ipairs(channels) do local step = math.round(channel * 255) if steps ~= nil and step >= 0 and step <= 255 and string.unpack(" rows, one per option, in path order: -- { path, type, default, doc, server, required, -- display fields -- optional, value, example, constraints, -- for templates and Tools -- pinned } -- plan B0, for T.migrate -- `default` is the display text the reference prints. `value` is the -- default itself, a fresh copy, with the defaults of nested fields filled in -- (Schema.defaults), nil when there is none. `example` is a copy of the -- option's `example`. `constraints` lists the limits `type` does not say. function Schema.describe(root) local rows = {} -- A list item or a map value is a structural node, not required to carry -- its own doc (Schema.check does not demand one there). Its row falls -- back to the list/map's own doc; an explicit doc on the item still wins. local function walk(node, path, server, parentDoc) local optional = node.kind == "optional" local n = unwrap(node) local isServer = server or n.server == true if path ~= "" then local doc = n.doc if doc == nil or doc == "" then doc = parentDoc end table.insert(rows, { path = path, type = typeName(n), default = show(n.default), doc = doc or "", server = isServer, required = (not optional) and n.default == nil and SCALAR[n.kind] == true, optional = optional, value = Schema.defaults(node), example = copy(n.example), constraints = constraintsOf(n), pinned = n.pinned == true, }) end if n.kind == "record" or n.kind == "config" then for _, name in ipairs(sortedKeys(n.fields)) do walk(n.fields[name], childPath(path, name), isServer, nil) end elseif n.kind == "list" then walk(n.item, path .. "[]", isServer, n.doc) elseif n.kind == "map" then walk(n.value, path .. ".", isServer, n.doc) end end walk(root, "", false, nil) return rows end -- ── freeze ─────────────────────────────────────────────────────────── function Schema.freeze(value) if type(value) ~= "table" or table.isfrozen(value) then return value end for _, item in pairs(value) do Schema.freeze(item) end return table.freeze(value) end return Schema ]]> -1 Signal 0 false -1 UI 0 0 0 0 false -1 MenuSystem 0 false b.priority end return a.index < b.index end) local out = {} for i, d in ipairs(decorated) do out[i] = d.inst end return out end -- Async (task.spawn) image warm-up shared by both panel-acquisition paths: -- registerPanel's clone (below) and the panel branch of adoption -- (_adoptCandidate, "parity restoration" fix - adopted panels used to skip -- this entirely, causing first-open texture pop-in for every StarterGui- -- shipped panel post-edit-time-GUI-migration). Interactables are NOT -- preloaded (registerPanel never did for addInteractable's clones either - -- this only restores parity with registerPanel's own existing behavior, not -- a new scope). local function preloadPanelImages(panel) task.spawn(function() local images = {} for _, desc in ipairs(panel:GetDescendants()) do if desc:IsA("ImageLabel") or desc:IsA("ImageButton") then table.insert(images, desc) end end if #images > 0 then ContentProvider:PreloadAsync(images) end end) end local MenuSystem = {} MenuSystem.__index = MenuSystem function MenuSystem.new(playerGui, opts) local self = setmetatable({}, MenuSystem) self._playerGui = playerGui -- 3.0: the Kernel's piece runtime (UI/Pieces.lua). When present, every -- adoption candidate is offered to it first; nil keeps 2.x behavior. self._pieces = opts and opts.pieces or nil self._mouse = Players.LocalPlayer:GetMouse() self.gui = buildShell(playerGui) self._menus = self.gui.Menus self._interactables = self.gui.Interactables.Container self._tooltip = self.gui.Tooltip self._handlers = {} self._panels = {} self._panelPriority = {} self._panelScrollers = {} self._interactableRegistry = {} self._interactablePriority = {} self._animations = {} self._wired = {} self._toggled = {} for name, fn in pairs(PanelAnimations) do self._animations[name] = fn end for _, desc in ipairs(self.gui:GetDescendants()) do self:_wireDescendant(desc) end self.gui.DescendantAdded:Connect(function(desc) self:_wireDescendant(desc) end) for _, button in ipairs(CollectionService:GetTagged("UI_Toggle")) do self:_wireToggle(button) end CollectionService:GetInstanceAddedSignal("UI_Toggle"):Connect(function(button) self:_wireToggle(button) end) -- Edit-time GUI adoption (StarterGui-shipped panels/interactables). Must -- run after the shell + wiring above exist so reparenting into Menus / -- Interactables.Container flows through the DescendantAdded wiring path -- automatically (no separate wiring code needed for adopted instances). -- self:_safeAdopt pcall-wraps each candidate: MenuSystem.new runs BEFORE -- Loader.boot in KernelClient, so an uncaught error here would take down -- the whole client ecosystem, not just adoption - one bad tag must never -- do that. for _, inst in ipairs(sortByAdoptPriority(CollectionService:GetTagged("UI_Panel"))) do self:_safeAdopt(inst, "Panel") end CollectionService:GetInstanceAddedSignal("UI_Panel"):Connect(function(inst) self:_safeAdopt(inst, "Panel") end) for _, inst in ipairs(sortByAdoptPriority(CollectionService:GetTagged("UI_Interactable"))) do self:_safeAdopt(inst, "Interactable") end CollectionService:GetInstanceAddedSignal("UI_Interactable"):Connect(function(inst) self:_safeAdopt(inst, "Interactable") end) return self end -- ── handlers ───────────────────────────────────────────────────────── function MenuSystem:registerHandlers(handlers) for action, fn in pairs(handlers) do self._handlers[action] = fn end end function MenuSystem:dispatch(action, button) local fn = self._handlers[action] if fn then fn(button) else warn("[RBLXE UI] No handler registered for action:", action) end end function MenuSystem:registerAnimation(name, fn) self._animations[name] = fn end -- ── panels ─────────────────────────────────────────────────────────── function MenuSystem:registerPanel(template) local panel = template:Clone() panel.Visible = false panel.Parent = self._menus self._panels[panel.Name] = panel local scrollers = {} for _, desc in ipairs(panel:GetDescendants()) do if desc:IsA("ScrollingFrame") then table.insert(scrollers, desc) end end self._panelScrollers[panel.Name] = scrollers preloadPanelImages(panel) return panel end function MenuSystem:getPanel(name) return self._panels[name] end --- The HUD button that actually opens `panelName` - the one this system --- REGISTERED, not merely one that carries the attribute. --- --- Packs need this to put a notification badge on their own button, and until --- 2026-08-25 every one of them scanned the shell for the first GuiButton with --- a matching `TargetPanel`. That is wrong whenever two packs ship a fallback --- button for the same panel: the loser of the priority contest is hidden but --- LEFT IN THE CONTAINER when it was adopted before the winner arrived (see --- `_adoptCandidate`'s "deposed" branch), so the scan could - and did, for --- Easy Pet System's Pets button - return an invisible button and light a --- badge nobody could see. Which of the two a scan hits depends on sweep --- order, so the packs that appeared to work were only lucky. function MenuSystem:getInteractable(panelName) return self._interactableRegistry["TogglePanel:" .. tostring(panelName)] end --- A 3.0 interface piece, already resolved by the Kernel: the game's Interface --- override when it satisfies its contract, otherwise the pack's default. --- `pieceId` is "." (packs use ctx.getPiece("")). Yields --- up to `timeout` seconds (default 10) for it to reach PlayerGui. A Panel or --- HudButton piece (tagged UI_Panel / UI_Interactable) is only useful once --- this menu adopted it; if it did not, the piece is still returned but a --- warning says why the menu cannot open it, instead of failing silently. function MenuSystem:getPiece(pieceId, timeout) if self._pieces == nil then return nil end local piece = self._pieces:get(pieceId, timeout) if piece ~= nil then local tag = (CollectionService:HasTag(piece, "UI_Panel") and "UI_Panel") or (CollectionService:HasTag(piece, "UI_Interactable") and "UI_Interactable") or nil -- M-d: the kind in the server's decision marks a menu piece even when -- it lacks its tag (a default that fails its contract). local kind = if self._pieces.kindOf ~= nil then self._pieces:kindOf(pieceId) else nil local menuPiece = tag ~= nil or kind == "Panel" or kind == "HudButton" if menuPiece and not self:_holds(piece) then -- A piece that has just arrived is adopted from its own tag signal: -- give that one frame before warning. task.wait() if not self:_holds(piece) then warn(("[RBLXE] UI: piece %s (%s) was not adopted by the menu; nothing can open it"):format(pieceId, tag or kind)) end end end return piece end -- Whether `inst` holds a registry slot (an adopted or registered panel or -- interactable), by identity. function MenuSystem:_holds(inst) for _, registry in ipairs({ self._panels, self._interactableRegistry }) do for _, registered in pairs(registry) do if registered == inst then return true end end end return false end function MenuSystem:openPanel(name) local menu = self._panels[name] if not menu or menu.Visible then return end SFX:Play("Press") menu.Visible = true local animFn = self._animations[menu:GetAttribute("Animation") or "Bounce"] if animFn then animFn(menu) end for _, sf in ipairs(self._panelScrollers[name] or {}) do sf.CanvasPosition = Vector2.zero end if menu:GetAttribute("Exclusive") ~= false then for otherName, otherMenu in pairs(self._panels) do if otherName ~= name and otherMenu.Visible and otherMenu:GetAttribute("Exclusive") ~= false then otherMenu.Visible = false end end end end function MenuSystem:closePanel(name) local menu = self._panels[name] if menu then menu.Visible = false end end function MenuSystem:togglePanel(name) local menu = self._panels[name] if not menu then return end if menu.Visible then SFX:Play("Press") menu.Visible = false else self:openPanel(name) end end function MenuSystem:addInteractable(template) local button = template:Clone() button.Parent = self._interactables return button end -- ── adoption (edit-time GUI: StarterGui-shipped panels/interactables) ── -- interactableKey(inst) -> the identity two packs' HUD buttons are deduped -- by. A button that toggles a panel IS that panel's button, whatever the -- instance happens to be called, so the key is the panel it opens. -- -- It used to be `inst.Name`, which only ever worked by coincidence: General -- UI Kit and Easy Pet System both shipped a fallback "Shop" button and both -- happened to name it after the panel. Renaming General UI Kit's buttons to -- "Shop Button" etc. (2026-08-21) broke that coincidence instantly - the two -- stopped colliding, both got adopted, and the HUD would have shown two Shop -- buttons side by side, each opening the same panel. Keying off what the -- button DOES cannot be broken by a rename. -- -- Anything that is not a panel toggle (a pack's own custom Action, or a -- decorative interactable with none) falls back to the name: there is -- nothing better to compare, and two of those are not obviously duplicates. local function interactableKey(inst) if inst:GetAttribute("Action") == "TogglePanel" then local target = inst:GetAttribute("TargetPanel") if type(target) == "string" and target ~= "" then return "TogglePanel:" .. target end end return inst.Name end local ADOPT_KIND = { Panel = { tag = "UI_Panel", container = "_menus", registry = "_panels", priorities = "_panelPriority" }, Interactable = { tag = "UI_Interactable", container = "_interactables", registry = "_interactableRegistry", priorities = "_interactablePriority" }, } -- Entry point for both the sweep (GetTagged) and late-arrival -- (GetInstanceAddedSignal) paths. Exposed (not local-only) so specs can -- drive it directly where there is no natural way to simulate a scenario -- through the tag-add signal (e.g. reentrancy guard). function MenuSystem:_adoptCandidate(inst, kind) local cfg = ADOPT_KIND[kind] if not cfg then return end -- A UI_Panel/UI_Interactable tag on a non-GuiObject (Folder, ScreenGui, -- UIStroke, ...) is not a valid candidate - bail before touching any -- GuiObject-only property (Visible, below) that would error on it. if not inst:IsA("GuiObject") then return end -- Only adopt from the local player's own PlayerGui tree, and never -- re-adopt something already living inside our own shell (avoids -- re-registration loops for anything CollectionService reports again). if not inst:IsDescendantOf(self._playerGui) or inst:IsDescendantOf(self.gui) then return end -- 3.0 pieces: a copy the Kernel did not choose (the default behind a valid -- Interface override, or the reverse, or a clone a pack made) is never -- adopted. Instances without RBLXE_Piece are always admitted, so 2.x GUIs -- keep the priority path below. if self._pieces ~= nil and not self._pieces:admit(inst) then return end local registry = self[cfg.registry] local priorities = self[cfg.priorities] local name = (kind == "Panel" and inst:GetAttribute("PanelId")) or interactableKey(inst) local priority = readAdoptPriority(inst) local existingPriority = priorities[name] local incumbent = registry[name] local chosen = self._pieces ~= nil and self._pieces:chose(inst) if chosen then -- The Kernel already decided this piece: it takes the slot whatever -- the AdoptPriority of a 2.x copy, which is deposed (hidden) instead. -- Two chosen pieces on one key is a declaration conflict: the first -- keeps the slot and both are named. local pieceId = inst:GetAttribute("RBLXE_Piece") if incumbent ~= nil and incumbent ~= inst and self._pieces:chose(incumbent) then inst.Visible = false warn(("[RBLXE] UI: pieces %s and %s both use %s '%s'; %s keeps it, %s is left unadopted") :format(tostring(incumbent:GetAttribute("RBLXE_Piece")), tostring(pieceId), cfg.tag, tostring(name), tostring(incumbent:GetAttribute("RBLXE_Piece")), tostring(pieceId))) return end if incumbent ~= nil and incumbent ~= inst then warn(("[RBLXE] UI: %s '%s' %s deposed by the 3.0 piece %s") :format(cfg.tag, tostring(name), incumbent:GetFullName(), tostring(pieceId))) end priority = math.huge elseif incumbent ~= nil and self._pieces ~= nil and self._pieces:chose(incumbent) then -- A 2.x copy arriving after the piece: the slot stays with the piece. inst.Visible = false warn(("[RBLXE] UI: %s '%s' %s left unadopted: the slot belongs to the 3.0 piece %s") :format(cfg.tag, tostring(name), inst:GetFullName(), tostring(incumbent:GetAttribute("RBLXE_Piece")))) return elseif existingPriority ~= nil and priority <= existingPriority then -- Loses to the incumbent (strictly lower, or a tie): left in place, -- unadopted, hidden so a dangling duplicate is never visible/clickable. inst.Visible = false if incumbent ~= nil and incumbent.Parent == nil then warn(("[RBLXE] duplicate %s '%s' left unadopted (priority): the incumbent was destroyed"):format(cfg.tag, name)) else warn(("[RBLXE] duplicate %s '%s' left unadopted (priority)"):format(cfg.tag, name)) end return end -- A higher-priority late arrival swaps the registration: the previously -- registered instance (if any) is deposed - hide it so it doesn't stay -- visible/reachable (an open panel, or a still-clickable interactable) -- after losing its registry slot, symmetric with the sweep-loser path. local previous = registry[name] if previous and previous ~= inst then previous.Visible = false end inst.Parent = self[cfg.container] if kind == "Panel" then inst.Visible = false -- panels default closed; interactables stay visible end registry[name] = inst priorities[name] = priority if kind == "Panel" then local scrollers = {} for _, desc in ipairs(inst:GetDescendants()) do if desc:IsA("ScrollingFrame") then table.insert(scrollers, desc) end end self._panelScrollers[name] = scrollers -- Parity restoration (M3 review fix): registerPanel always warmed up -- its clone's images; adopted panels must get the identical treatment -- - otherwise every StarterGui-shipped panel (GUK's 13, EPS's own) -- loses this warm-up entirely post edit-time-GUI-migration, causing -- first-open texture pop-in that registerPanel-based panels never had. preloadPanelImages(inst) end end -- Safety net around _adoptCandidate: MenuSystem.new runs before Loader.boot, -- so any uncaught error here would kill client boot entirely. A malformed -- candidate (or anything else unexpected) is logged and skipped instead. function MenuSystem:_safeAdopt(inst, kind) local ok, err = pcall(self._adoptCandidate, self, inst, kind) if not ok then warn(("[RBLXE] adoption failed for '%s': %s"):format(inst.Name, tostring(err))) end end function MenuSystem:_findAncestorPanel(instance) local current = instance.Parent while current and current ~= self.gui do -- Identity lookup, not a Name-keyed probe: adopted panels register -- under their PanelId attribute, which may differ from the -- instance's own Name - self._panels[current.Name] would miss those. for _, panel in pairs(self._panels) do if panel == current then return current end end current = current.Parent end return nil end -- Action routing. Real clicks call this from _wireButton; tests call it -- directly because Activated cannot be fired programmatically. function MenuSystem:_onButtonActivated(button) local action = button:GetAttribute("Action") if not action or action == "" then return end if action == "TogglePanel" then self:togglePanel(button:GetAttribute("TargetPanel") or "") elseif action == "ClosePanel" then local target = button:GetAttribute("TargetPanel") or "" if target ~= "" then self:closePanel(target) else local ancestor = self:_findAncestorPanel(button) if ancestor then ancestor.Visible = false end end else self:dispatch(action, button) end end -- ── wiring (Task 8 fills these in) ─────────────────────────────────── function MenuSystem:_wireDescendant(desc) if desc:IsA("GuiButton") then self:_wireButton(desc) elseif desc:IsA("GuiObject") then self:_wireDecoration(desc) end end function MenuSystem:_wireButton(button) if self._wired[button] then return end self._wired[button] = true if CollectionService:HasTag(button, "UI_Toggle") then return end -- A blocker is a GuiButton only so that it SINKS input - the invisible -- full-screen sheet a modal panel puts behind itself so clicks never -- reach what it covers. It is not something the player presses, so it -- gets no press sound, no hover sound, no icon tween and no tooltip. -- Reported by the user against Roulette System's Spin: "cada vez que -- clico el fondo del menu Spin suena el SFX de click". Declared with a -- tag rather than inferred: 100 GuiButtons across the shipped v2 assets -- carry neither a tag nor an Action (Teleport zones, Claim buttons, -- Equip/Merge/Delete, the music player's Next/Mute - all wired by pack -- code and all of them SHOULD click), so there is no property of a -- blocker to detect. It still sinks input exactly as before: absorbing -- clicks is what a GuiButton does, not something this wiring conferred. if CollectionService:HasTag(button, "UI_Blocker") then return end button.Activated:Connect(function() SFX:Play(button:GetAttribute("BuySound") and "Buy_1" or "Press") self:_onButtonActivated(button) end) local icon = button:FindFirstChild("Icon") button.MouseEnter:Connect(function() SFX:Play("Hover") if icon then icon:TweenSize(ICON_HOVER_SCALE, Enum.EasingDirection.Out, Enum.EasingStyle.Quint, ICON_HOVER_TWEEN_TIME, true) end if button:GetAttribute("ShowTooltip") then self._tooltip.Visible = true self._tooltip.ButtonName.Text = button:GetAttribute("TooltipText") or button.Name end end) local lastTooltipMove = 0 button.MouseMoved:Connect(function() if button:GetAttribute("ShowTooltip") then local now = tick() if now - lastTooltipMove < TOOLTIP_THROTTLE_INTERVAL then return end lastTooltipMove = now self._tooltip.Position = UDim2.fromOffset( self._mouse.X + TOOLTIP_OFFSET_X, self._mouse.Y + TOOLTIP_OFFSET_Y) end end) button.MouseLeave:Connect(function() if icon then icon:TweenSize(ICON_DEFAULT_SCALE, Enum.EasingDirection.Out, Enum.EasingStyle.Quint, ICON_LEAVE_TWEEN_TIME, true) end if button:GetAttribute("ShowTooltip") then self._tooltip.Visible = false end end) end function MenuSystem:_wireDecoration(element) if self._wired[element] then return end local animation = element:GetAttribute("Animation") if not animation then return end if element.Parent == self._menus then return end -- panels use Animation for their open-anim self._wired[element] = true if animation == "Rotate" then local speed = element:GetAttribute("Speed") or 15 TweenService:Create(element, TweenInfo.new(speed, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, -1), { Rotation = 360 }):Play() elseif animation == "HoverBob" then local basePos = element.Position element.MouseEnter:Connect(function() element:TweenPosition(basePos - UDim2.fromScale(0, 0.03), Enum.EasingDirection.Out, Enum.EasingStyle.Quint, 0.2, true) end) element.MouseLeave:Connect(function() element:TweenPosition(basePos, Enum.EasingDirection.Out, Enum.EasingStyle.Quint, 0.2, true) end) end end function MenuSystem:_wireToggle(button) if not button:IsA("GuiButton") then return end if not button:IsDescendantOf(self._playerGui) then return end -- ignore RS/asset templates if self._toggled[button] then return end local state = { isEnabled = true } self._toggled[button] = state local function setVisual() button.BackgroundColor3 = state.isEnabled and TOGGLE_COLOR_ON or TOGGLE_COLOR_OFF local status = button:FindFirstChild("Status") if status then status.Text = state.isEnabled and "ON" or "OFF" end end setVisual() button.MouseButton1Click:Connect(function() state.isEnabled = not state.isEnabled setVisual() local action = button:GetAttribute("Action") if action then self:dispatch(action, button) end end) end return MenuSystem ]]> -1 PanelAnimations 0 false -1 Bounce 0 false -1 Pieces 0 false /Pieces` -- (see Contracts.lua). Each piece has one DEFAULT copy, shipped by the pack -- under StarterGui.RBLXEssentials., and may have one OVERRIDE, owned -- by the game, under StarterGui.RBLXEssentials.Interface (a theme's piece or -- a fork). Piece roots carry RBLXE_Piece = ".". -- -- The server decides once, at boot (`plan`), which copy each piece uses: a -- valid override, else the default. Each decision is published as the -- relative path of the chosen instance under the RBLXEssentials root (for -- example "Interface/ThemeGui/Panel" or "Demo/DemoGui/Panel"), together with -- the path of every other candidate copy the server saw for that id (the -- refused ones), reaching every client in the RBLXE_PieceWinners attribute -- (`encodeDecisions`/`decodeDecisions`). The client (`runtime`) admits only -- the first instance of a piece whose own path under its nearest -- RBLXEssentials ancestor matches the winner, and retires the copies that -- arrive at a refused path or as a second copy at the winner path, so no pack -- ever holds a copy that is later replaced (the 434 failure). Any other -- instance carrying RBLXE_Piece (a clone a pack makes at runtime: a toast, a -- billboard per adornee, a registerPanel copy) is not admitted but is left -- alone: clones belong to the pack that made them. -- -- The server makes StarterGui.RBLXEssentials survive character respawns -- before `plan` runs (UI/RootPersistence.lua), so a piece admitted here -- stays the same instance for the whole session. -- -- Pure: every Instance, require function and scheduler comes in as an argument. local Pieces = {} Pieces.PIECE_ATTRIBUTE = "RBLXE_Piece" Pieces.SOURCE_ATTRIBUTE = "RBLXE_Source" Pieces.WINNERS_ATTRIBUTE = "RBLXE_PieceWinners" Pieces.LEGACY = "legacy" Pieces.INTERFACE = "Interface" Pieces.ROOT = "RBLXEssentials" -- StarterGui.RBLXEssentials.Interface.Custom holds what the 2.1 to 3.0 -- migration kept without managing it (T.migrate: retired panels and -- buttons). Nothing there is a candidate for any piece, here or in Tools. Pieces.CUSTOM = "Custom" -- How long getPiece waits for PlayerGui.RBLXEssentials (it arrives with the -- first character) before its own timeout starts counting (RT-4). Pieces.ROOT_WAIT = 120 local function pieceIdOf(inst) local id = inst:GetAttribute(Pieces.PIECE_ATTRIBUTE) if type(id) == "string" and id ~= "" then return id end return nil end local function sortedKeys(t) local keys = {} for key in pairs(t) do table.insert(keys, key) end table.sort(keys) return keys end -- ── declarations ───────────────────────────────────────────────────── -- collectDeclarations(...) -> (declarations, warnings, failures). `failures` -- maps the id of a pack whose Pieces module errors or is invalid to the -- reason its boot fails with (RT-6): its pieces can never be resolved, so -- the Loader fails it instead of letting it drive an interface nobody sees. function Pieces.collectDeclarations(packsFolder, requireFn, contracts) local declarations, warnings, failures = {}, {}, {} for _, packFolder in ipairs(packsFolder:GetChildren()) do local module = packFolder:FindFirstChild("Pieces") if module ~= nil and module:IsA("ModuleScript") then local ok, specs = pcall(requireFn, module) if not ok then local message = ("%s.Pieces errored: %s"):format(packFolder.Name, tostring(specs)) table.insert(warnings, message) failures[packFolder.Name] = "invalid Pieces: " .. message else local errors = contracts.validateSpecs(packFolder.Name, specs) if #errors > 0 then for _, message in ipairs(errors) do table.insert(warnings, message) end failures[packFolder.Name] = "invalid Pieces:\n " .. table.concat(errors, "\n ") else declarations[packFolder.Name] = specs end end end end table.sort(warnings) return declarations, warnings, failures end -- ── server plan ────────────────────────────────────────────────────── -- byId keeps the first copy of each id (sorted by full name); all keeps -- every copy, so the plan can publish the paths of the ones it refuses. local function index(list, origin, warnings, all) table.sort(list, function(a, b) return a:GetFullName() < b:GetFullName() end) local byId = {} for _, inst in ipairs(list) do local id = pieceIdOf(inst) all[id] = all[id] or {} table.insert(all[id], inst) if byId[id] ~= nil then table.insert(warnings, ("%s: more than one %s piece; using %s"):format(id, origin, byId[id]:GetFullName())) else byId[id] = inst end end return byId end -- The attribute that ties each piece kind to MenuSystem: a Panel is -- registered under its PanelId, a HudButton opens its TargetPanel. An -- Interface override must keep the default copy's value, or the button that -- opens the panel (and every pack that asks for it) would miss it. local IDENTITY = { Panel = "PanelId", HudButton = "TargetPanel" } local function nonEmptyText(value) if type(value) == "string" and value ~= "" then return value end return nil end local function quoted(value) if type(value) == "string" then return ("%q"):format(value) end return tostring(value) end -- The path of `inst` under `root`, as the names of every node strictly -- between them, joined by "/" (for example "Interface/ThemeGui/Panel"). local function relativePath(inst, root) local segments = {} local node = inst while node ~= nil and node ~= root do table.insert(segments, 1, node.Name) node = node.Parent end return table.concat(segments, "/") end -- winners maps each declared piece id to the relative path of the instance -- chosen to satisfy it; a piece with nothing valid to use has no entry. -- refused maps every id seen under the root, declared or not, to the paths -- of its other copies (the default behind a valid override, a rejected -- override, duplicates, copies of an id no pack declares): the client -- retires exactly those, and nothing else. function Pieces.plan(args) local contracts = args.contracts local root = args.root local interface = root and root:FindFirstChild(Pieces.INTERFACE) local custom = interface and interface:FindFirstChild(Pieces.CUSTOM) local defaultList, overrideList = {}, {} if root ~= nil then for _, inst in ipairs(root:GetDescendants()) do if pieceIdOf(inst) ~= nil and not (custom ~= nil and inst:IsDescendantOf(custom)) then if interface ~= nil and inst:IsDescendantOf(interface) then table.insert(overrideList, inst) else table.insert(defaultList, inst) end end end end local warnings, copies = {}, {} local defaults = index(defaultList, "default", warnings, copies) local overrides = index(overrideList, "Interface", warnings, copies) local declared, order, chosen, fromInterface, kinds = {}, {}, {}, {}, {} local detail = {} -- Stand-ins (Kernel 3.0.1): a piece with standsInFor = "." -- steps aside when that owner piece is declared. It gets no candidate at -- all, so its default and every Interface copy land in `refused` below. -- An owner of another kind keeps its piece and the stand-in is refused -- with a warning. A HudButton that opens a replaced panel is replaced -- with it ("a stand-in's opens follows its panel"). local replaced = {} for _, packId in ipairs(sortedKeys(args.declarations)) do local specs = args.declarations[packId] for _, name in ipairs(sortedKeys(specs)) do local spec = specs[name] local ownerId = spec.standsInFor if type(ownerId) == "string" then local ownerPack, ownerName = contracts.splitId(ownerId) local ownerSpecs = ownerPack ~= nil and ownerPack ~= packId and args.declarations[ownerPack] or nil local owner = ownerSpecs ~= nil and ownerSpecs[ownerName] or nil if type(owner) == "table" then local id = packId .. "." .. name replaced[id] = true if owner.kind == spec.kind then table.insert(detail, ("%s stands in for %s: replaced (owner installed)"):format(id, ownerId)) else table.insert(warnings, ("%s stands in for %s, a %s: a %s cannot stand in for it, refused") :format(id, ownerId, tostring(owner.kind), tostring(spec.kind))) end end end end end local followed = true while followed do followed = false for _, packId in ipairs(sortedKeys(args.declarations)) do local specs = args.declarations[packId] for _, name in ipairs(sortedKeys(specs)) do local id = packId .. "." .. name local opens = specs[name].opens if not replaced[id] and type(opens) == "string" and replaced[packId .. "." .. opens] then replaced[id] = true followed = true table.insert(detail, ("%s opens %s.%s: refused with its panel"):format(id, packId, opens)) end end end end -- Pass 1: each piece's contract, and an override's identity (PanelId or -- TargetPanel) against its default. for _, packId in ipairs(sortedKeys(args.declarations)) do local specs = args.declarations[packId] for _, name in ipairs(sortedKeys(specs)) do local spec = specs[name] local id = packId .. "." .. name declared[id] = { packId = packId, spec = spec } if replaced[id] then continue end kinds[id] = spec.kind table.insert(order, id) local default = defaults[id] if default ~= nil then local problems = contracts.check(default, spec) if #problems > 0 then table.insert(warnings, ("%s: default piece does not satisfy its contract: %s"):format(id, contracts.formatProblems(problems))) end end chosen[id] = default local override = overrides[id] if override ~= nil then local reason = nil local problems = contracts.check(override, spec) if #problems > 0 then reason = contracts.formatProblems(problems) else local attribute = IDENTITY[spec.kind] local want = attribute ~= nil and default ~= nil and nonEmptyText(default:GetAttribute(attribute)) or nil local got = attribute ~= nil and override:GetAttribute(attribute) or nil if want ~= nil and got ~= want then reason = ("%s is %s, the default's is %s"):format(attribute, quoted(got), quoted(want)) end end if reason == nil then chosen[id] = override fromInterface[id] = true else table.insert(warnings, ("%s: Interface piece rejected, using the default: %s"):format(id, reason)) end end end end -- Pass 2: `opens`. The chosen HudButton must target the PanelId of the -- chosen copy of the panel it opens, or it would open nothing. for _, id in ipairs(order) do local entry = declared[id] local opens = entry.spec.opens local panel = opens ~= nil and chosen[entry.packId .. "." .. opens] or nil if panel ~= nil and chosen[id] ~= nil then local panelId = panel:GetAttribute("PanelId") local function mismatch(button) local target = button:GetAttribute("TargetPanel") if target ~= panelId then return ("TargetPanel is %s but %s.%s has PanelId %s"):format(quoted(target), entry.packId, opens, quoted(panelId)) end return nil end local reason = mismatch(chosen[id]) if reason ~= nil and fromInterface[id] then table.insert(warnings, ("%s: Interface piece rejected, using the default: %s"):format(id, reason)) fromInterface[id] = nil chosen[id] = defaults[id] reason = chosen[id] ~= nil and mismatch(chosen[id]) or nil end if reason ~= nil then table.insert(warnings, ("%s: default piece does not satisfy its contract: %s"):format(id, reason)) end end end local winners, refused = {}, {} local total, interfaceCount = #order, 0 for _, id in ipairs(order) do local inst = chosen[id] if inst == nil then table.insert(warnings, ("%s: no piece available (no valid Interface piece and no default)"):format(id)) else winners[id] = relativePath(inst, root) if fromInterface[id] then interfaceCount += 1 table.insert(detail, ("%s <- Interface (%s)"):format(id, tostring(inst:GetAttribute(Pieces.SOURCE_ATTRIBUTE) or "custom"))) end end end for _, id in ipairs(sortedKeys(copies)) do local seen = {} for _, inst in ipairs(copies[id]) do local path = relativePath(inst, root) if inst ~= chosen[id] and path ~= winners[id] and not seen[path] then seen[path] = true refused[id] = refused[id] or {} table.insert(refused[id], path) end end if refused[id] ~= nil then table.sort(refused[id]) end end for _, id in ipairs(sortedKeys(overrides)) do if declared[id] == nil then table.insert(warnings, ("%s: Interface piece ignored, no installed pack declares it (%s)"):format(id, overrides[id]:GetFullName())) end end table.sort(warnings) local lines = {} if total > 0 then table.insert(lines, ("%d pieces: %d from Interface, %d default"):format(total, interfaceCount, total - interfaceCount)) for _, line in ipairs(detail) do table.insert(lines, line) end end return { winners = winners, refused = refused, kinds = kinds, lines = lines, warnings = warnings } end -- The RBLXE_PieceWinners value: the plan's winners and refused paths as JSON. -- `jsonEncode` is HttpService:JSONEncode in the Kernel; the server calls this -- inside the same pcall as the plan, so a value JSON cannot encode (an -- instance name that is not valid UTF-8, for example) falls back to LEGACY -- instead of stopping the server script. function Pieces.encodeDecisions(plan, jsonEncode) return jsonEncode({ winners = plan.winners, refused = plan.refused or {}, kinds = plan.kinds or {} }) end -- The client side of encodeDecisions. Returns { winners, refused }, or nil -- when the server sent no usable decision (missing, LEGACY, not JSON, or not -- the { winners, refused } shape): every piece is then adopted as in 2.x. -- An empty winners map encodes as "[]" and decodes to an empty table. function Pieces.decodeDecisions(encoded, jsonDecode) if type(encoded) ~= "string" or encoded == Pieces.LEGACY then return nil end local ok, decoded = pcall(jsonDecode, encoded) if not ok or type(decoded) ~= "table" or type(decoded.winners) ~= "table" then return nil end local refused = decoded.refused if type(refused) ~= "table" then refused = {} end local kinds = decoded.kinds if type(kinds) ~= "table" then kinds = {} end return { winners = decoded.winners, refused = refused, kinds = kinds } end -- strays(starterGui, root) -> warnings (M-c): every RBLXE_Piece instance in -- StarterGui outside StarterGui.RBLXEssentials. Nothing resolves or retires -- it, so it shows on every client as it is. The server says so once at boot -- (Kernel.server.lua) and T.validate says it in Studio. A clone a pack makes -- at runtime never reaches StarterGui, so it never warns. function Pieces.strays(starterGui, root) local warnings = {} if starterGui == nil then return warnings end for _, inst in ipairs(starterGui:GetDescendants()) do local id = pieceIdOf(inst) if id ~= nil and not (root ~= nil and (inst == root or inst:IsDescendantOf(root))) then table.insert(warnings, ("%s: %s is outside StarterGui.%s: the Kernel never uses it, and it shows on screen as it is") :format(id, inst:GetFullName(), Pieces.ROOT)) end end table.sort(warnings) return warnings end -- ── client runtime ─────────────────────────────────────────────────── function Pieces.originOf(inst) local node = inst.Parent while node ~= nil do if node.Name == Pieces.INTERFACE and node.Parent ~= nil and node.Parent.Name == Pieces.ROOT then return "Interface" end node = node.Parent end return "Default" end -- The path of `inst` under its nearest ancestor named Pieces.ROOT -- ("RBLXEssentials"), matching what the server published in `plan`'s -- winners. Nil when `inst` has no such ancestor at all. local function pathUnderRoot(inst) local segments = {} local node = inst while node ~= nil do local parent = node.Parent if parent == nil then return nil end table.insert(segments, 1, node.Name) if parent.Name == Pieces.ROOT then return table.concat(segments, "/") end node = parent end return nil end local Runtime = {} Runtime.__index = Runtime -- decisions is what decodeDecisions returns (or a plan result): winners maps -- a piece id to the relative path (relativePath/pathUnderRoot) of the -- instance chosen to satisfy it, refused maps an id to the paths of the -- copies the server refused. decisions == nil means the server sent no -- decision at all: 2.x adoption for every piece. function Pieces.runtime(decisions, opts) opts = opts or {} local self = setmetatable({}, Runtime) self._winners = decisions and decisions.winners or nil self._refused = {} for id, paths in pairs(decisions and decisions.refused or {}) do if type(paths) == "table" then local set = {} for _, path in ipairs(paths) do set[path] = true end self._refused[id] = set end end self._admitted = {} self._decided = setmetatable({}, { __mode = "k" }) self._kinds = decisions and decisions.kinds or {} self._noDecision = {} -- RT-4: getPiece counts its timeout only once PlayerGui.RBLXEssentials -- exists. attach() records the PlayerGui; without one (a spec) the root -- counts as arrived. self._playerGui = opts.playerGui self._rootWait = opts.rootWait or Pieces.ROOT_WAIT self._wait = opts.wait or function(seconds) return seconds end self._warn = opts.warn or function() end self._defer = opts.defer or function(fn) fn() end return self end -- The declared kind of a piece id ("Panel", "HudButton", ...) as the -- server's decision carries it, or nil. MenuSystem:getPiece warns from it -- about a menu piece it never adopted, even one that lacks its tag (M-d). function Runtime:kindOf(pieceId) local kind = self._kinds[pieceId] return if type(kind) == "string" then kind else nil end -- One warning per id the server's decision does not contain (T-G, M5): no -- installed pack declares it, or no copy of it was usable. function Runtime:_warnNoDecision(id, where) if self._noDecision[id] then return end self._noDecision[id] = true self._warn(("[RBLXE] UI: piece %s has no decision from the server (no installed pack declares it, or no copy of it is usable)%s") :format(id, if where ~= nil then ("; %s is not used"):format(where) else "")) end function Runtime:_retire(inst) pcall(function() if inst:IsA("GuiObject") then inst.Visible = false elseif inst:IsA("LayerCollector") then inst.Enabled = false end end) -- Deferred: the clone may still be mid-parenting when it is refused. self._defer(function() inst:Destroy() end) end -- Decides once per instance (the answer is cached, so a later move into the -- MenuSystem shell cannot change it) and returns whether it may be used. -- Only copies competing for the id are retired: one at a path the server -- refused, or a second one at the winner path. Any other instance carrying -- RBLXE_Piece (a clone a pack made) is refused but left alone. function Runtime:admit(inst) local cached = self._decided[inst] if cached ~= nil then return cached end local id = pieceIdOf(inst) local admitted = true if id ~= nil then if self._winners == nil then self._admitted[id] = self._admitted[id] or inst else local winnerPath = self._winners[id] local path = pathUnderRoot(inst) if winnerPath == nil then admitted = false self:_warnNoDecision(id, inst:GetFullName()) local refused = self._refused[id] if path ~= nil and refused ~= nil and refused[path] then self:_retire(inst) end elseif path ~= nil and path == winnerPath then local incumbent = self._admitted[id] if incumbent == nil then self._admitted[id] = inst else admitted = false if incumbent.Parent == nil then self._warn(("[RBLXE] UI: piece %s was destroyed; its new copy %s is refused (pieces are admitted once per session)") :format(id, inst:GetFullName())) else -- M-b: never removed without a word. self._warn(("[RBLXE] UI: piece %s: a second copy arrived at %s and was removed; the first copy keeps the piece") :format(id, inst:GetFullName())) end self:_retire(inst) end else admitted = false local refused = self._refused[id] if path ~= nil and refused ~= nil and refused[path] then self:_retire(inst) end end end end self._decided[inst] = admitted return admitted end -- Whether `inst` is the copy the server's decision chose for its id (always -- false in 2.x legacy mode, where nothing was decided). MenuSystem adopts -- such a piece over any 2.x panel or button with the same key. function Runtime:chose(inst) if self._winners == nil then return false end local id = pieceIdOf(inst) return id ~= nil and self._admitted[id] == inst end function Runtime:attach(playerGui) self._playerGui = playerGui local function consider(inst) if pieceIdOf(inst) ~= nil then self:admit(inst) end end for _, inst in ipairs(playerGui:GetDescendants()) do consider(inst) end return playerGui.DescendantAdded:Connect(consider) end -- get(pieceId, timeout?) -> the admitted piece, or nil. An id the server's -- decision does not contain returns at once (M5): no copy of it will ever be -- admitted. Otherwise the timeout (default 10 s) counts only while -- PlayerGui.RBLXEssentials exists (RT-4): the root arrives with the first -- character, which a slow client or a pack like DatastorePurchaseSystem can -- delay; waiting for the root is bounded by rootWait on its own. function Runtime:get(pieceId, timeout) if self._winners ~= nil and self._winners[pieceId] == nil then self:_warnNoDecision(pieceId, nil) return nil end local limit = timeout or 10 local elapsed, waitedForRoot = 0, 0 while true do local found = self._admitted[pieceId] if found ~= nil and found.Parent ~= nil then return found end local rootHere = self._playerGui == nil or self._playerGui:FindFirstChild(Pieces.ROOT) ~= nil if rootHere and elapsed >= limit then break end if not rootHere and waitedForRoot >= self._rootWait then self._warn(("[RBLXE] UI: piece %s: PlayerGui.%s did not arrive within %ss (the player has no character yet?)") :format(pieceId, Pieces.ROOT, tostring(self._rootWait))) return nil end local step = self._wait(0.1) step = if type(step) == "number" and step > 0 then step else 0.1 if rootHere then elapsed += step else waitedForRoot += step end end self._warn(("[RBLXE] UI: piece %s did not appear within %ss"):format(pieceId, tostring(limit))) return nil end return Pieces ]]> -1 RootPersistence 0 false . path stays the same: look the root -- up by name after boot. The holder is neutral (no insets, no safe-area -- clipping), so it adds no layout of its own, and the pack ScreenGuis nested -- inside keep rendering as independent layers. -- -- Pure: no `game` access. `create` is Instance.new and `enums` is Enum, -- both injected so Lune specs can pass @lune/roblox's versions. local RootPersistence = {} RootPersistence.ROOT = "RBLXEssentials" -- The nearest ancestor of `inst` (not `inst` itself) that is a GuiObject or -- a LayerCollector, or nil when there is none. local function nearestGuiAncestor(inst) local node = inst.Parent while node ~= nil do if node:IsA("GuiObject") or node:IsA("LayerCollector") then return node end node = node.Parent end return nil end -- Reports every instance under the root whose behavior changes now that the -- root persists instead of resetting on spawn: -- * client code (a LocalScript, or a Script with RunContext Client) now -- runs once per session instead of on every respawn; -- * a nested LayerCollector that asked to reset on spawn no longer does; -- * only when the old root was not a LayerCollector (a Folder, which -- renders nothing): a GuiObject with no GuiObject or LayerCollector -- between it and the root now renders. Only the top of each such subtree -- is reported, so a Frame > Folder > Frame chain gives one warning. When -- the old root was already a ScreenGui, those objects were already -- rendering, so they are not reported. local function audit(root, enums, warnings, rootWasLayerCollector) for _, inst in ipairs(root:GetDescendants()) do if inst:IsA("LocalScript") or (inst:IsA("Script") and inst.RunContext == enums.RunContext.Client) then table.insert(warnings, ("%s: now runs once per session instead of on every respawn"):format(inst:GetFullName())) elseif inst:IsA("LayerCollector") then if inst.ResetOnSpawn == true then table.insert(warnings, ("%s: no longer resets on spawn"):format(inst:GetFullName())) end elseif inst:IsA("GuiObject") then if not rootWasLayerCollector and nearestGuiAncestor(inst) == root then table.insert(warnings, ("%s: now renders (it has no ScreenGui of its own)"):format(inst:GetFullName())) end end end end -- Makes StarterGui.RBLXEssentials survive respawn. Returns (root, warnings); -- root is nil only when StarterGui has no RBLXEssentials child. function RootPersistence.persist(starterGui, create, enums) local warnings = {} local root = starterGui:FindFirstChild(RootPersistence.ROOT) local matches = 0 for _, child in ipairs(starterGui:GetChildren()) do if child.Name == RootPersistence.ROOT then matches += 1 end end if matches > 1 and root ~= nil then table.insert(warnings, ("more than one StarterGui child is named %s; only %s was made persistent") :format(RootPersistence.ROOT, root:GetFullName())) end if root == nil then return nil, warnings end if root:IsA("ScreenGui") then -- Already converted, or the root may already be a ScreenGui if the -- game replaced it by hand: only make sure it survives respawn, and -- audit only when that is a change. Its GuiObjects already rendered. if root.ResetOnSpawn then root.ResetOnSpawn = false audit(root, enums, warnings, true) end table.sort(warnings) return root, warnings end local holder = create("ScreenGui") holder.Name = RootPersistence.ROOT holder.ResetOnSpawn = false holder.ScreenInsets = enums.ScreenInsets.None holder.ClipToDeviceSafeArea = false holder.SafeAreaCompatibility = enums.SafeAreaCompatibility.None for key, value in pairs(root:GetAttributes()) do holder:SetAttribute(key, value) end for _, tag in ipairs(root:GetTags()) do holder:AddTag(tag) end local moved = {} local moveOk, moveErr = pcall(function() for _, child in ipairs(root:GetChildren()) do child.Parent = holder table.insert(moved, child) end end) if not moveOk then -- Put back whatever already moved, so nothing is left orphaned. local stranded = {} for _, child in ipairs(moved) do local backOk = pcall(function() child.Parent = root end) if not backOk then table.insert(stranded, child) end end if #stranded == 0 then holder:Destroy() else -- Destroying the holder would destroy these children with it. for _, child in ipairs(stranded) do table.insert(warnings, ("%s could not be returned to %s"):format(child.Name, RootPersistence.ROOT)) end end table.insert(warnings, ("%s: root not made persistent; menus, HUD buttons and pack interfaces may stop working after a respawn (%s)") :format(RootPersistence.ROOT, tostring(moveErr))) table.sort(warnings) return root, warnings end -- Parented before the Folder is destroyed, with no yield in between, so -- the moved children always have a root. holder.Parent = starterGui root:Destroy() audit(holder, enums, warnings, false) table.sort(warnings) return holder, warnings end return RootPersistence ]]> -1 Shell 0 false -- Interactables.Container pre-M1-unwrap, verified directly by a Lune -- probe against `git show 8b0e864:"General UI Kit v2/src/ -- ReplicatedStorage/GeneralUIKit/Assets/Interactables.rbxm"` - see -- task-M1-report.md's I2 fix section for the probe output) as the -- kernel default for ALL packs, designed or not: since Task M1, GUK -- ships its 10 nav buttons directly adopted into THIS Container (no -- pack ever overwrites this geometry anymore - the old "GUK v2 -- overwrites this after cloning its layout" comment this replaced is -- stale post-M1). local container = Instance.new("Frame") container.Name = "Container" container.BackgroundTransparency = 1 container.AnchorPoint = Vector2.new(0, 0.5) container.Position = UDim2.fromScale(0.01, 0.5) container.Size = UDim2.fromScale(0.2, 0.38) -- Explicit even though it equals the Frame default: this is the low half -- of the rank documented on `menus.ZIndex` above, and a silent default is -- exactly what produced the tie in the first place. container.ZIndex = 1 container.Parent = interactables local grid = Instance.new("UIGridLayout") grid.CellSize = UDim2.fromScale(0.24, 0.24) grid.CellPadding = UDim2.fromScale(0.03, 0.01) grid.FillDirection = Enum.FillDirection.Vertical grid.HorizontalAlignment = Enum.HorizontalAlignment.Left grid.SortOrder = Enum.SortOrder.LayoutOrder grid.Parent = container -- The designed Container parents this directly to the FRAME, not to the -- UIGridLayout (a UIAspectRatioConstraint parented to a UIGridLayout has -- no effect on anything - verified via the probe above: it does nothing -- there, which is why this was a real, not merely cosmetic, v1-parity -- bug prior to this fix). local aspect = Instance.new("UIAspectRatioConstraint") aspect.AspectRatio = 0.9341463446617126 aspect.AspectType = Enum.AspectType.FitWithinMaxSize aspect.DominantAxis = Enum.DominantAxis.Height aspect.Parent = container local tooltip = Instance.new("Frame") tooltip.Name = "Tooltip" tooltip:SetAttribute("TooltipType", "Button") tooltip.Visible = false tooltip.BackgroundColor3 = Color3.fromRGB(30, 30, 30) tooltip.BackgroundTransparency = 0.15 tooltip.BorderSizePixel = 0 tooltip.Size = UDim2.fromOffset(140, 34) tooltip.ZIndex = 50 tooltip.Parent = gui local corner = Instance.new("UICorner") corner.CornerRadius = UDim.new(0, 6) corner.Parent = tooltip local label = Instance.new("TextLabel") label.Name = "ButtonName" label.BackgroundTransparency = 1 label.Size = UDim2.fromScale(1, 1) label.TextColor3 = Color3.fromRGB(255, 255, 255) label.TextScaled = true label.Font = Enum.Font.GothamBold label.Text = "" label.ZIndex = 51 label.Parent = tooltip gui.Parent = playerGui return gui end ]]> -1 Version 0 false .": a -- stand-in copy of a piece another pack owns (the General UI Kit -- ships its 2.x menus this way). Pieces.plan refuses the stand-in, -- its default and every Interface copy, when the owner piece is -- declared, and a HudButton that opens a refused stand-in panel is -- refused with it; without the owner the stand-in is planned like -- any piece. An owner of another kind keeps its piece and the -- stand-in is refused with a warning. PATCH: an older Kernel ignores -- the field and would choose both copies, so a pack that declares -- stand-ins needs Kernel >= 3.0.1. return "3.0.1" ]]> -1 Packs 0 0 0 0 false -1 DatastorePurchaseSystem AQAAAAwAAABSQkxYRV9IYXNoZXMCRAQAACNyYmx4ZS1oYXNoZXMgdjEgZm52MWEzMiBsZgpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9NaWdyYXRpb25zL0Zyb21WMgkwMzkxYTNlMQpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9NaWdyYXRpb25zL0tlZXAJMTFmYTJkZGUKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvRGF0YXN0b3JlUHVyY2hhc2VTeXN0ZW0vUGFja2FnZXMvUHJvbWlzZQk2ZDUzZjgzNgpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9TY2hlbWEJMjNhMTE2ZmQKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvRGF0YXN0b3JlUHVyY2hhc2VTeXN0ZW0vbWFuaWZlc3QJYTA1Y2QzYmYKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbQkzYjNjNDdiNwpTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL0FjdGlvbnMvV2lwZVN0dWRpb0RhdGEJMzE1ZDk2ZWEKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9Db25maWcJMzJmZDJlOGYKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9EYXRhUGF0aAk5YTBlMjI4MApTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL0RhdGFTdG9yZU1hbmFnZXIJODdkOTIyNWUKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9EZWZhdWx0RGF0YQkxZDFkODIzNApTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL01pZ3JhdGlvbglmZWU4NjZiNQpTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL1B1cmNoYXNlTWFuYWdlcgk3MWM0NmQzNgpTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL1N0dWRpb1NhZmVJZAkwZTE4YjM1NApTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL1ZhbHVlUmVwbGljYXRvcglkYjgxNGVhMA== 0 0 0 0 false -1 Migrations 0 0 0 0 false -1 FromV2 0 false (kind, value): what 2.x's `inst.Value` gave. -- "none" nothing found, or `.Value` errored: 2.x's default; -- "value" a value's Value (nil when it had none); Tree.read keeps an -- ObjectValue's target as a path, 2.x read the Instance: -- "instance" for that; -- "instance" an Instance: an ObjectValue's target, or the child named -- Value of an instance that is not a value; -- "unreadable" the Value property of a class in UNREADABLE. local function valueOf(node) if node == nil then return "none", nil end if node.value ~= nil then return if node.class == "ObjectValue" then "instance" else "value", node.value end if VALUE_BASES[node.class] then return "value", nil end if UNREADABLE[node.class] then return "unreadable", nil end local inner = child(node, "Value") if inner ~= nil then return "instance", inner end return "none", nil end -- aClass(class) -> the class name with its article (B3b acceptance R3 -- review: a note's first sentence is its line in T.migrate's report, which -- the agent quotes to the user): "an" before a vowel sound (an IntValue, an -- ObjectValue), "a" before a consonant sound, a U read as "you" too (a -- UIListLayout, a UnionOperation, a UserSettings). local function aClass(class) local you = string.find(class, "^U%u") ~= nil or string.find(class, "^Uni") ~= nil or string.find(class, "^Us[eu]") ~= nil return (if string.find(class, "^[AEIOU]") ~= nil and not you then "an " else "a ") .. class end local function describe(node, kind, value) if kind == "instance" then return if node.class == "ObjectValue" then "an ObjectValue pointing at an instance" else ("%s with a child named Value"):format(aClass(node.class)) end if kind == "unreadable" then return aClass(node.class) end if type(value) == "string" then return ("%s %q"):format(aClass(node.class), value) end return ("%s %s"):format(aClass(node.class), tostring(value)) end local UNREADABLE_FIX = "whose Value 2.x read, but T.migrate cannot read it (it reads the Value of value instances only). Replace it with a %s holding the same value" -- B3b acceptance R3 review: a note's first sentence is its line in -- T.migrate's report (Migrate.brief), so FreeMode's says there what 3.0 -- changes: 2.x applied it on live servers too, 3.0 only in Studio. local FREE_MODE_3 = "carried as on, but 3.0 applies FreeMode only in Studio, while 2.x applied it on live servers too" local FREE_MODE_STORE = "Nor does it work in Studio while Studio uses the live store; a live server checks real ownership and warns at start" -- The fixes of the notes that ask for an action (B3b acceptance R1). local RESTART_FIX = "Nothing to do in Studio. Tell the user: after publishing the migrated game, restart every server (Migrate To Latest Update, or Shut Down All Servers) so no 2.0.0 server keeps saving next to 3.0 ones" local SHARED_STORE_FIX = "Nothing to do now: it is carried as the game ran it. Tell the user that Studio sessions use the live profiles; only if they ask, set another StudioDataStoreVersion in Config.DatastorePurchaseSystem, which gives Studio profiles of their own" local WIPE_FIX = "Nothing to do: it is not a setting but the 2.x plugin's Wipe Studio Data button, and the config module has nothing in its place. The 3.0 plugin keeps that button: never wipe Studio profiles yourself; only the user does, when they ask" -- B3b acceptance R5 (migrate-5, stumble 1): a store version's note. Every -- DataStoreVersion and StudioDataStoreVersion note ends its first sentence, -- its line in T.migrate's report, with the store that stays (stays), and -- gives its own fix (storeFix): with the generic one an agent offered the -- user the live store version as a value to decide, and another value -- starts every player on an empty profile (Schema.lua). A live server uses -- PlayerData_, Studio PlayerData_ -- (DataStoreManager's storeName, as 2.x's Config). -- storeOf(version) -> that store's name, in quotes when the text is empty -- or has a space or a quote, so a space at its end shows. local function storeOf(version) local store = "PlayerData_" .. version return if version ~= "" and string.find(version, '[%s"]') == nil then store else ("%q"):format(store) end local function stays(name, version) return ("so the %s store stays %s"):format(if name == "DataStoreVersion" then "live" else "Studio", storeOf(version)) end local function storeFix(name, version) if name == "DataStoreVersion" then return ("Nothing to do: the live store stays %s, where 2.x saved every player's data. In a live game, never change DataStoreVersion: another value starts every player on an empty profile (their saved data stays in the old store)"):format( storeOf(version)) end return ("Nothing to do: the Studio store stays %s, where 2.x saved the data of Studio sessions. Changing StudioDataStoreVersion touches Studio data only: Studio sessions start on empty profiles in the new store, and live players keep theirs"):format( storeOf(version)) end return function(tree, ctx) local config, notes, sources, refusals = {}, {}, {}, {} local rootName = tree and tree.name or "Settings" local used = {} local function note(path, message, fix, action) local entry = { path = path, message = message, fix = fix, action = action } table.insert(notes, entry) return entry end local function refuse(path, message) table.insert(refusals, { path = path, message = message }) end -- readAtOrBelow(path): 2.x read that instance or one inside it. local function readAtOrBelow(path) for read in pairs(used) do if read == path or string.sub(read, 1, #path + 1) == path .. "." then return true end end return false end local empty = tree == nil or #tree.children == 0 if empty then note(rootName, ("is missing or empty, so 2.x ran its defaults: the live store stays %s and the Studio store %s. DataStoreVersion %q, StudioDataStoreVersion %q and an empty DefaultData (only its built-in groups) are written, since they are pinned; AutoSaveInterval 90 and FreeMode off are the 3.0 defaults"):format( storeOf(DEFAULTS.DataStoreVersion), storeOf(DEFAULTS.StudioDataStoreVersion), DEFAULTS.DataStoreVersion, DEFAULTS.StudioDataStoreVersion), ("Nothing to do: the live store stays %s, where 2.x saved every player's data, and the Studio store %s. In a live game, never change DataStoreVersion: another value starts every player on an empty profile (their saved data stays in the old store)"):format( storeOf(DEFAULTS.DataStoreVersion), storeOf(DEFAULTS.StudioDataStoreVersion))) end if ctx ~= nil and ctx.fromVersion == "2.0.0" then note(rootName, "belongs to Datastore & Purchase System 2.0.0, whose servers do not honour the session ownership protocol 2.1.0 added to player profiles (docs/releases/2.1.0.md): after publishing the migrated game, restart every server (Migrate To Latest Update, or Shut Down All Servers) so no 2.0.0 server keeps saving next to 3.0 ones", RESTART_FIX, true) end -- setting(name) -> (kind, value, node, path, shadow): 2.x's setting(name, -- default); shadow is the note that 2.x read it somewhere else, if any. local function setting(name) if tree == nil then return "none", nil, nil, nil end local node, path = ctx.find(tree, name, true) if node == nil then return "none", nil, nil, nil end used[path] = true local home = ("%s.%s.%s"):format(rootName, HOMES[name], name) local shadow = nil if path ~= home then shadow = note(path, ("is the first %s 2.x's recursive search found in Settings, so 2.x read this one%s"):format(name, if child(child(tree, HOMES[name]), name) ~= nil then (" and never %s"):format(home) else "")) end local kind, value = valueOf(node) return kind, value, node, path, shadow end -- ── the two store versions: the DataStore of every profile (ruling 1) ── for _, name in ipairs({ "DataStoreVersion", "StudioDataStoreVersion" }) do local kind, value, node, path, shadow = setting(name) local default = DEFAULTS[name] if kind == "unreadable" then refuse(path, ("is %s, " .. UNREADABLE_FIX):format(describe(node, kind, value), "StringValue")) elseif kind == "none" or value == nil or value == false then config[name] = default if node ~= nil then note(path, ("is %s, so 2.x used %q: written (pinned), %s"):format( if kind == "none" then ("%s with no Value"):format(aClass(node.class)) else describe(node, kind, value), default, stays(name, default)), storeFix(name, default)) elseif not empty then note(("%s.%s.%s"):format(rootName, HOMES[name], name), ("is missing, so 2.x used %q: written (pinned), %s"):format(default, stays(name, default)), storeFix(name, default)) end elseif kind == "value" and type(value) == "string" then config[name] = value sources[name] = path elseif kind == "value" and type(value) == "number" then config[name] = tostring(value) sources[name] = path note(path, ("is %s: 2.x joined it to \"PlayerData_\" as the text %q, carried as that text, %s"):format(describe(node, kind, value), tostring(value), stays(name, config[name])), storeFix(name, config[name])) else refuse(path, ("is %s, which 2.x could not join to \"PlayerData_\": every load of player data %s failed. Set the store version the game really uses as a StringValue"):format( describe(node, kind, value), if name == "DataStoreVersion" then "in a live server" else "in Studio")) end -- B3b acceptance R5: the note that 2.x read it somewhere else says the -- store too, once it is known (a refused value has none). if shadow ~= nil and config[name] ~= nil then shadow.message ..= ", " .. stays(name, config[name]) shadow.fix = storeFix(name, config[name]) end end if config.DataStoreVersion ~= nil and config.DataStoreVersion == config.StudioDataStoreVersion then note(sources.StudioDataStoreVersion or rootName, ("is %q, the same as DataStoreVersion (2.0.0 shipped them equal): Studio sessions load and save the live profiles of PlayerData_%s. Carried as it is; the 3.0 server warns at start and keeps FreeMode off in Studio, and you can set another StudioDataStoreVersion once the migration is done%s"):format( config.DataStoreVersion, config.DataStoreVersion, -- A game installed on 2.0.0 may have updated its place to 2.1.0 -- in Studio and never published it: what matters is what its -- live servers run (the 2.0.0 note below already says it). if ctx ~= nil and ctx.fromVersion == "2.0.0" then "" else ". If your published game still runs Datastore & Purchase System 2.0.0 (the 2.1.0 update was never published), restart every server after publishing the migrated game, as for a 2.0.0 game (docs/releases/2.1.0.md)"), SHARED_STORE_FIX .. (if ctx ~= nil and ctx.fromVersion == "2.0.0" then "" else ". If the published game still runs Datastore & Purchase System 2.0.0, they restart every server after publishing the migrated game"), true) end -- ── AutoSaveInterval (ruling 2) ── do local kind, value, node, path = setting("AutoSaveInterval") if kind == "unreadable" then refuse(path, ("is %s, " .. UNREADABLE_FIX):format(describe(node, kind, value), "NumberValue")) elseif kind == "none" or value == nil or value == false then config.AutoSaveInterval = DEFAULTS.AutoSaveInterval if node ~= nil then note(path, ("is %s, so 2.x saved every 90 seconds, the 3.0 default"):format( if kind == "none" then ("%s with no Value"):format(aClass(node.class)) else describe(node, kind, value))) end else local number = if kind == "value" and type(value) == "number" then value elseif kind == "value" and type(value) == "string" then tonumber(value) else nil if number == nil then refuse(path, ("is %s, which 2.x could not use as a number of seconds: scheduling the first save failed, so every player was kicked when they joined. Set a NumberValue"):format( describe(node, kind, value))) elseif number == math.huge then refuse(path, ("is %s, infinite: 2.x's save schedule with it was erratic (some saves never came, others came after 10 seconds), and a 3.0 config module cannot write it. Set a finite number (1e9 never saves on a timer)"):format( describe(node, kind, value))) elseif number ~= number or number == -math.huge then config.AutoSaveInterval = 0 sources.AutoSaveInterval = path note(path, ("is %s: 2.x's arithmetic made every autosave due after 10 seconds (the scheduler's floor), which is what 0 does: carried as 0"):format( describe(node, kind, value))) else config.AutoSaveInterval = number sources.AutoSaveInterval = path if type(value) == "string" then note(path, ("is %s: 2.x's arithmetic read it as the number %s, carried as that number"):format(describe(node, kind, value), tostring(number))) end end end end -- ── FreeMode: HasPass's and GrantProduct's reading (ruling 4) ── do local kind, value, node, path = setting("FreeMode") if node == nil then config.FreeMode = false elseif kind == "none" then config.FreeMode = false note(path, ("is %s with no Value, so 2.x's HasPass, GrantProduct and IsFreeMode failed on every call: carried as off"):format(aClass(node.class))) elseif kind ~= "unreadable" and (value == nil or value == false) then config.FreeMode = false sources.FreeMode = path else config.FreeMode = true sources.FreeMode = path if node.class == "BoolValue" then note(path, ("is on: %s. %s"):format(FREE_MODE_3, FREE_MODE_STORE)) else note(path, ("is %s: %s. In 2.x, HasPass and GrantProduct counted any value but false as on (IsFreeMode did not). %s"):format( describe(node, kind, value), FREE_MODE_3, FREE_MODE_STORE)) end end end -- ── DefaultData: convertTree (ruling 3) ── local function convert(node, path) local out, setBy = {}, {} for _, item in ipairs(node.children) do local at = path .. "." .. item.name local value = nil if item.class == "Folder" then value = convert(item, at) elseif DATA_CLASSES[item.class] then value = item.value else note(at, ("is %s, which 2.x's Default Data skipped: not carried over"):format(aClass(item.class))) end if item.class == "Folder" or DATA_CLASSES[item.class] then if setBy[item.name] ~= nil then note(setBy[item.name], ("has the same name as the later %s, and 2.x kept the later one: not carried over"):format(at)) end out[item.name] = value setBy[item.name] = at end end return out, setBy end local dataNode = child(tree, "Default Data") local dataPath = rootName .. ".Default Data" if dataNode == nil then config.DefaultData = {} if not empty then note(dataPath, "is missing, so 2.x used only its built-in groups (Stats with Cash 0 and Wins 0, Pets, Purchases): carried as an empty DefaultData, which 3.0 fills the same way") end else local data, setBy = convert(dataNode, dataPath) if data.Meta ~= nil then note(setBy.Meta, "is named Meta, the profile's own record, which 2.x's build ignored: not carried over") data.Meta = nil end config.DefaultData = data sources.DefaultData = dataPath end -- ── what 2.x never read as a setting ── for _, item in ipairs(tree and tree.children or {}) do local at = rootName .. "." .. item.name local known = KNOWN[item.name] if known == nil then if not readAtOrBelow(at) then note(at, "is not a Datastore & Purchase System 2.x setting, so 2.x never read it: not carried over") end elseif item.name ~= "Default Data" then for _, inner in ipairs(item.children) do local innerAt = at .. "." .. inner.name if inner.name == "WipeStudioData" and known.WipeStudioData then note(innerAt, "is the plugin's Wipe Studio Data button, not a setting: not carried over. The 3.0 plugin keeps that button, which only the user presses (it refuses when Studio and live share a store)", WIPE_FIX) elseif not known[inner.name] and not readAtOrBelow(innerAt) then note(innerAt, "is not a Datastore & Purchase System 2.x setting, so 2.x never read it: not carried over") end end end end return config, notes, sources, refusals end ]]> -1 Keep 0 false /", with the SourceHash -- (plugins/Official/src/Shared/SourceHash.lua) of every published version -- of it. A game that edited one (a profile migration in Migration, product -- handlers in the server module or PurchaseManager) makes T.migrate -- refuse without force (migrate-custom-modified) and name the lines it -- changed; with force the 3.0 version replaces it and the edited copy -- stays in the protected migration backup. Move a profile migration into -- Extensions, and product handlers into a pack of the game's own -- (registerProfileHandler), before forcing. -- Config, DefaultData, DataStoreManager and StudioSafeId are never -- forced, whatever the edit (identity, below). A store version or a -- default hard-coded into Config.lua or DefaultData.lua goes back into -- the 2.x Settings, with the shipped script restored, before migrating: -- FromV2 reads only the Settings, so a 3.0 run on them would hand over -- the Settings' values (v1 when they say v1) and every player would load -- another store, or a new player another starting profile. A store name -- edited in DataStoreManager, which builds it (PlayerData_), or -- a key edited in StudioSafeId, whose GetSafeKey builds it -- (tostring(GetSafeUserId(player)); DataStoreManager only calls it), has -- no 3.0 option at all: such a game stays on 2.x for now. -- identity: those four scripts (plan B3b, B3a's Keep.identity): an edited -- or missing one is migrate-identity-modified, which force never lifts. -- For an edited one, its fix puts the published script back (a value the -- 2.x Settings hold moved there first) only once the user agrees, or asks -- the user; for a missing one, it puts back the game's version, or the -- published one when the game had none. -- lines: for each published SourceHash, SourceHash.fnv1a32 of each line of -- that source, trimmed, blank lines left out, in order. T.migrate names -- the lines a game changed with them. return { folders = {}, identity = { "ServerScriptService/Packs/DatastorePurchaseSystem/Config", "ServerScriptService/Packs/DatastorePurchaseSystem/DataStoreManager", "ServerScriptService/Packs/DatastorePurchaseSystem/DefaultData", "ServerScriptService/Packs/DatastorePurchaseSystem/StudioSafeId", }, shipped = { -- 2.0.0, 2.1.0 ["ReplicatedStorage/Packs/DatastorePurchaseSystem/Packages/Promise"] = { "6d53f836" }, -- 2.0.0; 2.1.0 ["ReplicatedStorage/Packs/DatastorePurchaseSystem/manifest"] = { "41abcf9f", "29093316" }, -- 2.0.0; 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem"] = { "125746ae", "76f959cd" }, -- 2.0.0, 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem/Actions/WipeStudioData"] = { "c40fe1b3" }, -- 2.0.0, 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem/Config"] = { "4799fdaa" }, -- 2.0.0, 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem/DataPath"] = { "9a0e2280" }, -- 2.0.0; 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem/DataStoreManager"] = { "b5d84f05", "87d9225e" }, -- 2.0.0, 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem/DefaultData"] = { "9d57bd9d" }, -- 2.0.0, 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem/Migration"] = { "fee866b5" }, -- 2.0.0; 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem/PurchaseManager"] = { "67b2ce1e", "db4c16d8" }, -- 2.0.0, 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem/StudioSafeId"] = { "0e18b354" }, -- 2.0.0, 2.1.0 ["ServerScriptService/Packs/DatastorePurchaseSystem/ValueReplicator"] = { "db814ea0" }, }, lines = { ["0e18b354"] = "3c753427 c810bcd6 05b18514 09d0d170 20cd1d0f 7eb45537 30f7e6c3 cefb0de3 10a9f11d f599469a 151c7975 07927118 c3afe8e2 287f8882 908c08c2 cda40c92 9d2186b6 5feef797 441d008c 981efa61 27432d93 3c9f6ce0 413c6390 4e2309d8 6a8e75aa 91b61305 2388b63d 1a766734 7366cffe de826e49 603d1850 6a8e75aa 214474fd 4200fc5e 9da72a3b 48152d07 e14cc924 6a8e75aa a471d96f 6a8e75aa d358500f 6bf29b69 9ab16ca5 6a8e75aa d42ab072 dfd92cc9 06607f19 ae9ca9f7 6a8e75aa 6a8e75aa b56319bd 6a8e75aa", ["125746ae"] = "d0719448 20cd1d0f 98406232 b3d4f3e3 1c32994d db84d82c 87d76e8a 2945fb82 d7ebc684 268ed75c 8f350bee b61bbb86 54f53612 3216ddbd 16715ceb 82ee11a3 3a5ca984 4a32db22 4e4e837e 37b2ccf4 edc7c74c 4260d70f f68b2746 f09e722f 20cd1d0f 85a7fb60 d336069b 86fb328e 9d6bd759 afb7f93d c02f2988 2f0aae2e d7fad579 c446fc21 4e348d63 2647636e 45adc5ef 9a5cdea5 e9ca72a8 418e3d10 06288af2 0efe1257 3e7dceeb 42a54e43 56d93dc9 4a0e8026 05089dba f9f856b8 2125b982 550e46d8 6e501d46 04850ac0 6b37033e 5e720d7b 4119abe8 11150029 2bbcaf42 e27e103d fb892158 4b350b0d a9f95eee 2be4336a a10afd2a bb3595c4 2e9b66b4 c23828a1 16b7f63f fc562313 bfc94e69 20cd1d0f bb2d425f 25b5b07e 49f2b000 ee17f303 50753455 155328b1 dcae1451 20cd1d0f 09118751 2c14a7e4 4b4b410d 946f1d29 20cd1d0f dbb13cdb b8c5d4a1 8c0376c0 d609b840 31e267af 4dee7c42 1dcd17de ac00e9d9 168a4e20 70f31494 cd3d1934 a0e4b848 f635e12e 04053bc7 444301f2 fc562313 0fcdcb0b fd10c18c fcbbe3a8 febff2ec 943136d7 5d171fa1 19c17786 4142fd39 8dcbc7b6 acdbf4c3 75d253c5 85ee37bf 6a8e75aa bc4e9d07 83434966 af464080 0611a931 ef66c34b 97119d0e 7ccea23e 6a8e75aa 4142fd39 4142fd39 4142fd39 949c3079 c154d2d1 cca8fd4a 7ccea23e 6a8e75aa 6a8e75aa c680565f 3c1a8f49 4142fd39 f6fd7e38 2cde96ce 4142fd39 0fa21658 b4725586 d413ff26 4649ffe6 3c1a8f49 6a8e75aa 1c09b1e6 6292109e b368953a 4142fd39 4142fd39 d2dcee57 da8bf263 447c7d2b d1a68d3d be713eb3 afc65b37 30eaf820 5dcf8711 6a8e75aa 05fd2b4d 19ae59ad 6a01fdab c8e08831 4142fd39 8dcbc7b6 21fbc03b 6a8e75aa 2dc48a06 6a8e75aa 34a6f48c 8cf01121 6a01fdab 8d4e5fe0 4142fd39 0b6535ac 274bcd3f 6a8e75aa 8bba9d8d 6a8e75aa cc480872 e0f34ef7 6a8e75aa 67747202 ae9f81f6 a35cbcc0 f3925f10 58fb2912 d9e8703d e96dfe14 f464e0e4 dfe59438 a60249f4 55a0fea6 39d262c6 c23975ba 901ca274 22538f18 f80c48a8 6a8e75aa", ["29093316"] = "67747202 b3e58952 a849de35 c30f3f58 f80c48a8", ["41abcf9f"] = "67747202 b3e58952 836bce0a c30f3f58 f80c48a8", ["4799fdaa"] = "900e069a f93c64c9 1065125f ac8af668 e8c67b5a 3a653c00 84e14f9e 9f628ce1 f4661a2a 986476c3 62eb3766 6a8e75aa ea58ed95 11996737 20cf8142 4142fd39 a07993dc 6a8e75aa 64c4294d 67747202 80bd761c 15fcb9e1 e831ea40 c095e8af 25270aff 19311164 ece6bb4c 2098509b 3716d3bc 67680a70 2797058c ff5627cc ff5627cc f80c48a8 6a8e75aa", ["67b2ce1e"] = "e233ae5b 20cd1d0f c8439a6b 1230380f 2b4e144d 85d6b201 56a15d07 ccef3773 f99dca07 6e11d991 20cd1d0f 709d2044 38f82c17 d15de5c5 2f66117b 801d381e b3299c55 d272eda8 bb3b6157 e05a17f2 506a6220 be9864a4 e364f993 adc9d02f 0a44958c 20cd1d0f f82823b6 5e576c91 3b0b9c3e 20cd1d0f 75da84e0 17665512 cabc49f4 6db6e7a6 990b1de8 cb81d3f8 6a97195c 20cd1d0f dea4a6a9 35a3322b bd53e97d 23861502 6df6b94a a47c423f f74033ac 497b269c c28fb20e bb35904e 28996320 b3f27fa2 c6296445 be4a6626 88889bd4 44f98f29 8f269f16 6a8e75aa 9fc3c0c0 8fa69177 959b5822 c0c24f05 6a8e75aa 6a8e75aa c76d0cb4 20cd1d0f 674430bf 2b3b79f2 1ff6d57f bcacea1e 289c2c87 cc21cad6 8c2ae597 ff4989a2 7132c7ee ef10ebf7 3098c15f 23873069 c2efbc30 471b4c26 1f87d7a7 7d51b023 85ee37bf 6a8e75aa 98bc3cc6 8dcbc7b6 c863ecfa 6a8e75aa 6a8e75aa 09b8e058 4adae112 4dc10082 870aee06 f9237ee6 c7bb1694 7d16d120 9ba0f388 06a72756 dff43f39 be145507 71978316 6a8e75aa 472c1066 9910f592 abe8e280 d26ff3ee 6a8e75aa 6a8e75aa 64b30b0e 6fb65bec 0853accc d1f215cb 256f545a eb6a66ed 9910f592 7577c6ef 760df139 7fade65c 00ad3ace 6a8e75aa b2890ca6 20cd234a 8db21a97 005c426b bc04c08d 6a8e75aa 582f38de f502fb56 42a54e43 e4d049e6 d244eea2 0c9869ae 791ee20c 80c3675a 6292109e cd5a55c7 d636f5e3 0df2bb73 0ff1dfc4 4142fd39 4142fd39 6a8e75aa 977263bc 6a8e75aa 836eae2e dc14b258 4735b1c1 9b6b837d 6ecdb87c c3f07f56 0ad72f75 08552835 67a84083 0192fb15 6d7cab0d 6a8e75aa d0ee1731 6a8e75aa 55537dbb 1e3c639f 3e7dceeb 2033ca59 401c5c57 a107f719 6a8e75aa d4d674be 42bd1d3a 7c6b8271 a107f719 6a8e75aa ec68f34d ec1f8dca d35b3226 38d1db7d 14869b67 db61a1f7 493272bd fbbbdf6c 13b148a6 d69eb187 0da83f03 c83deb5b 4fbcd04a f855ab84 6a8e75aa dcd62af8 08552835 35a788ef 823c3047 9e20ac4c 45f5bef8 036540ae f855ab84 4c792af7 8f579753 6a8e75aa a107f719 6a8e75aa fa9329cb 7de2b239 46f8fc83 a66b4569 6292109e 42a54e43 3e7dceeb 0b5c9f18 fdb7e067 e51df417 d0136e34 352459cc 6a8e75aa 4142fd39 720c0d79 d0d06229 4142fd39 4142fd39 4b616dde 6a8e75aa 67747202 df18f65c 5dcf575c f5db9444 f80c48a8", ["6d53f836"] = "11c35325 fb0bccc1 3006c30f 9e8c6981 8f4a7f26 5d3fee22 4eac4425 c10a4440 a0513863 bc04c08d 6a8e75aa 303756c3 c41ad9cd 266155ba bc04c08d 6a8e75aa 6a8e75aa 3568a3c0 6a8e75aa 11c35325 6bf1d256 3006c30f f5ba7415 6f741252 d6c2029e de100705 6a8e75aa 5b137928 acc094bf 435a826f 444301f2 f0cd180d a7b04b20 444301f2 fc562313 6a8e75aa 2b7f70d8 b7d33f41 783730e7 9a2db465 1c8700bb 2d936176 555dc8de 621cd814 706550ef 3f6be881 04dee8af bc292080 248fa23a c052577a 7a997c2d f80c48a8 b7c1e0c8 1f7eded0 51720ad7 2eee07f7 aa989ad6 0eefe350 6c1fa810 3fff67d6 a419acba 4ad02fee 35053d65 8315f201 6a8e75aa 4f1b9e76 b30a3e76 bcb448d6 0ea76c25 4bc77df4 6a8e75aa 6a8e75aa 3568a3c0 6a8e75aa 52fbdc36 435bbe06 1cf984e3 6a8e75aa 30d7c1e0 51720ad7 9c7272f5 0a075a34 6a8e75aa a40b2c95 e973262a 798b4ab2 38fa98cd 6a8e75aa 9442abf8 6a8e75aa 27ad07f6 e9763b56 bdd39a92 f80c48a8 785e9f36 1eafb40e 45144e53 a1dec9d6 df91f3ff 45b51286 e4f52759 2c0c9a84 6a8e75aa ab86394a 6a8e75aa 6a8e75aa 11c35325 0a6e02bf 452b6a30 3006c30f b76e0a6a a465d5ad 6a8e75aa 11c35325 5487b004 3006c30f cd5fce96 4fbcbe7e 6a8e75aa c6e66ac5 cab336dd 9d8a9735 82e3a9af 20d8d38b 2f0f8529 656d65a4 6a8e75aa a53be8d0 b2c10c27 4035de2c 0c47547f d21469b1 fc562313 6a8e75aa 6a8e75aa 11c35325 0e1420e8 3006c30f f2b973c8 243928f9 6a8e75aa 11c35325 d9e89c1d 5516648b 3006c30f 49e55b67 9c0091aa 2d36f3e1 2aa424e3 857d2478 bdbf5bf0 03bd1ef1 6a8e75aa 6a8e75aa 6a8e75aa c24c6b24 4c823a04 6a8e75aa 2b7f70d8 aae60e4c 48f2afe4 aa9033d6 51e0d08d de77eeca 11be7598 eda809e0 e6f4c511 2d936176 2b7f70d8 91190c6a 51e0d08d 117ed79d 26014cbf 0b547c5a 2d936176 2b7f70d8 2a616bf5 67c37b83 392e958e 2afce7c0 2a554b8d 2d936176 cfe454ff 3de14b1c 83cdd7b7 87e38aae 76290058 e31db683 f80c48a8 06ad9dd7 edd342d4 902c7795 1b3c2b21 4e1ea35e 6a8e75aa c45413b8 b117ceaf 71bb73f2 73a44191 78e2ef9a cf58a123 065fbb98 33154d14 0b11639c 20a5d17e b7061ca7 98c5ca0d 541e5f45 5f00cfab 4ff4c787 5dbeed6e fcfab827 81f9c91d ad206658 7de9c322 e9fdc5ae caaea239 72271699 efa01463 46f6cc0e b9e1bd5b f80c48a8 49f17871 958f2bae 6a8e75aa 7f877e8c 8d40a911 de8649d9 6a8e75aa f63028c4 d0fcf02c 6a8e75aa 114c8628 1f249f8d 5d380850 d15cf4be bdbf5bf0 98a0b879 6a8e75aa 6a8e75aa b50ce522 6a8e75aa 7b6b052c 15710327 8dcbc7b6 03bd1ef1 6a8e75aa 4142fd39 fa00f2d9 4ffc77af 6a8e75aa 2b7f70d8 d2d3db67 7e9e8353 76789316 1fd5c767 c762b189 13132829 df6dc906 f01ca60f 4142fd39 6a8e75aa 46a0a346 8e2a7297 f6f736cf f4c36889 4cca8adc ab58554b d3b89b47 0bc1c830 b2457bd3 ce6f8fdd 593b957e 3e0f45cb de8dc7b5 20bed5dd a3f060b0 fd78cb44 2d936176 4618d328 4cf5cd44 6a8e75aa ceef82db 1087f6ef 6a8e75aa 2b7f70d8 0e06c55b 3981fe03 1fd5c767 0949695c f60b4186 9dd1f8af d7d22751 4142fd39 6a8e75aa 8e2a7297 a3f060b0 fd78cb44 2d936176 a565438a eda33b7c 0efb1261 752c6f2c cab8a330 a0112362 72c622e4 523b0d5d 8dcbc7b6 03bd1ef1 6a8e75aa 4142fd39 4142fd39 df4215ea 6a8e75aa 6b9feddd d931efe0 2b7f70d8 91b6529b 1fd5c767 367ae400 9adad9c1 0eeac6ac 70e5a262 bdbf5bf0 23205798 aa72d8e1 6985f0a3 0ba2c106 4142fd39 6a8e75aa 6a8e75aa 8e2a7297 63ead650 f0e81c8a 2d936176 6b070bef de51edc7 b6023d07 d4d4d968 4142fd39 6a8e75aa 2b7f70d8 74433329 593b957e b5b80a43 20bed5dd 63ead650 f0e81c8a 2d936176 6c5284f2 de51edc7 455f42c9 54b9bacb 4142fd39 6a8e75aa 11c35325 9f8dd8ad 90fd422c 3006c30f 5a949b3c a82f3bc1 cae5263a c55ab684 4142fd39 6a8e75aa 2b7f70d8 6a9b201d 579a01cd 453dda27 20bed5dd 1fd5c767 1f94a834 3a42cac3 4142fd39 f79c1a89 9c79b39a 4142fd39 a3fbdad6 32678bf5 4142fd39 8e2a7297 69ae1a3f 0e0f853f fd78cb44 2d936176 42943167 70b23181 6a8e75aa 11c35325 792ef6c9 b98983a2 dd75f3f5 3006c30f 60fe08b5 e841fdc3 ccce3001 6a8e75aa cca0229e d0736eeb 9d23d0ec 3eed316b 191ac329 6a8e75aa 6a8e75aa 2c280ef8 ca2c9f47 dd7afb87 6a8e75aa 2b20b3be 6d8e36c2 873a54bb 95ef3e59 9e4c809e 0e266a21 b5a32e20 b0b0fc9a ccdddcc0 9385408d 4aec368f c03f3d35 6a8e75aa 6a8e75aa 6368474a 3cab69ce 5a258941 85ee37bf 6a8e75aa 50f0f5b6 038e25b6 a0059ddf bdbf5bf0 cc108a3b 6a8e75aa 8f5f527e 5eb02042 6dfcd46a 3b348320 6a8e75aa 6a8e75aa e23c8ecf a84e2b41 4aca513f ef40808d d91b342d eaf19153 7ebe8277 a72ab9e2 9b197e7e 3b348320 5eb02042 f756a5c3 6a8e75aa 4142fd39 6a8e75aa 5a258941 3b348320 6a8e75aa 4142fd39 6a8e75aa 2b7f70d8 4df7dd62 4ae8d9e0 fc56b70d 579a01cd 6b10ef7b 20bed5dd ca644442 1fd5c767 183130a4 f135b93a 5458b49d 3c1aa640 f80c48a8 f80d8196 8e2a7297 6b79b8d1 e57eb590 2d936176 c00dda30 985776c6 6a8e75aa 2b7f70d8 d046e27d c862a4d7 3ef06c16 1fd5c767 5ec19a19 1d611661 3165e1f1 bbb93e85 bdbf5bf0 88604186 ced0766b 7216f462 4142fd39 6a8e75aa e1bb45a1 8e2a7297 0cf8c3b5 4ccf2eb3 00441bc4 421967ea 2d936176 af21e40b 0d98675d 6471cf54 24fea982 e4f007c9 af0bb3d5 68d97b55 4142fd39 7a26aec4 25607481 4142fd39 6a8e75aa 2b7f70d8 a06d068d d54705d4 1fd5c767 183130a4 f135b93a 5458b49d 3c1aa640 f80c48a8 ea608153 8e2a7297 6b79b8d1 bda423ac e57eb590 2d936176 79b8ae12 57286126 81c1f29d 6a8e75aa 2b7f70d8 b829d85f 29d3c264 1fd5c767 183130a4 f135b93a 5458b49d 3c1aa640 f80c48a8 dcb734c6 8e2a7297 6b79b8d1 e40b37fe 2d936176 abdc9369 80663216 8ad7fc22 4142fd39 6a8e75aa 2b7f70d8 f021e14b 1fd5c767 183130a4 f135b93a 5458b49d 3c1aa640 f80c48a8 bb8ecab1 8e2a7297 6b79b8d1 8f6c8ed4 2d936176 5c411443 e841fdc3 d271a9ed 6a8e75aa cca0229e d0736eeb 9d23d0ec 3eed316b 3d1b7827 6a8e75aa 6a8e75aa 2c280ef8 2e195a8c dd7afb87 6a8e75aa c907ae75 6d8e36c2 1ba7043c 95ef3e59 9e4c809e 0e266a21 7b68f536 6368474a 3cab69ce 22d8e342 fb7b7da6 8d3e67ee d88ffa8f 6a8e75aa 6a8e75aa 11e076ed 4aec368f c03f3d35 6a8e75aa 4142fd39 a84e2b41 4aca513f ef40808d 24a06f50 eaf19153 4142fd39 6a8e75aa 4142fd39 6a8e75aa 2b7f70d8 274b3fae 2eea43c7 f091db3d 282cc937 20bed5dd 41c940f2 1fd5c767 183130a4 f135b93a 5458b49d 3c1aa640 f80c48a8 0df90677 8e2a7297 6b79b8d1 e40b37fe 2d936176 2c1d430e 974541e5 9d23d0ec 63f3087f 6a8e75aa f9223c83 95ef3e59 4f01fd66 9385408d 4aec368f c03f3d35 6a8e75aa 6a8e75aa 967134f0 9c0091aa 3b348320 26870684 e30e7fdb 6a8e75aa 6a8e75aa d5d2e0a9 85ee37bf 6a8e75aa ef40808d ee81c500 6a8e75aa 19996d23 3b348320 6a8e75aa 4142fd39 6a8e75aa 2b7f70d8 740f0bc3 5cb19462 c49bbdba 579a01cd 5781177d 3135a9dd d519d24c 20bed5dd 1fd5c767 f6d400a4 e1cc7719 6820cc2c 80eb4b04 2f44c391 07b0930a 91de3fea 83956726 4142fd39 4142fd39 11c35325 01bda1e2 b241ddf6 01bda1e2 3e11b9b8 01bda1e2 bd034b27 01bda1e2 3a94e573 3006c30f 8e2a7297 08f5b404 eea0fc02 75a377d2 05c8cfdb a3f6c657 eb683e95 ffc7d1c3 29df9228 74ef3ac2 4ccf2eb3 a8ac9742 7871830f 2d936176 0353e9a5 4fc6139f 3446e864 f9223c83 e20deddb d956136a a649b3df 9385408d 178388e1 09e382e4 6a8e75aa 6a8e75aa 11e076ed fb916979 3b348320 4142fd39 2dfdea49 db1b22a7 5a95641a aa86bd54 1426e065 b3f94f1c bc0b9fc8 e9672e54 604dd0b7 3b348320 918d2f01 2614d16e 705d7e09 1ff7bb47 58cda0d2 c2c8df85 712e8af4 ffd77678 7599744e 3d266837 3b348320 88e07eac 6a8e75aa dc3530d7 2726bca0 c5f3cf21 4142fd39 5bbd5def 9ba854f6 bdbf5bf0 767ac30a 6a8e75aa 6a8e75aa dbea7fdb e9672e54 3b6f30eb 18aa9850 1a63a6d7 3b348320 3f021ee6 6a8e75aa 6a8e75aa 034ff4cc 85ee37bf 6a8e75aa aa776b50 0d5fe2d4 18beca5a 1a63a6d7 3b348320 5a652d36 6a8e75aa b06d067f 6a8e75aa 7f086ae0 4142fd39 6a8e75aa 2b7f70d8 f7b6f29c 6ff10101 71273485 2d936176 52b46cf8 a5a87434 3568a3c0 6a8e75aa a94bddd2 2ffc7382 d2d24248 bc04c08d f50843c5 0066d1b7 1c0554bb 54554c87 b04d4c40 37e42f8c ee2a61d7 e522e976 e295bd3c bc04c08d 6a8e75aa 3568a3c0 6a8e75aa 2b7f70d8 a1a4993e 28db2aca 579a01cd c1b1acd0 20bed5dd 1fd5c767 9264897b 1b335794 8e2a7297 1fd5c767 0fe2bf81 9456a041 4142fd39 8e2a7297 b2c3be55 51842be0 2d936176 406688f4 9c0091aa 70b23181 6a8e75aa 6a8e75aa 2b7f70d8 3bdf8a30 b8ae4fb5 2eea43c7 14a0dc92 20bed5dd 1fd5c767 112926fb 8e2a7297 5b3ea430 51e0d08d f1cc009a 036e4125 2d936176 621cd814 4ac79ab3 0944200b becbc766 cab8a330 3e738f27 493a2768 11214e97 74eac621 04970b7a 8e796e53 6a8e75aa c907ae75 3a55d0ca a27532a2 346f0ca6 6c654c74 5cd9fdd8 527a24fc f80c48a8 1f1bcaac f5e2410a a0112362 ed762409 c65961cc a4f85d50 a3c795f2 ffe34648 72c622e4 c6a5f3ad bdbf5bf0 32b3afcc 6a8e75aa 66351760 6a8e75aa 4142fd39 8c153441 0171b505 b96e5a2d ff4f363e a4f85d50 ed90243a 6d42ee56 95cb2aa2 8f14849d 6a8e75aa fff5bd4d 729bc35e 9ba2e66e f9f3f84a bf870704 e3728904 6a8e75aa bdbf5bf0 a736fc1c 39e9830d 2bf8fe6d f5e2410a 6a8e75aa 6a8e75aa 11e076ed cb748c1e dc727c2d 79986195 bbea7ff2 72c622e4 c6a5f3ad 8e594b80 7927fb27 6a8e75aa b0c06dd3 bdbf5bf0 31a78c5d 78e0dcba 9b9a3151 f9f3f84a 2cc4ae7d 6a8e75aa 6a8e75aa 4142fd39 4142fd39 6a8e75aa 6a8e75aa 2b7f70d8 4d94e839 3af24f93 1fd5c767 2eb595c0 5e488611 7939de9a 04e50d7e 1368fd46 271b768b bdbf5bf0 06fe16c9 6a8e75aa 4142fd39 8e2a7297 7f3501d0 1fd5c767 92834940 a4beca30 bab707ed 75a376fe f8c5577d f909ebd0 2c0c9a84 d174680f 2217e942 fc562313 8e2a7297 f1cc009a 0eb55228 fd78cb44 2d936176 f8b97203 eda33b7c 32d1d888 a4beca30 f5c2af14 b990c097 b69740ad 1ff7bb47 5e03bdfc 77c5eeb2 c9c5df0d ffd77678 cb416e0f d174680f 57409541 fc562313 6a8e75aa 2b7f70d8 ee52df23 9e5e29b1 2d936176 61449b17 2c6cd7ae 6a8e75aa 11c35325 175ca723 d225d7aa 3006c30f 6845aec1 5e5fd0ca dd0fa50a 5d380850 f205c296 c03f3d35 df4215ea 6a8e75aa f76272a9 2b20b3be 3cc40580 ad72d145 e8641e07 c1f3dde2 bb311835 6a8e75aa d17906f1 a961839b bbbc4cc9 6a8e75aa 8505c37e 42525a14 9982f52d aa5dbd95 11e076ed d6162c6f 7404922e 8505c37e fb6213d4 95285fc1 6a8e75aa 4142fd39 0d2d3ffa c23bdcdc 343a1fa8 b246ff10 f928c899 d1ecbdd3 6a8e75aa 06bfb24b 6a8e75aa 2b7f70d8 9e53e97c 2eea43c7 21dd5052 20bed5dd d2034492 46e1d5ed c5fb4402 12da8ff9 fa2630d1 20bed5dd 3ec142b3 4e8590e1 f0e81c8a 2d936176 370bcd42 1215d72c 28f65984 18871ea3 6a8e75aa 2b7f70d8 e164bcc6 6505694b 2eea43c7 21dd5052 20bed5dd 6d5359a2 c5fb4402 acf5a040 fa2630d1 20bed5dd 7c1bc452 f0e81c8a 2d936176 a5986fdc 107b05c7 0fedca8f 6a8e75aa 2b7f70d8 601cd4b0 1fd5c767 e38e1fa0 1cb18968 cea45ba0 3c28da0a 4142fd39 8e2a7297 0dc720be 835dd875 f0e81c8a 2d936176 6fe0a111 fbc27f9a c45fec88 a5c3d39a 0189ecb6 de51edc7 06c112c7 8f27b71d 4142fd39 6a8e75aa c5f3cf21 4142fd39 6a8e75aa 2b7f70d8 8d8a949c 1fd5c767 1d7beb11 8e2a7297 608e010a 1fd5c767 3b7b18ad 5b5b8924 4142fd39 8e2a7297 da33f071 9ea27dec fd78cb44 2d936176 64bf81fa 69c11ce7 de51edc7 d766fd7c f1be7d73 4142fd39 6a8e75aa 2b7f70d8 732966e9 1fd5c767 7bbc3745 8e2a7297 608e010a 1fd5c767 3b7b18ad 0052b4fb 4142fd39 8e2a7297 593b957e 8aa4a4f2 20bed5dd 4824c59c fd78cb44 2d936176 de01a4b7 de51edc7 d766fd7c 8f27b71d 4142fd39 6a8e75aa 2b7f70d8 860951a5 b72592a5 177580c7 1fd5c767 c03f3d35 8e2a7297 2d936176 016bed57 4d73dff9 85ee37bf 6a8e75aa 6cb2219d b30314ce 0cb576a3 6a8e75aa acbab9b7 1b6c9baa ff4d44ff 6a8e75aa 294d2662 43b3a180 6a8e75aa 5df5f5c5 6a8e75aa 11c35325 b140f059 a9ef7e86 3006c30f f5d670ad 4d73dff9 85ee37bf 6a8e75aa 82f47fe5 3dc258e0 dfffb2b6 6a8e75aa 6a8e75aa 11c35325 b90cd321 91edb6b6 3006c30f db81b290 5e5fd0ca 3b4d166b f2f85a1d 11e076ed 683ad753 ba609ab0 28a5c717 54e38c9a 91d0b0ca f6868097 6a8e75aa 4142fd39 db3ceda3 0cb0890a 99319901 65c18aa8 0189ecb6 f4bc4590 8bf3fad0 8613f1d9 d39c72db a6b39466 6a8e75aa 4142fd39 49e80201 f756a5c3 4142fd39 bdbf5bf0 a6b39466 6a8e75aa 6a8e75aa 6a8e75aa 8505c37e 9388d378 1168512e bdbf5bf0 50e1a520 adbda261 6a8e75aa 4142fd39 df4215ea 6a8e75aa 2b7f70d8 35c2577e a74ec31b 9567aca9 7faf5afd c506751b d91b09ec a7c9af9a eacc79fc 8845ad94 dd7f1021 95ee2d9f 24e01084 392ad8c4 75d9a79b 6f1f89ad 1d84cb42 909688d7 424aab7f 6da2ef20 20bed5dd 1fd5c767 6074637c 1905b1bf ceee1490 448318f1 76fde82c 4142fd39 e571fc0f 788dfbe5 4142fd39 840e14d3 1cf5e7df b86874b4 4142fd39 8e2a7297 ba7f9583 f0e81c8a 2d936176 f021bfa1 1b2b7e37 f010c0de 6a8e75aa 2b7f70d8 87536516 68294ae0 da33f071 9ea27dec fd78cb44 2d936176 fa23fbf1 4a84fc5c de51edc7 a0a0ec81 f1be7d73 4142fd39 6a8e75aa 2b7f70d8 768ad74e 1fd5c767 63c5ed84 8e2a7297 608e010a 1fd5c767 cfe0a8f6 0052b4fb 4142fd39 8e2a7297 4824c59c fd78cb44 2d936176 4a3f74dc de51edc7 a0a0ec81 8f27b71d 4142fd39 6a8e75aa 2b7f70d8 57a363d7 0309c82d 9c71f816 c402ebcb 2d936176 b47a89bd 5e5fd0ca 8505c37e f896b653 645ba277 840e14d3 b67669da 4142fd39 ab5d2971 28b26b0b ededc4f4 176d19f7 2c0c9a84 0de53d6d 6a8e75aa 859e9295 c615f26c b246ff10 c615f26c 6a8e75aa 2c6cd7ae 6a8e75aa 8e3eac7d a24b4022 6a8e75aa 2b7f70d8 b6cf0b02 593b957e ed6a0e71 20bed5dd 1fd5c767 bb0fafbe 94330bbd 62b6cc3e bdbf5bf0 c224042e 6a8e75aa 8e2a7297 0309c82d e918c5bb c402ebcb 2d936176 dc2799ab 5cd4ac33 6a8e75aa 5c5922a4 7bb8666d 07bf0b8b 6a8e75aa c5f3cf21 6a8e75aa 2b7f70d8 8e28cd07 1fd5c767 a523953a f1397a9e 4142fd39 b0316b10 c224042e 6a8e75aa 8e2a7297 918ee7f5 1fd5c767 07078701 8e2a7297 76bd5d90 60b4517a 0309c82d bf376142 2d936176 26d2a150 07e924f2 6a8e75aa 6b9feddd c6f56c78 11c35325 4db8253a bc39474d 3fc5c80e 052010b1 3006c30f fbc49713 8505c37e 3e8c57ef 6a8e75aa 7b481ee0 a492a96e 6a8e75aa f4e2e2b6 4d73dff9 a47f2ef8 9fcfa7d5 6a8e75aa 85ee37bf 6a8e75aa e7328304 a47f2ef8 7717771f 272d3fc8 17cfcbce 715669c4 21b11959 2c0c9a84 99d5b651 6a8e75aa fce1f15c 76c17aa6 de8649d9 7ebe8277 6152d4be 2acfbfb7 ff9aff99 3028d47d 2883aa2e 4035de2c 756b3e03 fc562313 6a8e75aa f3fc6a48 df6c9d90 ce9ec389 ef50e619 1ff7bb47 b6acf892 21b11959 ffd77678 7599744e 6a8e75aa d0fcf02c 4142fd39 64f6fd55 dfffb2b6 5654bc88 e834d0da 2237bb56 39a4b735 6a8e75aa 85ee37bf 6a8e75aa cab7184a c8401158 fd7882ed e11e8937 f48b1a90 6a8e75aa 5df5f5c5 6a8e75aa b3c7112d 4d73dff9 85ee37bf 6a8e75aa 13851818 c8401158 f2dcd3f8 37cc9017 fd7882ed 5f2d948a f48b1a90 6a8e75aa bdbf5bf0 441f427a bbf71eb3 f9f256c7 480c32f8 94b1e648 35403d08 dc422f48 f5c3499d c510ace9 85ee37bf 6a8e75aa 58d0b09b 0bc24fc3 5e11fa95 47296cef 6a8e75aa 8de870f2 3e8af42b 85ee37bf 6a8e75aa 99d5b651 5836235e 6a8e75aa 5df5f5c5 6a8e75aa 11c35325 1cdbd7d2 4fdccdc5 2465dea3 3006c30f 7555ca96 98da37e0 c88a9f4a ef569fe9 b3a04df6 bb69fced 6a8e75aa a2742294 c162ec5e 1f33005b ff88c045 f9c70e17 5d105068 f3c5053d 6a8e75aa c4c60622 6a8e75aa 2b7f70d8 ba4d8b4d 1fd5c767 d4a3a423 0a888924 4359199d ce1db5c2 4142fd39 8e2a7297 a431d27c 1c8598ab fd78cb44 2d936176 19250f1d eda33b7c 859e9295 1337464d c5f3cf21 4142fd39 bdbf5bf0 f5c2af14 8a4a1225 f6eefaf3 61aefe51 cb416e0f 6a8e75aa 6a8e75aa 2b7f70d8 a7d7ee56 8d488841 1fd5c767 008283b1 23205798 7d0c8a65 ee2387ef 1336f302 b95e0ab3 bdbf5bf0 0ba2c106 6a8e75aa 4142fd39 6a8e75aa a30fd9ed d0b51cc2 8e2a7297 74ef3ac2 31011c82 2fd2f153 352a3407 e40b37fe 2d936176 8eada4ea c26cd754 8f0ddf98 d3225c68 585683e7 6fc9be61 0c937fc9 bdbf5bf0 a6b07fb8 6a8e75aa 4142fd39 6a8e75aa 2b7f70d8 51c06e92 9977ba8f 8d488841 7c6a0b98 31011c82 2fd2f153 f1cc009a 352a3407 e40b37fe 2d936176 f89cb330 c26cd754 4a4c70d1 69eb7324 d3225c68 585683e7 6fc9be61 c84b27ea 44c470a3 bdbf5bf0 a6b07fb8 6a8e75aa 4142fd39 6a8e75aa 2b7f70d8 411b9eb5 8174b818 aba0c6d4 c5fb4402 a1ce242d 20bed5dd 1fd5c767 ead0dbe5 3c2dcaaf 88f5fa8d e84dfa5b 4142fd39 8e2a7297 74ef3ac2 ee4abcc2 cb342d49 64017422 2d936176 23687686 514dd888 bc04c08d 6a8e75aa c907ae75 cab8a330 89a3933d 6db4202d 72c622e4 c6a5f3ad 6a8e75aa c2692f38 9c8ab947 7e9e59ba 364b0993 7a4cd39b 64c42ea3 97b9db94 d840801d 87ad2b70 bdbf5bf0 a83b0489 6a8e75aa 6e8f655c fce925ed 6a8e75aa 4142fd39 cfeaa3c1 801e9038 6a8e75aa 6a948ab3 4142fd39 6a8e75aa 2b7f70d8 cfe66874 0e70e4a0 a37e289a 7c6a0b98 9cd8f2db f6e616e3 2d936176 fc3cee3f 82744798 9d2186b6 d7edefb6 068f196d 2a4aaf72 6a8e75aa 6a8e75aa 6a8e75aa 0feaf18a", ["76f959cd"] = "d0719448 20cd1d0f 98406232 b3d4f3e3 1c32994d db84d82c 87d76e8a 2945fb82 d7ebc684 268ed75c 8f350bee b61bbb86 54f53612 3216ddbd 16715ceb 82ee11a3 3a5ca984 4a32db22 4e4e837e 37b2ccf4 edc7c74c 4260d70f f68b2746 f09e722f 20cd1d0f 85a7fb60 d336069b 86fb328e 9d6bd759 afb7f93d c02f2988 2f0aae2e d7fad579 c446fc21 4e348d63 2647636e 45adc5ef 9a5cdea5 e9ca72a8 418e3d10 06288af2 0efe1257 3e7dceeb 42a54e43 56d93dc9 4a0e8026 05089dba f9f856b8 2125b982 550e46d8 6e501d46 04850ac0 6b37033e 5e720d7b 4119abe8 11150029 2bbcaf42 e27e103d fb892158 4b350b0d a9f95eee 2be4336a a10afd2a bb3595c4 2e9b66b4 c23828a1 16b7f63f fc562313 bfc94e69 20cd1d0f bb2d425f 25b5b07e 49f2b000 ee17f303 50753455 155328b1 dcae1451 20cd1d0f 09118751 2c14a7e4 4b4b410d 946f1d29 20cd1d0f dbb13cdb b8c5d4a1 8c0376c0 d609b840 31e267af 4dee7c42 1dcd17de ac00e9d9 168a4e20 70f31494 cd3d1934 a0e4b848 f635e12e 04053bc7 444301f2 fc562313 0fcdcb0b fd10c18c fcbbe3a8 febff2ec 943136d7 5d171fa1 19c17786 4142fd39 8dcbc7b6 acdbf4c3 75d253c5 85ee37bf 6a8e75aa bc4e9d07 83434966 af464080 0611a931 ef66c34b 97119d0e 7ccea23e 6a8e75aa 4142fd39 4142fd39 4142fd39 949c3079 c154d2d1 cca8fd4a 7ccea23e 6a8e75aa 6a8e75aa c680565f 3c1a8f49 4142fd39 f6fd7e38 2cde96ce 4142fd39 0fa21658 b4725586 d413ff26 4649ffe6 3c1a8f49 6a8e75aa 1c09b1e6 6292109e b368953a 4142fd39 4142fd39 d2dcee57 da8bf263 447c7d2b d1a68d3d be713eb3 afc65b37 30eaf820 5dcf8711 6a8e75aa 05fd2b4d 19ae59ad 6a01fdab c8e08831 4142fd39 8dcbc7b6 21fbc03b 6a8e75aa 2dc48a06 6a8e75aa 34a6f48c 8cf01121 6a01fdab 8d4e5fe0 4142fd39 0b6535ac 274bcd3f 6a8e75aa 8bba9d8d 6a8e75aa cc480872 e0f34ef7 6a8e75aa 67747202 ae9f81f6 a35cbcc0 559bbf86 dc884718 6213b9e0 f3925f10 58fb2912 d9e8703d e96dfe14 f464e0e4 dfe59438 a60249f4 55a0fea6 431380e8 39d262c6 eda25666 c23975ba 901ca274 22538f18 f80c48a8 6a8e75aa", ["87d9225e"] = "d4911a9e bde3efe5 e5031d8c 6e8c17a4 bd675240 ba270482 79fdc91a f80c48a8 ca48da0d 12b8ac69 14a1bee8 e71cc62c 963fdbb7 ed312dc5 6a8e75aa 1d137568 24d47f3c 49b2c51b 365fe857 6a8e75aa 9587d575 6a8e75aa e9d0f99f 3076988c 733ad758 ce0fb68f 4aafc34c b60bd732 6a5ab244 530f2c69 20cd1d0f f0e3f39f 9470d276 7830e2d8 5f86a9cd 559a8b08 b4a1edc0 4d6cb3ff f70b0c4f 8c959a55 f76be948 8f41b275 7676ec7c 968b5dfd 6a8e75aa d65a35e9 5f0b7eec a2b41fca 4c3f7dfa 267d3ad7 7bee8f50 7b787181 72f23da8 118a722a 6a8e75aa 754df234 78e2e509 514bc83e 91e61f4f c95b4bc4 1b62353a df1f5414 85ee37bf 6a8e75aa d178b79b 9b9ff6de 6a8e75aa 43a6c0bd e9d2131a 6a8e75aa 73b4a192 1cc8e44a 3776c40c 75cea83d b4e7ecbf b2cafa94 9542704b 9186afbf e1afbc5e 4142fd39 caaddc97 6a8e75aa defdec4e 9f712bee 49499c3b 8b55aa86 a449e666 0b1d0211 b2770640 29f541f2 91f9079b df1f5414 bf5561f8 6a8e75aa 10d0ba33 fd0119cb bf5561f8 6a8e75aa 7e5f056a 969c7020 d8297aee a39d22a2 5a277980 98dacace e23dc48a 92ebfad0 6a8e75aa 4314ae0a 309356a0 d6b784ea e252e819 2b917dd2 6a8e75aa 73b1bc59 c4ed9a38 15a8ddab a925c8cd fc6fefbb 15dca99f 64afa155 4142fd39 6a8e75aa c5e0276d 8e9e80de 6206674f fd0119cb bf5561f8 6a8e75aa 9b283c8e 760c8cc9 6a8e75aa 24c3b202 6a8e75aa 7903339d c6ab66c7 d40efdc5 f26a15d7 8d48ace8 fbb40d0f a5efb97c 0b9ad786 d1d1c752 977263bc 6a8e75aa 7451b236 6a656839 df1f5414 bc04c08d 6a8e75aa 10d0ba33 fd0119cb bc04c08d 6a8e75aa 28ee321f 992d3318 7d927886 88e26519 5a277980 57cfd669 421c88fd bf39d005 c79c3dac 6a8e75aa f0bb7d4f d6180d0f 58822a04 6a8e75aa 5036ae0c 4142fd39 8e9e80de c982dffb d19bc45a ffcaf489 c198a591 9583f320 633c9e24 6a8e75aa 6a8e75aa 594e8787 fd0119cb af24b84b 6a8e75aa d26e8cac 6a8e75aa a3afdaa5 49b2c51b 233ebf22 8ce00902 e1cd7b87 f98c9df9 6a8e75aa 3568a3c0 6a8e75aa 5ac5ac02 f4edfdbd 2cea0d33 022b0c16 47265215 290472b7 6a8e75aa 2572d6c9 589875ab 6a8e75aa 1955d073 80688e1b 9745f046 7ec1b6f0 8d49220a 4a82b174 6a8e75aa 650afa71 421dc96c 65154905 8a0442c2 6a8e75aa 6a8e75aa 12136b6b 6a8e75aa 0541b4a6 26cea3a2 2cdff234 55695e43 dfc92629 3568a3c0 6a8e75aa eb60d48d d3a92601 8691796a f65ebf3f f68d12d7 3568a3c0 6a8e75aa 15a8ddab 5a880eb6 5e5ffecc 1a9391b2 2dcd64e3 98bfbe16 d439469d 0bfe420b bc1811f7 6ccb25eb c8d60ffe 52b4eb2e dec6adc2 443881a9 6a8e75aa 3df805e1 ac74a732 797f95ff 45476c56 ba49cb52 12705692 6a8e75aa ac8e0cfe 6a8e75aa c44be57c afdb80eb 1c7d32b7 16e70128 eb9ddfb6 6a8e75aa 963fdbb7 5f573553 6dc9c134 42d9fdc7 05a1fa5d 875a44ab 49b2c51b d6ffa5bd 60681a7c 6a8e75aa 9f547310 eb2fb9cf e221d644 e0f98a00 af750ee8 f0a37126 55e7ba50 85ee37bf 6a8e75aa 60a86f44 82eb2eba fe7df634 65c14f2b 34ab3e62 45ec06d3 aca2853b 85ee37bf 6a8e75aa 1f7fe4fc 5f7ccc1c e0f98a00 3dc8d6bb 6a8e75aa dd8bf467 bfe08afc dad67ca4 94e56058 85ee37bf 6a8e75aa 15e9a4ba 601ff546 fe7df634 65c14f2b f802cf32 8313613d e26a66fd 4142fd39 6a8e75aa 30d0c636 87b0e493 f4e448b3 b84f4ad2 3e21ee4f bde44b67 f9537a8f 942b88bf 68f84115 fe3e929f baea68c1 70d84d97 6f8a63eb 8e27f0ff 2b94b75d 52437efa fbd79661 85e81833 6022c430 034e10ce 53d99248 d75454a3 066ea55f 185a2aea acfb7882 57ae03ab 4ffc77af 6a8e75aa e277cc1a 7dc6ed47 f5acd332 d546941d 38398ab9 e5807f50 d067cf8b eeebb35c f0270773 7c96162e 248738d0 426c2bf2 97a5e111 3fabc91d 160d5bea 9f547310 44686528 6a8e75aa 6a8e75aa 4142fd39 fb6e4dc5 6a8e75aa 3432afd1 4f404cfc 6c91cb3a ca802b53 c198a591 2b5ddb66 24260500 6a8e75aa a98cecb8 dd7008b4 922e66bc f5acd332 64cd8af8 69eb1232 6a8e75aa 89f798a7 e10e45cf e684a5b4 21c250fb 9b4fbbf4 11769f70 89f798a7 6a8e75aa 4942b779 c19f3a20 29aad4b6 975b8ad2 9d2f48d5 248738d0 f1623060 a3837021 ed9c843a 6a8e75aa 60fbc6e0 8dcbc7b6 f1623060 03d4bdb9 6ce4d80c f5d23839 bdbf5bf0 85bf3195 6a8e75aa 53d09205 15a8ddab 2259b80d 3a005ebc d5dff2c5 470f0a71 fa61d721 6a8e75aa 16db469b 4bb4b818 f1623060 3ef86a17 7c7e63cd a3837021 927ddced 6a8e75aa 61ec3a2f c2c899db da10f589 ac6de176 ebc6aacc 92deac30 6a8e75aa 1ef986f0 f52600f5 c74e22bd fb8e6211 bc04c08d 6a8e75aa 3f09ef39 f1053989 651d40cc da10f589 8f6a0235 be48e876 27744dfd 8b1905aa 0f5f5773 26e9a0a1 d5c107bf c813a293 6a8e75aa d9ab2e54 010eba01 82a06b57 568d67e4 c3da633a 63324480 f1c2c447 aa28dd58 c2c899db ebc6aacc 3fabc91d 202ddf0e 796e46a4 6a8e75aa 7d5ee063 d4b90bf3 865d0069 da9cdd98 a7d04da7 074bafe9 1b03c172 6a8e75aa c2b7f49d d7818bce 6a8e75aa d0c07042 0efd688f 67082394 e32d49f1 c2c899db 6a656839 39523ae3 1ea6aff3 f6bb30e9 f98c9df9 6a8e75aa 37fd4ceb 60a86f44 e221d644 c3491063 aca2853b ff7c2dca fd5b7eba bc04c08d 6a8e75aa 03a454ad 3568a3c0 6a8e75aa d5303d6b d997b3b5 7584beaa 955aaeba 48d32275 e3537494 6a8e75aa 17412508 e079b352 d83b3afa da10da2a 60a86f44 82eb2eba aca2853b 5ee36135 6a8e75aa 2aa424e3 7dbdc1e1 bdbf5bf0 f6723a05 6a8e75aa 6a8e75aa 6a8e75aa 7f5dc62b 7584beaa 6a8e75aa beeb841d f6d9a952 d9f31298 7132e079 f200cc68 c791f7d4 6a8e75aa 54745419 6a8e75aa bf6c7b80 cdfa0b41 10c380f0 2a2123e6 098734d9 a0ede086 6a8e75aa 958faad4 4f44031c 6a8e75aa 8d417798 ab4fec3c f93d5bae b31b5633 6a8e75aa 015cce71 b157b7f5 58079c7f 0d3e1d44", ["9a0e2280"] = "35cd28d4 20cd1d0f c4c977fb 4f32024e 3d7276af 8fda288f 94ff9773 20cd1d0f 527e9c11 abcc1f03 c81a13d5 e077988c 1e2752ee 30368e49 a917396a dd30e141 48d3e274 6a8e75aa a29f7397 f4780811 75fdd5e4 6a8e75aa 1459fcf4 48d3e274 6a8e75aa 63ec09dd 6a8e75aa db3301fc 9f2c7b0e a7c888f0 f3b66e81 48d3e274 6a8e75aa df520443 f0a8b023 a897754b 48d3e274 6a8e75aa da2ce9af 6a8e75aa f52c29ad 6a8e75aa 3108f1f9 3d8c7fe8 e17bb5a0 a7c888f0 324f5d40 3e724601 6a8e75aa d9846005 7e0992af 6a8e75aa df520443 76fd6d47 07d9dac9 f38e92a3 c318e4db f0aa8391 d84ef210 281357b9 769ca16a 6a8e75aa ffc8919f 6a8e75aa 8d005228 bf5561f8 6a8e75aa c91e2423 f97d3726 3acd83ae f2098f6f b9d020b4 0fded03e 6a8e75aa cafe0881 f2e6684d 61ecdd79 6a8e75aa 0e92f79a 9a3bd139 58583c4b 6a8e75aa 6c2607b8 8dcbc7b6 608bda07 6a8e75aa c2f49059 6a8e75aa 130083ee", ["9d57bd9d"] = "346dbbf4 7b82c991 402053ee dec0da32 580105e4 31c56c45 81fd7ff6 4ae77a81 165ff28a d9c1e771 dfecd152 3ad02400 65e391c3 ddf0a17c 6a8e75aa 6a8e75aa 6a7476bb 6a8e75aa f2189d36 29e7095c 295456b8 3ebb2999 4142fd39 0febd176 3ba8165f f4c3818c b9c91fd6 a4bf4670 d710b1e8 f80c48a8 8601f02f c3deefb9 bbf8229e 29fa1575 6a8e75aa 6a8e75aa 977263bc 6a8e75aa 7d590826", ["b5d84f05"] = "2b215108 20cd1d0f b481ffc9 6084bfc6 8e76f8c8 d0b08f5b 29c8615c 20cd1d0f b0872b52 dfcdf719 4765dd34 fa03624e d78f409a 8d97c4f0 1df10c44 20cd1d0f 1c7aa50c e51d8a56 00724424 272b3928 eca07d87 104966b8 20cd1d0f 54ea9f7d e7754ff1 224a0df5 b39e14c4 97e47563 e61655bb 20cd1d0f fc51867d 5ff7c876 c1f12797 27c1e31b 1a0b2b33 5734ce60 0dfcfca7 d5c4b94c f258f49f 2aa7fb16 f4cdbeba c0a87cc1 6468f017 e5031d8c 6e8c17a4 bd675240 ba270482 79fdc91a f80c48a8 ca48da0d 12b8ac69 14a1bee8 e71cc62c 963fdbb7 ed312dc5 6a8e75aa 1d137568 24d47f3c 49b2c51b 365fe857 6a8e75aa 9587d575 6a8e75aa e9d0f99f 3076988c 733ad758 ce0fb68f 4aafc34c b60bd732 6a5ab244 530f2c69 20cd1d0f f0e3f39f 9470d276 7830e2d8 5f86a9cd 559a8b08 b4a1edc0 4d6cb3ff f70b0c4f 8c959a55 f76be948 8f41b275 7676ec7c 968b5dfd 6a8e75aa d65a35e9 5f0b7eec a2b41fca 4c3f7dfa 267d3ad7 7bee8f50 7b787181 72f23da8 118a722a 6a8e75aa 754df234 78e2e509 514bc83e 91e61f4f c95b4bc4 1b62353a df1f5414 85ee37bf 6a8e75aa d178b79b 9b9ff6de 6a8e75aa 43a6c0bd e9d2131a 6a8e75aa 73b4a192 8f145984 fb962ab7 23f563d5 0c4d7961 23205798 f390ea9c 9dae9dc4 4142fd39 dc48a174 618e75a1 4142fd39 6a8e75aa defdec4e 9f712bee 49499c3b 8b55aa86 a449e666 0b1d0211 b2770640 29f541f2 1d986f22 df1f5414 bf5561f8 6a8e75aa 10d0ba33 fd0119cb bf5561f8 6a8e75aa d8297aee c5e0276d 8e9e80de 6206674f fd0119cb bf5561f8 6a8e75aa 24c3b202 6a8e75aa 7903339d c6ab66c7 d40efdc5 de217225 c04ab646 c4980112 61c9eaef 7451b236 df1f5414 bc04c08d 6a8e75aa 10d0ba33 fd0119cb bc04c08d 6a8e75aa d439469d 7d927886 2074a21d 57cfd669 421c88fd f0bb7d4f d6180d0f f859659e 6a8e75aa 24b1ccb2 4142fd39 8e9e80de 594e8787 fd0119cb af24b84b 6a8e75aa ac8e0cfe 6a8e75aa a3afdaa5 49b2c51b 233ebf22 8ce00902 e1cd7b87 f98c9df9 6a8e75aa 3568a3c0 6a8e75aa 5ac5ac02 f4edfdbd 2cea0d33 022b0c16 47265215 290472b7 6a8e75aa 2572d6c9 589875ab 6a8e75aa 1955d073 80688e1b 9745f046 7ec1b6f0 8d49220a 4a82b174 6a8e75aa 650afa71 421dc96c 65154905 8a0442c2 6a8e75aa 6a8e75aa 12136b6b 6a8e75aa 0541b4a6 26cea3a2 2cdff234 55695e43 dfc92629 3568a3c0 6a8e75aa eb60d48d d3a92601 8691796a f65ebf3f f68d12d7 3568a3c0 6a8e75aa 15a8ddab 5a880eb6 5e5ffecc 1a9391b2 2dcd64e3 98bfbe16 d439469d 0bfe420b bc1811f7 6ccb25eb 52b4eb2e dec6adc2 443881a9 6a8e75aa 26d778cc ac74a732 797f95ff 45476c56 ba49cb52 6a8e75aa ac8e0cfe 6a8e75aa c44be57c afdb80eb 1c7d32b7 16e70128 eb9ddfb6 6a8e75aa 963fdbb7 5f573553 6dc9c134 42d9fdc7 05a1fa5d 875a44ab 49b2c51b d6ffa5bd 60681a7c 6a8e75aa 9f547310 eb2fb9cf e221d644 af750ee8 f0a37126 55e7ba50 85ee37bf 6a8e75aa 60a86f44 5dc7f220 65c14f2b 34ab3e62 45ec06d3 aca2853b 85ee37bf 6a8e75aa 1f7fe4fc 5f7ccc1c 3dc8d6bb 6a8e75aa dd8bf467 bfe08afc dad67ca4 94e56058 85ee37bf 6a8e75aa 15e9a4ba 1de63370 65c14f2b f802cf32 8313613d e26a66fd 4142fd39 6a8e75aa 30d0c636 87b0e493 f4e448b3 b84f4ad2 3e21ee4f bde44b67 f9537a8f 942b88bf 68f84115 fe3e929f baea68c1 70d84d97 6f8a63eb 8e27f0ff 2b94b75d 52437efa fbd79661 85e81833 6022c430 034e10ce 53d99248 d75454a3 066ea55f 185a2aea 4ffc77af 6a8e75aa 3432afd1 4f404cfc 6c91cb3a a8b58c18 e10e45cf e684a5b4 21c250fb 9b4fbbf4 11769f70 a8b58c18 6a8e75aa 4942b779 c19f3a20 29aad4b6 975b8ad2 a6e72ce5 248738d0 f1623060 ed9c843a 6a8e75aa 60fbc6e0 8dcbc7b6 f1623060 03d4bdb9 6ce4d80c f5d23839 bdbf5bf0 85bf3195 6a8e75aa 53d09205 15a8ddab 2259b80d 3a005ebc c575e715 470f0a71 fa61d721 6a8e75aa 16db469b 4bb4b818 f1623060 92deac30 3ef86a17 7c7e63cd f5acd332 d546941d 38398ab9 767dd27f d067cf8b e9cab02a f0270773 7c96162e 248738d0 426c2bf2 97a5e111 3fabc91d 160d5bea 9f547310 44686528 6a8e75aa 6a8e75aa 4142fd39 927ddced 6a8e75aa 61ec3a2f c2c899db da10f589 ac6de176 92deac30 6a8e75aa 1ef986f0 f52600f5 fb8e6211 bc04c08d 6a8e75aa d5303d6b d997b3b5 7584beaa 955aaeba 48d32275 e3537494 6a8e75aa 5dc7f220 2aa424e3 7dbdc1e1 bdbf5bf0 f6723a05 6a8e75aa 6a8e75aa 6a8e75aa 7f5dc62b 7584beaa 6a8e75aa beeb841d f6d9a952 d9f31298 7132e079 f200cc68 c791f7d4 6a8e75aa 54745419 6a8e75aa bf6c7b80 cdfa0b41 10c380f0 2a2123e6 e139b3c0 feeee46e 6a8e75aa 958faad4 4f44031c 6a8e75aa 8d417798 ab4fec3c f93d5bae b31b5633 6a8e75aa 015cce71 b157b7f5 58079c7f 0d3e1d44", ["c40fe1b3"] = "1b995adc 96066051 e733822c 6a388463 b357926b 49b2c51b 8d301cd7 41e1255b 9d2186b6 5b88c48a 8509ee28 71195580 7369a92d fa65ef90 a5ad6bdc 5c1aaa4f 34f56f5c 1a064af1 021c8d10 f1da7d7d 0de6b468 a58260a7 27c8e01c 3de3dcba 00aa585b 6a8e75aa 349b6d1b 358404c3 6a8e75aa 5a4a4b34 6a8e75aa", ["db4c16d8"] = "662ea531 f16852cd fa76c7c5 6f43a606 1cf4ba69 44f98f29 8f269f16 6a8e75aa 9fc3c0c0 8fa69177 aa5f4ab9 c0c24f05 6a8e75aa 6a8e75aa c76d0cb4 20cd1d0f 674430bf 2b3b79f2 1ff6d57f bcacea1e 289c2c87 cc21cad6 8c2ae597 ff4989a2 7132c7ee ef10ebf7 3098c15f 23873069 c2efbc30 471b4c26 1f87d7a7 7d51b023 85ee37bf 6a8e75aa 98bc3cc6 8dcbc7b6 c863ecfa 6a8e75aa 6a8e75aa 09b8e058 4adae112 4dc10082 70ae08ad c83b07ce fdecab4d fad95d23 870aee06 f9237ee6 b31025c8 c7bb1694 7d16d120 9ba0f388 06a72756 dff43f39 be145507 71978316 b7526f45 6a8e75aa 89380803 4648e66c 1b00a7e6 595ac888 4280f3b4 d98b2d1c 6a8e75aa 472c1066 9910f592 abe8e280 d26ff3ee 6a8e75aa 6a8e75aa d9919c8a cd340af4 358706a0 13f5f501 ec1720ee 87dd9e9e 9910f592 7577c6ef e8dfed9b b2ccca17 7ebe7c71 3dca7a7d 85a7bfdb 94d312ab 31c48a3f bc04c08d 6a8e75aa 8d5e13a7 c3099d81 7627d8f1 6a8e75aa b2890ca6 20cd234a 8db21a97 9206fd0a 09201db2 7627d8f1 6a8e75aa 8acf7454 b07b1170 6a8e75aa 582f38de f502fb56 42a54e43 e4d049e6 9cb00c57 fb9b2b29 791ee20c 80c3675a 2f4ef028 7bd5653b cd5a55c7 d636f5e3 0df2bb73 0ff1dfc4 4142fd39 4142fd39 3b0c3bd9 202a03d6 f0ac8f36 c8828948 d3f6bab8 ea0859ff 6a8e75aa e6dc2db7 24ff64c8 6a8e75aa 88be53b3 256f545a 245151f6 6a8e75aa 836eae2e dc14b258 4735b1c1 9b6b837d be2cc6ec d655bf60 b3f7017c 3075b2dc 4142fd39 fcb5162d 2d2595e1 6d7cab0d bc04c08d 6a8e75aa 6ecdb87c c3f07f56 0ad72f75 08552835 67a84083 0192fb15 6d7cab0d 6a8e75aa d0ee1731 6a8e75aa 55537dbb 4548428e 3e7dceeb 2033ca59 401c5c57 a107f719 6a8e75aa d4d674be c259940e ec68f34d ec1f8dca d35b3226 38d1db7d 14869b67 db61a1f7 86902fe9 885bfd08 4d3c9431 7c6b8271 a107f719 6a8e75aa 581fd65b d655bf60 e1b38797 d13e0595 4142fd39 d9a9ab85 bdbf5bf0 4207341d 6347f0fc 9ec73f6e d576b610 71205dd1 6a8e75aa f1ee52d5 a1382dad 6a8e75aa 436f95dc fbe1708d 6a8e75aa e1861bef 4cc5494f 39eeaabc d55f2d94 09548e29 43616d90 036540ae 6a8e75aa f855ab84 6a8e75aa 1e3c639f ac76c8e9 dfd0c6e7 ba793897 14d3a1b8 b4c0a6aa 8dcbc7b6 b0095976 a107f719 6a8e75aa 977263bc 6a8e75aa fa9329cb 7de2b239 46f8fc83 a66b4569 6292109e 42a54e43 3e7dceeb 0b5c9f18 fdb7e067 e51df417 d0136e34 352459cc 6a8e75aa 4142fd39 720c0d79 d0d06229 d77924fb 90024819 820a3e83 6a8e75aa 4142fd39 4142fd39 4b616dde 6a8e75aa 67747202 df18f65c 5dcf575c f5db9444 f80c48a8", ["db814ea0"] = "a988a55c d8325701 7f266ff1 992706b7 7fafe1e8 5b607995 53fdbdad a1187f11 e21201d0 da7ad802 2e36ebcc ebb382d4 d452d547 6a8e75aa 9d654399 f62c8e2c 6a8e75aa bc04c08d 6a8e75aa fb7eb15f bfdc7613 a2492d95 c1b917e7 4f9841d5 48d3e274 6a8e75aa a13457ac 53de0022 74c31e21 b180cf43 34030392 b23735f4 2e5eada2 6a8e75aa 5c7460b1 6a8e75aa 6d79129f 112332cc 03a723ee 31674855 72b5b112 78255439 1bcab2b2 88a4df2b 8fc1d859 6a8e75aa b121784d c2925631 6a8e75aa 6a8e75aa c6aa700d d0484969 6655bce5 5d84bc50 29342ddd 7cea4f67 b41ae7fa 02c0eb54 f20f36c5 b44e1ae2 bdbf5bf0 d9a4aea3 6a8e75aa 6a8e75aa 165ff28a 564e25bc 6a8e75aa bdbf5bf0 59518d34 2c868c41 67b78604 4c016e7e f20f36c5 e0bffa44 bdbf5bf0 fce62ef5 6a8e75aa 6a8e75aa 165ff28a 767c7b32 6a8e75aa 6a8e75aa 6a8e75aa 31749745 b5b5841c 3c2b103b 78a6a635 28f95976 35a7c374 1dcfdc7e 6a8e75aa 19734644 71e53447 d862af1b 3d33b898 7b04101f 85db34c3 6a8e75aa 7bb86778 6a8e75aa e9ab980f", ["fee866b5"] = "50cd2275 8f9d427c 8e483302 6286cea9 c5217a9a 35b34599 f2820c92 620993f1 71ee1071 6a8e75aa 0559570a 6a8e75aa 59114f0d cf30f5ff f20f36c5 5be6ae50 c18fea38 ecdef414 91f07820 6a8e75aa 98bc31d1 343a94b4 6a8e75aa 6a8e75aa 69570fbc 6a8e75aa e749657a e288009c d620d1b4 b4cb0cba 5a42678e 99a4153e a68f96fb 8ffe2ed1 14f66991 6a8e75aa 0bc266d3", }, } ]]> -1 Packages 0 0 0 0 false -1 Promise 0 false (), reject: (...: any) -> (), onCancel: (abortHandler?: () -> ()) -> boolean) -> () @return Promise ]=] function Promise.new(executor) return Promise._new(debug.traceback(nil, 2), executor) end function Promise:__tostring() return string.format("Promise(%s)", self._status) end --[=[ The same as [Promise.new](/api/Promise#new), except execution begins after the next `Heartbeat` event. This is a spiritual replacement for `spawn`, but it does not suffer from the same [issues](https://eryn.io/gist/3db84579866c099cdd5bb2ff37947cec) as `spawn`. ```lua local function waitForChild(instance, childName, timeout) return Promise.defer(function(resolve, reject) local child = instance:WaitForChild(childName, timeout) ;(child and resolve or reject)(child) end) end ``` @param executor (resolve: (...: any) -> (), reject: (...: any) -> (), onCancel: (abortHandler?: () -> ()) -> boolean) -> () @return Promise ]=] function Promise.defer(executor) 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, executor, resolve, reject, onCancel) if not ok then reject(result[1]) end end) end) return promise end -- Backwards compatibility Promise.async = Promise.defer --[=[ Creates an immediately resolved Promise with the given value. ```lua -- Example using Promise.resolve to deliver cached values: function getSomething(name) if cache[name] then return Promise.resolve(cache[name]) else return Promise.new(function(resolve, reject) local thing = getTheThing() cache[name] = thing resolve(thing) end) end end ``` @param ... any @return Promise<...any> ]=] function Promise.resolve(...) local length, values = pack(...) return Promise._new(debug.traceback(nil, 2), function(resolve) resolve(unpack(values, 1, length)) end) end --[=[ Creates an immediately rejected Promise with the given value. :::caution Something needs to consume this rejection (i.e. `:catch()` it), otherwise it will emit an unhandled Promise rejection warning on the next frame. Thus, you should not create and store rejected Promises for later use. Only create them on-demand as needed. ::: @param ... any @return Promise<...any> ]=] 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, calling a function and returning a Promise resolving with its return value. If the function errors, the returned Promise will be rejected with the error. You can safely yield within the Promise.try callback. :::info `Promise.try` is similar to [Promise.promisify](#promisify), except the callback is invoked immediately instead of returning a new function. ::: ```lua Promise.try(function() return math.random(1, 2) == 1 and "ok" or error("Oh an error!") end) :andThen(function(text) print(text) end) :catch(function(err) warn("Something went wrong") end) ``` @param callback (...: T...) -> ...any @param ... T... -- Additional arguments passed to `callback` @return Promise ]=] function Promise.try(callback, ...) return Promise._try(debug.traceback(nil, 2), callback, ...) 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 --[=[ Accepts an array of Promises and returns a new promise that: * is resolved after all input promises resolve. * is rejected if *any* input promises reject. :::info Only the first return value from each promise will be present in the resulting array. ::: After any input Promise rejects, all other input Promises that are still pending will be cancelled if they have no other consumers. ```lua local promises = { returnsAPromise("example 1"), returnsAPromise("example 2"), returnsAPromise("example 3"), } return Promise.all(promises) ``` @param promises {Promise} @return Promise<{T}> ]=] function Promise.all(promises) return Promise._all(debug.traceback(nil, 2), promises) end --[=[ Folds an array of values or promises into a single value. The array is traversed sequentially. The reducer function can return a promise or value directly. Each iteration receives the resolved value from the previous, and the first receives your defined initial value. The folding will stop at the first rejection encountered. ```lua local basket = {"blueberry", "melon", "pear", "melon"} Promise.fold(basket, function(cost, fruit) if fruit == "blueberry" then return cost -- blueberries are free! else -- call a function that returns a promise with the fruit price return fetchPrice(fruit):andThen(function(fruitCost) return cost + fruitCost end) end end, 0) ``` @since v3.1.0 @param list {T | Promise} @param reducer (accumulator: U, value: T, index: number) -> U | Promise @param initialValue U ]=] function Promise.fold(list, reducer, initialValue) assert(type(list) == "table", "Bad argument #1 to Promise.fold: must be a table") assert(isCallable(reducer), "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 reducer(previousValueResolved, resolvedElement, i) end) end):andThen(function() return accumulator end) end --[=[ Accepts an array of Promises and returns a Promise that is resolved as soon as `count` Promises are resolved from the input array. The resolved array values are in the order that the Promises resolved in. When this Promise resolves, all other pending Promises are cancelled if they have no other consumers. `count` 0 results in an empty array. The resultant array will never have more than `count` elements. ```lua local promises = { returnsAPromise("example 1"), returnsAPromise("example 2"), returnsAPromise("example 3"), } return Promise.some(promises, 2) -- Only resolves with first 2 promises to resolve ``` @param promises {Promise} @param count number @return Promise<{T}> ]=] function Promise.some(promises, count) assert(type(count) == "number", "Bad argument #2 to Promise.some: must be a number") return Promise._all(debug.traceback(nil, 2), promises, count) end --[=[ Accepts an array of Promises and returns a Promise that is resolved as soon as *any* of the input Promises resolves. It will reject only if *all* input Promises reject. As soon as one Promises resolves, all other pending Promises are cancelled if they have no other consumers. Resolves directly with the value of the first resolved Promise. This is essentially [[Promise.some]] with `1` count, except the Promise resolves with the value directly instead of an array with one element. ```lua local promises = { returnsAPromise("example 1"), returnsAPromise("example 2"), returnsAPromise("example 3"), } return Promise.any(promises) -- Resolves with first value to resolve (only rejects if all 3 rejected) ``` @param promises {Promise} @return Promise ]=] function Promise.any(promises) return Promise._all(debug.traceback(nil, 2), promises, 1):andThen(function(values) return values[1] end) end --[=[ Accepts an array of Promises and returns a new Promise that resolves with an array of in-place Statuses when all input Promises have settled. This is equivalent to mapping `promise:finally` over the array of Promises. ```lua local promises = { returnsAPromise("example 1"), returnsAPromise("example 2"), returnsAPromise("example 3"), } return Promise.allSettled(promises) ``` @param promises {Promise} @return Promise<{Status}> ]=] 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 --[=[ Accepts an array of Promises and returns a new promise that is resolved or rejected as soon as any Promise in the array resolves or rejects. :::warning If the first Promise to settle from the array settles with a rejection, the resulting Promise from `race` will reject. If you instead want to tolerate rejections, and only care about at least one Promise resolving, you should use [Promise.any](#any) or [Promise.some](#some) instead. ::: All other Promises that don't win the race will be cancelled if they have no other consumers. ```lua local promises = { returnsAPromise("example 1"), returnsAPromise("example 2"), returnsAPromise("example 3"), } return Promise.race(promises) -- Only returns 1st value to resolve or reject ``` @param promises {Promise} @return Promise ]=] 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 value before continuing. If the predicate returns a Promise, we wait for that Promise to resolve before moving on to the next item in the array. :::info `Promise.each` is similar to `Promise.all`, except the Promises are ran in order instead of all at once. But because Promises are eager, by the time they are created, they're already running. Thus, we need a way to defer creation of each Promise until a later time. The predicate function exists as a way for us to operate on our data instead of creating a new closure for each Promise. If you would prefer, you can pass in an array of functions, and in the predicate, call the function and return its return value. ::: ```lua Promise.each({ "foo", "bar", "baz", "qux" }, function(value, index) return Promise.delay(1):andThen(function() print(("%d) Got %s!"):format(index, value)) end) end) --[[ (1 second passes) > 1) Got foo! (1 second passes) > 2) Got bar! (1 second passes) > 3) Got baz! (1 second passes) > 4) Got qux! ]] ``` If the Promise a predicate returns rejects, the Promise from `Promise.each` is also rejected with the same value. If the array of values contains a Promise, when we get to that point in the list, we wait for the Promise to resolve before calling the predicate with the value. If a Promise in the array of values is already Rejected when `Promise.each` is called, `Promise.each` rejects with that value immediately (the predicate callback will never be called even once). If a Promise in the list is already Cancelled when `Promise.each` is called, `Promise.each` rejects with `Promise.Error(Promise.Error.Kind.AlreadyCancelled`). If a Promise in the array of values is Started at first, but later rejects, `Promise.each` will reject with that value and iteration will not continue once iteration encounters that value. Returns a Promise containing an array of the returned/resolved values from the predicate for each item in the array of values. If this Promise returned from `Promise.each` rejects or is cancelled for any reason, the following are true: - Iteration will not continue. - Any Promises within the array of values will now be cancelled if they have no other consumers. - The Promise returned from the currently active predicate will be cancelled if it hasn't resolved yet. @since 3.0.0 @param list {T | Promise} @param predicate (value: T, index: number) -> U | Promise @return Promise<{U}> ]=] function Promise.each(list, predicate) assert(type(list) == "table", string.format(ERROR_NON_LIST, "Promise.each")) assert(isCallable(predicate), 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 --[=[ Checks whether the given object is a Promise via duck typing. This only checks if the object is a table and has an `andThen` method. @param object any @return boolean -- `true` if the given `object` is a Promise. ]=] 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 isCallable(object.andThen) elseif type(objectMetatable) == "table" and type(rawget(objectMetatable, "__index")) == "table" and isCallable(rawget(rawget(objectMetatable, "__index"), "andThen")) then -- Maybe this came from a different or older Promise library. return true end return false end --[=[ Wraps a function that yields into one that returns a Promise. Any errors that occur while executing the function will be turned into rejections. :::info `Promise.promisify` is similar to [Promise.try](#try), except the callback is returned as a callable function instead of being invoked immediately. ::: ```lua local sleep = Promise.promisify(wait) sleep(1):andThen(print) ``` ```lua local isPlayerInGroup = Promise.promisify(function(player, groupId) return player:IsInGroup(groupId) end) ``` @param callback (...: any) -> ...any @return (...: any) -> Promise ]=] function Promise.promisify(callback) return function(...) return Promise._try(debug.traceback(nil, 2), callback, ...) end end --[=[ Returns a Promise that resolves after `seconds` seconds have passed. The Promise resolves with the actual amount of time that was waited. This function is **not** a wrapper around `wait`. `Promise.delay` uses a custom scheduler which provides more accurate timing. As an optimization, cancelling this Promise instantly removes the task from the scheduler. :::warning Passing `NaN`, infinity, or a number less than 1/60 is equivalent to passing 1/60. ::: ```lua Promise.delay(5):andThenCall(print, "This prints after 5 seconds") ``` @function delay @within Promise @param seconds number @return Promise ]=] 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 --[=[ Returns a new Promise that resolves if the chained Promise resolves within `seconds` seconds, or rejects if execution time exceeds `seconds`. The chained Promise will be cancelled if the timeout is reached. Rejects with `rejectionValue` if it is non-nil. If a `rejectionValue` is not given, it will reject with a `Promise.Error(Promise.Error.Kind.TimedOut)`. This can be checked with [[Error.isKind]]. ```lua getSomething():timeout(5):andThen(function(something) -- got something and it only took at max 5 seconds end):catch(function(e) -- Either getting something failed or the time was exceeded. if Promise.Error.isKind(e, Promise.Error.Kind.TimedOut) then warn("Operation timed out!") else warn("Operation encountered an error!") end end) ``` Sugar for: ```lua Promise.race({ Promise.delay(seconds):andThen(function() return Promise.reject( rejectionValue == nil and Promise.Error.new({ kind = Promise.Error.Kind.TimedOut }) or rejectionValue ) end), promise }) ``` @param seconds number @param rejectionValue? any -- The value to reject with if the timeout is reached @return Promise ]=] 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 --[=[ Returns the current Promise status. @return Status ]=] 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 -- If we are already cancelled, we return a cancelled Promise if self._status == Promise.Status.Cancelled then local promise = Promise.new(function() end) promise:cancel() return promise end -- Create a new promise to follow this part of the chain return Promise._new(traceback, function(resolve, reject, onCancel) -- 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) onCancel(function() -- These are guaranteed to exist because the cancellation handler is guaranteed to only -- be called at most once if self._status == Promise.Status.Started then table.remove(self._queuedResolve, table.find(self._queuedResolve, successCallback)) table.remove(self._queuedReject, table.find(self._queuedReject, failureCallback)) end end) 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)) end end, self) end --[=[ Chains onto an existing Promise and returns a new Promise. :::warning Within the failure handler, you should never assume that the rejection value is a string. Some rejections within the Promise library are represented by [[Error]] objects. If you want to treat it as a string for debugging, you should call `tostring` on it first. ::: You can return a Promise from the success or failure handler and it will be chained onto. Calling `andThen` on a cancelled Promise returns a cancelled Promise. :::tip If the Promise returned by `andThen` is cancelled, `successHandler` and `failureHandler` will not run. To run code no matter what, use [Promise:finally]. ::: @param successHandler (...: any) -> ...any @param failureHandler? (...: any) -> ...any @return Promise<...any> ]=] function Promise.prototype:andThen(successHandler, failureHandler) assert(successHandler == nil or isCallable(successHandler), string.format(ERROR_NON_FUNCTION, "Promise:andThen")) assert(failureHandler == nil or isCallable(failureHandler), string.format(ERROR_NON_FUNCTION, "Promise:andThen")) return self:_andThen(debug.traceback(nil, 2), successHandler, failureHandler) end --[=[ Shorthand for `Promise:andThen(nil, failureHandler)`. Returns a Promise that resolves if the `failureHandler` worked without encountering an additional error. :::warning Within the failure handler, you should never assume that the rejection value is a string. Some rejections within the Promise library are represented by [[Error]] objects. If you want to treat it as a string for debugging, you should call `tostring` on it first. ::: Calling `catch` on a cancelled Promise returns a cancelled Promise. :::tip If the Promise returned by `catch` is cancelled, `failureHandler` will not run. To run code no matter what, use [Promise:finally]. ::: @param failureHandler (...: any) -> ...any @return Promise<...any> ]=] function Promise.prototype:catch(failureHandler) assert(failureHandler == nil or isCallable(failureHandler), string.format(ERROR_NON_FUNCTION, "Promise:catch")) return self:_andThen(debug.traceback(nil, 2), nil, failureHandler) end --[=[ Similar to [Promise.andThen](#andThen), except the return value is the same as the value passed to the handler. In other words, you can insert a `:tap` into a Promise chain without affecting the value that downstream Promises receive. ```lua getTheValue() :tap(print) :andThen(function(theValue) print("Got", theValue, "even though print returns nil!") end) ``` If you return a Promise from the tap handler callback, its value will be discarded but `tap` will still wait until it resolves before passing the original value through. @param tapHandler (...: any) -> ...any @return Promise<...any> ]=] function Promise.prototype:tap(tapHandler) assert(isCallable(tapHandler), string.format(ERROR_NON_FUNCTION, "Promise:tap")) return self:_andThen(debug.traceback(nil, 2), function(...) local callbackReturn = tapHandler(...) if Promise.is(callbackReturn) then local length, values = pack(...) return callbackReturn:andThen(function() return unpack(values, 1, length) end) end return ... end) end --[=[ Attaches an `andThen` handler to this Promise that calls the given callback with the predefined arguments. The resolved value is discarded. ```lua promise:andThenCall(someFunction, "some", "arguments") ``` This is sugar for ```lua promise:andThen(function() return someFunction("some", "arguments") end) ``` @param callback (...: any) -> any @param ...? any -- Additional arguments which will be passed to `callback` @return Promise ]=] function Promise.prototype:andThenCall(callback, ...) assert(isCallable(callback), 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 --[=[ Attaches an `andThen` handler to this Promise that discards the resolved value and returns the given value from it. ```lua promise:andThenReturn("some", "values") ``` This is sugar for ```lua promise:andThen(function() return "some", "values" end) ``` :::caution Promises are eager, so if you pass a Promise to `andThenReturn`, it will begin executing before `andThenReturn` is reached in the chain. Likewise, if you pass a Promise created from [[Promise.reject]] into `andThenReturn`, it's possible that this will trigger the unhandled rejection warning. If you need to return a Promise, it's usually best practice to use [[Promise.andThen]]. ::: @param ... any -- Values to return from the function @return Promise ]=] function Promise.prototype:andThenReturn(...) local length, values = pack(...) return self:_andThen(debug.traceback(nil, 2), function() return unpack(values, 1, length) end) end --[=[ Cancels this promise, preventing the promise from resolving or rejecting. Does not do anything if the promise is already settled. Cancellations will propagate upwards and downwards through chained promises. Promises will only be cancelled if all of their consumers are also cancelled. This is to say that if you call `andThen` twice on the same promise, and you cancel only one of the child promises, it will not cancel the parent promise until the other child promise is also cancelled. ```lua promise:cancel() ``` ]=] 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 coroutine.close(self._thread) 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. ]] function Promise.prototype:_finally(traceback, finallyHandler) self._unhandledRejection = false local promise = Promise._new(traceback, function(resolve, reject, onCancel) local handlerPromise onCancel(function() -- The finally Promise is not a proper consumer of self. We don't care about the resolved value. -- All we care about is running at the end. Therefore, if self has no other consumers, it's safe to -- cancel. We don't need to hold out cancelling just because there's a finally handler. self:_consumerCancelled(self) if handlerPromise then handlerPromise:cancel() end end) local finallyCallback = resolve if finallyHandler then finallyCallback = function(...) local callbackReturn = finallyHandler(...) if Promise.is(callbackReturn) then handlerPromise = callbackReturn callbackReturn :finally(function(status) if status ~= Promise.Status.Rejected then resolve(self) end end) :catch(function(...) reject(...) end) else resolve(self) end 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) return promise end --[=[ Set a handler that will be called regardless of the promise's fate. The handler is called when the promise is resolved, rejected, *or* cancelled. Returns a new Promise that: - resolves with the same values that this Promise resolves with. - rejects with the same values that this Promise rejects with. - is cancelled if this Promise is cancelled. If the value you return from the handler is a Promise: - We wait for the Promise to resolve, but we ultimately discard the resolved value. - If the returned Promise rejects, the Promise returned from `finally` will reject with the rejected value from the *returned* promise. - If the `finally` Promise is cancelled, and you returned a Promise from the handler, we cancel that Promise too. Otherwise, the return value from the `finally` handler is entirely discarded. :::note Cancellation As of Promise v4, `Promise:finally` does not count as a consumer of the parent Promise for cancellation purposes. This means that if all of a Promise's consumers are cancelled and the only remaining callbacks are finally handlers, the Promise is cancelled and the finally callbacks run then and there. Cancellation still propagates through the `finally` Promise though: if you cancel the `finally` Promise, it can cancel its parent Promise if it had no other consumers. Likewise, if the parent Promise is cancelled, the `finally` Promise will also be cancelled. ::: ```lua local thing = createSomething() doSomethingWith(thing) :andThen(function() print("It worked!") -- do something.. end) :catch(function() warn("Oh no it failed!") end) :finally(function() -- either way, destroy thing thing:Destroy() end) ``` @param finallyHandler (status: Status) -> ...any @return Promise<...any> ]=] function Promise.prototype:finally(finallyHandler) assert(finallyHandler == nil or isCallable(finallyHandler), string.format(ERROR_NON_FUNCTION, "Promise:finally")) return self:_finally(debug.traceback(nil, 2), finallyHandler) end --[=[ Same as `andThenCall`, except for `finally`. Attaches a `finally` handler to this Promise that calls the given callback with the predefined arguments. @param callback (...: any) -> any @param ...? any -- Additional arguments which will be passed to `callback` @return Promise ]=] function Promise.prototype:finallyCall(callback, ...) assert(isCallable(callback), 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 --[=[ Attaches a `finally` handler to this Promise that discards the resolved value and returns the given value from it. ```lua promise:finallyReturn("some", "values") ``` This is sugar for ```lua promise:finally(function() return "some", "values" end) ``` @param ... any -- Values to return from the function @return Promise ]=] function Promise.prototype:finallyReturn(...) local length, values = pack(...) return self:_finally(debug.traceback(nil, 2), function() return unpack(values, 1, length) end) end --[=[ Yields the current thread until the given Promise completes. Returns the Promise's status, followed by the values that the promise resolved or rejected with. @yields @return Status -- The Status representing the fate of the Promise @return ...any -- The values the Promise resolved or rejected with. ]=] function Promise.prototype:awaitStatus() self._unhandledRejection = false if self._status == Promise.Status.Started then local thread = coroutine.running() self :finally(function() task.spawn(thread) end) -- The finally promise can propagate rejections, so we attach a catch handler to prevent the unhandled -- rejection warning from appearing :catch( function() end ) coroutine.yield() 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 --[=[ Yields the current thread until the given Promise completes. Returns true if the Promise resolved, followed by the values that the promise resolved or rejected with. :::caution If the Promise gets cancelled, this function will return `false`, which is indistinguishable from a rejection. If you need to differentiate, you should use [[Promise.awaitStatus]] instead. ::: ```lua local worked, value = getTheValue():await() if worked then print("got", value) else warn("it failed") end ``` @yields @return boolean -- `true` if the Promise successfully resolved @return ...any -- The values the Promise resolved or rejected with. ]=] 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 --[=[ Yields the current thread until the given Promise completes. Returns the values that the promise resolved with. ```lua local worked = pcall(function() print("got", getTheValue():expect()) end) if not worked then warn("it failed") end ``` This is essentially sugar for: ```lua select(2, assert(promise:await())) ``` **Errors** if the Promise rejects or gets cancelled. @error any -- Errors with the rejection value if this Promise rejects or gets cancelled. @yields @return ...any -- The values the Promise resolved with. ]=] 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) for _, callback in ipairs(Promise._unhandledRejectionCallbacks) do task.spawn(callback, self, unpack(self._values, 1, self._valuesLength)) end 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 task.defer(coroutine.close, self._thread) end --[=[ Chains a Promise from this one that is resolved if this Promise is already resolved, and rejected if it is not resolved at the time of calling `:now()`. This can be used to ensure your `andThen` handler occurs on the same frame as the root Promise execution. ```lua doSomething() :now() :andThen(function(value) print("Got", value, "synchronously.") end) ``` If this Promise is still running, Rejected, or Cancelled, the Promise returned from `:now()` will reject with the `rejectionValue` if passed, otherwise with a `Promise.Error(Promise.Error.Kind.NotResolvedInTime)`. This can be checked with [[Error.isKind]]. @param rejectionValue? any -- The value to reject with if the Promise isn't resolved @return Promise ]=] function Promise.prototype:now(rejectionValue) local traceback = debug.traceback(nil, 2) if self._status == 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 --[=[ Repeatedly calls a Promise-returning function up to `times` number of times, until the returned Promise resolves. If the amount of retries is exceeded, the function will return the latest rejected Promise. ```lua local function canFail(a, b, c) return Promise.new(function(resolve, reject) -- do something that can fail local failed, thing = doSomethingThatCanFail(a, b, c) if failed then reject("it failed") else resolve(thing) end end) end local MAX_RETRIES = 10 local value = Promise.retry(canFail, MAX_RETRIES, "foo", "bar", "baz") -- args to send to canFail ``` @since 3.0.0 @param callback (...: P) -> Promise @param times number @param ...? P @return Promise ]=] function Promise.retry(callback, times, ...) assert(isCallable(callback), "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 --[=[ Repeatedly calls a Promise-returning function up to `times` number of times, waiting `seconds` seconds between each retry, until the returned Promise resolves. If the amount of retries is exceeded, the function will return the latest rejected Promise. @since v3.2.0 @param callback (...: P) -> Promise @param times number @param seconds number @param ...? P @return Promise ]=] function Promise.retryWithDelay(callback, times, seconds, ...) assert(isCallable(callback), "Parameter #1 to Promise.retry must be a function") assert(type(times) == "number", "Parameter #2 (times) to Promise.retry must be a number") assert(type(seconds) == "number", "Parameter #3 (seconds) to Promise.retry must be a number") local args, length = { ... }, select("#", ...) return Promise.resolve(callback(...)):catch(function(...) if times > 0 then Promise.delay(seconds):await() return Promise.retryWithDelay(callback, times - 1, seconds, unpack(args, 1, length)) else return Promise.reject(...) end end) end --[=[ Converts an event into a Promise which resolves the next time the event fires. The optional `predicate` callback, if passed, will receive the event arguments and should return `true` or `false`, based on if this fired event should resolve the Promise or not. If `true`, the Promise resolves. If `false`, nothing happens and the predicate will be rerun the next time the event fires. The Promise will resolve with the event arguments. :::tip This function will work given any object with a `Connect` method. This includes all Roblox events. ::: ```lua -- Creates a Promise which only resolves when `somePart` is touched -- by a part named `"Something specific"`. return Promise.fromEvent(somePart.Touched, function(part) return part.Name == "Something specific" end) ``` @since 3.0.0 @param event Event -- Any object with a `Connect` method. This includes all Roblox events. @param predicate? (...: P) -> boolean -- A function which determines if the Promise should resolve with the given value, or wait for the next event to check again. @return Promise

]=] function Promise.fromEvent(event, predicate) predicate = predicate or function() return true end return Promise._new(debug.traceback(nil, 2), function(resolve, _, 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(disconnect) end) end --[=[ Registers a callback that runs when an unhandled rejection happens. An unhandled rejection happens when a Promise is rejected, and the rejection is not observed with `:catch`. The callback is called with the actual promise that rejected, followed by the rejection values. @since v3.2.0 @param callback (promise: Promise, ...: any) -- A callback that runs when an unhandled rejection happens. @return () -> () -- Function that unregisters the `callback` when called ]=] function Promise.onUnhandledRejection(callback) table.insert(Promise._unhandledRejectionCallbacks, callback) return function() local index = table.find(Promise._unhandledRejectionCallbacks, callback) if index then table.remove(Promise._unhandledRejectionCallbacks, index) end end end return Promise ]]> -1 Schema 0 false . Another value starts every player on an empty profile (their saved data stays in the old store).", }), StudioDataStoreVersion = S.string({ default = "v4", pinned = true, doc = "The DataStore used when you play in Studio is PlayerData_. Keep it different from DataStoreVersion by more than spaces or letter case: when they are equal, Studio tests load and save live profiles, and when they differ only in spaces or case they may (the server warns at start, FreeMode stays off and Wipe Studio Data refuses).", }), AutoSaveInterval = S.number({ default = 90, doc = "Seconds between automatic saves of each player's profile. Players are also saved when they leave and when the server shuts down, and the scheduler never saves one player more often than about every 45 seconds.", check = checkInterval, checkDoc = "A finite number of seconds", }), FreeMode = S.boolean({ default = false, doc = "Test purchases without spending Robux: HasPass is true and GrantProduct runs the product's handler. It only works in Studio, and not while StudioDataStoreVersion equals DataStoreVersion, ignoring spaces and letter case (Studio would use live profiles): in a live server gamepasses and products are always real, and the server warns at start when it is on and ignored.", }), DefaultData = S.tree({ default = { Stats = { Cash = 0, Wins = 0 } }, pinned = true, doc = "What a new player's profile starts with. Every saved profile also gains each key it lacks when it loads; a value a player already has is never changed or removed. Replaced whole: list every group you want. Stats (Cash 0, Wins 0), Pets and Purchases are added when you leave them out.", check = checkDefaultData, checkDoc = "No top-level Meta: that group is the profile's own record", }), }) end ]]> -1 manifest 0 false -1 ServerScriptService 0 0 0 0 false -1 Kernel 0 false 0 false -1 Packs 0 0 0 0 false -1 DatastorePurchaseSystem AQAAAAwAAABSQkxYRV9IYXNoZXMCRAQAACNyYmx4ZS1oYXNoZXMgdjEgZm52MWEzMiBsZgpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9NaWdyYXRpb25zL0Zyb21WMgkwMzkxYTNlMQpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9NaWdyYXRpb25zL0tlZXAJMTFmYTJkZGUKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvRGF0YXN0b3JlUHVyY2hhc2VTeXN0ZW0vUGFja2FnZXMvUHJvbWlzZQk2ZDUzZjgzNgpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9TY2hlbWEJMjNhMTE2ZmQKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvRGF0YXN0b3JlUHVyY2hhc2VTeXN0ZW0vbWFuaWZlc3QJYTA1Y2QzYmYKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbQkzYjNjNDdiNwpTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL0FjdGlvbnMvV2lwZVN0dWRpb0RhdGEJMzE1ZDk2ZWEKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9Db25maWcJMzJmZDJlOGYKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9EYXRhUGF0aAk5YTBlMjI4MApTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL0RhdGFTdG9yZU1hbmFnZXIJODdkOTIyNWUKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9EYXRhc3RvcmVQdXJjaGFzZVN5c3RlbS9EZWZhdWx0RGF0YQkxZDFkODIzNApTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL01pZ3JhdGlvbglmZWU4NjZiNQpTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL1B1cmNoYXNlTWFuYWdlcgk3MWM0NmQzNgpTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL1N0dWRpb1NhZmVJZAkwZTE4YjM1NApTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL0RhdGFzdG9yZVB1cmNoYXNlU3lzdGVtL1ZhbHVlUmVwbGljYXRvcglkYjgxNGVhMA== 0 false Kick-on-failure -> connect -- CharacterAdded/Died -> LoadCharacter), matching v1's shape exactly. A -- split into two separate PlayerAdded connections (one task.spawn'd for -- Get+LoadCharacter, one plain for CharacterAdded wiring) would race: -- if manager:Get ever resolves without yielding, LoadCharacter could run -- before the CharacterAdded/Died connection existed, silently breaking -- respawn for that player's first life. -- * `player:LoadCharacter()` is guarded by `player.Parent ~= nil` - the -- player can leave while manager:Get is yielding on the DataStore round -- trip; v1 guards this, the naive port did not. -- * Humanoid wait is `WaitForChild("Humanoid", 10)` with a nil-guard, not -- an unbounded wait - matches v1 exactly and avoids a stray indefinite -- yield inside the CharacterAdded connection. -- * Kick message text matches v1 verbatim: "Failed to load your data. -- Please rejoin." -- * `Players.PlayerRemoving` -> `safeId.CleanupPlayer(player)` is wired -- (v1 had this; the initial sketch omitted it entirely). -- * `SaveAllImmediate` on BindToClose is pcall-wrapped, matching v1 (a -- save failure during shutdown must not throw out of BindToClose). -- -- Trove split (binding decision from Task 3's review, overrides a single -- shared trove): DataStoreManager and PurchaseManager each call -- `trove:Clean()` on THEIR OWN trove during Stop()/SaveAllImmediate. Sharing -- one trove across all three would mean SaveAllImmediate (called from -- BindToClose) also disconnects PlayerAdded/PlayerRemoving and -- PurchaseManager's own lifecycle connections - a blast radius v1 never had, -- since v1's Bootstrap connections were plain top-level `:Connect` calls, not -- routed through the manager's cleanup trove. Three separate troves keep each -- owner's Clean() scoped to only what it should own: -- managerTrove -> passed into DataStoreManager.new (owns the Heartbeat -- save-scheduler connection; cleaned by Stop()/SaveAllImmediate) -- purchasesTrove -> passed into PurchaseManager.new (owns -- PromptGamePassPurchaseFinished / PlayerRemoving->passCache) -- packTrove -> this init's own connections (PlayerAdded/PlayerRemoving -- for data-load/respawn/safeId cleanup); never cleaned by -- either manager, so it always outlives BindToClose saves return function(ctx) local Players = game:GetService("Players") local MarketplaceService = game:GetService("MarketplaceService") local RunService = game:GetService("RunService") local Promise = require(ctx.folder.Packages.Promise) local Config = require(script.Config) local DefaultData = require(script.DefaultData) -- The game's profile migration first (plan B1, ruling 7): no update -- replaces Extensions, so an edit there survives every update. local migrationModule, migrationFrom = ctx.extension("Migration", script) local Migration = require(migrationModule) if type(Migration) ~= "table" or type(Migration.migrate) ~= "function" then error(("the Migration module from the %s (%s) must return a table with a migrate(loaded, defaults) function"):format( if migrationFrom == "game" then "game" else "pack", migrationModule:GetFullName()), 0) end if migrationFrom == "game" then -- DataStoreManager hands every migrate call the same defaults table and -- then writes into what comes back; the shipped migrate deep-copies it. -- A game's migrate gets its own deep copy for each profile, so a module -- that returns or keeps `defaults` never shares one table between two -- players. local own, shipped = Migration, require(script.Migration) Migration = { migrate = function(loaded, defaults) return own.migrate(loaded, shipped.deepClone(defaults)) end, } end local StudioSafeId = require(script.StudioSafeId) local ValueReplicator = require(script.ValueReplicator) local DataStoreManager = require(script.DataStoreManager) local PurchaseManager = require(script.PurchaseManager) local DataPath = require(script.DataPath) local managerTrove = ctx.kernel.Trove.new() local purchasesTrove = ctx.kernel.Trove.new() local packTrove = ctx.kernel.Trove.new() local config = Config(ctx.config, RunService:IsStudio()) local defaults = DefaultData.build(ctx.config.DefaultData) local safeId = StudioSafeId() if config.SameStores then local live, studio = ctx.config.DataStoreVersion, ctx.config.StudioDataStoreVersion local why = if live == studio then ("DataStoreVersion and StudioDataStoreVersion are both %q, so Studio sessions load and save the live profiles of PlayerData_%s (2.0.0 shipped them equal)"):format(live, live) else ("DataStoreVersion %q and StudioDataStoreVersion %q differ only in spaces or letter case, which may not make another DataStore, so Studio sessions may load and save the live profiles of PlayerData_%s"):format(live, studio, live) warn(("[RBLXE] DatastorePurchaseSystem: %s. To keep Studio tests apart, set another StudioDataStoreVersion in ReplicatedStorage.RBLXEssentials.Config.DatastorePurchaseSystem."):format(why)) end local manager = DataStoreManager.new({ config = config, defaults = defaults, safeId = safeId, Promise = Promise, Migration = Migration, Replicator = ValueReplicator, trove = managerTrove, }) -- The DataStore this server uses, PlayerData_ for Studio or live -- (plan B1): a diagnostic on the server module, which no client receives. -- Naming it opens nothing. ctx.serverFolder:SetAttribute("StoreName", manager:StoreName()) -- PurchaseCompleted - an OPTIONAL extension point, added 2026-08-25. -- -- It fires (player, kind, id, currencySpent) after every purchase this -- pack records as granted, where `kind` is "product" or "gamepass". It -- exists so Notifications System can announce purchases WITHOUT either -- pack declaring the other in manifest.deps - a declared dependency -- would make an optional companion mandatory, since the plugin refuses -- to install a pack whose deps are missing. Anyone can FindFirstChild it -- and connect; nobody has to. -- -- A BindableEvent rather than a field on the returned API on purpose: -- the returned table is only reachable through `ctx.require`, which -- asserts the caller declared this pack as a dependency. An Instance is -- reachable by path, which is the whole point. -- -- DS publishes a neutral fact and decides nothing about how it is shown. -- The wording and the on/off switches live in Notifications System's own -- settings, where a buyer looks for them. local purchaseCompleted = Instance.new("BindableEvent") purchaseCompleted.Name = "PurchaseCompleted" purchaseCompleted.Parent = ctx.serverFolder packTrove:Add(purchaseCompleted) -- FreeMode (plan B1, ruling 4) only takes effect in Studio, and not while -- Studio uses the live store (Config.lua). PurchaseManager reads `.Value` -- as it read the 2.x BoolValue; the configuration is frozen, so it never -- changes while the server runs. Clients (Easy Pet System's shop) read the -- same decision from the FreeMode attribute of this pack's -- ReplicatedStorage folder. local freeModeValue = table.freeze({ Value = config.FreeMode }) ctx.folder:SetAttribute("FreeMode", config.FreeMode) if config.FreeModeIgnored == "not Studio" then warn("[DatastorePurchaseSystem] FreeMode is on in Config.DatastorePurchaseSystem, but it only works in Studio: " .. "gamepass checks and product grants are real in this server. Set FreeMode = false in ReplicatedStorage.RBLXEssentials.Config.DatastorePurchaseSystem.") elseif config.FreeModeIgnored == "same stores" then warn(("[DatastorePurchaseSystem] FreeMode is on in Config.DatastorePurchaseSystem, but StudioDataStoreVersion equals DataStoreVersion (ignoring spaces and letter case), so Studio may use the live store PlayerData_%s and FreeMode stays off: it would grant passes and products into real players' profiles. Set another StudioDataStoreVersion to use FreeMode in Studio."):format( ctx.config.DataStoreVersion)) end local purchases = PurchaseManager.new({ manager = manager, freeModeValue = freeModeValue, trove = purchasesTrove, onPurchase = function(player, kind, id, currencySpent) purchaseCompleted:Fire(player, kind, id, currencySpent) end, }) MarketplaceService.ProcessReceipt = purchases._processReceipt -- v1 parity: pack owns character loading -- (Datastore & Purchase System/src/ServerScriptService/.../DataStoreSystem/Bootstrap.server.lua) Players.CharacterAutoLoads = false local function onPlayerAdded(player: Player) local ok, err = pcall(function() manager:Get(player) end) if not ok then warn(("[RBLXE] DatastorePurchaseSystem: data load failed for %s: %s"):format(player.Name, tostring(err))) player:Kick("Failed to load your data. Please rejoin.") return end player.CharacterAdded:Connect(function(character) local humanoid = character:WaitForChild("Humanoid", 10) :: Humanoid? if not humanoid then return end humanoid.Died:Connect(function() task.delay(Players.RespawnTime, function() if player.Parent then player:LoadCharacter() end end) end) end) -- Player may have left while manager:Get was yielding on the DataStore -- round trip; guard against loading a character for a departed player. if player.Parent ~= nil then player:LoadCharacter() end end packTrove:Connect(Players.PlayerAdded, function(player) task.spawn(onPlayerAdded, player) end) packTrove:Connect(Players.PlayerRemoving, function(player) safeId.CleanupPlayer(player) end) -- Backfill: players already in-game when this pack boots (e.g. Loader -- runs after PlayerAdded already fired for them) never get a PlayerAdded -- event of their own. for _, player in ipairs(Players:GetPlayers()) do task.spawn(onPlayerAdded, player) end game:BindToClose(function() pcall(function() manager:SaveAllImmediate(2.0) end) end) -- Dot-path convenience layer (2026-08-22; replaces v1's Cash-only -- PlayerMutators with path-addressed equivalents - see DataPath.lua). -- Paths are the ones the plugin's Default Data editor shows -- ("Stats.Cash"). SetValue/Increment go through manager:Update so the -- replica and the save scheduler see them like any other write; -- Increment's optional `floor` clamps (pass 0 for v1's AddCash behaviour). local function getValue(player, path) return DataPath.get(manager:Get(player), path) end local function setValue(player, path, value) local ok, err = true, nil manager:Update(player, function(data) ok, err = DataPath.set(data, path, value) end) if not ok then warn("[DataStore] SetValue:", err) end return ok, err end local function increment(player, path, delta, floor) local newValue, err = nil, nil manager:Update(player, function(data) newValue, err = DataPath.increment(data, path, delta, floor) end) if err then warn("[DataStore] Increment:", err) end return newValue, err end local function isFreeMode() return freeModeValue ~= nil and freeModeValue.Value == true end return { Get = function(player) return manager:Get(player) end, Update = function(player, fn) return manager:Update(player, fn) end, SaveAndWait = function(player, timeout) return manager:SaveAndWait(player, timeout) end, ReadSaved = function(userId) return manager:ReadSaved(userId) end, StoreName = function() return manager:StoreName() end, Save = function(player) return manager:Save(player) end, SaveAllImmediate = function(t) return manager:SaveAllImmediate(t) end, GetSafeUserId = function(player) return safeId.GetSafeUserId(player) end, GetValue = getValue, SetValue = setValue, Increment = increment, IsFreeMode = isFreeMode, registerHandler = purchases.registerHandler, registerProfileHandler = purchases.registerProfileHandler, HasPass = purchases.HasPass, HasPassStrict = purchases.HasPassStrict, GrantProduct = purchases.GrantProduct, InvalidatePass = purchases.InvalidatePass, PushRoot = ValueReplicator.PushRoot, } end ]]> -1 Actions 0 0 0 0 false -1 WipeStudioData 0 false " }, the store it would -- wipe (as T.backups.delete(id, { force = id }) names its backup): the -- plugin's Wipe Studio Data button passes it after its second click, and an -- AI assistant only once the user asked for the wipe (docs AI run -- datastore-ai-setup, 2026-10-09: an agent wiped them on its own). local DataStoreService = game:GetService("DataStoreService") local RunService = game:GetService("RunService") local ReplicatedStorage = game:GetService("ReplicatedStorage") local ServerScriptService = game:GetService("ServerScriptService") local PACK = "DatastorePurchaseSystem" local function fresh(module) return require(module:Clone()) end -- The store key of Config.lua's SameStores rule. local function storeKey(version: string): string return string.lower((string.gsub(string.gsub(version, "^%s+", ""), "%s+$", ""))) end local function configModule(service) local root = service:FindFirstChild("RBLXEssentials") local folder = root and root:FindFirstChild("Config") return folder and folder:FindFirstChild(PACK) end return function(opts) assert(RunService:IsStudio(), "WipeStudioData can only run in Studio") local rblx = ReplicatedStorage.RBLXEssentials local config, errors = fresh(rblx.Kernel.Config).load({ packId = PACK, side = "Server", schemaLib = fresh(rblx.Kernel.Schema), requireFn = fresh, schemaModule = rblx.Packs[PACK]:FindFirstChild("Schema"), sharedModule = configModule(ReplicatedStorage), serverModule = configModule(ServerScriptService), }) if config == nil then return false, "Nothing was wiped: the configuration of " .. PACK .. " is invalid: " .. table.concat(errors, "; ") end if config.StudioDataStoreVersion == config.DataStoreVersion then return false, ("Nothing was wiped: StudioDataStoreVersion and DataStoreVersion are both %q, so the Studio store PlayerData_%s is the live one, and wiping it would delete every player's profile. Set another StudioDataStoreVersion first."):format( config.DataStoreVersion, config.DataStoreVersion) end if storeKey(config.StudioDataStoreVersion) == storeKey(config.DataStoreVersion) then return false, ("Nothing was wiped: StudioDataStoreVersion %q and DataStoreVersion %q differ only in spaces or letter case, which may not make another DataStore, so wiping PlayerData_%s could delete every player's live profile. Set another StudioDataStoreVersion first."):format( config.StudioDataStoreVersion, config.DataStoreVersion, config.StudioDataStoreVersion) end local storeName = "PlayerData_" .. config.StudioDataStoreVersion if type(opts) ~= "table" or opts.confirm ~= storeName then return false, ("Nothing was wiped: wiping %s deletes every Studio profile in it for good, so it needs { confirm = %q }. Ask the user first: only once they agree, call it again with that argument (the plugin's Wipe Studio Data button passes it)."):format( storeName, storeName) end local ds = DataStoreService:GetDataStore(storeName) local pages = ds:ListKeysAsync() local count = 0 while true do for _, key in ipairs(pages:GetCurrentPage()) do ds:RemoveAsync(key.KeyName) count += 1 end if pages.IsFinished then break end pages:AdvanceToNextPageAsync() end return true, "Wiped " .. count .. " key(s) from " .. storeName end ]]> -1 Config 0 false -1 DataPath 0 false { "Stats", "Cash" }; nil for an empty or -- malformed path (leading/trailing/double dots). function DataPath.split(path: string?): { string }? if type(path) ~= "string" or path == "" then return nil end local parts = {} for part in path:gmatch("[^%.]+") do table.insert(parts, part) end if #parts == 0 or table.concat(parts, ".") ~= path then return nil end return parts end -- DataPath.get(data, path) -> value or nil (nil also when a step is not a table). function DataPath.get(data: any, path: string?): any local parts = DataPath.split(path) if parts == nil or type(data) ~= "table" then return nil end local cur = data for _, key in ipairs(parts) do if type(cur) ~= "table" then return nil end cur = cur[key] end return cur end -- DataPath.set(data, path, value) -> ok, err. Creates intermediate tables; -- refuses to walk THROUGH a non-table value ("Stats.Cash.X" when Cash = 0). function DataPath.set(data: any, path: string?, value: any): (boolean, string?) local parts = DataPath.split(path) if parts == nil then return false, ("Invalid data path: %q"):format(tostring(path)) end if type(data) ~= "table" then return false, "Profile is not a table." end local cur = data for i = 1, #parts - 1 do local key = parts[i] local nextNode = cur[key] if nextNode == nil then nextNode = {} cur[key] = nextNode elseif type(nextNode) ~= "table" then return false, ("Cannot set %q: %q is a %s, not a group."):format(path, table.concat(parts, ".", 1, i), type(nextNode)) end cur = nextNode end cur[parts[#parts]] = value return true, nil end -- DataPath.increment(data, path, delta, floor?) -> newValue?, err. A missing -- key counts as 0; a non-number key is refused. `floor` clamps the result -- (v1's AddCash never went below 0 - pass 0 to keep that behaviour). function DataPath.increment(data: any, path: string?, delta: number, floor: number?): (number?, string?) if type(delta) ~= "number" or delta ~= delta then return nil, "Delta must be a number." end local current = DataPath.get(data, path) if current ~= nil and type(current) ~= "number" then return nil, ("Cannot increment %q: it holds a %s."):format(tostring(path), type(current)) end local newValue = (current or 0) + delta if type(floor) == "number" then newValue = math.max(floor, newValue) end local ok, err = DataPath.set(data, path, newValue) if not ok then return nil, err end return newValue, nil end return DataPath ]]> -1 DataStoreManager 0 false 1 then task.wait(self._config.DataStore.RetryDelay * 2 ^ (attempt - 2)) end local ok, result = pcall(fn) if ok then resolve(result) else reject(result) end end) end, self._config.DataStore.MaxRetries) end -- Resolves (ok, loadedOrErr) for Get(). Once self._apiUnavailable is set, this -- never touches DataStoreService again - it resolves as "no saved data" so the -- caller's existing no-data/defaults path (Migration.migrate(nil, defaults)) -- handles it exactly like a first-time player. The FIRST failure of this kind -- still makes the real GetAsync call (that's how it's detected), classifies -- the error, warns once, and degrades gracefully for THIS call too - Get() -- must never throw/kick a player for an api-access failure, only for a -- genuine (transient) one, which is left byte-for-byte unchanged below. local function loadFromStore(self, key: string, claimSession: boolean?) if self._apiUnavailable then return true, nil end if isStudioUnpublished() then markApiUnavailable(self) return true, nil end local claimId = claimSession and generateGuid() or nil local observed, priorId, priorStart, rejected = false, nil, nil, false local ok, loadedOrErr = retryPromise(self, function() if claimId then return getStore(self):UpdateAsync(key, function(old, keyInfo) local meta = old and old.Meta if meta and meta.SessionId == claimId then return old, keyInfo and keyInfo:GetUserIds(), keyInfo and keyInfo:GetMetadata() end -- A retried request must not take ownership back from a newer claimant. if not observed then observed, priorId, priorStart = true, meta and meta.SessionId, meta and meta.SessionStart elseif (meta and meta.SessionId) ~= priorId or (meta and meta.SessionStart) ~= priorStart then rejected = true; return nil end if rejected then return nil end local data = self._Migration.migrate(old, self._defaults) data.Meta = data.Meta or {} data.Meta.SessionId, data.Meta.SessionFenced = claimId, true data.Meta.SessionStart = os.time() data.Meta.FirstJoinDate = data.Meta.FirstJoinDate or os.time() return data, keyInfo and keyInfo:GetUserIds(), keyInfo and keyInfo:GetMetadata() end) end return getStore(self):GetAsync(key) end):await() if not ok and isApiAccessError(loadedOrErr) then markApiUnavailable(self) return true, nil end if claimId and (rejected or (ok and (not loadedOrErr or loadedOrErr.Meta.SessionId ~= claimId))) then return false, "Profile ownership changed during load; please rejoin." end return ok, loadedOrErr end -- Resolves `wrote` for performSave(). Once self._apiUnavailable is set, this -- never touches DataStoreService again - saves are no-ops that report success -- (wrote = true) so the scheduler does not treat them as failures and retry- -- loop every ~6-10s. SaveAndWait explicitly excludes this in-memory fallback. -- A callback alone is not confirmation: the complete UpdateAsync must succeed. local function copySnapshot(value) if type(value) ~= "table" then return value end local result = {} for key, child in pairs(value) do result[key] = copySnapshot(child) end return result end local function saveToStore(self, uid: number, key: string, thisSessionStart: number, data: any) if self._lostSessions[uid] then return false end if self._apiUnavailable then return true end if isStudioUnpublished() then markApiUnavailable(self) return true end data = copySnapshot(data) -- freeze before the first yielding store call local wrote, lostSession = false, false local ok, err = retryPromise(self, function() wrote = false -- each attempt/callback must establish its own success return getStore(self):UpdateAsync(key, function(old, keyInfo) local oldMeta = old and old.Meta local oldStart = oldMeta and oldMeta.SessionStart if data.Meta and data.Meta.SessionFenced and (not oldMeta or oldMeta.SessionId ~= data.Meta.SessionId) then wrote = false; lostSession = true; return nil end if old == nil then wrote = true; return data end if type(oldStart) == "number" and type(thisSessionStart) == "number" and oldStart > thisSessionStart then wrote = false; return nil end wrote = true; return data, keyInfo and keyInfo:GetUserIds(), keyInfo and keyInfo:GetMetadata() end) end):await() if lostSession then self._lostSessions[uid] = true self._saveQueue[uid], self._nextDue[uid] = nil, nil local state = self._playerState[uid] if state and state.player and state.player.Parent then pcall(function()state.player:Kick("Your profile opened in another server. Please rejoin.")end) end end if not ok and isApiAccessError(err) then markApiUnavailable(self) wrote = true end return wrote and (ok or self._apiUnavailable) end local function waitForBudget(reqType: Enum.DataStoreRequestType, maxWait: number) local DataStoreService = game:GetService("DataStoreService") local deadline = os.clock() + maxWait while os.clock() < deadline do if DataStoreService:GetRequestBudgetForRequestType(reqType) > 0 then return true end task.wait(0.1) end return false end local function scheduleNext(self, uid: number, nowClock: number?) local now = nowClock or os.clock() local interval = self._config.DataStore.AutoSaveInterval local jf = (self._config.DataStore.SaveSmoothing and self._config.DataStore.SaveSmoothing.JitterFraction) or 0 local jitter = interval * jf * (math.random()*2 - 1) self._nextDue[uid] = now + math.max(10, interval + jitter) end local function scheduleFirstDue(self, uid: number) scheduleNext(self, uid, os.clock()) end -- Minimal per-player leave-tracking handle - see header comment for why this -- isn't a full kernel Trove instance. Same call shape as v1 (`:Clean()`). local function newLeaveTrove() local handle = { _conn = nil :: RBXScriptConnection? } function handle:Connect(signal, fn) self._conn = signal:Connect(fn) end function handle:Clean() if self._conn then self._conn:Disconnect() self._conn = nil end end return handle end local function performSave(self, uid: number) local data = self._cache[uid] if not data then return false end if not data.Meta then log.warn(("Refusing to save data for uid %d: missing Meta"):format(uid)) return false end local hasRealSession = data.Meta.SessionId and data.Meta.SessionStart local hasBeenSaved = data.Meta.SaveCount and data.Meta.SaveCount > 0 local hasFirstJoin = data.Meta.FirstJoinDate if not hasRealSession and not hasBeenSaved and not hasFirstJoin then log.warn(("Refusing to save data for uid %d: looks like corrupted/empty data"):format(uid)) return false end data.Meta = data.Meta or {} data.Meta.LastSaveDate = os.time() data.Meta.SaveCount = (data.Meta.SaveCount or 0) + 1 data.Meta.SessionId = data.Meta.SessionId or generateGuid() data.Meta.SessionStart = data.Meta.SessionStart or os.time() local thisSessionStart = data.Meta.SessionStart local wrote = false -- Key unification: the ONLY key ever used to save is the one derived and -- stored at load time (Get()). No second/independent derivation here. local key = self._keys[uid] local revision = self._revisions[uid] or 0 wrote = saveToStore(self, uid, key, thisSessionStart, data) if wrote then self._lastPlayerSaveAt[uid] = os.clock() end if self._playerState[uid] and self._playerState[uid].removed and wrote and revision == (self._revisions[uid] or 0) then self._cache[uid] = nil self._nextDue[uid] = nil self._playerState[uid] = nil self._keys[uid] = nil -- pairs with self._cache[uid]'s lifecycle; not in v1 (v1 had no stored key) self._revisions[uid] = nil end return wrote end local function startScheduler(self) if self._schedulerStarted then return end self._schedulerStarted = true local function failureBackoffSeconds() return 6 + math.random() * 4 end local RunService = game:GetService("RunService") self._trove:Connect(RunService.Heartbeat, function() local now = os.clock() local minGap = (self._config.DataStore.SaveSmoothing and self._config.DataStore.SaveSmoothing.MinGapSeconds) or 0 if (now - self._lastSaveAt) < minGap then return end if (self._config.DataStore.SaveSmoothing and self._config.DataStore.SaveSmoothing.RespectBudget) and not self._apiUnavailable then local DataStoreService = game:GetService("DataStoreService") local budget = DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.UpdateAsync) if budget <= 0 then return end end local perMin = (self._config.DataStore.SaveSmoothing and self._config.DataStore.SaveSmoothing.PerPlayerMinInterval) or 0 for uid in pairs(self._saveQueue) do self._saveQueue[uid] = nil if self._lostSessions[uid] then self._nextDue[uid] = nil; continue end if self._inFlight[uid] then return end if (now - (self._lastPlayerSaveAt[uid] or 0)) < perMin then self._nextDue[uid] = math.max(self._nextDue[uid] or 0, (self._lastPlayerSaveAt[uid] or now) + perMin) return end self._inFlight[uid] = true local ran, wrote = pcall(performSave, self, uid) local ok = ran and wrote self._lastSaveAt = now if ok then scheduleNext(self, uid, now) else self._nextDue[uid] = math.max(self._nextDue[uid] or 0, now + failureBackoffSeconds()) end self._inFlight[uid] = nil return end local dueUid, earliest = nil, math.huge for uid, due in pairs(self._nextDue) do if self._lostSessions[uid] then self._nextDue[uid] = nil; continue end if due < earliest then earliest, dueUid = due, uid end end if not dueUid or earliest > now then return end if self._inFlight[dueUid] then return end if (now - (self._lastPlayerSaveAt[dueUid] or 0)) < perMin then self._nextDue[dueUid] = (self._lastPlayerSaveAt[dueUid] or now) + perMin return end self._inFlight[dueUid] = true local ran, wrote = pcall(performSave, self, dueUid) local ok = ran and wrote self._lastSaveAt = now if ok then scheduleNext(self, dueUid, now) else self._nextDue[dueUid] = math.max(self._nextDue[dueUid] or 0, now + failureBackoffSeconds()) end self._inFlight[dueUid] = nil end) end -- deps = { config, defaults, safeId, Promise, Migration, Replicator, trove } -- No game-service access here - constructible in Lune. function Manager.new(deps) local self = setmetatable({}, Manager) self._config = deps.config self._defaults = deps.defaults self._safeId = deps.safeId self._Promise = deps.Promise self._Migration = deps.Migration self._Replicator = deps.Replicator self._trove = deps.trove self._store = nil -- lazily created by getStore() on first Get()/save self._apiUnavailable = false -- flip validation fix: see markApiUnavailable() above self._cache = {} self._loading = {} self._nextDue = {} self._saveQueue = {} self._lastSaveAt = 0 self._lastPlayerSaveAt = {} self._schedulerStarted = false self._inFlight = {} self._playerTroves = {} self._playerState = {} self._keys = {} -- [uid] = safeId.GetSafeKey(player) captured at load - fix #2 self._lostSessions = {} self._revisions = {} return self end local function bindPlayer(self, uid, player) if self._playerState[uid] and self._playerState[uid].player == player then return end if self._playerTroves[uid] then self._playerTroves[uid]:Clean() end local t = newLeaveTrove() self._playerTroves[uid] = t self._playerState[uid] = { removed = false, player = player } t:Connect(player.AncestryChanged, function(_, parent) if parent == nil and self._playerState[uid] and self._playerState[uid].player == player then t:Clean() self._playerTroves[uid] = nil if self._cache[uid] then self._playerState[uid] = self._playerState[uid] or { removed = true } self._playerState[uid].removed = true self._saveQueue[uid] = true local nowClock = os.clock() local perMin = (self._config.DataStore.SaveSmoothing and self._config.DataStore.SaveSmoothing.PerPlayerMinInterval) or 0 self._nextDue[uid] = math.max(self._nextDue[uid] or 0, (self._lastPlayerSaveAt[uid] or nowClock) + math.max(0.2, perMin * 0.25)) end end end) self._Replicator.PushRoot(player, "PlayerData", self._cache[uid]) end function Manager:Get(player: Player) local safeId = self._safeId local uid = safeId.GetSafeUserId(player) if self._lostSessions[uid] then local state = self._playerState[uid] if not state or state.player == player or (state.player and state.player.Parent) then error("Profile session is no longer owned by this server") end -- A later Player can rejoin this server, but must load the current stored -- profile instead of adopting the invalid cache from its old session. while self._inFlight[uid] do task.wait(0.1) end if self._playerTroves[uid] then self._playerTroves[uid]:Clean() end self._cache[uid], self._keys[uid], self._playerState[uid], self._playerTroves[uid] = nil, nil, nil, nil self._lostSessions[uid], self._revisions[uid], self._saveQueue[uid], self._nextDue[uid] = nil, nil, nil, nil end if self._cache[uid] then bindPlayer(self, uid, player); return self._cache[uid] end -- Deduplicate concurrent loads: only one GetAsync per uid may be in flight. -- A second concurrent Get would otherwise replace cache[uid] with a freshly -- migrated table, silently discarding any writes made to the first one. while self._loading[uid] do task.wait() if self._cache[uid] then bindPlayer(self, uid, player); return self._cache[uid] end end self._loading[uid] = true -- Single derivation of the save key, captured now so performSave never -- has to (and never does) re-derive it independently. local key = safeId.GetSafeKey(player) local ok, loadedOrErr = loadFromStore(self, key, true) if self._cache[uid] then self._loading[uid] = nil bindPlayer(self, uid, player) return self._cache[uid] end local data if not ok then self._loading[uid] = nil error(("[DataStore] Failed to load data for user %d: %s"):format(uid, tostring(loadedOrErr))) elseif loadedOrErr == nil then data = self._Migration.migrate(nil, self._defaults) else data = self._Migration.migrate(loadedOrErr, self._defaults) end local now = os.time() data.Meta = data.Meta or {} data.Meta.SessionStart = now data.Meta.LastSaveDate = now data.Meta.SessionId = data.Meta.SessionFenced and data.Meta.SessionId or generateGuid() if loadedOrErr == nil then data.Meta.FirstJoinDate = data.Meta.FirstJoinDate or now end self._cache[uid] = data self._keys[uid] = key self._loading[uid] = nil scheduleFirstDue(self, uid) startScheduler(self) bindPlayer(self, uid, player) return data end function Manager:Update(player: Player, patch: (data: any) -> ()) local uid = self._safeId.GetSafeUserId(player) local data = self:Get(player) patch(data) self._revisions[uid] = (self._revisions[uid] or 0) + 1 self._Replicator.PushRoot(player, "PlayerData", data) end function Manager:Save(player: Player) if not player then return false end if self._lostSessions[self._safeId.GetSafeUserId(player)] then return false end self._saveQueue[self._safeId.GetSafeUserId(player)] = true return true end -- A profile-only grant is staged synchronously. Never yield, send remotes or -- mutate external state in patch. Receipt and reward enter the cache together. function Manager:ApplyProfilePurchase(player, purchaseId, patch) local data = self:Get(player) local history = data.Purchases and data.Purchases.ReceiptHistory or {} if purchaseId and table.find(history, purchaseId) then return true, false end local staged = copySnapshot(data) local thread = coroutine.create(patch) local ok, granted, result = coroutine.resume(thread, staged) if coroutine.status(thread) ~= "dead" then pcall(task.cancel, thread); pcall(coroutine.close, thread) return false, false, "Profile purchase callback must not yield" end if not ok or granted ~= true then return false, false, ok and result or granted end staged.Purchases = staged.Purchases or {} staged.Purchases.ReceiptHistory = staged.Purchases.ReceiptHistory or {} if purchaseId then table.insert(staged.Purchases.ReceiptHistory, purchaseId) end -- Detach the committed values from any references retained by the callback. staged = copySnapshot(staged) for key in pairs(data) do data[key] = nil end for key, value in pairs(staged) do data[key] = value end local uid = self._safeId.GetSafeUserId(player) self._revisions[uid] = (self._revisions[uid] or 0) + 1 self._saveQueue[uid] = true pcall(self._Replicator.PushRoot, player, "PlayerData", data) return true, true, result end function Manager:ReadSaved(userId: number) assert(type(userId) == "number" and userId > 0 and userId % 1 == 0, "invalid_user") if self._apiUnavailable or isStudioUnpublished() then error("storage_unavailable") end local options = Instance.new("DataStoreGetOptions"); options.UseCache = false local ok, value = retryPromise(self, function()return getStore(self):GetAsync(tostring(userId), options)end):await() if not ok then error(value) end return value end function Manager:StoreName() return storeName(self._config.DataStore) end -- Unlike Save (queue only), this confirms a durable write before a handoff. -- Callers must pause their profile mutations until it returns. function Manager:SaveAndWait(player: Player, lockTimeout: number?) if not player or self._apiUnavailable then return false end local uid = self._safeId.GetSafeUserId(player) if self._lostSessions[uid] then return false end local deadline = os.clock() + (lockTimeout or 15) while self._inFlight[uid] do if os.clock() >= deadline then return false end task.wait(0.1) end if not self._cache[uid] or self._apiUnavailable then return false end self._inFlight[uid] = true self._saveQueue[uid] = nil local ok, wrote = pcall(performSave, self, uid) self._inFlight[uid] = nil if ok and wrote and not self._apiUnavailable then if self._cache[uid] then scheduleNext(self, uid) end return true end if self._cache[uid] and not self._lostSessions[uid] then self._saveQueue[uid] = true end return false end function Manager:SaveAllImmediate(maxWaitPerWrite: number?) maxWaitPerWrite = maxWaitPerWrite or 2.0 self._trove:Clean() for uid, _ in pairs(self._cache) do if not self._apiUnavailable then waitForBudget(Enum.DataStoreRequestType.UpdateAsync, maxWaitPerWrite) end local deadline = os.clock() + maxWaitPerWrite while self._inFlight[uid] and os.clock() < deadline do task.wait(0.1) end local ok = false if not self._inFlight[uid] then self._inFlight[uid] = true local ran, wrote = pcall(performSave, self, uid) self._inFlight[uid] = nil ok = ran and wrote end if ok then log.print(("SaveAllImmediate: saved %d"):format(uid)) else log.warn(("SaveAllImmediate: skipped/stale %d"):format(uid)) end end end function Manager:Stop() self._trove:Clean() end -- Test-only accessor: number of entries currently cached on THIS instance. -- Used by tests/manager.spec.luau to prove two new() calls share no state. function Manager:_cacheCount(): number local n = 0 for _ in pairs(self._cache) do n += 1 end return n end -- Test-only hooks (flip-validation fix): exercise the real load/save-vs-store -- short-circuit logic without needing a live Player/ValueReplicator round trip -- (Get()/performSave() need a real Player Instance for AncestryChanged/PushRoot, -- which Lune cannot provide - see tests/manager.spec.luau header comment). function Manager:_loadFromStoreForTest(key: string, claimSession: boolean?) return loadFromStore(self, key, claimSession) end function Manager:_saveToStoreForTest(uid: number, key: string, thisSessionStart: number, data: any) return saveToStore(self, uid, key, thisSessionStart, data) end -- Test-only hook: directly exercises markApiUnavailable()'s idempotency guard -- (the "warns exactly once" latch) without needing a failing store round trip. function Manager:_markApiUnavailableForTest() return markApiUnavailable(self) end -- Exposed for direct pure-function testing (mirrors PurchaseManager.shouldProcess/ -- record's precedent of exposing small pure helpers on the module table). Manager.isApiAccessError = isApiAccessError return Manager ]]> -1 DefaultData 0 false Default Data. A top-level Meta is ignored, as in 2.x (the -- Schema refuses one). for key, value in pairs(saved) do if result[key] == nil then result[key] = value end end return result end return DefaultData ]]> -1 Migration 0 false -1 PurchaseManager 0 false cap do table.remove(history, 1) end end -- deps = { manager, freeModeValue: BoolValue?, trove, onPurchase: function? } -- -- `onPurchase(player, kind, id, currencySpent)` is an OPTIONAL callback, added -- 2026-08-25 for Notifications System. It is a plain function rather than an -- Instance so this module stays constructible in Lune with no `game` global; -- init.lua owns the BindableEvent it fires. Three call sites, all AFTER the -- grant is recorded - announcing a purchase that then failed to land would be -- worse than announcing nothing - and every one of them wrapped in a pcall, -- because a listener's bug must never break a receipt. -- No unconditional game-service access here - see header comment. new() is -- constructible in Lune with zero `game` global at all. local function new(deps) local manager = deps.manager local trove = deps.trove -- Fire-and-forget: a listener that errors must not change what -- ProcessReceipt returns to Roblox. local function announce(player, kind, id, currencySpent) if type(deps.onPurchase) ~= "function" then return end local ok, err = pcall(deps.onPurchase, player, kind, id, currencySpent) if not ok then warn("[PurchaseManager] onPurchase listener failed:", err) end end -- productId (number) -> handler function. Instance state (was a module -- upvalue in v1). local handlers = {} local profileHandlers = {} local receiptBusy = {} local pendingNotices = {} local warnedLegacy = {} -- uid -> passId -> bool. Instance state (was a module upvalue in v1). local passCache = {} local passNeedsSave = {} local pm = {} -- Register a handler for a dev product ID. callback receives (player, -- receiptInfo) and must return true if the purchase was granted. v1 had no -- duplicate-registration guard - a second registerHandler call for the same -- productId silently overwrites the first. Ported verbatim: no guard here either. function pm.registerHandler(productId, callback) handlers[productId] = callback profileHandlers[productId] = nil end -- grant(player, draft, receipt) -> true, presentationPayload -- Only mutate draft; no yields or external effects. Notify after persistence. function pm.registerProfileHandler(productId, grant, afterCommit) assert(type(grant) == "function", "Profile grant callback required") profileHandlers[productId] = {grant=grant, afterCommit=afterCommit} handlers[productId] = nil end function pm.InvalidatePass(player, passId) local uid = player.UserId if passCache[uid] then passCache[uid][passId] = nil end end -- Verifies ownership independently of FreeMode. Saved gamepasses include -- gifts and are checked before a negative marketplace cache entry. Only -- trusted server code may grant them. API/update failures return false in -- the second result so callers can retry; FreeMode never creates ownership. function pm.HasPassStrict(player, passId) if type(passId) ~= "number" or passId <= 0 or passId % 1 ~= 0 then return false, true end local uid = player.UserId passCache[uid] = passCache[uid] or {} passNeedsSave[uid] = passNeedsSave[uid] or {} -- Keep this lookup valid if PlayerRemoving clears the tables while an API yields. local cache, needsSave = passCache[uid], passNeedsSave[uid] local function queueRegistration() local ok, queued = pcall(manager.Save, manager, player) if not ok or queued == false then return false end needsSave[passId] = nil return true end -- Confirmed positive rights are permanent; negatives cannot hide gifts. if cache[passId] == true then return true, true end -- Check datastore local dsOk, data = pcall(function() return manager:Get(player) end) if dsOk and data and data.Purchases and data.Purchases.Gamepasses and data.Purchases.Gamepasses[tostring(passId)] then if needsSave[passId] and not queueRegistration() then return true, false end cache[passId] = true return true, true end if cache[passId] == false then return false, dsOk and data ~= nil end -- Fall back to MarketplaceService (lazy fetch: only reached on a cache -- AND datastore miss). local MarketplaceService = game:GetService("MarketplaceService") local mpsOk, owns = pcall(MarketplaceService.UserOwnsGamePassAsync, MarketplaceService, uid, passId) if not mpsOk then return false,false end -- transient failure must not poison the negative cache local result = owns==true -- Persist to datastore if confirmed owned if result then needsSave[passId] = true local stored = pcall(function() manager:Update(player, function(d) d.Purchases = d.Purchases or {} d.Purchases.Gamepasses = d.Purchases.Gamepasses or {} d.Purchases.Gamepasses[tostring(passId)] = true end) end) -- Do not cache success before recording it: a failed Update must -- retry instead of leaving an API-only entitlement for this session. if not stored or not queueRegistration() then return true,false end elseif not dsOk or not data then -- An API denial cannot establish absence of a saved gift if data failed to load. return false, false end cache[passId] = result return result, true end -- CLEANUP302 (3.0.1, security): PromptGamePassPurchaseFinished comes -- from the client side of the purchase prompt, so an exploiter can fire -- it with wasPurchased = true for a pass they never bought. It only ever -- invalidates the cache (a real purchase must be re-checked at once) and -- grants nothing. The public "bought the pass" announcement waits for -- HasPassStrict (UserOwnsGamePassAsync, or the saved record), in its own -- thread so the handler never yields, and is made once per player and -- pass: never for a pass the player's profile already recorded before the -- event (an old purchase or a gift), never twice for repeated events. local announcedPasses = {} function pm._onGamePassPurchaseFinished(player, passId, wasPurchased) if not wasPurchased or type(passId) ~= "number" then return end local uid = player.UserId local seen = announcedPasses[uid] or {} announcedPasses[uid] = seen if seen[passId] then return end seen[passId] = true -- claimed now: a second event during the check is ignored local knownBefore = passCache[uid] ~= nil and passCache[uid][passId] == true pm.InvalidatePass(player, passId) task.spawn(function() local okData, data = pcall(function() return manager:Get(player) end) local saved = okData and type(data) == "table" and type(data.Purchases) == "table" and type(data.Purchases.Gamepasses) == "table" and data.Purchases.Gamepasses[tostring(passId)] == true if knownBefore or saved then return -- owned before this event: not a new purchase end local okOwns, owns = pcall(pm.HasPassStrict, player, passId) if okOwns and owns == true then announce(player, "gamepass", passId, nil) else seen[passId] = nil -- not confirmed: a later real event may still announce end end) end function pm.HasPass(player,passId) if deps.freeModeValue and deps.freeModeValue.Value then return true end return pm.HasPassStrict(player,passId) end -- Directly grants a dev product in FreeMode without going through -- MarketplaceService. Returns true if the handler ran successfully. function pm.GrantProduct(player, productId) if not (deps.freeModeValue and deps.freeModeValue.Value) then return false end local profileHandler = profileHandlers[productId] if profileHandler then local ok, applied, fresh, payload = pcall(manager.ApplyProfilePurchase, manager, player, nil, function(draft) return profileHandler.grant(player, draft, nil) end) if not ok or not applied then return false end if fresh and profileHandler.afterCommit then pcall(profileHandler.afterCommit, player, payload) end announce(player, "product", productId, 0) return true end local handler = handlers[productId] if not handler then return false end local ok, granted = pcall(handler, player, nil) if ok and granted then -- FreeMode grants announce too: it is how a purchase -- announcement can be tested in Studio without spending Robux. announce(player, "product", productId, 0) end return ok and granted end -- Called by Task 5's `MarketplaceService.ProcessReceipt` binding. local function processReceipt(receiptInfo) local Players = game:GetService("Players") local player = Players:GetPlayerByUserId(receiptInfo.PlayerId) if not player then return Enum.ProductPurchaseDecision.NotProcessedYet end local handler = handlers[receiptInfo.ProductId] local profileHandler = profileHandlers[receiptInfo.ProductId] -- Fix #1: load data, ensure ReceiptHistory exists, dedupe before running -- the handler. local data = manager:Get(player) data.Purchases = data.Purchases or {} data.Purchases.ReceiptHistory = data.Purchases.ReceiptHistory or {} local history = data.Purchases.ReceiptHistory local noticeKey = tostring(receiptInfo.PlayerId)..":"..receiptInfo.PurchaseId if shouldProcess(history, receiptInfo.PurchaseId) then if not handler and not profileHandler then warn("[PurchaseManager] Unhandled product ID:", receiptInfo.ProductId) return Enum.ProductPurchaseDecision.NotProcessedYet end local granted, payload if profileHandler then local applied, fresh, result = manager:ApplyProfilePurchase(player, receiptInfo.PurchaseId, function(draft) return profileHandler.grant(player, draft, receiptInfo) end) granted, payload = applied, result else -- Compatibility only: arbitrary legacy callbacks cannot be made -- atomic retroactively. Built-in rewards use registerProfileHandler. if not warnedLegacy[receiptInfo.ProductId] then warnedLegacy[receiptInfo.ProductId] = true warn("[PurchaseManager] Migrate product to registerProfileHandler for atomic rewards:", receiptInfo.ProductId) end granted = handler(player, receiptInfo) == true if granted then record(history, receiptInfo.PurchaseId) end end if not granted then return Enum.ProductPurchaseDecision.NotProcessedYet end pendingNotices[noticeKey] = {payload=payload, player=player, afterCommit=profileHandler and profileHandler.afterCommit} end -- Even a cached duplicate may be an earlier unconfirmed write. if not manager:SaveAndWait(player) then return Enum.ProductPurchaseDecision.NotProcessedYet end local notice = pendingNotices[noticeKey] pendingNotices[noticeKey] = nil if notice then if notice.afterCommit then pcall(notice.afterCommit, player, notice.payload) end announce(player, "product", receiptInfo.ProductId, receiptInfo.CurrencySpent) end return Enum.ProductPurchaseDecision.PurchaseGranted end function pm._processReceipt(receiptInfo) local uid = receiptInfo.PlayerId if receiptBusy[uid] then return Enum.ProductPurchaseDecision.NotProcessedYet end receiptBusy[uid] = true local ok, result = pcall(processReceipt, receiptInfo) receiptBusy[uid] = nil if not ok then warn("[PurchaseManager] Receipt remains pending:", tostring(result)) return Enum.ProductPurchaseDecision.NotProcessedYet end return result end -- v1 rule 1: PromptGamePassPurchaseFinished / PlayerRemoving move here, -- registered on deps.trove instead of connected at require time. Wrapped in -- one pcall - see header comment for why (Lune has no `game` global at all; -- in live Roblox this pcall is always a no-op success). pcall(function() local MarketplaceService = game:GetService("MarketplaceService") local Players = game:GetService("Players") -- Auto-invalidate cache when a pass is purchased mid-session trove:Connect(MarketplaceService.PromptGamePassPurchaseFinished, pm._onGamePassPurchaseFinished) trove:Connect(Players.PlayerRemoving, function(player) passCache[player.UserId] = nil announcedPasses[player.UserId] = nil passNeedsSave[player.UserId] = nil for key, notice in pairs(pendingNotices) do if notice.player == player then pendingNotices[key] = nil end end end) end) return pm end return { new = new, shouldProcess = shouldProcess, record = record, } ]]> -1 StudioSafeId 0 false 0 then -- Positive UserId (real account) - use as-is. return player.UserId end -- Non-positive UserId - generate/reuse a unique synthetic id. if not studioIdCache[player] then studioIdCache[player] = generateStudioId() warn(string.format("[StudioSafeId] Generated unique ID %d for test client %s (original: %d, Player: %s)", studioIdCache[player], player.Name, player.UserId, tostring(player))) end return studioIdCache[player] end -- Get a safe string key for DataStore operations. function safeId.GetSafeKey(player: Player): string return tostring(safeId.GetSafeUserId(player)) end -- Clean up cache when player leaves. function safeId.CleanupPlayer(player: Player) if studioIdCache[player] then studioIdCache[player] = nil end end return safeId end ]]> -1 ValueReplicator 0 false -1 StarterPlayerScripts 0 0 0 0 false -1 KernelClient 0 false 0 false -1 RBLXE_Major3 AQAAAAoAAABSQkxYRV9Ob3RlAnIAAABSQkxYIEVzc2VudGlhbHMgMy54OiBpbnN0YWxsIGl0IHdpdGggdGhlIFJCTFggRXNzZW50aWFscyAzLjAgcGx1Z2luIG9yIFRvb2xzLiBBIDIueCBwbHVnaW4gcmVmdXNlcyB0aGlzIGNvbnRhaW5lci4= 0 0 0 0 false -1