robot-heads-solid 0.1.0 → 0.2.0

package/dist/solid2.server.js

@@ -0,0 +1,532 @@
+import { ssrElement as e } from "@solidjs/web";
+import { createSignal as t, createTrackedEffect as n, createUniqueId as r, omit as i, onSettled as a } from "solid-js";
+var o = [
+	"idle",
+	"thinking",
+	"searching",
+	"listening",
+	"speaking",
+	"working",
+	"happy",
+	"error",
+	"sleeping"
+], s = [
+	"rectangle",
+	"square",
+	"circle",
+	"hexagon"
+], c = {
+	bevel: .075,
+	margin: .045,
+	gasket: .022,
+	recess: .03,
+	earY: .03,
+	stem: .2,
+	ball: .052
+}, l = {
+	plate: c.bevel,
+	hole: c.bevel + c.margin,
+	glass: c.bevel + c.margin + c.gasket
+}, u = Math.PI * 2;
+function d(e, t, n, r, i, a) {
+	let o = t.map(([e, t]) => ({
+		x: e,
+		y: t,
+		t: Math.atan2(t, e)
+	})).sort((e, t) => e.t - t.t), s = o.length, d = [];
+	for (let e = 0; e < s; e++) {
+		let t = o[e], n = o[(e + 1) % s];
+		d.push(Math.atan2(-(n.x - t.x), n.y - t.y));
+	}
+	let f = o.map((e, t) => {
+		if (s === 1) return {
+			x: e.x,
+			y: e.y,
+			a0: -Math.PI,
+			a1: Math.PI
+		};
+		let n = d[(t - 1 + s) % s], r = d[t];
+		for (; r < n;) r += u;
+		return {
+			x: e.x,
+			y: e.y,
+			a0: n,
+			a1: r
+		};
+	}), m = (e, t) => {
+		if (s === 1) return Math.hypot(e - o[0].x, t - o[0].y);
+		let n = Infinity, r = !0;
+		for (let i = 0; i < s; i++) {
+			let a = o[i], c = o[(i + 1) % s], l = c.x - a.x, u = c.y - a.y, d = e - a.x, f = t - a.y, p = Math.max(0, Math.min(1, (d * l + f * u) / (l * l + u * u)));
+			n = Math.min(n, Math.hypot(d - l * p, f - u * p)), l * f - u * d < 0 && (r = !1);
+		}
+		return r ? -n : n;
+	}, h = (e, t, r) => m(e, t) - (n - r), g = (e, t) => {
+		let r = Math.max(5e-4, n - t);
+		f.forEach((t, n) => {
+			n === 0 && e.moveTo(t.x + r * Math.cos(t.a0), t.y + r * Math.sin(t.a0)), e.arc(t.x, t.y, r, t.a0, t.a1);
+		}), e.closePath();
+	}, _ = 0, v = 0;
+	for (let e of o) _ = Math.max(_, Math.abs(e.x) + n), v = Math.max(v, Math.abs(e.y) + n);
+	let y = 0, b = _ + .1;
+	for (let e = 0; e < 40; e++) {
+		let e = (y + b) / 2;
+		h(e, c.earY, 0) < 0 ? y = e : b = e;
+	}
+	let x = (e, t) => e.map((e, r) => {
+		let i = e * Math.PI / 180, a = f.find((e) => [
+			i,
+			i + u,
+			i - u
+		].some((t) => t >= e.a0 - 1e-6 && t <= e.a1 + 1e-6)) ?? f[0];
+		return [
+			a.x + Math.cos(i) * (n - t),
+			a.y + Math.sin(i) * (n - t),
+			.5 + r * .9
+		];
+	}), S = 2 * (_ - l.glass), C = 2 * (v - l.glass), w = Math.min(p * S / 14, .65 * C / 10);
+	return {
+		name: e,
+		r: n,
+		depth: r,
+		corners: f,
+		hx: _,
+		hy: v,
+		pitch: w,
+		earX: y - .008,
+		screws: x(i, (l.hole - .018 + l.plate) / 2),
+		backScrews: x(a, l.plate + .07),
+		sd: h,
+		path: g
+	};
+}
+var f = (e) => [
+	0,
+	60,
+	120,
+	180,
+	240,
+	300
+].map((t) => [e * Math.cos(t * Math.PI / 180), e * Math.sin(t * Math.PI / 180)]), p = .6, m = [45, 135], h = [
+	-135,
+	-45,
+	45,
+	135
+], g = {
+	rectangle: () => d("rectangle", [
+		[-.29, -.17],
+		[.29, -.17],
+		[.29, .17],
+		[-.29, .17]
+	], .21, .6, m, h),
+	square: () => d("square", [
+		[-.22, -.22],
+		[.22, -.22],
+		[.22, .22],
+		[-.22, .22]
+	], .2, .6, m, h),
+	circle: () => d("circle", [[0, 0]], .46, .56, m, h),
+	hexagon: () => d("hexagon", f(.35), .16, .58, [60, 120], [
+		-120,
+		-60,
+		60,
+		120
+	])
+}, _ = /* @__PURE__ */ new Map();
+function v(e) {
+	let t = _.get(e);
+	return t || (t = (g[e] ?? g.rectangle)(), _.set(e, t)), t;
+}
+//#endregion
+//#region ../src/tv/sim.ts
+var y = class {
+	x = 0;
+	v = 0;
+	constructor(e = 0) {
+		this.x = e;
+	}
+	step(e, t, n, r) {
+		let i = n * Math.PI * 2;
+		this.v += (i * i * (e - this.x) - 2 * r * i * this.v) * t, this.x += this.v * t;
+	}
+};
+function b(e) {
+	let t = Math.floor(e * 4294967295) >>> 0 || 1;
+	return () => {
+		t = t + 1831565813 >>> 0;
+		let e = t;
+		return e = Math.imul(e ^ e >>> 15, e | 1), e ^= e + Math.imul(e ^ e >>> 7, e | 61), ((e ^ e >>> 14) >>> 0) / 4294967296;
+	};
+}
+var x = (e, t, n) => Math.min(n, Math.max(t, e)), S = (e) => e < .5 ? 4 * e * e * e : 1 - (-2 * e + 2) ** 3 / 2, C = .11, w = class {
+	state;
+	shown;
+	previous;
+	switched = 10;
+	age = 0;
+	time = 0;
+	since = 0;
+	pose = {
+		yaw: 0,
+		pitch: 0,
+		roll: 0,
+		x: 0,
+		lift: 0,
+		sx: 1,
+		sy: 1,
+		antennaX: 0,
+		antennaZ: 0
+	};
+	face;
+	pointer = null;
+	yaw = new y();
+	pitch = new y();
+	roll = new y();
+	sway = new y();
+	squash = new y();
+	antX = new y();
+	antZ = new y();
+	lastV = {
+		roll: 0,
+		pitch: 0,
+		sway: 0
+	};
+	jump = null;
+	random;
+	lookAt = {
+		yaw: 0,
+		pitch: 0,
+		x: 0,
+		y: 0
+	};
+	nextLook = .6;
+	nextBlink = 1.5;
+	blinkAge = -1;
+	nextHop = 8;
+	nextSide = 4;
+	reactUntil = -1;
+	nextNod = 2.5;
+	constructor(e, t) {
+		this.random = b(e), this.state = this.shown = this.previous = t, this.face = {
+			lookX: 0,
+			lookY: 0,
+			blink: 0,
+			time: 0,
+			side: 1,
+			seed: e
+		}, this.nextBlink = 1 + this.random() * 3, this.nextHop = 6 + this.random() * 6;
+	}
+	setState(e) {
+		e !== this.state && (this.state = e, this.since = 0, this.nextLook = 0, this.nextHop = this.time + (e === "happy" ? .2 : 3 + this.random() * 4), e === "happy" && this.hop(.22, 1));
+	}
+	poke() {
+		this.hop(.24, this.random() < .5 ? 1 : -1), this.reactUntil = this.time + 1.6;
+	}
+	hop(e, t) {
+		this.jump ||= {
+			age: 0,
+			height: e,
+			spin: t,
+			lean: (this.random() - .5) * .3,
+			air: .42 + e * .45,
+			landed: !1
+		};
+	}
+	update(e) {
+		if (!Number.isFinite(e) || !(e > 0)) return;
+		let t = Math.min(e, .8), n = Math.max(1, Math.ceil(t / (1 / 120)));
+		for (let e = 0; e < n; e++) this.step(t / n);
+	}
+	stepJump(e) {
+		let t = 0, n = 0, r = 0, i = 0, a = this.jump, o = this.random;
+		if (a) {
+			if (a.age += e, a.age < C) i = .14;
+			else {
+				let e = (a.age - C) / a.air;
+				e < 1 ? (e < .06 && this.squash.x > .05 && (this.squash.v = -2.6, this.antZ.v -= 3), t = 4 * a.height * e * (1 - e), n = a.spin * Math.PI * 2 * S(x(e * 1.08, 0, 1)), r = a.lean * Math.sin(e * Math.PI), i = e < .5 ? -.05 : 0) : a.landed ? a.age - C - a.air > .35 && (this.jump = null) : (a.landed = !0, this.squash.v += 3.2, this.antX.v += (o() < .5 ? -1 : 1) * (2.5 + o() * 2), this.antZ.v += 3.5);
+			}
+		}
+		return this.squash.step(i, e, 3.2, .32), {
+			lift: t,
+			spin: n,
+			lean: r
+		};
+	}
+	hopWithChance(e, t) {
+		this.hop(e, this.random() < t ? this.random() < .5 ? 1 : -1 : 0);
+	}
+	updateLookAt(e) {
+		if (e > this.nextLook) {
+			let t = this.random;
+			this.lookAt = {
+				yaw: (t() - .5) * .75,
+				pitch: (t() - .5) * .24,
+				x: 0,
+				y: 0
+			}, this.lookAt.x = x(Math.round(this.lookAt.yaw * 5), -2, 2), this.lookAt.y = t() < .3 ? -1 : +(t() < .2), this.nextLook = e + 1.4 + t() * 2.6;
+		}
+	}
+	stateTargets(e) {
+		let t = this.random, n = 0, r = 0, i = 0, a = Math.sin(e * 1.9) * .008, o = 0, s = 0, c = 1.3, l = .62, u = 0;
+		switch (this.state) {
+			case "idle":
+				n = this.lookAt.yaw, r = this.lookAt.pitch, i = -this.lookAt.yaw * .16, o = this.lookAt.x, s = this.lookAt.y, e > this.nextHop && (this.hopWithChance(.15 + t() * .07, .35), this.nextHop = e + 7 + t() * 7);
+				break;
+			case "thinking": {
+				e > this.nextSide && (this.face.side = -this.face.side, this.nextSide = e + 3 + t() * 2);
+				let a = this.face.side;
+				n = .24 * a + Math.sin(e * .9) * .05, r = .17 + Math.sin(e * 1.3) * .03, i = -.13 * a, c = .9;
+				break;
+			}
+			case "searching": {
+				let t = e * 1.6;
+				n = Math.sin(t) * .55, r = -.04 + Math.sin(t * 2) * .04, i = Math.sin(t) * -.06, o = x(Math.sin(t + .4) * 3, -3, 3), c = 2.2, l = .8;
+				break;
+			}
+			case "listening":
+				n = -.14, r = .02, i = .17, e > this.nextNod && (this.pitch.v -= .9, this.nextNod = e + 2 + t() * 2.5);
+				break;
+			case "speaking":
+				n = Math.sin(e * .7) * .12, r = .03 + Math.sin(e * 6.3) * .025 * (.5 + .5 * Math.sin(e * 2.1)), i = Math.sin(e * .9) * .05, a += Math.abs(Math.sin(e * 6.3)) * .01, c = 1.8;
+				break;
+			case "working":
+				n = Math.sin(e * .8) * .08, r = -.16, i = Math.sin(e * .5) * .04, a += Math.abs(Math.sin(e * 7)) * .012, e > this.nextHop && (this.hop(.2, t() < .5 ? 1 : -1), this.nextHop = e + 5 + t() * 3);
+				break;
+			case "happy":
+				n = Math.sin(e * 2.2) * .18, i = Math.sin(e * 4.4) * .12, r = .08, e > this.nextHop && (this.hopWithChance(.17, .34), this.nextHop = e + 1.05 + t() * .4);
+				break;
+			case "error": {
+				let t = e % 2.4 / .7;
+				u = t < 1 ? Math.sin(t * Math.PI * 7) * .22 * (1 - t) : 0, r = -.06, i = -.05, c = 1.6;
+				break;
+			}
+			case "sleeping":
+				r = -.34, i = .13, n = .06, a = Math.sin(e * 1.15) * .016, c = .55, l = .9, e > this.nextNod && (this.pitch.v -= .5, this.nextNod = e + 5 + t() * 4);
+				break;
+			default: this.state;
+		}
+		return {
+			yaw: n,
+			pitch: r,
+			roll: i,
+			bob: a,
+			lookX: o,
+			lookY: s,
+			freq: c,
+			damping: l,
+			shake: u
+		};
+	}
+	step(e) {
+		this.time += e, this.since += e, this.age += e, this.switched += e;
+		let t = this.time, n = this.random, r = t < this.reactUntil ? "happy" : this.state;
+		r !== this.shown && (this.previous = this.shown, this.shown = r, this.switched = 0), this.updateLookAt(t);
+		let { yaw: i, pitch: a, roll: o, bob: s, lookX: c, lookY: l, freq: u, damping: d, shake: f } = this.stateTargets(t), p = this.pointer;
+		p && (this.state === "idle" || this.state === "listening" || this.state === "happy" || this.state === "speaking") && p && (i = x(p.x / 260, -1, 1) * .55, a = -x(p.y / 260, -1, 1) * .32, o = -i * .12 + (this.state === "listening" ? .12 : 0), c = x(p.x / 120, -2.4, 2.4), l = x(p.y / 160, -1.4, 1.4)), this.yaw.step(i, e, u, d), this.pitch.step(a, e, u, d), this.roll.step(o, e, u, d), this.sway.step(0, e, 1.2, .7);
+		let { lift: m, spin: h, lean: g } = this.stepJump(e);
+		t > this.nextBlink && (this.blinkAge = 0, this.nextBlink = t + 2.2 + n() * 3.5, n() < .2 && (this.nextBlink = t + .35));
+		let _ = 0;
+		this.blinkAge >= 0 && (this.blinkAge += e, _ = Math.sin(x(this.blinkAge / .17, 0, 1) * Math.PI), this.blinkAge > .17 && (this.blinkAge = -1));
+		let v = (this.roll.v - this.lastV.roll) / e, y = (this.pitch.v - this.lastV.pitch) / e, b = (this.sway.v - this.lastV.sway) / e;
+		this.lastV = {
+			roll: this.roll.v,
+			pitch: this.pitch.v,
+			sway: this.sway.v
+		};
+		let S = 2.3;
+		this.antX.v -= (v * .05 + b * .3) * e * 6, this.antZ.v -= y * .05 * e * 6, this.antX.step(0, e, S, .09), this.antZ.step(0, e, S, .09), this.antX.x = x(this.antX.x, -.7, .7), this.antZ.x = x(this.antZ.x, -.7, .7);
+		let C = this.squash.x;
+		this.pose = {
+			yaw: this.yaw.x + h + f,
+			pitch: this.pitch.x,
+			roll: this.roll.x + g,
+			x: this.sway.x,
+			lift: m + s,
+			sx: 1 + C * .55,
+			sy: 1 - C,
+			antennaX: this.antX.x,
+			antennaZ: this.antZ.x
+		}, this.face.lookX = c, this.face.lookY = l, this.face.blink = this.state === "sleeping" ? 0 : _, this.face.time = this.since;
+	}
+}, T = (e, t, n) => {
+	let r = Math.hypot(e, t, n);
+	return [
+		e / r,
+		t / r,
+		n / r
+	];
+}, E = T(-.5, -.78, .62);
+T(.85, .15, .5), T(.55, -.55, -.62), T(E[0], E[1], E[2] + 1);
+var D = (e) => (e / 255) ** 2.2;
+function O(e) {
+	return [
+		D(e[0]),
+		D(e[1]),
+		D(e[2])
+	];
+}
+//#endregion
+//#region ../src/color.ts
+function k(e) {
+	let t = e.trim(), n = t.match(/^#([0-9a-f]{3}|[0-9a-f]{6})$/i);
+	if (n) {
+		let e = n[1].length === 3 ? n[1].replace(/./g, (e) => e + e) : n[1], t = parseInt(e, 16);
+		return [
+			t >> 16 & 255,
+			t >> 8 & 255,
+			t & 255
+		];
+	}
+	let r = t.match(/^rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)/i);
+	return r ? [
+		Number(r[1]),
+		Number(r[2]),
+		Number(r[3])
+	] : null;
+}
+//#endregion
+//#region ../src/ticker.ts
+var A = {
+	x: NaN,
+	y: NaN
+}, j = /* @__PURE__ */ new Set(), M = 0, N = 0, P = !1;
+function F() {
+	A.x = NaN, A.y = NaN;
+}
+function I(e) {
+	A.x = e.clientX, A.y = e.clientY;
+}
+function L() {
+	document.hidden ? B() : j.size && z();
+}
+function R(e) {
+	M = 0;
+	let t = N ? Math.min(.1, (e - N) / 1e3) : 0;
+	N = e, j.forEach((e) => e(t)), j.size && (M = requestAnimationFrame(R));
+}
+function z() {
+	M || typeof document > "u" || document.hidden || (N = 0, M = requestAnimationFrame(R));
+}
+function B() {
+	M && cancelAnimationFrame(M), M = 0;
+}
+function V() {
+	P || typeof document > "u" || (P = !0, document.addEventListener("pointermove", I, { passive: !0 }), document.addEventListener("pointerleave", F), window.addEventListener("blur", F), document.addEventListener("visibilitychange", L));
+}
+function H() {
+	P && (P = !1, F(), document.removeEventListener("pointermove", I), document.removeEventListener("pointerleave", F), window.removeEventListener("blur", F), document.removeEventListener("visibilitychange", L));
+}
+function U(e) {
+	return V(), j.add(e), z(), () => {
+		j.delete(e), j.size || (B(), H());
+	};
+}
+//#endregion
+//#region ../src/solid2/RobotHead.tsx
+var W = Symbol(), G = Symbol(), K = {
+	get() {
+		let e = this[W];
+		return e["aria-label"] ?? `Robot, ${Q(e.state)}`;
+	},
+	enumerable: !0,
+	configurable: !0
+}, q = {
+	get() {
+		let e = this[W];
+		return e.class ?? e.className;
+	},
+	enumerable: !0,
+	configurable: !0
+}, J = {
+	get() {
+		let e = this[W], t = this[G];
+		return ee(e.style) ? `width:${t()}px;height:${t()}px;display:block;cursor:${e.interactive === !1 ? "auto" : "pointer"};${e.style}` : {
+			width: `${t()}px`,
+			height: `${t()}px`,
+			display: "block",
+			cursor: e.interactive === !1 ? void 0 : "pointer",
+			...e.style
+		};
+	},
+	enumerable: !0,
+	configurable: !0
+};
+function Y(e, t, n) {
+	this[W] = e, this[G] = t, this.role = n, Object.defineProperty(this, "aria-label", K), Object.defineProperty(this, "class", q), Object.defineProperty(this, "style", J);
+}
+Y.prototype = Object.prototype;
+function X(e) {
+	let t = 2166136261;
+	for (let n = 0; n < e.length; n++) t = Math.imul(t ^ e.charCodeAt(n), 16777619);
+	return (t >>> 0) % 1e3 / 1e3;
+}
+function Z(e, t, n) {
+	let r = k(e) ?? [
+		48,
+		80,
+		172
+	], i = k(t) ?? [
+		150,
+		168,
+		200
+	], a = k(n) ?? [
+		232,
+		242,
+		255
+	];
+	return {
+		shell: {
+			albedo: O(r),
+			f0: .05,
+			metal: .15,
+			spec: .55,
+			shininess: 70,
+			rim: .9
+		},
+		trim: {
+			albedo: O(i),
+			f0: .2,
+			metal: .65,
+			spec: .8,
+			shininess: 45,
+			rim: .7
+		},
+		led: a
+	};
+}
+var Q = (e) => e && o.includes(e) ? e : "idle", $ = (e) => e && s.includes(e) ? e : "rectangle";
+function ee(e) {
+	return typeof e == "string";
+}
+function te(o) {
+	let s = r(), c = o, l = i(o, "model", "shape", "state", "size", "color", "trimColor", "screenColor", "speed", "paused", "interactive", "floorShadow", "seed", "class", "className", "style", "onClick", "aria-label", "ref"), u, d = () => Number.isFinite(c.size) && (c.size ?? 0) > 0 ? Math.max(32, Math.min(c.size, 1024)) : 160, f = () => Number.isFinite(c.speed) && (c.speed ?? -1) >= 0 ? Math.min(c.speed, 8) : 1, p = new w(Number.isFinite(c.seed) ? Math.min(1, Math.max(0, c.seed)) : X(s), Q(c.state)), [m, h] = t(!1), [g, _] = t(!0);
+	return a(() => {
+		let e = new IntersectionObserver(([e]) => _(e.isIntersecting));
+		e.observe(u);
+		let t = window.matchMedia("(prefers-reduced-motion: reduce)");
+		h(t.matches);
+		let n = () => h(t.matches);
+		return t.addEventListener("change", n), () => {
+			e.disconnect(), t.removeEventListener("change", n);
+		};
+	}), n(() => {
+		let e = Q(c.state);
+		v($(c.shape)), d(), Z(c.color ?? "#2b49a3", c.trimColor ?? "#93a6c8", c.screenColor ?? "#e8f2ff");
+		let t = f(), n = c.interactive ?? !0;
+		c.floorShadow;
+		let r = (c.paused ?? !1) || !(t > 0) || m();
+		if (p.setState(e), r || !g()) g();
+		else return U((e) => {
+			if (n && Number.isFinite(A.x)) {
+				let e = u.getBoundingClientRect(), t = A.x - (e.left + e.width / 2), n = A.y - (e.top + e.height * .56);
+				p.pointer = Math.hypot(t, n) < 700 ? {
+					x: t,
+					y: n
+				} : null;
+			} else p.pointer = null;
+			p.update(e * t);
+		});
+	}), e("canvas", [new Y(c, d, "img"), l], void 0, !0);
+}
+//#endregion
+export { te as RobotHead, s as robotHeadShapes, o as robotHeadStates };

