@flamework-experimental/core 2.0.0-alpha.0

package/out/lifecycle/lifecyclePlugin.d.ts

@@ -0,0 +1,85 @@
+import type { Module } from "../module/module";
+import type { OnExtinguished, OnInit, OnPhysics, OnRender, OnStart, OnTick } from "./lifecycleInterfaces";
+import { PluginDefinition, type InterfaceContext } from "../plugin/pluginDefinition";
+export interface LifecyclePluginOptions {
+    /**
+     * Whether per-frame lifecycle callbacks are wrapped in `debug.profilebegin` and
+     * `debug.setmemorycategory` with the provider's identifier, so that they show up by name in the
+     * MicroProfiler and the memory view.
+     *
+     * Defaults to `RunService.IsStudio()`, which is what v1's `flamework.json` defaulted to as well.
+     */
+    profiling?: boolean;
+}
+/**
+ * Tracks the objects attached to each lifecycle event for one module.
+ *
+ * The plugin builds one per ignition of every module that includes it, so nothing here is shared
+ * between modules, and provides it, so `module.resolveDependency<LifecycleProvider>()` answers what
+ * is attached to a module's events right now.
+ */
+export declare class LifecycleProvider {
+    /** In attachment order, which for providers is dependency order. */
+    private onInit;
+    private initMembers;
+    /** The providers `postIgnite` starts, in attachment order; `onStart` is every member. */
+    private startOrder;
+    onStart: Set<OnStart>;
+    onTick: Set<OnTick>;
+    onPhysics: Set<OnPhysics>;
+    onRender: Set<OnRender>;
+    onExtinguished: Set<OnExtinguished>;
+    private identifiers;
+    private moduleConnections;
+    private lateProviders;
+    private hasStarted;
+    private isProfiling;
+    constructor(options: LifecyclePluginOptions);
+    private getIdentifier;
+    /**
+     * Drops the memoised identifier of an object that has left its last lifecycle event.
+     *
+     * The memo is keyed by the object itself, so an entry left behind is a strong reference to it:
+     * a removed component, and with it its instance, its attributes and everything it links to,
+     * held for as long as the module lives. `profile` fills it in for every object it runs a
+     * per-frame callback for, so the table grew by one for every component that ever ticked
+     * whenever profiling was on -- which it is in Studio by default, and in production for anyone
+     * who sets `core.profiling`.
+     *
+     * The entry stays while any event still holds the object: dropping it there would only make the
+     * next frame look it up again.
+     */
+    private forget;
+    private profile;
+    /**
+     * Runs `onInit` synchronously, waiting on a returned Promise, so that initialisation happens in
+     * dependency order and is complete before anything starts.
+     */
+    private runInit;
+    private runStart;
+    /**
+     * A provider constructed after ignition (a lazy one) still gets `onInit` and `onStart`, in that
+     * order, once every one of its interfaces has been attached. Instances attached late through
+     * `listen` or `createClassInstance` do not; they are owned by whoever created them.
+     */
+    private scheduleLateProvider;
+    addInit(object: OnInit, context: InterfaceContext): void;
+    removeInit(object: OnInit): void;
+    addStart(object: OnStart, context: InterfaceContext): void;
+    removeStart(object: OnStart): void;
+    postIgnite(module: Module): void;
+    extinguished(module: Module): void;
+}
+/**
+ * Creates a lifecycle plugin with the specified options.
+ *
+ * `LifecyclePlugin` is `createLifecyclePlugin()` with the defaults; use this when a module needs
+ * different ones, such as forcing profiling on or off.
+ */
+export declare function createLifecyclePlugin(options?: LifecyclePluginOptions): PluginDefinition;
+/**
+ * The lifecycle plugin with default options. Every module made with `Flamework.createModule()`
+ * starts with it; `disableDefaultLifecycle()` on the builder leaves it out, and including one built
+ * with {@link createLifecyclePlugin} takes its place.
+ */
+export declare const LifecyclePlugin: PluginDefinition;

package/out/lifecycle/lifecyclePlugin.luau

