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.

30.3 KB
Raw Blame
// Instant Agent Genesis — selfie/prompt/remix → rigged 3D avatar → agent +
// custodial Solana/EVM wallet → optional ERC-8004 on-chain identity, in one
// guided flow. Every step is real:
//
//   • 3D body          POST /api/avatars/reconstruct  (text prompt OR photo),
//                      poll /api/avatars/regenerate-status  — the same rigged-
//                      avatar pipeline /create/prompt and /create/selfie use.
//                      Remix instead forks a public avatar (POST /api/avatars/fork).
//   • agent + wallet   reconstruct/fork auto-provision the agent; we resolve it
//                      via GET /api/agents?avatar_id=… and guarantee both wallets
//                      with POST /api/agents/:id/wallet/provision (real addresses).
//   • persona + voice  POST /api/persona/extract synthesizes a system prompt,
//                      PATCH /api/agents/:id persists name + persona + voice.
//   • on-chain id      bindExistingAgentOnchain() mints a real ERC-8004 record
//                      and returns a real tx hash.
//
// No mocks, no fake progress: the bar is driven by the real job state, the wallet
// address is the real custodial address, the tx hash is the real signature.

import { apiFetch } from './api.js';
import { getMe } from './account.js';
import { rippleOnce } from './ui-juice.js';
import { shortAddress } from './shared/address.js';
// wallet-auth.js and erc8004/agent-registry.js pull in ethers — heavy and only
// needed when the user actually signs in or registers an identity. They're
// dynamically imported at those call sites so the initial genesis bundle stays light.

const $ = (sel, root = document) => root.querySelector(sel);
const $$ = (sel, root = document) => Array.from(root.querySelectorAll(sel));

// ── Constants ──────────────────────────────────────────────────────────────
const RECONSTRUCT_ENDPOINT = '/api/avatars/reconstruct';
const STATUS_ENDPOINT = '/api/avatars/regenerate-status';
const POLL_FIRST_MS = 1500;
const POLL_BACKOFF = 1.4;
const POLL_MAX_MS = 12000;
const GENERATION_DEADLINE_MS = 8 * 60 * 1000;
const AGENT_RESOLVE_DEADLINE_MS = 60 * 1000;
const REGISTER_CHAIN_ID = 8453; // Base — same default as the rest of the platform

const EXAMPLE_PROMPTS = [
	'A silver-haired explorer in a teal flight jacket',
	'A neon cyber-samurai with a glowing visor',
	'A friendly robot barista with copper plating',
	'A cosmic oracle in flowing star-speckled robes',
	'A rugged desert ranger in a dust-worn cloak',
];

// ── State ──────────────────────────────────────────────────────────────────
const state = {
	authed: false,
	mode: 'text',
	photoDataUrl: null,
	remixAvatarId: null,
	abort: null,
	startedAt: 0,
	elapsedTimer: null,
	// outputs
	avatarId: null,
	agent: null, // { id, solana_address, wallet_address, home_url, name }
	modelUrl: null,
	onchain: null,
};

// ── Stage helpers ──────────────────────────────────────────────────────────
function showStage(name) {
	$$('[data-stage]').forEach((el) => {
		el.hidden = el.dataset.stage !== name;
	});
	window.scrollTo({ top: 0, behavior: 'smooth' });
	// The reveal is the real "it shipped" beat — the agent is born and on screen.
	// One restrained ripple on the reveal card marks it (reduced-motion-safe).
	if (name === 'reveal') rippleOnce(document.querySelector('.gx-stage[data-stage="reveal"] .gx-reveal'));
}

function showError(elId, message, onRetry) {
	const el = document.getElementById(elId);
	if (!el) return;
	el.innerHTML = '';
	const p = document.createElement('div');
	p.textContent = message;
	el.appendChild(p);
	if (onRetry) {
		const btn = document.createElement('button');
		btn.className = 'gx-btn gx-btn-ghost';
		btn.textContent = 'Try again';
		btn.addEventListener('click', onRetry);
		el.appendChild(btn);
	}
	el.hidden = false;
}

