Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

31.9 KB
Raw Blame
// /dissolve: page controller.
//
// Owns the renderer, camera, post-processing and the DOM. All particle physics
// is in engine.js, all geometry maths in sample-core.js; this file wires the
// shelf, the pointer tools, the morph timeline, the mic, capture and share
// links to them, and decides what the person sees while something loads or
// fails.

import * as THREE from 'three';
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
import { OutputPass } from 'three/addons/postprocessing/OutputPass.js';
import { getMeshoptDecoder } from '../viewer/internal.js';
import { DissolveEngine, TOOL, probeSupport } from './engine.js';
import { buildShapeCloud } from './shape.js';
import { MicLevels } from './audio.js';
import { CanvasRecorder, extensionFor } from './recorder.js';
import { SHELF, PRESETS, QUALITY, shelfEntry, parseModelUrl, readState, writeState } from './shelf.js';

const FOV = 40;
const MORPH_SECONDS = 3.4;
const LOOP_HOLD_SECONDS = 1.2;
const QUALITY_KEY = 'twx_dissolve_quality';

const $ = (id) => document.getElementById(id);
const el = {
	stage: $('dsStage'),
	canvas: $('dsCanvas'),
	hero: $('dsHero'),
	count: $('dsCount'),
	loading: $('dsLoading'),
	loadingLabel: $('dsLoadingLabel'),
	barFill: $('dsBarFill'),
	fallback: $('dsFallback'),
	fallbackTitle: $('dsFallbackTitle'),
	fallbackBody: $('dsFallbackBody'),
	rec: $('dsRec'),
	recTime: $('dsRecTime'),
	dock: $('dsDock'),
	dockToggle: $('dsDockToggle'),
	shelfA: $('dsShelfA'),
	shelfB: $('dsShelfB'),
	file: $('dsFile'),
	pickA: $('dsPickA'),
	pickB: $('dsPickB'),
	urlForm: $('dsUrlForm'),
	url: $('dsUrl'),
	morph: $('dsMorph'),
	swap: $('dsSwap'),
	loop: $('dsLoop'),
	mix: $('dsMix'),
	tools: $('dsTools'),
	toolHint: $('dsToolHint'),
	collapse: $('dsCollapse'),
	detonate: $('dsDetonate'),
	presets: $('dsPresets'),
	size: $('dsSize'),
	glow: $('dsGlow'),
	chaos: $('dsChaos'),
	orbit: $('dsOrbit'),
	mic: $('dsMic'),
	shot: $('dsShot'),
	record: $('dsRecord'),
	share: $('dsShare'),
	quality: $('dsQuality'),
	toast: $('dsToast'),
};

const reducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;

const TOOL_HINTS = {
	orbit: 'Drag to turn the camera, scroll to zoom.',
	gravity: 'Hold and drag to open a black hole. Particles that cross the horizon leave as jets.',
	vortex: 'Hold and drag to spin a tornado through the shape.',
	burst: 'Click anywhere to send a shockwave through the shape.',
};

// ── State ─────────────────────────────────────────────────────────────────
const initial = readState(location.search);
const state = {
	a: initial.a,
	b: initial.b,
	preset: initial.preset,
	quality: initial.quality || savedQuality() || defaultQuality(),
	tool: 'gravity',
	bloom: PRESETS[initial.preset].bloom,
	autoOrbit: !reducedMotion,
	loopOn: false,
	collapsed: false,
	tween: null,
	pressed: false,
	hovering: false,
	engine: null,
	models: new Map(), // key -> Promise<THREE.Group>
	loadToken: { A: 0, B: 0 },
	busy: 0,
	labels: { A: '', B: '' },
	custom: { A: null, B: null },
};

function savedQuality() {
	try {
		const q = localStorage.getItem(QUALITY_KEY);
		return QUALITY[q] ? q : null;
	} catch {
		return null;
	}
}

function defaultQuality() {
	const weak = (navigator.hardwareConcurrency || 4) <= 4 || window.matchMedia('(pointer: coarse)').matches;
	return weak ? 'lite' : 'standard';
}

