@fabrika/app 0.7.0 → 0.8.0

package/src/implement/challenge.ts

@@ -1,10 +1,15 @@
 // A form's challenge, verified on the server before its row is written. The provider list is closed: Turnstile's
 // siteverify is the only endpoint the framework asks, with the secret from the application variable the contract
-// names. A token verifies only for this host and this form's action, while it is fresh; the dispatcher then records
+// names; an ALTCHA challenge the application issues and verifies itself, with the HMAC key that variable holds, and asks
+// no one. A token verifies only for this host and this form's action, while it is fresh; the dispatcher then records
 // it, so its second use is a replay whatever the provider says.
 
-import type { ChallengeProvider } from '@fabrika/auth-core'
+import type { AltchaChallenge, ChallengeProvider } from '@fabrika/auth-core'
+import { createChallenge, randomInt, verifySolution } from 'altcha-lib'
+import { deriveKey } from 'altcha-lib/algorithms/web/pbkdf2'
+import { createHmac } from 'node:crypto'
 import { z } from 'zod/v4'
+import { ALTCHA_LIMITS } from '../contract/defaults'
 import { readBoundedBytes } from './bounded'
 
 export const TURNSTILE_VERIFY_URL = 'https://challenges.cloudflare.com/turnstile/v0/siteverify'
@@ -37,11 +42,23 @@ export interface ChallengeCheck {
 	readonly action: string
 }
 
+/**
+ * A verification's answer. A passed one names what the dispatcher records it by: the token itself, or, for ALTCHA, the
+ * signature of the challenge it solved, since one solution can be encoded as many tokens. Its record lasts at least
+ * as long as this token could pass again, even if the issuer's configured lifetime has since changed.
+ */
+export type ChallengeVerdict =
+	| { readonly outcome: 'passed'; readonly replayKey: string; readonly recordMs: number }
+	| { readonly outcome: Exclude<ChallengeOutcome, 'passed'> }
+
 export interface ChallengeVerifier {
 	readonly provider: ChallengeProvider
-	verify(check: ChallengeCheck): Promise<ChallengeOutcome>
+	verify(check: ChallengeCheck): Promise<ChallengeVerdict>
 }
 
+const verdictOf = (outcome: ChallengeOutcome, replayKey: string, recordMs: number): ChallengeVerdict =>
+	outcome === 'passed' ? { outcome, replayKey, recordMs } : { outcome }
+
 /** A token as the widget issues it: printable ASCII without spaces, within the provider's length. */
 const TOKEN = new RegExp(`^[\\x21-\\x7e]{1,${CHALLENGE_LIMITS.maxTokenLength}}$`)
 
