@el4cteo/rbx-studio-mcp 0.3.1 → 0.3.5

package/plugin/src/Themes/Nebula.luau

@@ -0,0 +1,182 @@
+--!strict
+--[[
+	Nebula -- the pink one, and the only preset with no straight lines.
+
+	Soft blobs advected by a slow flow field, magenta through cyan. Every other
+	theme in the set draws edges, points or bars; this one draws nothing with a
+	corner in it, which is what makes it read as a different instrument rather
+	than as the same instrument recoloured.
+
+	The flow is a pair of sines sampled at each blob's position -- cheap, and
+	continuous, so neighbouring blobs drift in similar directions and the field
+	holds together instead of scattering. Blobs that leave the cell wrap back to
+	the far side rather than being respawned, so the field never thins out.
+
+	A reply blooms rather than flashes: the blobs swell and brighten over the
+	third of a second `flare` lasts. On a strip this small a hard flash reads as
+	a rendering fault; a bloom reads as something arriving.
+]]
+
+local Draw = require(script.Parent.Draw)
+local Theme = require(script.Parent.Theme)
+
+local BLOBS = 20
+
+local Nebula = {}
+
+Nebula.id = "nebula"
+Nebula.label = "Nebula"
+Nebula.blurb = "Drifting dust"
+
+Nebula.palette = {
+	background = Color3.fromRGB(19, 11, 24),
+	surface = Color3.fromRGB(30, 18, 38),
+	rule = Color3.fromRGB(236, 122, 196),
+	text = Color3.fromRGB(238, 214, 236),
+	dim = Color3.fromRGB(122, 96, 128),
+	green = Color3.fromRGB(142, 230, 196),
+	red = Color3.fromRGB(255, 122, 148),
+	amber = Color3.fromRGB(250, 190, 140),
+	cyan = Color3.fromRGB(134, 226, 240),
+	violet = Color3.fromRGB(226, 140, 236),
+}
+
+type Blob = {
+	frame: Frame,
+	position: Vector2,
+	-- Fixed per blob: size, how much of the magenta-to-cyan range it sits at,
+	-- and its own drift phase.
+	scale: number,
+	hue: number,
+	phase: number,
+}
+
+local blobs: { Blob } = {}
+local size = 40
+
+--[[
+	The flow field. Two sines crossed, which is enough structure to look like a
+	current and cheap enough to sample forty times a frame.
+
+	Time enters slowly. A field that changes as fast as the things moving
+	through it reads as noise; at this rate the current itself visibly turns
+	over about a minute, under blobs that take a few seconds to cross.
+]]
+local function flow(at: Vector2, clock: number): Vector2
+	local x = math.sin(at.Y * 0.16 + clock * 0.21)
+	local y = math.cos(at.X * 0.14 - clock * 0.17)
+	return Vector2.new(x, y)
+end
+
+function Nebula.mount(cell: Frame)
+	size = cell.AbsoluteSize.X
+	if size < 8 then
+		size = 40
+	end
+	local frames = Draw.pool(cell, BLOBS, "Blob", true)
+	blobs = {}
+	for index = 1, BLOBS do
+		blobs[index] = {
+			frame = frames[index],
+			position = Vector2.new(Draw.hash(index, 21) * size, Draw.hash(index, 22) * size),
+			scale = 0.4 + Draw.hash(index, 23) * 1.6,
+			hue = Draw.hash(index, 24),
+			phase = Draw.hash(index, 25) * math.pi * 2,
+		}
+	end
+end
+
+function Nebula.unmount()
+	blobs = {}
+end
+
+function Nebula.paint(ctx: Theme.Context, delta: number)
+	-- Clamped because Studio hands out long frames while it compiles, and an
+	-- unclamped step teleports the whole field across the cell in one of them.
+	local step = math.min(delta, 1 / 30)
+	local drift = 6 + ctx.energy * 22
+
+	for index = 1, #blobs do
+		local blob = blobs[index]
+		blob.position += flow(blob.position, ctx.clock + blob.phase) * drift * step
+
+		-- Wrapped rather than respawned. A blob that reappears at a random point
+		-- pops; one that comes back around the far edge is simply still moving.
+		local margin = 6
+		if blob.position.X < -margin then
+			blob.position = Vector2.new(size + margin, blob.position.Y)
+		elseif blob.position.X > size + margin then
+			blob.position = Vector2.new(-margin, blob.position.Y)
+		end
+		if blob.position.Y < -margin then
+			blob.position = Vector2.new(blob.position.X, size + margin)
+		elseif blob.position.Y > size + margin then
+			blob.position = Vector2.new(blob.position.X, -margin)
+		end
+
+		--[[
+			Breathing on the blob's own phase, so the cloud is never uniform.
+			The bloom on top of it is shared, which is what makes a reply read as
+			one event happening to the whole field rather than as twenty
+			independent flickers.
+		]]
+		local breathe = 0.85 + 0.15 * math.sin(ctx.clock * 0.8 + blob.phase)
+		local diameter = math.max(
+			2,
+			math.floor(blob.scale * 5 * breathe * ctx.scale + ctx.flare * 4)
+		)
+
+		local colour = ctx.palette.violet:Lerp(ctx.palette.cyan, blob.hue)
+		Draw.dot(
+			blob.frame,
+			blob.position,
+			diameter,
+			colour:Lerp(Color3.new(1, 1, 1), ctx.flare * 0.5),
+			--[[
+				Deliberately very transparent. Dust is only dust when the blobs
+				overlap into something denser than any one of them, and at any
+				less than this each blob reads as a discrete circle.
+			]]
+			math.clamp(0.82 - ctx.energy * 0.12 - ctx.flare * 0.25, 0, 1)
+		)
+	end
+end
+
+--[[
+	History as columns of dust lit from below rather than as bars.
+
+	Same data, same heights, but drawn with a rounded cap and no hard baseline,
+	so the trace belongs to the same picture as the cell.
+]]
+function Nebula.paintSlot(slot: Theme.Slot, ctx: Theme.Context)
+	local frame = slot.frame
+	local recency = 1 - slot.age
+	local height = math.max(2, math.floor(2 + slot.weight * 20))
+
+	frame.AnchorPoint = Vector2.new(0.5, 1)
+	frame.Size = UDim2.fromOffset(3, height)
+	frame.Position = UDim2.new(frame.Position.X.Scale, frame.Position.X.Offset, 1, 0)
+	frame.BackgroundColor3 = if slot.ok
+		then ctx.palette.violet:Lerp(ctx.palette.cyan, slot.weight)
+		else ctx.palette.red
+	frame.BackgroundTransparency = math.clamp(0.72 - recency * 0.6, 0, 1)
+	frame.Rotation = 0
+end
+
+function Nebula.swatch(frame: Frame, palette: Theme.Palette)
+	local pool = Draw.pool(frame, 12, "Blob", true)
+	for index = 1, 12 do
+		local x = 4 + Draw.hash(index, 31) * 32
+		local y = 3 + Draw.hash(index, 32) * 18
+		local hue = Draw.hash(index, 33)
+		Draw.dot(
+			pool[index],
+			Vector2.new(x, y),
+			4 + math.floor(Draw.hash(index, 34) * 6),
+			palette.violet:Lerp(palette.cyan, hue),
+			0.7
+		)
+	end
+end
+
+return Nebula

