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

package/out/module/module.luau

@@ -5,6 +5,9 @@ local convertConciseDependencyInfo = TS.import(script, script.Parent.Parent, "ut
 local getClassImplements = TS.import(script, script.Parent.Parent, "utility", "getClassImplements").getClassImplements
 local getClassesInPath = TS.import(script, script.Parent.Parent, "utility", "getClassesInPath").getClassesInPath
 local getClassesInGlob = TS.import(script, script.Parent.Parent, "utility", "globs").getClassesInGlob
+local _threadWaits = TS.import(script, script.Parent.Parent, "utility", "threadWaits")
+local extinguishesBegun = _threadWaits.extinguishesBegun
+local threadWaits = _threadWaits.threadWaits
 local clearDefaultModule = TS.import(script, script.Parent, "defaultModule").clearDefaultModule
 local HookPriority = TS.import(script, script.Parent, "moduleHooks").HookPriority
 local _providerRegistration = TS.import(script, script.Parent, "providerRegistration")
@@ -88,12 +91,24 @@ local function createModuleInstantiation(state, options)
 	local instantiatedProviders = {}
 	--* Objects handed over by `provideInstance`, attached to their interfaces once every plugin is set up. 
 	local providedInstances = {}
+	--[[
+		*
+		     * Provided objects that have not joined their interfaces: until the ignition reaches them, and
+		     * for good when an observer refuses one. `release` has nothing to take them out of, and a failed
+		     * ignition told every observer `onRemoved` for objects it had never been told of, and told the
+		     * observers that had just undone a refused one of it again.
+		     
+	]]
+	local unjoinedInstances = {}
 	local observers = {}
 	local hooks = {}
 	local includedPlugins = {}
 	local filledSlots = {}
 	local temporaryInstances = {}
 	local moduleInitState = ModuleInitState.Created
+	--* The thread `extinguish` runs on, and what wakes each thread waiting in `awaitExtinguished` for it to finish. 
+	local extinguishingThread
+	local extinguishWaiters = {}
 	local switchInitState = function(from, to)
 		if moduleInitState ~= from then
 			error(`module '{state.debugName}' is in invalid state when transitioning to '{ModuleInitState[to]}', got '{ModuleInitState[moduleInitState]}' when '{ModuleInitState[from]}' was expected.`)
@@ -292,12 +307,18 @@ local function createModuleInstantiation(state, options)
 		     * observer that raises from its `onAdded` has the ones before it told `onRemoved`, and the
 		     * error comes out, so a refused object is attached nowhere -- rather than left ticking in the
 		     * lifecycle's sets, with no handle to remove it by.
+		     *
+		     * `dependencies`, what a provider's constructor was given, is handed to the observers with it.
 		     
 	]]
-	local registerClassInterfaces = function(instance, kind)
-		local added = {}
+	local registerClassInterfaces = function(instance, kind, dependencies)
+		local interfaces = getClassImplements(instance)
+		-- How many observers have been told `onAdded`, in the order they were told: what a refusal
+		-- undoes. Counted rather than recorded, since an attachment that goes through -- every one,
+		-- in a game -- then builds nothing to throw away.
+		local attached = 0
 		local success, err = pcall(function()
-			for _, interfaceId in getClassImplements(instance) do
+			for _, interfaceId in interfaces do
 				local interested = observers[interfaceId]
 				if not interested then
 					continue
@@ -308,18 +329,35 @@ local function createModuleInstantiation(state, options)
 						_result_1(instance, {
 							interfaceId = interfaceId,
 							kind = kind,
+							dependencies = dependencies,
 						})
 					end
-					local _arg0 = { interfaceId, observer }
-					table.insert(added, _arg0)
+					attached += 1
 				end
 			end
 		end)
 		if not success then