package/dist/types/RobotHead.d.ts

@@ -0,0 +1,4 @@
+import type { JSX } from 'solid-js';
+import type { RobotHeadProps } from './types';
+/** An animated TV-headed robot, rendered on a 2D canvas. */
+export declare function RobotHead(props: RobotHeadProps): JSX.Element;

package/dist/types/color.d.ts

@@ -0,0 +1,2 @@
+/** Parse #rgb, #rrggbb or rgb() into 0–255 channels; null for anything else. */
+export declare function parseColor(input: string): [number, number, number] | null;

package/dist/types/domain-types.d.ts

@@ -0,0 +1,8 @@
+declare const states: readonly ["idle", "thinking", "searching", "listening", "speaking", "working", "happy", "error", "sleeping"];
+export type RobotHeadState = typeof states[number];
+export declare const robotHeadStates: RobotHeadState[];
+export type RobotHeadModel = 'tv';
+declare const geometries: readonly ["rectangle", "square", "circle", "hexagon"];
+export type RobotHeadShape = typeof geometries[number];
+export declare const robotHeadShapes: RobotHeadShape[];
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { RobotHead } from './RobotHead';
+export { robotHeadStates, robotHeadShapes } from './types';
+export type { RobotHeadProps, RobotHeadState, RobotHeadModel, RobotHeadShape } from './types';