// ── Toasts and loading ────────────────────────────────────────────────────
let toastTimer = 0;
function toast(message, { action = null, ms = 5200 } = {}) {
	clearTimeout(toastTimer);
	el.toast.replaceChildren();
	const text = document.createElement('span');
	text.textContent = message;
	el.toast.append(text);
	if (action) {
		const btn = document.createElement('button');
		btn.type = 'button';
		btn.className = 'ds-toast-action';
		btn.textContent = action.label;
		btn.addEventListener('click', () => {
			el.toast.hidden = true;
			action.run();
		});
		el.toast.append(btn);
	}
	el.toast.hidden = false;
	toastTimer = setTimeout(() => (el.toast.hidden = true), ms);
}

function setLoading(on, label = '', progress = null) {
	el.loading.hidden = !on;
	if (!on) return;
	el.loadingLabel.textContent = label;
	el.barFill.style.transform = `scaleX(${progress == null ? 0.08 : Math.max(0.04, progress)})`;
	el.barFill.classList.toggle('is-indeterminate', progress == null);
}

function showFallback(title, body) {
	el.fallbackTitle.textContent = title;
	el.fallbackBody.textContent = body;
	el.fallback.hidden = false;
	el.dock.hidden = true;
	el.dockToggle.hidden = true;
	el.hero.hidden = true;
}

// ── Renderer, scene, post ─────────────────────────────────────────────────
const support = probeSupport();
if (!support.ok) {
	showFallback(
		'This browser cannot run Dissolve',
		support.reason === 'webgl2'
			? 'Dissolve simulates its particles on the GPU and needs WebGL 2. Turn on hardware acceleration, or try a current Chrome, Edge, Firefox or Safari.'
			: 'Your GPU cannot render to floating-point textures, which the particle simulation needs. Update your graphics driver or try another browser.',
	);
} else {
	boot();
}