+			-- The observers told, found again by walking the same way as far as the count goes.
+			local told = {}
+			for _, interfaceId in interfaces do
+				local interested = observers[interfaceId]
+				if not interested then
+					continue
+				end
+				for _1, observer in interested do
+					if #told == attached then
+						break
+					end
+					local _arg0 = { interfaceId, observer }
+					table.insert(told, _arg0)
+				end
+			end
 			-- Undone in reverse, each step guarded, so that one `onRemoved` raising does not leave
-			-- the rest attached; the observer's error is what comes out.
-			for i = #added - 1, 0, -1 do
-				local _binding = added[i + 1]
+			-- the rest attached; the observer's error is what comes out. Marked as refused, so that
+			-- an observer owing a departing object a last event -- the lifecycle plugin's
+			-- `onExtinguished` while the module extinguishes -- does not deliver it.
+			for i = #told - 1, 0, -1 do
+				local _binding = told[i + 1]
 				local interfaceId = _binding[1]
 				local observer = _binding[2]
 				guarded("undoing an attachment", function()
@@ -328,6 +366,7 @@ local function createModuleInstantiation(state, options)
 						_result_1 = _result_1(instance, {
 							interfaceId = interfaceId,
 							kind = kind,
+							refused = true,
 						})
 					end
 					return _result_1
@@ -353,11 +392,15 @@ local function createModuleInstantiation(state, options)
 			end
 		end
 	end
+	--* Constructs a class, resolving what its constructor takes into `resolvedParameters`. 
 	local resolveDependencyWithOrigin
-	local instantiateClassWithDependencies = function(constructor, resolve)
+	local instantiateClassWithDependencies = function(constructor, resolve, resolvedParameters)
+		if resolvedParameters == nil then
+			resolvedParameters = {}
+		end
 		local dependencies = Reflect.getMetadata(constructor, "flamework:dependencies") or {}
-		local resolvedParameters = {}
 		for _, dependency in dependencies do
+			local _resolvedParameters = resolvedParameters
 			local _result_1 = resolve
 			if _result_1 ~= nil then
 				_result_1 = _result_1(dependency)
@@ -366,7 +409,7 @@ local function createModuleInstantiation(state, options)
 			if _condition_1 == nil then
 				_condition_1 = resolveDependencyWithOrigin(dependency, constructor)
 			end
-			table.insert(resolvedParameters, _condition_1)
+			table.insert(_resolvedParameters, _condition_1)
 		end
 		return constructor.new(unpack(resolvedParameters))
 	end
@@ -405,10 +448,21 @@ local function createModuleInstantiation(state, options)
 		if moduleProvider then
 			local config = moduleProvider.config
 			if config.type == "class" then
-				local instantiatedProvider = instantiateClassWithDependencies(config.value)
+				local dependencies = {}
+				local instantiatedProvider = instantiateClassWithDependencies(config.value, nil, dependencies)
 				local _id_1 = info.id
 				instantiatedProviders[_id_1] = instantiatedProvider
-				registerClassInterfaces(instantiatedProvider, "provider")
+				-- Held only if it is attached: one an observer refuses is attached nowhere, so it must
+				-- not be cached either -- the next resolve handed it out with no lifecycle at all, and
+				-- `release` told every observer, the refusing one included, it was removed again.
+				local attached, err = pcall(function()
+					return registerClassInterfaces(instantiatedProvider, "provider", dependencies)
+				end)
+				if not attached then
+					local _id_2 = info.id
+					instantiatedProviders[_id_2] = nil
+					error(err, 0)
+				end
 				return instantiatedProvider
 			elseif config.type == "function" then
 				-- Function providers are not cached.
@@ -602,6 +656,7 @@ local function createModuleInstantiation(state, options)
 			-- every plugin's observers are in place.
 			for _, instance in providedInstances do
 				registerClassInterfaces(instance, "provider")
+				unjoinedInstances[instance] = nil
 			end
 			for _, provider in providers do
 				-- Lazy providers are constructed the first time they are resolved instead.
@@ -610,6 +665,15 @@ local function createModuleInstantiation(state, options)
 				end
 			end
 			runHooks("postIgnite")
+			-- Checked again once everything has run: an `onInit` that yields lets other threads run in
+			-- the middle of ignition, and one that extinguished an import then did not see this module
+			-- among its importers, since it joins them only below. Carrying on left it ignited onto a
+			-- released import that would never take it down.
+			for _, imported in imports do
+				if not imported.isIgnited() then
+					error(`module '{state.debugName}': imported module '{imported.debugName}' was extinguished while this module was igniting`)
+				end
+			end
 		end)
 		if not success then
 			moduleInitState = ModuleInitState.Extinguishing