function clearError(elId) {
	const el = document.getElementById(elId);
	if (el) el.hidden = true;
}

function setStep(step, stateName, detail) {
	const el = $(`.gx-step[data-step="${step}"]`);
	if (!el) return;
	el.dataset.state = stateName;
	if (detail != null) {
		const d = $('[data-role="detail"]', el);
		if (d) d.textContent = detail;
	}
}

function setStepBar(step, pct) {
	const el = $(`.gx-step[data-step="${step}"] [data-role="bar"]`);
	if (el) el.style.width = `${Math.max(0, Math.min(100, pct))}%`;
}

// ── Model viewer ───────────────────────────────────────────────────────────
function mountModelViewer(container, src) {
	container.innerHTML = '';
	const mv = document.createElement('model-viewer');
	mv.setAttribute('src', src);
	mv.setAttribute('alt', 'Your new 3D agent');
	mv.setAttribute('auto-rotate', '');
	mv.setAttribute('rotation-per-second', '14deg');
	mv.setAttribute('interaction-prompt', 'none');
	mv.setAttribute('camera-controls', '');
	mv.setAttribute('shadow-intensity', '0.8');
	mv.setAttribute('shadow-softness', '0.9');
	mv.setAttribute('environment-image', 'neutral');
	mv.setAttribute('exposure', '0.95');
	mv.setAttribute('camera-orbit', '0deg 80deg auto');
	mv.setAttribute('loading', 'eager');
	container.appendChild(mv);
}

// ── Auth ───────────────────────────────────────────────────────────────────
async function refreshAuth() {
	let me = null;
	try {
		me = await getMe();
	} catch {
		me = null;
	}
	state.authed = !!(me && me.id);
	const banner = $('#gx-auth');
	if (banner) banner.hidden = state.authed;
	return state.authed;
}

async function handleSignIn() {
	const btn = $('#gx-signin');
	if (btn) {
		btn.disabled = true;
		btn.textContent = 'Connecting…';
	}
	try {
		const { signInWithWallet } = await import('./wallet-auth.js');
		await signInWithWallet();
		await refreshAuth();
	} catch (err) {
		showError('gx-input-error', err?.message || 'Sign-in failed. Try again.');
	} finally {
		if (btn) {
			btn.disabled = false;
			btn.textContent = 'Sign in';
		}
	}
}

// ── Input wiring ───────────────────────────────────────────────────────────
function selectMode(mode) {
	state.mode = mode;
	$$('.gx-tab').forEach((t) => t.setAttribute('aria-selected', String(t.dataset.mode === mode)));
	$$('.gx-panel').forEach((p) => {
		p.hidden = p.dataset.panel !== mode;
	});
	if (mode === 'remix') loadRemixGallery();
}

function renderExampleChips() {
	const wrap = $('#gx-chips');
	if (!wrap) return;
	EXAMPLE_PROMPTS.forEach((text) => {
		const b = document.createElement('button');
		b.type = 'button';
		b.className = 'gx-chip';
		b.textContent = text;
		b.addEventListener('click', () => {
			$('#gx-prompt').value = text;
			$('#gx-prompt').focus();
		});
		wrap.appendChild(b);
	});
}

async function loadVoices() {
	try {
		const res = await fetch('/api/tts/voices', { credentials: 'omit' });
		if (!res.ok) return;
		const data = await res.json();
		const select = $('#gx-voice');
		if (!select || !Array.isArray(data.voices)) return;
		for (const v of data.voices) {
			const id = v.id || v.voice_id;
			if (!id) continue;
			const opt = document.createElement('option');
			opt.value = id;
			opt.textContent = v.name || v.label || id;
			select.appendChild(opt);
		}
	} catch {
		/* voice picker stays at browser default — non-fatal */
	}
}

function handlePhotoFile(file) {
	if (!file || !file.type.startsWith('image/')) return;
	const reader = new FileReader();
	reader.onload = () => {
		state.photoDataUrl = String(reader.result || '');
		$('#gx-photo-img').src = state.photoDataUrl;
		$('#gx-photo-preview').classList.add('is-on');
	};
	reader.readAsDataURL(file);
}

