@flamework-experimental/core 2.0.0-alpha.0

package/out/module/module.luau

@@ -0,0 +1,811 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Reflect = TS.import(script, script.Parent.Parent, "reflect").Reflect
+local convertConciseDependencyInfo = TS.import(script, script.Parent.Parent, "utility", "convertConciseDependencyInfo").convertConciseDependencyInfo
+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 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")
+local getProviderClassId = _providerRegistration.getProviderClassId
+local getProviderClassScope = _providerRegistration.getProviderClassScope
+local normalizeProviderConfig = _providerRegistration.normalizeProviderConfig
+local _scopes = TS.import(script, script.Parent, "scopes")
+local NO_CONDITION = _scopes.NO_CONDITION
+local describeConditions = _scopes.describeConditions
+local hasCondition = _scopes.hasCondition
+local holdsCondition = _scopes.holdsCondition
+local holdsEveryCondition = _scopes.holdsEveryCondition
+--* What a lookup through a module and its imports found: where, and which class when it is a class provider. 
+local ModuleInitState
+do
+	local _inverse = {}
+	ModuleInitState = setmetatable({}, {
+		__index = _inverse,
+	})
+	ModuleInitState.Created = 0
+	_inverse[0] = "Created"
+	ModuleInitState.PreIgniting = 1
+	_inverse[1] = "PreIgniting"
+	ModuleInitState.Igniting = 2
+	_inverse[2] = "Igniting"
+	ModuleInitState.Ignited = 3
+	_inverse[3] = "Ignited"
+	ModuleInitState.Extinguishing = 4
+	_inverse[4] = "Extinguishing"
+	ModuleInitState.Extinguished = 5
+	_inverse[5] = "Extinguished"
+end
+local MODULE_ID = "$:module/module@Module"
+--* The class-and-path registration forms take their options as a separate argument; here they join the config. 
+local function withOptions(config, options)
+	local _result
+	if options ~= nil then
+		local _object = {}
+		if config then
+			for _k, _v in config do
+				_object[_k] = _v
+			end
+		end
+		for _k, _v in options do
+			_object[_k] = _v
+		end
+		_result = _object
+	else
+		_result = config
+	end
+	return _result
+end
+local function createModuleInstantiation(state, options)
+	--* The module's own scope condition, from `ignite`. Applies to everything it registers. 
+	local moduleScope = if options ~= nil and (options.activeIn ~= nil or options.inactiveIn ~= nil) then {
+		activeIn = options.activeIn,
+		inactiveIn = options.inactiveIn,
+	} else NO_CONDITION
+	--* Every registration: the definition's providers, followed by whatever the plugins register. 
+	local _array = {}
+	local _length = #_array
+	local _array_1 = state.providers
+	table.move(_array_1, 1, #_array_1, _length + 1, _array)
+	local registered = _array
+	--* The registrations whose conditions hold, decided once every plugin has been set up. 
+	local providers = {}
+	--* The registrations left out, by id, with the conditions that were judged: for the error a miss gets. 
+	local skipped = {}
+	--* Modules searched after this one's own providers, in order. Ignited before this one, and extinguished after. 
+	local _result = options
+	if _result ~= nil then
+		_result = _result.imports
+	end
+	local _condition = _result
+	if _condition == nil then
+		_condition = {}
+	end
+	local imports = _condition
+	--* Modules that import this one. They go down before this one does. 
+	local importers = {}
+	local instantiatedProviders = {}
+	--* Objects handed over by `provideInstance`, attached to their interfaces once every plugin is set up. 
+	local providedInstances = {}
+	local observers = {}
+	local hooks = {}
+	local includedPlugins = {}
+	local filledSlots = {}
+	local temporaryInstances = {}
+	local moduleInitState = ModuleInitState.Created
+	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.`)
+		end
+		moduleInitState = to
+	end
+	local assertAlive = function(action)
+		if moduleInitState >= ModuleInitState.Extinguishing then
+			error(`module '{state.debugName}' has been extinguished, cannot {action}`)
+		end
+	end
+	local assertNotProvided = function(injectionId)
+		local _injectionId = injectionId
+		if instantiatedProviders[_injectionId] ~= nil then
+			error(`module '{state.debugName}': provider ID was registered more than once: {injectionId}`)
+		end
+	end
+	local registerClassProvider = function(provider, registrationOptions)
+		local injectionId = getProviderClassId(provider)
+		local _arg0 = {
+			config = normalizeProviderConfig(withOptions({
+				type = "class",
+				value = provider,
+			}, registrationOptions)),
+			injectionId = injectionId,
+		}
+		table.insert(registered, _arg0)
+	end
+	--* Own metadata only, as the builder does: an undecorated subclass of a provider is skipped. 
+	local registerProviderClasses = function(classes, registrationOptions)
+		for _, provider in classes do
+			if Reflect.hasOwnMetadata(provider, "flamework:provider") then
+				registerClassProvider(provider, registrationOptions)
+			end
+		end
+	end
+	--[[
+		*
+		     * Sets a plugin up against this module, once. A plugin reached again -- included by the module
+		     * and by a plugin, or by two plugins -- is skipped, and so is one that includes itself through
+		     * another: it is marked before its setup runs, so the ring stops on the second arrival.
+		     *
+		     * An inclusion given a scope condition that does not hold is skipped entirely: the setup does
+		     * not run, so nothing it would have registered exists. The plugin itself is not marked, since
+		     * it is the inclusion that was scoped, not the plugin.
+		     
+	]]
+	local pluginTarget
+	local includePlugin = function(plugin, scope)
+		local _plugin = plugin
+		if includedPlugins[_plugin] ~= nil then
+			return nil
+		end
+		if not holdsCondition(scope) then
+			return nil
+		end
+		-- The builder swaps a slotted plugin for the one in its slot, so by the time a module
+		-- ignites the only way to reach a second one is through a plugin. That is refused rather
+		-- than run: two lifecycle plugins would tick everything twice.
+		if plugin.slot ~= nil then
+			local _slot = plugin.slot
+			local occupant = filledSlots[_slot]
+			if occupant ~= nil then
+				error(`module '{state.debugName}': plugin '{plugin.name}' fills the '{plugin.slot}' slot that plugin '{occupant.name}' already fills; include it on the module instead`)
+			end
+			local _slot_1 = plugin.slot
+			local _plugin_1 = plugin
+			filledSlots[_slot_1] = _plugin_1
+		end
+		local _plugin_1 = plugin
+		includedPlugins[_plugin_1] = true
+		plugin.setup(pluginTarget)
+	end
+	local lookupInImports = function(injectionId)
+		for _, imported in imports do
+			local found = imported.lookupProvider(injectionId)
+			if found ~= nil then
+				return found
+			end
+		end
+	end
+	--[[
+		*
+		     * Decides which registrations this ignition keeps: those whose conditions -- the module's, the
+		     * registration's own, and the class's decorator -- all hold. Two registrations may share an id
+		     * as long as at most one of them is kept, which is how a fake takes a real provider's place
+		     * under one scope.
+		     *
+		     * A class an import already resolves to is not constructed again here: the import's instance
+		     * answers, so the registration is dropped unless it asked to be isolated. A different class
+		     * under the same id is kept, and answers ahead of the import's.
+		     
+	]]
+	local activateProviders = function()
+		local active = {}
+		local seen = {}
+		for _, entry in registered do
+			local conditions = { moduleScope, entry.config, getProviderClassScope(entry.config) }
+			if not holdsEveryCondition(conditions) then
+				local _injectionId = entry.injectionId
+				skipped[_injectionId] = conditions
+				continue
+			end
+			if entry.config.type == "class" and entry.config.isolated ~= true then
+				local found = lookupInImports(entry.injectionId)
+				if found ~= nil and found.classValue == entry.config.value then
+					continue
+				end
+			end
+			assertNotProvided(entry.injectionId)
+			local _injectionId = entry.injectionId
+			if seen[_injectionId] ~= nil then
+				error(`module '{state.debugName}': provider ID was registered more than once: {entry.injectionId}`)
+			end
+			local _injectionId_1 = entry.injectionId
+			seen[_injectionId_1] = true
+			table.insert(active, entry)
+		end
+		providers = active
+	end
+	local registerHook = function(phase, callback, priority)
+		local _object = {
+			phase = phase,
+			callback = callback,
+		}
+		local _left = "priority"
+		local _condition_1 = priority
+		if _condition_1 == nil then
+			_condition_1 = HookPriority.Normal
+		end
+		_object[_left] = _condition_1
+		table.insert(hooks, _object)
+	end
+	local sortedHooks = function(phase)
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(hook)
+			return hook.phase == phase
+		end
+		local _length_1 = 0
+		for _k, _v in hooks do
+			if _callback(_v, _k - 1, hooks) == true then
+				_length_1 += 1
+				_newValue[_length_1] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		local matching = _newValue
+		-- `table.sort` is not stable, so hooks of equal priority are ordered by the position they
+		-- were registered at to keep registration order meaningful.
+		local order = {}
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback_1 = function(hook, index)
+			local _hook = hook
+			local _index = index
+			order[_hook] = _index
+			return order
+		end
+		for _k, _v in matching do
+			_callback_1(_v, _k - 1, matching)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+		table.sort(matching, function(a, b)
+			if a.priority ~= b.priority then
+				return a.priority < b.priority
+			end
+			local _a = a
+			local _exp = order[_a]
+			local _b = b
+			return _exp < order[_b]
+		end)
+		return matching
+	end
+	local module
+	local runHooks = function(phase)
+		for _, hook in sortedHooks(phase) do
+			hook.callback(module)
+		end
+	end
+	--[[
+		*
+		     * Runs one step of a teardown, reporting a raise rather than letting it out, so that the steps
+		     * after it still run: one hook or removal callback that fails must not leave the module holding
+		     * the rest -- the guarantee the lifecycle plugin gives for its own handlers, made the module's.
+		     
+	]]
+	local guarded = function(what, callback)
+		local success, err = pcall(callback)
+		if not success then
+			warn(`[Flamework] module '{state.debugName}': {what} failed: {tostring(err)}`)
+		end
+	end
+	--[[
+		*
+		     * Attaches an object to every observer of every interface it implements, all or nothing: an
+		     * 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.
+		     
+	]]
+	local registerClassInterfaces = function(instance, kind)
+		local added = {}
+		local success, err = pcall(function()
+			for _, interfaceId in getClassImplements(instance) do
+				local interested = observers[interfaceId]
+				if not interested then
+					continue
+				end
+				for _1, observer in interested do
+					local _result_1 = observer.onAdded
+					if _result_1 ~= nil then
+						_result_1(instance, {
+							interfaceId = interfaceId,
+							kind = kind,
+						})
+					end
+					local _arg0 = { interfaceId, observer }
+					table.insert(added, _arg0)
+				end
+			end
+		end)
+		if not success then
+			-- 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]
+				local interfaceId = _binding[1]
+				local observer = _binding[2]
+				guarded("undoing an attachment", function()
+					local _result_1 = observer.onRemoved
+					if _result_1 ~= nil then
+						_result_1 = _result_1(instance, {
+							interfaceId = interfaceId,
+							kind = kind,
+						})
+					end
+					return _result_1
+				end)
+			end
+			error(err, 0)
+		end
+	end
+	local unregisterClassInterfaces = function(instance, kind)
+		for _, interfaceId in getClassImplements(instance) do
+			local interested = observers[interfaceId]
+			if not interested then
+				continue
+			end
+			for _1, observer in interested do
+				local _result_1 = observer.onRemoved
+				if _result_1 ~= nil then
+					_result_1(instance, {
+						interfaceId = interfaceId,
+						kind = kind,
+					})
+				end
+			end
+		end
+	end
+	local resolveDependencyWithOrigin
+	local instantiateClassWithDependencies = function(constructor, resolve)
+		local dependencies = Reflect.getMetadata(constructor, "flamework:dependencies") or {}
+		local resolvedParameters = {}
+		for _, dependency in dependencies do
+			local _result_1 = resolve
+			if _result_1 ~= nil then
+				_result_1 = _result_1(dependency)
+			end
+			local _condition_1 = _result_1
+			if _condition_1 == nil then
+				_condition_1 = resolveDependencyWithOrigin(dependency, constructor)
+			end
+			table.insert(resolvedParameters, _condition_1)
+		end
+		return constructor.new(unpack(resolvedParameters))
+	end
+	local tryResolveDependency
+	tryResolveDependency = function(info, requestingOrigin)
+		if moduleInitState <= ModuleInitState.PreIgniting then
+			error(`module '{state.debugName}' is in pre-ignite phase, dependency cannot be resolved: {info.id}`)
+		end
+		-- Extinguished hooks and removal callbacks may still resolve siblings while extinguishing,
+		-- so only a fully extinguished module refuses.
+		if moduleInitState == ModuleInitState.Extinguished then
+			error(`module '{state.debugName}' has been extinguished, dependency cannot be resolved: {info.id}`)
+		end
+		local _id = info.id
+		local instantiatedProvider = instantiatedProviders[_id]
+		if instantiatedProvider ~= nil then
+			return instantiatedProvider
+		end
+		-- The Module type always refers to the current module instantiation.
+		if info.id == MODULE_ID then
+			return module
+		end
+		-- ▼ ReadonlyArray.find ▼
+		local _callback = function(v)
+			return v.injectionId == info.id
+		end
+		local _result_1
+		for _i, _v in providers do
+			if _callback(_v, _i - 1, providers) == true then
+				_result_1 = _v
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.find ▲
+		local moduleProvider = _result_1
+		if moduleProvider then
+			local config = moduleProvider.config
+			if config.type == "class" then
+				local instantiatedProvider = instantiateClassWithDependencies(config.value)
+				local _id_1 = info.id
+				instantiatedProviders[_id_1] = instantiatedProvider
+				registerClassInterfaces(instantiatedProvider, "provider")
+				return instantiatedProvider
+			elseif config.type == "function" then
+				-- Function providers are not cached.
+				-- It is up to the provider to decide whether to cache dependency resolution, based on the injection context.
+				return config.callback({
+					injectionId = info.id,
+					dependencyInfo = info,
+					module = module,
+					origin = requestingOrigin,
+				})
+			elseif config.type == "alias" then
+				return tryResolveDependency(convertConciseDependencyInfo(config.injectionId), requestingOrigin)
+			end
+		end
+		-- Through the owner's resolver, so that a lazy provider is constructed by the module that
+		-- registered it and joins that module's interfaces, not this one's.
+		for _, imported in imports do
+			local found = imported.tryResolveDependency(info, requestingOrigin)
+			if found ~= nil then
+				return found
+			end
+		end
+	end
+	resolveDependencyWithOrigin = function(info, requestingOrigin)
+		local dependency = tryResolveDependency(info, requestingOrigin)
+		if dependency == nil then
+			local _result_1
+			if #imports > 0 then
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue = table.create(#imports)
+				local _callback = function(v)
+					return v.debugName
+				end
+				for _k, _v in imports do
+					_newValue[_k] = _callback(_v, _k - 1, imports)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				_result_1 = `; not found in imports [{table.concat(_newValue, ", ")}]`
+			else
+				_result_1 = ""
+			end
+			local searched = _result_1
+			local _id = info.id
+			local inactive = skipped[_id]
+			if inactive ~= nil then
+				error(`module '{state.debugName}' could not resolve dependency '{info.id}': it is registered but inactive ({describeConditions(inactive)}){searched}`)
+			end
+			error(`module '{state.debugName}' could not resolve dependency '{info.id}'{searched}`)
+		end
+		return dependency
+	end
+	local lookupProvider = function(injectionId)
+		-- ▼ ReadonlyArray.find ▼
+		local _callback = function(v)
+			return v.injectionId == injectionId
+		end
+		local _result_1
+		for _i, _v in providers do
+			if _callback(_v, _i - 1, providers) == true then
+				_result_1 = _v
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.find ▲
+		local own = _result_1
+		if own ~= nil then
+			return {
+				module = module,
+				classValue = if own.config.type == "class" then own.config.value else nil,
+			}
+		end
+		-- A provided instance is an object, not a class, so nothing registered here is the same class as it.
+		local _injectionId = injectionId
+		if instantiatedProviders[_injectionId] ~= nil then
+			return {
+				module = module,
+			}
+		end
+		return lookupInImports(injectionId)
+	end
+	local resolveDependency = function(info)
+		local _arg0 = info ~= nil
+		assert(_arg0)
+		return resolveDependencyWithOrigin(convertConciseDependencyInfo(info))
+	end
+	local createClassInstance = function(constructor, config)
+		assertAlive("create class instances")
+		local _exp = constructor
+		local _result_1 = config
+		if _result_1 ~= nil then
+			_result_1 = _result_1.overrideDependency
+		end
+		local instance = instantiateClassWithDependencies(_exp, _result_1)
+		-- Attached before it is held: an observer that refuses it leaves it attached nowhere, so
+		-- there is nothing for the module to hold, or to release on extinguish.
+		registerClassInterfaces(instance, "instance")
+		temporaryInstances[instance] = true
+		return instance
+	end
+	local removeClassInstance = function(instance)
+		local _instance = instance
+		if not (temporaryInstances[_instance] ~= nil) then
+			return nil
+		end
+		unregisterClassInterfaces(instance, "instance")
+		local _instance_1 = instance
+		temporaryInstances[_instance_1] = nil
+	end
+	local listen = function(param, metaId, metaKey)
+		local _arg0 = metaId ~= nil
+		assert(_arg0)
+		assertAlive("listen for lifecycle events")
+		local listener
+		if metaKey == nil then
+			-- Non-shorthand
+			-- We create a proxy object so that we have a unique reference for this specific listener.
+			-- It stands in for the object without being it: a method reached through it runs with
+			-- the object as `self`, so what the method writes to `this` lands on the object; and
+			-- its `__index` is a function rather than the object, which is where the metadata walk
+			-- stops -- through the object it went on to the object's class, and attached the proxy
+			-- to every interface the class implements instead of the one named here.
+			local target = param
+			listener = setmetatable({}, {
+				__index = function(_, key)
+					local value = target[key]
+					if type(value) == "function" then
+						return function(_self, ...)
+							local args = { ... }
+							return value(target, unpack(args))
+						end
+					end
+					return value
+				end,
+			})
+			-- The class's identifier is what the object was profiled under through the old walk.
+			local identifier = Reflect.getMetadata(target, "identifier")
+			if identifier ~= nil then
+				Reflect.defineMetadata(listener, "identifier", identifier)
+			end
+		else
+			local _arg0_1 = type(param) == "function"
+			assert(_arg0_1)
+			listener = {
+				[metaKey] = function(self, ...)
+					local args = { ... }
+					return param(unpack(args))
+				end,
+			}
+		end
+		-- Register the lifecycle event
+		Reflect.defineMetadata(listener, "flamework:implements", { metaId })
+		-- Attached before it is held, as in `createClassInstance`.
+		registerClassInterfaces(listener, "instance")
+		local _listener = listener
+		temporaryInstances[_listener] = true
+		return function()
+			local _arg0_1 = listener ~= nil
+			assert(_arg0_1, "listeners cannot be destructed more than once")
+			removeClassInstance(listener)
+			listener = nil
+		end
+	end
+	local release
+	local ignite = function()
+		-- Checked before anything changes: an import that is not ready leaves this module as it was,
+		-- and `ignite()` being synchronous is what makes "ignite it first" a line order.
+		for _, imported in imports do
+			if not imported.isIgnited() then
+				error(`module '{state.debugName}': imported module '{imported.debugName}' is not ignited; ignite it first`)
+			end
+		end
+		-- Raises on a module that has ignited already: a definition is what gets ignited twice.
+		switchInitState(ModuleInitState.Created, ModuleInitState.PreIgniting)
+		-- From here on the module holds things: what the plugins set up, then the providers, then
+		-- what the hooks connect. A raise anywhere in it takes the module down the way `extinguish`
+		-- does before it comes out, so that a failed ignition holds nothing. The lifecycle plugin's
+		-- postIgnite hook connects the RunService signals, and a hook after it that raised used to
+		-- leave those ticking a module stuck in `Igniting`, which nothing could extinguish.
+		local success, err = pcall(function()
+			-- Plugins are set up before any provider exists, so a setup that resolves is refused the
+			-- same way an `onPreIgnite` hook is.
+			for _, inclusion in state.plugins do
+				includePlugin(inclusion.plugin, inclusion.scope)
+			end
+			runHooks("preIgnite")
+			-- Every registration is in by now, the plugins' included, so this is where the conditions
+			-- are judged and the ids checked for collisions among what is kept.
+			activateProviders()
+			switchInitState(ModuleInitState.PreIgniting, ModuleInitState.Igniting)
+			-- Provided instances exist already; here they join the interfaces they implement, now that
+			-- every plugin's observers are in place.
+			for _, instance in providedInstances do
+				registerClassInterfaces(instance, "provider")
+			end
+			for _, provider in providers do
+				-- Lazy providers are constructed the first time they are resolved instead.
+				if provider.config.type == "class" and provider.config.lazy ~= true then
+					resolveDependency(provider.injectionId)
+				end
+			end
+			runHooks("postIgnite")
+		end)
+		if not success then
+			moduleInitState = ModuleInitState.Extinguishing
+			release()
+			error(err, 0)
+		end
+		switchInitState(ModuleInitState.Igniting, ModuleInitState.Ignited)
+		-- Told last, once this module is whole: an importer only counts once it can be extinguished.
+		for _, imported in imports do
+			imported.addImporter(module)
+		end
+		return module
+	end
+	local extinguish = function()
+		switchInitState(ModuleInitState.Ignited, ModuleInitState.Extinguishing)
+		-- 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.
+		local _array_2 = {}
+		local _length_1 = #_array_2
+		for _v in importers do
+			_length_1 += 1
+			_array_2[_length_1] = _v
+		end
+		for _, importer in _array_2 do
+			if not importer.isExtinguished() then
+				importer.extinguish()
+			end
+		end
+		table.clear(importers)
+		release()
+	end
+	--[[
+		*
+		     * Lets go of everything this instantiation holds, from `Extinguishing`: the extinguished hooks
+		     * run, the instances it created and the providers it constructed leave their interfaces, and
+		     * the default is released. Shared by `extinguish` and by an ignition that raised, so the hooks
+		     * that ran before the raise are undone by the same hooks that undo them on extinguish.
+		     *
+		     * Every step is guarded: one that raises is warned about and the rest still run, so the module
+		     * cannot get stuck half-extinguished -- which used to hold it, and everything in it, for good,
+		     * as the default `Dependency<T>()` answered from.
+		     
+	]]
+	release = function()
+		for _, hook in sortedHooks("extinguished") do
+			guarded("an onExtinguished hook", function()
+				return hook.callback(module)
+			end)
+		end
+		-- Copied first: removal callbacks may themselves remove instances.
+		local _array_2 = {}
+		local _length_1 = #_array_2
+		for _v in temporaryInstances do
+			_length_1 += 1
+			_array_2[_length_1] = _v
+		end
+		for _, temporaryInstance in _array_2 do
+			guarded("removing an instance", function()
+				return removeClassInstance(temporaryInstance)
+			end)
+		end
+		-- 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)
+		end
+		-- A removal that raised leaves its instance behind, and nothing can add one any more.
+		table.clear(temporaryInstances)
+		table.clear(instantiatedProviders)
+		switchInitState(ModuleInitState.Extinguishing, ModuleInitState.Extinguished)
+		for _, imported in imports do
+			imported.removeImporter(module)
+		end
+		-- 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)
+	end
+	local isExtinguished = function()
+		return moduleInitState >= ModuleInitState.Extinguishing
+	end
+	local isIgnited = function()
+		return moduleInitState == ModuleInitState.Ignited
+	end
+	module = {
+		debugName = state.debugName,
+		tryResolveDependency = tryResolveDependency,
+		resolveDependency = resolveDependency,
+		listen = listen,
+		createClassInstance = createClassInstance,
+		removeClassInstance = removeClassInstance,
+		ignite = ignite,
+		extinguish = extinguish,
+		isExtinguished = isExtinguished,
+		isIgnited = isIgnited,
+		lookupProvider = lookupProvider,
+		addImporter = function(importer)
+			local _importer = importer
+			importers[_importer] = true
+			return importers
+		end,
+		removeImporter = function(importer)
+			local _importer = importer
+			-- ▼ Set.delete ▼
+			local _valueExisted = importers[_importer] ~= nil
+			importers[_importer] = nil
+			-- ▲ Set.delete ▲
+			return _valueExisted
+		end,
+	}
+	--* What a plugin's setup is handed. Everything registers into this instantiation. 
+	pluginTarget = {
+		module = module,
+		scope = if hasCondition(moduleScope) then moduleScope else nil,
+		isActive = function(...)
+			local conditions = { ... }
+			local _array_2 = { moduleScope }
+			local _length_1 = #_array_2
+			table.move(conditions, 1, #conditions, _length_1 + 1, _array_2)
+			return holdsEveryCondition(_array_2)
+		end,
+		registerClassProvider = registerClassProvider,
+		registerProviders = function(_path, registrationOptions, resolved)
+			local _arg0 = resolved ~= nil
+			assert(_arg0)
+			registerProviderClasses(getClassesInPath(resolved), registrationOptions)
+		end,
+		registerProvidersGlob = function(_glob, registrationOptions, resolved)
+			local _arg0 = resolved ~= nil
+			assert(_arg0)
+			registerProviderClasses(getClassesInGlob(resolved), registrationOptions)
+		end,
+		registerProvider = function(config, injectionId)
+			local _arg0 = injectionId ~= nil
+			assert(_arg0)
+			local _arg0_1 = {
+				config = normalizeProviderConfig(config),
+				injectionId = injectionId,
+			}
+			table.insert(registered, _arg0_1)
+		end,
+		provideInstance = function(instance, injectionId)
+			local _arg0 = injectionId ~= nil
+			assert(_arg0)
+			assertNotProvided(injectionId)
+			local _injectionId = injectionId
+			local _instance = instance
+			instantiatedProviders[_injectionId] = _instance
+			local _instance_1 = instance
+			table.insert(providedInstances, _instance_1)
+		end,
+		includePlugin = includePlugin,
+		onPreIgnite = function(callback, hookOptions)
+			local _exp = callback
+			local _result_1 = hookOptions
+			if _result_1 ~= nil then
+				_result_1 = _result_1.priority
+			end
+			return registerHook("preIgnite", _exp, _result_1)
+		end,
+		onPostIgnite = function(callback, hookOptions)
+			local _exp = callback
+			local _result_1 = hookOptions
+			if _result_1 ~= nil then
+				_result_1 = _result_1.priority
+			end
+			return registerHook("postIgnite", _exp, _result_1)
+		end,
+		onExtinguished = function(callback, hookOptions)
+			local _exp = callback
+			local _result_1 = hookOptions
+			if _result_1 ~= nil then
+				_result_1 = _result_1.priority
+			end
+			return registerHook("extinguished", _exp, _result_1)
+		end,
+		observe = function(config, interfaceId)
+			local _arg0 = interfaceId ~= nil
+			assert(_arg0)
+			local _interfaceId = interfaceId
+			local interested = observers[_interfaceId]
+			if not interested then
+				local _exp = interfaceId
+				interested = {}
+				local _interested = interested
+				observers[_exp] = _interested
+			end
+			local _interested = interested
+			local _config = config
+			table.insert(_interested, _config)
+		end,
+	}
+	return module
+end
+return {
+	createModuleInstantiation = createModuleInstantiation,
+}