ghosto 0.0.2

package/dist/index.mjs

@@ -0,0 +1,1284 @@
+import { Canvas, useFrame, useThree } from "@react-three/fiber";
+import { Suspense, lazy, useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import * as THREE from "three";
+import { create } from "zustand";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { get, set } from "idb-keyval";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/constants.ts
+const BODY_BREATHE_HZ = .42;
+const BODY_BASE_SCALE = .55;
+const CAMERA_NEAR = .1;
+const EYE_HALF_SPACING = .18;
+const EYE_VERTICAL_OFFSET = .16;
+const BLINK_DURATION_S = .12;
+const CHANNEL_DECAY_S = {
+	affection: 30,
+	affinity: Number.POSITIVE_INFINITY,
+	annoyance: 3,
+	attention: 4,
+	boredom: 600,
+	cheer: .6,
+	curiosity: .8,
+	dizzy: .5,
+	energy: 1800,
+	excitement: .5,
+	fatigue: 3600,
+	heat: .6,
+	hunger: 1800,
+	joy: .6,
+	loneliness: 40,
+	magnetism: 1.5,
+	worry: 4
+};
+const AFFINITY_TIERS = [
+	{
+		interactions: 0,
+		label: "shy"
+	},
+	{
+		interactions: 10,
+		label: "curious"
+	},
+	{
+		interactions: 50,
+		label: "bold"
+	},
+	{
+		interactions: 200,
+		label: "bestFriend"
+	},
+	{
+		interactions: 1e3,
+		label: "lifelong"
+	}
+];
+const COLOR_BODY = "oklch(0.99 0.003 250)";
+const COLOR_HEAT = "oklch(0.78 0.20 50)";
+//#endregion
+//#region src/shader/body.frag.ts
+const bodyFrag = `
+varying vec3 vNormal;
+varying vec3 vWorldPos;
+uniform vec3 uBaseColor;
+uniform vec3 uCoreColor;
+uniform float uHeat;
+uniform float uJoy;
+uniform vec3 uPointer3D;
+uniform vec3 uCameraPos;
+uniform float uTime;
+void main(){
+  vec3 N = normalize(vNormal);
+  vec3 V = normalize(uCameraPos - vWorldPos);
+  vec3 L1 = normalize(vec3(-0.4, 0.85, 0.5));
+  vec3 L2 = normalize(vec3(0.7, -0.2, 0.6));
+  float NdotL1 = max(dot(N, L1), 0.0);
+  float NdotL2 = max(dot(N, L2), 0.0);
+  float NdotV = max(dot(N, V), 0.0);
+  float wrap = 1.0;
+  float diffuse = max((dot(N, L1) + wrap) / (1.0 + wrap), 0.0) * 0.35 + 0.65;
+  float fillLight = NdotL2 * 0.18;
+  float fresnel = pow(1.0 - NdotV, 3.5);
+  vec3 col = uBaseColor * (diffuse + fillLight);
+  col *= (1.0 - fresnel * 0.18);
+  col += vec3(0.85, 0.88, 0.92) * fresnel * 0.05;
+  float dPointer = length(vWorldPos - uPointer3D);
+  float radial = smoothstep(0.9, 0.0, dPointer);
+  col = mix(col, uCoreColor, radial * uHeat * 0.3);
+  col += col * uJoy * 0.05;
+  gl_FragColor = vec4(col, 1.0);
+}
+`;
+//#endregion
+//#region src/shader/body.vert.ts
+const bodyVert = `
+varying vec3 vNormal;
+varying vec3 vWorldPos;
+varying float vDisplace;
+uniform float uTime;
+uniform float uExcitement;
+uniform float uHeat;
+uniform float uBreathePhase;
+uniform vec3 uImpulses[8];
+uniform float uImpulseStrength[8];
+vec3 mod289(vec3 x){ return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 mod289v(vec4 x){ return x - floor(x * (1.0 / 289.0)) * 289.0; }
+vec4 permute(vec4 x){ return mod289v(((x*34.0)+1.0)*x); }
+vec4 taylorInvSqrt(vec4 r){ return 1.79284291400159 - 0.85373472095314 * r; }
+float snoise(vec3 v){
+  const vec2  C = vec2(1.0/6.0, 1.0/3.0);
+  const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
+  vec3 i  = floor(v + dot(v, C.yyy));
+  vec3 x0 = v - i + dot(i, C.xxx);
+  vec3 g = step(x0.yzx, x0.xyz);
+  vec3 l = 1.0 - g;
+  vec3 i1 = min(g.xyz, l.zxy);
+  vec3 i2 = max(g.xyz, l.zxy);
+  vec3 x1 = x0 - i1 + C.xxx;
+  vec3 x2 = x0 - i2 + C.yyy;
+  vec3 x3 = x0 - D.yyy;
+  i = mod289(i);
+  vec4 p = permute(permute(permute(
+            i.z + vec4(0.0, i1.z, i2.z, 1.0))
+          + i.y + vec4(0.0, i1.y, i2.y, 1.0))
+          + i.x + vec4(0.0, i1.x, i2.x, 1.0));
+  float n_ = 0.142857142857;
+  vec3 ns = n_ * D.wyz - D.xzx;
+  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);
+  vec4 x_ = floor(j * ns.z);
+  vec4 y_ = floor(j - 7.0 * x_);
+  vec4 x = x_ *ns.x + ns.yyyy;
+  vec4 y = y_ *ns.x + ns.yyyy;
+  vec4 h = 1.0 - abs(x) - abs(y);
+  vec4 b0 = vec4(x.xy, y.xy);
+  vec4 b1 = vec4(x.zw, y.zw);
+  vec4 s0 = floor(b0)*2.0 + 1.0;
+  vec4 s1 = floor(b1)*2.0 + 1.0;
+  vec4 sh = -step(h, vec4(0.0));
+  vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy;
+  vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww;
+  vec3 p0 = vec3(a0.xy, h.x);
+  vec3 p1 = vec3(a0.zw, h.y);
+  vec3 p2 = vec3(a1.xy, h.z);
+  vec3 p3 = vec3(a1.zw, h.w);
+  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2,p2), dot(p3,p3)));
+  p0 *= norm.x; p1 *= norm.y; p2 *= norm.z; p3 *= norm.w;
+  vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+  m = m * m;
+  return 42.0 * dot(m*m, vec4(dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3)));
+}
+void main(){
+  vec3 p = position;
+  float freq = mix(1.4, 3.5, uExcitement);
+  float amp  = mix(0.0, 0.04, uExcitement);
+  float n = snoise(p * freq + uTime * 0.6);
+  p += normal * (n * amp);
+  p *= 1.0 + sin(uBreathePhase) * 0.018;
+  for(int i = 0; i < 8; i++){
+    float s = uImpulseStrength[i];
+    if(s <= 0.0) continue;
+    vec3 ip = uImpulses[i];
+    float d = length(p - ip);
+    p -= normal * (s * exp(-d*d * 12.0));
+  }
+  vDisplace = n * amp;
+  vNormal = normalize(normalMatrix * normal);
+  vec4 wp = modelMatrix * vec4(p, 1.0);
+  vWorldPos = wp.xyz;
+  gl_Position = projectionMatrix * viewMatrix * wp;
+}
+`;
+//#endregion
+//#region src/use-mascot-channels.ts
+const ZERO = {
+	affection: 0,
+	affinity: 0,
+	annoyance: 0,
+	attention: 0,
+	boredom: 0,
+	cheer: 0,
+	curiosity: 0,
+	dizzy: 0,
+	energy: .5,
+	excitement: 0,
+	fatigue: 0,
+	heat: 0,
+	hunger: 0,
+	joy: 0,
+	loneliness: 0,
+	magnetism: 0,
+	worry: 0
+};
+const smoothedState = { ...ZERO };
+let smoothK = 7;
+const clamp01 = (x) => Math.max(0, Math.min(1, x));
+const useMascotChannels = create((setState, getState) => ({
+	bump: (name, delta, cap = 1) => {
+		setState((s) => ({ channels: {
+			...s.channels,
+			[name]: clamp01(Math.min(cap, s.channels[name] + delta))
+		} }));
+	},
+	channels: { ...ZERO },
+	decay: (dt) => {
+		const next = { ...getState().channels };
+		for (const key of Object.keys(next)) {
+			const tau = CHANNEL_DECAY_S[key];
+			if (Number.isFinite(tau) && tau >= .01) next[key] *= Math.exp(-dt / tau);
+		}
+		setState({ channels: next });
+	},
+	set: (name, value) => {
+		setState((s) => ({ channels: {
+			...s.channels,
+			[name]: clamp01(value)
+		} }));
+	},
+	setSmoothK: (k) => {
+		smoothK = k;
+	},
+	smoothed: () => ({ ...smoothedState }),
+	snapshot: () => ({ ...getState().channels }),
+	tick: (dt) => {
+		const current = getState().channels;
+		const alpha = 1 - Math.exp(-smoothK * dt);
+		for (const key of Object.keys(current)) smoothedState[key] += (current[key] - smoothedState[key]) * alpha;
+	}
+}));
+//#endregion
+//#region src/use-mascot-pose.ts
+const useMascotPose = create((setState) => ({
+	bodyScreenPx: {
+		x: 0,
+		y: 0
+	},
+	homeWorld: {
+		x: 0,
+		y: .1,
+		z: 0
+	},
+	setBodyScreenPx: (x, y) => {
+		setState((s) => s.bodyScreenPx.x === x && s.bodyScreenPx.y === y ? s : { bodyScreenPx: {
+			x,
+			y
+		} });
+	},
+	setHomeWorld: (x, y, z) => {
+		setState((s) => s.homeWorld.x === x && s.homeWorld.y === y && s.homeWorld.z === z ? s : { homeWorld: {
+			x,
+			y,
+			z
+		} });
+	}
+}));
+//#endregion
+//#region src/mascot-body.tsx
+/** biome-ignore-all lint/nursery/noUnknownAttribute: R3F intrinsics */
+/** biome-ignore-all lint/performance/noNamespaceImport: three convention */
+const SPHERE_ARGS$1 = [
+	1,
+	64,
+	48
+];
+const MAX_IMPULSES = 8;
+const DRAG_SPRING_K = 18;
+const RELEASE_SPRING_K = 6;
+const SQUASH_GAIN = .06;
+const SQUASH_MAX = .45;
+const MascotBody = ({ baseHue = 0, onCenter, pointer3D }) => {
+	const meshRef = useRef(null);
+	const getSmoothed = useMascotChannels((s) => s.smoothed);
+	const uniforms = useMemo(() => ({
+		uBaseColor: { value: new THREE.Color(COLOR_BODY) },
+		uBreathePhase: { value: 0 },
+		uCameraPos: { value: new THREE.Vector3() },
+		uCoreColor: { value: new THREE.Color(COLOR_HEAT) },
+		uDiscoveryAura: { value: 0 },
+		uExcitement: { value: 0 },
+		uHeat: { value: 0 },
+		uImpulseStrength: { value: new Float32Array(MAX_IMPULSES) },
+		uImpulses: { value: Array.from({ length: MAX_IMPULSES }, () => new THREE.Vector3()) },
+		uJoy: { value: 0 },
+		uPointer3D: { value: new THREE.Vector3() },
+		uTime: { value: 0 }
+	}), []);
+	const tmpVRef = useRef(new THREE.Vector3());
+	const bounceRef = useRef({
+		end: 0,
+		lastExc: 0
+	});
+	const dragRef = useRef({ active: false });
+	const velRef = useRef({
+		x: 0,
+		y: 0
+	});
+	const lastPosRef = useRef({
+		x: 0,
+		y: 0
+	});
+	const getHome = useMascotPose((s) => s.homeWorld);
+	useEffect(() => {
+		const onDown = (e) => {
+			const b = useMascotPose.getState().bodyScreenPx;
+			if (Math.hypot(e.clientX - b.x, e.clientY - b.y) < 75) dragRef.current.active = true;
+		};
+		const onUp = () => {
+			dragRef.current.active = false;
+		};
+		globalThis.addEventListener("pointerdown", onDown);
+		globalThis.addEventListener("pointerup", onUp);
+		globalThis.addEventListener("pointercancel", onUp);
+		return () => {
+			globalThis.removeEventListener("pointerdown", onDown);
+			globalThis.removeEventListener("pointerup", onUp);
+			globalThis.removeEventListener("pointercancel", onUp);
+		};
+	}, []);
+	useFrame((state, dt) => {
+		const c = getSmoothed();
+		const t = state.clock.elapsedTime;
+		uniforms.uTime.value = t;
+		uniforms.uExcitement.value = c.excitement;
+		uniforms.uHeat.value = c.heat;
+		uniforms.uJoy.value = c.joy;
+		uniforms.uBreathePhase.value = t * BODY_BREATHE_HZ * Math.PI * 2;
+		uniforms.uPointer3D.value.copy(pointer3D);
+		state.camera.getWorldPosition(uniforms.uCameraPos.value);
+		if (baseHue !== 0) {
+			const baseCol = new THREE.Color(COLOR_BODY);
+			baseCol.offsetHSL(baseHue / 360, 0, 0);
+			uniforms.uBaseColor.value.copy(baseCol);
+		}
+		if (!meshRef.current) return;
+		const mesh = meshRef.current;
+		const isDrag = dragRef.current.active;
+		const leanGain = Math.min(1, c.magnetism * 1.2);
+		const idleSwayX = (Math.sin(t * .7) * .6 + Math.sin(t * .31) * .4) * .01;
+		const idleSwayY = (Math.cos(t * .55) * .5 + Math.sin(t * .23) * .3) * .006;
+		const targetX = isDrag ? pointer3D.x : getHome.x + pointer3D.x * .32 * leanGain + idleSwayX;
+		const targetY = isDrag ? pointer3D.y : getHome.y + pointer3D.y * .22 * leanGain + idleSwayY;
+		const alpha = 1 - Math.exp(-(isDrag ? DRAG_SPRING_K : RELEASE_SPRING_K) * dt);
+		const cur = mesh.position;
+		const prevX = cur.x;
+		const prevY = cur.y;
+		cur.x += (targetX - cur.x) * alpha;
+		cur.y += (targetY - cur.y) * alpha;
+		cur.z = getHome.z;
+		const dxv = (cur.x - prevX) / Math.max(dt, .001);
+		const dyv = (cur.y - prevY) / Math.max(dt, .001);
+		const velAlpha = 1 - Math.exp(-12 * dt);
+		velRef.current.x += (dxv - velRef.current.x) * velAlpha;
+		velRef.current.y += (dyv - velRef.current.y) * velAlpha;
+		lastPosRef.current.x = cur.x;
+		lastPosRef.current.y = cur.y;
+		const speed = Math.hypot(velRef.current.x, velRef.current.y);
+		const squash = Math.min(SQUASH_MAX, speed * SQUASH_GAIN);
+		const angle = Math.atan2(velRef.current.y, velRef.current.x);
+		mesh.rotation.set(0, 0, angle);
+		const breathe = Math.sin(t * BODY_BREATHE_HZ * Math.PI * 2) * .006;
+		const bounce = bounceRef.current;
+		if (c.excitement - bounce.lastExc > .2) bounce.end = t + .22;
+		bounce.lastExc = c.excitement;
+		let bounceAmp = 0;
+		if (t < bounce.end) {
+			const phase = (bounce.end - t) / .22;
+			bounceAmp = Math.sin((1 - phase) * Math.PI) * .12;
+		}
+		const baseScale = BODY_BASE_SCALE + c.joy * .04 - c.fatigue * .02 + breathe + bounceAmp;
+		const sxStretch = 1 + squash;
+		const syStretch = 1 - squash * .6;
+		mesh.scale.set(baseScale * sxStretch, baseScale * syStretch, baseScale * (1 - squash * .3));
+		mesh.getWorldPosition(tmpVRef.current);
+		onCenter?.(tmpVRef.current);
+	});
+	return /* @__PURE__ */ jsxs("mesh", {
+		ref: meshRef,
+		children: [/* @__PURE__ */ jsx("sphereGeometry", { args: SPHERE_ARGS$1 }), /* @__PURE__ */ jsx("shaderMaterial", {
+			fragmentShader: bodyFrag,
+			uniforms,
+			vertexShader: bodyVert
+		})]
+	});
+};
+//#endregion
+//#region src/shader/eye.frag.ts
+const eyeVert = `
+varying vec3 vNormal;
+varying vec3 vWorldPos;
+uniform float uClosed;
+uniform float uSad;
+uniform float uBlink;
+void main(){
+  vec3 p = position;
+  p.x *= 0.42;
+  p.y *= 1.35;
+  p.z *= 0.42;
+  float blendUp = clamp(uClosed - uSad * 0.5, 0.0, 1.0);
+  float blendDn = clamp(uSad, 0.0, 1.0);
+  float blend = max(blendUp, blendDn);
+  float s = blendDn > blendUp ? -1.0 : 1.0;
+  float wideMul = mix(1.0, 3.2, blend);
+  float xWide = p.x * wideMul;
+  float archPeak = s * 0.04;
+  float archK = 5.5;
+  float archY = archPeak - s * archK * xWide * xWide;
+  float tubeFlat = mix(1.0, 0.14, blend);
+  float arched = mix(p.y, archY + p.y * tubeFlat, blend);
+  arched -= uBlink * 0.05;
+  p.x = xWide;
+  p.y = arched;
+  p.z = p.z * mix(1.0, 0.4, blend);
+  vec4 wp = modelMatrix * vec4(p, 1.0);
+  vWorldPos = wp.xyz;
+  vNormal = normalize(normalMatrix * normal);
+  gl_Position = projectionMatrix * viewMatrix * wp;
+}
+`;
+const eyeFrag = `
+varying vec3 vNormal;
+varying vec3 vWorldPos;
+uniform vec3 uColor;
+uniform vec3 uCameraPos;
+uniform float uHighlight;
+void main(){
+  vec3 N = normalize(vNormal);
+  vec3 V = normalize(uCameraPos - vWorldPos);
+  float NdotV = max(dot(N, V), 0.0);
+  float rim = pow(1.0 - NdotV, 1.2);
+  vec3 col = uColor * (0.92 + 0.08 * rim) + vec3(0.08) * uHighlight;
+  gl_FragColor = vec4(col, 1.0);
+}
+`;
+//#endregion
+//#region src/use-reduced-motion.ts
+const QUERY = "(prefers-reduced-motion: reduce)";
+const subscribe = (cb) => {
+	if (typeof globalThis.matchMedia !== "function") return () => void 0;
+	const mql = globalThis.matchMedia(QUERY);
+	mql.addEventListener("change", cb);
+	return () => mql.removeEventListener("change", cb);
+};
+const getSnapshot = () => {
+	if (typeof globalThis.matchMedia !== "function") return false;
+	return globalThis.matchMedia(QUERY).matches;
+};
+const getServerSnapshot = () => false;
+const useReducedMotion = () => useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+//#endregion
+//#region src/mascot-eyes.tsx
+/** biome-ignore-all lint/nursery/noUnknownAttribute: R3F intrinsics */
+/** biome-ignore-all lint/performance/noNamespaceImport: three convention */
+const EYE_RADIUS = .1;
+const EYE_FRONT_Z = .55;
+const SPHERE_ARGS = [
+	EYE_RADIUS,
+	32,
+	24
+];
+const TRACK_OFFSET_GAIN = .07;
+const PURSUIT_GAIN = 1;
+const IDLE_AMP_X = .6;
+const IDLE_AMP_Y = .4;
+const SACCADE_AMP = .08;
+const EYE_COLOR = new THREE.Color("#020202");
+const LIGHT_DIR = new THREE.Vector3(.4, .85, .5).normalize();
+const clamp = (x, lo, hi) => Math.max(lo, Math.min(hi, x));
+const idleWalk = (t, s) => .55 * Math.sin(t * .27 + s[0]) + .3 * Math.sin(t * .61 + s[1]) + .18 * Math.sin(t * 1.13 + s[2]);
+const SingleEye = ({ bodyCenter, pointer3D, side }) => {
+	const meshRef = useRef(null);
+	const getSmoothed = useMascotChannels((s) => s.smoothed);
+	const followK = useReducedMotion() ? 3 : 6;
+	const uniforms = useMemo(() => ({
+		uBlink: { value: 0 },
+		uCameraPos: { value: new THREE.Vector3() },
+		uClosed: { value: 0 },
+		uColor: { value: EYE_COLOR },
+		uHighlight: { value: 0 },
+		uLightDir: { value: LIGHT_DIR },
+		uSad: { value: 0 }
+	}), []);
+	const trackRef = useRef({
+		x: 0,
+		y: 0
+	});
+	const blinkRef = useRef({
+		delay: side === -1 ? .04 : 0,
+		end: 0,
+		nextAt: 0,
+		spring: 0,
+		springV: 0
+	});
+	const sideSeedsRef = useRef({
+		sa: side * 7.13 + 1.9,
+		sa2: side * 9.41 + .3,
+		sx: [
+			side * 4.13 + .7,
+			side * 2.91 + 1.4,
+			side * 5.32 + .2
+		],
+		sy: [
+			side * 3.27 + 2.1,
+			side * 1.85 + 3.6,
+			side * 6.04 + .5
+		]
+	});
+	useFrame((state, dt) => {
+		const mesh = meshRef.current;
+		if (!mesh) return;
+		let probeSearch;
+		try {
+			({search: probeSearch} = globalThis.location);
+		} catch {
+			probeSearch = "";
+		}
+		if (probeSearch.includes("test=1")) {
+			const probe = globalThis;
+			probe.__mascotEyes ??= [];
+			if (!probe.__mascotEyes.includes(mesh)) probe.__mascotEyes.push(mesh);
+		}
+		const matUniforms = mesh.material.uniforms;
+		state.camera.getWorldPosition(matUniforms.uCameraPos.value);
+		const anchorX = bodyCenter.x + side * EYE_HALF_SPACING;
+		const anchorY = bodyCenter.y + EYE_VERTICAL_OFFSET;
+		const anchorZ = bodyCenter.z + EYE_FRONT_Z;
+		const c = getSmoothed();
+		const now = state.clock.elapsedTime;
+		const seeds = sideSeedsRef.current;
+		const idleX = idleWalk(now, seeds.sx) * IDLE_AMP_X;
+		const idleY = idleWalk(now, seeds.sy) * IDLE_AMP_Y;
+		const dx = pointer3D.x - anchorX;
+		const dy = pointer3D.y - anchorY;
+		const pointerTargetX = clamp(dx / 2.5, -1, 1) * PURSUIT_GAIN;
+		const pointerTargetY = clamp(dy / 2.5, -1, 1) * PURSUIT_GAIN;
+		const attentionMag = clamp(c.attention + c.curiosity * .8 + c.magnetism * .6, 0, 1);
+		const idleWeight = 1 - .6 * attentionMag;
+		const focusWeight = .4 + .6 * attentionMag;
+		const targetX = pointerTargetX * focusWeight + idleX * idleWeight;
+		const targetY = pointerTargetY * focusWeight + idleY * idleWeight;
+		const alpha = 1 - Math.exp(-followK * dt);
+		trackRef.current.x += (targetX - trackRef.current.x) * alpha;
+		trackRef.current.y += (targetY - trackRef.current.y) * alpha;
+		const exDiz = .6 + c.excitement + c.dizzy;
+		const saccadeX = Math.sin(now * 11.3 + seeds.sa) * Math.sin(now * 2.7 + seeds.sa2) * SACCADE_AMP * exDiz;
+		const saccadeY = Math.cos(now * 9.1 + seeds.sa2) * Math.sin(now * 3.1 + seeds.sa) * SACCADE_AMP * .7 * exDiz;
+		const closed = clamp(.95 * c.joy + .7 * c.cheer + .15 * c.affection, 0, 1);
+		const sad = clamp(c.loneliness * .8 + c.worry * .4 - c.joy, 0, 1);
+		const blink = blinkRef.current;
+		if (blink.nextAt === 0) blink.nextAt = now + 3 + Math.random() * 4;
+		if (now > blink.nextAt && now > blink.end + blink.delay) {
+			blink.end = now + BLINK_DURATION_S + blink.delay;
+			blink.nextAt = now + 3 + Math.random() * 4;
+		}
+		const force = 90 * ((now > blink.delay && now < blink.end ? Math.sin((blink.end - now) / BLINK_DURATION_S * Math.PI) : 0) - blink.spring) - 14 * blink.springV;
+		blink.springV += force * dt;
+		blink.spring += blink.springV * dt;
+		const blinkOut = clamp(blink.spring, 0, 1);
+		matUniforms.uClosed.value = closed;
+		matUniforms.uSad.value = sad;
+		matUniforms.uBlink.value = blinkOut;
+		matUniforms.uHighlight.value = clamp(c.joy + c.attention * .7 + .08 * Math.sin(now * 1.9), 0, 1);
+		const tx = (trackRef.current.x + saccadeX) * TRACK_OFFSET_GAIN;
+		const ty = (trackRef.current.y + saccadeY) * TRACK_OFFSET_GAIN;
+		mesh.position.set(anchorX + tx, anchorY + ty - sad * .04, anchorZ);
+	});
+	return /* @__PURE__ */ jsxs("mesh", {
+		ref: meshRef,
+		children: [/* @__PURE__ */ jsx("sphereGeometry", { args: SPHERE_ARGS }), /* @__PURE__ */ jsx("shaderMaterial", {
+			depthTest: false,
+			fragmentShader: eyeFrag,
+			uniforms,
+			vertexShader: eyeVert
+		})]
+	});
+};
+const MascotEyes = ({ bodyCenter, pointer3D }) => /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(SingleEye, {
+	bodyCenter,
+	pointer3D,
+	side: -1
+}), /* @__PURE__ */ jsx(SingleEye, {
+	bodyCenter,
+	pointer3D,
+	side: 1
+})] });
+//#endregion
+//#region src/svg-fallback.tsx
+const SvgFallback = () => /* @__PURE__ */ jsx("div", {
+	className: "flex size-full items-center justify-center",
+	children: /* @__PURE__ */ jsxs("svg", {
+		className: "size-40 animate-pulse text-foreground/80",
+		fill: "currentColor",
+		viewBox: "0 0 100 100",
+		xmlns: "http://www.w3.org/2000/svg",
+		children: [
+			/* @__PURE__ */ jsx("title", { children: "Mascot fallback" }),
+			/* @__PURE__ */ jsx("circle", {
+				cx: "50",
+				cy: "50",
+				fill: "currentColor",
+				opacity: "0.92",
+				r: "38"
+			}),
+			/* @__PURE__ */ jsx("ellipse", {
+				cx: "42",
+				cy: "46",
+				fill: "#0a0a14",
+				rx: "3",
+				ry: "6"
+			}),
+			/* @__PURE__ */ jsx("ellipse", {
+				cx: "58",
+				cy: "46",
+				fill: "#0a0a14",
+				rx: "3",
+				ry: "6"
+			})
+		]
+	})
+});
+//#endregion
+//#region src/use-history-channel.ts
+const KEY$1 = "va.mascot.v1.affinity.self";
+const tierFor = (interactions) => {
+	let chosen = AFFINITY_TIERS[0];
+	for (const t of AFFINITY_TIERS) if (interactions >= t.interactions) chosen = t;
+	return chosen;
+};
+const useHistoryChannel = ({ enabled = true } = {}) => {
+	const setCh = useMascotChannels((s) => s.set);
+	const recordRef = useRef(null);
+	useEffect(() => {
+		if (!enabled) return;
+		let cancelled = false;
+		const init = async () => {
+			recordRef.current = await get(KEY$1) ?? {
+				cumulativeMs: 0,
+				interactions: 0,
+				lastSeenAt: Date.now()
+			};
+			if (!cancelled) setCh("affinity", Math.min(1, recordRef.current.interactions / 1e3));
+		};
+		init().catch(() => void 0);
+		const bumpInteraction = () => {
+			const r = recordRef.current;
+			if (!r) return;
+			r.interactions += 1;
+			r.lastSeenAt = Date.now();
+			setCh("affinity", Math.min(1, r.interactions / 1e3));
+		};
+		const flush = () => {
+			const r = recordRef.current;
+			if (!r) return;
+			set(KEY$1, r).catch(() => void 0);
+		};
+		globalThis.addEventListener("pointerdown", bumpInteraction);
+		globalThis.addEventListener("keydown", bumpInteraction);
+		const id = globalThis.setInterval(flush, 5e3);
+		globalThis.addEventListener("beforeunload", flush);
+		return () => {
+			cancelled = true;
+			globalThis.removeEventListener("pointerdown", bumpInteraction);
+			globalThis.removeEventListener("keydown", bumpInteraction);
+			globalThis.removeEventListener("beforeunload", flush);
+			globalThis.clearInterval(id);
+			flush();
+		};
+	}, [enabled, setCh]);
+	return {
+		recordRef,
+		tierFor
+	};
+};
+//#endregion
+//#region src/use-keyboard-channel.ts
+const useKeyboardChannel = ({ enabled = true } = {}) => {
+	const bump = useMascotChannels((s) => s.bump);
+	const setCh = useMascotChannels((s) => s.set);
+	const stateRef = useRef({
+		capsLockOn: false,
+		composerFocused: false,
+		keyTimestamps: []
+	});
+	useEffect(() => {
+		if (!enabled) return;
+		const st = stateRef.current;
+		const onKey = (e) => {
+			const now = e.timeStamp;
+			st.keyTimestamps.push(now);
+			while (st.keyTimestamps[0] !== void 0 && now - st.keyTimestamps[0] > 5e3) st.keyTimestamps.shift();
+			const wpm = st.keyTimestamps.length / 5 * 12;
+			setCh("energy", Math.min(1, .4 + wpm / 200));
+			bump("attention", .04, 1);
+			if (e.key === "Enter") {
+				bump("cheer", .5, 1);
+				bump("joy", .3, 1);
+			} else if (e.key === "!") bump("excitement", .25, 1);
+			else if (e.key === "?") bump("curiosity", .2, 1);
+			const capsOn = e.getModifierState("CapsLock");
+			if (capsOn !== st.capsLockOn) {
+				st.capsLockOn = capsOn;
+				if (capsOn) bump("annoyance", .15, 1);
+			}
+		};
+		const onFocus = (e) => {
+			const t = e.target;
+			const focused = t instanceof HTMLTextAreaElement || t instanceof HTMLInputElement;
+			st.composerFocused = focused;
+			if (focused) bump("attention", .3, 1);
+		};
+		globalThis.addEventListener("keydown", onKey);
+		globalThis.addEventListener("focusin", onFocus);
+		globalThis.addEventListener("focusout", onFocus);
+		return () => {
+			globalThis.removeEventListener("keydown", onKey);
+			globalThis.removeEventListener("focusin", onFocus);
+			globalThis.removeEventListener("focusout", onFocus);
+		};
+	}, [
+		bump,
+		enabled,
+		setCh
+	]);
+};
+//#endregion
+//#region src/use-mascot-dna.ts
+/** biome-ignore-all lint/suspicious/noAssignInExpressions: mulberry32 PRNG step */
+/** biome-ignore-all lint/style/noParameterAssign: mulberry32 advances local copy */
+/** biome-ignore-all lint/suspicious/noBitwiseOperators: mulberry32 requires xor/shift */
+const mulberry32 = (a) => () => {
+	let t = Math.trunc(a += 1831565813);
+	t = Math.imul(t ^ t >>> 15, t | 1);
+	t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+	return Math.trunc(t ^ t >>> 14) / 4294967296;
+};
+const generateSeed = () => {
+	const buf = new Uint32Array(1);
+	globalThis.crypto.getRandomValues(buf);
+	return buf[0] ?? Date.now();
+};
+const paramsFromSeed = (seed) => {
+	const rng = mulberry32(seed);
+	return {
+		baseHue: 240 + (rng() * 60 - 30),
+		bodyAspectRatio: 1 + (rng() * .2 - .1),
+		driftPersonality: rng(),
+		eyeSize: 1 + (rng() * .3 - .15),
+		eyeSpacing: .22 * (.9 + rng() * .2),
+		pulseCadence: .9 + rng() * .3,
+		voiceFormantOffset: rng() * 200 - 100
+	};
+};
+const KEY = "va.mascot.v1.dna.self";
+const useMascotDna = () => {
+	const [dna, setDna] = useState(null);
+	useEffect(() => {
+		let cancelled = false;
+		const loadOrCreate = async () => {
+			const seedOverride = new URL(globalThis.location.href).searchParams.get("seed");
+			if (seedOverride !== null) {
+				const seed = Number.parseInt(seedOverride, 10);
+				if (!cancelled) setDna({
+					createdAt: Date.now(),
+					params: paramsFromSeed(seed),
+					seed
+				});
+				return;
+			}
+			const existing = await get(KEY);
+			if (existing) {
+				if (!cancelled) setDna(existing);
+				return;
+			}
+			const seed = generateSeed();
+			const rec = {
+				createdAt: Date.now(),
+				params: paramsFromSeed(seed),
+				seed
+			};
+			await set(KEY, rec);
+			if (!cancelled) setDna(rec);
+		};
+		loadOrCreate().catch(() => void 0);
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+	return dna;
+};
+//#endregion
+//#region src/use-needs-channel.ts
+const useNeedsChannel = ({ enabled = true } = {}) => {
+	const set = useMascotChannels((s) => s.set);
+	const bump = useMascotChannels((s) => s.bump);
+	const lastInputAtRef = useRef(0);
+	useEffect(() => {
+		lastInputAtRef.current = Date.now();
+	}, []);
+	useEffect(() => {
+		if (!enabled) return;
+		const onInput = () => {
+			lastInputAtRef.current = Date.now();
+		};
+		globalThis.addEventListener("pointerdown", onInput);
+		globalThis.addEventListener("pointermove", onInput, { passive: true });
+		globalThis.addEventListener("keydown", onInput);
+		const id = globalThis.setInterval(() => {
+			const idleS = (Date.now() - lastInputAtRef.current) / 1e3;
+			const h = (/* @__PURE__ */ new Date()).getHours();
+			const energyCurve = .4 + .5 * Math.sin((h - 7) / 24 * Math.PI * 2);
+			set("energy", Math.max(0, Math.min(1, energyCurve)));
+			if (idleS > 60) bump("boredom", .02, 1);
+			if (idleS > 10) bump("loneliness", .01, 1);
+			if (h < 5 || h > 23) bump("fatigue", .02, 1);
+		}, 5e3);
+		return () => {
+			globalThis.removeEventListener("pointerdown", onInput);
+			globalThis.removeEventListener("pointermove", onInput);
+			globalThis.removeEventListener("keydown", onInput);
+			globalThis.clearInterval(id);
+		};
+	}, [
+		bump,
+		enabled,
+		set
+	]);
+};
+//#endregion
+//#region src/use-pointer-channel.ts
+const smoothstep = (a, b, x) => {
+	const t = Math.max(0, Math.min(1, (x - a) / (b - a)));
+	return t * t * (3 - 2 * t);
+};
+const usePointerChannel = ({ enabled = true } = {}) => {
+	const bump = useMascotChannels((s) => s.bump);
+	const setCh = useMascotChannels((s) => s.set);
+	const stateRef = useRef({
+		insideCanvas: false,
+		lastClickT: 0,
+		lastMoveT: 0,
+		lastT: 0,
+		lastX: 0,
+		lastY: 0,
+		mascotCenterPx: {
+			x: 0,
+			y: 0
+		},
+		movePx: 0,
+		pressActive: false,
+		pressStart: null
+	});
+	useEffect(() => {
+		if (!enabled) return;
+		const st = stateRef.current;
+		const onEnter = () => {
+			st.insideCanvas = true;
+			bump("curiosity", .3, 1);
+			bump("attention", .4, 1);
+			bump("affection", .04, 1);
+			bump("joy", .1, 1);
+		};
+		const onLeave = () => {
+			st.insideCanvas = false;
+			setCh("magnetism", 0);
+			bump("loneliness", .25, 1);
+		};
+		const onMove = (e) => {
+			const t = e.timeStamp;
+			const dx = e.clientX - st.lastX;
+			const dy = e.clientY - st.lastY;
+			const dt = Math.max(.001, (t - st.lastT) / 1e3);
+			const speed = Math.hypot(dx, dy) / dt;
+			const jumpPx = Math.hypot(dx, dy);
+			st.lastX = e.clientX;
+			st.lastY = e.clientY;
+			st.lastT = t;
+			st.lastMoveT = t;
+			const closeness = 1 - smoothstep(220, 900, Math.hypot(e.clientX - st.mascotCenterPx.x, e.clientY - st.mascotCenterPx.y));
+			setCh("magnetism", closeness);
+			if (jumpPx >= 600 && st.lastMoveT - st.lastT < 100) {
+				bump("attention", .6, 1);
+				bump("curiosity", .3, 1);
+				bump("worry", .1, 1);
+				bump("dizzy", .05, 1);
+			}
+			if (st.pressActive) {
+				bump("joy", .05, 1);
+				bump("cheer", .04, 1);
+				bump("affection", .02, 1);
+				bump("attention", .12, 1);
+				bump("magnetism", .06, 1);
+			} else if (speed >= 1500) {
+				bump("worry", .08, 1);
+				bump("dizzy", .05, 1);
+				bump("attention", .1, 1);
+			} else if (speed >= 800) {
+				bump("excitement", .05, 1);
+				bump("attention", .06, 1);
+			} else if (speed >= 30 && speed <= 180 && closeness > .5) {
+				bump("attention", .06, 1);
+				bump("magnetism", .04, 1);
+				bump("joy", .02, 1);
+			} else if (speed <= 50 && closeness > .4) {
+				bump("joy", .03, 1);
+				bump("cheer", .02, 1);
+				bump("affection", .01, 1);
+			} else if (closeness > .15) bump("curiosity", .02, 1);
+			if (st.pressActive && st.pressStart) st.movePx += jumpPx;
+		};
+		const onDown = (e) => {
+			st.pressActive = true;
+			st.movePx = 0;
+			st.pressStart = {
+				t: e.timeStamp,
+				x: e.clientX,
+				y: e.clientY
+			};
+		};
+		const onUp = (e) => {
+			if (!(st.pressActive && st.pressStart)) {
+				st.pressActive = false;
+				return;
+			}
+			if (st.movePx > 4) {
+				bump("cheer", .4, 1);
+				bump("joy", .3, 1);
+				bump("affection", .06, 1);
+			} else {
+				const streakDt = e.timeStamp - st.lastClickT;
+				const streakMult = streakDt < 1e3 ? Math.min(1.6, 1 + .2 * Math.max(0, 5 - streakDt / 200)) : 1;
+				const dbl = streakDt < 350;
+				bump("joy", (dbl ? .9 : .7) * streakMult, 1);
+				bump("cheer", (dbl ? .7 : .5) * streakMult, 1);
+				bump("excitement", (dbl ? .6 : .4) * streakMult, 1);
+				bump("heat", .3, 1);
+				bump("affection", .05, 1);
+			}
+			st.lastClickT = e.timeStamp;
+			st.pressActive = false;
+			st.pressStart = null;
+		};
+		globalThis.addEventListener("pointerenter", onEnter);
+		globalThis.addEventListener("pointerleave", onLeave);
+		globalThis.addEventListener("pointermove", onMove, { passive: true });
+		globalThis.addEventListener("pointerdown", onDown);
+		globalThis.addEventListener("pointerup", onUp);
+		globalThis.addEventListener("pointercancel", onUp);
+		return () => {
+			globalThis.removeEventListener("pointerenter", onEnter);
+			globalThis.removeEventListener("pointerleave", onLeave);
+			globalThis.removeEventListener("pointermove", onMove);
+			globalThis.removeEventListener("pointerdown", onDown);
+			globalThis.removeEventListener("pointerup", onUp);
+			globalThis.removeEventListener("pointercancel", onUp);
+		};
+	}, [
+		bump,
+		enabled,
+		setCh
+	]);
+	const setMascotCenter = useCallback((x, y) => {
+		stateRef.current.mascotCenterPx = {
+			x,
+			y
+		};
+	}, []);
+	return {
+		isInside: useCallback(() => stateRef.current.insideCanvas, []),
+		setMascotCenter
+	};
+};
+//#endregion
+//#region src/use-webgl-context-loss.ts
+const useWebglContextLoss = ({ canvasRef }) => {
+	const [lost, setLost] = useState(false);
+	useEffect(() => {
+		const c = canvasRef.current;
+		if (!c) return;
+		const onLost = (e) => {
+			e.preventDefault();
+			setLost(true);
+		};
+		const onRestored = () => setLost(false);
+		c.addEventListener("webglcontextlost", onLost);
+		c.addEventListener("webglcontextrestored", onRestored);
+		return () => {
+			c.removeEventListener("webglcontextlost", onLost);
+			c.removeEventListener("webglcontextrestored", onRestored);
+		};
+	}, [canvasRef]);
+	return { lost };
+};
+//#endregion
+//#region src/mascot-canvas.tsx
+/** biome-ignore-all lint/nursery/noUnknownAttribute: R3F intrinsics */
+/** biome-ignore-all lint/performance/noNamespaceImport: three convention */
+var mascot_canvas_exports = /* @__PURE__ */ __exportAll({ MascotCanvas: () => MascotCanvas });
+const CAMERA_PROPS = {
+	fov: 28,
+	near: CAMERA_NEAR,
+	position: [
+		0,
+		0,
+		12
+	]
+};
+const DPR_RANGE = [1, 2];
+const GL_PROPS = {
+	alpha: true,
+	antialias: true,
+	powerPreference: "high-performance"
+};
+const LIGHT_POS = [
+	1,
+	2,
+	1
+];
+const POINT_LIGHT_POS = [
+	2,
+	3,
+	4
+];
+const Scene = ({ bodyCenterRef, pointer3DRef, setMascotCenterPx }) => {
+	const decay = useMascotChannels((s) => s.decay);
+	const tick = useMascotChannels((s) => s.tick);
+	const setBodyScreenPx = useMascotPose((s) => s.setBodyScreenPx);
+	const { camera, gl, size } = useThree();
+	useEffect(() => {
+		if (!(camera instanceof THREE.PerspectiveCamera)) return;
+		camera.fov = 28;
+		camera.near = CAMERA_NEAR;
+		camera.far = 20;
+		camera.position.set(0, 0, 12);
+		camera.updateProjectionMatrix();
+	}, [camera]);
+	useEffect(() => {
+		gl.toneMapping = THREE.ACESFilmicToneMapping;
+		gl.outputColorSpace = THREE.SRGBColorSpace;
+	}, [gl]);
+	const raycasterRef = useRef(new THREE.Raycaster());
+	const ndcRef = useRef(new THREE.Vector2());
+	const pointer3DTargetRef = useRef(new THREE.Vector3());
+	useEffect(() => {
+		const onMove = (e) => {
+			const rect = gl.domElement.getBoundingClientRect();
+			ndcRef.current.x = (e.clientX - rect.left) / rect.width * 2 - 1;
+			ndcRef.current.y = -((e.clientY - rect.top) / rect.height) * 2 + 1;
+			raycasterRef.current.setFromCamera(ndcRef.current, camera);
+			const dir = raycasterRef.current.ray.direction;
+			const denom = dir.z === 0 ? 1e-4 : dir.z;
+			const t = -raycasterRef.current.ray.origin.z / denom;
+			pointer3DTargetRef.current.copy(raycasterRef.current.ray.origin).addScaledVector(dir, t);
+		};
+		globalThis.addEventListener("pointermove", onMove);
+		return () => globalThis.removeEventListener("pointermove", onMove);
+	}, [camera, gl]);
+	const domEl = gl.domElement;
+	useEffect(() => {
+		const update = () => {
+			const rect = domEl.getBoundingClientRect();
+			setMascotCenterPx(rect.left + rect.width / 2, rect.top + rect.height / 2);
+		};
+		update();
+		const ro = new ResizeObserver(update);
+		ro.observe(domEl);
+		globalThis.addEventListener("scroll", update, { passive: true });
+		return () => {
+			ro.disconnect();
+			globalThis.removeEventListener("scroll", update);
+		};
+	}, [domEl, setMascotCenterPx]);
+	const projTmpRef = useRef(new THREE.Vector3());
+	const onCenter = useCallback((v) => {
+		bodyCenterRef.current.copy(v);
+		const tmp = projTmpRef.current;
+		tmp.copy(v).project(camera);
+		setBodyScreenPx((tmp.x * .5 + .5) * size.width, (-tmp.y * .5 + .5) * size.height);
+	}, [
+		bodyCenterRef,
+		camera,
+		setBodyScreenPx,
+		size.height,
+		size.width
+	]);
+	useEffect(() => {
+		let raf = 0;
+		let last = performance.now();
+		const loop = () => {
+			const now = performance.now();
+			const dt = Math.min(.1, (now - last) / 1e3);
+			last = now;
+			decay(dt);
+			tick(dt);
+			const target = pointer3DTargetRef.current;
+			const { current } = pointer3DRef;
+			const alpha = 1 - Math.exp(-12 * dt);
+			current.x += (target.x - current.x) * alpha;
+			current.y += (target.y - current.y) * alpha;
+			current.z += (target.z - current.z) * alpha;
+			raf = requestAnimationFrame(loop);
+		};
+		raf = requestAnimationFrame(loop);
+		return () => cancelAnimationFrame(raf);
+	}, [
+		decay,
+		tick,
+		pointer3DRef
+	]);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("ambientLight", {
+			color: "#ffffff",
+			intensity: .85
+		}),
+		/* @__PURE__ */ jsx("directionalLight", {
+			color: "#ffffff",
+			intensity: 1.2,
+			position: LIGHT_POS
+		}),
+		/* @__PURE__ */ jsx("pointLight", {
+			color: "#ffffff",
+			intensity: .6,
+			position: POINT_LIGHT_POS
+		}),
+		/* @__PURE__ */ jsx(MascotBody, {
+			onCenter,
+			pointer3D: pointer3DRef.current
+		}),
+		/* @__PURE__ */ jsx(MascotEyes, {
+			bodyCenter: bodyCenterRef.current,
+			pointer3D: pointer3DRef.current
+		})
+	] });
+};
+const MascotCanvas = () => {
+	useMascotDna();
+	const pointer3DRef = useRef(new THREE.Vector3());
+	const bodyCenterRef = useRef(new THREE.Vector3());
+	const canvasRef = useRef(null);
+	const reducedMotion = useReducedMotion();
+	const setSmoothK = useMascotChannels((s) => s.setSmoothK);
+	useEffect(() => {
+		setSmoothK(reducedMotion ? 3 : 7);
+	}, [reducedMotion, setSmoothK]);
+	const { setMascotCenter } = usePointerChannel({ enabled: !reducedMotion });
+	useKeyboardChannel({ enabled: true });
+	useNeedsChannel({ enabled: true });
+	useHistoryChannel({ enabled: true });
+	const { lost } = useWebglContextLoss({ canvasRef });
+	const [glReady, setGlReady] = useState(false);
+	useEffect(() => {
+		let search;
+		try {
+			({search} = globalThis.location);
+		} catch {
+			return;
+		}
+		if (!search.includes("test=1")) return;
+		const probe = globalThis;
+		probe.__mascot = {
+			body: bodyCenterRef.current,
+			channels: useMascotChannels.getState,
+			lost,
+			pointer3D: pointer3DRef.current
+		};
+	}, [lost]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "pointer-events-none relative size-full [&_canvas]:pointer-events-none [&>div]:pointer-events-none",
+		children: [/* @__PURE__ */ jsx(Canvas, {
+			camera: CAMERA_PROPS,
+			dpr: DPR_RANGE,
+			gl: GL_PROPS,
+			onCreated: ({ gl }) => {
+				canvasRef.current = gl.domElement;
+				gl.domElement.style.pointerEvents = "none";
+				setGlReady(true);
+			},
+			children: glReady ? /* @__PURE__ */ jsx(Scene, {
+				bodyCenterRef,
+				pointer3DRef,
+				setMascotCenterPx: setMascotCenter
+			}) : null
+		}), lost ? /* @__PURE__ */ jsx(SvgFallback, {}) : null]
+	});
+};
+//#endregion
+//#region src/mascot.tsx
+const MascotCanvas$1 = lazy(async () => {
+	return { default: (await Promise.resolve().then(() => mascot_canvas_exports)).MascotCanvas };
+});
+const MascotBubbleFollower = ({ children, offsetY = -110 }) => {
+	const px = useMascotPose((s) => s.bodyScreenPx);
+	return /* @__PURE__ */ jsx("div", {
+		className: "pointer-events-none fixed z-20 hidden md:block",
+		style: useMemo(() => ({
+			left: 0,
+			top: 0,
+			transform: `translate3d(${px.x}px, ${px.y + offsetY}px, 0) translate(-50%, -100%)`
+		}), [
+			px.x,
+			px.y,
+			offsetY
+		]),
+		children: /* @__PURE__ */ jsx("div", {
+			className: "pointer-events-auto",
+			children
+		})
+	});
+};
+const MascotOverlay = ({ anchorRef }) => {
+	const setHomeWorld = useMascotPose((s) => s.setHomeWorld);
+	const overlayRef = useRef(null);
+	useEffect(() => {
+		const root = overlayRef.current;
+		if (!root) return;
+		const apply = () => {
+			const all = root.querySelectorAll("*");
+			for (const el of all) el.style.pointerEvents = "none";
+		};
+		apply();
+		const mo = new MutationObserver(apply);
+		mo.observe(root, {
+			childList: true,
+			subtree: true
+		});
+		return () => mo.disconnect();
+	}, []);
+	useEffect(() => {
+		const update = () => {
+			const el = anchorRef.current;
+			if (!el) return;
+			const rect = el.getBoundingClientRect();
+			const cx = rect.left + rect.width / 2;
+			const cy = rect.top + rect.height / 2;
+			const vw = globalThis.innerWidth;
+			const vh = globalThis.innerHeight;
+			const fov = 28 * Math.PI / 180;
+			const pxToWorld = 24 * Math.tan(fov / 2) / vh;
+			setHomeWorld((cx - vw / 2) * pxToWorld, -(cy - vh / 2) * pxToWorld, 0);
+		};
+		update();
+		const ro = new ResizeObserver(update);
+		const el = anchorRef.current;
+		if (el) ro.observe(el);
+		globalThis.addEventListener("scroll", update, { passive: true });
+		globalThis.addEventListener("resize", update);
+		return () => {
+			ro.disconnect();
+			globalThis.removeEventListener("scroll", update);
+			globalThis.removeEventListener("resize", update);
+		};
+	}, [anchorRef, setHomeWorld]);
+	return /* @__PURE__ */ jsx("div", {
+		className: "pointer-events-none fixed inset-0 z-10",
+		ref: overlayRef,
+		children: /* @__PURE__ */ jsx(Suspense, {
+			fallback: null,
+			children: /* @__PURE__ */ jsx(MascotCanvas$1, {})
+		})
+	});
+};
+const Mascot = ({ bubble, size = 240 }) => {
+	const anchorRef = useRef(null);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("div", {
+			ref: anchorRef,
+			style: useMemo(() => ({
+				height: size,
+				width: size
+			}), [size])
+		}),
+		/* @__PURE__ */ jsx(MascotOverlay, { anchorRef }),
+		bubble === void 0 ? null : /* @__PURE__ */ jsx(MascotBubbleFollower, { children: bubble })
+	] });
+};
+//#endregion
+export { Mascot, MascotBubbleFollower, MascotCanvas, useMascotChannels, useMascotPose };