@@ -61,55 +78,60 @@ const SECRET_ERRORS = ['missing-input-secret', 'invalid-input-secret']
 export function turnstileVerifier(secret: string, fetch: ChallengeFetch, now: () => number = Date.now): ChallengeVerifier {
 	const verifier: ChallengeVerifier = {
 		provider: 'turnstile',
-		async verify(check: ChallengeCheck): Promise<ChallengeOutcome> {
-			if (!TOKEN.test(check.token)) {
-				return 'failed'
-			}
-			const deadline = new AbortController()
-			const timer = setTimeout(() => deadline.abort(), CHALLENGE_LIMITS.timeoutMs)
-			let raw: Uint8Array<ArrayBuffer> | null
-			try {
-				const response = await fetch(
-					new Request(TURNSTILE_VERIFY_URL, {
-						method: 'POST',
-						headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-						body: new URLSearchParams({ secret, response: check.token }),
-						redirect: 'manual',
-						signal: deadline.signal,
-					}),
-					check,
-				)
-				const type = response.headers.get('Content-Type')?.split(';')[0]?.trim().toLowerCase()
-				if (response.status !== 200 || type !== 'application/json') {
-					await response.body?.cancel()
-					return 'unavailable'
-				}
-				raw = await readBoundedBytes(response.body, { maxBytes: CHALLENGE_LIMITS.maxAnswerBytes, signal: deadline.signal })
-			} catch {
-				return 'unavailable'
-			} finally {
-				clearTimeout(timer)
-			}
-			const answer = raw === null ? null : parseAnswer(raw)
-			if (answer === null) {
-				return 'unavailable'
-			}
-			if (!answer.success) {
-				const codes = answer['error-codes'] ?? []
-				if (codes.some((code) => SECRET_ERRORS.includes(code))) {
-					return 'misconfigured'
-				}
-				return codes.includes('internal-error') ? 'unavailable' : 'failed'
-			}
-			const issued = Date.parse(answer.challenge_ts ?? '')
-			const age = now() - issued
-			const fresh = Number.isFinite(issued) && age <= CHALLENGE_LIMITS.maxAgeMs && age >= -CHALLENGE_LIMITS.maxSkewMs
-			return fresh && answer.hostname === check.hostname && answer.action === check.action ? 'passed' : 'failed'
+		async verify(check: ChallengeCheck): Promise<ChallengeVerdict> {
+			return verdictOf(await siteverify(secret, fetch, now, check), check.token, CHALLENGE_LIMITS.maxAgeMs + CHALLENGE_LIMITS.maxSkewMs)
 		},
 	}
 	return Object.freeze(verifier)
 }
 
+/** Turnstile's answer for `check`, under one deadline and a byte budget. */
+async function siteverify(secret: string, fetch: ChallengeFetch, now: () => number, check: ChallengeCheck): Promise<ChallengeOutcome> {
+	if (!TOKEN.test(check.token)) {
+		return 'failed'
+	}
+	const deadline = new AbortController()
+	const timer = setTimeout(() => deadline.abort(), CHALLENGE_LIMITS.timeoutMs)
+	let raw: Uint8Array<ArrayBuffer> | null
+	try {
+		const response = await fetch(
+			new Request(TURNSTILE_VERIFY_URL, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+				body: new URLSearchParams({ secret, response: check.token }),
+				redirect: 'manual',
+				signal: deadline.signal,
+			}),
+			check,
+		)
+		const type = response.headers.get('Content-Type')?.split(';')[0]?.trim().toLowerCase()
+		if (response.status !== 200 || type !== 'application/json') {
+			await response.body?.cancel()
+			return 'unavailable'
+		}
+		raw = await readBoundedBytes(response.body, { maxBytes: CHALLENGE_LIMITS.maxAnswerBytes, signal: deadline.signal })
+	} catch {
+		return 'unavailable'
+	} finally {
+		clearTimeout(timer)
+	}
+	const answer = raw === null ? null : parseAnswer(raw)
+	if (answer === null) {
+		return 'unavailable'
+	}
+	if (!answer.success) {
+		const codes = answer['error-codes'] ?? []
+		if (codes.some((code) => SECRET_ERRORS.includes(code))) {
+			return 'misconfigured'
+		}
+		return codes.includes('internal-error') ? 'unavailable' : 'failed'
+	}
+	const issued = Date.parse(answer.challenge_ts ?? '')
+	const age = now() - issued
+	const fresh = Number.isFinite(issued) && age <= CHALLENGE_LIMITS.maxAgeMs && age >= -CHALLENGE_LIMITS.maxSkewMs
+	return fresh && answer.hostname === check.hostname && answer.action === check.action ? 'passed' : 'failed'
+}
+
 function parseAnswer(raw: Uint8Array<ArrayBuffer>): z.infer<typeof siteverifyAnswer> | null {
 	try {
 		const parsed = siteverifyAnswer.safeParse(JSON.parse(new TextDecoder().decode(raw)))
@@ -118,3 +140,137 @@ function parseAnswer(raw: Uint8Array<ArrayBuffer>): z.infer<typeof siteverifyAns
 		return null
 	}
 }