function wirePhotoInput() {
	const input = $('#gx-photo-input');
	const drop = $('#gx-drop');
	input.addEventListener('change', () => handlePhotoFile(input.files?.[0]));
	['dragenter', 'dragover'].forEach((ev) =>
		drop.addEventListener(ev, (e) => {
			e.preventDefault();
			drop.classList.add('is-drag');
		}),
	);
	['dragleave', 'drop'].forEach((ev) =>
		drop.addEventListener(ev, (e) => {
			e.preventDefault();
			drop.classList.remove('is-drag');
		}),
	);
	drop.addEventListener('drop', (e) => handlePhotoFile(e.dataTransfer?.files?.[0]));
	$('#gx-photo-clear').addEventListener('click', () => {
		state.photoDataUrl = null;
		input.value = '';
		$('#gx-photo-preview').classList.remove('is-on');
	});
}

async function loadRemixGallery() {
	const grid = $('#gx-remix-grid');
	if (!grid || grid.dataset.loaded) return;
	try {
		const res = await fetch('/api/avatars/featured?limit=18', { credentials: 'include' });
		const data = await res.json();
		const avatars = (data.avatars || data.data || []).filter((a) => a && a.id);
		if (!avatars.length) {
			grid.innerHTML = '<p class="gx-hint">No public avatars to fork yet — try Describe or Selfie.</p>';
			return;
		}
		grid.innerHTML = '';
		for (const a of avatars) {
			const thumb = a.thumb_url || a.thumbnail_url || a.thumbnail || a.poster_url;
			if (!thumb) continue;
			const tile = document.createElement('button');
			tile.type = 'button';
			tile.className = 'gx-remix-tile';
			tile.setAttribute('aria-pressed', 'false');
			// Avatar names are written by other users, so the tile is built as DOM
			// nodes rather than an HTML string.
			const img = document.createElement('img');
			img.loading = 'lazy';
			img.src = thumb;
			img.alt = a.name || 'Avatar';
			const label = document.createElement('span');
			label.textContent = a.name || 'Avatar';
			tile.append(img, label);
			tile.addEventListener('click', () => {
				state.remixAvatarId = a.id;
				$$('.gx-remix-tile').forEach((t) => t.setAttribute('aria-pressed', 'false'));
				tile.setAttribute('aria-pressed', 'true');
				if (!$('#gx-name').value) $('#gx-name').value = a.name || '';
			});
			grid.appendChild(tile);
		}
		grid.dataset.loaded = '1';
		if (!grid.children.length) {
			grid.innerHTML = '<p class="gx-hint">No public avatars to fork yet — try Describe or Selfie.</p>';
		}
	} catch {
		grid.innerHTML = '<p class="gx-hint">Couldn\'t load avatars. Try Describe or Selfie instead.</p>';
	}
}