@@ -0,0 +1,424 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Reflect_1 = TS.import(script, script.Parent.Parent, "reflect").Reflect
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+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 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
+--[[
+	*
+	 * Tracks the objects attached to each lifecycle event for one module.
+	 *
+	 * The plugin builds one per ignition of every module that includes it, so nothing here is shared
+	 * between modules, and provides it, so `module.resolveDependency<LifecycleProvider>()` answers what
+	 * is attached to a module's events right now.
+	 
+]]
+local LifecycleProvider
+do
+	LifecycleProvider = setmetatable({}, {
+		__tostring = function()
+			return "LifecycleProvider"
+		end,
+	})
+	LifecycleProvider.__index = LifecycleProvider
+	function LifecycleProvider.new(...)
+		local self = setmetatable({}, LifecycleProvider)
+		return self:constructor(...) or self
+	end
+	function LifecycleProvider:constructor(options)
+		self.onInit = {}
+		self.initMembers = {}
+		self.startOrder = {}
+		self.onStart = {}
+		self.onTick = {}
+		self.onPhysics = {}
+		self.onRender = {}
+		self.onExtinguished = {}
+		self.identifiers = {}
+		self.moduleConnections = {}
+		self.lateProviders = {}
+		self.hasStarted = false
+		-- Per-module option, then the project's flamework.config.json, then Studio.
+		local _condition = options.profiling
+		if _condition == nil then
+			local _result = getRuntimeConfig().core
+			if _result ~= nil then
+				_result = _result.profiling
+			end
+			_condition = _result
+			if _condition == nil then
+				_condition = RunService:IsStudio()
+			end
+		end
+		self.isProfiling = _condition
+	end
+	function LifecycleProvider:getIdentifier(object)
+		local _identifiers = self.identifiers
+		local _object = object
+		local identifier = _identifiers[_object]
+		if identifier == nil then
+			local _condition = Reflect.getMetadata(object, "identifier")
+			if _condition == nil then
+				_condition = "[flamework listener]"
+			end
+			identifier = _condition
+			local _identifiers_1 = self.identifiers
+			local _object_1 = object
+			local _identifier = identifier
+			_identifiers_1[_object_1] = _identifier
+		end
+		return identifier
+	end
+	function LifecycleProvider:forget(object)
+		local _initMembers = self.initMembers
+		local _object = object
+		local _condition = _initMembers[_object] ~= nil
+		if not _condition then
+			local _onStart = self.onStart
+			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
+				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
+				end
+			end
+		end
+		local attached = _condition
+		if not attached then
+			local _identifiers = self.identifiers
+			local _object_1 = object
+			_identifiers[_object_1] = nil
+		end
+	end
+	function LifecycleProvider:removeFrom(set, value)
+		local _set = set
+		local _value = value
+		_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)
+		end
+		return recycleThread(callback)
+	end
+	function LifecycleProvider:runInit(object)
+		local id = self:getIdentifier(object)
+		if self.isProfiling then
+			debug.setmemorycategory(id)
+		end
+		local result = object:onInit()
+		if TS.Promise.is(result) then
+			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
+	end
+	function LifecycleProvider:runStart(object)
+		task.spawn(function()
+			return object:onStart()
+		end)
+	end
+	function LifecycleProvider:scheduleLateProvider(object)
+		local _lateProviders = self.lateProviders
+		local _object = object
+		if _lateProviders[_object] ~= nil then
+			return nil
+		end
+		local _lateProviders_1 = self.lateProviders
+		local _object_1 = object
+		_lateProviders_1[_object_1] = true
+		task.defer(function()
+			local _lateProviders_2 = self.lateProviders
+			local _object_2 = object
+			if not (_lateProviders_2[_object_2] ~= nil) then
+				return nil
+			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)
+			end
+			local _onStart = self.onStart
+			local _object_5 = object
+			if _onStart[_object_5] ~= nil then
+				self:runStart(object)
+			end
+		end)
+	end
+	function LifecycleProvider:addInit(object, context)
+		local _initMembers = self.initMembers
+		local _object = object
+		_initMembers[_object] = true
+		-- Only a provider is initialised by the plugin. An instance attached through `listen` or
+		-- `createClassInstance` is owned by whoever created it -- `Components` runs a component's
+		-- `onInit` itself, before the component can be seen -- so one built during ignition must not
+		-- be initialised a second time here.
+		if context.kind ~= "provider" then
+			return nil
+		end
+		if not self.hasStarted then
+			local _onInit = self.onInit
+			local _object_1 = object
+			table.insert(_onInit, _object_1)
+		else
+			self:scheduleLateProvider(object)
+		end
+	end
+	function LifecycleProvider:removeInit(object)
+		local _initMembers = self.initMembers
+		local _object = object
+		_initMembers[_object] = nil
+		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
+		if index ~= -1 then
+			table.remove(self.onInit, index + 1)
+		end
+		self:forget(object)
+	end
+	function LifecycleProvider:addStart(object, context)
+		local _onStart = self.onStart
+		local _object = object
+		_onStart[_object] = true
+		-- Only a provider is started by the plugin, as with `onInit`: an instance attached through
+		-- `listen` or `createClassInstance` is owned by whoever created it. `Components` starts a
+		-- component itself, once the component is attached and ignition has finished.
+		if context.kind ~= "provider" then
+			return nil
+		end
+		if not self.hasStarted then
+			local _startOrder = self.startOrder
+			local _object_1 = object
+			table.insert(_startOrder, _object_1)
+		else
+			self:scheduleLateProvider(object)
+		end
+	end
+	function LifecycleProvider:removeStart(object)
+		local _onStart = self.onStart
+		local _object = object
+		_onStart[_object] = nil
+		local _lateProviders = self.lateProviders
+		local _object_1 = object
+		_lateProviders[_object_1] = nil
+		local _startOrder = self.startOrder
+		local _object_2 = object
+		local index = (table.find(_startOrder, _object_2) or 0) - 1
+		if index ~= -1 then
+			table.remove(self.startOrder, index + 1)
+		end
+		self:forget(object)
+	end
+	function LifecycleProvider:postIgnite(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.
+		local index = 0
+		while index < #self.onInit do
+			self:runInit(self.onInit[index + 1])
+			index += 1
+		end
+		self.hasStarted = true
+		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
+			self:runStart(object)
+		end
+		local onTick = self.onTick
+		local onPhysics = self.onPhysics
+		local onRender = self.onRender
+		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
+		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
+		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
+			end)
+			table.insert(connections, _arg0_2)
+		end
+		local _moduleConnections = self.moduleConnections
+		local _module = module
+		_moduleConnections[_module] = connections
+	end
+	function LifecycleProvider:extinguished(module)
+		local _moduleConnections = self.moduleConnections
+		local _module = module
+		local connections = _moduleConnections[_module]
+		if connections then
+			local _moduleConnections_1 = self.moduleConnections
+			local _module_1 = module
+			_moduleConnections_1[_module_1] = nil
+			for _, connection in connections do
+				connection:Disconnect()
+			end
+		end
+		-- 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.
+		local _array = {}
+		local _length = #_array
+		for _v in self.onExtinguished do
+			_length += 1
+			_array[_length] = _v
+		end
+		for _, provider in _array 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)}`)
+			end
+		end
+	end
+	do
+		-- (Flamework) LifecycleProvider metadata
+		Reflect_1.defineMetadata(LifecycleProvider, "identifier", "$:lifecycle/lifecyclePlugin@LifecycleProvider")
+		Reflect_1.defineMetadata(LifecycleProvider, "flamework:implements", {})
+		Reflect_1.defineMetadata(LifecycleProvider, "flamework:parameters", { "$:lifecycle/lifecyclePlugin@LifecyclePluginOptions" })
+		Reflect_1.defineMetadata(LifecycleProvider, "flamework:dependencies", { {
+			id = "$:lifecycle/lifecyclePlugin@LifecyclePluginOptions",
+		} })
+	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.
+	 *
+	 * `LifecyclePlugin` is `createLifecyclePlugin()` with the defaults; use this when a module needs
+	 * different ones, such as forcing profiling on or off.
+	 
+]]
+local function createLifecyclePlugin(options)
+	if options == nil then
+		options = {}
+	end
+	local setup = function(target)
+		-- One per ignition: the setup runs for every module that includes the plugin, and again for
+		-- every ignition of a definition, so nothing here is shared between modules.
+		local lifecycle = LifecycleProvider.new(options)
+		target.provideInstance(lifecycle, "$:lifecycle/lifecyclePlugin@LifecycleProvider")
+		target.onPostIgnite(function(module)
+			return lifecycle:postIgnite(module)
+		end)
+		target.onExtinguished(function(module)
+			return lifecycle:extinguished(module)
+		end)
+		target.observe({
+			onAdded = function(value, context)
+				return lifecycle:addInit(value, context)
+			end,
+			onRemoved = function(value)
+				return lifecycle:removeInit(value)
+			end,
+		}, "$:lifecycle/lifecycleInterfaces@OnInit")
+		target.observe({
+			onAdded = function(value, context)
+				return lifecycle:addStart(value, context)
+			end,
+			onRemoved = function(value)
+				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")
+	end
+	return PluginDefinition.new("Lifecycle", setup, LIFECYCLE_SLOT)
+end
+--[[
+	*
+	 * The lifecycle plugin with default options. Every module made with `Flamework.createModule()`
+	 * starts with it; `disableDefaultLifecycle()` on the builder leaves it out, and including one built
+	 * with {@link createLifecyclePlugin} takes its place.
+	 
+]]
+local LifecyclePlugin = createLifecyclePlugin()
+return {
+	createLifecyclePlugin = createLifecyclePlugin,
+	LifecycleProvider = LifecycleProvider,
+	LifecyclePlugin = LifecyclePlugin,
+}

package/out/modding.d.ts

@@ -0,0 +1,171 @@
+import { t } from "@rbxts/t";
+export declare namespace Modding {
+    /**
+     * This function is able to utilize Flamework's user macros to generate and inspect types.
+     * This function supports all values natively supported by Flamework's user macros.
+     *
+     * For example, if you want to retrieve the properties of an instance, you could write code like this:
+     * ```ts
+     * // Returns an array of all keys part of the union.
+     * const basePartKeys = Modding.inspect<InstancePropertyNames<BasePart>[]>();
+     * ```
+     *
+     * @metadata macro
+     */
+    export function inspect<T>(value?: Modding.Emit<T>): T;
+    /**
+     * This type emits runtime equivalents of types, such as generating strings from string literal types.
+     *
+     * You are able to generate most TS types, including objects and tuples which will generate equivalent objects at runtime.
+     * Additionally, you can generate unions by using `Array<T>`, which will generate an array where each constituent of `T` is its own element.
+     *
+     * This type is primarily used to mark a user macro parameter as metadata, and is not necessary if you use other macro types.
+     */
+    export type Emit<T> = T & {
+        /** @hidden */ _flamework_macro_many: T;
+    };
+    /**
+     * Creates an injectable type that can be used to modify dependency injection behavior.
+     */
+    export type Injectable<C extends {
+        type: unknown;
+        id?: unknown;
+        metadata?: unknown[];
+    }> = RealType<C["type"]> & {
+        /** @hidden @deprecated */
+        _flamework_injectable: C;
+    };
+    /**
+     * An internal type for intrinsic user macro metadata.
+     *
+     * @hidden
+     */
+    export type Intrinsic<N extends string, M extends unknown[], T = symbol> = T & {
+        _flamework_intrinsic: [N, ...M];
+    };
+    /**
+     * This namespace contains types and metadata related to the current macro's callsite.
+     */
+    export namespace Caller {
+        /**
+         * Retrieves metadata about the callsite using Flamework's user macros.
+         */
+        type CallerHelper<U, M extends string> = U & {
+            /** @hidden */ _flamework_macro_caller: M;
+        };
+        /**
+         * The starting line of the expression in the TypeScript source, starting at 1.
+         */
+        export type Line = CallerHelper<number, "line">;
+        /**
+         * The char at the start of the expression relative to the starting line, starting at 1.
+         */
+        export type Character = CallerHelper<number, "character">;
+        /**
+         * The width of the expression.
+         * This includes the width of multiline statements.
+         */
+        export type Width = CallerHelper<number, "width">;
+        /**
+         * A unique identifier that can be used to identify exact callsites.
+         * This can be used for hooks.
+         *
+         * Derived from the callsite's position, so it is the same in every file of one build and,
+         * without obfuscation, across builds. With obfuscation on it changes with every build, so
+         * that what it names -- a remote, say -- cannot be mapped once and found again in the next
+         * release.
+         */
+        export type Uuid = CallerHelper<string, "uuid">;
+        /**
+         * The source text for the expression.
+         */
+        export type Text = CallerHelper<string, "text">;
+        /**
+         * This API will generate a constant reference to the nested metadata.
+         * This means that the same object will be passed in for every invocation of a specific function call.
+         *
+         * This can be used to implement caching, and avoid allocation overhead for large metadata.
+         */
+        export type Constant<T> = T & {
+            /** @hidden */ _flamework_macro_shared_ref: T;
+        };
+        export {};
+    }
+    /**
+     * This namespace contains types that allow you to perform functions or fetch metadata about specific types.
+     */
+    export namespace Target {
+        type TargetHelper<T, U, M extends string> = U & {
+            /** @hidden */ _flamework_macro_generic: [T, M];
+        };
+        /**
+         * Retrieves the ID from the type.
+         *
+         * The ID is a mostly unique identifier meant to identify specific resources in Flamework projects, such as providers.
+         */
+        export type Id<T> = TargetHelper<T, string, "id">;
+        /**
+         * Retrieves the text of the type, equivalent to what is seen in TypeScript's intellisense.
+         *
+         * The resulting text may not be identical as the type inputted as its dependent on how TypeScript renders types.
+         */
+        export type Text<T> = TargetHelper<T, string, "text">;
+        /**
+         * Retrieves a `t` guard that matches this specific type.
+         */
+        export type Guard<T> = TargetHelper<T, t.check<T>, "guard">;
+        /**
+         * Retrieves the dependency info for this type, which contains the ID and any metadata included on the type.
+         */
+        export type Dependency<T> = TargetHelper<T, DependencyInfo, "dependency">;
+        /**
+         * Retrieves the dependency info for this type, which contains the ID and any metadata included on the type.
+         *
+         * This is equivalent to the {@link Dependency} type, except it will shorten itself to a string (the type's ID) if possible.
+         */
+        export type DependencyConcise<T> = TargetHelper<T, DependencyInfo | string, "dependencyConcise">;
+        /**
+         * Retrieves the labels from this tuple.
+         *
+         * This can also be used to extract parameter names via `Parameters<T>`
+         */
+        export type Labels<T extends readonly unknown[]> = (string[] & {
+            _flamework_macro_tuple_labels: T;
+        }) | undefined;
+        /**
+         * Hashes a string literal type (such as an event name.)
+         *
+         * The second type argument, `C`, is for providing a context to the hashing which will generate new hashes
+         * for strings which already have a hash under another context.
+         */
+        export type Hash<T extends string, C extends string = never> = string & {
+            /** @hidden */ _flamework_macro_hash: [T, C];
+        };
+        /**
+         * This is equivalent to {@link Hash `Hash`} except it will only hash strings when `obfuscation` is turned on.
+         */
+        export type Obfuscate<T extends string, C extends string = never> = string & {
+            /** @hidden */ _flamework_macro_hash: [T, C, true];
+        };
+        export {};
+    }
+    /**
+     * Information about an injected dependency.
+     */
+    export interface DependencyInfo {
+        /**
+         * The ID used to resolve this dependency.
+         */
+        id: string;
+        /**
+         * Metadata provided by the injectable type.
+         */
+        metadata?: unknown[];
+    }
+    type RealType<T> = T extends {
+        _flamework_injectable: {
+            type: infer R;
+        };
+    } ? RealType<R> : T;
+    export {};
+}