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

package/out/module/moduleDefinition.d.ts

@@ -2,6 +2,7 @@ import type { Modding } from "../modding";
 import type { PluginDefinition } from "../plugin/pluginDefinition";
 import { type Module } from "./module";
 import type { ScopeCondition } from "./scopes";
+import type { LeftOutRegistration } from "../utility/leftOut";
 /**
  * Options for one ignition of a module.
  *
@@ -44,6 +45,11 @@ export interface ModuleState {
     readonly providers: readonly ModuleProvider[];
     /** The plugins to set up on ignition, in inclusion order. */
     readonly plugins: readonly PluginInclusion[];
+    /**
+     * The path and glob registrations left out by their own scope condition, whose folders were
+     * never looked up: what a miss on a class under one of them names.
+     */
+    readonly leftOut?: readonly LeftOutRegistration[];
 }
 export declare class ModuleDefinition {
     private moduleState;

package/out/module/providerRegistration.d.ts

@@ -20,3 +20,11 @@ export declare function normalizeProviderConfig(config: ProviderConfig): Provide
  * parent's scope.
  */
 export declare function getProviderClassScope(config: ProviderConfig): ScopeCondition;
+/** v1's default, which a provider that does not set `loadOrder` has. */
+export declare const DEFAULT_LOAD_ORDER = 1;
+/**
+ * Where a registration sits in its module's startup: its class's `loadOrder`, or the default. A
+ * lazy one has none (`undefined`): it starts when it is first resolved, whatever its decorator says.
+ * Own metadata, as everywhere else.
+ */
+export declare function getProviderLoadOrder(config: ProviderConfig): number | undefined;

package/out/module/providerRegistration.luau

@@ -72,9 +72,38 @@ local function getProviderClassScope(config)
 		inactiveIn = decoratorConfig.inactiveIn,
 	}
 end
+--* v1's default, which a provider that does not set `loadOrder` has. 
+local DEFAULT_LOAD_ORDER = 1
+--[[
+	*
+	 * Where a registration sits in its module's startup: its class's `loadOrder`, or the default. A
+	 * lazy one has none (`undefined`): it starts when it is first resolved, whatever its decorator says.
+	 * Own metadata, as everywhere else.
+	 
+]]
+local function getProviderLoadOrder(config)
+	if config.type ~= "class" then
+		return DEFAULT_LOAD_ORDER
+	end
+	if config.lazy == true then
+		return nil
+	end
+	local decoratorConfig = Reflect.getOwnMetadata(config.value, "flamework:providerConfig")
+	local _result = decoratorConfig
+	if _result ~= nil then
+		_result = _result.loadOrder
+	end
+	local _condition = _result
+	if _condition == nil then
+		_condition = DEFAULT_LOAD_ORDER
+	end
+	return _condition
+end
 return {
 	assertIsProviderClass = assertIsProviderClass,
 	getProviderClassId = getProviderClassId,
 	normalizeProviderConfig = normalizeProviderConfig,
 	getProviderClassScope = getProviderClassScope,
+	getProviderLoadOrder = getProviderLoadOrder,
+	DEFAULT_LOAD_ORDER = DEFAULT_LOAD_ORDER,
 }

package/out/plugin/pluginDefinition.d.ts