// ── Genesis orchestration ──────────────────────────────────────────────────
async function beginGenesis() {
	clearError('gx-input-error');

	if (!(await refreshAuth())) {
		showError('gx-input-error', 'Sign in first — genesis claims the agent and wallet to your account.');
		$('#gx-auth')?.scrollIntoView({ behavior: 'smooth', block: 'center' });
		return;
	}

	// Validate per-mode input before leaving the form.
	const prompt = $('#gx-prompt').value.trim();
	if (state.mode === 'text' && prompt.length < 3) {
		showError('gx-input-error', 'Describe your agent in a few words to begin.');
		return;
	}
	if (state.mode === 'photo' && !state.photoDataUrl) {
		showError('gx-input-error', 'Choose a photo to build your agent from.');
		return;
	}
	if (state.mode === 'remix' && !state.remixAvatarId) {
		showError('gx-input-error', 'Pick a public avatar to fork.');
		return;
	}

	// Reset run state.
	state.abort = new AbortController();
	state.avatarId = null;
	state.agent = null;
	state.modelUrl = null;
	state.onchain = null;
	clearError('gx-forge-error');
	resetForgeUi();
	showStage('forging');
	startElapsed();

	const name = $('#gx-name').value.trim() || null;
	const personaText = $('#gx-persona').value.trim();
	const voiceId = $('#gx-voice').value || null;

	// Persona synthesis (LLM) needs no avatar — run it in parallel with the mesh.
	// Swallow its failure here so a later abort/throw can't surface as an unhandled
	// rejection; a null persona just falls back to the raw text.
	const personaPromise = (personaText ? extractPersona(personaText, name) : Promise.resolve(null)).catch(
		() => null,
	);

	try {
		// 1) Body → avatarId (also auto-provisions the agent server-side).
		let forkAgent = null;
		if (state.mode === 'remix') {
			const forked = await forkAvatar(state.remixAvatarId);
			state.avatarId = forked.avatar.id;
			forkAgent = forked.agent || null;
			setStep('model', 'done', 'Forked into your namespace.');
			setStepBar('model', 100);
		} else {
			const jobId = await submitReconstruct({ name, prompt });
			state.avatarId = await pollReconstruct(jobId);
			setStep('model', 'done', 'Rigged and ready.');
			setStepBar('model', 100);
		}
		if (state.abort.signal.aborted) return;

		// 2) Resolve the agent + guarantee a real custodial wallet.
		setStep('wallet', 'active', 'Provisioning Solana + EVM wallets…');
		const agentId = forkAgent?.id || (await resolveAgentId(state.avatarId));
		const wallet = await provisionWallet(agentId, forkAgent);
		state.agent = {
			id: agentId,
			solana_address: wallet.solana_address,
			wallet_address: wallet.wallet_address,
		};
		setStep('wallet', 'done', 'Wallet live.');
		if (state.abort.signal.aborted) return;

		// 3) Persona + voice + name onto the agent.
		setStep('persona', 'active', personaText ? 'Writing the persona…' : 'Saving identity…');
		const persona = await personaPromise;
		await applyAgentProfile(agentId, { name, persona, personaText, voiceId });
		setStep('persona', 'done', persona ? 'Persona set.' : 'Saved.');

		// 4) Hydrate the reveal.
		await hydrateReveal(agentId, state.avatarId, name);
		stopElapsed();
		showStage('reveal');
	} catch (err) {
		if (state.abort?.signal.aborted) return;
		stopElapsed();
		const active = $('.gx-step[data-state="active"]');
		if (active) active.dataset.state = 'failed';
		showError('gx-forge-error', err?.message || 'Genesis hit a snag. Your inputs are safe — try again.', () => {
			clearError('gx-forge-error');
			showStage('input');
		});
	}
}

async function readJson(res) {
	return res.json().catch(() => ({}));
}

function apiError(data, fallback) {
	return (
		data?.error_description ||
		(typeof data?.error === 'string' ? data.error : null) ||
		data?.message ||
		fallback
	);
}

async function submitReconstruct({ name, prompt }) {
	// A selfie stays private; a described avatar is unlisted — usable and
	// shareable by its owner, but never auto-injected into public galleries.
	const body = { name: name || undefined, visibility: state.mode === 'photo' ? 'private' : 'unlisted' };
	if (state.mode === 'photo') {
		body.photos = [state.photoDataUrl];
		body.params = { bodyType: $('#gx-bodytype').value, style: $('#gx-style').value };
	} else {
		body.prompt = prompt;
		const key = $('#gx-meshy-key')?.value.trim();
		if (key) {
			body.provider_key = key;
			body.provider_name = 'meshy';
		}
	}
	const res = await apiFetch(RECONSTRUCT_ENDPOINT, {
		method: 'POST',
		headers: { 'Content-Type': 'application/json' },
		body: JSON.stringify(body),
		signal: state.abort.signal,
	});
	const data = await readJson(res);
	if (!res.ok || !data.jobId) {
		throw new Error(mapReconstructError(res.status, data));
	}
	return data.jobId;
}

