feat(auth): prove an ordinary domain with a TXT record

The commodity half of "sign in with a name", and the last unblocked
piece of the design. There is no key to sign with in the public root, so
the proof is the one thing only the holder can do: publish the challenge
under the domain.

The record to create travels with the challenge response, so nothing has
to describe it twice and drift from what is actually checked.

Resolution goes to PUBLIC resolvers over DoH, never the system resolver.
That is the point rather than an implementation detail: any box running
the Moshpit DNS bridge answers for its own endings locally, so asking the
machine we happen to be on whether a name exists in the public root asks
the wrong authority. It is the same confusion that made moshcode.sh
redirect into the pit.

Other things worth keeping:

- SERVFAIL is not NXDOMAIN. Only NOERROR and NXDOMAIN are answers; a
  resolver failing is an outage and answers 503, because reading a
  non-answer as absence refuses a good proof for the length of somebody
  else's outage.
- The lookup runs BEFORE the burn. Publishing DNS is slow and people
  retry while it propagates, so spending the challenge on a lookup that
  ran too early would make "I just added it" the case that fails.
- A challenge minted in one namespace cannot be spent in the other.
- TXT character-strings are joined before comparing; a value crossing the
  255-byte boundary would otherwise never match.
- Domains take 2+ labels (example.co.uk), so the challenge route now
  normalizes per namespace. A bare IP is refused: whoever holds the
  address today would otherwise answer for it.

Provisioning is extracted to lib/auth/name-account.js and shared with the
Moshpit path rather than duplicated -- its 10 tests still pass unchanged.

Migration 20260827182712 (applied; user_names was empty) makes pin_kind
nullable and ties both pin columns to the proof: a pin-signature binding
must carry a pin, a dns-txt binding must not. Without it every DNS
binding would default pin_kind to 'tls' and quietly assert a key kind
nobody checked.

Suite 560 green, up from 534.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018gSbLXLe3hMPnhcjpEtxwf

Author: ralyodio

src/app/api/auth/dns/verify/route.js

@@ -0,0 +1,124 @@
+/**
+ * @fileoverview POST /api/auth/dns/verify — prove an ordinary domain, get a session.
+ *
+ * The commodity half of "sign in with a name". There is no key to sign with in
+ * the public root, so the proof is the one thing only the holder can do:
+ * publish the challenge under the domain. The record to create travels with the
+ * challenge (see the challenge route), so nothing has to describe it twice.
+ *
+ * Weaker than the Moshpit path on purpose, and worth being clear about: whoever
+ * controls DNS controls the identity, so a registrar seizure or a lapsed
+ * renewal is an account takeover. `recheck_at` is what limits the window.
+ *
+ * Additive only: does NOT touch the phone/SMS, CoinPay, anon or Moshpit flows.
+ */
+
+import { NextResponse } from 'next/server';
+import { normalizeDnsName, verifyDnsProof, DnsProofError } from '@/lib/auth/dns-name.js';
+import {
+	createServiceClient,
+	loadSpendableChallenge,
+	burnChallenge,
+	provisionNameAccount,
+	mintSession,
+	ProvisionError
+} from '@/lib/auth/name-account.js';
+
+/**
+ * POST /api/auth/dns/verify
+ *
+ * Body: { jti, name, publicKey, displayName? }
+ * Returns: { success, session, user }
+ *
+ * @param {import('next/server').NextRequest} request
+ */
+export async function POST(request) {
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return NextResponse.json({ error: 'Invalid request format' }, { status: 400 });
+	}
+
+	const { jti, publicKey, displayName } = body || {};
+	const name = normalizeDnsName(body?.name);
+
+	if (!name) {
+		return NextResponse.json({ error: 'Not a valid domain name' }, { status: 400 });
+	}
+	if (typeof jti !== 'string' || !jti) {
+		return NextResponse.json({ error: 'A challenge id is required' }, { status: 400 });
+	}
+	const mlkemKey = typeof publicKey === 'string' ? publicKey.trim() : '';
+	if (!mlkemKey) {
+		return NextResponse.json({ error: 'A public key is required' }, { status: 400 });
+	}
+
+	const serviceSupabase = createServiceClient();
+
+	// --- a) Load the challenge ---
+	const loaded = await loadSpendableChallenge(serviceSupabase, jti, { name, namespace: 'dns' });
+	if ('error' in loaded) {
+		return NextResponse.json({ error: loaded.error }, { status: 400 });
+	}
+	const { challenge } = loaded;
+
+	// --- b) Look for the record BEFORE burning anything ---
+	//
+	// Publishing DNS is slow and people will retry while it propagates. Spending
+	// the challenge on a lookup that simply ran too early would make the honest
+	// case -- "I just added it" -- the one that fails.
+	try {
+		await verifyDnsProof({ name: challenge.name, nonce: challenge.nonce });
+	} catch (error) {
+		if (error instanceof DnsProofError) {
+			return NextResponse.json(
+				{ error: error.message, code: error.code },
+				{ status: error.definite ? 400 : 503 }
+			);
+		}
+		console.error('dns/verify: unexpected verification failure', error);
+		return NextResponse.json({ error: 'Could not verify that proof' }, { status: 500 });
+	}
+
+	try {
+		// --- c) Burn the challenge, atomically ---
+		if (!(await burnChallenge(serviceSupabase, jti))) {
+			return NextResponse.json({ error: 'That challenge has already been used' }, { status: 400 });
+		}
+
+		// No pin and no pin kind: there is no key in this path, and the schema
+		// refuses a binding that claims otherwise.
+		const { userRow, email } = await provisionNameAccount({
+			serviceSupabase,
+			name,
+			namespace: 'dns',
+			proof: 'dns-txt',
+			boundPin: null,
+			pinKind: null,
+			mlkemKey,
+			displayName
+		});
+
+		const session = await mintSession(serviceSupabase, email);
+
+		return NextResponse.json({
+			success: true,
+			name,
+			namespace: 'dns',
+			session,
+			user: {
+				id: userRow.id,
+				username: userRow.username,
+				display_name: userRow.display_name,
+				account_type: userRow.account_type
+			}
+		});
+	} catch (error) {
+		if (error instanceof ProvisionError) {
+			return NextResponse.json({ error: error.message }, { status: error.status });
+		}
+		console.error('dns/verify: unexpected failure', error);
+		return NextResponse.json({ error: 'Could not verify that proof' }, { status: 500 });
+	}
+}

