@quenty/loader 8.0.0-canary.ee17b33.0 → 8.0.0

package/CHANGELOG.md

@@ -3,7 +3,59 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-# [8.0.0-canary.ee17b33.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/loader@7.1.0...@quenty/loader@8.0.0-canary.ee17b33.0) (2024-01-08)
+# [8.0.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/loader@7.3.0...@quenty/loader@8.0.0) (2024-02-13)
+
+
+### Features
+
+* New loader (breaking changes), fixing loader issues  ([#439](https://github.com/Quenty/NevermoreEngine/issues/439)) ([3534345](https://github.com/Quenty/NevermoreEngine/commit/353434522918812953bd9f13fece73e27a4d034d))
+
+
+### BREAKING CHANGES
+
+* Standard loader
+
+Adds new loader version which replicates full structure instead of some partial structure. This allows us to have hot-reloading (in the future), as well as generally do less computation, handle dependencies more carefully, and other changes.
+
+This means you'll need to change you how require client-side modules, as we export a simple `loader` module instead of all modules available.
+
+Signed-off-by: James Onnen <jonnen0@gmail.com>
+
+* fix: Fix missing dependency in ResetService
+
+* feat: Add RxPhysicsUtils.observePartMass
+
+* fix: Fix package discovery for games
+
+* feat: Add UIAlignmentUtils.verticalToHorizontalAlignment(verticalAlignment) and UIAlignmentUtils.horizontalToVerticalAlignment(horizontalAlignment)
+
+* feat: AdorneeData:InitAttributes() does not require data as a  secondparameter
+
+* ci: Upgrade to new rojo 7.4.0
+
+* fix: Update loader to handle hoarcekat properly
+
+* docs: Fix spacing in Maid
+
+* fix: Add new ragdoll constants
+
+* fix: Compress influxDB sends
+
+* style: Errors use string.format
+
+* fix: Handle motor animations
+
+* ci: Upgrade rojo version
+
+* feat!: Maid no longer is includd in ValueObject.Changed event
+
+* docs: Fix docs
+
+
+
+
+
+# [7.3.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/loader@7.1.0...@quenty/loader@7.3.0) (2024-01-08)
 
 
 ### Features

package/README.md

@@ -56,8 +56,6 @@ For a given package folder, all packages underneath it shall have...
 3. Access to every package in the dependency folder at each ancestor level at the 1st level of recursion
 4. Access to every sibling package (this is because we expect to be installed at a uniform level)
 
-We will 
-
 
 
 -------

package/default.project.json

@@ -1,6 +1,6 @@
 {
   "name": "loader",
   "tree": {
-    "$path": "src"
+    "$path": "src2"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/loader",
-  "version": "8.0.0-canary.ee17b33.0",
+  "version": "8.0.0",
   "description": "A simple module loader for Roblox",
   "keywords": [
     "Roblox",
@@ -26,5 +26,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ee17b3373035e250a9056103aee214c433ccf70e"
+  "gitHead": "5736b108e4d23cd4c9e761bbe4cc9fed6fb32dfa"
 }

package/src/LoaderConstants.lua

@@ -8,5 +8,5 @@ local Utils = require(script.Parent.Utils)
 return Utils.readonly({
 	GROUP_EACH_PACKAGE_INDIVIDUALLY = false;
 	ALLOW_MULTIPLE_GROUPS = true;
-	INCLUDE_IMPLICIT_DEPENDENCIES = true;
+	INCLUDE_IMPLICIT_DEPENDENCIES = false;
 })

package/src/LoaderUtils.lua

@@ -45,9 +45,7 @@ function LoaderUtils.toWallyFormat(instance, isPlugin)
 	PackageInfoUtils.fillDependencySet(packageInfoList)
 
 	if isPlugin then
-		local pluginGroup = GroupInfoUtils.groupPackageInfos(packageInfoList,
-			ScriptInfoUtils.ModuleReplicationTypes.PLUGIN)
-
+		local pluginGroup = GroupInfoUtils.groupPackageInfos(packageInfoList, ScriptInfoUtils.ModuleReplicationTypes.PLUGIN)
 		local publishSet = LoaderUtils.getPublishPackageInfoSet(packageInfoList)
 
 		local pluginFolder = Instance.new("Folder")
@@ -57,13 +55,9 @@ function LoaderUtils.toWallyFormat(instance, isPlugin)
 
 		return pluginFolder
 	else
-		local clientGroupList = GroupInfoUtils.groupPackageInfos(packageInfoList,
-			ScriptInfoUtils.ModuleReplicationTypes.CLIENT)
-		local serverGroupList = GroupInfoUtils.groupPackageInfos(packageInfoList,
-			ScriptInfoUtils.ModuleReplicationTypes.SERVER)
-		local sharedGroupList = GroupInfoUtils.groupPackageInfos(packageInfoList,
-			ScriptInfoUtils.ModuleReplicationTypes.SHARED)
-
+		local clientGroupList = GroupInfoUtils.groupPackageInfos(packageInfoList, ScriptInfoUtils.ModuleReplicationTypes.CLIENT)
+		local serverGroupList = GroupInfoUtils.groupPackageInfos(packageInfoList, ScriptInfoUtils.ModuleReplicationTypes.SERVER)
+		local sharedGroupList = GroupInfoUtils.groupPackageInfos(packageInfoList, ScriptInfoUtils.ModuleReplicationTypes.SHARED)
 		local publishSet = LoaderUtils.getPublishPackageInfoSet(packageInfoList)
 
 		local clientFolder = Instance.new("Folder")

package/src/init.lua

@@ -96,7 +96,7 @@ local function bootstrapPlugin(packageFolder)
 				return require(pluginFolder:FindFirstChild(value))
 			end
 
-			error(("Unknown module %q"):format(tostring(value)))
+			error(string.format("Unknown module %q", tostring(value)))
 		else
 			return require(value)
 		end

package/src2/Dependencies/DependencyUtils.lua

@@ -5,6 +5,10 @@
 	@class DependencyUtils
 ]=]
 
+local loader = script.Parent.Parent
+local ReplicationType = require(loader.Replication.ReplicationType)
+local ReplicationTypeUtils = require(loader.Replication.ReplicationTypeUtils)
+
 local DependencyUtils = {}
 
 --[=[
@@ -13,16 +17,22 @@ local DependencyUtils = {}
 
 	@param requester Instance
 	@param moduleName string
+	@param requestedReplicationType ReplicationType
 	@return ModuleScript?
 ]=]
-function DependencyUtils.findDependency(requester, moduleName)
+function DependencyUtils.findDependency(requester, moduleName, requestedReplicationType)
 	assert(typeof(requester) == "Instance", "Bad requester")
 	assert(type(moduleName) == "string", "Bad moduleName")
+	assert(ReplicationTypeUtils.isReplicationType(requestedReplicationType), "Bad requestedReplicationType")
 
 	for packageInst in DependencyUtils.iterPackages(requester) do
-		for module in DependencyUtils.iterModules(packageInst) do
+		for module, replicationType in DependencyUtils.iterModules(packageInst, ReplicationType.SHARED) do
 			if module.Name == moduleName then
-				return module
+				if ReplicationTypeUtils.isAllowed(replicationType, requestedReplicationType) then
+					return module
+				else
+					error(string.format("[DependencyUtils] - %q is not allowed in %q", moduleName, requestedReplicationType))
+				end
 			end
 		end
 	end
@@ -30,20 +40,24 @@ function DependencyUtils.findDependency(requester, moduleName)
 	return nil
 end
 
-function DependencyUtils.iterModules(packageInst)
+function DependencyUtils.iterModules(packageInst, ancestorReplicationType)
 	assert(typeof(packageInst) == "Instance", "Bad packageInst")
+	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
 
 	return coroutine.wrap(function()
 		if packageInst:IsA("ModuleScript") then
-			coroutine.yield(packageInst)
+			coroutine.yield(packageInst, ancestorReplicationType)
 			return
 		end
 
 		-- Iterate over the package contents
 		for _, item in pairs(packageInst:GetChildren()) do
-			if item.Name ~= "node_modules" then
-				for result in DependencyUtils.iterModules(item) do
-					coroutine.yield(result)
+			local itemName = item.Name
+			local itemReplicationType = ReplicationTypeUtils.getFolderReplicationType(itemName, ancestorReplicationType)
+
+			if itemName ~= "node_modules" then
+				for result, resultReplicationType in DependencyUtils.iterModules(item, itemReplicationType) do
+					coroutine.yield(result, resultReplicationType)
 				end
 			end
 		end
@@ -98,10 +112,10 @@ function DependencyUtils.iterPackagesInModuleModules(nodeModules)
 								if linked:IsA("ModuleScript") or linked:IsA("Folder") then
 									coroutine.yield(linked)
 								else
-									warn("Bad link value type")
+									warn("[DependencyUtils] - Bad link value type")
 								end
 							else
-								warn("Nothing linked")
+								warn("[DependencyUtils] - Nothing linked")
 							end
 						end
 					end
@@ -116,10 +130,10 @@ function DependencyUtils.iterPackagesInModuleModules(nodeModules)
 					if linked:IsA("ModuleScript") or linked:IsA("Folder") then
 						coroutine.yield(linked)
 					else
-						warn("Bad link value type")
+						warn("[DependencyUtils] - Bad link value type")
 					end
 				else
-					warn("Nothing linked")
+					warn("[DependencyUtils] - Nothing linked")
 				end
 			end
 		end

package/src2/Dependencies/PackageTracker.lua

@@ -0,0 +1,441 @@
+--[=[
+	For each package, track subdependent packages and packages
+
+	@class PackageTracker
+]=]
+
+local loader = script.Parent.Parent
+local Maid = require(loader.Maid)
+local DependencyUtils = require(loader.Dependencies.DependencyUtils)
+local ReplicationType = require(loader.Replication.ReplicationType)
+local ReplicationTypeUtils = require(loader.Replication.ReplicationTypeUtils)
+
+local PackageTracker = {}
+PackageTracker.ClassName = "PackageTracker"
+PackageTracker.__index = PackageTracker
+
+function PackageTracker.new(packageTrackerProvider, packageRoot)
+	assert(packageTrackerProvider, "No packageTrackerProvider")
+	assert(typeof(packageRoot) == "Instance", "Bad packageRoot")
+
+	local self = setmetatable({}, PackageTracker)
+	self._maid = Maid.new()
+
+	self._packageTrackerProvider = assert(packageTrackerProvider, "No packageTrackerProvider")
+	self._packageRoot = assert(packageRoot, "No packageRoot")
+
+	self._subpackagesMap = {}
+	self._subpackagesTrackerList = {}
+	self._packageModuleScriptMap = {}
+
+	if self._packageRoot:IsA("ModuleScript") then
+		-- Module script children don't get to be observed
+		self._maid:GiveTask(self:_trackModuleScript(self._packageRoot, ReplicationType.SHARED))
+	else
+		self._maid:GiveTask(self:_trackChildren(self._packageRoot, ReplicationType.SHARED))
+	end
+
+	return self
+end
+
+function PackageTracker:ResolveDependency(request, replicationType)
+	local packageModuleScript = self:FindPackageModuleScript(request, replicationType)
+	if packageModuleScript then
+		return packageModuleScript
+	end
+
+	local subpackageModuleScript = self:FindSubpackageModuleScript(request, replicationType)
+	if subpackageModuleScript then
+		return subpackageModuleScript
+	end
+
+	local parentModuleScript = self:FindImplicitParentModuleScript(request, replicationType)
+	if parentModuleScript then
+		return parentModuleScript
+	end
+
+	return nil
+end
+
+function PackageTracker:FindImplicitParentModuleScript(request, replicationType)
+	assert(type(request) == "string", "Bad request")
+	assert(ReplicationTypeUtils.isReplicationType(replicationType), "Bad replicationType")
+
+	-- Implicit dependencies
+	local packageRootParent = self._packageRoot.Parent
+	if not packageRootParent then
+		return nil
+	end
+
+	local parentProvider = self._packageTrackerProvider:FindPackageTracker(packageRootParent)
+	if not parentProvider then
+		return nil
+	end
+
+	-- Check parent provider for implicit dependency
+	local subpackageModuleScript = parentProvider:FindSubpackageModuleScript(request, replicationType)
+	if subpackageModuleScript then
+		return subpackageModuleScript
+	end
+
+	return parentProvider:FindImplicitParentModuleScript(request, replicationType)
+end
+
+function PackageTracker:FindPackageModuleScript(moduleScriptName, replicationType)
+	assert(type(moduleScriptName) == "string", "Bad moduleScriptName")
+	assert(ReplicationTypeUtils.isReplicationType(replicationType), "Bad replicationType")
+
+	local found = self._packageModuleScriptMap[moduleScriptName]
+
+	if found then
+		if ReplicationTypeUtils.isAllowed(found.replicationType, replicationType) then
+			return found.moduleScript
+		else
+			return nil
+		end
+	else
+		return nil
+	end
+end
+
+function PackageTracker:FindSubpackageModuleScript(moduleScriptName, replicationType)
+	assert(type(moduleScriptName) == "string", "Bad moduleScriptName")
+	assert(ReplicationTypeUtils.isReplicationType(replicationType), "Bad replicationType")
+
+	for _, packageTracker in pairs(self._subpackagesTrackerList) do
+		local found = packageTracker._packageModuleScriptMap[moduleScriptName]
+		if found then
+			if ReplicationTypeUtils.isAllowed(found.replicationType, replicationType) then
+				return found.moduleScript
+			else
+				return nil
+			end
+		end
+	end
+
+	return nil
+end
+
+function PackageTracker:_trackChildrenAndReplicationType(parent, ancestorReplicationType)
+	assert(typeof(parent) == "Instance", "Bad parent")
+	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
+
+	local maid = Maid.new()
+
+	local lastReplicationType = ReplicationTypeUtils.getFolderReplicationType(parent.Name, ancestorReplicationType)
+
+	maid:GiveTask(parent:GetPropertyChangedSignal("Name"):Connect(function()
+		local newReplicationType = ReplicationTypeUtils.getFolderReplicationType(parent.Name, ancestorReplicationType)
+		if newReplicationType ~= lastReplicationType then
+			maid._current = self:_trackChildren(parent, newReplicationType)
+			lastReplicationType = newReplicationType
+		end
+	end))
+
+	maid._current = self:_trackChildren(parent, lastReplicationType)
+
+	return maid
+end
+
+function PackageTracker:_trackChildren(parent, ancestorReplicationType)
+	assert(typeof(parent) == "Instance", "Bad parent")
+	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
+
+	local maid = Maid.new()
+
+	maid:GiveTask(parent.ChildAdded:Connect(function(child)
+		self:_handleChildAdded(maid, child, ancestorReplicationType)
+	end))
+	maid:GiveTask(parent.ChildRemoved:Connect(function(child)
+		self:_handleChildRemoved(maid, child, ancestorReplicationType)
+	end))
+	for _, child in pairs(parent:GetChildren()) do
+		self:_handleChildAdded(maid, child, ancestorReplicationType)
+	end
+
+	return maid
+end
+
+function PackageTracker:_handleChildAdded(parentMaid, child, ancestorReplicationType)
+	assert(Maid.isMaid(parentMaid), "Bad maid")
+	assert(typeof(child) == "Instance", "Bad child")
+	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
+
+	if child:IsA("ModuleScript") then
+		parentMaid[child] = self:_trackModuleScript(child, ancestorReplicationType)
+	elseif child:IsA("Folder") then
+		parentMaid[child] = self:_trackFolder(child, ancestorReplicationType)
+	end
+end
+
+function PackageTracker:_handleChildRemoved(parentMaid, child)
+	assert(Maid.isMaid(parentMaid), "Bad maid")
+	assert(typeof(child) == "Instance", "Bad child")
+
+	parentMaid[child] = nil
+end
+
+
+function PackageTracker:_trackFolder(child, ancestorReplicationType)
+	assert(typeof(child) == "Instance", "Bad child")
+	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
+
+	local maid = Maid.new()
+
+	maid:GiveTask(child:GetPropertyChangedSignal("Name"):Connect(function()
+		if child.Name == "node_modules" then
+			maid._current = self:_trackMainNodeModuleFolder(child)
+		else
+			maid._current = self:_trackChildrenAndReplicationType(child, ancestorReplicationType)
+		end
+	end))
+
+	if child.Name == "node_modules" then
+		maid._current = self:_trackMainNodeModuleFolder(child)
+	else
+		maid._current = self:_trackChildrenAndReplicationType(child, ancestorReplicationType)
+	end
+
+	return maid
+end
+
+
+function PackageTracker:_trackModuleScript(child, ancestorReplicationType)
+	assert(typeof(child) == "Instance", "Bad child")
+	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
+
+
+	local maid = Maid.new()
+
+	local function update()
+		if child.Archivable then
+			maid._current = self:_storeModuleScript(child.Name, child, ancestorReplicationType)
+		else
+			maid._current = nil
+		end
+	end
+
+	maid:GiveTask(child:GetPropertyChangedSignal("Name"):Connect(update))
+	maid:GiveTask(child:GetPropertyChangedSignal("Archivable"):Connect(update))
+
+	update()
+
+	return maid
+end
+
+function PackageTracker:_storeModuleScript(moduleScriptName, child, ancestorReplicationType)
+	assert(type(moduleScriptName) == "string", "Bad moduleScriptName")
+	assert(typeof(child) == "Instance", "Bad child")
+	assert(ReplicationTypeUtils.isReplicationType(ancestorReplicationType), "Bad ancestorReplicationType")
+
+	if self._packageModuleScriptMap[moduleScriptName] then
+		warn(string.format("[PackageTracker] - Overwriting moduleScript with name %q", moduleScriptName))
+	end
+
+	local data = {
+		moduleScript = child;
+		replicationType = ancestorReplicationType;
+	}
+	self._packageModuleScriptMap[moduleScriptName] = data
+
+	return function()
+		if self._packageModuleScriptMap[moduleScriptName] == data then
+			self._packageModuleScriptMap[moduleScriptName] = nil
+		end
+	end
+end
+
+function PackageTracker:_trackMainNodeModuleFolder(parent)
+	local maid = Maid.new()
+
+	maid:GiveTask(parent.ChildAdded:Connect(function(child)
+		self:_handleNodeModulesChildAdded(maid, child)
+	end))
+	maid:GiveTask(parent.ChildRemoved:Connect(function(child)
+		self:_handleNodeModulesChildRemoved(maid, child)
+	end))
+	for _, child in pairs(parent:GetChildren()) do
+		self:_handleNodeModulesChildAdded(maid, child)
+	end
+
+	return maid
+end
+
+
+function PackageTracker:_handleNodeModulesChildAdded(parentMaid, child)
+	assert(Maid.isMaid(parentMaid), "Bad maid")
+	assert(typeof(child) == "Instance", "Bad child")
+
+	if child:IsA("ObjectValue") then
+		-- Assume symlinked package
+		parentMaid[child] = self:_trackNodeModulesObjectValue(child)
+	elseif child:IsA("Folder") then
+		parentMaid[child] = self:_trackNodeModulesChildFolder(child)
+	elseif child:IsA("ModuleScript") then
+		parentMaid[child] = self:_trackAddPackage(child)
+	end
+end
+
+function PackageTracker:_handleNodeModulesChildRemoved(parentMaid, child)
+	assert(Maid.isMaid(parentMaid), "Bad maid")
+	assert(typeof(child) == "Instance", "Bad child")
+
+	parentMaid[child] = nil
+end
+
+function PackageTracker:_trackNodeModulesChildFolder(child)
+	assert(typeof(child) == "Instance", "Bad child")
+
+	local maid = Maid.new()
+
+	local function update()
+		local childName = child.Name
+
+		-- like @quenty
+		if DependencyUtils.isPackageGroup(childName) then
+			return self:_trackScopedChildFolder(childName, child)
+		else
+			return self:_tryStorePackage(childName, child)
+		end
+	end
+
+	maid:GiveTask(child:GetPropertyChangedSignal("Name"):Connect(function()
+		maid._current = update()
+	end))
+
+	maid._current = update()
+
+	return maid
+end
+
+function PackageTracker:_trackNodeModulesObjectValue(objectValue)
+	assert(typeof(objectValue) == "Instance", "Bad objectValue")
+
+	local maid = Maid.new()
+
+	maid:GiveTask(objectValue:GetPropertyChangedSignal("Name"):Connect(function()
+		maid._current = self:_tryStorePackage(objectValue.Name, objectValue.Value)
+	end))
+	maid:GiveTask(objectValue:GetPropertyChangedSignal("Value"):Connect(function()
+		maid._current = self:_tryStorePackage(objectValue.Name, objectValue.Value)
+	end))
+
+	maid._current = self:_tryStorePackage(objectValue.Name, objectValue.Value)
+
+	return maid
+end
+
+function PackageTracker:_trackScopedChildFolder(scopeName, parent)
+	assert(type(scopeName) == "string", "Bad scopeName")
+	assert(typeof(parent) == "Instance", "Bad parent")
+
+	local maid = Maid.new()
+
+	maid:GiveTask(parent.ChildAdded:Connect(function(child)
+		self:_handleScopedModulesChildAdded(scopeName, maid, child)
+	end))
+	maid:GiveTask(parent.ChildRemoved:Connect(function(child)
+		self:_handleScopedModulesChildRemoved(maid, child)
+	end))
+	for _, child in pairs(parent:GetChildren()) do
+		self:_handleScopedModulesChildAdded(scopeName, maid, child)
+	end
+
+	return maid
+end
+
+function PackageTracker:_handleScopedModulesChildAdded(scopeName, parentMaid, child)
+	assert(type(scopeName) == "string", "Bad scopeName")
+	assert(Maid.isMaid(parentMaid), "Bad maid")
+	assert(typeof(child) == "Instance", "Bad child")
+
+	if child:IsA("ObjectValue") then
+		parentMaid[child] = self:_trackScopedNodeModulesObjectValue(scopeName, child)
+	elseif child:IsA("Folder") or child:IsA("ModuleScript") then
+		parentMaid[child] = self:_trackAddScopedPackage(scopeName, child)
+	end
+end
+
+function PackageTracker:_trackScopedNodeModulesObjectValue(scopeName, objectValue)
+	assert(type(scopeName) == "string", "Bad scopeName")
+	assert(typeof(objectValue) == "Instance", "Bad objectValue")
+
+	local maid = Maid.new()
+
+	maid:GiveTask(objectValue:GetPropertyChangedSignal("Name"):Connect(function()
+		maid._current = self:_tryStorePackage(scopeName .. "/" .. objectValue.Name, objectValue.Value)
+	end))
+	maid:GiveTask(objectValue:GetPropertyChangedSignal("Value"):Connect(function()
+		maid._current = self:_tryStorePackage(scopeName .. "/" .. objectValue.Name, objectValue.Value)
+	end))
+
+	maid._current = self:_tryStorePackage(scopeName .. "/" .. objectValue.Name, objectValue.Value)
+
+	return maid
+end
+
+function PackageTracker:_handleScopedModulesChildRemoved(parentMaid, child)
+	assert(Maid.isMaid(parentMaid), "Bad maid")
+	assert(typeof(child) == "Instance", "Bad child")
+
+	parentMaid[child] = nil
+end
+
+function PackageTracker:_trackAddScopedPackage(scopeName, child)
+	assert(type(scopeName) == "string", "Bad scopeName")
+	assert(typeof(child) == "Instance", "Bad child")
+
+	local maid = Maid.new()
+
+	maid:GiveTask(child:GetPropertyChangedSignal("Name"):Connect(function()
+		maid._current = self:_tryStorePackage(scopeName .. "/" .. child.Name, child)
+	end))
+
+	maid._current = self:_tryStorePackage(scopeName .. "/" .. child.Name, child)
+
+	return maid
+end
+
+function PackageTracker:_trackAddPackage(child)
+	assert(typeof(child) == "Instance", "Bad child")
+
+	local maid = Maid.new()
+
+	maid:GiveTask(child:GetPropertyChangedSignal("Name"):Connect(function()
+		maid._current = self:_tryStorePackage(child.Name, child)
+	end))
+
+	maid._current = self:_tryStorePackage(child.Name, child)
+
+	return maid
+end
+
+function PackageTracker:_tryStorePackage(fullPackageName, packageInst)
+	assert(type(fullPackageName) == "string", "Bad fullPackageName")
+
+	if not packageInst then
+		return nil
+	end
+
+	self._subpackagesMap[fullPackageName] = packageInst
+
+	local packageTracker = self._packageTrackerProvider:AddPackageRoot(packageInst)
+	table.insert(self._subpackagesTrackerList, packageTracker)
+
+	return function()
+		local index = table.find(self._subpackagesTrackerList, packageTracker)
+		if index then
+			table.remove(self._subpackagesTrackerList, packageTracker)
+		end
+
+		if self._subpackagesMap[fullPackageName] == packageInst then
+			self._subpackagesMap[fullPackageName] = nil
+		end
+	end
+end
+
+function PackageTracker:Destroy()
+	self._maid:DoCleaning()
+end
+
+return PackageTracker