function mapReconstructError(status, data) {
	const code = typeof data?.error === 'string' ? data.error : data?.code;
	if (status === 429 || code === 'txt2img_rate_limited') return 'The avatar engine is busy. Wait a moment and try again.';
	if (code === 'txt2img_error') return "Couldn't render from that prompt. Try rewording it.";
	if (code === 'regen_needs_byok') return 'Avatar generation needs a 3D engine key on this deployment. Add a Meshy or Tripo key in settings, or use the selfie scanner.';
	if (code === 'regen_provider_error') return 'The avatar engines are all busy right now. Try again shortly.';
	if (status === 413) return 'That photo is too large. Try a smaller image.';
	return apiError(data, `The avatar engine returned ${status}. Try again.`);
}

const RECON_PROGRESS = {
	queued: [5, 18, 'Queued behind the avatar engine…'],
	running: [18, 78, 'Sculpting your 3D body…'],
	rigging: [78, 96, 'Rigging the skeleton so it can move…'],
};

async function pollReconstruct(jobId) {
	const deadline = Date.now() + GENERATION_DEADLINE_MS;
	let wait = POLL_FIRST_MS;
	let shown = 5;
	setStepBar('model', shown);
	while (Date.now() < deadline) {
		if (state.abort.signal.aborted) throw new Error('cancelled');
		await sleep(wait, state.abort.signal);
		wait = Math.min(wait * POLL_BACKOFF, POLL_MAX_MS);

		const res = await apiFetch(`${STATUS_ENDPOINT}?jobId=${encodeURIComponent(jobId)}`, {
			allowAnonymous: true,
			signal: state.abort.signal,
		});
		const data = await readJson(res);
		if (!res.ok) throw new Error(apiError(data, `Status check failed (${res.status}).`));

		const band = RECON_PROGRESS[data.status];
		if (band) {
			const [floor, ceil, label] = band;
			shown = Math.min(ceil, Math.max(shown + 3, floor));
			setStepBar('model', shown);
			setStep('model', 'active', label);
		}
		if (data.status === 'done' && data.resultAvatarId) return data.resultAvatarId;
		if (data.status === 'failed') throw new Error(friendlyJobError(data.error));
	}
	throw new Error('Generation took too long. Try a simpler prompt or photo.');
}

function friendlyJobError(code) {
	const map = {
		moderation_blocked: 'That photo was flagged by moderation. Try a clear, front-facing photo of a person.',
		no_face_detected: "Couldn't find a face in that photo. Use a clear, front-facing shot.",
		provider_error: 'The avatar engine failed on this one. Try again or tweak your input.',
	};
	return map[code] || 'The avatar engine couldn\'t finish this one. Try again with a different input.';
}

async function forkAvatar(sourceAvatarId) {
	const res = await apiFetch('/api/avatars/fork', {
		method: 'POST',
		headers: { 'Content-Type': 'application/json' },
		body: JSON.stringify({ source_avatar_id: sourceAvatarId }),
		signal: state.abort.signal,
	});
	const data = await readJson(res);
	if (res.status === 409 && data?.error === 'royalty_consent_required') {
		const pct = data?.royalty?.total_pct ?? 0;
		const ok = window.confirm(
			`This avatar charges a ${pct}% fork royalty to its creators on tips & streams. Fork it on these terms?`,
		);
		if (!ok) throw new Error('Fork cancelled — no royalty accepted.');
		return forkAvatarWithConsent(sourceAvatarId);
	}
	if (!res.ok || !data.avatar?.id) throw new Error(apiError(data, 'Could not fork that avatar.'));
	return data;
}

async function forkAvatarWithConsent(sourceAvatarId) {
	const res = await apiFetch('/api/avatars/fork', {
		method: 'POST',
		headers: { 'Content-Type': 'application/json' },
		body: JSON.stringify({ source_avatar_id: sourceAvatarId, accept_royalty: true }),
		signal: state.abort.signal,
	});
	const data = await readJson(res);
	if (!res.ok || !data.avatar?.id) throw new Error(apiError(data, 'Could not fork that avatar.'));
	return data;
}