+
+/**
+ * How hard an ALTCHA challenge is to solve: PBKDF2 attempts of `cost` iterations, up to a count drawn between
+ * `minCounter` and `maxCounter`. The contract's by default; a test kit and `fabrika app dev` make it cheap.
+ */
+export interface ChallengeWork {
+	readonly cost: number
+	readonly minCounter: number
+	readonly maxCounter: number
+}
+
+/** The cheapest work: the test kit's and `fabrika app dev`'s, so a test solves a challenge in milliseconds. */
+export const MINIMAL_CHALLENGE_WORK: ChallengeWork = Object.freeze({ cost: 1, minCounter: 1, maxCounter: 10 })
+
+/** What the issuing endpoint answers: the signed parameters, which the widget solves and sends back with its solution. */
+export interface IssuedChallenge {
+	readonly parameters: Readonly<Record<string, unknown>>
+	readonly signature?: string
+}
+
+export interface ChallengeIssuer {
+	/** A fresh challenge for this host and the procedure's action. */
+	issue(hostname: string): Promise<IssuedChallenge>
+}
+
+const HEX = /^[0-9a-f]+$/
+const hex = (length: number) => z.string().length(length).regex(HEX)
+
+// Strict: exactly what `issue` signs, so a payload of another shape (the widget's `test` mode, a server-signed one) never
+// reaches the verification.
+const altchaPayload = z.strictObject({
+	challenge: z.strictObject({
+		parameters: z.strictObject({
+			algorithm: z.literal(ALTCHA_LIMITS.algorithm),
+			nonce: hex(32),
+			salt: hex(32),
+			cost: z.int().positive(),
+			keyLength: z.literal(32),
+			keyPrefix: hex(32),
+			keySignature: hex(64),
+			expiresAt: z.int().positive(),
+			data: z.strictObject({ action: z.string(), host: z.string() }),
+		}),
+		signature: hex(64),
+	}),
+	solution: z.strictObject({ counter: z.int().nonnegative(), derivedKey: hex(64), time: z.number().nonnegative().optional() }),
+})
+
+type AltchaPayload = z.infer<typeof altchaPayload>
+
+/** A payload as the widget sends it: base64 of its JSON, within the bound. */
+const PAYLOAD = new RegExp(`^[A-Za-z0-9+/]{1,${ALTCHA_LIMITS.maxTokenLength}}={0,2}$`)
+
+/**
+ * The two HMAC keys of an ALTCHA challenge, each derived from the application's key for one use: one signs the
+ * parameters, the other the solution the server knows, so neither signature can stand in for the other.
+ */
+function altchaKeys(secret: string): { readonly signature: string; readonly key: string } {
+	const derive = (use: string) => createHmac('sha256', secret).update(`fabrika-altcha-${use}`).digest('hex')
+	return { signature: derive('challenge'), key: derive('solution') }
+}
+
+function parsePayload(token: string): AltchaPayload | null {
+	if (token.length > ALTCHA_LIMITS.maxTokenLength || !PAYLOAD.test(token)) {
+		return null
+	}
+	try {
+		const parsed = altchaPayload.safeParse(JSON.parse(atob(token)))
+		return parsed.success ? parsed.data : null
+	} catch {
+		return null
+	}
+}
+
+/**
+ * The issuer and the verifier of one public procedure's ALTCHA challenge, with the HMAC key its application variable
+ * holds. A challenge carries the action and the host it was issued for and expires `maxAgeMs` after it was issued; the
+ * server picks the attempt that solves it and signs that attempt's key, so verifying is two HMACs and no proof of work.
+ * Nothing leaves the process. `now` is the clock a challenge's expiry is set with; altcha-lib reads it on the real clock,
+ * and so does the verifier, so the two never disagree.
+ */
+export function altchaChallenge(
+	secret: string,
+	rules: Pick<AltchaChallenge, 'action' | 'cost' | 'maxAgeMs'>,
+	work: ChallengeWork | null = null,
+	now: () => number = Date.now,
+): { readonly issuer: ChallengeIssuer; readonly verifier: ChallengeVerifier } {
+	const keys = altchaKeys(secret)
+	const effort = work ?? { cost: rules.cost, minCounter: ALTCHA_LIMITS.minCounter, maxCounter: ALTCHA_LIMITS.maxCounter }
+	const issuer: ChallengeIssuer = {
+		async issue(hostname: string): Promise<IssuedChallenge> {
+			const challenge = await createChallenge({
+				algorithm: ALTCHA_LIMITS.algorithm,
+				cost: effort.cost,
+				counter: randomInt(effort.maxCounter, effort.minCounter),
+				expiresAt: Math.floor((now() + rules.maxAgeMs) / 1000),
+				data: { action: rules.action, host: hostname },
+				deriveKey,
+				hmacSignatureSecret: keys.signature,
+				hmacKeySignatureSecret: keys.key,
+			})
+			return { parameters: { ...challenge.parameters }, ...(challenge.signature === undefined ? {} : { signature: challenge.signature }) }
+		},
+	}
+	const verifier: ChallengeVerifier = {
+		provider: 'altcha',
+		async verify(check: ChallengeCheck): Promise<ChallengeVerdict> {
+			const payload = parsePayload(check.token)
+			if (payload === null) {
+				return { outcome: 'failed' }
+			}
+			const { parameters } = payload.challenge
+			// The signature covers these; they are read before it only to answer without the HMAC.
+			if (parameters.data.action !== check.action || parameters.data.host !== check.hostname || parameters.expiresAt * 1000 < Date.now()) {
+				return { outcome: 'failed' }
+			}
+			try {
+				const result = await verifySolution({
+					challenge: payload.challenge,
+					solution: payload.solution,
+					deriveKey,
+					hmacSignatureSecret: keys.signature,
+					hmacKeySignatureSecret: keys.key,
+				})
+				// A previous deployment may have issued longer-lived challenges with this same key.
+				const recordMs = Math.max(0, parameters.expiresAt * 1000 - Date.now()) + CHALLENGE_LIMITS.maxSkewMs
+				return verdictOf(result.verified ? 'passed' : 'failed', payload.challenge.signature, recordMs)
+			} catch {
+				return { outcome: 'failed' }
+			}
+		},
+	}
+	return Object.freeze({ issuer: Object.freeze(issuer), verifier: Object.freeze(verifier) })
+}