@@ -52,15 +52,18 @@ export interface PluginTarget {
      */
     registerClassProvider: (provider: Constructor, options?: ProviderRegistrationOptions) => void;
     /**
-     * Registers every exported `@Provider()` class under a source folder, as the module builder's
-     * `registerProviders` does. This is how a plugin ships a folder of providers. The options apply
-     * to every class found.
+     * Registers every `@Provider()` class the modules under a source folder define, exported or not,
+     * as the module builder's `registerProviders` does. This is how a plugin ships a folder of
+     * providers. The options apply to every class found; when their scope condition does not hold,
+     * the folder is not looked up and nothing under it is required.
      *
      * @metadata macro
      */
     registerProviders: <T extends string>(path: T, options?: ProviderRegistrationOptions, resolved?: Modding.Intrinsic<"path", [T], string[]>) => void;
     /**
-     * Registers every exported `@Provider()` class under every folder a compile-time glob matches.
+     * Registers every `@Provider()` class the modules under every folder a compile-time glob matches
+     * define, exported or not. As with `registerProviders`, a scope condition that does not hold
+     * leaves the folders untouched.
      *
      * @metadata macro
      */

package/out/provider.d.ts

@@ -11,6 +11,25 @@ export interface ProviderDecoratorConfig extends ScopeCondition {
      * Defaults to `false`.
      */
     lazy?: boolean;
+    /**
+     * Orders this provider's `onInit` and `onStart` against the other providers the same ignition
+     * constructs, as v1's `loadOrder` did: lower goes first. Defaults to `1`; any finite number,
+     * negative and fractional ones included. Providers with the same `loadOrder` keep the order
+     * they would have without one.
+     *
+     * Dependency order still wins. The module constructs its providers in ascending `loadOrder`,
+     * each after what its constructor takes, so a provider's dependencies are constructed and
+     * initialised before it even when theirs is higher: a low `loadOrder` pulls what the provider
+     * needs forward with it. `onInit` runs in that construction order. `onStart` runs in ascending
+     * `loadOrder` alone, each on its own thread as always, so a lower one runs up to its first yield
+     * before the next is started.
+     *
+     * Only within one module's ignition: imported modules ignite, and start, before it. Per-frame
+     * events (`onTick`, `onPhysics`, `onRender`) stay unordered. A lazy provider is not part of
+     * the order: it is initialised and started when it is first resolved, and its `loadOrder` is
+     * ignored.
+     */
+    loadOrder?: number;
 }
 /**
  * Register a class as a provider.

package/out/provider.luau

@@ -17,6 +17,14 @@ local Reflect = TS.import(script, script.Parent, "reflect").Reflect
 ]]
 local function Provider(config)
 	return function(constructor)
+		local _loadOrder = config
+		if _loadOrder ~= nil then
+			_loadOrder = _loadOrder.loadOrder
+		end
+		local loadOrder = _loadOrder
+		if loadOrder ~= nil and (not (type(loadOrder) == "number") or not (math.abs(loadOrder) < math.huge)) then
+			error(`@Provider() on '{constructor}': loadOrder must be a finite number, got {tostring(loadOrder)} ({typeof(loadOrder)})`)
+		end
 		Reflect.defineMetadata(constructor, "flamework:provider", true)
 		Reflect.defineMetadata(constructor, "flamework:providerConfig", config or {})
 	end

package/out/reflect.luau

@@ -1,6 +1,7 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
 local forgetImplements = TS.import(script, script.Parent, "utility", "implementsCache").forgetImplements
+local recordModuleClass = TS.import(script, script.Parent, "utility", "moduleClasses").recordModuleClass
 --[[
 	*
 	 * Reflection/metadata API
@@ -66,6 +67,11 @@ do
 		if key == "flamework:implements" then
 			forgetImplements(obj)
 		end
+		-- The transformer records the module a class was defined in under this key, which is how
+		-- path registration finds a class its module does not export.
+		if key == "flamework:module" and property == nil then
+			recordModuleClass(value, obj)
+		end
 	end
 	_container.defineMetadata = defineMetadata
 	--[[

package/out/utility/explainUnresolved.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Why a dependency no module resolved cannot be resolved, when its id names a Flamework class that
+ * has been loaded -- one a module defined at its top level, which the module record knows -- with
+ * what to do about it. Nothing for any other id: an interface, a type registered nowhere, a class
+ * defined inside a function or never required, whose failure keeps the plain message.
+ *
+ * `origin` is the class whose constructor asked, when one did.
+ */
+export declare function explainUnresolvedClass(id: string, origin?: object): string | undefined;

package/out/utility/explainUnresolved.luau

@@ -0,0 +1,43 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Reflect = TS.import(script, script.Parent.Parent, "reflect").Reflect
+local findModuleClass = TS.import(script, script.Parent, "moduleClasses").findModuleClass
+local function describeModule(moduleScript)
+	local _moduleScript = moduleScript
+	return if typeof(_moduleScript) == "Instance" then moduleScript:GetFullName() else tostring(moduleScript)
+end
+--[[
+	*
+	 * Why a dependency no module resolved cannot be resolved, when its id names a Flamework class that
+	 * has been loaded -- one a module defined at its top level, which the module record knows -- with
+	 * what to do about it. Nothing for any other id: an interface, a type registered nowhere, a class
+	 * defined inside a function or never required, whose failure keeps the plain message.
+	 *
+	 * `origin` is the class whose constructor asked, when one did.
+	 
+]]
+local function explainUnresolvedClass(id, origin)
+	local found = findModuleClass(function(value)
+		return Reflect.getOwnMetadata(value, "identifier") == id
+	end)
+	if found == nil then
+		return nil
+	end
+	local _binding = found
+	local value = _binding[1]
+	local moduleScript = _binding[2]
+	local where = describeModule(moduleScript)
+	if Reflect.hasOwnMetadata(value, "flamework:provider") then
+		return `'{value}' ({where}) is a @Provider() that nothing in this module registers or provides: ` .. "add its folder to registerProviders, register it with registerClassProvider, include the plugin that provides it, " .. "or import a module that has it"
+	end
+	if Reflect.hasOwnMetadata(value, "flamework:component") then
+		if origin ~= nil and Reflect.hasOwnMetadata(origin, "flamework:component") then
+			return `'{value}' ({where}) is a component that no ComponentPlugin of this module registers, ` .. `so the component '{origin}' cannot take it: register it in one`
+		end
+		return `'{value}' ({where}) is a component (@Component), not a provider: a module never constructs a component, ` .. "so Dependency<T>() and constructor injection cannot reach one. Make it a @Provider(), or get it from " .. "Components on the instance it is attached to (components.getComponent<T>(instance))"
+	end
+	return `'{value}' ({where}) is not a provider: it carries no @Provider() decorator. ` .. "Decorate it with @Provider(), or build it with module.createClassInstance"
+end
+return {
+	explainUnresolvedClass = explainUnresolvedClass,
+}

package/out/utility/getClassesInPath.d.ts

@@ -14,8 +14,16 @@ export declare function importModule(moduleScript: ModuleScript): defined | unde
  */
 export declare function requireModulesInPath(rbxPath: readonly string[]): Array<defined>;
 /**
- * Requires every ModuleScript at and under the specified Rojo path and returns every exported value
- * that carries its own Flamework identifier.
+ * Requires every ModuleScript at and under the specified Rojo path and returns every Flamework
+ * class they hold, each once: every class carrying its own identifier that a module defined at its
+ * top level -- exported or not, as v1 registered every decorated class it required -- then every
+ * exported value carrying its own identifier that the module did not define there, such as a
+ * re-export of a class from elsewhere.
+ *
+ * A class declared inside a function is not found unless its module exports it: it is created by
+ * every call, so the transformer does not record it against its module. Neither is a class
+ * compiled by a transformer older than the one that records classes, other than through its
+ * module's exports.
  *
  * A module that fails to load raises, as it did in v1: a class that silently fails to register
  * would otherwise only show up later as an unresolvable dependency, far from the cause.

package/out/utility/getClassesInPath.luau

@@ -3,6 +3,7 @@ local TS = _G[script]
 local tsImport = TS.import(script, script.Parent, "tsImport").tsImport
 local Reflect = TS.import(script, script.Parent.Parent, "reflect").Reflect
 local resolveRbxPath = TS.import(script, script.Parent, "pathRoot").resolveRbxPath
+local getModuleClasses = TS.import(script, script.Parent, "moduleClasses").getModuleClasses
 --[[
 	*
 	 * Requires one ModuleScript through the roblox-ts runtime, as an `import` would, and returns what
@@ -20,6 +21,25 @@ local function importModule(moduleScript)
 	end
 	return value
 end
+--[[
+	*
+	 * Requires every ModuleScript at and under a Rojo path, in tree order, handing each to `visit` with
+	 * what it exported.
+	 
+]]
+local function loadModulesInPath(rbxPath, visit)
+	local _rbxPath = rbxPath
+	assert(_rbxPath)
+	local preloadPath = resolveRbxPath(rbxPath)
+	if preloadPath:IsA("ModuleScript") then
+		visit(preloadPath, importModule(preloadPath))
+	end
+	for _, instance in preloadPath:GetDescendants() do
+		if instance:IsA("ModuleScript") then
+			visit(instance, importModule(instance))
+		end
+	end
+end
 --[[
 	*
 	 * Requires every ModuleScript at and under the specified Rojo path, in tree order, and returns
@@ -32,30 +52,27 @@ end
 	 
 ]]
 local function requireModulesInPath(rbxPath)
-	local _rbxPath = rbxPath
-	assert(_rbxPath)
-	local preloadPath = resolveRbxPath(rbxPath)
 	local loaded = {}
-	if preloadPath:IsA("ModuleScript") then
-		local value = importModule(preloadPath)
+	loadModulesInPath(rbxPath, function(_, value)
 		if value ~= nil then
-			table.insert(loaded, value)
+			local _value = value
+			table.insert(loaded, _value)
 		end
-	end
-	for _, instance in preloadPath:GetDescendants() do
-		if instance:IsA("ModuleScript") then
-			local value = importModule(instance)
-			if value ~= nil then
-				table.insert(loaded, value)
-			end
-		end
-	end
+	end)
 	return loaded
 end
 --[[
 	*
-	 * Requires every ModuleScript at and under the specified Rojo path and returns every exported value
-	 * that carries its own Flamework identifier.
+	 * Requires every ModuleScript at and under the specified Rojo path and returns every Flamework
+	 * class they hold, each once: every class carrying its own identifier that a module defined at its
+	 * top level -- exported or not, as v1 registered every decorated class it required -- then every
+	 * exported value carrying its own identifier that the module did not define there, such as a
+	 * re-export of a class from elsewhere.
+	 *
+	 * A class declared inside a function is not found unless its module exports it: it is created by
+	 * every call, so the transformer does not record it against its module. Neither is a class
+	 * compiled by a transformer older than the one that records classes, other than through its
+	 * module's exports.
 	 *
 	 * A module that fails to load raises, as it did in v1: a class that silently fails to register
 	 * would otherwise only show up later as an unresolvable dependency, far from the cause.
@@ -63,25 +80,47 @@ end
 ]]
 local function getClassesInPath(rbxPath)
 	local foundClasses = {}
-	for _, value in requireModulesInPath(rbxPath) do
-		if not (type(value) == "table") then
-			continue
+	local found = {}
+	-- Own metadata only: an undecorated subclass inherits its parent's identifier, and must not be
+	-- mistaken for a registered class of its own.
+	local add = function(value)
+		local _value = value
+		local _condition = type(_value) == "table"
+		if _condition then
+			local _value_1 = value
+			_condition = not (found[_value_1] ~= nil)
+			if _condition then
+				_condition = Reflect.hasOwnMetadata(value, "identifier")
+			end
+		end
+		if _condition then
+			local _value_1 = value
+			found[_value_1] = true
+			local _value_2 = value
+			table.insert(foundClasses, _value_2)
+		end
+	end
+	loadModulesInPath(rbxPath, function(moduleScript, value)
+		local defined = getModuleClasses(moduleScript)
+		if defined ~= nil then
+			for _, value in defined do
+				add(value)
+			end
+		end
+		local _value = value
+		if not (type(_value) == "table") then
+			return nil
 		end
 		-- This is an `export =` on a Flamework class.
 		if Reflect.hasOwnMetadata(value, "identifier") then
-			table.insert(foundClasses, value)
-			continue
+			add(value)
+			return nil
 		end
-		for _1, member in pairs(value) do
-			-- This is an `export` on a Flamework class.
-			--
-			-- Own metadata only: an undecorated subclass inherits its parent's identifier, and
-			-- must not be mistaken for a registered class of its own.
-			if type(member) == "table" and Reflect.hasOwnMetadata(member, "identifier") then
-				table.insert(foundClasses, member)
-			end
+		-- This is an `export` on a Flamework class.
+		for _, member in pairs(value) do
+			add(member)
 		end
-	end
+	end)
 	return foundClasses
 end
 return {

package/out/utility/globs.d.ts

@@ -3,7 +3,7 @@
  */
 export declare function getGlobPaths(glob: string): string[][];
 /**
- * Requires every ModuleScript under every path the glob matched and returns the exported classes,
- * each at most once.
+ * Requires every ModuleScript under every path the glob matched and returns the Flamework classes
+ * they hold, exported or not, each at most once (see {@link getClassesInPath}).
  */
 export declare function getClassesInGlob(glob: string): Array<object>;

package/out/utility/globs.luau

@@ -37,14 +37,14 @@ local function getGlobPaths(glob)
 	end
 	local paths = _result
 	if paths == nil then
-		error(`Flamework has no paths for the glob '{glob}'. ` .. "Globs are resolved at compile time into include/flamework/globs.json, which only game projects emit; " .. "make sure the include directory is part of your Rojo project and that the glob matched at least one file.", 0)
+		error(`Flamework has no paths for the glob '{glob}'. ` .. "A game's globs are resolved at compile time into include/flamework/globs.json, and this one is not there: " .. "the include folder is not in your Rojo project, the glob is used inside a package (a package's globs " .. "are not resolved), the string was not produced by a glob macro, or globs.json is from another build. " .. "A glob that matched no files does not raise: it resolves to no paths, and the build warns about it.", 0)
 	end
 	return paths
 end
 --[[
 	*
-	 * Requires every ModuleScript under every path the glob matched and returns the exported classes,
-	 * each at most once.
+	 * Requires every ModuleScript under every path the glob matched and returns the Flamework classes
+	 * they hold, exported or not, each at most once (see {@link getClassesInPath}).
 	 
 ]]
 local function getClassesInGlob(glob)

package/out/utility/leftOut.d.ts

@@ -0,0 +1,35 @@
+import { type ScopeCondition } from "../module/scopes";
+/**
+ * A path or glob registration that its own scope condition left out. Its folder was never looked up,
+ * so nothing under it was loaded, and nothing from it was registered or recorded as inactive: this
+ * is what a miss can still say about the classes there.
+ */
+export interface LeftOutRegistration {
+    /** The call as written, for messages: `registerProviders("src/server/debug")`. */
+    readonly call: string;
+    /** The registration's own condition, which did not hold. */
+    readonly condition: ScopeCondition;
+    /** The folder's tree path, for a path registration. */
+    readonly path?: readonly string[];
+    /** The glob as the runtime keys it, for a glob registration. */
+    readonly glob?: string;
+    /** What `path` was relative to when the registration was made. */
+    readonly root: Instance;
+}
+/**
+ * Records a registration left out by its own condition. Reads nothing but the path root, which is
+ * found from Flamework's own metadata, never from the folder.
+ */
+export declare function leftOutRegistration(call: string, condition: ScopeCondition, folder: {
+    path?: readonly string[];
+    glob?: string;
+}): LeftOutRegistration;
+/**
+ * What a miss on `id` can say about the registrations its module or plugin left out by their own
+ * condition, without looking at their folders:
+ *
+ * - the class has loaded some other way, and its module is under one of them: that one, and why;
+ * - the class has not loaded: every one of them, since the class may be under any;
+ * - nothing when there are none, or when the loaded class is under none of them.
+ */
+export declare function explainLeftOut(id: string, leftOut: ReadonlyArray<LeftOutRegistration>): string | undefined;

package/out/utility/leftOut.luau

@@ -0,0 +1,171 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local describeConditions = TS.import(script, script.Parent.Parent, "module", "scopes").describeConditions
+local Reflect = TS.import(script, script.Parent.Parent, "reflect").Reflect
+local getGlobPaths = TS.import(script, script.Parent, "globs").getGlobPaths
+local findModuleClass = TS.import(script, script.Parent, "moduleClasses").findModuleClass
+local getPathRoot = TS.import(script, script.Parent, "pathRoot").getPathRoot
+--[[
+	*
+	 * A path or glob registration that its own scope condition left out. Its folder was never looked up,
+	 * so nothing under it was loaded, and nothing from it was registered or recorded as inactive: this
+	 * is what a miss can still say about the classes there.
+	 
+]]
+--[[
+	*
+	 * Records a registration left out by its own condition. Reads nothing but the path root, which is
+	 * found from Flamework's own metadata, never from the folder.
+	 
+]]
+local function leftOutRegistration(call, condition, folder)
+	return {
+		call = call,
+		condition = {
+			activeIn = condition.activeIn,
+			inactiveIn = condition.inactiveIn,
+		},
+		path = folder.path,
+		glob = folder.glob,
+		root = getPathRoot(),
+	}
+end
+--[[
+	*
+	 * The tree path of a loaded module below `root`, in the form a compile-time path has: a client's
+	 * `PlayerScripts` is written as `StarterPlayer/StarterPlayerScripts`, where its content comes from.
+	 * Nothing when the module is not below `root`.
+	 
+]]
+local function treePathOf(moduleScript, root)
+	local names = {}
+	local current = moduleScript
+	while current ~= nil and current ~= root do
+		local _name = current.Name
+		table.insert(names, 1, _name)
+		current = current.Parent
+	end
+	if current == nil then
+		return nil
+	end
+	if root == game and names[1] == "Players" and names[3] == "PlayerScripts" then
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(_, index)
+			return index >= 3
+		end
+		local _length = 0
+		for _k, _v in names do
+			if _callback(_v, _k - 1, names) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		local rest = _newValue
+		local _array = { "StarterPlayer", "StarterPlayerScripts" }
+		local _length_1 = #_array
+		table.move(rest, 1, #rest, _length_1 + 1, _array)
+		return _array
+	end
+	return names
+end
+local function startsWith(path, prefix)
+	if #path < #prefix then
+		return false
+	end
+	for i = 0, #prefix - 1 do
+		if path[i + 1] ~= prefix[i + 1] then
+			return false
+		end
+	end
+	return true
+end
+--* Whether a loaded module is under the folder, or one of the folders, a left-out registration named. 
+local function isUnder(moduleScript, registration)
+	local modulePath = treePathOf(moduleScript, registration.root)
+	if modulePath == nil then
+		return false
+	end
+	if registration.path ~= nil then
+		return startsWith(modulePath, registration.path)
+	end
+	if registration.glob ~= nil then
+		-- `globs.json`, not the folders: what the glob matched when the build was compiled.
+		local ok, paths = pcall(getGlobPaths, registration.glob)
+		if not ok then
+			return false
+		end
+		-- ▼ ReadonlyArray.some ▼
+		local _result = false
+		local _callback = function(path)
+			return startsWith(modulePath, path)
+		end
+		for _k, _v in paths do
+			if _callback(_v, _k - 1, paths) then
+				_result = true
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.some ▲
+		return _result
+	end
+	return false
+end
+--[[
+	*
+	 * What a miss on `id` can say about the registrations its module or plugin left out by their own
+	 * condition, without looking at their folders:
+	 *
+	 * - the class has loaded some other way, and its module is under one of them: that one, and why;
+	 * - the class has not loaded: every one of them, since the class may be under any;
+	 * - nothing when there are none, or when the loaded class is under none of them.
+	 
+]]
+local function explainLeftOut(id, leftOut)
+	if #leftOut == 0 then
+		return nil
+	end
+	local advice = "the build's scopes so that the condition holds, or do not depend on it in this build"
+	local found = findModuleClass(function(value)
+		return Reflect.getOwnMetadata(value, "identifier") == id
+	end)
+	if found ~= nil then
+		local _binding = found
+		local value = _binding[1]
+		local moduleScript = _binding[2]
+		-- ▼ ReadonlyArray.find ▼
+		local _callback = function(registration)
+			return isUnder(moduleScript, registration)
+		end
+		local _result
+		for _i, _v in leftOut do
+			if _callback(_v, _i - 1, leftOut) == true then
+				_result = _v
+				break
+			end
+		end
+		-- ▲ ReadonlyArray.find ▲
+		local under = _result
+		if under == nil then
+			return nil
+		end
+		local where = if typeof(moduleScript) == "Instance" then moduleScript:GetFullName() else tostring(moduleScript)
+		return `'{value}' ({where}) is under {under.call}, which is left out by its scope ` .. `({describeConditions({ under.condition })}): nothing under it is registered. Change {advice}`
+	end
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#leftOut)
+	local _callback = function(v)
+		return `{v.call} ({describeConditions({ v.condition })})`
+	end
+	for _k, _v in leftOut do
+		_newValue[_k] = _callback(_v, _k - 1, leftOut)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	local listed = table.concat(_newValue, ", ")
+	return `nothing registers it. Left out by their scope, without loading their folders: {listed}. ` .. `If it is defined under one of them, change {advice}`
+end
+return {
+	leftOutRegistration = leftOutRegistration,
+	explainLeftOut = explainLeftOut,
+}

package/out/utility/moduleClasses.d.ts

@@ -0,0 +1,9 @@
+/** Records a class against the module that defined it. Called by `Reflect.defineMetadata`. */
+export declare function recordModuleClass(moduleScript: unknown, value: object): void;
+/** The classes a module defined as it loaded, in definition order, or none. */
+export declare function getModuleClasses(moduleScript: unknown): ReadonlyArray<object> | undefined;
+/**
+ * Every recorded class, with the module that defined it, until the callback answers `true`. For
+ * explaining a failed resolution, which is rare: nothing here is indexed for it.
+ */
+export declare function findModuleClass(predicate: (value: object) => boolean): [object, unknown] | undefined;