async function resolveAgentId(avatarId) {
	const deadline = Date.now() + AGENT_RESOLVE_DEADLINE_MS;
	let wait = 800;
	while (Date.now() < deadline) {
		if (state.abort.signal.aborted) throw new Error('cancelled');
		const res = await apiFetch(`/api/agents?avatar_id=${encodeURIComponent(avatarId)}`, {
			allowAnonymous: true,
			signal: state.abort.signal,
		});
		const data = await readJson(res);
		const agents = data.agents || data.data?.agents || [];
		const agent = agents.find((a) => a && a.id);
		if (agent) return agent.id;
		await sleep(wait, state.abort.signal);
		wait = Math.min(wait * 1.4, 4000);
	}
	throw new Error('Your agent is taking longer than usual to wake up. Refresh in a moment — it will be in your account.');
}

async function provisionWallet(agentId, forkAgent) {
	// Fork already provisioned both wallets synchronously and handed them back.
	if (forkAgent?.solana_address || forkAgent?.wallet_address) {
		return { solana_address: forkAgent.solana_address, wallet_address: forkAgent.wallet_address };
	}
	const res = await apiFetch(`/api/agents/${encodeURIComponent(agentId)}/wallet/provision`, {
		method: 'POST',
		signal: state.abort.signal,
	});
	const data = await readJson(res);
	if (!res.ok) throw new Error(apiError(data, 'Could not provision the wallet.'));
	return { solana_address: data.solana_address, wallet_address: data.wallet_address };
}

async function extractPersona(freeform, name) {
	const res = await apiFetch('/api/persona/extract', {
		method: 'POST',
		headers: { 'Content-Type': 'application/json' },
		body: JSON.stringify({ freeform: name ? `${name}: ${freeform}` : freeform }),
	});
	if (!res.ok) return null;
	const data = await readJson(res);
	return data.persona || null;
}

function composePersonaPrompt(name, persona, fallbackText) {
	if (!persona) return fallbackText || null;
	const who = name || 'this agent';
	const lines = [`You are ${who}, a 3D AI agent on three.ws.`];
	if (persona.tone) lines.push(persona.tone);
	if (persona.communication_style) lines.push(`Your communication style is ${persona.communication_style}.`);
	if (Array.isArray(persona.interests) && persona.interests.length) {
		lines.push(`You care about ${persona.interests.join(', ')}.`);
	}
	if (Array.isArray(persona.vocabulary) && persona.vocabulary.length) {
		lines.push(`You naturally say things like: ${persona.vocabulary.slice(0, 6).join('; ')}.`);
	}
	if (Array.isArray(persona.dont_say) && persona.dont_say.length) {
		lines.push(`Never say: ${persona.dont_say.join('; ')}.`);
	}
	return lines.join(' ');
}

async function applyAgentProfile(agentId, { name, persona, personaText, voiceId }) {
	const personaPrompt = composePersonaPrompt(name, persona, personaText);
	const meta = { created_via: 'genesis' };
	if (voiceId) {
		meta.voice_preference = voiceId;
		meta.voice_id = voiceId;
	}
	if (persona?.sample_greeting) meta.greeting = persona.sample_greeting;
	const body = { meta };
	if (name) body.name = name;
	if (personaPrompt) body.persona_prompt = personaPrompt.slice(0, 8000);

	// Best-effort: a profile-write hiccup must not lose the already-created agent.
	try {
		await apiFetch(`/api/agents/${encodeURIComponent(agentId)}`, {
			method: 'PATCH',
			headers: { 'Content-Type': 'application/json' },
			body: JSON.stringify(body),
		});
	} catch {
		/* the agent exists and is owned; profile can be edited from its page */
	}
}

async function hydrateReveal(agentId, avatarId, name) {
	// Pull the agent for its real name + home_url, and the avatar for its model URL.
	let agentRow = null;
	try {
		const res = await apiFetch(`/api/agents/${encodeURIComponent(agentId)}`, { allowAnonymous: true });
		if (res.ok) agentRow = (await readJson(res)).agent;
	} catch {
		/* fall back to local state below */
	}
	if (agentRow) {
		state.agent.solana_address = agentRow.solana_address || state.agent.solana_address;
		state.agent.wallet_address = agentRow.wallet_address || state.agent.wallet_address;
		state.agent.home_url = agentRow.home_url || null;
		state.agent.name = agentRow.name || name;
	}

	try {
		const res = await apiFetch(`/api/avatars/${encodeURIComponent(avatarId)}`, { allowAnonymous: true });
		if (res.ok) {
			const av = (await readJson(res)).avatar;
			state.modelUrl = av?.model_url || av?.url || null;
		}
	} catch {
		/* viewer falls back to placeholder */
	}

	renderReveal(name);
}

