@trioforge/anvil 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Trio Forge Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,112 @@
-# Temporary Holding Version
+# @trioforge/anvil
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Headless UI primitives for Roblox games, built on [Vide](https://centau.github.io/vide/). Anvil owns behaviour: who gets gamepad selection, which modal is on top, how a press, a hold or a repeat fires, and when the Close button may close a screen. Your game owns every pixel and every sound.
+
+Anvil started as the interface runtime of Fragile Delivery. Version 0.1 covers modals, selection and presses. Components such as sliders, tabs and dialogs come next.
+
+## Install
+
+```sh
+pnpm add @trioforge/anvil @rbxts/vide @rbxts/charm @rbxts/vide-charm @rbxts/services
+```
+
+roblox-ts only looks for packages in the scopes your project lists, so add the `@trioforge` scope in two places.
+
+1. In `tsconfig.json`, add it to `typeRoots`:
+
+	```json
+	"typeRoots": ["node_modules/@rbxts", "node_modules/@trioforge"]
+	```
+
+2. In your Rojo project, map it beside `@rbxts` under `rbxts_include/node_modules`:
+
+	```json
+	"node_modules": {
+		"$className": "Folder",
+		"@rbxts": { "$path": "node_modules/@rbxts" },
+		"@trioforge": { "$path": "node_modules/@trioforge" }
+	}
+	```
+
+## Connect your game
+
+Anvil reads input and gives feedback only through an adapter that you install once, on the client, before any Anvil UI renders. Then start the menu runtime.
+
+```ts
+import { atom } from "@rbxts/charm";
+import { UserInputService } from "@rbxts/services";
+import Vide from "@rbxts/vide";
+import { installAnvil, Modal, startMenuRuntime, usePress, type AnvilAdapter, type InputDevice } from "@trioforge/anvil";
+
+const device = atom<InputDevice>("Keyboard");
+UserInputService.LastInputTypeChanged.Connect((input) => {
+	if (input === Enum.UserInputType.Touch) device("Touch");
+	else if (input === Enum.UserInputType.Gamepad1) device("Gamepad");
+	else if (input === Enum.UserInputType.Keyboard || input === Enum.UserInputType.MouseMovement) device("Keyboard");
+});
+
+function onButtonB(signal: RBXScriptSignal<(input: InputObject) => void>, listener: () => void) {
+	const connection = signal.Connect((input) => {
+		if (input.KeyCode === Enum.KeyCode.ButtonB) listener();
+	});
+	return () => connection.Disconnect();
+}
+
+const sounds = new Map<string, Sound>();
+
+const adapter: AnvilAdapter = {
+	device,
+	close: {
+		held: () =>
+			UserInputService.GetConnectedGamepads().some((gamepad) =>
+				UserInputService.IsGamepadButtonDown(gamepad, Enum.KeyCode.ButtonB),
+			),
+		onPressed: (listener) => onButtonB(UserInputService.InputBegan, listener),
+		onReleased: (listener) => onButtonB(UserInputService.InputEnded, listener),
+	},
+	claimMenuInput: () => () => {},
+	feedback: (kind) => sounds.get(kind)?.Play(),
+};
+
+installAnvil(adapter);
+startMenuRuntime();
+```
+
+`installAnvil` accepts the same adapter again and does nothing. It refuses a different adapter. Anvil reads the adapter when the first control renders or the runtime starts, and raises an error if you never installed one.
+
+| Member | What Anvil does with it |
+| --- | --- |
+| `device` | Reads the current input device. Selection only moves while it is `"Gamepad"`, and highlights ignore `"Touch"`. It must be a Charm atom or computed, because Anvil reads it inside Charm effects. |
+| `close.held` | Asks whether the close input is down. A screen closes only on a fresh press, so a press that started before the screen opened does nothing. |
+| `close.onPressed` | Subscribes to close presses. The top native modal's `onClose` runs on each armed press. |
+| `close.onReleased` | Subscribes to anything that may have lifted the close input. Anvil reads `close.held` again each time, so extra calls are harmless. |
+| `claimMenuInput` | Runs while a native modal is on top and no text box has focus. Return a function that releases the claim, for example to stop gameplay actions from reading ButtonB. |
+| `feedback` | Receives `"Focus"`, `"Press"` or `"Refused"` for each press that is not `silent`. Play your sounds here. |
+
+## Build a modal
+
+```tsx
+function BuyButton(props: { onBuy: () => void }) {
+	const press = usePress({ onPress: props.onBuy, selectFirst: true });
+	return (
+		<textbutton
+			action={press.action}
+			Text="Buy"
+			Size={() => (press.pressed() ? UDim2.fromOffset(112, 38) : UDim2.fromOffset(120, 40))}
+			BackgroundColor3={() => (press.highlighted() ? Color3.fromRGB(255, 214, 102) : Color3.fromRGB(240, 240, 240))}
+		/>
+	);
+}
+
+export function Shop(props: { onBuy: () => void; onClose: () => void }) {
+	return <Modal name="Shop" onClose={props.onClose}>{() => <BuyButton onBuy={props.onBuy} />}</Modal>;
+}
+```
+
+- `usePress` returns `highlighted`, `pressed` and `progress` getters, and an `action` that you attach to your own `GuiButton`. Pass `hold` for a hold-to-confirm button, or `repeating` for a button that repeats while held.
+- `Modal` takes its children as a function, so the controls inside know which modal owns them.
+- The topmost modal, ranked by its `ScreenGui`'s `DisplayOrder`, owns gamepad selection and blocks presses underneath. Use `modalOpen()` to pause gameplay while any modal is open.
+
+## License
+
+MIT

package/out/adapter.d.ts

@@ -0,0 +1,16 @@
+import type { Getter } from "@rbxts/charm";
+export type InputDevice = "Gamepad" | "Touch" | "Keyboard";
+export type PressFeedback = "Focus" | "Press" | "Refused";
+export interface CloseInput {
+    readonly held: () => boolean;
+    readonly onPressed: (listener: () => void) => () => void;
+    readonly onReleased: (listener: () => void) => () => void;
+}
+export interface AnvilAdapter {
+    readonly device: Getter<InputDevice>;
+    readonly close: CloseInput;
+    readonly claimMenuInput: () => () => void;
+    readonly feedback: (kind: PressFeedback) => void;
+}
+export declare function installAnvil(adapter: AnvilAdapter): void;
+export declare function adapter(): AnvilAdapter;

package/out/adapter.luau

@@ -0,0 +1,19 @@
+-- Compiled with roblox-ts v3.0.0
+local installed
+local function installAnvil(adapter)
+	if installed == adapter then
+		return nil
+	end
+	local _arg0 = installed == nil
+	assert(_arg0, "Anvil already has a different adapter")
+	installed = adapter
+end
+local function adapter()
+	local _installed = installed
+	assert(_installed, "Anvil has no adapter. Call installAnvil before rendering Anvil UI.")
+	return installed
+end
+return {
+	installAnvil = installAnvil,
+	adapter = adapter,
+}

package/out/frame-loop.d.ts

@@ -0,0 +1,3 @@
+export type FrameListener = (now: number, delta: number) => void;
+export declare const heartbeat: (listener: FrameListener) => (() => void);
+export declare const preRender: (listener: FrameListener) => (() => void);

package/out/frame-loop.luau

@@ -0,0 +1,56 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local function loop(signal)
+	local listeners = {}
+	local order
+	local connection
+	return function(listener)
+		local _listener = listener
+		listeners[_listener] = true
+		order = nil
+		if connection == nil then
+			connection = signal:Connect(function(delta)
+				if order == nil then
+					local _array = {}
+					local _length = #_array
+					for _v in listeners do
+						_length += 1
+						_array[_length] = _v
+					end
+					order = _array
+				end
+				local now = os.clock()
+				for _, callback in order do
+					if listeners[callback] ~= nil then
+						callback(now, delta)
+					end
+				end
+			end)
+		end
+		return function()
+			local _listener_1 = listener
+			-- ▼ Set.delete ▼
+			local _valueExisted = listeners[_listener_1] ~= nil
+			listeners[_listener_1] = nil
+			-- ▲ Set.delete ▲
+			if not _valueExisted then
+				return nil
+			end
+			order = nil
+			if next(listeners) == nil then
+				local _result = connection
+				if _result ~= nil then
+					_result:Disconnect()
+				end
+				connection = nil
+			end
+		end
+	end
+end
+local heartbeat = loop(RunService.Heartbeat)
+local preRender = loop(RunService.PreRender)
+return {
+	heartbeat = heartbeat,
+	preRender = preRender,
+}

package/out/index.d.ts

@@ -0,0 +1,6 @@
+export { installAnvil, type AnvilAdapter, type CloseInput, type InputDevice, type PressFeedback } from "./adapter";
+export { Modal, modalOpen, useModalActive, useTextEditing, type ModalProps } from "./modal";
+export { closeFallbackContext, startMenuRuntime, useSelection } from "./runtime";
+export { usePress, type PressOptions, type PressTiming } from "./use-press";
+export { heartbeat, preRender, type FrameListener } from "./frame-loop";
+export type { Children, ChildFactory, Getter, Placement, Value } from "./props";

package/out/init.luau

@@ -0,0 +1,18 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+exports.installAnvil = TS.import(script, script, "adapter").installAnvil
+local _modal = TS.import(script, script, "modal")
+exports.Modal = _modal.Modal
+exports.modalOpen = _modal.modalOpen
+exports.useModalActive = _modal.useModalActive
+exports.useTextEditing = _modal.useTextEditing
+local _runtime = TS.import(script, script, "runtime")
+exports.closeFallbackContext = _runtime.closeFallbackContext
+exports.startMenuRuntime = _runtime.startMenuRuntime
+exports.useSelection = _runtime.useSelection
+exports.usePress = TS.import(script, script, "use-press").usePress
+local _frame_loop = TS.import(script, script, "frame-loop")
+exports.heartbeat = _frame_loop.heartbeat
+exports.preRender = _frame_loop.preRender
+return exports

package/out/modal-state.d.ts

@@ -0,0 +1,12 @@
+export interface ModalEntry<Id> {
+    readonly id: Id;
+    readonly order: number | undefined;
+    readonly serial: number;
+}
+export interface ModalState<Id> {
+    readonly entries: readonly ModalEntry<Id>[];
+}
+export declare function enter<Id>(state: ModalState<Id>, entry: ModalEntry<Id>): ModalState<Id>;
+export declare function leave<Id>(state: ModalState<Id>, id: Id): ModalState<Id>;
+export declare function top<Id>(state: ModalState<Id>): ModalEntry<Id> | undefined;
+export declare function hasModal<Id>(state: ModalState<Id>): boolean;

package/out/modal-state.luau

@@ -0,0 +1,133 @@
+-- Compiled with roblox-ts v3.0.0
+local function enter(state, entry)
+	local _exp = state.entries
+	-- ▼ ReadonlyArray.find ▼
+	local _callback = function(value)
+		return value.id == entry.id
+	end
+	local _result
+	for _i, _v in _exp do
+		if _callback(_v, _i - 1, _exp) == true then
+			_result = _v
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.find ▲
+	local existing = _result
+	local _result_1 = existing
+	if _result_1 ~= nil then
+		_result_1 = _result_1.order
+	end
+	local _condition = _result_1 == entry.order
+	if _condition then
+		_condition = existing ~= nil
+	end
+	if _condition then
+		return state
+	end
+	local _object = {}
+	local _left = "entries"
+	local _result_2
+	if existing then
+		local _exp_1 = state.entries
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_exp_1)
+		local _callback_1 = function(value)
+			local _result_3
+			if value.id == entry.id then
+				local _object_1 = table.clone(value)
+				setmetatable(_object_1, nil)
+				_object_1.order = entry.order
+				_result_3 = _object_1
+			else
+				_result_3 = value
+			end
+			return _result_3
+		end
+		for _k, _v in _exp_1 do
+			_newValue[_k] = _callback_1(_v, _k - 1, _exp_1)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		_result_2 = _newValue
+	else
+		local _array = {}
+		local _length = #_array
+		local _array_1 = state.entries
+		local _Length = #_array_1
+		table.move(_array_1, 1, _Length, _length + 1, _array)
+		_length += _Length
+		_array[_length + 1] = entry
+		_result_2 = _array
+	end
+	_object[_left] = _result_2
+	return _object
+end
+local function leave(state, id)
+	local _exp = state.entries
+	-- ▼ ReadonlyArray.some ▼
+	local _result = false
+	local _callback = function(value)
+		return value.id == id
+	end
+	for _k, _v in _exp do
+		if _callback(_v, _k - 1, _exp) then
+			_result = true
+			break
+		end
+	end
+	-- ▲ ReadonlyArray.some ▲
+	if not _result then
+		return state
+	end
+	local _object = {}
+	local _left = "entries"
+	local _exp_1 = state.entries
+	-- ▼ ReadonlyArray.filter ▼
+	local _newValue = {}
+	local _callback_1 = function(value)
+		return value.id ~= id
+	end
+	local _length = 0
+	for _k, _v in _exp_1 do
+		if _callback_1(_v, _k - 1, _exp_1) == true then
+			_length += 1
+			_newValue[_length] = _v
+		end
+	end
+	-- ▲ ReadonlyArray.filter ▲
+	_object[_left] = _newValue
+	return _object
+end
+local function top(state)
+	local result
+	for _, entry in state.entries do
+		if entry.order == nil then
+			return nil
+		end
+		local _condition = not result
+		if not _condition then
+			local _exp = entry.order
+			local _condition_1 = result.order
+			if _condition_1 == nil then
+				_condition_1 = 0
+			end
+			_condition = _exp > _condition_1
+			if not _condition then
+				_condition = (entry.order == result.order and entry.serial > result.serial)
+			end
+		end
+		if _condition then
+			result = entry
+		end
+	end
+	return result
+end
+local function hasModal(state)
+	return not (#state.entries == 0)
+end
+return {
+	enter = enter,
+	leave = leave,
+	top = top,
+	hasModal = hasModal,
+}

package/out/modal.d.ts

@@ -0,0 +1,13 @@
+import Vide from "@rbxts/vide";
+import type { ChildFactory, Placement, Value } from "./props";
+import { modalOpen } from "./runtime";
+export { modalOpen };
+export interface ModalProps extends Placement {
+    selection?: "Native" | "Pointer";
+    onClose?: () => void;
+    size?: Value<UDim2>;
+    children: ChildFactory;
+}
+export declare function Modal(props: ModalProps): Vide.Node;
+export declare function useModalActive(): () => boolean;
+export declare function useTextEditing(): () => boolean;

package/out/modal.luau

@@ -0,0 +1,58 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
+local Vide = _vide
+local cleanup = _vide.cleanup
+local useAtom = TS.import(script, TS.getModule(script, "@rbxts", "vide-charm").src).useAtom
+local _runtime = TS.import(script, script.Parent, "runtime")
+local active = _runtime.active
+local attachRoot = _runtime.attachRoot
+local closeRoot = _runtime.closeRoot
+local modalOpen = _runtime.modalOpen
+local openRoot = _runtime.openRoot
+local ownerContext = _runtime.ownerContext
+local textEditing = _runtime.textEditing
+local function Modal(props)
+	local id = openRoot(props.selection or "Native", props.onClose)
+	cleanup(function()
+		return closeRoot(id)
+	end)
+	return ownerContext(id, function()
+		local _attributes = {}
+		local _condition = props.name
+		if _condition == nil then
+			_condition = "Modal"
+		end
+		_attributes.Name = _condition
+		_attributes.Size = props.size or UDim2.fromScale(1, 1)
+		_attributes.Position = props.position
+		_attributes.AnchorPoint = props.anchorPoint
+		_attributes.LayoutOrder = props.layoutOrder
+		_attributes.ZIndex = props.zIndex
+		_attributes.BackgroundTransparency = 1
+		_attributes.SelectionGroup = true
+		_attributes.SelectionBehaviorUp = Enum.SelectionBehavior.Stop
+		_attributes.SelectionBehaviorDown = Enum.SelectionBehavior.Stop
+		_attributes.SelectionBehaviorLeft = Enum.SelectionBehavior.Stop
+		_attributes.SelectionBehaviorRight = Enum.SelectionBehavior.Stop
+		_attributes.action = function(root)
+			return cleanup(attachRoot(id, root))
+		end
+		return Vide.jsx("frame", _attributes, props.children())
+	end)
+end
+local function useModalActive()
+	local owner = ownerContext()
+	return useAtom(function()
+		return active(owner)
+	end)
+end
+local function useTextEditing()
+	return useAtom(textEditing)
+end
+return {
+	Modal = Modal,
+	useModalActive = useModalActive,
+	useTextEditing = useTextEditing,
+	modalOpen = modalOpen,
+}

package/out/press-state.d.ts

@@ -0,0 +1,35 @@
+export type PressMode = {
+    readonly kind: "Activate";
+} | {
+    readonly kind: "Hold";
+    readonly seconds: number;
+} | {
+    readonly kind: "Repeat";
+};
+export interface PressState<Source> {
+    readonly source?: Source;
+    readonly elapsed: number;
+    readonly progress: number;
+    readonly fired: boolean;
+    readonly nextRepeatAt: number;
+    readonly repeatInterval: number;
+}
+export type PressEvent<Source> = {
+    readonly kind: "Begin";
+    readonly source: Source;
+} | {
+    readonly kind: "Tick";
+    readonly delta: number;
+} | {
+    readonly kind: "End";
+    readonly source: Source;
+} | {
+    readonly kind: "Cancel";
+};
+export interface PressTransition<Source> {
+    readonly state: PressState<Source>;
+    readonly fire: boolean;
+    readonly ended: boolean;
+}
+export declare function idlePress<Source>(): PressState<Source>;
+export declare function transition<Source>(state: PressState<Source>, mode: PressMode, event: PressEvent<Source>): PressTransition<Source>;

package/out/press-state.luau

@@ -0,0 +1,104 @@
+-- Compiled with roblox-ts v3.0.0
+local function idlePress()
+	return {
+		elapsed = 0,
+		progress = 0,
+		fired = false,
+		nextRepeatAt = 0.4,
+		repeatInterval = 0.15,
+	}
+end
+local function transition(state, mode, event)
+	if event.kind == "Begin" then
+		local _result
+		if state.source ~= nil then
+			_result = {
+				state = state,
+				fire = false,
+				ended = false,
+			}
+		else
+			local _object = {}
+			local _left = "state"
+			local _object_1 = table.clone(idlePress())
+			setmetatable(_object_1, nil)
+			_object_1.source = event.source
+			_object[_left] = _object_1
+			_object.fire = mode.kind == "Repeat"
+			_object.ended = false
+			_result = _object
+		end
+		return _result
+	end
+	if event.kind == "Cancel" or event.kind == "End" then
+		if event.kind == "End" and event.source ~= state.source then
+			return {
+				state = state,
+				fire = false,
+				ended = false,
+			}
+		end
+		local _object = {}
+		local _left = "state"
+		local _object_1 = table.clone(idlePress())
+		setmetatable(_object_1, nil)
+		_object_1.progress = state.progress
+		_object[_left] = _object_1
+		_object.fire = false
+		_object.ended = state.source ~= nil
+		return _object
+	end
+	local delta = math.max(0, event.delta)
+	if state.source == nil then
+		local _object = {}
+		local _left = "state"
+		local _object_1 = table.clone(state)
+		setmetatable(_object_1, nil)
+		_object_1.progress = math.max(0, state.progress - delta / 0.25)
+		_object[_left] = _object_1
+		_object.fire = false
+		_object.ended = false
+		return _object
+	end
+	local elapsed = state.elapsed + delta
+	if mode.kind == "Hold" then
+		local fire = not state.fired and elapsed >= mode.seconds
+		local _object = {}
+		local _left = "state"
+		local _object_1 = table.clone(state)
+		setmetatable(_object_1, nil)
+		_object_1.elapsed = elapsed
+		_object_1.fired = state.fired or fire
+		_object_1.progress = if state.fired or fire then 0 else math.min(1, elapsed / mode.seconds)
+		_object[_left] = _object_1
+		_object.fire = fire
+		_object.ended = false
+		return _object
+	end
+	if mode.kind == "Repeat" and elapsed >= state.nextRepeatAt then
+		local _object = {}
+		local _left = "state"
+		local _object_1 = table.clone(state)
+		setmetatable(_object_1, nil)
+		_object_1.elapsed = elapsed
+		_object_1.nextRepeatAt = elapsed + state.repeatInterval
+		_object_1.repeatInterval = math.max(0.04, state.repeatInterval * 0.85)
+		_object[_left] = _object_1
+		_object.fire = true
+		_object.ended = false
+		return _object
+	end
+	local _object = {}
+	local _left = "state"
+	local _object_1 = table.clone(state)
+	setmetatable(_object_1, nil)
+	_object_1.elapsed = elapsed
+	_object[_left] = _object_1
+	_object.fire = false
+	_object.ended = false
+	return _object
+end
+return {
+	idlePress = idlePress,
+	transition = transition,
+}

package/out/props.d.ts

@@ -0,0 +1,12 @@
+import type Vide from "@rbxts/vide";
+export type Value<T> = Vide.Derivable<T>;
+export type Getter<T> = () => T;
+export type Children = Vide.Node;
+export type ChildFactory = () => Vide.Node;
+export interface Placement {
+    name?: string;
+    layoutOrder?: number;
+    anchorPoint?: Value<Vector2>;
+    position?: Value<UDim2>;
+    zIndex?: Value<number>;
+}

package/out/props.luau

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v3.0.0
+return nil

package/out/runtime.d.ts

@@ -0,0 +1,30 @@
+import type { Value } from "./props";
+export type Owner = number | "Base";
+export declare const ownerContext: import("@rbxts/vide").Context<Owner>;
+export declare const closeFallbackContext: import("@rbxts/vide").Context<boolean>;
+export declare const modalOpen: import("@rbxts/charm").Getter<boolean>;
+export declare const selectedObject: import("@rbxts/charm").Atom<GuiObject | undefined>;
+export declare const textEditing: import("@rbxts/charm").Atom<boolean>;
+export declare const menuOpen: import("@rbxts/charm").Atom<boolean>;
+interface Control {
+    readonly owner: Owner;
+    readonly buttonADown?: (input: InputObject) => void;
+    readonly buttonAUp?: (input: InputObject) => void;
+}
+export declare function active(owner: Owner): boolean;
+export declare function openRoot(mode: "Native" | "Pointer", onClose?: () => void): number;
+export declare function attachRoot(id: number, root: GuiObject): () => void;
+export declare function closeRoot(id: number): void;
+export declare function registerControl(object: GuiObject, control: Control, fallback?: boolean): () => void;
+export declare function markControl(owner: Owner, object: GuiObject, marked: boolean): void;
+export declare function useSelection(options?: {
+    selectFirst?: Value<boolean>;
+    buttonADown?: (input: InputObject) => void;
+    buttonAUp?: (input: InputObject) => void;
+}): {
+    allowed: () => boolean;
+    selected: () => boolean;
+    action: (instance: GuiObject) => void;
+};
+export declare function startMenuRuntime(): () => void;
+export {};