package/src/implement/dispatch.ts

@@ -81,7 +81,7 @@ import {
 	runInRequest,
 	type Within,
 } from './capability'
-import { CHALLENGE_LIMITS, type ChallengeVerifier } from './challenge'
+import type { ChallengeIssuer, ChallengeVerifier } from './challenge'
 import { connectContext, type ImportWire } from './connect'
 import { runAsSite } from './egress'
 import type { FailureReports } from './failures'
@@ -197,6 +197,8 @@ export type ServedEndpoint =
 		readonly admission: ProcedureAdmission
 		readonly site: ServedSite
 	}
+	/** The framework's own `GET` that issues a public procedure's ALTCHA challenge, behind buckets of its own. */
+	| { readonly kind: 'challenge'; readonly row: EndpointRow; readonly issuer: ChallengeIssuer; readonly admission: ProcedureAdmission }
 	| {
 		readonly kind: 'webhook'
 		readonly row: EndpointRow
@@ -371,6 +373,8 @@ export class ContractRuntime {
 					return await this.#procedure(served, request, exec)
 				case 'public':
 					return await this.#public(served, request, exec)
+				case 'challenge':
+					return await this.#issueChallenge(served, request)
 				case 'webhook':
 					return await this.#webhook(served, request, plan.params, exec)
 				case 'description':
@@ -849,16 +853,16 @@ export class ContractRuntime {
 	 * failure is 400, as a 0.5 form answered, an unreachable provider 503.
 	 */
 	async #challenge(action: string, verifier: ChallengeVerifier, token: string | null, request: Request, repeatable: string | null): Promise<void> {
-		const outcome = token === null ? 'failed' : await verifier.verify({ token, hostname: new URL(request.url).hostname, action })
-		if (outcome === 'unavailable') {
+		const verdict = token === null ? null : await verifier.verify({ token, hostname: new URL(request.url).hostname, action })
+		if (verdict?.outcome === 'unavailable') {
 			throw new ServerFault('challenge_unavailable', `the ${verifier.provider} challenge of '${action}' could not be verified`, 503)
 		}
-		if (outcome === 'misconfigured') {
+		if (verdict?.outcome === 'misconfigured') {
 			throw new ServerFault('challenge_misconfigured', `the ${verifier.provider} challenge of '${action}' refused the application's secret`, 503)
 		}
-		const refused = token === null || outcome === 'failed'
+		const refused = verdict?.outcome !== 'passed'
 			|| (token !== repeatable
-				&& !(await this.#framework().admissions.recordChallenge(action, sha256Hex(token), CHALLENGE_LIMITS.maxAgeMs + CHALLENGE_LIMITS.maxSkewMs)))
+				&& !(await this.#framework().admissions.recordChallenge(action, sha256Hex(verdict.replayKey), verdict.recordMs)))
 		if (refused) {
 			throw new HttpError(400, 'challenge_failed', 'The challenge did not verify; solve it again')
 		}
@@ -911,6 +915,23 @@ export class ContractRuntime {
 		}
 	}
 
+	/**
+	 * A fresh ALTCHA challenge for this host: within the anonymous share and after the endpoint's buckets, as a public
+	 * procedure is admitted. It reads no body and writes nothing but the buckets.
+	 */
+	async #issueChallenge(served: Extract<ServedEndpoint, { kind: 'challenge' }>, request: Request): Promise<Response> {
+		const release = this.#parts.publicShare.enter()
+		if (release === null) {
+			throw new HttpError(503, 'public_share_full', 'Too many anonymous requests at once; try again shortly')
+		}
+		try {
+			await this.#admit(served.row, served.admission, request, null)
+			return jsonResponse(await served.issuer.issue(new URL(request.url).hostname), 200)
+		} finally {
+			release()
+		}
+	}
+
 	/**
 	 * Sends each job once, after the commit: in the background, never awaited and never rejecting. Without an execution
 	 * context a kick runs detached.

package/src/implement/public.ts

@@ -4,8 +4,16 @@
 
 import { type AdmissionRate, CLIENT_ADDRESS_HEADER, type ContractArtifact, type ProcedureArtifact } from '@fabrika/auth-core'
 import { createHash } from 'node:crypto'
+import { ALTCHA_LIMITS } from '../contract/defaults'
 import { REQUEST_BUDGET_MS } from './bounded'
-import { type ChallengeFetch, type ChallengeVerifier, turnstileVerifier } from './challenge'
+import {
+	altchaChallenge,
+	type ChallengeFetch,
+	type ChallengeIssuer,
+	type ChallengeVerifier,
+	type ChallengeWork,
+	turnstileVerifier,
+} from './challenge'
 import { clientBucket, clientKey } from './client-address'
 import type { RequestClient } from './types'
 
@@ -26,10 +34,12 @@ export interface ProcedureAdmission {
 	readonly timeoutMs: number
 }
 
-/** A challenge's verifier and the widget action the verification expects back. */
+/** A challenge's verifier and the widget action the verification expects back; an ALTCHA one's issuer too. */
 export interface AdmittedChallenge {
 	readonly verifier: ChallengeVerifier
 	readonly action: string
+	/** What the procedure's issuing endpoint answers with; `null` for a provider that issues its own (Turnstile). */
+	readonly issuer: ChallengeIssuer | null
 }
 
 /** A procedure the artifact holds no rules for (a `defineContract` one): no bucket, the request budget. */
@@ -44,11 +54,13 @@ export interface AdmissionOptions {
 	readonly application: Readonly<Record<string, unknown>>
 	readonly challengeFetch?: ChallengeFetch
 	readonly repeatableChallengeToken?: string
+	/** The work of every ALTCHA challenge in place of the contract's: a test kit's and `fabrika app dev`'s. */
+	readonly challengeWork?: ChallengeWork
 }
 
 /**
- * The admission of endpoint `id`, or `null` after a problem: a challenge whose secret's application variable is not set
- * keeps the application from booting, as a form's does.
+ * The admission of endpoint `id`, or `null` after a problem: a challenge whose secret's application variable is not set,
+ * or an ALTCHA key too short to resist a guess, keeps the application from booting, as a form's does.
  */
 export function procedureAdmission(id: string, artifact: ContractArtifact, options: AdmissionOptions, problems: string[]): ProcedureAdmission | null {
 	const rules: ProcedureArtifact | undefined = artifact.procedures !== undefined && Object.hasOwn(artifact.procedures, id)
@@ -66,9 +78,22 @@ export function procedureAdmission(id: string, artifact: ContractArtifact, optio
 			)
 			return null
 		}
-		challenge = {
-			verifier: turnstileVerifier(secret.trim(), options.challengeFetch ?? ((request) => fetch(request))),
-			action: rules.challenge.action,
+		if (rules.challenge.provider === 'altcha') {
+			// Every issued challenge carries a signature made with this key, so a short one can be guessed offline.
+			if (secret.trim().length < ALTCHA_LIMITS.minKeyLength) {
+				problems.push(
+					`procedure '${id}' signs its altcha challenge with the application variable ${rules.challenge.secret}, which holds fewer than ${ALTCHA_LIMITS.minKeyLength} characters; set it to a long random value (openssl rand -base64 32)`,
+				)
+				return null
+			}
+			const altcha = altchaChallenge(secret.trim(), rules.challenge, options.challengeWork ?? null)
+			challenge = { verifier: altcha.verifier, action: rules.challenge.action, issuer: altcha.issuer }
+		} else {
+			challenge = {
+				verifier: turnstileVerifier(secret.trim(), options.challengeFetch ?? ((request) => fetch(request))),
+				action: rules.challenge.action,
+				issuer: null,
+			}
 		}
 	}
 	return Object.freeze({

package/src/testing/challenge.ts

@@ -1,5 +1,10 @@
-// A stand-in for a form challenge's provider, for a test kit and for `fabrika app dev`.
+// A stand-in for a form challenge's provider, for a test kit and for `fabrika app dev`; and the solver of an ALTCHA
+// challenge, which needs no stand-in: the application issues and verifies it itself.
 
+import { type Challenge, solveChallenge } from 'altcha-lib'
+import { deriveKey } from 'altcha-lib/algorithms/web/pbkdf2'
+import { z } from 'zod/v4'
+import type { RpcFetch } from '../client/transport'
 import type { ChallengeFetch } from '../implement/challenge'
 
 /** The token Turnstile's always-passing test widget (site key `1x00000000000000000000AA`) hands out every time. */
@@ -8,3 +13,32 @@ export const TURNSTILE_TEST_TOKEN = 'XXXX.DUMMY.TOKEN.XXXX'
 /** Turnstile's siteverify that passes every token: a fresh answer for the host and the form the check expects. */
 export const passingChallenge: ChallengeFetch = (_request, check) =>
 	Promise.resolve(Response.json({ success: true, challenge_ts: new Date().toISOString(), hostname: check.hostname, action: check.action }))
+
+// Read as loosely as the widget reads it: the verification is what holds a challenge to its shape.
+const issuedChallenge = z.object({
+	parameters: z.object({ algorithm: z.string(), nonce: z.string(), salt: z.string(), cost: z.number(), keyLength: z.number(), keyPrefix: z.string() })
+		.catchall(z.unknown()),
+	signature: z.string().optional(),
+})
+
+/**
+ * Fetches a challenge from `url` through `fetch` and solves it as the widget does, answering the payload the page puts
+ * into `challengeToken`. The kit issues the cheapest challenge, so this takes milliseconds.
+ */
+export async function solveChallengeAt(fetch: RpcFetch, url: string): Promise<string> {
+	const response = await fetch(url, { headers: { Accept: 'application/json' } })
+	if (response.status !== 200) {
+		throw new Error(`the challenge at ${url} answered ${response.status}: ${await response.text()}`)
+	}
+	const parsed = issuedChallenge.safeParse(await response.json())
+	if (!parsed.success) {
+		throw new Error(`the challenge at ${url} is no ALTCHA challenge`)
+	}
+	const { parameters, signature } = parsed.data
+	const challenge: Challenge = { parameters: { ...parameters }, ...(signature === undefined ? {} : { signature }) }
+	const solution = await solveChallenge({ challenge, deriveKey, timeout: 10_000 })
+	if (solution === null) {
+		throw new Error(`the challenge at ${url} was not solved in time`)
+	}
+	return btoa(JSON.stringify({ challenge, solution }))
+}

package/src/testing/endpoint-access.ts

@@ -12,7 +12,7 @@ import {
 	endpointDirectory,
 	endpointMembers,
 	type EndpointMethod,
-	type FormChallenge,
+	type ProcedureChallenge,
 	type SchemaShape,
 	type Scope,
 } from '@fabrika/auth-core'
@@ -230,13 +230,14 @@ const cleanScanner: FileScanner = {
  */
 function unusedVariables(app: ContractImplementation<AnyContract>): ApplicationEnvironment {
 	const artifact = compileContract(app.contract, app.database?.tables ?? {})
-	const challengeVariables = (challenge: FormChallenge): readonly string[] =>
-		challenge.siteKey === undefined ? [challenge.secret] : [challenge.secret, challenge.siteKey]
+	const challengeVariables = (challenge: ProcedureChallenge): readonly string[] =>
+		challenge.provider === 'altcha' || challenge.siteKey === undefined ? [challenge.secret] : [challenge.secret, challenge.siteKey]
 	const names = Object.values(artifact.mounts).flatMap((mount): readonly string[] => mount.kind === 'spa' ? (mount.public ?? []) : [])
 	const procedures = Object.values(artifact.procedures ?? {}).flatMap((procedure) =>
 		procedure.challenge === null ? [] : challengeVariables(procedure.challenge)
 	)
-	return Object.fromEntries([...names, ...procedures].map((name) => [name, 'unused']))
+	// Long enough for an ALTCHA key, which boot refuses under 32 characters.
+	return Object.fromEntries([...names, ...procedures].map((name) => [name, 'unused-by-every-generated-case-of-the-kit']))
 }
 
 /**

package/src/testing/kit.ts

@@ -36,6 +36,7 @@ import { exportJWK, generateKeyPair, SignJWT } from 'jose'
 import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
 import type { z } from 'zod/v4'
+import { challengeUrl } from '../client/contract'
 import type { RpcFetch } from '../client/transport'
 import { compileContract } from '../contract/compile'
 import type { AnyContract, DimensionOf } from '../contract/define'
@@ -45,7 +46,7 @@ import type { RequestExecutionContext } from '../fetch'
 import type { FILE_SWEEP_JOB } from '../files/kinds'
 import type { FILE_SCAN_JOB, FileScanner } from '../files/scan'
 import { boot, type BootOptions, type ContractApp } from '../implement/boot'
-import type { ChallengeFetch } from '../implement/challenge'
+import { type ChallengeFetch, MINIMAL_CHALLENGE_WORK } from '../implement/challenge'
 import { type ConnectFetch, connectVariables } from '../implement/connect'
 import type { SpaAssets } from '../implement/dispatch'
 import type { ApplicationEnvironment, ContractImplementation } from '../implement/implement'
@@ -64,6 +65,7 @@ import {
 	type TestGrant,
 	type TestScope,
 } from './caller'
+import { solveChallengeAt } from './challenge'
 import {
 	credentialCallers,
 	type JobCredential,
@@ -192,6 +194,12 @@ export interface TestKit<C extends AnyContract> {
 	 * what a test sends where an input carries `signedToken('<purpose>')`.
 	 */
 	signToken<const P extends TokenPurposeName<C>>(purpose: P, claims: TokenClaimsInput<C, P>, options: { readonly days: number }): string
+	/**
+	 * A solved ALTCHA challenge of `procedure`, a procedure of a client over this kit whose challenge is
+	 * `provider: 'altcha'`: what the page sends as `challengeToken`. Each one passes once. The kit issues the cheapest
+	 * challenge whatever the contract's `cost`, so solving one takes milliseconds.
+	 */
+	solveChallenge(procedure: object): Promise<string>
 }
 
 /** The names of the contract's cron jobs. */
@@ -416,6 +424,7 @@ export function bootTestKit<C extends AnyContract>(
 		files: options.files,
 		...(options.scanner === undefined ? {} : { scanner: options.scanner }),
 		...(options.challengeFetch === undefined ? {} : { challengeFetch: options.challengeFetch }),
+		challengeWork: MINIMAL_CHALLENGE_WORK,
 		...dev,
 		...(options.revealHandlerErrors === undefined ? {} : { revealHandlerErrors: options.revealHandlerErrors }),
 		membership,
@@ -702,6 +711,7 @@ export function bootTestKit<C extends AnyContract>(
 			mail,
 			mailKeyScope,
 			signToken,
+			solveChallenge: (procedure: object) => solveChallengeAt(kitFetch, new URL(challengeUrl(procedure), origin).href),
 		}),
 		standIn,
 		callerOf: (value) => [...memberships.keys()].find((caller) => caller === value),