@rbxts/app-forge 0.7.2-prototype.1 → 0.7.2-prototype.3

package/out/appRegistry.d.ts

@@ -2,6 +2,7 @@ import Vide from "@rbxts/vide";
 import type Types from "./types";
 import type AppForge from "./mount";
 export declare const AppRegistry: Map<string, Types.AppRegistry.Static>;
+export declare const AppsLoaded: Map<`${string}-${string}`, boolean>;
 /**
  * Registers a Vide App with AppForge.
  *

package/out/appRegistry.luau

@@ -8,6 +8,7 @@ local px = TS.import(script, script.Parent, "hooks", "usePx").px
 local Logger = TS.import(script, script.Parent, "logger").default
 local logger = Logger.new("AppRegistry")
 local AppRegistry = {}
+local AppsLoaded = {}
 --[[
 	*
 	 * Registers a Vide App with AppForge.
@@ -17,8 +18,12 @@ local AppRegistry = {}
 ]]
 local function App(props)
 	return function(constructor)
-		local _name = props.name
-		if AppRegistry[_name] ~= nil then
+		local _condition = props.renderGroup
+		if _condition == nil then
+			_condition = "None"
+		end
+		local _arg0 = `{_condition}-{props.name}`
+		if AppRegistry[_arg0] ~= nil then
 			logger:log("ERROR", "Duplicate App name detected", {
 				name = props.name,
 			})
@@ -29,14 +34,18 @@ local function App(props)
 			logger:log("ERROR", "Attempted to register App without a name", props)
 			error("App registration failed: missing app name", 2)
 		end
-		local _name_1 = props.name
+		local _condition_1 = props.renderGroup
+		if _condition_1 == nil then
+			_condition_1 = "None"
+		end
+		local _arg0_1 = `{_condition_1}-{props.name}`
 		local _arg1 = {
 			constructor = constructor,
 			renderGroup = props.renderGroup,
 			visible = props.visible,
 			rules = props.rules,
 		}
-		AppRegistry[_name_1] = _arg1
+		AppRegistry[_arg0_1] = _arg1
 		return constructor
 	end
 end
@@ -71,5 +80,6 @@ end
 return {
 	App = App,
 	AppRegistry = AppRegistry,
+	AppsLoaded = AppsLoaded,
 	Args = Args,
 }

package/out/mount.d.ts

@@ -1,37 +1,26 @@
 import Vide from "@rbxts/vide";
-import Renders from "./renderManager";
+import Renders from "./renders";
 import Debugger from "./debugger";
 import Logger from "./logger";
 import Types from "./types";
 type Destructor = () => void;
-type Loaded = {
-    container: Vide.Node;
-    render: Vide.Node;
-    anchor?: Vide.Node;
-};
 export default class AppForge extends Renders {
     readonly logger: Logger;
     readonly debug: Debugger;
-    protected sources: Map<string, Vide.Source<boolean>>;
-    protected loaded: Map<string, Loaded>;
-    protected innerMount?: Destructor;
-    protected __px: boolean;
+    private sources;
+    private innerMount?;
     constructor();
-    protected createSource(name: AppNames): void;
+    private createSource;
     getSource(name: AppNames): Vide.Source<boolean>;
-    isLoaded(name: AppNames): boolean;
     bind(name: AppNames, value: Vide.Source<boolean>): void;
-    anchor(name: AppNames, anchorName: AppNames, props: Types.Props.Main): void;
-    index(name: AppNames, index: number): void;
     set(name: AppNames, value: boolean, rules?: boolean): void;
     open(name: AppNames, rules?: boolean): void;
     close(name: AppNames, rules?: boolean): void;
     toggle(name: AppNames, rules?: boolean): void;
-    story(props: AppProps, target: GuiObject, conf?: {
+    story(props: AppProps, target: GuiObject, config?: {
         render?: Types.Props.Render;
         minScale?: number;
     }): Frame;
-    mount(node: Vide.Node, props: Types.Props.Main, target: Instance): Destructor;
-    unMount(): void;
+    mount(node: Vide.Node, props: Exclude<Types.Props.Main, "forge">, target: Instance): Destructor;
 }
 export {};

package/out/mount.luau

@@ -12,7 +12,7 @@ local mount = _vide.mount
 local source = _vide.source
 local untrack = _vide.untrack
 -- Classes
-local Renders = TS.import(script, script.Parent, "renderManager").default
+local Renders = TS.import(script, script.Parent, "renders").default
 -- Helpers
 local AppRegistry = TS.import(script, script.Parent, "appRegistry").AppRegistry
 local Debugger = TS.import(script, script.Parent, "debugger").default
@@ -38,8 +38,6 @@ do
 			return self.logger:log(level, msg, data, trace)
 		end)
 		self.sources = {}
-		self.loaded = {}
-		self.__px = false
 		-- ▼ ReadonlyMap.forEach ▼
 		local _callback = function(_, name)
 			return self:createSource(name)
@@ -50,8 +48,8 @@ do
 		-- ▲ ReadonlyMap.forEach ▲
 	end
 	function AppForge:createSource(name)
-		local _name = name
-		local app = AppRegistry[_name]
+		local _arg0 = `-{name}`
+		local app = AppRegistry[_arg0]
 		if not app then
 			self.logger:log("ERROR", "App not registered while creating source", {
 				name = name,
@@ -59,8 +57,8 @@ do
 			return nil
 		end
 		local _sources = self.sources
-		local _name_1 = name
-		if _sources[_name_1] ~= nil then
+		local _name = name
+		if _sources[_name] ~= nil then
 			return nil
 		end
 		local _debug = self.debug
@@ -96,11 +94,6 @@ do
 		end
 		return src
 	end
-	function AppForge:isLoaded(name)
-		local _loaded = self.loaded
-		local _name = name
-		return _loaded[_name] ~= nil
-	end
 	function AppForge:bind(name, value)
 		if not RunService:IsRunning() then
 			self.debug:logTag("state", name, "Binding external visibility source")
@@ -136,81 +129,6 @@ do
 			})
 		end
 	end
-	function AppForge:anchor(name, anchorName, props)
-		if name == anchorName then
-			self.logger:log("ERROR", "Attempted to anchor app to itself", {
-				name = name,
-			})
-			return nil
-		end
-		local _anchorName = anchorName
-		local anchorApp = AppRegistry[_anchorName]
-		if not anchorApp then
-			self.logger:log("ERROR", "Anchor parent not registered", {
-				child = name,
-				parent = anchorName,
-			})
-			return nil
-		end
-		local _loaded = self.loaded
-		local _name = name
-		local _render = _loaded[_name]
-		if _render ~= nil then
-			_render = _render.render
-		end
-		local render = _render
-		if not render then
-			self.debug:logTag("rules", name, "Anchor skipped (child not rendered yet)", {
-				parent = anchorName,
-			})
-			return nil
-		end
-		self.debug:logTag("rules", name, "Anchoring to parent", {
-			parent = anchorName,
-		})
-		local anchor = anchorApp.constructor.new(props, anchorName):render()
-		for _, child in anchor:GetDescendants() do
-			child:Destroy()
-		end
-		apply(anchor)({
-			Name = "Anchor",
-			BackgroundTransparency = 1,
-			[0] = render,
-		})
-		local _loaded_1 = self.loaded
-		local _name_1 = name
-		local prev = _loaded_1[_name_1]
-		if not prev then
-			error(`AppForge invariant broken: missing loaded app for {name}`, 2)
-		end
-		apply(prev.container)({
-			[0] = anchor,
-		})
-		local _loaded_2 = self.loaded
-		local _exp = name
-		local _object = table.clone(prev)
-		setmetatable(_object, nil)
-		_object.anchor = anchor
-		_loaded_2[_exp] = _object
-	end
-	function AppForge:index(name, index)
-		local _loaded = self.loaded
-		local _name = name
-		local loaded = _loaded[_name]
-		if not loaded then
-			self.logger:log("WARN", "ZIndex skipped (app not loaded)", {
-				name = name,
-				index = index,
-			})
-			return nil
-		end
-		self.debug:logTag("rules", name, "Applying ZIndex", {
-			index = index,
-		})
-		apply(loaded.container)({
-			ZIndex = index,
-		})
-	end
 	function AppForge:set(name, value, rules)
 		if rules == nil then
 			rules = true
@@ -261,7 +179,7 @@ do
 		end
 		self:set(name, not self:getSource(name)(), rules)
 	end
-	function AppForge:story(props, target, conf)
+	function AppForge:story(props, target, config)
 		self.debug:logTag("lifecycle", "story", "Creating story mount")
 		local Container = create("Frame")({
 			Name = "Story Container",
@@ -278,8 +196,8 @@ do
 			props = props,
 			forge = self,
 		}
-		local _left_1 = "render"
-		local _result = conf
+		local _left_1 = "renders"
+		local _result = config
 		if _result ~= nil then
 			_result = _result.render
 		end
@@ -291,34 +209,33 @@ do
 			target = target,
 		}
 		local _left_4 = "minScale"
-		local _result_1 = conf
+		local _result_1 = config
 		if _result_1 ~= nil then
 			_result_1 = _result_1.minScale
 		end
 		_object_3[_left_4] = _result_1
 		_object_2[_left_3] = _object_3
 		_object_1[_left_2] = _object_2
-		_object[_left] = _self:renderMount(_object_1)
+		_object[_left] = _self:initalize(_object_1)
 		_fn(_object)
 		return Container
 	end
 	function AppForge:mount(node, props, target)
 		self.debug:logTag("lifecycle", "mount", "Mounting AppForge")
 		self.innerMount = mount(function()
-			apply(node)({
-				[0] = self:renderMount(props),
-			})
+			local _fn = apply(node)
+			local _object = {}
+			local _left = 0
+			local _self = self
+			local _object_1 = table.clone(props)
+			setmetatable(_object_1, nil)
+			_object_1.forge = self
+			_object[_left] = _self:initalize(_object_1)
+			_fn(_object)
 			return node
 		end, target)
 		return self.innerMount
 	end
-	function AppForge:unMount()
-		self.debug:logTag("lifecycle", "unmount", "Unmounting AppForge")
-		local _result = self.innerMount
-		if _result ~= nil then
-			_result()
-		end
-	end
 end
 return {
 	default = AppForge,

package/out/renders.d.ts

@@ -0,0 +1,8 @@
+import type Types from "./types";
+import Rules from "./ruleEngine";
+export default class Renders extends Rules {
+    private __px;
+    constructor();
+    private render;
+    protected initalize(props: Types.Props.Main): void;
+}

package/out/renders.luau

@@ -0,0 +1,66 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+-- Types
+-- Components
+-- Hooks
+local usePx = TS.import(script, script.Parent, "hooks", "usePx").usePx
+-- Classes
+local Rules = TS.import(script, script.Parent, "ruleEngine").default
+local Renders
+do
+	local super = Rules
+	Renders = setmetatable({}, {
+		__tostring = function()
+			return "Renders"
+		end,
+		__index = super,
+	})
+	Renders.__index = Renders
+	function Renders.new(...)
+		local self = setmetatable({}, Renders)
+		return self:constructor(...) or self
+	end
+	function Renders:constructor()
+		super.constructor(self)
+		self.__px = false
+	end
+	function Renders:render(name, names, group)
+		print(name, names, group)
+	end
+	function Renders:initalize(props)
+		if not self.__px then
+			local _result = props.config
+			if _result ~= nil then
+				_result = _result.px.target
+			end
+			local _result_1 = props.config
+			if _result_1 ~= nil then
+				_result_1 = _result_1.px.resolution
+			end
+			local _result_2 = props.config
+			if _result_2 ~= nil then
+				_result_2 = _result_2.px.minScale
+			end
+			usePx(_result, _result_1, _result_2)
+			self.__px = true
+		end
+		local _self = self
+		local _result = props.renders
+		if _result ~= nil then
+			_result = _result.name
+		end
+		local _result_1 = props.renders
+		if _result_1 ~= nil then
+			_result_1 = _result_1.names
+		end
+		local _result_2 = props.renders
+		if _result_2 ~= nil then
+			_result_2 = _result_2.group
+		end
+		_self:render(_result, _result_1, _result_2)
+	end
+end
+return {
+	default = Renders,
+}

package/out/ruleEngine/check/exclusiveGroup.d.ts

@@ -0,0 +1,2 @@
+import type AppForge from "../../mount";
+export default function ExclusiveGroupRule(name: AppNames, forge: AppForge): void;

package/out/ruleEngine/{exclusiveGroup.luau → check/exclusiveGroup.luau}

@@ -2,10 +2,10 @@
 local TS = _G[script]
 -- Types
 -- Components
-local AppRegistry = TS.import(script, script.Parent.Parent, "appRegistry").AppRegistry
-local function ExclusiveGroupRule(entry, forge)
-	local _entry = entry
-	local entryApp = AppRegistry[_entry]
+local AppRegistry = TS.import(script, script.Parent.Parent.Parent, "appRegistry").AppRegistry
+local function ExclusiveGroupRule(name, forge)
+	local _name = name
+	local entryApp = AppRegistry[_name]
 	local _group = entryApp
 	if _group ~= nil then
 		_group = _group.rules
@@ -17,14 +17,14 @@ local function ExclusiveGroupRule(entry, forge)
 	if not (group ~= "" and group) then
 		return nil
 	end
-	local entryVisible = forge:getSource(entry)()
+	local entryVisible = forge:getSource(name)()
 	if not entryVisible then
 		return nil
 	end
-	forge.debug:logTag("rules", entry, "Exclusive group activated", group)
+	forge.debug:logTag("rules", name, "Exclusive group activated", group)
 	-- ▼ ReadonlyMap.forEach ▼
 	local _callback = function(app, name)
-		if name == entry then
+		if name == name then
 			return nil
 		end
 		local _result = app.rules
@@ -38,7 +38,7 @@ local function ExclusiveGroupRule(entry, forge)
 		if not visible then
 			return nil
 		end
-		forge.debug:logTag("rules", entry, "Closing app due to exclusive group", {
+		forge.debug:logTag("rules", name, "Closing app due to exclusive group", {
 			closed = name,
 			group = group,
 		})

package/out/ruleEngine/check/parent.d.ts

@@ -0,0 +1,2 @@
+import type AppForge from "../../mount";
+export default function ParentRule(name: AppNames, forge: AppForge): void;

package/out/ruleEngine/check/parent.luau

@@ -0,0 +1,37 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent.Parent.Parent, "appRegistry").AppRegistry
+local function ParentRule(name, forge)
+	local _name = name
+	local entry = AppRegistry[_name]
+	local _result = entry
+	if _result ~= nil then
+		_result = _result.rules
+		if _result ~= nil then
+			_result = _result.parent
+		end
+	end
+	if not (_result ~= "" and _result) then
+		return nil
+	end
+	local _forge = forge
+	local _result_1 = entry
+	if _result_1 ~= nil then
+		_result_1 = _result_1.rules
+		if _result_1 ~= nil then
+			_result_1 = _result_1.parent
+		end
+	end
+	local parentSource = _forge:getSource(_result_1)
+	if not parentSource() then
+		local source = forge:getSource(name)
+		if source() then
+			source(false)
+		end
+	end
+end
+return {
+	default = ParentRule,
+}

package/out/ruleEngine/init.luau

@@ -4,8 +4,9 @@ local TS = _G[script]
 -- Components
 local AppRegistry = TS.import(script, script.Parent, "appRegistry").AppRegistry
 -- Rules
-local ExclusiveGroupRule = TS.import(script, script, "exclusiveGroup").default
-local ParentRule = TS.import(script, script, "parent").default
+local ExclusiveGroupRule = TS.import(script, script, "check", "exclusiveGroup").default
+local ParentRule = TS.import(script, script, "check", "parent").default
+local AnchorRule = TS.import(script, script, "render", "anchor").default
 local Rules
 do
 	Rules = setmetatable({}, {
@@ -34,18 +35,19 @@ do
 		-- Parent Anchor
 		local _condition = rules.parent
 		if _condition ~= "" and _condition then
-			_condition = not rules.detach
+			_condition = not rules.anchor
 		end
 		if _condition ~= "" and _condition then
 			forge.debug:logTag("rules", name, "Applying parent anchor", {
 				parent = rules.parent,
 			})
-			forge:anchor(name, rules.parent, props)
+			AnchorRule(name, props)
 		end
 		-- Index
 		if rules.zIndex ~= nil then
 			forge.debug:logTag("rules", name, "Applying ZIndex", rules.zIndex)
-			forge:index(name, rules.zIndex)
+			-- TODO: will be a separate file under ruleEngine
+			-- forge.index(name, rules.zIndex);
 		end
 	end
 	function Rules:checkRules(forge, name)

package/out/ruleEngine/render/anchor.d.ts

@@ -0,0 +1,2 @@
+import type Types from "../../types";
+export default function anchor(name: AppNames, props: Types.Props.Main): void;

package/out/ruleEngine/render/anchor.luau

@@ -0,0 +1,38 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Components
+local _appRegistry = TS.import(script, script.Parent.Parent.Parent, "appRegistry")
+local AppRegistry = _appRegistry.AppRegistry
+local AppsLoaded = _appRegistry.AppsLoaded
+local function anchor(name, props)
+	local _binding = props
+	local forge = _binding.forge
+	local _name = name
+	local app = AppRegistry[_name]
+	local _result = app
+	if _result ~= nil then
+		_result = _result.renderGroup
+	end
+	local _condition = _result
+	if _condition == nil then
+		_condition = "None"
+	end
+	local _arg0 = `{_condition}-{name}`
+	local loaded = AppsLoaded[_arg0]
+	local _result_1 = app
+	if _result_1 ~= nil then
+		_result_1 = _result_1.rules
+		if _result_1 ~= nil then
+			_result_1 = _result_1.parent
+		end
+	end
+	local parentApp = AppRegistry[_result_1]
+	if not parentApp then
+		forge.debug:logTag("rules", name, `Has no Parent to Anchor to, Remove the Anchor For {name}`)
+	end
+	print(`App: {app} \n Loaded: {loaded} \n parentApp: {parentApp}`)
+end
+return {
+	default = anchor,
+}

package/out/types.d.ts

@@ -21,7 +21,7 @@ declare namespace Types {
 					minScale?: number;
 				};
 			};
-			render?: Render;
+			renders?: Render;
 		};
 
 		type Class = AppProps & {
@@ -58,12 +58,12 @@ declare namespace Types {
 	namespace Rules {
 		type WithParent<P> = {
 			parent: P;
-			detach?: boolean;
+			anchor?: boolean;
 		};
 
 		type WithoutParent = {
 			parent?: never;
-			detach?: never;
+			anchor?: never;
 		};
 
 		export type Static = {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rbxts/app-forge",
-	"version": "0.7.2-prototype.1",
+	"version": "0.7.2-prototype.3",
 	"description": "An App Manager for Vide",
 	"main": "out/init.lua",
 	"types": "out/index.d.ts",

package/out/renderManager.d.ts

@@ -1,32 +0,0 @@
-import Vide from "@rbxts/vide";
-import type Types from "./types";
-import type AppForge from "./mount";
-import Rules from "./ruleEngine";
-export default class Renders extends Rules {
-    protected anchored: Map<string, {
-        id: AppNames;
-        render: Vide.Node;
-    }>;
-    constructor();
-    /**
-     * Entry point for mounting renders.
-     * Decides render strategy based on props.
-     */
-    protected renderMount(this: AppForge, props: Types.Props.Main): Vide.Node;
-    /**
-     * Render multiple apps by name, avoiding duplicates.
-     */
-    private renderNames;
-    /**
-     * Render children of a parent app recursively inside parent container
-     */
-    private renderChildren;
-    private collectByGroup;
-    private normalizeGroups;
-    protected renderApp(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>, parentContainer?: Instance): Vide.Node;
-    protected renderApps(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-    protected renderGroup(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-    protected renderGroupByName(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-    protected renderGroupByNames(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-    protected renderAll(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-}

package/out/renderManager.luau

@@ -1,326 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
--- Packages
-local _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
-local apply = _vide.apply
-local create = _vide.create
-local mount = _vide.mount
--- Types
--- Components
-local AppRegistry = TS.import(script, script.Parent, "appRegistry").AppRegistry
--- Hooks
-local usePx = TS.import(script, script.Parent, "hooks", "usePx").usePx
--- Classes
-local Rules = TS.import(script, script.Parent, "ruleEngine").default
-local Renders
-do
-	local super = Rules
-	Renders = setmetatable({}, {
-		__tostring = function()
-			return "Renders"
-		end,
-		__index = super,
-	})
-	Renders.__index = Renders
-	function Renders.new(...)
-		local self = setmetatable({}, Renders)
-		return self:constructor(...) or self
-	end
-	function Renders:constructor()
-		super.constructor(self)
-		self.anchored = {}
-	end
-	function Renders:renderMount(props)
-		local _binding = props
-		local config = _binding.config
-		local render = _binding.render
-		local forge = _binding.forge
-		if not forge.__px then
-			local _debug = forge.debug
-			local _result = config
-			if _result ~= nil then
-				_result = _result.px
-			end
-			_debug:logTag("px", "global", "Initializing px scaling", _result)
-			local _result_1 = config
-			if _result_1 ~= nil then
-				_result_1 = _result_1.px.target
-			end
-			local _result_2 = config
-			if _result_2 ~= nil then
-				_result_2 = _result_2.px.resolution
-			end
-			local _result_3 = config
-			if _result_3 ~= nil then
-				_result_3 = _result_3.px.minScale
-			end
-			usePx(_result_1, _result_2, _result_3)
-			forge.__px = true
-		else
-			forge.debug:logTag("px", "global", "Skipped duplicate px initialization")
-		end
-		local renderedSet = {}
-		if render then
-			local _condition = render.name
-			if _condition ~= "" and _condition then
-				_condition = render.group
-			end
-			if _condition ~= "" and _condition then
-				return self:renderGroupByName(props, renderedSet)
-			end
-			local _value = render.names and render.group
-			if _value ~= "" and _value then
-				return self:renderGroupByNames(props, renderedSet)
-			end
-			local _value_1 = render.name
-			if _value_1 ~= "" and _value_1 then
-				return self:renderApp(props, renderedSet)
-			end
-			if render.names then
-				return self:renderApps(props, renderedSet)
-			end
-			local _value_2 = render.group
-			if _value_2 ~= "" and _value_2 then
-				return self:renderGroup(props, renderedSet)
-			end
-		end
-		return self:renderAll(props, renderedSet)
-	end
-	function Renders:renderNames(props, names, forge, context, renderedSet, details, parentContainer)
-		if not names then
-			local _logger = forge.logger
-			local _exp = `Renderer resolved 0 apps ({context})`
-			local _condition = details
-			if _condition == nil then
-				_condition = props.render
-			end
-			_logger:log("WARN", _exp, _condition)
-			return {}
-		end
-		local rendered = {}
-		for _, name in names do
-			if renderedSet[name] ~= nil then
-				continue
-			end
-			renderedSet[name] = true
-			local _forge = forge
-			local _object = table.clone(props)
-			setmetatable(_object, nil)
-			_object.render = {
-				name = name,
-			}
-			local appRender = _forge:renderApp(_object, renderedSet, parentContainer)
-			table.insert(rendered, appRender)
-			self:renderChildren(props, name, forge, renderedSet, rendered, appRender)
-		end
-		return rendered
-	end
-	function Renders:renderChildren(props, parentName, forge, renderedSet, accumulated, parentContainer)
-		-- ▼ ReadonlyMap.forEach ▼
-		local _callback = function(app, childName)
-			local _result = app.rules
-			if _result ~= nil then
-				_result = _result.parent
-			end
-			local _condition = _result == parentName
-			if _condition then
-				local _renderedSet = renderedSet
-				local _childName = childName
-				_condition = not (_renderedSet[_childName] ~= nil)
-			end
-			if _condition then
-				local _renderedSet = renderedSet
-				local _childName = childName
-				_renderedSet[_childName] = true
-				local _forge = forge
-				local _object = table.clone(props)
-				setmetatable(_object, nil)
-				_object.render = {
-					name = childName,
-				}
-				local childRender = _forge:renderApp(_object, renderedSet, parentContainer)
-				table.insert(accumulated, childRender)
-				mount(function()
-					return childRender
-				end, parentContainer)
-				self:renderChildren(props, childName, forge, renderedSet, accumulated, childRender)
-			end
-		end
-		for _k, _v in AppRegistry do
-			_callback(_v, _k, AppRegistry)
-		end
-		-- ▲ ReadonlyMap.forEach ▲
-	end
-	function Renders:collectByGroup(groups, filter)
-		local result = {}
-		-- ▼ ReadonlyMap.forEach ▼
-		local _callback = function(app, name)
-			local appGroup = app.renderGroup
-			if not (appGroup ~= "" and appGroup) then
-				return nil
-			end
-			if not (table.find(groups, appGroup) ~= nil) then
-				return nil
-			end
-			if filter and not filter(name) then
-				return nil
-			end
-			local _name = name
-			table.insert(result, _name)
-		end
-		for _k, _v in AppRegistry do
-			_callback(_v, _k, AppRegistry)
-		end
-		-- ▲ ReadonlyMap.forEach ▲
-		return result
-	end
-	function Renders:normalizeGroups(group)
-		local _group = group
-		local _result
-		if type(_group) == "table" then
-			local _array = {}
-			local _length = #_array
-			table.move(group, 1, #group, _length + 1, _array)
-			_result = _array
-		else
-			_result = { group }
-		end
-		return _result
-	end
-	function Renders:renderApp(props, renderedSet, parentContainer)
-		local _name = props.render
-		if _name ~= nil then
-			_name = _name.name
-		end
-		local name = _name
-		if not (name ~= "" and name) then
-			error("renderApp requires an app name", 2)
-		end
-		local appClass = AppRegistry[name]
-		if not appClass then
-			error(`App "{name}" not registered`, 2)
-		end
-		self.debug:time("render", name)
-		if not (self.loaded[name] ~= nil) then
-			local render = appClass.constructor.new(props, name):render()
-			if not render then
-				error(`App "{name}" returned undefined from render()`, 2)
-			end
-			apply(render)({
-				Name = "Render",
-			})
-			local container = create("Frame")({
-				Name = name,
-				BackgroundTransparency = 1,
-				AnchorPoint = Vector2.new(0.5, 0.5),
-				Position = UDim2.fromScale(0.5, 0.5),
-				Size = UDim2.fromScale(1, 1),
-				[0] = render,
-			})
-			if parentContainer then
-				container.Parent = parentContainer
-			end
-			local _loaded = self.loaded
-			local _arg1 = {
-				container = container,
-				render = render,
-			}
-			_loaded[name] = _arg1
-		else
-			self.debug:logTag("render", name, "Reusing existing render instance")
-		end
-		local _result = renderedSet
-		if _result ~= nil then
-			_result[name] = true
-		end
-		self:renderRules(self, name, props)
-		self.debug:timeEnd("render", name)
-		return self.loaded[name].container
-	end
-	function Renders:renderApps(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local _names = props.render
-		if _names ~= nil then
-			_names = _names.names
-		end
-		local names = _names
-		if not names then
-			error("renderApps requires app names", 2)
-		end
-		return self:renderNames(props, names, self, "renderApps", renderedSet, names)
-	end
-	function Renders:renderGroup(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local _group = props.render
-		if _group ~= nil then
-			_group = _group.group
-		end
-		local group = _group
-		if not (group ~= "" and group) then
-			error("renderGroup requires a group", 2)
-		end
-		local groups = self:normalizeGroups(group)
-		return self:renderNames(props, self:collectByGroup(groups), self, "renderGroup", renderedSet, group)
-	end
-	function Renders:renderGroupByName(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local _binding = props.render or {}
-		local group = _binding.group
-		local name = _binding.name
-		if not (group ~= "" and group) or not (name ~= "" and name) then
-			error("Invalid renderGroupByName call", 2)
-		end
-		local groups = self:normalizeGroups(group)
-		return self:renderNames(props, self:collectByGroup(groups, function(n)
-			return n == name
-		end), self, "renderGroupByName", renderedSet, {
-			group = group,
-			name = name,
-		})
-	end
-	function Renders:renderGroupByNames(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local _binding = props.render or {}
-		local group = _binding.group
-		local names = _binding.names
-		if not (group ~= "" and group) or not names then
-			error("Invalid renderGroupByNames call", 2)
-		end
-		local groups = self:normalizeGroups(group)
-		return self:renderNames(props, self:collectByGroup(groups, function(n)
-			local _n = n
-			return table.find(names, _n) ~= nil
-		end), self, "renderGroupByNames", renderedSet, {
-			group = group,
-			names = names,
-		})
-	end
-	function Renders:renderAll(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local names = {}
-		-- ▼ ReadonlyMap.forEach ▼
-		local _callback = function(_, name)
-			local _name = name
-			table.insert(names, _name)
-			return #names
-		end
-		for _k, _v in AppRegistry do
-			_callback(_v, _k, AppRegistry)
-		end
-		-- ▲ ReadonlyMap.forEach ▲
-		return self:renderNames(props, names, self, "renderAll", renderedSet)
-	end
-end
-return {
-	default = Renders,
-}

package/out/ruleEngine/exclusiveGroup.d.ts

@@ -1,2 +0,0 @@
-import type AppForge from "../mount";
-export default function ExclusiveGroupRule(entry: AppNames, forge: AppForge): void;

package/out/ruleEngine/parent.d.ts

@@ -1,2 +0,0 @@
-import type AppForge from "../mount";
-export default function ParentRule(entry: AppNames, forge: AppForge): void;

package/out/ruleEngine/parent.luau

@@ -1,34 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
--- Types
--- Components
-local AppRegistry = TS.import(script, script.Parent.Parent, "appRegistry").AppRegistry
-local function ParentRule(entry, forge)
-	local entryVisible = forge:getSource(entry)()
-	-- ▼ ReadonlyMap.forEach ▼
-	local _callback = function(app, name)
-		local rules = app.rules
-		if not rules or rules.parent ~= entry then
-			return nil
-		end
-		if name == entry then
-			return nil
-		end
-		local childVisible = forge:getSource(name)()
-		if entryVisible or not childVisible then
-			return nil
-		end
-		forge.debug:logTag("rules", entry, "Closing child app (parent closed)", {
-			parent = entry,
-			child = name,
-		})
-		forge:close(name, false)
-	end
-	for _k, _v in AppRegistry do
-		_callback(_v, _k, AppRegistry)
-	end
-	-- ▲ ReadonlyMap.forEach ▲
-end
-return {
-	default = ParentRule,
-}