package/dist/types/ticker.d.ts

@@ -0,0 +1,8 @@
+type Tick = (dt: number) => void;
+/** Where the pointer last was on the page, NaN while it is away. */
+export declare const pointer: {
+    x: number;
+    y: number;
+};
+export declare function subscribe(fn: Tick): () => void;
+export {};

package/dist/types/tv/faces.d.ts

@@ -0,0 +1,28 @@
+import type { RobotHeadState } from '../domain-types';
+export declare const COLS = 22;
+export declare const ROWS = 14;
+export interface FaceParams {
+    lookX: number;
+    lookY: number;
+    blink: number;
+    time: number;
+    side: number;
+    seed: number;
+}
+export interface Grid {
+    v: Float32Array;
+    cols: number;
+    rows: number;
+    ox: number;
+    oy: number;
+}
+/** A matrix of `cols` × `rows` (each at least the face area, by even steps) with the face area centred. */
+export declare function makeGrid(cols: number, rows: number): Grid;
+export declare const FACES: Record<RobotHeadState, (g: Grid, f: FaceParams) => void>;
+/** The light the screen and the antenna ball carry in a state. */
+export interface StateLight {
+    screen: [number, number, number] | null;
+    ball: [number, number, number];
+    pulse: (t: number) => number;
+}
+export declare const LIGHTS: Record<RobotHeadState, StateLight>;