package/plugin/src/Themes/Observatory.luau

@@ -0,0 +1,200 @@
+--!strict
+--[[
+	Observatory -- AMOLED, and a session you can read as a sky.
+
+	The background is true #000000. On an OLED display those pixels are off, so
+	the panel has no edges at all and the console appears to float in the Studio
+	dock rather than sit in a box. That only works if the black is actually
+	black: a near-black at RGB(11, 12, 20) lights every pixel and the illusion
+	collapses, which is why this theme does not simply darken the default one.
+
+	The cell holds a star sphere instead of a prism -- points on a shell, turned
+	slowly and projected, twinkling on their own phases. It reads as depth
+	without a single straight line, which is the whole point of the contrast
+	with Lattice.
+
+	The trace is the reason the theme exists. Each finished call is a star whose
+	height is how slow it was and whose brightness fades as it ages, so forty
+	calls of history read as a constellation rather than as a bar chart. A
+	failure is a red giant: bigger, redder, and slower to fade, so the one thing
+	you actually want to find in a session's history is the one thing the eye
+	lands on first.
+]]
+
+local Draw = require(script.Parent.Draw)
+local Theme = require(script.Parent.Theme)
+
+-- Points on the shell. Enough to read as a field, few enough that every one of
+-- them is a Frame the paint loop touches every frame.
+local STARS = 26
+local FOCAL = 3.2
+local SHELL = 0.36
+
+local Observatory = {}
+
+Observatory.id = "observatory"
+Observatory.label = "Observatory"
+Observatory.blurb = "True black. Stars"
+
+Observatory.palette = {
+	-- Genuinely off, not merely dark. Every other colour here is chosen to hold
+	-- contrast against zero rather than against a lifted black.
+	background = Color3.fromRGB(0, 0, 0),
+	surface = Color3.fromRGB(8, 9, 12),
+	rule = Color3.fromRGB(148, 178, 214),
+	text = Color3.fromRGB(214, 224, 238),
+	dim = Color3.fromRGB(78, 88, 106),
+	green = Color3.fromRGB(126, 226, 176),
+	red = Color3.fromRGB(248, 122, 122),
+	amber = Color3.fromRGB(240, 196, 118),
+	cyan = Color3.fromRGB(150, 214, 240),
+	violet = Color3.fromRGB(176, 172, 236),
+}
+
+local stars: { Frame } = {}
+local meridian: { Frame } = {}
+
+--[[
+	A fixed point on the shell for star `index`.
+
+	Derived from the index rather than stored, and derived the same way every
+	frame -- a field that re-randomised itself per frame would boil rather than
+	drift.
+
+	Evenly spread rather than randomly placed. A hashed longitude and latitude
+	is the obvious way to do this and it produced a visibly lopsided sky: the
+	field bunched into one corner of the cell with an empty half beside it,
+	which reads as a rendering fault rather than as stars. Twinkle supplies the
+	irregularity instead, and it does it without leaving holes.
+]]
+local function starAt(index: number): Vector3
+	return Draw.sphere(index, STARS)
+end
+
+function Observatory.mount(cell: Frame)
+	-- The meridian sits under the stars so a bright point is never cut by the
+	-- line it happens to cross.
+	meridian = Draw.pool(cell, 24, "Meridian", true)
+	stars = Draw.pool(cell, STARS, "Star", true)
+end
+
+function Observatory.unmount()
+	stars = {}
+	meridian = {}
+end
+
+function Observatory.paint(ctx: Theme.Context, _delta: number)
+	local radius = ctx.size * SHELL * ctx.scale
+	-- A third of Lattice's rate. Stars that turn at a wireframe's pace read as
+	-- a spinning object; at this speed they read as a sky the panel is looking
+	-- out at, which is the difference the theme is trading on.
+	local angle = ctx.angle * 0.34
+
+	for index = 1, STARS do
+		local frame = stars[index]
+		if frame == nil then
+			continue
+		end
+		local point, depth = Draw.project(
+			Draw.rotate(starAt(index), angle),
+			FOCAL,
+			radius,
+			ctx.centre
+		)
+		local near = math.clamp((depth + 1) / 2, 0, 1)
+
+		--[[
+			Each star on its own phase and rate, so the field never pulses as one.
+
+			A shared clock would make the whole sphere breathe together, which
+			reads as the panel flickering rather than as stars twinkling. The
+			rates are deliberately irrational relative to each other.
+		]]
+		local twinkle = 0.5 + 0.5 * math.sin(ctx.clock * (0.7 + Draw.hash(index, 3) * 1.9)
+			+ Draw.hash(index, 4) * 9)
+
+		local brightness = near * 0.7 + twinkle * 0.3
+		Draw.dot(
+			frame,
+			point,
+			math.max(1, math.floor(1 + near * 2 + ctx.flare * 2)),
+			ctx.tint:Lerp(Color3.new(1, 1, 1), 0.3 + brightness * 0.6),
+			math.clamp(0.9 - brightness * 0.8 - ctx.flare * 0.4, 0, 1)
+		)
+	end
+
+	--[[
+		A great circle through the sphere: the horizon an observatory is aimed
+		along. Drawn as points rather than segments so it fades in and out with
+		depth like the stars do, instead of reading as a hard hoop drawn on top
+		of them.
+	]]
+	-- 1.05 rather than the 1.18 this started at: at full overshoot the wider
+	-- ring reached 21.5px from a centre with 20px of room, so the horizon was
+	-- sliced off by the cell's own clipping exactly when the session was busiest.
+	for index = 1, #meridian do
+		local frame = meridian[index]
+		local turn = (index / #meridian) * math.pi * 2
+		local point, depth = Draw.project(
+			Draw.rotate(Vector3.new(math.cos(turn), 0, math.sin(turn)), angle),
+			FOCAL,
+			radius * 1.05,
+			ctx.centre
+		)
+		local near = math.clamp((depth + 1) / 2, 0, 1)
+		Draw.dot(frame, point, 1, ctx.tint, math.clamp(0.94 - near * 0.35, 0, 1))
+	end
+end
+
+--[[
+	One call as a star rather than as a bar.
+
+	Height is duration, so a slow call sits high and the eye reads the skyline
+	as a latency profile without being told to. Brightness is recency, so the
+	newest calls are the ones that stand out and old history recedes on its own
+	rather than needing to be scrolled away.
+]]
+function Observatory.paintSlot(slot: Theme.Slot, ctx: Theme.Context)
+	local frame = slot.frame
+	local recency = 1 - slot.age
+
+	-- Failures ignore the height rule. A red giant is large because it failed,
+	-- not because it was slow, and conflating the two would hide a fast error
+	-- among fast successes at the bottom of the trace.
+	local size = if slot.ok
+		then math.max(2, math.floor(1.5 + slot.weight * 2.5 + recency * 1.5))
+		else math.max(4, math.floor(4 + recency * 2))
+
+	frame.AnchorPoint = Vector2.new(0.5, 0.5)
+	frame.Size = UDim2.fromOffset(size, size)
+	-- 0.12 keeps the newest star clear of the trace's top edge, and the 0.82
+	-- span leaves the baseline visible under the lowest one.
+	frame.Position = UDim2.new(frame.Position.X.Scale, frame.Position.X.Offset, 0.9 - slot.weight * 0.78, 0)
+	frame.BackgroundColor3 = if slot.ok
+		then ctx.palette.cyan:Lerp(Color3.new(1, 1, 1), 0.25 + recency * 0.4)
+		else ctx.palette.red
+	frame.BackgroundTransparency = if slot.ok
+		then math.clamp(0.72 - recency * 0.62, 0, 1)
+		-- Slower to fade than a success, so the failure in a session's history
+		-- is still legible forty calls later.
+		else math.clamp(0.45 - recency * 0.4, 0, 1)
+	frame.Rotation = 0
+end
+
+function Observatory.swatch(frame: Frame, palette: Theme.Palette)
+	local pool = Draw.pool(frame, 14, "Star", true)
+	for index = 1, 14 do
+		local x = 3 + Draw.hash(index, 11) * 34
+		local y = 3 + Draw.hash(index, 12) * 18
+		local bright = Draw.hash(index, 13)
+		Draw.dot(
+			pool[index],
+			Vector2.new(x, y),
+			if bright > 0.85 then 3 else 1 + math.floor(bright * 2),
+			palette.cyan:Lerp(Color3.new(1, 1, 1), bright * 0.7),
+			0.85 - bright * 0.7
+		)
+	end
+end
+
+return Observatory

package/plugin/src/Themes/Orbit.luau

@@ -0,0 +1,268 @@
+--!strict
+--[[
+	Orbit -- the only preset that reports something the others cannot.
+
+	A body at the centre with satellites running elliptical paths around it. The
+	number of satellites is the session's activity, so where Lattice climbs a
+	ladder of shapes to say "busy", this says it in a way you can count: one
+	moon is a quiet session, five is a burst.
+
+	The ellipses are a projected circle rather than a drawn oval, so the whole
+	system tilts as the angle turns and a satellite genuinely passes behind the
+	body -- it dims and shrinks on the far side because it is further away. That
+	is what stops it reading as a loading spinner with extra dots.
+
+	Colour is warm here on purpose. Every other dark preset in the set leans
+	blue or violet; a gold system against navy is the one that looks like an
+	instrument rather than a screensaver.
+]]
+
+local Draw = require(script.Parent.Draw)
+local Theme = require(script.Parent.Theme)
+
+-- Satellites are pooled at the maximum and hidden when the session is calm, so
+-- activity changes what is visible rather than what exists.
+local MOONS = 6
+local PATH_DOTS = 28
+local FOCAL = 3.2
+
+--[[
+	How far the orbits reach, as a multiple of the body's radius.
+
+	Chosen so the outermost satellite sits about 18px from a centre with 20px of
+	room: filling the cell, with just enough margin that it never touches the
+	clip. Two earlier values were both wrong for the same underlying reason --
+	2.4 threw the sixth moon 26px out when busy, and 1.5 fixed the clipping by
+	making the whole system too small to read.
+]]
+local ORBIT_SCALE = 1.95
+
+--[[
+	How much of the scale spring the ORBITS take. Almost none.
+
+	The spring swings 0.82 to 1.20, and letting the satellites carry that meant
+	the system had to rest small enough that its overshoot still fit -- so it
+	was sized by its worst moment rather than by the one you spend all your time
+	looking at. The body and the halo carry the spring instead: they sit at the
+	centre with room to grow, and a struck object whose middle flexes reads the
+	same as one that flexes all over.
+]]
+local ORBIT_BREATH = 0.08
+
+local Orbit = {}
+
+Orbit.id = "orbit"
+Orbit.label = "Orbit"
+Orbit.blurb = "Body and satellites"
+
+Orbit.palette = {
+	background = Color3.fromRGB(10, 13, 22),
+	surface = Color3.fromRGB(17, 22, 36),
+	rule = Color3.fromRGB(240, 186, 108),
+	text = Color3.fromRGB(226, 222, 210),
+	dim = Color3.fromRGB(96, 100, 116),
+	green = Color3.fromRGB(134, 214, 158),
+	red = Color3.fromRGB(240, 130, 116),
+	amber = Color3.fromRGB(246, 190, 106),
+	cyan = Color3.fromRGB(132, 196, 226),
+	violet = Color3.fromRGB(196, 164, 226),
+}
+
+local body: Frame? = nil
+local halo: Frame? = nil
+local moons: { Frame } = {}
+local path: { Frame } = {}
+
+--[[
+	Orbital parameters for satellite `index`.
+
+	Fixed per index so a moon keeps its own path for the life of the session --
+	re-rolling them would make the system reshuffle every frame. Radius rises
+	with the index so the moons never share an orbit, and the inclination is
+	what makes the paths cross rather than sit in one flat ring.
+]]
+local function orbitOf(index: number): (number, number, number)
+	-- Tightened from `0.42 + index * 0.1`, which put the sixth moon at 1.02 and
+	-- 26px from a centre with 20px of room -- so the satellite that only appears
+	-- when the session is busiest was the one that flew off the edge.
+	local radius = 0.34 + index * 0.055
+	local speed = 1.5 / (radius * 2.4)
+	local inclination = (Draw.hash(index, 5) - 0.5) * 1.6
+	return radius, speed, inclination
+end
+
+function Orbit.mount(cell: Frame)
+	path = Draw.pool(cell, PATH_DOTS, "Path", true)
+
+	local disc = Instance.new("Frame")
+	disc.Name = "Halo"
+	disc.AnchorPoint = Vector2.new(0.5, 0.5)
+	disc.BorderSizePixel = 0
+	disc.Parent = cell
+	local haloCorner = Instance.new("UICorner")
+	haloCorner.CornerRadius = UDim.new(1, 0)
+	haloCorner.Parent = disc
+	halo = disc
+
+	local core = Instance.new("Frame")
+	core.Name = "Body"
+	core.AnchorPoint = Vector2.new(0.5, 0.5)
+	core.BorderSizePixel = 0
+	core.Parent = cell
+	local coreCorner = Instance.new("UICorner")
+	coreCorner.CornerRadius = UDim.new(1, 0)
+	coreCorner.Parent = core
+	body = core
+
+	-- Last, so a near satellite passes in front of the body it orbits.
+	moons = Draw.pool(cell, MOONS, "Moon", true)
+end
+
+function Orbit.unmount()
+	body = nil
+	halo = nil
+	moons = {}
+	path = {}
+end
+
+function Orbit.paint(ctx: Theme.Context, _delta: number)
+	local breath = (1 - ORBIT_BREATH) + ctx.scale * ORBIT_BREATH
+	local radius = ctx.size * 0.34 * breath
+	local core = body
+	local glow = halo
+
+	if core ~= nil then
+		--[[
+			Amber, not the status tint.
+
+			Every other preset paints its cell in `ctx.tint` so the panel reads as
+			disconnected at a glance. Orbit cannot: the tint is green while
+			connected, so the body came out green while the drawer previewed it in
+			gold, and the preview is a promise. The HALO carries the status colour
+			instead -- same information, on the part of the scene that is supposed
+			to change.
+		]]
+		local size = math.max(5, math.floor(7.5 * ctx.scale + ctx.flare * 3))
+		Draw.dot(
+			core,
+			ctx.centre,
+			size,
+			ctx.palette.amber:Lerp(Color3.new(1, 1, 1), 0.3 + ctx.flare * 0.5),
+			0
+		)
+	end
+	if glow ~= nil then
+		-- A halo that grows with energy rather than a body that does: the body
+		-- staying put is what gives the satellites something fixed to orbit.
+		local size = math.max(10, math.floor(13 * ctx.scale + ctx.energy * 8 + ctx.flare * 6))
+		Draw.dot(glow, ctx.centre, size, ctx.tint, math.clamp(0.9 - ctx.flare * 0.35, 0, 1))
+	end
+
+	--[[
+		The innermost path, drawn as points so it fades with depth.
+
+		Only one path is drawn even though there are six orbits. Six rings turns
+		the cell into a scribble at forty pixels across; one ring establishes
+		that these things are orbiting and the rest is left to the motion.
+	]]
+	local pathRadius, _, pathTilt = orbitOf(1)
+	for index = 1, PATH_DOTS do
+		local frame = path[index]
+		local turn = (index / PATH_DOTS) * math.pi * 2
+		local local3 = Vector3.new(
+			math.cos(turn) * pathRadius,
+			math.sin(turn) * pathRadius * math.sin(pathTilt),
+			math.sin(turn) * pathRadius * math.cos(pathTilt)
+		)
+		local point, depth = Draw.project(
+			Draw.rotate(local3, ctx.angle * 0.5),
+			FOCAL,
+			radius * ORBIT_SCALE,
+			ctx.centre
+		)
+		local near = math.clamp((depth + 1) / 2, 0, 1)
+		Draw.dot(frame, point, 1, ctx.palette.dim, math.clamp(0.78 - near * 0.3, 0, 1))
+	end
+
+	--[[
+		How many satellites are up. Activity runs 0..1 over about ten seconds,
+		so this climbs through the pool as a burst lands and drops back as it
+		unwinds -- which is the readout the theme exists for.
+	]]
+	local visible = 1 + math.floor(math.clamp(ctx.activity, 0, 1) * (MOONS - 1) + 0.5)
+
+	for index = 1, MOONS do
+		local frame = moons[index]
+		if frame == nil then
+			continue
+		end
+		if index > visible then
+			frame.Visible = false
+			continue
+		end
+
+		local orbitRadius, speed, tilt = orbitOf(index)
+		-- Phase offset per moon so they do not launch from the same point and
+		-- travel as a clump.
+		local turn = ctx.clock * speed + Draw.hash(index, 6) * math.pi * 2
+		local local3 = Vector3.new(
+			math.cos(turn) * orbitRadius,
+			math.sin(turn) * orbitRadius * math.sin(tilt),
+			math.sin(turn) * orbitRadius * math.cos(tilt)
+		)
+		local point, depth = Draw.project(
+			Draw.rotate(local3, ctx.angle * 0.5),
+			FOCAL,
+			radius * ORBIT_SCALE,
+			ctx.centre
+		)
+		local near = math.clamp((depth + 1) / 2, 0, 1)
+		Draw.dot(
+			frame,
+			point,
+			math.max(2, math.floor(2.5 + near * 2.5 + ctx.flare * 1.5)),
+			ctx.palette.amber:Lerp(Color3.new(1, 1, 1), near * 0.4 + ctx.flare * 0.3),
+			math.clamp(0.35 - near * 0.32 - ctx.flare * 0.3, 0, 1)
+		)
+	end
+end
+
+--[[
+	History as a run of moons at their apoapsis: a dot per call, high when slow.
+
+	Bars would be the obvious choice and are wrong here -- a rectangle sitting
+	on a baseline has nothing to do with the rest of the scene, and the trace
+	and the cell would read as two unrelated instruments sharing a strip.
+]]
+function Orbit.paintSlot(slot: Theme.Slot, ctx: Theme.Context)
+	local frame = slot.frame
+	local recency = 1 - slot.age
+
+	frame.AnchorPoint = Vector2.new(0.5, 0.5)
+	local size = math.max(2, math.floor(2 + slot.weight * 3 + recency))
+	frame.Size = UDim2.fromOffset(size, size)
+	frame.Position = UDim2.new(frame.Position.X.Scale, frame.Position.X.Offset, 0.88 - slot.weight * 0.74, 0)
+	frame.BackgroundColor3 = if slot.ok then ctx.palette.amber else ctx.palette.red
+	frame.BackgroundTransparency = math.clamp((if slot.ok then 0.7 else 0.35) - recency * 0.55, 0, 1)
+	frame.Rotation = 0
+end
+
+function Orbit.swatch(frame: Frame, palette: Theme.Palette)
+	local centre = Vector2.new(20, 12)
+	local ring = Draw.pool(frame, 20, "Path", true)
+	for index = 1, 20 do
+		local turn = (index / 20) * math.pi * 2
+		Draw.dot(
+			ring[index],
+			centre + Vector2.new(math.cos(turn) * 13, math.sin(turn) * 5.5),
+			1,
+			palette.dim,
+			0.6
+		)
+	end
+	local pool = Draw.pool(frame, 2, "Body", true)
+	Draw.dot(pool[1], centre, 7, palette.amber:Lerp(Color3.new(1, 1, 1), 0.3), 0)
+	Draw.dot(pool[2], centre + Vector2.new(13, -1), 3, palette.amber, 0.1)
+end
+
+return Orbit