// ── Reveal rendering ───────────────────────────────────────────────────────
function shorten(addr) {
	return shortAddress(addr, 6, 6, { empty: '\u2014' });
}

function walletRow(chainLabel, address) {
	const row = document.createElement('div');
	row.className = 'gx-addr';
	const left = document.createElement('div');
	left.className = 'gx-addr-l';
	left.innerHTML = `<div class="gx-addr-chain">${chainLabel}</div><code title="${address || ''}">${address ? shorten(address) : 'Provisioning…'}</code>`;
	row.appendChild(left);
	if (address) {
		const copy = document.createElement('button');
		copy.className = 'gx-copy';
		copy.type = 'button';
		copy.textContent = 'Copy';
		copy.addEventListener('click', async () => {
			try {
				await navigator.clipboard.writeText(address);
				copy.textContent = 'Copied';
				copy.classList.add('is-copied');
				setTimeout(() => {
					copy.textContent = 'Copy';
					copy.classList.remove('is-copied');
				}, 1600);
			} catch {
				copy.textContent = 'Copy failed';
			}
		});
		row.appendChild(copy);
	}
	return row;
}

function renderReveal(name) {
	const agent = state.agent;
	const displayName = agent.name || name || 'Your Agent';
	$('#gx-reveal-name').textContent = displayName;

	const viewer = $('#gx-reveal-viewer');
	if (state.modelUrl) {
		mountModelViewer(viewer, state.modelUrl);
	} else {
		viewer.innerHTML = '<div class="gx-placeholder" style="height:100%;display:grid;place-items:center"><div><div class="gx-orb"></div>Your agent is ready in your account.</div></div>';
	}

	const wallets = $('#gx-wallets');
	wallets.innerHTML = '';
	wallets.appendChild(walletRow('Solana', agent.solana_address));
	wallets.appendChild(walletRow('EVM · Base', agent.wallet_address));

	$('#gx-cta-fund').href = `/agents/${agent.id}/wallet#deposit`;
	$('#gx-cta-open').href = agent.home_url || `/agents/${agent.id}`;
	$('#gx-cta-share').href = `/api/agent-share?id=${encodeURIComponent(agent.id)}`;

	renderIdentity();
}

function renderIdentity() {
	const badge = $('#gx-identity-badge');
	const body = $('#gx-identity-body');
	if (state.onchain?.txHash) {
		badge.textContent = 'Verified on-chain';
		badge.className = 'gx-badge gx-badge-live';
		const explorer = `https://basescan.org/tx/${state.onchain.txHash}`;
		body.innerHTML = `
			<p class="gx-identity-status">ERC-8004 agent #${state.onchain.agentId ?? ''} on Base. Identity tx:</p>
			<a class="gx-tx" href="${explorer}" target="_blank" rel="noopener">${state.onchain.txHash}</a>`;
		// A real ERC-8004 record just landed — ripple the badge once to mark it.
		rippleOnce(badge);
		return;
	}
	badge.textContent = 'Not registered';
	badge.className = 'gx-badge gx-badge-pending';
	// keep the existing register button + status (set in HTML / reset below)
	if (!$('#gx-register')) {
		body.innerHTML = `
			<button class="gx-btn gx-btn-primary" id="gx-register" type="button" style="width:100%">Register ERC-8004 identity</button>
			<p class="gx-identity-status" id="gx-identity-status">Connect an EVM wallet to mint a verifiable, tradeable identity. Optional — you can do this anytime.</p>`;
	}
	wireRegister();
}

function wireRegister() {
	const btn = $('#gx-register');
	if (!btn || btn.dataset.wired) return;
	btn.dataset.wired = '1';
	btn.addEventListener('click', registerIdentity);
}