package/dist/types/tv/geometry.d.ts

@@ -0,0 +1,62 @@
+import type { RobotHeadShape } from '../domain-types';
+export type V3 = [number, number, number];
+export declare const HEAD: {
+    readonly bevel: 0.075;
+    readonly margin: 0.045;
+    readonly gasket: 0.022;
+    readonly recess: 0.03;
+    readonly earY: 0.03;
+    readonly stem: 0.2;
+    readonly ball: 0.052;
+};
+export declare const INSET: {
+    readonly plate: 0.075;
+    readonly hole: number;
+    readonly glass: number;
+};
+export interface Mesh {
+    pos: Float32Array;
+    quads: Uint16Array;
+    normals: Float32Array;
+}
+/** v' = Roll · Yaw · Pitch · v, row-major. */
+export declare function rotation(yaw: number, pitch: number, roll: number): number[];
+export declare function rotate(m: number[], x: number, y: number, z: number): V3;
+interface Corner {
+    x: number;
+    y: number;
+    a0: number;
+    a1: number;
+}
+export interface Shape {
+    name: RobotHeadShape;
+    r: number;
+    depth: number;
+    corners: Corner[];
+    hx: number;
+    hy: number;
+    pitch: number;
+    earX: number;
+    screws: Array<[number, number, number]>;
+    backScrews: Array<[number, number, number]>;
+    /** Signed distance to the outline inset by `inset` (negative inside). */
+    sd: (x: number, y: number, inset: number) => number;
+    /** Trace the outline inset by `inset` as a closed path. */
+    path: (ctx: CanvasRenderingContext2D | Path2D, inset: number) => void;
+}
+export declare function getShape(name: RobotHeadShape): Shape;
+/** The shell's sides and its rolled edges, front and back (the flat faces are drawn as plates). */
+export declare function buildBody(shape: Shape, bevelSteps?: number): Mesh;
+/**
+ * A solid of revolution: `profile` is [radius, distance along the axis]
+ * from `origin` outward, closing on the axis at its end.
+ */
+export declare function buildLathe(profile: Array<[number, number]>, origin: V3, axis: V3, segments?: number): Mesh;
+export interface HeadMeshes {
+    body: Mesh;
+    earL: Mesh;
+    earR: Mesh;
+    collar: Mesh;
+}
+export declare function headMeshes(shape: Shape): HeadMeshes;
+export {};

package/dist/types/tv/light.d.ts

@@ -0,0 +1,16 @@
+import type { V3 } from './geometry';
+export interface Material {
+    albedo: V3;
+    f0: number;
+    metal: number;
+    spec: number;
+    shininess: number;
+    rim: number;
+}
+export declare const KEY: V3;
+export declare function linear(rgb: [number, number, number]): V3;
+/** The shell's colour at a world-space normal, as linear light. */
+export declare function radiance(m: Material, nx: number, ny: number, nz: number, out?: V3): V3;
+export declare function css(c: V3, alpha?: number): string;
+export declare function shadeCss(m: Material, nx: number, ny: number, nz: number): string;
+export declare function luma(c: V3): number;