@quenty/binder 14.40.0 → 14.41.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [14.41.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/binder@14.40.0...@quenty/binder@14.41.0) (2026-07-23)
+
+### Features
+
+- Add baseline player-mock and support across Nevermore for mocked players. ([567d121](https://github.com/Quenty/NevermoreEngine/commit/567d121ffc014b42391554088189a1a6296dda83))
+
 # [14.40.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/binder@14.39.0...@quenty/binder@14.40.0) (2026-07-22)
 
 **Note:** Version bump only for package @quenty/binder

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/binder",
-  "version": "14.40.0",
+  "version": "14.41.0",
   "description": "Utility object to Bind a class to Roblox object, and associated helper methods",
   "keywords": [
     "Roblox",
@@ -28,24 +28,24 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/baseobject": "10.14.0",
-    "@quenty/brio": "14.32.0",
-    "@quenty/canceltoken": "11.21.0",
-    "@quenty/instanceutils": "13.32.0",
-    "@quenty/linkutils": "13.33.0",
+    "@quenty/baseobject": "10.15.0",
+    "@quenty/brio": "14.33.0",
+    "@quenty/canceltoken": "11.22.0",
+    "@quenty/instanceutils": "13.33.0",
+    "@quenty/linkutils": "13.34.0",
     "@quenty/loader": "10.11.0",
-    "@quenty/maid": "3.10.0",
-    "@quenty/nevermore-test-runner": "1.4.0",
-    "@quenty/promise": "10.20.0",
-    "@quenty/rx": "13.30.0",
-    "@quenty/servicebag": "11.19.0",
+    "@quenty/maid": "3.11.0",
+    "@quenty/nevermore-test-runner": "1.5.0",
+    "@quenty/promise": "10.21.0",
+    "@quenty/rx": "13.31.0",
+    "@quenty/servicebag": "11.20.0",
     "@quenty/signal": "7.13.1",
     "@quenty/table": "3.9.2",
-    "@quenty/valueobject": "13.33.0",
+    "@quenty/valueobject": "13.34.0",
     "@quentystudios/jest-lua": "3.10.0-quenty.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "93f15b200c0f465a0b5304fcf05f5cfe7fdcbd1d"
+  "gitHead": "1de37218a2bedb8e3f8614a2e09bba9eddc812da"
 }

package/src/Shared/Binder.Loading.spec.lua

@@ -0,0 +1,54 @@
+--!strict
+--[[
+	@class Binder.Loading.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local BinderTestUtils = require("BinderTestUtils")
+local Jest = require("Jest")
+local Signal = require("Signal")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+local setup = BinderTestUtils.setup
+
+describe("Binder load abandonment", function()
+	it("does not bind a class when the instance is removed while the constructor yields", function()
+		local controller = setup()
+
+		local entered = Signal.new()
+		local resume = Signal.new()
+		local constructed = 0
+
+		local binder = controller.addBinder(function(inst)
+			constructed += 1
+			entered:Fire()
+			resume:Wait()
+			return { instance = inst }
+		end)
+		controller.boot()
+
+		local inst = controller.newInstance()
+		binder:Tag(inst)
+
+		-- The constructor may run synchronously on Tag or be deferred; wait until it has entered.
+		if constructed == 0 then
+			entered:Wait()
+		end
+
+		expect(constructed).toEqual(1)
+		expect(binder:Get(inst)).toBeNil()
+
+		binder:Untag(inst)
+		resume:Fire()
+		task.wait()
+
+		expect(binder:Get(inst)).toBeNil()
+		expect(constructed).toEqual(1)
+
+		controller.destroy()
+	end)
+end)

package/src/Shared/Binder.ObserveBrio.spec.lua

@@ -0,0 +1,209 @@
+--!strict
+--[[
+	@class Binder.ObserveBrio.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local BinderTestUtils = require("BinderTestUtils")
+local Brio = require("Brio")
+local Jest = require("Jest")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+local setup = BinderTestUtils.setup
+local makeTrackingClass = BinderTestUtils.makeTrackingClass
+local awaitUnbound = BinderTestUtils.awaitUnbound
+
+describe("Binder:ObserveBrio()", function()
+	it("emits a live brio wrapping the class on bind", function()
+		local controller = setup()
+
+		local binder = controller.addBinder(makeTrackingClass())
+		controller.boot()
+
+		local inst = controller.newInstance()
+
+		local brios = {}
+		local sub = binder:ObserveBrio(inst):Subscribe(function(brio: Brio.Brio<any>)
+			table.insert(brios, brio)
+		end)
+
+		expect(#brios).toEqual(0)
+
+		binder:Tag(inst)
+		local ok, class = binder:Promise(inst):Yield()
+		assert(ok, "Never bound")
+
+		expect(#brios).toEqual(1)
+		expect(Brio.isBrio(brios[1])).toEqual(true)
+		expect(brios[1]:IsDead()).toEqual(false)
+		expect(brios[1]:GetValue()).toEqual(class)
+
+		sub:Destroy()
+		controller.destroy()
+	end)
+
+	it("emits immediately when the instance is already bound", function()
+		local controller = setup()
+
+		local binder = controller.addBinder(makeTrackingClass())
+		controller.boot()
+
+		local inst = controller.newInstance()
+		binder:Tag(inst)
+		local ok, class = binder:Promise(inst):Yield()
+		assert(ok, "Never bound")
+
+		local brios = {}
+		local sub = binder:ObserveBrio(inst):Subscribe(function(brio: Brio.Brio<any>)
+			table.insert(brios, brio)
+		end)
+
+		expect(#brios).toEqual(1)
+		expect(brios[1]:IsDead()).toEqual(false)
+		expect(brios[1]:GetValue()).toEqual(class)
+
+		sub:Destroy()
+		controller.destroy()
+	end)
+
+	it("kills the emitted brio when the instance unbinds", function()
+		local controller = setup()
+
+		local binder = controller.addBinder(makeTrackingClass())
+		controller.boot()
+
+		local inst = controller.newInstance()
+
+		local brios = {}
+		local sub = binder:ObserveBrio(inst):Subscribe(function(brio: Brio.Brio<any>)
+			table.insert(brios, brio)
+		end)
+
+		binder:Tag(inst)
+		assert((binder:Promise(inst):Yield()), "Never bound")
+		expect(brios[1]:IsDead()).toEqual(false)
+
+		binder:Untag(inst)
+		awaitUnbound(binder, inst)
+
+		expect(brios[1]:IsDead()).toEqual(true)
+
+		sub:Destroy()
+		controller.destroy()
+	end)
+
+	it("emits a fresh live brio when the instance rebinds", function()
+		local controller = setup()
+
+		local binder = controller.addBinder(makeTrackingClass())
+		controller.boot()
+
+		local inst = controller.newInstance()
+
+		local brios = {}
+		local sub = binder:ObserveBrio(inst):Subscribe(function(brio: Brio.Brio<any>)
+			table.insert(brios, brio)
+		end)
+
+		binder:Tag(inst)
+		assert((binder:Promise(inst):Yield()), "Never bound")
+
+		binder:Untag(inst)
+		awaitUnbound(binder, inst)
+
+		binder:Tag(inst)
+		local ok, class = binder:Promise(inst):Yield()
+		assert(ok, "Never rebound")
+
+		expect(#brios).toEqual(2)
+		expect(brios[1]:IsDead()).toEqual(true)
+		expect(brios[2]:IsDead()).toEqual(false)
+		expect(brios[2]:GetValue()).toEqual(class)
+
+		sub:Destroy()
+		controller.destroy()
+	end)
+end)
+
+describe("Binder:ObserveAllBrio()", function()
+	it("emits a live brio for every already-bound class on subscribe", function()
+		local controller = setup()
+
+		local binder = controller.addBinder(makeTrackingClass())
+		controller.boot()
+
+		local instA = controller.newInstance()
+		local instB = controller.newInstance()
+		binder:Tag(instA)
+		binder:Tag(instB)
+		assert((binder:Promise(instA):Yield()), "A never bound")
+		assert((binder:Promise(instB):Yield()), "B never bound")
+
+		local values = {}
+		local sub = binder:ObserveAllBrio():Subscribe(function(brio: Brio.Brio<any>)
+			expect(brio:IsDead()).toEqual(false)
+			values[brio:GetValue()] = true
+		end)
+
+		expect(values[binder:Get(instA)]).toEqual(true)
+		expect(values[binder:Get(instB)]).toEqual(true)
+
+		sub:Destroy()
+		controller.destroy()
+	end)
+
+	it("emits a brio when a new class is added", function()
+		local controller = setup()
+
+		local binder = controller.addBinder(makeTrackingClass())
+		controller.boot()
+
+		local brios = {}
+		local sub = binder:ObserveAllBrio():Subscribe(function(brio: Brio.Brio<any>)
+			table.insert(brios, brio)
+		end)
+
+		expect(#brios).toEqual(0)
+
+		local inst = controller.newInstance()
+		binder:Tag(inst)
+		assert((binder:Promise(inst):Yield()), "Never bound")
+
+		expect(#brios).toEqual(1)
+		expect(brios[1]:IsDead()).toEqual(false)
+		expect(brios[1]:GetValue()).toEqual(binder:Get(inst))
+
+		sub:Destroy()
+		controller.destroy()
+	end)
+
+	it("kills the brio when the class is removed", function()
+		local controller = setup()
+
+		local binder = controller.addBinder(makeTrackingClass())
+		controller.boot()
+
+		local inst = controller.newInstance()
+		binder:Tag(inst)
+		assert((binder:Promise(inst):Yield()), "Never bound")
+
+		local brios = {}
+		local sub = binder:ObserveAllBrio():Subscribe(function(brio: Brio.Brio<any>)
+			table.insert(brios, brio)
+		end)
+
+		expect(#brios).toEqual(1)
+
+		binder:Untag(inst)
+		awaitUnbound(binder, inst)
+
+		expect(brios[1]:IsDead()).toEqual(true)
+
+		sub:Destroy()
+		controller.destroy()
+	end)
+end)