@el4cteo/rbx-studio-mcp 0.3.1 → 0.3.6

package/plugin/src/Themes/Lattice.luau

@@ -0,0 +1,304 @@
+--!strict
+--[[
+	Lattice -- the default.
+
+	A turning wireframe solid with a counter-rotating core, over a bar trace of
+	the last forty calls. This is the console's original look, and it stays the
+	default because it is the most legible of the eight: hard edges, one accent
+	colour, nothing moving that is not reporting something.
+
+	The solid is a real projection rather than a canned loop. Vertices rotate in
+	three dimensions and pass through a perspective divide every frame, so near
+	edges are brighter and thicker because they genuinely are nearer, and the
+	shape climbs a ladder -- tetrahedron, octahedron, cube, icosahedron -- as the
+	session gets busier. An idle plugin shows four vertices; a working one shows
+	twelve. The shape itself is the load meter.
+]]
+
+local Draw = require(script.Parent.Draw)
+local Theme = require(script.Parent.Theme)
+
+local PHI = (1 + math.sqrt(5)) / 2
+
+type Shape = {
+	name: string,
+	vertices: { Vector3 },
+	edges: { { number } },
+}
+
+--[[
+	Ordered by how busy they look. The session climbs this list as it works, so
+	the shape itself reports load: an idle plugin shows a tetrahedron, a busy one
+	an icosahedron.
+]]
+local SHAPES: { Shape } = {
+	{
+		name = "tetrahedron",
+		vertices = {
+			Vector3.new(1, 1, 1),
+			Vector3.new(1, -1, -1),
+			Vector3.new(-1, 1, -1),
+			Vector3.new(-1, -1, 1),
+		},
+		edges = { { 1, 2 }, { 1, 3 }, { 1, 4 }, { 2, 3 }, { 2, 4 }, { 3, 4 } },
+	},
+	{
+		name = "octahedron",
+		vertices = {
+			Vector3.new(1, 0, 0),
+			Vector3.new(-1, 0, 0),
+			Vector3.new(0, 1, 0),
+			Vector3.new(0, -1, 0),
+			Vector3.new(0, 0, 1),
+			Vector3.new(0, 0, -1),
+		},
+		edges = {
+			{ 1, 3 }, { 1, 4 }, { 1, 5 }, { 1, 6 },
+			{ 2, 3 }, { 2, 4 }, { 2, 5 }, { 2, 6 },
+			{ 3, 5 }, { 5, 4 }, { 4, 6 }, { 6, 3 },
+		},
+	},
+	{
+		name = "cube",
+		vertices = {
+			Vector3.new(-1, -1, -1), Vector3.new(1, -1, -1),
+			Vector3.new(1, 1, -1), Vector3.new(-1, 1, -1),
+			Vector3.new(-1, -1, 1), Vector3.new(1, -1, 1),
+			Vector3.new(1, 1, 1), Vector3.new(-1, 1, 1),
+		},
+		edges = {
+			{ 1, 2 }, { 2, 3 }, { 3, 4 }, { 4, 1 },
+			{ 5, 6 }, { 6, 7 }, { 7, 8 }, { 8, 5 },
+			{ 1, 5 }, { 2, 6 }, { 3, 7 }, { 4, 8 },
+		},
+	},
+	{
+		name = "icosahedron",
+		vertices = {
+			Vector3.new(0, 1, PHI), Vector3.new(0, -1, PHI),
+			Vector3.new(0, 1, -PHI), Vector3.new(0, -1, -PHI),
+			Vector3.new(1, PHI, 0), Vector3.new(-1, PHI, 0),
+			Vector3.new(1, -PHI, 0), Vector3.new(-1, -PHI, 0),
+			Vector3.new(PHI, 0, 1), Vector3.new(PHI, 0, -1),
+			Vector3.new(-PHI, 0, 1), Vector3.new(-PHI, 0, -1),
+		},
+		edges = {
+			{ 1, 2 }, { 1, 5 }, { 1, 6 }, { 1, 9 }, { 1, 11 },
+			{ 2, 7 }, { 2, 8 }, { 2, 9 }, { 2, 11 },
+			{ 3, 4 }, { 3, 5 }, { 3, 6 }, { 3, 10 }, { 3, 12 },
+			{ 4, 7 }, { 4, 8 }, { 4, 10 }, { 4, 12 },
+			{ 5, 6 }, { 5, 9 }, { 5, 10 },
+			{ 6, 11 }, { 6, 12 },
+			{ 7, 8 }, { 7, 9 }, { 7, 10 },
+			{ 8, 11 }, { 8, 12 },
+			{ 9, 10 }, { 11, 12 },
+		},
+	},
+}
+
+local MAX_EDGES = 30
+local MAX_VERTICES = 12
+local FOCAL = 3.4
+
+-- The inner solid, counter-rotating inside the outer one. An octahedron
+-- regardless of what is outside it: it reads as a core rather than as a second
+-- object competing for attention, and its 12 edges are cheap.
+local INNER_SHAPE = 2
+local INNER_SCALE = 0.42
+
+-- The solid's resting radius as a fraction of the cell. At full overshoot the
+-- perspective divide pushes a near vertex to roughly 15px, which still clears
+-- the cell's half-width.
+local BASE_RADIUS = 0.185
+
+local Lattice = {}
+
+Lattice.id = "lattice"
+Lattice.label = "Lattice"
+Lattice.blurb = "Wireframe solid"
+
+Lattice.palette = {
+	-- Violet-tinted near-black. The cast is slight but it stops the panel
+	-- reading as the same grey as every other Studio dock.
+	background = Color3.fromRGB(11, 12, 20),
+	surface = Color3.fromRGB(18, 20, 31),
+	rule = Color3.fromRGB(167, 139, 250),
+	text = Color3.fromRGB(206, 212, 226),
+	dim = Color3.fromRGB(90, 97, 120),
+	green = Color3.fromRGB(110, 231, 168),
+	red = Color3.fromRGB(251, 113, 133),
+	amber = Color3.fromRGB(251, 191, 36),
+	cyan = Color3.fromRGB(103, 232, 249),
+	violet = Color3.fromRGB(167, 139, 250),
+}
+
+local edges: { Frame } = {}
+local innerEdges: { Frame } = {}
+local dots: { Frame } = {}
+
+function Lattice.mount(cell: Frame)
+	edges = Draw.pool(cell, MAX_EDGES, "Edge", false)
+	innerEdges = Draw.pool(cell, #SHAPES[INNER_SHAPE].edges, "Inner", false)
+	-- Built after the edges so the lit corners sit over the strokes they join.
+	dots = Draw.pool(cell, MAX_VERTICES, "Vertex", true)
+end
+
+function Lattice.unmount()
+	edges = {}
+	innerEdges = {}
+	dots = {}
+end
+
+function Lattice.paint(ctx: Theme.Context, _delta: number)
+	local shapeIndex = math.clamp(1 + math.floor(ctx.activity * (#SHAPES - 0.001)), 1, #SHAPES)
+	local shape = SHAPES[shapeIndex]
+	local radius = ctx.size * BASE_RADIUS * ctx.scale
+
+	-- Wobble the axis rather than the panel: shaking the strip would read as a
+	-- glitch, tilting the solid reads as it being knocked.
+	local wobble = if ctx.shake > 0
+		then Vector3.new(
+			math.sin(ctx.clock * 37) * ctx.shake * 0.12,
+			math.cos(ctx.clock * 29) * ctx.shake * 0.12,
+			0
+		)
+		else Vector3.zero
+
+	local projected: { Vector2 } = {}
+	local depths: { number } = {}
+	for index, vertex in shape.vertices do
+		local point, depth = Draw.project(
+			Draw.rotate(vertex, ctx.angle + wobble),
+			FOCAL,
+			radius,
+			ctx.centre
+		)
+		projected[index] = point
+		depths[index] = depth
+	end
+
+	for index = 1, MAX_EDGES do
+		local frame = edges[index]
+		if frame == nil then
+			continue
+		end
+		local edge = shape.edges[index]
+		if edge == nil then
+			frame.Visible = false
+			continue
+		end
+		local a, b = edge[1], edge[2]
+		local depth = math.clamp(((depths[a] + depths[b]) / 2 + 2) / 4, 0, 1)
+		Draw.edge(
+			frame,
+			projected[a],
+			projected[b],
+			math.max(1, math.floor(1 + depth * 1.6 + ctx.flare * 0.8)),
+			ctx.tint:Lerp(Color3.new(1, 1, 1), depth * 0.35 + ctx.flare * 0.3),
+			math.max(0, 0.84 - depth * 0.74 - ctx.flare * 0.3)
+		)
+	end
+
+	--[[
+		Vertices as points, brighter than the edges they join.
+
+		Wireframes read as flat when every stroke is the same weight. Lighting
+		the corners gives the eye something to track as the solid turns, which is
+		what makes it read as rotating rather than merely flickering.
+	]]
+	for index = 1, MAX_VERTICES do
+		local dot = dots[index]
+		if dot == nil then
+			continue
+		end
+		local point = projected[index]
+		if point == nil then
+			dot.Visible = false
+			continue
+		end
+		local depth = math.clamp((depths[index] + 2) / 4, 0, 1)
+		-- The corners carry the flare. A pulse of light travelling through the
+		-- vertices is what makes a completed call land as an event rather than
+		-- as a bar quietly appearing somewhere off to the right.
+		Draw.dot(
+			dot,
+			point,
+			math.max(2, math.floor(1.5 + depth * 2.5 + ctx.flare * 2.5)),
+			ctx.tint:Lerp(Color3.new(1, 1, 1), 0.25 + depth * 0.5),
+			math.max(0, 0.55 - depth * 0.5 - ctx.flare * 0.45)
+		)
+	end
+
+	--[[
+		A second solid inside the first, turning the other way.
+
+		One rotating outline is a loading spinner. Two, at different rates and
+		opposite directions, read as a mechanism -- and the counter-rotation
+		makes the outer solid's direction obvious, which a lone wireframe hides
+		whenever it passes through a symmetrical angle.
+	]]
+	local inner = SHAPES[INNER_SHAPE]
+	local innerAngle = -ctx.angle * 1.6
+	local innerProjected: { Vector2 } = {}
+	local innerDepths: { number } = {}
+	for index, vertex in inner.vertices do
+		local point, depth = Draw.project(
+			Draw.rotate(vertex, innerAngle),
+			FOCAL,
+			radius * INNER_SCALE,
+			ctx.centre
+		)
+		innerProjected[index] = point
+		innerDepths[index] = depth
+	end
+	for index, frame in innerEdges do
+		local edge = inner.edges[index]
+		if edge == nil then
+			frame.Visible = false
+			continue
+		end
+		local a, b = edge[1], edge[2]
+		local depth = math.clamp(((innerDepths[a] + innerDepths[b]) / 2 + 2) / 4, 0, 1)
+		Draw.edge(
+			frame,
+			innerProjected[a],
+			innerProjected[b],
+			1,
+			ctx.tint:Lerp(Color3.new(1, 1, 1), 0.5),
+			0.9 - depth * 0.35
+		)
+	end
+end
+
+--[[
+	A still cube, which is the shape people recognise the console by, drawn at a
+	three-quarter angle so all three dimensions are visible at once.
+]]
+function Lattice.swatch(frame: Frame, palette: Theme.Palette)
+	local centre = Vector2.new(20, 12)
+	local pool = Draw.pool(frame, 12, "Edge", false)
+	local shape = SHAPES[3]
+	local angle = Vector3.new(0.5, 0.7, 0)
+
+	local projected: { Vector2 } = {}
+	local depths: { number } = {}
+	for index, vertex in shape.vertices do
+		local point, depth = Draw.project(Draw.rotate(vertex, angle), FOCAL, 5.5, centre)
+		projected[index] = point
+		depths[index] = depth
+	end
+	for index, edge in shape.edges do
+		local a, b = edge[1], edge[2]
+		local depth = math.clamp(((depths[a] + depths[b]) / 2 + 2) / 4, 0, 1)
+		Draw.edge(
+			pool[index],
+			projected[a],
+			projected[b],
+			1,
+			palette.violet:Lerp(Color3.new(1, 1, 1), depth * 0.4),
+			0.75 - depth * 0.6
+		)
+	end
+end
+
+return Lattice

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