@@ -621,12 +685,29 @@ local function createModuleInstantiation(state, options)
 		for _, imported in imports do
 			imported.addImporter(module)
 		end
+		-- Ignition has completed, so this is where the lifecycle plugin starts the providers: an
+		-- `onStart` sees the module ignited, may extinguish it, and may ignite one that imports it.
+		-- Nothing here can fail the ignition, so a hook that raises is warned about. One that
+		-- extinguishes the module ends the phase: the hooks after it would set up a module gone.
+		for _, hook in sortedHooks("ignited") do
+			if moduleInitState ~= ModuleInitState.Ignited then
+				break
+			end
+			guarded("an onIgnited hook", function()
+				return hook.callback(module)
+			end)
+		end
 		return module
 	end
 	local extinguish = function()
 		switchInitState(ModuleInitState.Ignited, ModuleInitState.Extinguishing)
+		extinguishingThread = coroutine.running()
+		extinguishesBegun.count += 1
 		-- Importers hold this module's instances, so they go first, and each takes its own importers
-		-- down before it returns: the deepest goes first. Copied, since each removes itself.
+		-- down before it returns: the deepest goes first. Copied, since each removes itself. One
+		-- extinguishing already, on another thread suspended in a handler that yields, is still
+		-- using this module's providers, so it is waited for: skipped, it had this module released
+		-- under it.
 		local _array_2 = {}
 		local _length_1 = #_array_2
 		for _v in importers do
@@ -636,6 +717,8 @@ local function createModuleInstantiation(state, options)
 		for _, importer in _array_2 do
 			if not importer.isExtinguished() then
 				importer.extinguish()
+			else
+				importer.awaitExtinguished()
 			end
 		end
 		table.clear(importers)
@@ -674,10 +757,31 @@ local function createModuleInstantiation(state, options)
 		-- Providers join their interfaces when they are instantiated, so they have to leave them
 		-- too. Without this, a plugin such as the lifecycle plugin keeps holding (and ticking)
 		-- providers that belong to an extinguished module.
-		for _, provider in instantiatedProviders do
-			guarded("removing a provider", function()
-				return unregisterClassInterfaces(provider, "provider")
-			end)
+		--
+		-- Over a copy, taken again until nothing new turns up: a removal runs user code -- the
+		-- lifecycle plugin tells a provider resolved since its walk `onExtinguished` as it leaves --
+		-- which may resolve a lazy provider for the first time, and a table gaining keys while it
+		-- is walked skipped providers, or had others unregistered twice. By object, not by id: an
+		-- object provided under several ids joined its interfaces once, so it leaves them once.
+		local released = {}
+		while true do
+			local remaining = {}
+			for _, provider in instantiatedProviders do
+				if not (released[provider] ~= nil) then
+					released[provider] = true
+					if not (unjoinedInstances[provider] ~= nil) then
+						table.insert(remaining, provider)
+					end
+				end
+			end
+			if #remaining == 0 then
+				break
+			end
+			for _, provider in remaining do
+				guarded("removing a provider", function()
+					return unregisterClassInterfaces(provider, "provider")
+				end)
+			end
 		end
 		-- A removal that raised leaves its instance behind, and nothing can add one any more.
 		table.clear(temporaryInstances)