async function registerIdentity() {
	const btn = $('#gx-register');
	const status = $('#gx-identity-status');
	if (!btn) return;
	btn.disabled = true;
	const setStatus = (m) => {
		if (status) status.textContent = m;
	};
	setStatus('Connecting your wallet…');
	try {
		const { bindExistingAgentOnchain } = await import('./erc8004/agent-registry.js');
		const result = await bindExistingAgentOnchain(state.agent.id, REGISTER_CHAIN_ID, {
			onStatus: setStatus,
		});
		state.onchain = {
			txHash: result.txHash || result.onchain?.tx_hash || null,
			agentId: result.agentId,
			chainId: result.chainId || REGISTER_CHAIN_ID,
		};
		if (result.alreadyBound && !state.onchain.txHash) {
			state.onchain.txHash = result.onchain?.tx_hash || null;
		}
		if (!state.onchain.txHash) {
			setStatus('Identity registered. Indexing the transaction…');
		}
		renderIdentity();
	} catch (err) {
		btn.disabled = false;
		const msg = err?.message || 'Registration failed.';
		setStatus(
			/wallet|account|reject|connect/i.test(msg)
				? 'Connect an EVM wallet (e.g. MetaMask) to register. You can do this anytime — your agent is already yours.'
				: `${msg} You can retry anytime.`,
		);
	}
}

// ── Forge UI lifecycle ─────────────────────────────────────────────────────
function resetForgeUi() {
	setStep('model', 'active', state.mode === 'remix' ? 'Forking into your namespace…' : 'Warming up the avatar engine…');
	setStepBar('model', 5);
	setStep('wallet', 'pending', 'Waiting on your agent…');
	setStep('persona', 'pending', $('#gx-persona').value.trim() ? 'Queued — writing once the body lands.' : 'Queued.');
	$('#gx-forge-preview').innerHTML =
		'<div class="gx-placeholder"><div class="gx-orb" aria-hidden="true"></div>Your agent is taking shape…</div>';
}

function startElapsed() {
	state.startedAt = Date.now();
	const el = $('#gx-elapsed');
	stopElapsed();
	state.elapsedTimer = setInterval(() => {
		const s = Math.floor((Date.now() - state.startedAt) / 1000);
		if (el) el.textContent = `Elapsed ${s}s`;
	}, 1000);
}

function stopElapsed() {
	if (state.elapsedTimer) {
		clearInterval(state.elapsedTimer);
		state.elapsedTimer = null;
	}
}

function cancelGenesis() {
	state.abort?.abort();
	stopElapsed();
	showStage('input');
}

function resetToInput() {
	state.onchain = null;
	state.agent = null;
	state.avatarId = null;
	state.modelUrl = null;
	state.photoDataUrl = null;
	state.remixAvatarId = null;
	$('#gx-photo-preview')?.classList.remove('is-on');
	$$('.gx-remix-tile').forEach((t) => t.setAttribute('aria-pressed', 'false'));
	showStage('input');
}

// ── Utils ──────────────────────────────────────────────────────────────────
function sleep(ms, signal) {
	return new Promise((resolve, reject) => {
		const t = setTimeout(resolve, ms);
		if (signal) {
			signal.addEventListener(
				'abort',
				() => {
					clearTimeout(t);
					reject(new Error('cancelled'));
				},
				{ once: true },
			);
		}
	});
}

// ── Init ───────────────────────────────────────────────────────────────────
function init() {
	renderExampleChips();
	wirePhotoInput();
	loadVoices();
	refreshAuth();

	$$('.gx-tab').forEach((tab) => tab.addEventListener('click', () => selectMode(tab.dataset.mode)));
	$('#gx-signin')?.addEventListener('click', handleSignIn);
	$('#gx-begin')?.addEventListener('click', beginGenesis);
	$('#gx-cancel')?.addEventListener('click', cancelGenesis);
	$('#gx-again')?.addEventListener('click', resetToInput);
	wireRegister();
}

if (document.readyState === 'loading') {
	document.addEventListener('DOMContentLoaded', init);
} else {
	init();
}