function boot() {
	const renderer = new THREE.WebGLRenderer({ canvas: el.canvas, antialias: false, powerPreference: 'high-performance', alpha: false });
	renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
	renderer.toneMapping = THREE.ACESFilmicToneMapping;
	renderer.toneMappingExposure = 1.0;
	renderer.setClearColor(0x04060b, 1);

	const scene = new THREE.Scene();
	const camera = new THREE.PerspectiveCamera(FOV, 1, 0.1, 80);
	camera.position.set(0.0, 0.5, 5.4);

	const controls = new OrbitControls(camera, el.canvas);
	controls.target.set(0, -0.1, 0);
	controls.enableDamping = true;
	controls.dampingFactor = 0.07;
	controls.minDistance = 1.6;
	controls.maxDistance = 14;
	controls.maxPolarAngle = Math.PI * 0.62;
	controls.autoRotateSpeed = 0.7;
	controls.enablePan = false;

	const composer = new EffectComposer(renderer);
	composer.addPass(new RenderPass(scene, camera));
	const bloom = new UnrealBloomPass(new THREE.Vector2(1, 1), state.bloom, 0.5, 0.3);
	composer.addPass(bloom);
	composer.addPass(new OutputPass());

	const backdrop = buildBackdrop();
	scene.add(backdrop.group);

	const loader = new GLTFLoader();
	const draco = new DRACOLoader();
	draco.setDecoderPath('/three/draco/gltf/');
	loader.setDRACOLoader(draco);
	getMeshoptDecoder().then((d) => loader.setMeshoptDecoder(d));

	const mic = new MicLevels();
	const recorder = new CanvasRecorder(el.canvas);
	const pointerPlane = new THREE.Plane();
	const ray = new THREE.Raycaster();
	const ndc = new THREE.Vector2();
	const forward = new THREE.Vector3();
	const hit = new THREE.Vector3();

	// ── Model loading ────────────────────────────────────────────────────
	function loadGltf(url, onProgress) {
		return new Promise((resolve, reject) => {
			loader.load(
				url,
				(gltf) => resolve(gltf.scene),
				(e) => e.lengthComputable && onProgress(e.loaded / e.total),
				(err) => reject(err instanceof Error ? err : new Error('The model could not be loaded.')),
			);
		});
	}

	function modelSource(key) {
		const entry = shelfEntry(key);
		if (entry) return { url: entry.url, label: entry.label };
		const custom = state.custom.A?.key === key ? state.custom.A : state.custom.B?.key === key ? state.custom.B : null;
		if (custom) return { url: custom.url, label: custom.label };
		const safe = parseModelUrl(key);
		if (safe) return { url: safe, label: safe.split('/').pop().slice(0, 28) || 'Linked model' };
		return null;
	}

	function getModel(key, onProgress) {
		if (!state.models.has(key)) {
			const source = modelSource(key);
			if (!source) return Promise.reject(new Error('That model link is not valid.'));
			const promise = loadGltf(source.url, onProgress).catch((err) => {
				state.models.delete(key);
				throw err;
			});
			state.models.set(key, promise);
		}
		return state.models.get(key);
	}

	async function setSlot(slot, key) {
		const token = ++state.loadToken[slot];
		const source = modelSource(key);
		const label = source ? source.label : 'model';
		state.busy++;
		setLoading(true, `Loading ${label}`, null);
		try {
			const group = await getModel(key, (p) => token === state.loadToken[slot] && setLoading(true, `Loading ${label}`, p * 0.5));
			if (token !== state.loadToken[slot]) return;
			const engine = state.engine;
			const cloud = await buildShapeCloud(group, engine.count, {
				seed: slot === 'A' ? 7 : 11,
				onProgress: (p) => token === state.loadToken[slot] && setLoading(true, `Dissolving ${label} into ${engine.count.toLocaleString()} points`, 0.5 + p * 0.5),
			});
			if (token !== state.loadToken[slot] || engine !== state.engine) return;
			engine.setShape(slot, cloud);
			state[slot.toLowerCase()] = key;
			state.labels[slot] = label;
			syncShelves();
			syncUrl();
			updateAria();
			if (slot === 'A') el.hero.classList.add('is-compact');
		} catch (err) {
			if (token !== state.loadToken[slot]) return;
			const reason = err && err.message ? err.message : 'The model could not be loaded.';
			toast(`Could not dissolve ${label}. ${reason}`);
			if (!state.engine.shapes[slot]) {
				// First load failed and nothing is on stage: fall back to the default.
				if (key !== 'agent') await setSlot(slot, slot === 'A' ? 'agent' : 'fox');
			}
		} finally {
			state.busy--;
			if (state.busy === 0) setLoading(false);
		}
	}

	// ── Engine lifecycle ─────────────────────────────────────────────────
	function createEngine() {
		if (state.engine) {
			scene.remove(state.engine.group);
			state.engine.dispose();
		}
		const side = QUALITY[state.quality].side;
		const engine = new DissolveEngine(renderer, side);
		scene.add(engine.group);
		state.engine = engine;
		applyPreset(state.preset, { silent: true });
		engine.setMix(0);
		engine.params.gravity = state.collapsed ? 9 : 0;
		el.mix.value = '0';
		el.count.textContent = `${engine.count.toLocaleString()} GPU particles`;
		resize();
	}

	function applyPreset(name, { silent = false } = {}) {
		const p = PRESETS[name];
		state.preset = name;
		const engine = state.engine;
		for (const key of ['spring', 'damp', 'turb', 'arc', 'stagger', 'size', 'bright']) engine.setParam(key, p[key]);
		state.bloom = p.bloom;
		bloom.strength = p.bloom;
		el.size.value = p.size;
		el.glow.value = p.bloom;
		el.chaos.value = p.turb;
		engine.setView(renderer.domElement.height, FOV);
		syncPresets();
		if (!silent) syncUrl();
	}

	// ── Layout ───────────────────────────────────────────────────────────
	function resize() {
		const w = el.stage.clientWidth;
		const h = el.stage.clientHeight;
		if (!w || !h) return;
		renderer.setSize(w, h, false);
		composer.setSize(w, h);
		bloom.resolution.set(w, h);
		camera.aspect = w / h;
		// Keep the whole figure in frame on a portrait phone.
		camera.fov = w / h < 0.8 ? FOV + 16 : FOV;
		camera.updateProjectionMatrix();
		if (state.engine) state.engine.setView(renderer.domElement.height, camera.fov);
	}
	new ResizeObserver(resize).observe(el.stage);

	// ── Pointer tools ────────────────────────────────────────────────────
	function updatePointer(e) {
		const rect = el.canvas.getBoundingClientRect();
		ndc.set(((e.clientX - rect.left) / rect.width) * 2 - 1, -((e.clientY - rect.top) / rect.height) * 2 + 1);
		ray.setFromCamera(ndc, camera);
		camera.getWorldDirection(forward);
		pointerPlane.setFromNormalAndCoplanarPoint(forward, controls.target);
		if (ray.ray.intersectPlane(pointerPlane, hit)) state.engine.pointer.point.copy(hit);
		state.engine.pointer.axis.copy(forward);
	}

	function applyToolState() {
		const engine = state.engine;
		const tool = state.tool;
		controls.enableRotate = tool === 'orbit';
		el.canvas.dataset.tool = tool;
		if (tool === 'gravity' || tool === 'vortex') {
			engine.pointer.mode = tool === 'gravity' ? TOOL.gravity : TOOL.vortex;
			const active = state.pressed ? 1 : state.hovering ? 0.28 : 0;
			engine.pointer.strength = active;
		} else {
			engine.pointer.mode = TOOL.none;
			engine.pointer.strength = 0;
		}
	}

	el.canvas.addEventListener('pointerenter', (e) => {
		if (e.pointerType === 'mouse') state.hovering = true;
	});
	el.canvas.addEventListener('pointerleave', () => {
		state.hovering = false;
		state.pressed = false;
	});
	el.canvas.addEventListener('pointermove', (e) => {
		if (state.engine) updatePointer(e);
	});
	el.canvas.addEventListener('pointerdown', (e) => {
		if (!state.engine) return;
		updatePointer(e);
		state.pressed = true;
		if (state.tool === 'burst') state.engine.shockwave(state.engine.pointer.point, 1);
		try {
			el.canvas.setPointerCapture(e.pointerId);
		} catch {
			/* capture is a nicety; the tool still works without it */
		}
	});
	const release = () => (state.pressed = false);
	el.canvas.addEventListener('pointerup', release);
	el.canvas.addEventListener('pointercancel', release);

	function selectTool(tool) {
		state.tool = tool;
		for (const btn of el.tools.querySelectorAll('[data-tool]')) {
			const on = btn.dataset.tool === tool;
			btn.setAttribute('aria-checked', String(on));
			btn.tabIndex = on ? 0 : -1;
		}
		el.toolHint.textContent = TOOL_HINTS[tool];
	}
	el.tools.addEventListener('click', (e) => {
		const btn = e.target.closest('[data-tool]');
		if (btn) selectTool(btn.dataset.tool);
	});
	el.tools.addEventListener('keydown', (e) => {
		const order = [...el.tools.querySelectorAll('[data-tool]')];
		const i = order.findIndex((b) => b.dataset.tool === state.tool);
		const step = e.key === 'ArrowRight' || e.key === 'ArrowDown' ? 1 : e.key === 'ArrowLeft' || e.key === 'ArrowUp' ? -1 : 0;
		if (!step) return;
		e.preventDefault();
		const next = order[(i + step + order.length) % order.length];
		selectTool(next.dataset.tool);
		next.focus();
	});

	// ── Morph timeline ───────────────────────────────────────────────────
	function morphTo(target) {
		const engine = state.engine;
		if (!engine.shapes.B || engine.shapes.B === engine.shapes.A) {
			toast('Pick a different shape for B first.');
			return;
		}
		const from = engine.mix;
		if (reducedMotion) {
			engine.setMix(target);
			syncMorphUi();
			return;
		}
		state.tween = { from, to: target, t: 0, hold: 0 };
		syncMorphUi();
	}

	function stepTween(dt) {
		const tw = state.tween;
		if (!tw) return;
		if (tw.t < 1) {
			tw.t = Math.min(1, tw.t + dt / MORPH_SECONDS);
			const e = tw.t < 0.5 ? 4 * tw.t ** 3 : 1 - (-2 * tw.t + 2) ** 3 / 2;
			state.engine.setMix(tw.from + (tw.to - tw.from) * e);
			el.mix.value = String(Math.round(state.engine.mix * 1000));
			if (tw.t >= 1) {
				tw.hold = 0;
				syncMorphUi();
			}
			return;
		}
		if (state.loopOn) {
			tw.hold += dt;
			if (tw.hold >= LOOP_HOLD_SECONDS) morphTo(tw.to > 0.5 ? 0 : 1);
		} else {
			state.tween = null;
		}
	}

	function syncMorphUi() {
		const atB = state.engine.mix > 0.5 && !(state.tween && state.tween.to < 0.5);
		el.morph.textContent = atB ? 'Morph to A' : 'Morph to B';
	}

	el.morph.addEventListener('click', () => {
		const e = state.engine;
		const goingTo = state.tween ? (state.tween.to > 0.5 ? 0 : 1) : e.mix > 0.5 ? 0 : 1;
		morphTo(goingTo);
	});
	el.swap.addEventListener('click', swap);
	function swap() {
		const e = state.engine;
		if (!e.shapes.B) return;
		e.swap();
		[state.a, state.b] = [state.b, state.a];
		[state.labels.A, state.labels.B] = [state.labels.B, state.labels.A];
		[state.custom.A, state.custom.B] = [state.custom.B, state.custom.A];
		state.tween = null;
		el.mix.value = String(Math.round(e.mix * 1000));
		syncShelves();
		syncUrl();
		syncMorphUi();
	}
	el.loop.addEventListener('click', () => {
		state.loopOn = !state.loopOn;
		el.loop.setAttribute('aria-pressed', String(state.loopOn));
		if (state.loopOn && !state.tween) morphTo(state.engine.mix > 0.5 ? 0 : 1);
	});
	el.mix.addEventListener('input', () => {
		state.tween = null;
		state.engine.setMix(Number(el.mix.value) / 1000);
		syncMorphUi();
	});

	// ── Forces ───────────────────────────────────────────────────────────
	function setCollapse(on) {
		state.collapsed = on;
		state.engine.params.gravity = on ? 9 : 0;
		el.collapse.setAttribute('aria-pressed', String(on));
	}
	el.collapse.addEventListener('click', () => setCollapse(!state.collapsed));
	function detonate() {
		state.engine.shockwave(new THREE.Vector3(0, -0.15, 0), 1.7);
	}
	el.detonate.addEventListener('click', detonate);

	// ── Looks ────────────────────────────────────────────────────────────
	function syncPresets() {
		for (const btn of el.presets.children) {
			const on = btn.dataset.preset === state.preset;
			btn.setAttribute('aria-checked', String(on));
			btn.tabIndex = on ? 0 : -1;
		}
	}
	for (const [id, p] of Object.entries(PRESETS)) {
		const btn = chip(p.label, 'preset', id);
		btn.addEventListener('click', () => applyPreset(id));
		el.presets.append(btn);
	}
	el.size.addEventListener('input', () => {
		state.engine.setParam('size', Number(el.size.value));
		state.engine.setView(renderer.domElement.height, camera.fov);
	});
	el.glow.addEventListener('input', () => {
		state.bloom = Number(el.glow.value);
		bloom.strength = state.bloom;
	});
	el.chaos.addEventListener('input', () => state.engine.setParam('turb', Number(el.chaos.value)));
	el.orbit.addEventListener('click', () => {
		state.autoOrbit = !state.autoOrbit;
		el.orbit.setAttribute('aria-pressed', String(state.autoOrbit));
	});
	el.orbit.setAttribute('aria-pressed', String(state.autoOrbit));

	// ── Mic ──────────────────────────────────────────────────────────────
	async function toggleMic() {
		if (mic.active) {
			mic.stop();
			state.engine.audio.bass = state.engine.audio.mid = 0;
			el.mic.setAttribute('aria-pressed', 'false');
			return;
		}
		if (!MicLevels.isSupported()) {
			toast('This browser does not expose a microphone to web pages.');
			return;
		}
		try {
			await mic.start();
			el.mic.setAttribute('aria-pressed', 'true');
			toast('Listening. Bass swells the storm, mids stir it. Nothing is recorded.');
		} catch (err) {
			const denied = err && (err.name === 'NotAllowedError' || err.name === 'SecurityError');
			toast(denied ? 'Microphone access was blocked. Allow it in the address bar, then press Mic again.' : `The microphone is not available: ${err && err.message ? err.message : 'unknown error'}.`);
		}
	}
	el.mic.addEventListener('click', toggleMic);
	if (!MicLevels.isSupported()) {
		el.mic.disabled = true;
		el.mic.title = 'This browser does not expose a microphone';
	}

	// ── Capture and share ────────────────────────────────────────────────
	function download(blob, name) {
		const a = document.createElement('a');
		a.href = URL.createObjectURL(blob);
		a.download = name;
		document.body.append(a);
		a.click();
		a.remove();
		setTimeout(() => URL.revokeObjectURL(a.href), 4000);
	}
	function stamp() {
		return new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
	}
	function snapshot() {
		composer.render();
		el.canvas.toBlob((blob) => {
			if (!blob) return toast('The snapshot could not be encoded.');
			download(blob, `dissolve-${stamp()}.png`);
			toast('Saved a PNG.');
		}, 'image/png');
	}
	el.shot.addEventListener('click', snapshot);

	let recTimer = 0;
	let recStart = 0;
	async function toggleRecord() {
		if (recorder.recording) {
			clearInterval(recTimer);
			el.rec.hidden = true;
			el.record.textContent = 'Record';
			const mime = recorder.mime;
			try {
				const blob = await recorder.stop();
				download(blob, `dissolve-${stamp()}.${extensionFor(mime)}`);
				toast('Saved your clip.');
			} catch (err) {
				toast(`Recording failed: ${err.message}`);
			}
			return;
		}
		if (!CanvasRecorder.isSupported()) {
			toast('This browser cannot record the canvas. Use Snapshot instead.');
			return;
		}
		try {
			recorder.start(60);
		} catch (err) {
			toast(err.message);
			return;
		}
		recStart = performance.now();
		el.rec.hidden = false;
		el.record.textContent = 'Stop';
		recTimer = setInterval(() => {
			const s = Math.floor((performance.now() - recStart) / 1000);
			el.recTime.textContent = `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`;
		}, 250);
	}
	el.record.addEventListener('click', toggleRecord);

	function shareUrl() {
		const q = writeState({ a: state.a, b: state.b, preset: state.preset, quality: state.quality }, '');
		return `${location.origin}${location.pathname}${q}`;
	}
	el.share.addEventListener('click', async () => {
		const customised = state.custom.A || state.custom.B;
		const url = shareUrl();
		try {
			await navigator.clipboard.writeText(url);
			toast(customised ? 'Link copied. Files from your device cannot travel in a link, so those slots will show the defaults.' : 'Link copied. Anyone who opens it sees this exact pair.');
		} catch {
			toast(`Copy this link: ${url}`, { ms: 12000 });
		}
	});
	function syncUrl() {
		const shareable = (k) => (shelfEntry(k) || parseModelUrl(k) ? k : k === state.a ? 'agent' : 'fox');
		const q = writeState({ a: shareable(state.a), b: shareable(state.b), preset: state.preset, quality: state.quality }, '');
		history.replaceState(null, '', `${location.pathname}${q}`);
	}

	// ── Shelves, files, links ────────────────────────────────────────────
	function chip(label, kind, id) {
		const btn = document.createElement('button');
		btn.type = 'button';
		btn.className = 'ds-chip-btn';
		btn.setAttribute('role', 'radio');
		btn.setAttribute('aria-checked', 'false');
		btn.dataset[kind] = id;
		btn.textContent = label;
		return btn;
	}
	function buildShelf(container, slot) {
		for (const item of SHELF) {
			const btn = chip(item.label, 'model', item.id);
			btn.addEventListener('click', () => setSlot(slot, item.id));
			container.append(btn);
		}
		const mine = chip('Yours', 'model', 'custom');
		mine.hidden = true;
		mine.dataset.custom = 'true';
		container.append(mine);
	}
	buildShelf(el.shelfA, 'A');
	buildShelf(el.shelfB, 'B');

	function syncShelves() {
		for (const [container, slot] of [[el.shelfA, 'A'], [el.shelfB, 'B']]) {
			const key = state[slot.toLowerCase()];
			const custom = state.custom[slot];
			for (const btn of container.children) {
				if (btn.dataset.custom) {
					btn.hidden = !custom;
					if (custom) btn.textContent = custom.label;
					const on = !!custom && custom.key === key;
					btn.setAttribute('aria-checked', String(on));
					btn.tabIndex = on ? 0 : -1;
					continue;
				}
				const on = btn.dataset.model === key;
				btn.setAttribute('aria-checked', String(on));
				btn.tabIndex = on || (!container.querySelector('[aria-checked="true"]') && btn === container.firstChild) ? 0 : -1;
			}
		}
	}

	let pickSlot = 'B';
	el.pickA.addEventListener('click', () => ((pickSlot = 'A'), el.file.click()));
	el.pickB.addEventListener('click', () => ((pickSlot = 'B'), el.file.click()));
	el.file.addEventListener('change', () => {
		const file = el.file.files && el.file.files[0];
		el.file.value = '';
		if (file) loadFile(file, pickSlot);
	});
	function loadFile(file, slot) {
		if (!/\.(glb|gltf)$/i.test(file.name)) {
			toast('Dissolve reads .glb and .gltf files. Convert other formats in the Forge first.');
			return;
		}
		if (file.size > 80 * 1024 * 1024) {
			toast('That file is over 80 MB. Compress it with meshopt or Draco, then try again.');
			return;
		}
		const key = `file:${file.name}:${file.size}:${file.lastModified}`;
		state.custom[slot] = { key, url: URL.createObjectURL(file), label: file.name.replace(/\.(glb|gltf)$/i, '').slice(0, 24) };
		setSlot(slot, key);
	}
	el.urlForm.addEventListener('submit', (e) => {
		e.preventDefault();
		const slot = e.submitter && e.submitter.dataset.slot ? e.submitter.dataset.slot : 'B';
		const safe = parseModelUrl(el.url.value.trim());
		if (!safe) {
			toast('Use an https link to a .glb file.');
			return;
		}
		state.custom[slot] = { key: safe, url: safe, label: safe.split('/').pop().slice(0, 24) || 'Linked model' };
		setSlot(slot, safe);
	});
	for (const type of ['dragenter', 'dragover']) {
		el.stage.addEventListener(type, (e) => {
			if (e.dataTransfer && [...e.dataTransfer.types].includes('Files')) {
				e.preventDefault();
				el.stage.classList.add('is-drop');
			}
		});
	}
	el.stage.addEventListener('dragleave', (e) => {
		if (e.target === el.stage) el.stage.classList.remove('is-drop');
	});
	el.stage.addEventListener('drop', (e) => {
		e.preventDefault();
		el.stage.classList.remove('is-drop');
		const file = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
		if (file) loadFile(file, e.shiftKey ? 'A' : 'B');
	});

	// ── Quality ──────────────────────────────────────────────────────────
	for (const [id, q] of Object.entries(QUALITY)) {
		const opt = document.createElement('option');
		opt.value = id;
		opt.textContent = `${q.label} · ${(q.side * q.side).toLocaleString()}`;
		el.quality.append(opt);
	}
	el.quality.value = state.quality;
	el.quality.addEventListener('change', async () => {
		state.quality = el.quality.value;
		try {
			localStorage.setItem(QUALITY_KEY, state.quality);
		} catch {
			/* the choice just will not persist */
		}
		await rebuild();
	});

	async function rebuild() {
		const [a, b] = [state.a, state.b];
		const mix = state.engine ? state.engine.mix : 0;
		state.tween = null;
		createEngine();
		await setSlot('A', a);
		if (b && b !== a) await setSlot('B', b);
		state.engine.setMix(mix);
		el.mix.value = String(Math.round(mix * 1000));
		syncUrl();
	}

	// ── Chrome ───────────────────────────────────────────────────────────
	el.dockToggle.addEventListener('click', () => {
		const open = el.dock.classList.toggle('is-closed') === false;
		el.dockToggle.setAttribute('aria-expanded', String(open));
	});
	if (window.matchMedia('(max-width: 760px)').matches) {
		el.dock.classList.add('is-closed');
		el.dockToggle.setAttribute('aria-expanded', 'false');
	}

	function updateAria() {
		const a = state.labels.A;
		const b = state.labels.B;
		el.canvas.setAttribute('aria-label', a && b && a !== b ? `${a} dissolved into a storm of glowing particles, ready to morph into ${b}` : `${a || 'A 3D model'} dissolved into a storm of glowing particles`);
	}

	window.addEventListener('keydown', (e) => {
		if (e.metaKey || e.ctrlKey || e.altKey) return;
		const t = e.target;
		if (t && (t.tagName === 'INPUT' || t.tagName === 'SELECT' || t.tagName === 'TEXTAREA' || t.isContentEditable)) return;
		if (t && t.tagName === 'BUTTON' && e.key === ' ') return;
		const map = { 1: 'orbit', 2: 'gravity', 3: 'vortex', 4: 'burst' };
		if (map[e.key]) return selectTool(map[e.key]);
		switch (e.key.toLowerCase()) {
			case ' ':
				e.preventDefault();
				return el.morph.click();
			case 's':
				return swap();
			case 'c':
				return setCollapse(!state.collapsed);
			case 'b':
				return detonate();
			case 'm':
				return toggleMic();
			case 'p':
				return snapshot();
			case 'r':
				return toggleRecord();
			case 'h':
				return el.dockToggle.click();
		}
	});

	// ── Frame loop ───────────────────────────────────────────────────────
	let last = performance.now();
	const tick = () => {
		const now = performance.now();
		const d = (now - last) / 1000;
		last = now;
		return d;
	};
	let slowFrames = 0;
	let slowWarned = false;
	function frame() {
		requestAnimationFrame(frame);
		const engine = state.engine;
		if (!engine) return;
		const dt = Math.min(tick(), 0.1);

		const levels = mic.active ? mic.sample() : null;
		if (levels) {
			engine.audio.bass = levels.bass;
			engine.audio.mid = levels.mid;
		}
		stepTween(dt);
		applyToolState();
		controls.autoRotate = state.autoOrbit && !state.pressed && state.tool !== 'orbit' ? true : state.autoOrbit && state.tool === 'orbit' && !state.pressed;
		controls.update();
		engine.step(dt);
		backdrop.update(engine.time, levels ? levels.bass : 0);
		composer.render();

		if (dt > 1 / 24 && state.quality !== 'lite' && state.busy === 0) slowFrames++;
		else slowFrames = Math.max(0, slowFrames - 1);
		if (slowFrames > 150 && !slowWarned) {
			slowWarned = true;
			toast('This is running slowly on your GPU.', {
				action: {
					label: 'Switch to Lite',
					run: () => {
						el.quality.value = 'lite';
						el.quality.dispatchEvent(new Event('change'));
					},
				},
				ms: 10000,
			});
		}
	}

	// ── Go ───────────────────────────────────────────────────────────────
	selectTool(state.tool);
	syncPresets();
	createEngine();
	frame();
	setSlot('A', state.a).then(() => (state.b !== state.a ? setSlot('B', state.b) : null));
	document.addEventListener('visibilitychange', tick);
	window.__dissolve = { state, get engine() { return state.engine; } };
}