@@ -689,6 +793,80 @@ local function createModuleInstantiation(state, options)
 		-- Released last, once nothing in here can resolve any more, so that the next root ignited
 		-- becomes the default rather than `Dependency<T>()` answering from a dead module.
 		clearDefaultModule(module)
+		for _, wake in extinguishWaiters do
+			wake()
+		end
+		table.clear(extinguishWaiters)
+	end
+	local awaitExtinguished = function()
+		if moduleInitState ~= ModuleInitState.Extinguishing then
+			return nil
+		end
+		-- On the extinguish's own thread -- one of its handlers extinguishing an import -- it cannot
+		-- finish until this returns, so waiting would never end. Nor on a thread the extinguish's
+		-- thread is itself waiting on here, however many waits away: two extinguishes, each waiting
+		-- for a module the other is taking down, held each other -- and every module between them,
+		-- still ticking -- for good. The wait that would close the circle is skipped, as the wait on
+		-- the extinguish's own thread is. The chain runs through an ignition waiting for an `onInit`
+		-- on its own thread too, which the lifecycle plugin records -- and through one waiting for the
+		-- Promise an `onInit` returned, whose work runs on a thread nothing can name: an `async`
+		-- method's body runs on one of its own. A chain that ends at one is taken to close the circle,
+		-- since the thread that settles it may be this one.
+		local running = coroutine.running()
+		local thread = extinguishingThread
+		local closesCircle = function()
+			local waitedOn = thread
+			while waitedOn ~= nil do
+				local _condition_1 = waitedOn == running
+				if not _condition_1 then
+					local _waitedOn = waitedOn
+					_condition_1 = not (type(_waitedOn) == "thread")
+				end
+				if _condition_1 then
+					return true
+				end
+				local _waitedOn = waitedOn
+				waitedOn = threadWaits[_waitedOn]
+			end
+			return false
+		end
+		if closesCircle() then
+			return nil
+		end
+		-- Nor on a thread that has died -- cancelled, as the testing runner cancels a body that
+		-- overran, or closed: that extinguish never finishes, and waiting for it held this module,
+		-- and everything in it, for good. One that dies while this waits is noticed within a frame.
+		if coroutine.status(thread) == "dead" then
+			return nil
+		end
+		local woken = false
+		local wake = function()
+			if woken then
+				return nil
+			end
+			woken = true
+			-- Removed here rather than by this thread once it resumes: one cancelled while it waits
+			-- never does, and left its entry behind for good.
+			threadWaits[running] = nil
+			if coroutine.status(running) ~= "dead" then
+				task.spawn(running)
+			end
+		end
+		threadWaits[running] = thread
+		table.insert(extinguishWaiters, wake)
+		-- Checked again every frame, as well as for a dead extinguish: this thread may be cancelled
+		-- while it waits, and the chain may come to close the circle after the wait began -- an
+		-- `async` `onInit`'s body waits here before the ignition that called it takes the Promise it
+		-- returned and waits on that.
+		task.spawn(function()
+			while not woken do
+				task.wait()
+				if coroutine.status(thread) == "dead" or coroutine.status(running) == "dead" or closesCircle() then
+					wake()
+				end
+			end
+		end)
+		coroutine.yield()
 	end
 	local isExtinguished = function()
 		return moduleInitState >= ModuleInitState.Extinguishing
@@ -721,6 +899,7 @@ local function createModuleInstantiation(state, options)
 			-- ▲ Set.delete ▲
 			return _valueExisted
 		end,
