@quenty/gameconfig 12.53.0 → 12.55.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [12.55.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/gameconfig@12.54.0...@quenty/gameconfig@12.55.0) (2026-07-21)
+
+**Note:** Version bump only for package @quenty/gameconfig
+
+# [12.54.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/gameconfig@12.53.0...@quenty/gameconfig@12.54.0) (2026-07-20)
+
+### Bug Fixes
+
+- Strict typing on tests ([efbc458](https://github.com/Quenty/NevermoreEngine/commit/efbc45882fac95755ea4ff4e007c5f71bedebf6f))
+
+### Features
+
+- **gameconfig:** add asset selection priority for key clashes ([ae7d765](https://github.com/Quenty/NevermoreEngine/commit/ae7d7651f6a3270e8e0ee9fc592b4e6bc2fc5a51))
+- **gameconfig:** auto-register manifest places via NevermoreManifestConfigProvider ([db58cfc](https://github.com/Quenty/NevermoreEngine/commit/db58cfc62b9164f316895c4252942bd292a02f89))
+- **gameproductservice:** add paid-access game ownership tracking ([581a595](https://github.com/Quenty/NevermoreEngine/commit/581a5950d433ea4d6dfbcc33e88f254f9f13e14c))
+
 # [12.53.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/gameconfig@12.52.0...@quenty/gameconfig@12.53.0) (2026-07-18)
 
 **Note:** Version bump only for package @quenty/gameconfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/gameconfig",
-  "version": "12.53.0",
+  "version": "12.55.0",
   "description": "Configuration service to specify Roblox badges, products, and other specific assets.",
   "keywords": [
     "Roblox",
@@ -42,8 +42,9 @@
     "@quenty/instanceutils": "13.32.0",
     "@quenty/loader": "10.11.0",
     "@quenty/maid": "3.10.0",
-    "@quenty/marketplaceutils": "11.23.0",
+    "@quenty/marketplaceutils": "11.24.0",
     "@quenty/nevermore-test-runner": "1.4.0",
+    "@quenty/nevermoreclimanifest": "1.5.0",
     "@quenty/observablecollection": "12.41.0",
     "@quenty/playerutils": "8.35.0",
     "@quenty/preferredparentutils": "4.4.2",
@@ -57,7 +58,8 @@
     "@quenty/statestack": "14.34.0",
     "@quenty/string": "3.3.7",
     "@quenty/table": "3.9.2",
-    "@quenty/valueobject": "13.33.0"
+    "@quenty/valueobject": "13.33.0",
+    "@quentystudios/jest-lua": "3.10.0-quenty.2"
   },
-  "gitHead": "647acfad93dca41c38f59cda247d2bfc0fff36d4"
+  "gitHead": "8bd905a5c7e7f1fd4e178b54beeadef94a615d1d"
 }

package/src/Server/GameConfigService.lua

@@ -103,9 +103,10 @@ end
 	Adds a new place with the key configured to the `assetKey`
 	@param assetKey string -- Key name to use for the place
 	@param placeId number -- Cloud id
+	@param priority number? -- Selection priority; higher wins on a key clash
 ]=]
-function GameConfigService:AddPlace(assetKey: string, placeId: number)
-	self:AddTypedAsset(GameConfigAssetTypes.PLACE, assetKey, placeId)
+function GameConfigService:AddPlace(assetKey: string, placeId: number, priority: number?)
+	return self:AddTypedAsset(GameConfigAssetTypes.PLACE, assetKey, placeId, priority)
 end
 
 --[=[
@@ -141,19 +142,22 @@ end
 	@param assetType GameConfigAssetType
 	@param assetKey string -- Key name to use for the bundle
 	@param assetId number -- Cloud id
+	@param priority number? -- Selection priority; higher wins on a key clash
 ]=]
 function GameConfigService:AddTypedAsset(
 	assetType: GameConfigAssetTypes.GameConfigAssetType,
 	assetKey: string,
-	assetId: number
+	assetId: number,
+	priority: number?
 )
 	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
 	assert(type(assetKey) == "string", "Bad assetKey")
 	assert(type(assetId) == "number", "Bad assetId")
+	assert(priority == nil or type(priority) == "number", "Bad priority")
 
 	local gameConfig = self:_getOrCreateDefaultGameConfig()
 
-	local asset = GameConfigAssetUtils.create(self._binders.GameConfigAsset, assetType, assetKey, assetId)
+	local asset = GameConfigAssetUtils.create(self._binders.GameConfigAsset, assetType, assetKey, assetId, priority)
 	asset.Parent = GameConfigUtils.getOrCreateAssetFolder(gameConfig, assetType)
 
 	return asset

package/src/Server/Manifest/NevermoreManifestConfigProvider.lua

@@ -0,0 +1,80 @@
+--!strict
+--[=[
+	Registers the deploy target's places -- read from the nevermore CLI manifest
+	baked into the running place -- as PLACE assets in [GameConfigService], each
+	at a high priority so it wins over a hand-authored place sharing the same key
+	(see [GameConfigPicker.FindFirstActiveAssetOfKey]).
+
+	Add it to a server [ServiceBag] after [GameConfigService]:
+
+	```lua
+	serviceBag:GetService(require("GameConfigService"))
+	serviceBag:GetService(require("NevermoreManifestConfigProvider"))
+	```
+
+	In Studio or an undeployed build the manifest place table is empty, so nothing
+	is registered and hand-authored config resolves exactly as before.
+
+	@server
+	@class NevermoreManifestConfigProvider
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local GameConfigService = require("GameConfigService")
+local Maid = require("Maid")
+local NevermoreCLIManifestUtils = require("NevermoreCLIManifestUtils")
+local ServiceBag = require("ServiceBag")
+
+-- Well above the default priority (0) so a manifest place always beats a
+-- hand-authored one that shares its key.
+local MANIFEST_PLACE_PRIORITY = 1000
+
+local NevermoreManifestConfigProvider = {}
+NevermoreManifestConfigProvider.ServiceName = "NevermoreManifestConfigProvider"
+
+export type NevermoreManifestConfigProvider = typeof(setmetatable(
+	{} :: {
+		_serviceBag: ServiceBag.ServiceBag,
+		_gameConfigService: GameConfigService.GameConfigService,
+		_maid: Maid.Maid,
+	},
+	{} :: typeof({ __index = NevermoreManifestConfigProvider })
+))
+
+function NevermoreManifestConfigProvider.Init(self: NevermoreManifestConfigProvider, serviceBag: ServiceBag.ServiceBag)
+	assert(not (self :: any)._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._maid = Maid.new()
+
+	self._gameConfigService = self._serviceBag:GetService(GameConfigService :: any)
+end
+
+function NevermoreManifestConfigProvider.Start(self: NevermoreManifestConfigProvider)
+	self:_applyPlaces(NevermoreCLIManifestUtils.getPlaces())
+end
+
+--[=[
+	Registers each named place as a high-priority PLACE asset. Nameless entries
+	(single-place targets) are skipped -- there is no config key to bind them to.
+
+	@param places { NevermoreCLIManifestUtils.ManifestPlace }
+	@private
+]=]
+function NevermoreManifestConfigProvider._applyPlaces(
+	self: NevermoreManifestConfigProvider,
+	places: { NevermoreCLIManifestUtils.ManifestPlace }
+)
+	for _, place in places do
+		if place.name then
+			local asset = self._gameConfigService:AddPlace(place.name, place.placeId, MANIFEST_PLACE_PRIORITY)
+			self._maid:GiveTask(asset)
+		end
+	end
+end
+
+function NevermoreManifestConfigProvider.Destroy(self: NevermoreManifestConfigProvider)
+	self._maid:DoCleaning()
+end
+
+return NevermoreManifestConfigProvider

package/src/Server/Manifest/NevermoreManifestConfigProvider.spec.lua

@@ -0,0 +1,95 @@
+--!strict
+--[[
+	Coverage for NevermoreManifestConfigProvider: it registers named manifest
+	places as high-priority PLACE assets (so they win over a hand-authored place
+	sharing the key) and skips nameless single-place-target entries.
+
+	Registration is driven through the private _applyPlaces so the test controls
+	the place table directly, rather than depending on a real deploy stamp on the
+	manifest module. Each test uses distinct keys/ids; assets bind through global
+	CollectionService tags under a shared parent, so they persist across tests in
+	a run.
+
+	@class NevermoreManifestConfigProvider.spec.lua
+]]
+local require = require(script.Parent.loader).load(script)
+
+local GameConfigAssetTypes = require("GameConfigAssetTypes")
+local GameConfigService = require("GameConfigService")
+local Jest = require("Jest")
+local NevermoreManifestConfigProvider = require("NevermoreManifestConfigProvider")
+local ServiceBag = require("ServiceBag")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+local PLACE: GameConfigAssetTypes.GameConfigAssetType = GameConfigAssetTypes.PLACE
+
+local function newProvider()
+	local serviceBag = ServiceBag.new()
+	local gameConfigService = (serviceBag:GetService(GameConfigService) :: any) :: GameConfigService.GameConfigService
+	local provider = (
+		serviceBag:GetService(NevermoreManifestConfigProvider) :: any
+	) :: NevermoreManifestConfigProvider.NevermoreManifestConfigProvider
+	serviceBag:Init()
+	serviceBag:Start()
+	return serviceBag, gameConfigService, provider, gameConfigService:GetConfigPicker()
+end
+
+describe("NevermoreManifestConfigProvider", function()
+	it("registers a named place as a resolvable PLACE asset", function()
+		local serviceBag, _, provider, picker = newProvider()
+
+		provider:_applyPlaces({
+			{ name = "provChapterA", placeId = 555, universeId = 1 },
+		})
+
+		local asset = picker:FindFirstActiveAssetOfKey(PLACE, "provChapterA")
+		expect(asset).never.toBeNil()
+		assert(asset, "no asset")
+		expect(asset:GetAssetId()).toEqual(555)
+
+		serviceBag:Destroy()
+	end)
+
+	it("wins over a hand-authored place sharing the key", function()
+		local serviceBag, gameConfigService, provider, picker = newProvider()
+
+		gameConfigService:AddPlace("provChapterB", 111) -- hand-authored, priority 0
+		provider:_applyPlaces({
+			{ name = "provChapterB", placeId = 999, universeId = 1 },
+		})
+
+		local asset = picker:FindFirstActiveAssetOfKey(PLACE, "provChapterB")
+		assert(asset, "no asset")
+		expect(asset:GetAssetId()).toEqual(999)
+		expect(asset:GetPriority() > 0).toEqual(true)
+
+		serviceBag:Destroy()
+	end)
+
+	it("skips nameless (single-place-target) entries", function()
+		local serviceBag, _, provider, picker = newProvider()
+
+		expect(function()
+			provider:_applyPlaces({
+				{ placeId = 777, universeId = 1 },
+			})
+		end).never.toThrow()
+
+		-- Nameless places have no config key to bind to, so nothing is registered.
+		expect(picker:FindFirstActiveAssetOfId(PLACE, 777)).toBeNil()
+
+		serviceBag:Destroy()
+	end)
+
+	it("registers nothing for an empty place table", function()
+		local serviceBag, _, provider, picker = newProvider()
+
+		provider:_applyPlaces({})
+		expect(picker:FindFirstActiveAssetOfKey(PLACE, "provNeverAdded")).toBeNil()
+
+		serviceBag:Destroy()
+	end)
+end)

package/src/Shared/Config/Asset/GameConfigAssetBase.lua

@@ -126,6 +126,20 @@ function GameConfigAssetBase:GetAssetType(): string?
 	return self._obj:GetAttribute(GameConfigAssetConstants.ASSET_TYPE_ATTRIBUTE)
 end
 
+--[=[
+	Gets the asset's selection priority. Higher wins when several active assets
+	share a type and key. Assets that never set it read back as
+	[GameConfigAssetConstants.DEFAULT_PRIORITY].
+	@return number
+]=]
+function GameConfigAssetBase:GetPriority(): number
+	local priority = self._obj:GetAttribute(GameConfigAssetConstants.PRIORITY_ATTRIBUTE)
+	if type(priority) == "number" then
+		return priority
+	end
+	return GameConfigAssetConstants.DEFAULT_PRIORITY
+end
+
 --[=[
 	Observes the asset type
 	@return Observable<string?>

package/src/Shared/Config/Asset/GameConfigAssetConstants.lua

@@ -10,4 +10,9 @@ local Table = require("Table")
 return Table.readonly({
 	ASSET_TYPE_ATTRIBUTE = "AssetType",
 	ASSET_ID_ATTRIBUTE = "AssetId",
+	-- Higher wins when several active assets share a type and key. Absent means
+	-- the default, DEFAULT_PRIORITY -- so hand-authored assets (which never set
+	-- it) are beaten by a higher-priority one registered in code.
+	PRIORITY_ATTRIBUTE = "Priority",
+	DEFAULT_PRIORITY = 0,
 })

package/src/Shared/Config/Asset/GameConfigAssetUtils.lua

@@ -18,17 +18,25 @@ local GameConfigAssetUtils = {}
 
 --[=[
 	Creates a new game configuration
+
+	`priority` is only stamped when given; an asset without it reads back as
+	[GameConfigAssetConstants.DEFAULT_PRIORITY]. Pass a higher value to win over
+	hand-authored assets that share this type and key (see
+	[GameConfigPicker.FindFirstActiveAssetOfKey]).
+
 	@param binder Binder<GameConfigAssetBase>
 	@param assetType GameConfigAssetType
 	@param assetKey string
 	@param assetId number
+	@param priority number?
 	@return Instance
 ]=]
 function GameConfigAssetUtils.create(
 	binder: Binder.Binder<any>, -- GameConfigAssetBase.GameConfigAssetBase (require cycle: GameConfigAssetBase requires this module)
 	assetType: GameConfigAssetTypes.GameConfigAssetType,
 	assetKey: string,
-	assetId: number
+	assetId: number,
+	priority: number?
 ): Folder
 	local asset = Instance.new("Folder")
 	asset.Name = assetKey
@@ -37,6 +45,9 @@ function GameConfigAssetUtils.create(
 
 	AttributeUtils.initAttribute(asset, GameConfigAssetConstants.ASSET_TYPE_ATTRIBUTE, assetType)
 	AttributeUtils.initAttribute(asset, GameConfigAssetConstants.ASSET_ID_ATTRIBUTE, assetId)
+	if priority ~= nil then
+		AttributeUtils.initAttribute(asset, GameConfigAssetConstants.PRIORITY_ATTRIBUTE, priority)
+	end
 
 	return asset
 end
@@ -69,6 +80,8 @@ function GameConfigAssetUtils.promiseCloudDataForAssetType(
 		return marketplaceServiceCache:PromiseProductInfo(assetId, Enum.InfoType.GamePass)
 	elseif assetType == GameConfigAssetTypes.PLACE then
 		return marketplaceServiceCache:PromiseProductInfo(assetId, Enum.InfoType.Asset)
+	elseif assetType == GameConfigAssetTypes.GAME then
+		return marketplaceServiceCache:PromiseProductInfo(assetId, Enum.InfoType.Asset)
 	elseif assetType == GameConfigAssetTypes.ASSET then
 		return marketplaceServiceCache:PromiseProductInfo(assetId, Enum.InfoType.Asset)
 	elseif assetType == GameConfigAssetTypes.BUNDLE then

package/src/Shared/Config/AssetTypes/GameConfigAssetTypeUtils.lua

@@ -14,6 +14,7 @@ local pluralMap: { [GameConfigAssetTypes.GameConfigAssetType]: string } = {
 	[GameConfigAssetTypes.PRODUCT] = "products",
 	[GameConfigAssetTypes.PASS] = "passes",
 	[GameConfigAssetTypes.PLACE] = "places",
+	[GameConfigAssetTypes.GAME] = "games",
 	[GameConfigAssetTypes.ASSET] = "assets",
 	[GameConfigAssetTypes.BUNDLE] = "bundles",
 	[GameConfigAssetTypes.SUBSCRIPTION] = "subscriptions",

package/src/Shared/Config/AssetTypes/GameConfigAssetTypes.lua

@@ -14,6 +14,7 @@ export type GameConfigAssetType =
 	| "asset"
 	| "bundle"
 	| "place"
+	| "game"
 	| "subscription"
 	| "membership"
 
@@ -63,6 +64,16 @@ return SimpleEnum.new({
 ]=]
 	PLACE = "place" :: "place",
 
+	--[=[
+	Specifies the asset is a game (universe). Ownership is checked against paid-access
+	via [MarketplaceService.PlayerOwnsAssetAsync]. Games cannot be prompted for purchase
+	in-experience, so prompting a game asset type throws.
+
+	@prop GAME string
+	@within GameConfigAssetTypes
+]=]
+	GAME = "game" :: "game",
+
 	--[=[
 	Specifies the asset is of type subscription
 	@prop SUBSCRIPTION string

package/src/Shared/Config/Picker/GameConfigPicker.lua

@@ -266,7 +266,13 @@ function GameConfigPicker.PromisePriceInRobux(
 end
 
 --[=[
-	Find the first asset of a given key
+	Find the active asset of a given type and key.
+
+	When several active assets share the type and key, the one with the highest
+	[GameConfigAssetBase.GetPriority] wins; equal priorities keep the first
+	iterated (so a lone hand-authored asset resolves exactly as before, and a
+	higher-priority asset registered in code -- e.g. from the deploy manifest --
+	overrides it). Returns nil when no active asset matches.
 
 	@param assetType
 	@param assetKey
@@ -280,13 +286,20 @@ function GameConfigPicker.FindFirstActiveAssetOfKey(
 	assert(GameConfigAssetTypeUtils.isAssetType(assetType), "Bad assetType")
 	assert(type(assetKey) == "string", "Bad assetKey")
 
+	local best: GameConfigAssetBase? = nil
+	local bestPriority: number? = nil
+
 	for _, gameConfig in self:GetActiveConfigs() do
 		for _, gameConfigAsset in gameConfig:GetAssetsOfTypeAndKey(assetType, assetKey) do
-			return gameConfigAsset
+			local priority = gameConfigAsset:GetPriority()
+			if bestPriority == nil or priority > bestPriority then
+				best = gameConfigAsset
+				bestPriority = priority
+			end
 		end
 	end
 
-	return nil
+	return best
 end
 
 --[=[

package/src/Shared/Config/Picker/GameConfigPicker.spec.lua

@@ -0,0 +1,170 @@
+--!strict
+--[[
+	Coverage for GameConfigPicker priority selection: when several active assets
+	share a type and key (e.g. a hand-authored place and one registered from the
+	deploy manifest), the highest-priority one wins, and equal priorities keep
+	the first iterated -- so a lone hand-authored asset resolves exactly as it did
+	before priority existed.
+
+	Each test uses a distinct asset key. Configs are bound through global
+	CollectionService tags under a shared parent, so assets registered by one
+	ServiceBag remain visible to the next within a run; distinct keys keep lookups
+	isolated regardless.
+
+	@class GameConfigPicker.spec.lua
+]]
+local require = require(script.Parent.loader).load(script)
+
+local GameConfigAssetTypes = require("GameConfigAssetTypes")
+local GameConfigAssetUtils = require("GameConfigAssetUtils")
+local GameConfigBindersServer = require("GameConfigBindersServer")
+local GameConfigService = require("GameConfigService")
+local GameConfigUtils = require("GameConfigUtils")
+local Jest = require("Jest")
+local ServiceBag = require("ServiceBag")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+local PLACE: GameConfigAssetTypes.GameConfigAssetType = GameConfigAssetTypes.PLACE
+
+local function newPicker()
+	local serviceBag = ServiceBag.new()
+	local gameConfigService = (serviceBag:GetService(GameConfigService) :: any) :: GameConfigService.GameConfigService
+	serviceBag:Init()
+	serviceBag:Start()
+	return serviceBag, gameConfigService, gameConfigService:GetConfigPicker()
+end
+
+describe("GameConfigPicker.FindFirstActiveAssetOfKey priority", function()
+	it("resolves a single added place", function()
+		local serviceBag, gameConfigService, picker = newPicker()
+
+		gameConfigService:AddPlace("specResolve", 111)
+		local asset = picker:FindFirstActiveAssetOfKey(PLACE, "specResolve")
+		expect(asset).never.toBeNil()
+		assert(asset, "No asset")
+		expect(asset:GetAssetId()).toEqual(111)
+
+		serviceBag:Destroy()
+	end)
+
+	it("defaults an asset without a priority to DEFAULT_PRIORITY", function()
+		local serviceBag, gameConfigService, picker = newPicker()
+
+		gameConfigService:AddPlace("specDefaultPriority", 111)
+		local asset = picker:FindFirstActiveAssetOfKey(PLACE, "specDefaultPriority")
+		assert(asset, "No asset")
+		expect(asset:GetPriority()).toEqual(0)
+
+		serviceBag:Destroy()
+	end)
+
+	it("prefers the higher-priority asset added after a default one", function()
+		local serviceBag, gameConfigService, picker = newPicker()
+
+		gameConfigService:AddPlace("specClashAfter", 111) -- hand-authored (priority 0)
+		gameConfigService:AddPlace("specClashAfter", 222, 100) -- manifest (priority 100)
+
+		local asset = picker:FindFirstActiveAssetOfKey(PLACE, "specClashAfter")
+		assert(asset, "No asset")
+		expect(asset:GetAssetId()).toEqual(222)
+
+		serviceBag:Destroy()
+	end)
+
+	it("prefers the higher-priority asset even when added first", function()
+		local serviceBag, gameConfigService, picker = newPicker()
+
+		gameConfigService:AddPlace("specClashFirst", 222, 100) -- manifest first
+		gameConfigService:AddPlace("specClashFirst", 111) -- hand-authored second
+
+		local asset = picker:FindFirstActiveAssetOfKey(PLACE, "specClashFirst")
+		assert(asset, "No asset")
+		expect(asset:GetAssetId()).toEqual(222)
+
+		serviceBag:Destroy()
+	end)
+
+	it("resolves deterministically to a matching asset when priorities tie", function()
+		local serviceBag, gameConfigService, picker = newPicker()
+
+		gameConfigService:AddPlace("specTie", 111)
+		gameConfigService:AddPlace("specTie", 222)
+
+		-- Equal priority keeps the config's own iteration order (unchanged from
+		-- before priority existed), so the exact winner is implementation-defined.
+		-- The real contract is only that it is stable and matches -- a higher
+		-- priority is the deterministic tie-breaker, covered above.
+		local firstAsset = picker:FindFirstActiveAssetOfKey(PLACE, "specTie")
+		local secondAsset = picker:FindFirstActiveAssetOfKey(PLACE, "specTie")
+		assert(firstAsset, "No firstAsset")
+		assert(secondAsset, "No secondAsset")
+		local first = firstAsset:GetAssetId()
+		local second = secondAsset:GetAssetId()
+		expect(first).toEqual(second)
+		expect(first == 111 or first == 222).toEqual(true)
+
+		serviceBag:Destroy()
+	end)
+
+	it("returns nil for a key with no active asset", function()
+		local serviceBag, _, picker = newPicker()
+
+		expect(picker:FindFirstActiveAssetOfKey(PLACE, "specDefinitelyMissing")).toBeNil()
+
+		serviceBag:Destroy()
+	end)
+end)
+
+describe("GameConfigPicker gameId gate dominates priority", function()
+	-- Builds a config whose GameId is NOT the running place's, containing one
+	-- PLACE asset. Such a config is never active, so its assets must never be
+	-- returned -- no matter how high their priority. Returns the config folder so
+	-- the caller can destroy it.
+	local function addInactiveConfigPlace(
+		serviceBag: any,
+		gameConfigService: any,
+		assetKey: string,
+		placeId: number,
+		priority: number
+	): Instance
+		local binders = serviceBag:GetService(GameConfigBindersServer)
+		local config = GameConfigUtils.create(binders.GameConfig, game.GameId + 1)
+		config.Parent = gameConfigService:GetPreferredParent()
+
+		local asset = GameConfigAssetUtils.create(binders.GameConfigAsset, PLACE, assetKey, placeId, priority)
+		asset.Parent = GameConfigUtils.getOrCreateAssetFolder(config, PLACE)
+
+		return config
+	end
+
+	it("excludes a high-priority asset whose config gameId does not match", function()
+		local serviceBag, gameConfigService, picker = newPicker()
+
+		local inactive = addInactiveConfigPlace(serviceBag, gameConfigService, "specGateOnly", 888, 5000)
+
+		expect(picker:FindFirstActiveAssetOfKey(PLACE, "specGateOnly")).toBeNil()
+
+		inactive:Destroy()
+		serviceBag:Destroy()
+	end)
+
+	it("keeps a lower-priority active asset over a higher-priority wrong-gameId one", function()
+		local serviceBag, gameConfigService, picker = newPicker()
+
+		-- Wrong-gameId asset with a far higher priority than the active one.
+		local inactive = addInactiveConfigPlace(serviceBag, gameConfigService, "specGateBeatsPriority", 888, 5000)
+		-- Correct-gameId asset at the default priority.
+		gameConfigService:AddPlace("specGateBeatsPriority", 111)
+
+		local resolved = picker:FindFirstActiveAssetOfKey(PLACE, "specGateBeatsPriority")
+		expect(resolved).never.toBeNil()
+		assert(resolved, "No resolved asset")
+		expect(resolved:GetAssetId()).toEqual(111)
+
+		inactive:Destroy()
+		serviceBag:Destroy()
+	end)
+end)