// ── Backdrop: starfield, floor glow and rings that breathe with the bass ────
function buildBackdrop() {
	const group = new THREE.Group();
	const n = 2600;
	const pos = new Float32Array(n * 3);
	for (let i = 0; i < n; i++) {
		const r = 18 + Math.random() * 22;
		const th = Math.random() * Math.PI * 2;
		const u = Math.random() * 2 - 1;
		const s = Math.sqrt(1 - u * u);
		pos[i * 3] = Math.cos(th) * s * r;
		pos[i * 3 + 1] = u * r;
		pos[i * 3 + 2] = Math.sin(th) * s * r;
	}
	const stars = new THREE.Points(
		new THREE.BufferGeometry().setAttribute('position', new THREE.BufferAttribute(pos, 3)),
		new THREE.PointsMaterial({ color: 0x8fb4ff, size: 0.06, transparent: true, opacity: 0.55, depthWrite: false }),
	);
	group.add(stars);

	const floor = new THREE.Mesh(
		new THREE.CircleGeometry(4.2, 96),
		new THREE.ShaderMaterial({
			transparent: true,
			depthWrite: false,
			blending: THREE.AdditiveBlending,
			uniforms: { uTime: { value: 0 }, uBass: { value: 0 } },
			vertexShader: 'varying vec2 vP; void main(){ vP = position.xy; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }',
			fragmentShader: `
				varying vec2 vP; uniform float uTime; uniform float uBass;
				void main(){
					float r = length(vP);
					float glow = exp(-r*r*0.55) * 0.20;
					float ring = 0.0;
					for (int i = 1; i <= 4; i++) {
						float rr = float(i) * 0.85 + uBass * 0.25;
						ring += exp(-pow((r - rr) * 14.0, 2.0)) * (0.20 / float(i));
					}
					float fade = smoothstep(4.2, 1.2, r);
					gl_FragColor = vec4(vec3(0.15, 0.55, 1.0) * (glow + ring * fade), 1.0);
				}
			`,
		}),
	);
	floor.rotation.x = -Math.PI / 2;
	floor.position.y = -1.002;
	group.add(floor);

	return {
		group,
		update(time, bass) {
			floor.material.uniforms.uTime.value = time;
			floor.material.uniforms.uBass.value = bass;
			stars.rotation.y = time * 0.01;
		},
	};
}