src/app/api/auth/dns/verify/route.test.js

@@ -0,0 +1,210 @@
+/**
+ * @fileoverview Tests for POST /api/auth/dns/verify.
+ *
+ * The invariants that matter here are the same as the Moshpit path's, plus one
+ * of its own: a lookup that ran before DNS propagated must not spend the
+ * challenge, because "I just added the record" is the honest case.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+	verifyDnsProof: vi.fn(),
+	createClient: vi.fn(),
+	createSupabaseServerClient: vi.fn(),
+	deriveUniqueUsername: vi.fn(async () => 'example')
+}));
+
+vi.mock('@supabase/supabase-js', () => ({ createClient: mocks.createClient }));
+vi.mock('@/lib/supabase.js', () => ({
+	createSupabaseServerClient: mocks.createSupabaseServerClient
+}));
+vi.mock('@/lib/auth/coinpay.js', () => ({ deriveUniqueUsername: mocks.deriveUniqueUsername }));
+vi.mock('@/lib/auth/dns-name.js', async (importOriginal) => {
+	const actual = await importOriginal();
+	return { ...actual, verifyDnsProof: mocks.verifyDnsProof };
+});
+
+const NAME = 'example.com';
+const JTI = 'challenge-1';
+
+const liveChallenge = (over = {}) => ({
+	jti: JTI,
+	name: NAME,
+	namespace: 'dns',
+	nonce: 'the-nonce',
+	consumed_at: null,
+	expires_at: new Date(Date.now() + 60_000).toISOString(),
+	...over
+});
+
+function supabaseStub({ challenge = liveChallenge(), burnRows = [{ jti: JTI }], onUpsert } = {}) {
+	const table = (name) => ({
+		select() {
+			return this;
+		},
+		eq() {
+			return this;
+		},
+		is() {
+			return this;
+		},
+		ilike() {
+			return this;
+		},
+		gte() {
+			return this;
+		},
+		single: async () =>
+			name === 'name_challenges'
+				? { data: challenge, error: challenge ? null : { code: 'PGRST116' } }
+				: { data: null, error: { code: 'PGRST116' } },
+		update() {
+			return {
+				eq() {
+					return this;
+				},
+				is() {
+					return this;
+				},
+				select: async () => ({ data: burnRows, error: null })
+			};
+		},
+		insert() {
+			return {
+				select: () => ({
+					single: async () => ({
+						data: { id: 'user-1', username: 'example', display_name: NAME, account_type: 'name' },
+						error: null
+					})
+				})
+			};
+		},
+		upsert: async (row) => {
+			onUpsert?.(name, row);
+			return { error: null };
+		},
+		delete() {
+			return this;
+		}
+	});
+
+	return {
+		from: (name) => table(name),
+		auth: {
+			admin: {
+				listUsers: async () => ({ data: { users: [] }, error: null }),
+				createUser: async () => ({ data: { user: { id: 'auth-1' } }, error: null }),
+				generateLink: async () => ({ data: { properties: { hashed_token: 'tok' } }, error: null })
+			}
+		}
+	};
+}
+
+function dnsRequest(over = {}) {
+	return new Request('https://example.com/api/auth/dns/verify', {
+		method: 'POST',
+		body: JSON.stringify({ jti: JTI, name: NAME, publicKey: 'ml-kem-public-key', ...over })
+	});
+}
+
+describe('dns/verify', () => {
+	beforeEach(() => {
+		vi.resetModules();
+		vi.clearAllMocks();
+		mocks.verifyDnsProof.mockResolvedValue({
+			name: NAME,
+			record: `_qryptchat-challenge.${NAME}`,
+			resolver: 'https://cloudflare-dns.com/dns-query'
+		});
+		mocks.createSupabaseServerClient.mockResolvedValue({
+			auth: {
+				verifyOtp: async () => ({
+					data: { session: { access_token: 'a', refresh_token: 'r', expires_at: 1 } },
+					error: null
+				})
+			}
+		});
+	});
+
+	it('signs in a domain whose record carries the challenge', async () => {
+		mocks.createClient.mockReturnValue(supabaseStub());
+		const { POST } = await import('./route.js');
+		const res = await POST(dnsRequest());
+		const bodyJson = await res.json();
+		expect(res.status).toBe(200);
+		expect(bodyJson).toMatchObject({ success: true, name: NAME, namespace: 'dns' });
+	});
+
+	it('binds with no pin, because this path has no key', async () => {
+		// The schema refuses a dns-txt binding that claims a pin, so a regression
+		// here would surface as a constraint violation in prod rather than here.
+		const rows = [];
+		mocks.createClient.mockReturnValue(
+			supabaseStub({ onUpsert: (table, row) => rows.push([table, row]) })
+		);
+		const { POST } = await import('./route.js');
+		await POST(dnsRequest());
+		const [, binding] = rows.find(([t]) => t === 'user_names');
+		expect(binding).toMatchObject({ namespace: 'dns', proof: 'dns-txt', bound_pin: null, pin_kind: null });
+	});
+
+	it('will not spend the challenge when the record has not propagated', async () => {
+		// "I just added it" is the honest case and must stay retryable.
+		const { DnsProofError } = await import('@/lib/auth/dns-name.js');
+		mocks.verifyDnsProof.mockRejectedValue(new DnsProofError('record_not_found', 'not there yet'));
+		const stub = supabaseStub();
+		const touched = vi.spyOn(stub, 'from');
+		mocks.createClient.mockReturnValue(stub);
+		const { POST } = await import('./route.js');
+		const res = await POST(dnsRequest());
+		expect(res.status).toBe(400);
+		expect(touched.mock.calls.every(([t]) => t === 'name_challenges')).toBe(true);
+	});
+
+	it('answers 503 when no public resolver could be reached', async () => {
+		const { DnsProofError } = await import('@/lib/auth/dns-name.js');
+		mocks.verifyDnsProof.mockRejectedValue(
+			new DnsProofError('resolvers_unreachable', 'down', { definite: false })
+		);
+		mocks.createClient.mockReturnValue(supabaseStub());
+		const { POST } = await import('./route.js');
+		expect((await POST(dnsRequest())).status).toBe(503);
+	});
+
+	it('refuses a challenge minted in the Moshpit namespace', async () => {
+		// Otherwise a name proved cheaply in one namespace could be spent in the
+		// other, which is the impersonation the namespace column exists to stop.
+		mocks.createClient.mockReturnValue(
+			supabaseStub({ challenge: liveChallenge({ namespace: 'moshpit' }) })
+		);
+		const { POST } = await import('./route.js');
+		const res = await POST(dnsRequest());
+		expect(res.status).toBe(400);
+		expect((await res.json()).error).toMatch(/different namespace/i);
+	});
+
+	it('refuses when it loses the burn race', async () => {
+		mocks.createClient.mockReturnValue(supabaseStub({ burnRows: [] }));
+		const { POST } = await import('./route.js');
+		const res = await POST(dnsRequest());
+		expect(res.status).toBe(400);
+		expect((await res.json()).error).toMatch(/already been used/i);
+	});
+
+	it('accepts a domain with more than two labels', async () => {
+		mocks.createClient.mockReturnValue(
+			supabaseStub({ challenge: liveChallenge({ name: 'example.co.uk' }) })
+		);
+		mocks.verifyDnsProof.mockResolvedValue({ name: 'example.co.uk', record: 'x', resolver: 'y' });
+		const { POST } = await import('./route.js');
+		const res = await POST(dnsRequest({ name: 'example.co.uk' }));
+		expect(res.status).toBe(200);
+	});
+
+	it('refuses a bare address', async () => {
+		mocks.createClient.mockReturnValue(supabaseStub());
+		const { POST } = await import('./route.js');
+		expect((await POST(dnsRequest({ name: '192.168.1.1' }))).status).toBe(400);
+	});
+});