+		awaitExtinguished = awaitExtinguished,
 	}
 	--* What a plugin's setup is handed. Everything registers into this instantiation. 
 	pluginTarget = {
@@ -760,8 +939,15 @@ local function createModuleInstantiation(state, options)
 			local _injectionId = injectionId
 			local _instance = instance
 			instantiatedProviders[_injectionId] = _instance
+			-- Once, however many ids it is provided under: it joins its interfaces once per entry,
+			-- and the same object twice was initialised, started and told `onAdded` twice.
 			local _instance_1 = instance
-			table.insert(providedInstances, _instance_1)
+			if not (table.find(providedInstances, _instance_1) ~= nil) then
+				local _instance_2 = instance
+				table.insert(providedInstances, _instance_2)
+				local _instance_3 = instance
+				unjoinedInstances[_instance_3] = true
+			end
 		end,
 		includePlugin = includePlugin,
 		onPreIgnite = function(callback, hookOptions)
@@ -780,6 +966,14 @@ local function createModuleInstantiation(state, options)
 			end
 			return registerHook("postIgnite", _exp, _result_1)
 		end,
+		onIgnited = function(callback, hookOptions)
+			local _exp = callback
+			local _result_1 = hookOptions
+			if _result_1 ~= nil then
+				_result_1 = _result_1.priority
+			end
+			return registerHook("ignited", _exp, _result_1)
+		end,
 		onExtinguished = function(callback, hookOptions)
 			local _exp = callback
 			local _result_1 = hookOptions

package/out/plugin/pluginDefinition.d.ts

@@ -94,6 +94,13 @@ export interface PluginTarget {
     onPreIgnite: (callback: (module: Module) => void, options?: HookOptions) => void;
     /** Runs after every provider has been constructed. */
     onPostIgnite: (callback: (module: Module) => void, options?: HookOptions) => void;
+    /**
+     * Runs once ignition has completed: the module is ignited, and its imports count it among
+     * their importers. The lifecycle plugin starts the providers here. Nothing can fail the
+     * ignition any more, so a hook that raises is warned about and the ones after it still run;
+     * once the module has been extinguished -- by an `onStart`, say -- the rest do not run.
+     */
+    onIgnited: (callback: (module: Module) => void, options?: HookOptions) => void;
     /** Runs when the module extinguishes, before its providers are released. */
     onExtinguished: (callback: (module: Module) => void, options?: HookOptions) => void;
     /**

package/out/reflect.luau

@@ -1,4 +1,6 @@
 -- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local forgetImplements = TS.import(script, script.Parent, "utility", "implementsCache").forgetImplements
 --[[
 	*
 	 * Reflection/metadata API
@@ -60,6 +62,10 @@ do
 		local _key = key
 		local _value = value
 		metadata[_key] = _value
+		-- What `getClassImplements` keeps per class is built from this key.
+		if key == "flamework:implements" then
+			forgetImplements(obj)
+		end
 	end
 	_container.defineMetadata = defineMetadata
 	--[[
@@ -72,6 +78,7 @@ do
 		for key, value in pairs(list) do
 			metadata[key] = value
 		end
+		forgetImplements(obj)
 	end
 	_container.defineMetadataBatch = defineMetadataBatch
 	--[[
@@ -86,6 +93,9 @@ do
 			local _key = key
 			_result[_key] = nil
 		end
+		if key == "flamework:implements" then
+			forgetImplements(obj)
+		end
 	end
 	_container.deleteMetadata = deleteMetadata
 	--[[
@@ -302,6 +312,7 @@ do
 	local function resetObject(object)
 		local _object = object
 		metadata[_object] = nil
+		forgetImplements(object)
 	end
 	_container.resetObject = resetObject
 end

package/out/utility/getClassImplements.d.ts

@@ -1,7 +1,14 @@
 /**
- * The interfaces a class implements, own and inherited, each once: the transformer writes every
+ * The interfaces an object implements, own and inherited, each once: the transformer writes every
  * class's own heritage clause, so a subclass that re-declares an interface its parent implements
  * carries the id twice up the chain, and attached to it twice -- the lifecycle's ordered lists ran
  * `onInit` and `onStart` twice for it.
+ *
+ * Walked once per class and kept: this runs on every attach and detach, and behind
+ * `Flamework.implements`. An instance, which implements nothing of its own, answers its class's
+ * list; so does a class asked directly. An object that implements something of its own -- a
+ * `listen` proxy, a plain object given the metadata -- or whose `__index` is not a table is walked
+ * every time, as before, rather than kept per object. The list is shared and frozen: callers must
+ * not change it.
  */
-export declare function getClassImplements(constructor: object): string[];
+export declare function getClassImplements(object: object): ReadonlyArray<string>;

package/out/utility/getClassImplements.luau

@@ -1,18 +1,26 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
 local Reflect = TS.import(script, script.Parent.Parent, "reflect").Reflect
+local implementsCache = TS.import(script, script.Parent, "implementsCache").implementsCache
+local IMPLEMENTS = "flamework:implements"
+local EMPTY = table.freeze({})
+--* Where `Reflect.getMetadatas` goes next from an object: its metatable's `__index`, its class. 
+local function getParent(object)
+	local metatable = getmetatable(object)
+	if metatable ~= nil and type(metatable) == "table" then
+		return rawget(metatable, "__index")
+	end
+end
 --[[
 	*
-	 * The interfaces a class implements, own and inherited, each once: the transformer writes every
-	 * class's own heritage clause, so a subclass that re-declares an interface its parent implements
-	 * carries the id twice up the chain, and attached to it twice -- the lifecycle's ordered lists ran
-	 * `onInit` and `onStart` twice for it.
+	 * The walk as `Reflect.getMetadatas` makes it, for an object whose list is not cached: every
+	 * `flamework:implements` list from the object up its chain, each id once, first seen first.
 	 
 ]]
-local function getClassImplements(constructor)
+local function collect(object)
 	local classImplements = {}
 	local seen = {}
-	for _, implementList in Reflect.getMetadatas(constructor, "flamework:implements") do
+	for _, implementList in Reflect.getMetadatas(object, IMPLEMENTS) do
 		for _1, implementId in implementList do
 			if not (seen[implementId] ~= nil) then
 				seen[implementId] = true
@@ -22,6 +30,81 @@ local function getClassImplements(constructor)
 	end
 	return classImplements
 end
+--[[
+	*
+	 * A class's list, built once: its own ids, then those of the class above it that it does not
+	 * re-declare, which is the order and the ids `collect` finds. One that declares nothing of its own
+	 * shares the list above it.
+	 
+]]
+local function getCachedImplements(object)
+	local _byClass = implementsCache.byClass
+	local _object = object
+	local cached = _byClass[_object]
+	if cached ~= nil then
+		return cached
+	end
+	local parent = getParent(object)
+	local inherited = if parent ~= nil then getCachedImplements(parent) else EMPTY
+	local list = inherited
+	local own = Reflect.getOwnMetadata(object, IMPLEMENTS)
+	if own ~= nil then
+		local merged = {}
+		for _, implementId in own do
+			if not (table.find(merged, implementId) ~= nil) then
+				table.insert(merged, implementId)
+			end
+		end
+		for _, implementId in inherited do
+			if not (table.find(merged, implementId) ~= nil) then
+				table.insert(merged, implementId)
+			end
+		end
+		list = table.freeze(merged)
+	end
+	local _byClass_1 = implementsCache.byClass
+	local _object_1 = object
+	local _list = list
+	_byClass_1[_object_1] = _list
+	return list
+end
+--[[
+	*
+	 * The interfaces an object implements, own and inherited, each once: the transformer writes every
+	 * class's own heritage clause, so a subclass that re-declares an interface its parent implements
+	 * carries the id twice up the chain, and attached to it twice -- the lifecycle's ordered lists ran
+	 * `onInit` and `onStart` twice for it.
+	 *
+	 * Walked once per class and kept: this runs on every attach and detach, and behind
+	 * `Flamework.implements`. An instance, which implements nothing of its own, answers its class's
+	 * list; so does a class asked directly. An object that implements something of its own -- a
+	 * `listen` proxy, a plain object given the metadata -- or whose `__index` is not a table is walked
+	 * every time, as before, rather than kept per object. The list is shared and frozen: callers must
+	 * not change it.
+	 
+]]
+local function getClassImplements(object)
+	if Reflect.getOwnMetadata(object, IMPLEMENTS) == nil then
+		local parent = getParent(object)
+		if parent == nil then
+			return EMPTY
+		end
+		if type(parent) == "table" then
+			return getCachedImplements(parent)
+		end
+	else
+		local _object = object
+		local _condition = type(_object) == "table"
+		if _condition then
+			_condition = rawget(object, "__index") == object
+		end
+		if _condition then
+			-- A class: a roblox-ts class is its own instances' `__index`.
+			return getCachedImplements(object)
+		end
+	end
+	return collect(object)
+end
 return {
 	getClassImplements = getClassImplements,
 }

package/out/utility/implementsCache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What each class implements, own and inherited, as `getClassImplements` found it, by the class --
+ * and by every class above it, which it walked on the way. Its own module, apart from
+ * `getClassImplements`, so that `Reflect`, which that one reads through, can reach it too.
+ */
+export declare const implementsCache: {
+    byClass: WeakMap<object, readonly string[]>;
+};
+/**
+ * Forgets every list once an object whose `flamework:implements` metadata one was built from has
+ * it changed: the lists of the classes below it were built from it too. The transformer writes a
+ * class's metadata as the class is defined, before anything can ask, so this does not happen in a
+ * game; it keeps a later change seen as it was before the lists were cached. What `listen` gives
+ * its proxies changes nothing here: an object that implements something of its own is not cached.
+ */
+export declare function forgetImplements(object: object): void;

package/out/utility/implementsCache.luau

@@ -0,0 +1,35 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * What each class implements, own and inherited, as `getClassImplements` found it, by the class --
+	 * and by every class above it, which it walked on the way. Its own module, apart from
+	 * `getClassImplements`, so that `Reflect`, which that one reads through, can reach it too.
+	 
+]]
+local implementsCache = {
+	byClass = setmetatable({}, {
+		__mode = "k",
+	}),
+}
+--[[
+	*
+	 * Forgets every list once an object whose `flamework:implements` metadata one was built from has
+	 * it changed: the lists of the classes below it were built from it too. The transformer writes a
+	 * class's metadata as the class is defined, before anything can ask, so this does not happen in a
+	 * game; it keeps a later change seen as it was before the lists were cached. What `listen` gives
+	 * its proxies changes nothing here: an object that implements something of its own is not cached.
+	 
+]]
+local function forgetImplements(object)
+	local _byClass = implementsCache.byClass
+	local _object = object
+	if _byClass[_object] ~= nil then
+		implementsCache.byClass = setmetatable({}, {
+			__mode = "k",
+		})
+	end
+end
+return {
+	forgetImplements = forgetImplements,
+	implementsCache = implementsCache,
+}

package/out/utility/recycleThread.d.ts

@@ -1 +1,13 @@
+/**
+ * Runs `func` with the arguments given, on a thread that is kept for the next call once it returns:
+ * one that yields keeps its thread, and the next call gets a new one.
+ *
+ * The arguments are passed through rather than closed over, so that a caller running many callbacks
+ * -- the per-frame events, once per listener every frame -- creates nothing per call.
+ */
 export declare function recycleThread(func: () => void): void;
+export declare function recycleThread<A>(func: (a: A) => void, a: A): void;
+export declare function recycleThread<A, B>(func: (a: A, b: B) => void, a: A, b: B): void;
+export declare function recycleThread<A, B, C>(func: (a: A, b: B, c: C) => void, a: A, b: B, c: C): void;
+export declare function recycleThread<A, B, C, D>(func: (a: A, b: B, c: C, d: D) => void, a: A, b: B, c: C, d: D): void;
+export declare function recycleThread<A, B, C, D, E>(func: (a: A, b: B, c: C, d: D, e: E) => void, a: A, b: B, c: C, d: D, e: E): void;