@flamework-experimental/core 2.0.0-alpha.1 → 2.0.0-alpha.2

package/out/lifecycle/lifecyclePlugin.luau

@@ -5,10 +5,120 @@ local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services"))
 local getRuntimeConfig = TS.import(script, script.Parent.Parent, "utility", "runtimeConfig").getRuntimeConfig
 local Provider = TS.import(script, script.Parent.Parent, "provider").Provider
 local recycleThread = TS.import(script, script.Parent.Parent, "utility", "recycleThread").recycleThread
+local _threadWaits = TS.import(script, script.Parent.Parent, "utility", "threadWaits")
+local extinguishesBegun = _threadWaits.extinguishesBegun
+local runsPromiseWork = _threadWaits.runsPromiseWork
+local threadWaits = _threadWaits.threadWaits
 local Reflect = TS.import(script, script.Parent.Parent, "reflect").Reflect
 local _pluginDefinition = TS.import(script, script.Parent.Parent, "plugin", "pluginDefinition")
 local LIFECYCLE_SLOT = _pluginDefinition.LIFECYCLE_SLOT
 local PluginDefinition = _pluginDefinition.PluginDefinition
+--[[
+	*
+	 * Late providers whose `onInit` has yet to finish, or to raise, to the plugin that runs it: what a
+	 * dependent's waits for. Shared by every module's plugin, since a provider's constructor may take a
+	 * lazy provider of an import, which the import's plugin initialises.
+	 
+]]
+local pendingInits = {}
+--[[
+	*
+	 * How many seconds a dependency wait that may be on itself (see `mayWaitForRunningThread`) lasts
+	 * before it is warned about.
+	 
+]]
+local SELF_WAIT_WARNING = 5
+--[[
+	*
+	 * A per-frame method read off its object as a plain function, and called with the object as `self`:
+	 * roblox-ts refuses a reference to a method that does not call it, and calling it through the object
+	 * took a closure per listener per frame to hand to the thread that runs it.
+	 
+]]
+--* The per-frame methods, by name, as `FrameCallback`s. 
+--[[
+	*
+	 * Runs a per-frame callback under the MicroProfiler label and the memory category of its object's
+	 * identifier. A function of its own, handed its arguments, rather than a closure per call.
+	 
+]]
+local function runProfiled(id, callback, object, dt, now)
+	-- `profilebegin` ends when the thread yields or dies.
+	debug.profilebegin(id)
+	debug.setmemorycategory(id)
+	callback(object, dt, now)
+	debug.resetmemorycategory()
+end
+--[[
+	*
+	 * The listeners of one per-frame event, walked in place every frame rather than over a copy.
+	 *
+	 * Luau lets a walk clear keys of the table it walks, ones it has yet to reach included -- which it
+	 * then passes over -- but not add them: a key added while a table is walked can make the walk visit
+	 * others twice, or not at all, once the table grows. So what is detached leaves `members` at once,
+	 * and is not called if its turn this frame has yet to come, while what is attached during the
+	 * event's walk -- by a callback: `createClassInstance`, `listen`, a lazy provider resolved -- waits
+	 * in `added` and joins once the walk is over, for its first call on the next frame.
+	 
+]]
+local FrameListeners
+do
+	FrameListeners = setmetatable({}, {
+		__tostring = function()
+			return "FrameListeners"
+		end,
+	})
+	FrameListeners.__index = FrameListeners
+	function FrameListeners.new(...)
+		local self = setmetatable({}, FrameListeners)
+		return self:constructor(...) or self
+	end
+	function FrameListeners:constructor(members)
+		self.members = members
+		self.walking = false
+		self.added = {}
+	end
+	function FrameListeners:has(value)
+		local _members = self.members
+		local _value = value
+		local _condition = _members[_value] ~= nil
+		if not _condition then
+			local _added = self.added
+			local _value_1 = value
+			_condition = _added[_value_1] ~= nil
+		end
+		return _condition
+	end
+	function FrameListeners:add(value)
+		if self.walking then
+			local _added = self.added
+			local _value = value
+			_added[_value] = true
+		else
+			local _members = self.members
+			local _value = value
+			_members[_value] = true
+		end
+	end
+	function FrameListeners:delete(value)
+		local _members = self.members
+		local _value = value
+		_members[_value] = nil
+		local _added = self.added
+		local _value_1 = value
+		_added[_value_1] = nil
+	end
+	function FrameListeners:endWalk()
+		self.walking = false
+		if next(self.added) == nil then
+			return nil
+		end
+		for value in self.added do
+			self.members[value] = true
+		end
+		table.clear(self.added)
+	end
+end
 --[[
 	*
 	 * Tracks the objects attached to each lifecycle event for one module.
@@ -39,9 +149,20 @@ do
 		self.onPhysics = {}
 		self.onRender = {}
 		self.onExtinguished = {}
+		self.tickListeners = FrameListeners.new(self.onTick)
+		self.physicsListeners = FrameListeners.new(self.onPhysics)
+		self.renderListeners = FrameListeners.new(self.onRender)
 		self.identifiers = {}
 		self.moduleConnections = {}
 		self.lateProviders = {}
+		self.lateQueue = {}
+		self.hasLateTurn = false
+		self.lateTurns = {}
+		self.lateTurnInits = {}
+		self.heldLateProviders = {}
+		self.initDependencies = {}
+		self.untold = {}
+		self.isExtinguishing = false
 		self.hasStarted = false
 		-- Per-module option, then the project's flamework.config.json, then Studio.
 		local _condition = options.profiling
@@ -83,23 +204,11 @@ do
 			local _object_1 = object
 			_condition = _onStart[_object_1] ~= nil
 			if not _condition then
-				local _onTick = self.onTick
-				local _object_2 = object
-				_condition = _onTick[_object_2] ~= nil
+				_condition = self.tickListeners:has(object) or self.physicsListeners:has(object) or self.renderListeners:has(object)
 				if not _condition then
-					local _onPhysics = self.onPhysics
-					local _object_3 = object
-					_condition = _onPhysics[_object_3] ~= nil
-					if not _condition then
-						local _onRender = self.onRender
-						local _object_4 = object
-						_condition = _onRender[_object_4] ~= nil
-						if not _condition then
-							local _onExtinguished = self.onExtinguished
-							local _object_5 = object
-							_condition = _onExtinguished[_object_5] ~= nil
-						end
-					end
+					local _onExtinguished = self.onExtinguished
+					local _object_2 = object
+					_condition = _onExtinguished[_object_2] ~= nil
 				end
 			end
 		end
@@ -108,6 +217,12 @@ do
 			local _identifiers = self.identifiers
 			local _object_1 = object
 			_identifiers[_object_1] = nil
+			local _lateProviders = self.lateProviders
+			local _object_2 = object
+			_lateProviders[_object_2] = nil
+			local _initDependencies = self.initDependencies
+			local _object_3 = object
+			_initDependencies[_object_3] = nil
 		end
 	end
 	function LifecycleProvider:removeFrom(set, value)
@@ -116,34 +231,125 @@ do
 		_set[_value] = nil
 		self:forget(value)
 	end
-	function LifecycleProvider:profile(callback, object)
-		if self.isProfiling then
-			local id = self:getIdentifier(object)
-			return recycleThread(function()
-				-- `profilebegin` ends when the thread yields or dies.
-				debug.profilebegin(id)
-				debug.setmemorycategory(id)
-				callback()
-				debug.resetmemorycategory()
-			end)
+	function LifecycleProvider:observeFrameEvents(target)
+		target.observe(self:observeFrameEvent(self.tickListeners), "$:lifecycle/lifecycleInterfaces@OnTick")
+		target.observe(self:observeFrameEvent(self.renderListeners), "$:lifecycle/lifecycleInterfaces@OnRender")
+		target.observe(self:observeFrameEvent(self.physicsListeners), "$:lifecycle/lifecycleInterfaces@OnPhysics")
+	end
+	function LifecycleProvider:observeFrameEvent(listeners)
+		return {
+			onAdded = function(value, context)
+				listeners:add(value)
+				if context.kind == "provider" then
+					self:addFrameProvider(value, context)
+				end
+			end,
+			onRemoved = function(value)
+				listeners:delete(value)
+				self:forget(value)
+			end,
+		}
+	end
+	function LifecycleProvider:addFrameProvider(object, context)
+		if self:recordDependencies(object, context) and self.hasStarted then
+			self:scheduleLateProvider(object)
 		end
-		return recycleThread(callback)
+	end
+	function LifecycleProvider:walkFrame(listeners, method, dt, now)
+		if self:hasBegunExtinguishing() then
+			return nil
+		end
+		local late = if next(self.lateProviders) == nil then nil else self.lateProviders
+		local profiling = self.isProfiling
+		local extinguishes = extinguishesBegun.count
+		listeners.walking = true
+		for listener in listeners.members do
+			if late ~= nil and late[listener] ~= nil then
+				continue
+			end
+			local callback = listener[method]
+			if profiling then
+				recycleThread(runProfiled, self:getIdentifier(listener), callback, listener, dt, now)
+			else
+				recycleThread(callback, listener, dt, now)
+			end
+			if extinguishesBegun.count ~= extinguishes then
+				extinguishes = extinguishesBegun.count
+				if self:hasBegunExtinguishing() then
+					break
+				end
+			end
+		end
+		listeners:endWalk()
 	end
 	function LifecycleProvider:runInit(object)
 		local id = self:getIdentifier(object)
-		if self.isProfiling then
-			debug.setmemorycategory(id)
-		end
-		local result = object:onInit()
+		local result = self:callInit(object, id)
 		if TS.Promise.is(result) then
+			-- Recorded as a wait on the Promise, as `callInit` records one on its thread: an `async`
+			-- `onInit` runs its body on a thread of its own, so one that extinguished an import of a
+			-- module this thread was extinguishing waited for this thread, which waited here for its
+			-- Promise, for good. Removed as the Promise settles, since a cancelled caller never resumes.
+			if result:getStatus() == TS.Promise.Status.Started then
+				local caller = coroutine.running()
+				threadWaits[caller] = result
+				result:finally(function()
+					threadWaits[caller] = nil
+				end):catch(function() end)
+			end
 			local status, value = result:awaitStatus()
 			if status == TS.Promise.Status.Rejected then
 				error(`onInit failed for '{id}': {tostring(value)}`, 0)
 			end
 		end
-		if self.isProfiling then
-			debug.resetmemorycategory()
+	end
+	function LifecycleProvider:callInit(object, id)
+		local caller = coroutine.running()
+		local outcome = nil
+		local waiting = false
+		local initThread = coroutine.create(function()
+			if self.isProfiling then
+				debug.setmemorycategory(id)
+			end
+			local success, value = pcall(function()
+				return object:onInit()
+			end)
+			outcome = { success, value }
+			-- Removed here rather than by the caller once it resumes: a caller cancelled meanwhile --
+			-- the testing runner cancels a body that overran -- never does, and left its entry behind.
+			threadWaits[caller] = nil
+			if waiting then
+				task.spawn(caller)
+			end
+		end)
+		-- Recorded as a wait, from before it starts, so that an extinguish can tell the caller waits
+		-- on it: an `onInit` that extinguished an import of a module the caller was extinguishing --
+		-- an ignition started from that module's `onExtinguished` -- waited for the caller, which
+		-- waited here, for good. On the caller's own thread, it would have gone straight through.
+		threadWaits[caller] = initThread
+		task.spawn(initThread)
+		if outcome == nil then
+			waiting = true
+			coroutine.yield()
+		end
+		local _binding = outcome
+		local success = _binding[1]
+		local value = _binding[2]
+		if not success then
+			error(value, 0)
 		end
+		return value
+	end
+	function LifecycleProvider:hasBegunExtinguishing()
+		local _condition = self.isExtinguishing
+		if not _condition then
+			local _result = self.module
+			if _result ~= nil then
+				_result = _result.isExtinguished()
+			end
+			_condition = _result == true
+		end
+		return _condition
 	end
 	function LifecycleProvider:runStart(object)
 		task.spawn(function()
@@ -159,26 +365,218 @@ do
 		local _lateProviders_1 = self.lateProviders
 		local _object_1 = object
 		_lateProviders_1[_object_1] = true
+		self:deferLateProvider(object)
+	end
+	function LifecycleProvider:deferLateProvider(object)
+		local turn = self:findRunningTurn()
+		if turn ~= nil then
+			local _exp = self.lateTurns[turn]
+			local _object = object
+			table.insert(_exp, _object)
+			return nil
+		end
+		local _lateQueue = self.lateQueue
+		local _object = object
+		table.insert(_lateQueue, _object)
+		if self.hasLateTurn then
+			return nil
+		end
+		self.hasLateTurn = true
 		task.defer(function()
-			local _lateProviders_2 = self.lateProviders
-			local _object_2 = object
-			if not (_lateProviders_2[_object_2] ~= nil) then
-				return nil
+			return self:runLateProviders()
+		end)
+	end
+	function LifecycleProvider:findRunningTurn()
+		local running = coroutine.running()
+		local waitingOnPromise
+		for turn in self.lateTurns do
+			local waitedOn = threadWaits[turn]
+			if waitedOn == running or coroutine.status(turn) == "normal" then
+				return turn
 			end
-			local _lateProviders_3 = self.lateProviders
-			local _object_3 = object
-			_lateProviders_3[_object_3] = nil
-			local _initMembers = self.initMembers
-			local _object_4 = object
-			if _initMembers[_object_4] ~= nil then
-				self:runInit(object)
+			if waitedOn ~= nil and not (type(waitedOn) == "thread") then
+				if waitingOnPromise == nil then
+					waitingOnPromise = turn
+				end
 			end
-			local _onStart = self.onStart
-			local _object_5 = object
-			if _onStart[_object_5] ~= nil then
+		end
+		if waitingOnPromise ~= nil and runsPromiseWork(running) then
+			return waitingOnPromise
+		end
+		return nil
+	end
+	function LifecycleProvider:initWaitsForRunningThread(object)
+		local running = coroutine.running()
+		for turn, providers in self.lateTurns do
+			if threadWaits[turn] == running or coroutine.status(turn) == "normal" then
+				local _condition = self.lateTurnInits[turn] == object
+				if not _condition then
+					local _object = object
+					_condition = table.find(providers, _object) ~= nil
+				end
+				return _condition
+			end
+		end
+		return false
+	end
+	function LifecycleProvider:mayWaitForRunningThread(object)
+		for turn, providers in self.lateTurns do
+			local _condition = self.lateTurnInits[turn] ~= object
+			if _condition then
+				local _object = object
+				_condition = not (table.find(providers, _object) ~= nil)
+			end
+			if _condition then
+				continue
+			end
+			local waitedOn = threadWaits[turn]
+			return waitedOn ~= nil and not (type(waitedOn) == "thread") and runsPromiseWork(coroutine.running())
+		end
+		return false
+	end
+	function LifecycleProvider:awaitDependencies(object)
+		local _initDependencies = self.initDependencies
+		local _object = object
+		local dependencies = _initDependencies[_object]
+		if dependencies == nil then
+			return not self:hasBegunExtinguishing()
+		end
+		local _initDependencies_1 = self.initDependencies
+		local _object_1 = object
+		_initDependencies_1[_object_1] = nil
+		local waitedFor
+		local since
+		local warned = false
+		while not self:hasBegunExtinguishing() do
+			local pending = false
+			for _, dependency in dependencies do
+				local owner = pendingInits[dependency]
+				if owner == nil or owner:initWaitsForRunningThread(dependency) then
+					continue
+				end
+				pending = true
+				if waitedFor == nil then
+					waitedFor = {}
+				end
+				if not (table.find(waitedFor, owner) ~= nil) then
+					table.insert(waitedFor, owner)
+				end
+				-- Once, and only for a wait that has lasted and may be on itself.
+				if not warned and since ~= nil and os.clock() - since >= SELF_WAIT_WARNING and owner:mayWaitForRunningThread(dependency) then
+					warned = true
+					warn(`[Flamework] '{self:getIdentifier(object)}' has waited {SELF_WAIT_WARNING}s for the onInit of '{owner:getIdentifier(dependency)}', which waits on Promise work that may be this very ignition: an onInit that ignites a module taking it after it has yielded waits for itself. Ignite such a module from onStart or a PlayerAdded handler instead.`)
+				end
+			end
+			if not pending then
+				break
+			end
+			if since == nil then
+				since = os.clock()
+			end
+			task.wait()
+		end
+		if self:hasBegunExtinguishing() then
+			return false
+		end
+		local _condition = waitedFor == nil
+		if not _condition then
+			-- ▼ ReadonlyArray.some ▼
+			local _result = false
+			local _callback = function(owner)
+				return owner:hasBegunExtinguishing()
+			end
+			for _k, _v in waitedFor do
+				if _callback(_v, _k - 1, waitedFor) then
+					_result = true
+					break
+				end
+			end
+			-- ▲ ReadonlyArray.some ▲
+			_condition = not _result
+		end
+		return _condition
+	end
+	function LifecycleProvider:runLateProviders()
+		-- This turn takes what was resolved before it began; anything resolved from here on, but by
+		-- its own `onInit`s, is the next one's.
+		local providers = self.lateQueue
+		self.lateQueue = {}
+		self.hasLateTurn = false
+		local turn = coroutine.running()
+		self.lateTurns[turn] = providers
+		local initialised = {}
+		-- Walked live, as `postIgnite` walks: an `onInit` may resolve another lazy provider, which
+		-- joins the end of this turn and is initialised after the ones before it.
+		while not (#providers == 0) do
+			-- Nothing once the module has begun to extinguish: by then it may have been told
+			-- `onExtinguished` -- one an `onExtinguished` handler resolved for the first time is --
+			-- and a later step that yields let this run after it, and before `release` detached it.
+			-- Nor once an `onInit` that yielded saw it begin.
+			if self:hasBegunExtinguishing() then
+				table.clear(providers)
+				break
+			end
+			-- Nor while the module is still igniting -- one a postIgnite hook after this plugin's
+			-- resolved, whose turn came when a hook yielded: it was started before the module was
+			-- ignited, even by an ignition that then failed. `start` gives them their turn again.
+			local _result = self.module
+			if _result ~= nil then
+				_result = _result.isIgnited()
+			end
+			if _result ~= true then
+				for _, object in providers do
+					local _exp = self.heldLateProviders
+					table.insert(_exp, object)
+				end
+				table.clear(providers)
+				break
+			end
+			local object = table.remove(providers, 1)
+			if not (self.lateProviders[object] ~= nil) then
+				continue
+			end
+			-- In front of its `onInit`, or of its `onStart` and per-frame events when it has none.
+			if not self:awaitDependencies(object) then
+				table.clear(providers)
+				break
+			end
+			if self.initMembers[object] ~= nil then
+				-- One that raises is reported and left out -- never ticking, never started, as on a
+				-- thread of its own -- and does not hold back the ones after it.
+				self.lateTurnInits[turn] = object
+				local success, err = pcall(function()
+					return self:runInit(object)
+				end)
+				self.lateTurnInits[turn] = nil
+				pendingInits[object] = nil
+				if not success then
+					task.spawn(error, err, 0)
+					continue
+				end
+			end
+			self.lateProviders[object] = nil
+			table.insert(initialised, object)
+		end
+		-- Over from here: one an `onStart` resolves gets a turn of its own.
+		self.lateTurns[turn] = nil
+		for _, object in initialised do
+			if self:hasBegunExtinguishing() then
+				return nil
+			end
+			if self.onStart[object] ~= nil then
 				self:runStart(object)
 			end
-		end)
+		end
+	end
+	function LifecycleProvider:recordDependencies(object, context)
+		if context.dependencies == nil or #context.dependencies == 0 then
+			return false
+		end
+		local _initDependencies = self.initDependencies
+		local _object = object
+		local _dependencies = context.dependencies
+		_initDependencies[_object] = _dependencies
+		return true
 	end
 	function LifecycleProvider:addInit(object, context)
 		local _initMembers = self.initMembers
@@ -191,11 +589,15 @@ do
 		if context.kind ~= "provider" then
 			return nil
 		end
+		self:recordDependencies(object, context)
 		if not self.hasStarted then
 			local _onInit = self.onInit
 			local _object_1 = object
 			table.insert(_onInit, _object_1)
 		else
+			local _object_1 = object
+			local _self = self
+			pendingInits[_object_1] = _self
 			self:scheduleLateProvider(object)
 		end
 	end
@@ -206,9 +608,14 @@ do
 		local _lateProviders = self.lateProviders
 		local _object_1 = object
 		_lateProviders[_object_1] = nil
-		local _onInit = self.onInit
 		local _object_2 = object
-		local index = (table.find(_onInit, _object_2) or 0) - 1
+		pendingInits[_object_2] = nil
+		local _initDependencies = self.initDependencies
+		local _object_3 = object
+		_initDependencies[_object_3] = nil
+		local _onInit = self.onInit
+		local _object_4 = object
+		local index = (table.find(_onInit, _object_4) or 0) - 1
 		if index ~= -1 then
 			table.remove(self.onInit, index + 1)
 		end
@@ -224,6 +631,7 @@ do
 		if context.kind ~= "provider" then
 			return nil
 		end
+		self:recordDependencies(object, context)
 		if not self.hasStarted then
 			local _startOrder = self.startOrder
 			local _object_1 = object
@@ -248,56 +656,84 @@ do
 		self:forget(object)
 	end
 	function LifecycleProvider:postIgnite(module)
+		self.module = module
 		-- Walked live rather than over a copy: an `onInit` may resolve a lazy provider, which joins
 		-- the end of the list while we iterate and is initialised in its turn -- over a copy it was
 		-- skipped, and then started with the rest, never initialised. Nothing leaves the list
 		-- during ignition, so the index stays true. A `while`, since a `for` compiles to a numeric
 		-- loop that reads the length once.
+		--
+		-- Then the providers without an `onInit` whose `onStart` or per-frame events wait for what
+		-- their constructor took: what is left in `initDependencies` once every `onInit` has waited.
 		local index = 0
-		while index < #self.onInit do
-			self:runInit(self.onInit[index + 1])
-			index += 1
+		while true do
+			local object
+			local initialises = index < #self.onInit
+			if initialises then
+				object = self.onInit[index + 1]
+			else
+				for waiting in self.initDependencies do
+					object = waiting
+					break
+				end
+				if object == nil then
+					break
+				end
+			end
+			-- After the `onInit`s still pending of what its constructor took, as in a late turn: a
+			-- lazy provider of an import that nothing had resolved yet is constructed for it here and
+			-- initialised by the import's plugin, on a turn of its own, which came after this one's
+			-- `onInit` and `onStart` both. The ignition waits, as for an `onInit` that yields, and
+			-- fails if that module extinguishes meanwhile, as it does when an import extinguishes
+			-- while an `onInit` yields -- here before this `onInit` runs against what it released.
+			if not self:awaitDependencies(object) then
+				error(`module '{module.debugName}': '{self:getIdentifier(object)}' takes a provider of a module that was extinguished while this module was igniting`, 0)
+			end
+			if initialises then
+				self:runInit(object)
+				index += 1
+			end
 		end
 		self.hasStarted = true
+	end
+	function LifecycleProvider:start(module)
+		-- An `onStart` may extinguish the module; nothing starts or ticks after that.
 		local _array = {}
 		local _length = #_array
 		local _array_1 = self.startOrder
 		table.move(_array_1, 1, #_array_1, _length + 1, _array)
 		for _, object in _array do
+			if self:hasBegunExtinguishing() then
+				return nil
+			end
 			self:runStart(object)
 		end
-		local onTick = self.onTick
-		local onPhysics = self.onPhysics
-		local onRender = self.onRender
+		if self:hasBegunExtinguishing() then
+			return nil
+		end
+		for _, object in self.heldLateProviders do
+			self:deferLateProvider(object)
+		end
+		table.clear(self.heldLateProviders)
+		local tickListeners = self.tickListeners
+		local physicsListeners = self.physicsListeners
+		local renderListeners = self.renderListeners
 		local connections = {}
 		-- Heartbeat rather than PostSimulation: the same point of the frame in a running game, but
 		-- Heartbeat also fires where no simulation runs (an edit-mode plugin, an Open Cloud Luau
 		-- task), so onTick works there too. PreSimulation has no such alias; onPhysics stays silent.
 		local _arg0 = RunService.Heartbeat:Connect(function(dt)
-			for provider in onTick do
-				self:profile(function()
-					return provider:onTick(dt)
-				end, provider)
-			end
+			return self:walkFrame(tickListeners, "onTick", dt)
 		end)
 		table.insert(connections, _arg0)
 		local _arg0_1 = RunService.PreSimulation:Connect(function(dt)
-			local now = time()
-			for provider in onPhysics do
-				self:profile(function()
-					return provider:onPhysics(dt, now)
-				end, provider)
-			end
+			return self:walkFrame(physicsListeners, "onPhysics", dt, time())
 		end)
 		table.insert(connections, _arg0_1)
 		-- PreRender never fires on the server, so there is nothing to connect there.
 		if RunService:IsClient() then
 			local _arg0_2 = RunService.PreRender:Connect(function(dt)
-				for provider in onRender do
-					self:profile(function()
-						return provider:onRender(dt)
-					end, provider)
-				end
+				return self:walkFrame(renderListeners, "onRender", dt)
 			end)
 			table.insert(connections, _arg0_2)
 		end
@@ -320,6 +756,7 @@ do
 		-- Over a copy, since a handler may detach objects; one detached by a handler before it --
 		-- `removeClassInstance` from an `onExtinguished` -- has left the event, so it is not told.
 		-- One failing handler must not leave the module stuck half-extinguished.
+		self.isExtinguishing = true
 		local _array = {}
 		local _length = #_array
 		for _v in self.onExtinguished do
@@ -330,14 +767,57 @@ do
 			if not (self.onExtinguished[provider] ~= nil) then
 				continue
 			end
-			local success, err = pcall(function()
-				return provider:onExtinguished()
-			end)
-			if not success then
-				warn(`[Flamework] onExtinguished failed for '{self:getIdentifier(provider)}': {tostring(err)}`)
+			self:tellExtinguished(provider)
+		end
+		-- What the handlers attached is not in the copy: a lazy provider they resolved for the first
+		-- time. It is told in its turn, as it would have been released without it.
+		while not (next(self.untold) == nil) do
+			local _array_1 = {}
+			local _length_1 = #_array_1
+			for _v in self.untold do
+				_length_1 += 1
+				_array_1[_length_1] = _v
 			end
+			local _binding = _array_1
+			local provider = _binding[1]
+			self.untold[provider] = nil
+			self:tellExtinguished(provider)
+		end
+	end
+	function LifecycleProvider:tellExtinguished(provider)
+		local success, err = pcall(function()
+			return provider:onExtinguished()
+		end)
+		if not success then
+			warn(`[Flamework] onExtinguished failed for '{self:getIdentifier(provider)}': {tostring(err)}`)
+		end
+	end
+	function LifecycleProvider:addExtinguished(object)
+		local _onExtinguished = self.onExtinguished
+		local _object = object
+		_onExtinguished[_object] = true
+		if self.isExtinguishing then
+			local _untold = self.untold
+			local _object_1 = object
+			_untold[_object_1] = true
 		end
 	end
+	function LifecycleProvider:removeExtinguished(object, refused)
+		if refused == nil then
+			refused = false
+		end
+		local _untold = self.untold
+		local _object = object
+		if _untold[_object] ~= nil then
+			local _untold_1 = self.untold
+			local _object_1 = object
+			_untold_1[_object_1] = nil
+			if not refused then
+				self:tellExtinguished(object)
+			end
+		end
+		self:removeFrom(self.onExtinguished, object)
+	end
 	do
 		-- (Flamework) LifecycleProvider metadata
 		Reflect_1.defineMetadata(LifecycleProvider, "identifier", "$:lifecycle/lifecyclePlugin@LifecycleProvider")
@@ -349,20 +829,6 @@ do
 	end
 	LifecycleProvider = Provider()(LifecycleProvider) or LifecycleProvider
 end
---* An observer that keeps one of the provider's plain event sets in step with the module. 
-local function observeSet(provider, set)
-	return {
-		onAdded = function(value)
-			local _set = set
-			local _value = value
-			_set[_value] = true
-			return _set
-		end,
-		onRemoved = function(value)
-			return provider:removeFrom(set, value)
-		end,
-	}
-end
 --[[
 	*
 	 * Creates a lifecycle plugin with the specified options.
@@ -383,6 +849,9 @@ local function createLifecyclePlugin(options)
 		target.onPostIgnite(function(module)
 			return lifecycle:postIgnite(module)
 		end)
+		target.onIgnited(function(module)
+			return lifecycle:start(module)
+		end)
 		target.onExtinguished(function(module)
 			return lifecycle:extinguished(module)
 		end)
@@ -402,10 +871,15 @@ local function createLifecyclePlugin(options)
 				return lifecycle:removeStart(value)
 			end,
 		}, "$:lifecycle/lifecycleInterfaces@OnStart")
-		target.observe(observeSet(lifecycle, lifecycle.onTick), "$:lifecycle/lifecycleInterfaces@OnTick")
-		target.observe(observeSet(lifecycle, lifecycle.onRender), "$:lifecycle/lifecycleInterfaces@OnRender")
-		target.observe(observeSet(lifecycle, lifecycle.onPhysics), "$:lifecycle/lifecycleInterfaces@OnPhysics")
-		target.observe(observeSet(lifecycle, lifecycle.onExtinguished), "$:lifecycle/lifecycleInterfaces@OnExtinguished")
+		lifecycle:observeFrameEvents(target)
+		target.observe({
+			onAdded = function(value)
+				return lifecycle:addExtinguished(value)
+			end,
+			onRemoved = function(value, context)
+				return lifecycle:removeExtinguished(value, context.refused == true)
+			end,
+		}, "$:lifecycle/lifecycleInterfaces@OnExtinguished")
 	end
 	return PluginDefinition.new("Lifecycle", setup, LIFECYCLE_SLOT)
 end