// node --test marca a sus procesos hijos con NODE_TEST_CONTEXT, y un node --test
// hijo que ve esa marca cambia su salida. Lo que aquí se corre es un programa aparte.
export function cleanEnv(): NodeJS.ProcessEnv {
  const env = { ...process.env };
  delete env.NODE_TEST_CONTEXT;
  return env;
}

// Las mismas reglas que Kallpa: las recomendadas de JavaScript y de
// typescript-eslint, sin información de tipos.
import js from '@eslint/js';
import tseslint from 'typescript-eslint';
import { defineConfig } from 'eslint/config';

export default defineConfig(
  { ignores: ['build/', 'ejemplos/pagina-nueva.js'] },
  js.configs.recommended,
  tseslint.configs.recommended,
);

// La regla no-deprecated necesita información de tipos (semana 11).
import process from 'node:process';
import tseslint from 'typescript-eslint';
import { defineConfig } from 'eslint/config';

export default defineConfig({
  files: ['ejemplos/deprecado.ts'],
  extends: [tseslint.configs.base],
  languageOptions: { parserOptions: { projectService: true, tsconfigRootDir: process.cwd() } },
  rules: { '@typescript-eslint/no-deprecated': 'error' },
});

// Prevenir el retroceso: que nadie agregue usos nuevos de la ruta deprecada mientras
// se migran los viejos. Revisa los textos del código, como el SQL de la semana 11.
import { defineConfig } from 'eslint/config';

export default defineConfig({
  files: ['**/*.js', '**/*.ts'],
  languageOptions: { sourceType: 'module' },
  rules: {
    'no-restricted-syntax': [
      'error',
      {
        selector: "TemplateElement[value.raw=/^\\/api\\/members\\//], Literal[value=/^\\/api\\/members\\/.*bookings/]",
        message: 'GET /api/members/:id/bookings está deprecada y deja de responder el 1 de enero de 2028. Usen /api/v2/members/:id/bookings, que devuelve { bookings }.',
      },
    ],
  },
});

// El strangler fig en pequeño: una fachada delante de la Kallpa vieja. Quien llama
// ve siempre la misma API; por dentro, cada prefijo va a un sistema u otro.
//   legacy       lo atiende el sistema viejo
//   shadow       responde el viejo y, en segundo plano, se compara con el nuevo
//   replacement  lo atiende el sistema nuevo
import http from 'node:http';

export type Mode = 'legacy' | 'shadow' | 'replacement';
export type Route = { prefix: string; mode: Mode };
export type FacadeOptions = {
  legacyUrl: string;
  replacementUrl: string;
  routes: Route[];
  log: (line: string) => void;
};

export function modeFor(path: string, routes: readonly Route[]): Mode {
  return routes.find((route) => path.startsWith(route.prefix))?.mode ?? 'legacy';
}

async function readBody(req: http.IncomingMessage): Promise<Buffer> {
  const chunks: Buffer[] = [];
  for await (const chunk of req) chunks.push(chunk as Buffer);
  return Buffer.concat(chunks);
}

export function createFacade(options: FacadeOptions): http.Server {
  return http.createServer(async (req, res) => {
    try {
      const path = req.url ?? '/';
      const mode = modeFor(path, options.routes);
      const body = await readBody(req);
      const send = (base: string) =>
        fetch(base + path, {
          method: req.method ?? 'GET',
          headers: { 'content-type': req.headers['content-type'] ?? 'application/json' },
          ...(body.length > 0 ? { body } : {}),
        });
      const response = await send(mode === 'replacement' ? options.replacementUrl : options.legacyUrl);
      const text = await response.text();
      res.writeHead(response.status, { 'content-type': response.headers.get('content-type') ?? 'application/json' });
      res.end(text);
      // Solo lecturas: un POST mandado a los dos sistemas haría dos reservas.
      if (mode === 'shadow' && req.method === 'GET') {
        const other = await send(options.replacementUrl);
        const otherText = await other.text();
        const same = other.status === response.status && otherText === text;
        options.log(`${same ? 'SHADOW-OK' : 'SHADOW-DIFF'} ${path}`);
      }
    } catch (error) {
      options.log(`FACADE-ERROR ${String(error)}`);
      if (!res.headersSent) res.writeHead(502);
      res.end();
    }
  });
}

// Dos formas de cambiar `members.phone` por `members.whatsapp`, con el código
// anterior corriendo encima: es lo que pasa durante un rollback.
import type { DatabaseSync } from 'node:sqlite';

// Incompatible: en el momento en que corre, el código anterior deja de funcionar.
export const RENAME_PHONE = 'ALTER TABLE members RENAME COLUMN phone TO whatsapp';

// Compatible: solo agrega. La columna nueva acepta NULL, porque el código anterior
// va a seguir insertando vecinos sin llenarla.
export const EXPAND_WHATSAPP = `
  ALTER TABLE members ADD COLUMN whatsapp TEXT;
  UPDATE members SET whatsapp = phone;
  PRAGMA user_version = 3;
`;

// Se aplica mucho después, cuando ninguna versión a la que se pueda volver lee `phone`.
export const CONTRACT_PHONE = `
  ALTER TABLE members DROP COLUMN phone;
  PRAGMA user_version = 4;
`;

export type NewMember = { id: number; name: string; whatsapp: string };

// El código nuevo durante la transición: escribe en las dos columnas y lee la nueva,
// con la vieja como respaldo para las filas que insertó el código anterior.
export function insertMemberNew(db: DatabaseSync, name: string, phone: string): number {
  const result = db.prepare("INSERT INTO members (name, phone, whatsapp, plan) VALUES (?, ?, ?, 'regular')").run(name, phone, phone);
  return Number(result.lastInsertRowid);
}

export function findMemberNew(db: DatabaseSync, id: number): NewMember | undefined {
  const row = db.prepare('SELECT id, name, COALESCE(whatsapp, phone) AS whatsapp FROM members WHERE id = ?').get(id) as NewMember | undefined;
  return row && { ...row };
}

// Una Kallpa con los datos de ejemplo alrededor de un lunes fijo, y su reloj. Las
// reservas no cambian de una corrida a otra: se pueden comparar con un archivo.
import type { AddressInfo } from 'node:net';
import type { Server } from 'node:http';
import { DatabaseSync } from 'node:sqlite';
import { fixedClock } from '../../kallpa/src/domain/clock.ts';
import { createServer } from '../../kallpa/src/http/server.ts';
import { openDatabase } from '../../kallpa/src/store/database.ts';
import { seedDatabase } from '../../kallpa/src/store/seed.ts';

export const TODAY = '2026-03-09';
export const MONDAY_10AM = '2026-03-09T15:00:00Z';

// Días con algo que mirar: pasados, hoy, una cancelación, dos horas que cruzan
// las 18:00, un sábado y un día sin reservas.
export const SAMPLE_DAYS = ['2026-03-06', '2026-03-08', '2026-03-09', '2026-03-10', '2026-03-11', '2026-03-14', '2026-03-20'];

export function seededDatabase(path = ':memory:'): DatabaseSync {
  const db = openDatabase(path);
  seedDatabase(db, TODAY);
  return db;
}

export async function listen(server: Server): Promise<string> {
  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
  return `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
}

export function close(server: Server): Promise<void> {
  server.closeAllConnections();
  return new Promise((resolve) => server.close(() => resolve()));
}

export function seededServer(db: DatabaseSync): Server {
  return createServer({ db, clock: fixedClock(MONDAY_10AM), notifier: { bookingConfirmed: () => {} }, log: () => {} });
}

export async function dailyReports(url: string): Promise<Record<string, unknown>> {
  const reports: Record<string, unknown> = {};
  for (const day of SAMPLE_DAYS) {
    reports[day] = await (await fetch(`${url}/api/reports/daily?date=${day}`)).json();
  }
  return reports;
}

diff --git a/src/http/handlers.ts b/src/http/handlers.ts
index 4f1354a..d90a582 100644
--- a/src/http/handlers.ts
+++ b/src/http/handlers.ts
@@ -12,7 +12,6 @@ import {
 import { isValidDate } from '../domain/calendar.ts';
 import { limaTime, type Clock } from '../domain/clock.ts';
 import { quotePriceCents } from '../domain/pricing.ts';
-import { dailySummary } from '../domain/report.ts';
 import type { Notifier } from '../notifications/notifier.ts';
 import type { BookingService } from '../services/booking-service.ts';
 import type { BookingRow } from '../store/booking-repository.ts';
@@ -159,8 +158,7 @@ export function dailyReport(deps: AppDependencies): Handler {
     if (!isValidDate(date)) {
       throw new HttpError(400, 'INVALID_DATE', 'Indiquen la fecha con el formato AAAA-MM-DD (?date=2026-03-14).');
     }
-    const bookings = deps.service.bookingsOn(date).map(toBookingJson);
-    sendJson(res, 200, dailySummary(date, deps.service.listCourts(), bookings));
+    sendJson(res, 200, deps.service.dailySummary(date));
   };
 }
 
diff --git a/src/services/booking-service.ts b/src/services/booking-service.ts
index 55e62cf..e196bbf 100644
--- a/src/services/booking-service.ts
+++ b/src/services/booking-service.ts
@@ -4,14 +4,18 @@ import type { Member } from '../domain/member.ts';
 import { BookingRepository, type BookingRow, type NewBookingRow } from '../store/booking-repository.ts';
 import { CourtRepository } from '../store/court-repository.ts';
 import { MemberRepository } from '../store/member-repository.ts';
+import { dailySummarySql } from '../store/report-sql.ts';
+import type { DailySummary } from '../domain/report.ts';
 
 // Punto de entrada a los datos de reservas para la capa HTTP.
 export class BookingService {
   #courts: CourtRepository;
   #members: MemberRepository;
   #bookings: BookingRepository;
+  #db: DatabaseSync;
 
   constructor(db: DatabaseSync) {
+    this.#db = db;
     this.#courts = new CourtRepository(db);
     this.#members = new MemberRepository(db);
     this.#bookings = new BookingRepository(db);
@@ -53,6 +57,10 @@ export class BookingService {
     return this.#bookings.insert(row);
   }
 
+  dailySummary(date: string): DailySummary {
+    return dailySummarySql(this.#db, date);
+  }
+
   markCancelled(id: number, cancelledAt: string): void {
     this.#bookings.updateStatus(id, 'cancelled', cancelledAt);
   }
diff --git a/src/store/report-sql.ts b/src/store/report-sql.ts
new file mode 100644
index 0000000..9b30fae
--- /dev/null
+++ b/src/store/report-sql.ts
@@ -0,0 +1,25 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { CourtSummary, DailySummary } from '../domain/report.ts';
+
+export function dailySummarySql(db: DatabaseSync, date: string): DailySummary {
+  const courts = db
+    .prepare(
+      `SELECT c.id AS courtId, c.name AS courtName,
+              COUNT(*) AS bookings,
+              SUM(b.hours) AS hours,
+              SUM(b.price_cents) AS revenueCents
+       FROM bookings b
+       JOIN courts c ON c.id = b.court_id
+       WHERE b.date = ? AND b.status = 'confirmed'
+       GROUP BY c.id
+       ORDER BY c.id`,
+    )
+    .all(date) as CourtSummary[];
+  return {
+    date,
+    bookings: courts.reduce((total, c) => total + c.bookings, 0),
+    hours: courts.reduce((total, c) => total + c.hours, 0),
+    revenueCents: courts.reduce((total, c) => total + c.revenueCents, 0),
+    courts: courts.map((c) => ({ ...c })),
+  };
+}

// Guarda en golden/caja.json lo que responde hoy la caja del día de Kallpa para
// los días de ejemplo. Se corre una vez, antes de cambiar nada.
//   make golden
import { writeFileSync } from 'node:fs';
import { close, dailyReports, listen, seededDatabase, seededServer } from '../seeded.ts';

const db = seededDatabase();
const server = seededServer(db);
const reports = await dailyReports(await listen(server));
writeFileSync('golden/caja.json', JSON.stringify(reports, null, 2) + '\n');
await close(server);
db.close();

// El sistema nuevo: un servicio que solo sabe de la caja del día.
import http from 'node:http';
import type { DatabaseSync } from 'node:sqlite';
import type { DailySummary } from '../../../kallpa/src/domain/report.ts';
import { sendError, sendJson, HttpError } from '../../../kallpa/src/http/json.ts';
import { isValidDate } from '../../../kallpa/src/domain/calendar.ts';

export type Summarize = (db: DatabaseSync, date: string) => DailySummary;

export function createReportService(db: DatabaseSync, summarize: Summarize): http.Server {
  return http.createServer((req, res) => {
    const url = new URL(req.url ?? '/', 'http://localhost');
    const date = url.searchParams.get('date');
    if (!isValidDate(date)) {
      sendError(res, new HttpError(400, 'INVALID_DATE', 'Indiquen la fecha con el formato AAAA-MM-DD (?date=2026-03-14).'));
      return;
    }
    sendJson(res, 200, summarize(db, date));
  });
}

// Ilustración escrita para la clase: un cambio como los que suele proponer un
// agente cuando se le pide "calcula la caja en SQL". Se lee bien y pasa
// `make check`. Tiene dos diferencias con lo que Kallpa hace hoy.
import type { DatabaseSync } from 'node:sqlite';
import type { CourtSummary, DailySummary } from '../../../kallpa/src/domain/report.ts';

export function dailySummarySql(db: DatabaseSync, date: string): DailySummary {
  const courts = db
    .prepare(
      `SELECT c.id AS courtId, c.name AS courtName,
              COUNT(*) AS bookings,
              SUM(b.hours) AS hours,
              SUM(b.price_cents) AS revenueCents
       FROM bookings b
       JOIN courts c ON c.id = b.court_id
       WHERE b.date = ? AND b.status = 'confirmed'
       GROUP BY c.id
       ORDER BY c.id`,
    )
    .all(date) as CourtSummary[];
  return {
    date,
    bookings: courts.reduce((total, c) => total + c.bookings, 0),
    hours: courts.reduce((total, c) => total + c.hours, 0),
    revenueCents: courts.reduce((total, c) => total + c.revenueCents, 0),
    courts: courts.map((c) => ({ ...c })),
  };
}

// La caja del día calculada en SQL en lugar de traer las reservas a memoria.
// Un refactoring: tiene que responder lo mismo que dailySummary.
import type { DatabaseSync } from 'node:sqlite';
import type { CourtSummary, DailySummary } from '../../../kallpa/src/domain/report.ts';

export function dailySummarySql(db: DatabaseSync, date: string): DailySummary {
  const courts = db
    .prepare(
      `SELECT c.id AS courtId, c.name AS courtName,
              COUNT(b.id) AS bookings,
              COALESCE(SUM(b.hours), 0) AS hours,
              COALESCE(SUM(b.price_cents), 0) AS revenueCents
       FROM courts c
       LEFT JOIN bookings b ON b.court_id = c.id AND b.date = ? AND b.status = 'confirmed'
       GROUP BY c.id, c.name
       ORDER BY c.name`,
    )
    .all(date) as CourtSummary[];
  return {
    date,
    bookings: courts.reduce((total, c) => total + c.bookings, 0),
    hours: courts.reduce((total, c) => total + c.hours, 0),
    revenueCents: courts.reduce((total, c) => total + c.revenueCents, 0),
    courts: courts.map((c) => ({ ...c })),
  };
}

// La caracterización de la caja contra la versión del agente. Falla a propósito.
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import { test } from 'node:test';
import { dailySummarySql } from '../caja/report-sql-agente.ts';
import { seededDatabase } from '../seeded.ts';

const golden = JSON.parse(readFileSync('golden/caja.json', 'utf8')) as Record<string, unknown>;

test('la caja del 20 de marzo, un día sin reservas', () => {
  assert.deepEqual(dailySummarySql(seededDatabase(), '2026-03-20'), golden['2026-03-20']);
});

test('la caja del 9 de marzo', () => {
  assert.deepEqual(dailySummarySql(seededDatabase(), '2026-03-09'), golden['2026-03-09']);
});

// make facade: la caja del día se muda detrás de la fachada, por fases.
import { dailySummarySql as agentVersion } from '../caja/report-sql-agente.ts';
import { dailySummarySql } from '../caja/report-sql.ts';
import { createReportService, type Summarize } from '../caja/report-service.ts';
import { createFacade, type Mode } from '../facade.ts';
import { close, listen, SAMPLE_DAYS, seededDatabase, seededServer } from '../seeded.ts';

const db = seededDatabase();
const legacy = seededServer(db);
const legacyUrl = await listen(legacy);

async function phase(title: string, mode: Mode, summarize: Summarize): Promise<void> {
  console.log(`\n=== ${title} (/api/reports/ en modo ${mode})`);
  const replacement = createReportService(db, summarize);
  const replacementUrl = await listen(replacement);
  const log = (line: string) => console.log(line);
  const facade = createFacade({ legacyUrl, replacementUrl, routes: [{ prefix: '/api/reports/', mode }], log });
  const url = await listen(facade);
  for (const day of SAMPLE_DAYS) {
    const response = await fetch(`${url}/api/reports/daily?date=${day}`);
    const body = (await response.json()) as { courts: unknown[] };
    await new Promise((resolve) => setTimeout(resolve, 20));
    console.log(`  ${day}: ${response.status}, ${body.courts.length} canchas`);
  }
  const courts = await (await fetch(`${url}/api/courts`)).json() as { courts: unknown[] };
  console.log(`  /api/courts lo sigue atendiendo Kallpa: ${courts.courts.length} canchas`);
  await close(facade);
  await close(replacement);
}

await phase('Fase 1: se compara la versión con errores', 'shadow', agentVersion);
await phase('Fase 2: se compara la versión corregida', 'shadow', dailySummarySql);
await phase('Fase 3: atiende el sistema nuevo', 'replacement', dailySummarySql);
await close(legacy);
db.close();

// make migraciones: el código publicado de Kallpa corriendo sobre cada migración.
import { DatabaseSync } from 'node:sqlite';
import { MemberRepository } from '../../../kallpa/src/store/member-repository.ts';
import { CONTRACT_PHONE, EXPAND_WHATSAPP, findMemberNew, insertMemberNew, RENAME_PHONE } from '../migraciones.ts';
import { seededDatabase } from '../seeded.ts';

function tryOld(label: string, db: DatabaseSync): void {
  try {
    const members = new MemberRepository(db).list();
    console.log(`${label}: el código anterior lista ${members.length} vecinos`);
  } catch (error) {
    console.log(`${label}: el código anterior falla: ${(error as Error).message}`);
  }
}

const renamed = seededDatabase();
renamed.exec(RENAME_PHONE);
tryOld('RENAME COLUMN', renamed);

const db = seededDatabase();
db.exec(EXPAND_WHATSAPP);
tryOld('ADD COLUMN', db);
const version = db.prepare('PRAGMA user_version').get() as { user_version: number };
console.log(`user_version: ${version.user_version}; el código anterior solo conoce 2 migraciones`);

const older = new MemberRepository(db).insert({ name: 'Vecina del rollback', phone: '900000001', plan: 'regular' });
const newer = insertMemberNew(db, 'Vecina nueva', '900000002');
console.log('insertó el código anterior:', findMemberNew(db, older));
console.log('insertó el código nuevo:', findMemberNew(db, newer));

db.exec(CONTRACT_PHONE);
tryOld('DROP COLUMN', db);

// El primer paso de una prueba de caracterización: una aserción que sabemos que
// falla, para que el fallo nos diga qué hace el código. Falla a propósito.
import assert from 'node:assert/strict';
import { test } from 'node:test';
import { closingReport } from '../heredado/cierre-con-costura.ts';
import { seededDatabase } from '../seeded.ts';

test('¿qué dice el cierre del 8 de marzo?', () => {
  const db = seededDatabase();
  assert.equal(closingReport(db, new Date('2026-03-09T15:00:00Z'), '2026-03-08'), '?');
});

// make renombrar: el mismo cambio mecánico de dos formas, en copias de Kallpa.
// Renombrar el campo priceCents de Booking a totalCents.
import { execSync, spawnSync } from 'node:child_process';
import { cpSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { join, relative, resolve } from 'node:path';
import ts from 'typescript';

const KALLPA = process.env.KALLPA ?? '../../kallpa';

function copyKallpa(name: string): string {
  const dir = resolve('build/renombrar', name);
  rmSync(dir, { recursive: true, force: true });
  cpSync(KALLPA, dir, { recursive: true, filter: (path) => !path.includes('/data/') });
  return dir;
}

function check(dir: string): void {
  for (const [label, command, args] of [['tsc', 'tsc', ['-p', '.']], ['pruebas', 'node', ['--test', 'test/**/*.test.ts']]] as const) {
    const result = spawnSync(command, args, { cwd: dir, encoding: 'utf8' });
    const output = result.stdout + result.stderr;
    if (label === 'tsc') console.log(`  tsc: ${result.status === 0 ? 'sin errores' : (output.match(/error TS/g)?.length ?? 0) + ' errores'}`);
    else console.log(`  pruebas: ${/^ℹ pass (\d+)$/m.exec(output)?.[1]} pasan, ${/^ℹ fail (\d+)$/m.exec(output)?.[1]} fallan`);
    if (label === 'pruebas') for (const line of output.match(/^✖ .*$/gm)?.slice(0, 2) ?? []) console.log(`  ${line}`);
  }
}

// El servicio de lenguaje: el mismo que usa el editor para "renombrar símbolo".
function renameWithTypes(dir: string, file: string, oldName: string, newName: string): Map<string, number> {
  const config = ts.parseJsonConfigFileContent(ts.readConfigFile(join(dir, 'tsconfig.json'), ts.sys.readFile).config, ts.sys, dir);
  const host: ts.LanguageServiceHost = {
    getCompilationSettings: () => config.options,
    getScriptFileNames: () => config.fileNames,
    getScriptVersion: () => '1',
    getScriptSnapshot: (name) => (ts.sys.fileExists(name) ? ts.ScriptSnapshot.fromString(ts.sys.readFile(name) ?? '') : undefined),
    getCurrentDirectory: () => dir,
    getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
    fileExists: ts.sys.fileExists,
    readFile: ts.sys.readFile,
    readDirectory: ts.sys.readDirectory,
    directoryExists: ts.sys.directoryExists,
    getDirectories: ts.sys.getDirectories,
  };
  const service = ts.createLanguageService(host);
  const path = join(dir, file);
  const position = readFileSync(path, 'utf8').indexOf(`${oldName}:`);
  const locations = service.findRenameLocations(path, position, false, false, {}) ?? [];
  const byFile = new Map<string, ts.RenameLocation[]>();
  for (const location of locations) byFile.set(location.fileName, [...(byFile.get(location.fileName) ?? []), location]);
  const counts = new Map<string, number>();
  for (const [name, list] of byFile) {
    let text = readFileSync(name, 'utf8');
    for (const location of [...list].sort((a, b) => b.textSpan.start - a.textSpan.start)) {
      const before = text.slice(0, location.textSpan.start);
      const after = text.slice(location.textSpan.start + location.textSpan.length);
      text = before + (location.prefixText ?? '') + newName + (location.suffixText ?? '') + after;
    }
    writeFileSync(name, text);
    counts.set(relative(dir, name), list.length);
  }
  return counts;
}

function remaining(dir: string, name: string): string {
  return execSync(`grep -rln ${name} src test public || true`, { cwd: dir, encoding: 'utf8' }).trim().split('\n').join(', ');
}

console.log('=== 1. Con sed, en todo el repositorio');
const withSed = copyKallpa('sed');
execSync(`grep -rl priceCents src test public | xargs sed -i 's/priceCents/totalCents/g'`, { cwd: withSed });
check(withSed);
const seededResponse = readFileSync(join(withSed, 'src/http/handlers.ts'), 'utf8').match(/totalCents: row\.price_cents/);
console.log(`  handlers.ts: ${seededResponse?.[0]}`);
console.log(`  quedan con priceCents: ${remaining(withSed, 'priceCents') || 'ninguno'}`);

console.log('\n=== 2. Con el servicio de lenguaje de TypeScript');
const withTypes = copyKallpa('tipos');
const counts = renameWithTypes(withTypes, 'src/domain/booking.ts', 'priceCents', 'totalCents');
for (const [file, count] of [...counts].sort()) console.log(`  ${String(count).padStart(2)} ${file}`);
check(withTypes);
console.log(`  quedan con priceCents: ${remaining(withTypes, 'priceCents')}`);

// Deprecar a nivel de código: @deprecated es lo que leen el editor y el linter. Por
// sí solo, el compilador no se queja.
export function formatSoles(cents: number): string {
  return `S/ ${(cents / 100).toFixed(2)}`;
}

/**
 * @deprecated Redondea mal los céntimos. Usen `formatSoles(cents)`, que recibe céntimos.
 */
export function toSoles(amount: number): string {
  return `S/ ${amount.toFixed(2)}`;
}

export const label = toSoles(112.5);

// Una pantalla nueva, copiada de un ejemplo viejo del mismo repositorio.
export async function loadHistory(memberId) {
  const response = await fetch(`/api/members/${memberId}/bookings`);
  return response.json();
}

export async function loadHistoryV2(memberId) {
  const response = await fetch(`/api/v2/members/${memberId}/bookings`);
  return (await response.json()).bookings;
}

diff --git a/src/domain/booking.ts b/src/domain/booking.ts
index d58bac2..f0ecf13 100644
--- a/src/domain/booking.ts
+++ b/src/domain/booking.ts
@@ -7,6 +7,7 @@ export const CLOSING_HOUR = 22; // a las 22:00 se apagan las luces
 export const MAX_HOURS_PER_BOOKING = 3;
 export const BOOKING_WINDOW_DAYS = 14; // se reserva con hasta dos semanas de anticipación
 export const CANCELLATION_NOTICE_HOURS = 3;
+export const TEAM_NAME_MIN_LENGTH = 3;
 export const TEAM_NAME_MAX_LENGTH = 40;
 
 export const BOOKING_STATUSES = ['confirmed', 'cancelled'] as const;
diff --git a/src/http/handlers.ts b/src/http/handlers.ts
index 4f1354a..3df3088 100644
--- a/src/http/handlers.ts
+++ b/src/http/handlers.ts
@@ -2,6 +2,7 @@ import {
   CLOSING_HOUR,
   OPENING_HOUR,
   TEAM_NAME_MAX_LENGTH,
+  TEAM_NAME_MIN_LENGTH,
   checkBookingRules,
   isCancellableAt,
   overlaps,
@@ -178,11 +179,11 @@ function parseBookingRequest(body: unknown): BookingRequest {
     throw new HttpError(400, 'VALIDATION_ERROR', 'Falta el campo date (AAAA-MM-DD).');
   }
   const teamName = typeof fields.teamName === 'string' ? fields.teamName.trim() : '';
-  if (teamName.length === 0 || teamName.length > TEAM_NAME_MAX_LENGTH) {
+  if (teamName.length < TEAM_NAME_MIN_LENGTH || teamName.length > TEAM_NAME_MAX_LENGTH) {
     throw new HttpError(
       400,
       'VALIDATION_ERROR',
-      `El nombre del equipo es obligatorio y tiene como máximo ${TEAM_NAME_MAX_LENGTH} caracteres.`,
+      `El nombre del equipo tiene entre ${TEAM_NAME_MIN_LENGTH} y ${TEAM_NAME_MAX_LENGTH} caracteres.`,
     );
   }
   return { courtId, memberId, date: fields.date, startHour, hours, teamName };
diff --git a/test/nombre-equipo.test.ts b/test/nombre-equipo.test.ts
new file mode 100644
index 0000000..83b38e2
--- /dev/null
+++ b/test/nombre-equipo.test.ts
@@ -0,0 +1,14 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { postJson, startTestServer } from './helpers.ts';
+
+test('un nombre de equipo de 2 caracteres se rechaza y uno de 3 se acepta', async () => {
+  const server = await startTestServer();
+  const request = { courtId: 1, memberId: 1, date: '2026-03-10', startHour: 9 };
+  const short = await postJson(`${server.url}/api/bookings`, { ...request, teamName: 'AB' });
+  assert.equal(short.status, 400);
+  assert.equal(short.body.error.code, 'VALIDATION_ERROR');
+  const ok = await postJson(`${server.url}/api/bookings`, { ...request, teamName: 'ABC' });
+  assert.equal(ok.status, 200);
+  await server.close();
+});

#!/usr/bin/env bash
# Ensayo de la defensa, sobre una copia de Kallpa: el clon limpio y el cambio en vivo.
set -euo pipefail
KALLPA="${KALLPA:-../../kallpa}"
HERE="$PWD"
git() { command git -c user.name=Kallpa -c user.email=kallpa@example.com -c init.defaultBranch=main -c advice.detachedHead=false "$@"; }
resumen() { grep -E '^(ℹ (pass|fail)|.*error TS)' || true; }

rm -rf build/ensayo
mkdir -p build/ensayo
cp -r "$KALLPA" build/ensayo/origen
rm -f build/ensayo/origen/data/*.db build/ensayo/origen/data/*.db-*
cd build/ensayo/origen

# Alguien del equipo usa un archivo que está en .gitignore y nunca subió.
echo '*.local.ts' >> .gitignore
git init -q && git add -A && git commit -qm "Kallpa publicada"
cat >> src/config.ts <<'TS'

export { HOLIDAYS } from './holidays.local.ts';
TS
echo "export const HOLIDAYS = ['2026-07-28'];" > src/holidays.local.ts
git add -A && git commit -qm "Agrega los feriados" 

echo '=== En la laptop de quien lo escribió'
make --no-print-directory check 2>&1 | resumen
echo '=== git status'
git status --short | wc -l

echo '=== En un clon limpio'
cd ..
git clone -q origen clon
cd clon
(make --no-print-directory check 2>&1 || true) | resumen

echo '=== Después de subir lo que faltaba'
cd ../origen
git rm -q --cached src/holidays.local.ts 2>/dev/null || true
mv src/holidays.local.ts src/holidays.ts
sed -i "s#./holidays.local.ts#./holidays.ts#" src/config.ts
git add -A && git commit -qm "Sube los feriados"
cd .. && rm -rf clon && git clone -q origen clon && cd clon
make --no-print-directory check 2>&1 | resumen

echo '=== El cambio en vivo: un nombre de equipo tiene al menos 3 caracteres'
git switch -q -c equipo-nombre-minimo
git apply --index "$HERE/ensayo/cambio-en-vivo.diff"
git diff --cached --stat
make --no-print-directory check 2>&1 | resumen

{
  "2026-03-06": {
    "date": "2026-03-06",
    "bookings": 1,
    "hours": 2,
    "revenueCents": 22500,
    "courts": [
      {
        "courtId": 4,
        "courtName": "Básquet",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 1,
        "courtName": "Fulbito 1",
        "bookings": 1,
        "hours": 2,
        "revenueCents": 22500
      },
      {
        "courtId": 2,
        "courtName": "Fulbito 2",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 3,
        "courtName": "Vóley",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      }
    ]
  },
  "2026-03-08": {
    "date": "2026-03-08",
    "bookings": 2,
    "hours": 3,
    "revenueCents": 21375,
    "courts": [
      {
        "courtId": 4,
        "courtName": "Básquet",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 1,
        "courtName": "Fulbito 1",
        "bookings": 1,
        "hours": 1,
        "revenueCents": 10125
      },
      {
        "courtId": 2,
        "courtName": "Fulbito 2",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 3,
        "courtName": "Vóley",
        "bookings": 1,
        "hours": 2,
        "revenueCents": 11250
      }
    ]
  },
  "2026-03-09": {
    "date": "2026-03-09",
    "bookings": 3,
    "hours": 5,
    "revenueCents": 48750,
    "courts": [
      {
        "courtId": 4,
        "courtName": "Básquet",
        "bookings": 1,
        "hours": 1,
        "revenueCents": 6000
      },
      {
        "courtId": 1,
        "courtName": "Fulbito 1",
        "bookings": 1,
        "hours": 2,
        "revenueCents": 20250
      },
      {
        "courtId": 2,
        "courtName": "Fulbito 2",
        "bookings": 1,
        "hours": 2,
        "revenueCents": 22500
      },
      {
        "courtId": 3,
        "courtName": "Vóley",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      }
    ]
  },
  "2026-03-10": {
    "date": "2026-03-10",
    "bookings": 2,
    "hours": 3,
    "revenueCents": 21250,
    "courts": [
      {
        "courtId": 4,
        "courtName": "Básquet",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 1,
        "courtName": "Fulbito 1",
        "bookings": 1,
        "hours": 1,
        "revenueCents": 11250
      },
      {
        "courtId": 2,
        "courtName": "Fulbito 2",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 3,
        "courtName": "Vóley",
        "bookings": 1,
        "hours": 2,
        "revenueCents": 10000
      }
    ]
  },
  "2026-03-11": {
    "date": "2026-03-11",
    "bookings": 2,
    "hours": 3,
    "revenueCents": 22125,
    "courts": [
      {
        "courtId": 4,
        "courtName": "Básquet",
        "bookings": 1,
        "hours": 2,
        "revenueCents": 12000
      },
      {
        "courtId": 1,
        "courtName": "Fulbito 1",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 2,
        "courtName": "Fulbito 2",
        "bookings": 1,
        "hours": 1,
        "revenueCents": 10125
      },
      {
        "courtId": 3,
        "courtName": "Vóley",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      }
    ]
  },
  "2026-03-14": {
    "date": "2026-03-14",
    "bookings": 1,
    "hours": 2,
    "revenueCents": 11250,
    "courts": [
      {
        "courtId": 4,
        "courtName": "Básquet",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 1,
        "courtName": "Fulbito 1",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 2,
        "courtName": "Fulbito 2",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 3,
        "courtName": "Vóley",
        "bookings": 1,
        "hours": 2,
        "revenueCents": 11250
      }
    ]
  },
  "2026-03-20": {
    "date": "2026-03-20",
    "bookings": 0,
    "hours": 0,
    "revenueCents": 0,
    "courts": [
      {
        "courtId": 4,
        "courtName": "Básquet",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 1,
        "courtName": "Fulbito 1",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 2,
        "courtName": "Fulbito 2",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      },
      {
        "courtId": 3,
        "courtName": "Vóley",
        "bookings": 0,
        "hours": 0,
        "revenueCents": 0
      }
    ]
  }
}

CIERRE DE CAJA 2026-03-06
Fulbito 1  19:00 Los Pumas de Comas         S/ 225.00
TOTAL S/ 225.00

CIERRE DE CAJA 2026-03-08
Fulbito 1  20:00 Deportivo Rímac            S/ 91.13
Vóley      18:00 Vóley Femenino San Juan    S/ 101.25
TOTAL S/ 192.38

CIERRE DE CAJA 2026-03-09
Básquet    17:00 Básquet Ate                S/ 60.00
Fulbito 1  19:00 Real Barranco              S/ 182.25
Fulbito 2  20:00 Los Cracks del Jueves      S/ 225.00
TOTAL S/ 467.25

CIERRE DE CAJA 2026-03-10
Fulbito 1  18:00 Los Pumas de Comas         S/ 112.50
Vóley       9:00 Las Matadoras              S/ 100.00
TOTAL S/ 212.50

CIERRE DE CAJA 2026-03-11
Básquet    17:00 Juventud San Martín        S/ 120.00
Fulbito 2  21:00 Promo 2015 Fe y Alegría    S/ 91.13
TOTAL S/ 211.13

CIERRE DE CAJA 2026-03-14
Vóley      10:00 Vóley Femenino San Juan    S/ 101.25
TOTAL S/ 101.25

CIERRE DE CAJA 2026-03-20
TOTAL S/ 0.00

// El mismo cierre, con los cambios mínimos para poder probarlo: la lógica pasa a
// una función que recibe la base de datos y el instante, y devuelve el texto.
// Nada más cambió: ni los nombres, ni el cálculo, ni lo raro que tiene.
import { DatabaseSync } from 'node:sqlite';

type Row = { court: string; start_hour: number; team_name: string; price_cents: number; plan: string; status: string };

export function closingReport(db: DatabaseSync, now: Date, dateArgument?: string): string {
  const date = dateArgument ?? now.toISOString().slice(0, 10);
  const rows = db
    .prepare(
      `SELECT c.name AS court, b.start_hour, b.team_name, b.price_cents, m.plan, b.status
       FROM bookings b JOIN courts c ON c.id = b.court_id JOIN members m ON m.id = b.member_id
       WHERE b.date = ? ORDER BY c.name, b.start_hour`,
    )
    .all(date) as Row[];

  const lines = [`CIERRE DE CAJA ${date}`];
  let total = 0;
  for (const row of rows) {
    if (row.status === 'cancelled') continue;
    let amount = row.price_cents / 100;
    if (row.plan === 'socio') amount = amount * 0.9;
    total += amount;
    lines.push(`${row.court.padEnd(10)} ${String(row.start_hour).padStart(2)}:00 ${row.team_name.padEnd(26)} S/ ${amount.toFixed(2)}`);
  }
  lines.push(`TOTAL S/ ${total.toFixed(2)}`);
  if (total > 500) lines.push('Depositar en el banco');
  return lines.join('\n') + '\n';
}

if (import.meta.main) {
  const db = new DatabaseSync(process.env.KALLPA_DB ?? 'data/kallpa.db');
  process.stdout.write(closingReport(db, new Date(), process.argv[2]));
}

// Cierre de caja de la administración. Lo escribió hace años alguien que ya no
// está en el complejo y no tiene pruebas. Doris lo corre cada noche, y le pasa
// la fecha a mano porque "sin fecha sale mal de noche".
//
//   KALLPA_DB=data/kallpa.db node cierre-de-caja.ts 2026-03-11
import { DatabaseSync } from 'node:sqlite';

const db = new DatabaseSync(process.env.KALLPA_DB ?? 'data/kallpa.db');
const date = process.argv[2] ?? new Date().toISOString().slice(0, 10);

type Row = { court: string; start_hour: number; team_name: string; price_cents: number; plan: string; status: string };
const rows = db
  .prepare(
    `SELECT c.name AS court, b.start_hour, b.team_name, b.price_cents, m.plan, b.status
     FROM bookings b JOIN courts c ON c.id = b.court_id JOIN members m ON m.id = b.member_id
     WHERE b.date = ? ORDER BY c.name, b.start_hour`,
  )
  .all(date) as Row[];

console.log(`CIERRE DE CAJA ${date}`);
let total = 0;
for (const row of rows) {
  if (row.status === 'cancelled') continue;
  let amount = row.price_cents / 100;
  if (row.plan === 'socio') amount = amount * 0.9;
  total += amount;
  console.log(`${row.court.padEnd(10)} ${String(row.start_hour).padStart(2)}:00 ${row.team_name.padEnd(26)} S/ ${amount.toFixed(2)}`);
}
console.log(`TOTAL S/ ${total.toFixed(2)}`);
if (total > 500) console.log('Depositar en el banco');

// El cambio que pidió Doris: al final del cierre, cuántas reservas fueron de
// socios y cuántas de regulares. Se agrega al lado del código viejo (una función
// nueva, con sus propias pruebas) en lugar de reescribirlo.
import { DatabaseSync } from 'node:sqlite';
import { closingReport } from './cierre-con-costura.ts';

export type PlanCount = { plan: string; bookings: number };

export function bookingsByPlan(db: DatabaseSync, date: string): PlanCount[] {
  const rows = db
    .prepare(
      `SELECT m.plan, COUNT(*) AS bookings
       FROM bookings b JOIN members m ON m.id = b.member_id
       WHERE b.date = ? AND b.status = 'confirmed'
       GROUP BY m.plan ORDER BY m.plan`,
    )
    .all(date) as PlanCount[];
  return rows.map((row) => ({ ...row }));
}

export function closingReportByPlan(db: DatabaseSync, now: Date, dateArgument?: string): string {
  const old = closingReport(db, now, dateArgument);
  const date = dateArgument ?? now.toISOString().slice(0, 10);
  const counts = bookingsByPlan(db, date).map((c) => `${c.plan}: ${c.bookings}`);
  return `${old}RESERVAS ${counts.join(', ') || 'ninguna'}\n`;
}

diff --git a/README.md b/README.md
index 77a7445..f8ed5ce 100644
--- a/README.md
+++ b/README.md
@@ -111,7 +111,8 @@ un código estable que los clientes HTTP pueden comparar sin leer el mensaje:
 | `GET /api/courts` | Lista las canchas | `200 { courts: [{ id, name, sport }] }` |
 | `GET /api/courts/:id/availability?date=YYYY-MM-DD` | Horas libres y ocupadas de una cancha ese día | `200 { courtId, date, slots: [{ hour, available, teamName? }] }` |
 | `GET /api/members` | Lista a los vecinos registrados | `200 { members: [{ id, name, phone, plan }] }` |
-| `GET /api/members/:id/bookings` | Las reservas de un vecino, también las canceladas | `200 [booking, ...]` |
+| `GET /api/members/:id/bookings` | **Deprecada, deja de responder el 1 de enero de 2028.** Usen la de abajo | `200 [booking, ...]` |
+| `GET /api/v2/members/:id/bookings` | Las reservas de un vecino, también las canceladas | `200 { bookings: [booking, ...] }` |
 | `POST /api/bookings` | Reserva | `200 { booking }` |
 | `POST /api/bookings/:id/cancel` | Cancela una reserva | `200 { booking }` |
 | `GET /api/reports/daily?date=YYYY-MM-DD` | La caja del día, para la administración: reservas, horas y dinero por cancha | `200 { date, bookings, hours, revenueCents, courts: [...] }` |
diff --git a/src/http/handlers.ts b/src/http/handlers.ts
index 4f1354a..ec3043e 100644
--- a/src/http/handlers.ts
+++ b/src/http/handlers.ts
@@ -143,12 +143,30 @@ export function cancelBooking(deps: AppDependencies): Handler {
   };
 }
 
-// GET /api/members/:id/bookings
+// La v1 sigue respondiendo igual: solo se anuncia su fin (RFC 9745 y RFC 8594).
+export const MEMBER_BOOKINGS_V1_DEPRECATED_AT = 1798761600; // 1 de enero de 2027, 00:00 UTC
+export const MEMBER_BOOKINGS_V1_SUNSET = 'Sat, 01 Jan 2028 00:00:00 GMT';
+
+function bookingsOfMember(deps: AppDependencies, id: string): Booking[] {
+  const member = deps.service.findMember(Number(id));
+  if (!member) throw new HttpError(404, 'MEMBER_NOT_FOUND', `No existe el miembro ${id}.`);
+  return deps.service.bookingsForMember(member.id).map(toBookingJson);
+}
+
+// GET /api/members/:id/bookings: arreglo suelto, deprecado.
 export function memberBookings(deps: AppDependencies): Handler {
   return ({ res, params }) => {
-    const member = deps.service.findMember(Number(params.id));
-    if (!member) throw new HttpError(404, 'MEMBER_NOT_FOUND', `No existe el miembro ${params.id}.`);
-    sendJson(res, 200, deps.service.bookingsForMember(member.id).map(toBookingJson));
+    res.setHeader('Deprecation', `@${MEMBER_BOOKINGS_V1_DEPRECATED_AT}`);
+    res.setHeader('Sunset', MEMBER_BOOKINGS_V1_SUNSET);
+    res.setHeader('Link', `</api/v2/members/${params.id}/bookings>; rel="successor-version"`);
+    sendJson(res, 200, bookingsOfMember(deps, params.id));
+  };
+}
+
+// GET /api/v2/members/:id/bookings: un objeto, que puede crecer.
+export function memberBookingsV2(deps: AppDependencies): Handler {
+  return ({ res, params }) => {
+    sendJson(res, 200, { bookings: bookingsOfMember(deps, params.id) });
   };
 }
 
diff --git a/src/http/server.ts b/src/http/server.ts
index 251064b..ed30624 100644
--- a/src/http/server.ts
+++ b/src/http/server.ts
@@ -11,6 +11,7 @@ import {
   listCourts,
   listMembers,
   memberBookings,
+  memberBookingsV2,
   type AppDependencies,
 } from './handlers.ts';
 import { HttpError, sendError } from './json.ts';
@@ -30,6 +31,7 @@ export function buildRouter(deps: AppDependencies): Router {
   router.get('/api/courts/:id/availability', courtAvailability(deps));
   router.get('/api/members', listMembers(deps));
   router.get('/api/members/:id/bookings', memberBookings(deps));
+  router.get('/api/v2/members/:id/bookings', memberBookingsV2(deps));
   router.post('/api/bookings', createBooking(deps));
   router.post('/api/bookings/:id/cancel', cancelBooking(deps));
   router.get('/api/reports/daily', dailyReport(deps));
@@ -66,6 +68,8 @@ export function createServer(options: ServerOptions): http.Server {
       }
     } finally {
       log(`${req.method} ${req.url} ${res.statusCode}`);
+      // Para saber quién sigue usando lo deprecado. Sin el número de vecino: no hace falta.
+      if (res.hasHeader('Deprecation')) log(`DEPRECATED /api/members/:id/bookings ua="${req.headers['user-agent'] ?? '?'}"`);
     }
   });
 }
diff --git a/test/v2.test.ts b/test/v2.test.ts
new file mode 100644
index 0000000..67946b3
--- /dev/null
+++ b/test/v2.test.ts
@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import { after, before, describe, test } from 'node:test';
+import { postJson, startTestServer, type TestServer } from './helpers.ts';
+
+// El reloj de las pruebas marca el lunes 9 de marzo de 2026 a las 10:00.
+describe('las reservas de un vecino, en v1 y en v2', () => {
+  let server: TestServer;
+
+  before(async () => {
+    server = await startTestServer();
+    await postJson(`${server.url}/api/bookings`, { courtId: 1, memberId: 2, date: '2026-03-11', startHour: 10, teamName: 'Real Barranco' });
+  });
+
+  after(async () => {
+    await server.close();
+  });
+
+  test('v1 responde lo mismo que antes y anuncia su fin', async () => {
+    const response = await fetch(`${server.url}/api/members/2/bookings`);
+    const body = await response.json();
+    assert.equal(response.status, 200);
+    assert.ok(Array.isArray(body));
+    assert.equal(response.headers.get('deprecation'), '@1798761600');
+    assert.equal(response.headers.get('sunset'), 'Sat, 01 Jan 2028 00:00:00 GMT');
+    assert.equal(response.headers.get('link'), '</api/v2/members/2/bookings>; rel="successor-version"');
+  });
+
+  test('v2 devuelve las mismas reservas dentro de un objeto y sin aviso', async () => {
+    const v1 = await (await fetch(`${server.url}/api/members/2/bookings`)).json();
+    const response = await fetch(`${server.url}/api/v2/members/2/bookings`);
+    assert.deepEqual(await response.json(), { bookings: v1 });
+    assert.equal(response.headers.get('deprecation'), null);
+  });
+
+  test('los errores no cambian entre versiones', async () => {
+    const response = await fetch(`${server.url}/api/v2/members/99/bookings`);
+    assert.equal(response.status, 404);
+    assert.equal(((await response.json()) as { error: { code: string } }).error.code, 'MEMBER_NOT_FOUND');
+  });
+});

diff --git a/public/app.js b/public/app.js
index 7963b5f..b1cadd7 100644
--- a/public/app.js
+++ b/public/app.js
@@ -54,7 +54,7 @@ async function loadSlots() {
 }
 
 async function loadMyBookings() {
-  const bookings = await api(`/api/members/${memberSelect.value}/bookings`);
+  const { bookings } = await api(`/api/v2/members/${memberSelect.value}/bookings`);
   myBookings.innerHTML = bookings
     .map((b) => {
       const text = `${b.date} · ${b.startHour}:00 a ${b.startHour + b.hours}:00 · ${b.teamName} · ${soles(b.priceCents)}`;
diff --git a/src/http/handlers.ts b/src/http/handlers.ts
index ec3043e..e338202 100644
--- a/src/http/handlers.ts
+++ b/src/http/handlers.ts
@@ -153,9 +153,24 @@ function bookingsOfMember(deps: AppDependencies, id: string): Booking[] {
   return deps.service.bookingsForMember(member.id).map(toBookingJson);
 }
 
+// Apagones anunciados: durante estas ventanas la v1 ya responde como responderá
+// después del fin. Así aparece quien no sabía que dependía de ella.
+export const MEMBER_BOOKINGS_V1_BROWNOUTS = [
+  { from: '2027-09-01T15:00:00Z', to: '2027-09-01T16:00:00Z' },
+  { from: '2027-10-05T15:00:00Z', to: '2027-10-05T21:00:00Z' },
+  { from: '2027-11-02T13:00:00Z', to: '2027-11-03T13:00:00Z' },
+];
+
+export function isBrownout(instant: Date): boolean {
+  return MEMBER_BOOKINGS_V1_BROWNOUTS.some(({ from, to }) => instant >= new Date(from) && instant < new Date(to));
+}
+
 // GET /api/members/:id/bookings: arreglo suelto, deprecado.
 export function memberBookings(deps: AppDependencies): Handler {
   return ({ res, params }) => {
+    if (isBrownout(deps.clock.now())) {
+      throw new HttpError(410, 'ENDPOINT_REMOVED', `Esta ruta deja de existir: usen /api/v2/members/${params.id}/bookings, que devuelve { bookings }.`);
+    }
     res.setHeader('Deprecation', `@${MEMBER_BOOKINGS_V1_DEPRECATED_AT}`);
     res.setHeader('Sunset', MEMBER_BOOKINGS_V1_SUNSET);
     res.setHeader('Link', `</api/v2/members/${params.id}/bookings>; rel="successor-version"`);
diff --git a/test/v2-migrado.test.ts b/test/v2-migrado.test.ts
new file mode 100644
index 0000000..13e6bbd
--- /dev/null
+++ b/test/v2-migrado.test.ts
@@ -0,0 +1,26 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { test } from 'node:test';
+import { isBrownout } from '../src/http/handlers.ts';
+import { startTestServer } from './helpers.ts';
+
+test('la página ya no usa la ruta deprecada', () => {
+  const page = readFileSync('public/app.js', 'utf8');
+  assert.doesNotMatch(page, /`\/api\/members\/[^`]*\/bookings`/);
+  assert.match(page, /\/api\/v2\/members\//);
+});
+
+test('durante un apagón la v1 responde 410 con lo que hay que hacer; la v2 sigue', async () => {
+  const server = await startTestServer({ now: '2027-09-01T15:30:00Z' });
+  const old = await fetch(`${server.url}/api/members/2/bookings`);
+  assert.equal(old.status, 410);
+  assert.match(((await old.json()) as { error: { message: string } }).error.message, /\/api\/v2\/members\/2\/bookings/);
+  assert.equal((await fetch(`${server.url}/api/v2/members/2/bookings`)).status, 200);
+  await server.close();
+});
+
+test('un apagón empieza y termina a la hora anunciada', () => {
+  assert.equal(isBrownout(new Date('2027-09-01T14:59:59Z')), false);
+  assert.equal(isBrownout(new Date('2027-09-01T15:00:00Z')), true);
+  assert.equal(isBrownout(new Date('2027-09-01T16:00:00Z')), false);
+});

diff --git a/README.md b/README.md
index f8ed5ce..b32869f 100644
--- a/README.md
+++ b/README.md
@@ -111,7 +111,7 @@ un código estable que los clientes HTTP pueden comparar sin leer el mensaje:
 | `GET /api/courts` | Lista las canchas | `200 { courts: [{ id, name, sport }] }` |
 | `GET /api/courts/:id/availability?date=YYYY-MM-DD` | Horas libres y ocupadas de una cancha ese día | `200 { courtId, date, slots: [{ hour, available, teamName? }] }` |
 | `GET /api/members` | Lista a los vecinos registrados | `200 { members: [{ id, name, phone, plan }] }` |
-| `GET /api/members/:id/bookings` | **Deprecada, deja de responder el 1 de enero de 2028.** Usen la de abajo | `200 [booking, ...]` |
+| `GET /api/members/:id/bookings` | Ya no existe. Usen la de abajo | `410 ENDPOINT_REMOVED` |
 | `GET /api/v2/members/:id/bookings` | Las reservas de un vecino, también las canceladas | `200 { bookings: [booking, ...] }` |
 | `POST /api/bookings` | Reserva | `200 { booking }` |
 | `POST /api/bookings/:id/cancel` | Cancela una reserva | `200 { booking }` |
@@ -135,6 +135,7 @@ Cuerpo de `POST /api/bookings`:
 | `INVALID_DATE` | 400 | La fecha no tiene el formato `YYYY-MM-DD` |
 | `COURT_NOT_FOUND`, `MEMBER_NOT_FOUND`, `BOOKING_NOT_FOUND` | 404 | No existe |
 | `NOT_FOUND` | 404 | La ruta no existe |
+| `ENDPOINT_REMOVED` | 410 | La ruta existió y se retiró; el mensaje dice cuál usar |
 | `METHOD_NOT_ALLOWED` | 405 | La ruta existe, con otro método |
 | `SLOT_TAKEN` | 409 | La cancha ya está reservada en ese horario |
 | `ALREADY_CANCELLED` | 409 | La reserva ya estaba cancelada |
diff --git a/src/http/handlers.ts b/src/http/handlers.ts
index e338202..6996c6f 100644
--- a/src/http/handlers.ts
+++ b/src/http/handlers.ts
@@ -143,38 +143,17 @@ export function cancelBooking(deps: AppDependencies): Handler {
   };
 }
 
-// La v1 sigue respondiendo igual: solo se anuncia su fin (RFC 9745 y RFC 8594).
-export const MEMBER_BOOKINGS_V1_DEPRECATED_AT = 1798761600; // 1 de enero de 2027, 00:00 UTC
-export const MEMBER_BOOKINGS_V1_SUNSET = 'Sat, 01 Jan 2028 00:00:00 GMT';
-
 function bookingsOfMember(deps: AppDependencies, id: string): Booking[] {
   const member = deps.service.findMember(Number(id));
   if (!member) throw new HttpError(404, 'MEMBER_NOT_FOUND', `No existe el miembro ${id}.`);
   return deps.service.bookingsForMember(member.id).map(toBookingJson);
 }
 
-// Apagones anunciados: durante estas ventanas la v1 ya responde como responderá
-// después del fin. Así aparece quien no sabía que dependía de ella.
-export const MEMBER_BOOKINGS_V1_BROWNOUTS = [
-  { from: '2027-09-01T15:00:00Z', to: '2027-09-01T16:00:00Z' },
-  { from: '2027-10-05T15:00:00Z', to: '2027-10-05T21:00:00Z' },
-  { from: '2027-11-02T13:00:00Z', to: '2027-11-03T13:00:00Z' },
-];
-
-export function isBrownout(instant: Date): boolean {
-  return MEMBER_BOOKINGS_V1_BROWNOUTS.some(({ from, to }) => instant >= new Date(from) && instant < new Date(to));
-}
-
-// GET /api/members/:id/bookings: arreglo suelto, deprecado.
-export function memberBookings(deps: AppDependencies): Handler {
-  return ({ res, params }) => {
-    if (isBrownout(deps.clock.now())) {
-      throw new HttpError(410, 'ENDPOINT_REMOVED', `Esta ruta deja de existir: usen /api/v2/members/${params.id}/bookings, que devuelve { bookings }.`);
-    }
-    res.setHeader('Deprecation', `@${MEMBER_BOOKINGS_V1_DEPRECATED_AT}`);
-    res.setHeader('Sunset', MEMBER_BOOKINGS_V1_SUNSET);
-    res.setHeader('Link', `</api/v2/members/${params.id}/bookings>; rel="successor-version"`);
-    sendJson(res, 200, bookingsOfMember(deps, params.id));
+// GET /api/members/:id/bookings ya no existe. Se responde 410 por un tiempo, para
+// que quien se haya quedado atrás lea qué hacer.
+export function memberBookingsRemoved(): Handler {
+  return ({ params }) => {
+    throw new HttpError(410, 'ENDPOINT_REMOVED', `Esta ruta ya no existe: usen /api/v2/members/${params.id}/bookings, que devuelve { bookings }.`);
   };
 }
 
diff --git a/src/http/server.ts b/src/http/server.ts
index ed30624..b39a724 100644
--- a/src/http/server.ts
+++ b/src/http/server.ts
@@ -10,7 +10,7 @@ import {
   dailyReport,
   listCourts,
   listMembers,
-  memberBookings,
+  memberBookingsRemoved,
   memberBookingsV2,
   type AppDependencies,
 } from './handlers.ts';
@@ -30,7 +30,7 @@ export function buildRouter(deps: AppDependencies): Router {
   router.get('/api/courts', listCourts(deps));
   router.get('/api/courts/:id/availability', courtAvailability(deps));
   router.get('/api/members', listMembers(deps));
-  router.get('/api/members/:id/bookings', memberBookings(deps));
+  router.get('/api/members/:id/bookings', memberBookingsRemoved());
   router.get('/api/v2/members/:id/bookings', memberBookingsV2(deps));
   router.post('/api/bookings', createBooking(deps));
   router.post('/api/bookings/:id/cancel', cancelBooking(deps));
@@ -68,8 +68,6 @@ export function createServer(options: ServerOptions): http.Server {
       }
     } finally {
       log(`${req.method} ${req.url} ${res.statusCode}`);
-      // Para saber quién sigue usando lo deprecado. Sin el número de vecino: no hace falta.
-      if (res.hasHeader('Deprecation')) log(`DEPRECATED /api/members/:id/bookings ua="${req.headers['user-agent'] ?? '?'}"`);
     }
   });
 }
diff --git a/test/v2-migrado.test.ts b/test/v2-migrado.test.ts
index 13e6bbd..2fdb7b5 100644
--- a/test/v2-migrado.test.ts
+++ b/test/v2-migrado.test.ts
@@ -1,26 +1,9 @@
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { test } from 'node:test';
-import { isBrownout } from '../src/http/handlers.ts';
-import { startTestServer } from './helpers.ts';
 
 test('la página ya no usa la ruta deprecada', () => {
   const page = readFileSync('public/app.js', 'utf8');
   assert.doesNotMatch(page, /`\/api\/members\/[^`]*\/bookings`/);
   assert.match(page, /\/api\/v2\/members\//);
 });
-
-test('durante un apagón la v1 responde 410 con lo que hay que hacer; la v2 sigue', async () => {
-  const server = await startTestServer({ now: '2027-09-01T15:30:00Z' });
-  const old = await fetch(`${server.url}/api/members/2/bookings`);
-  assert.equal(old.status, 410);
-  assert.match(((await old.json()) as { error: { message: string } }).error.message, /\/api\/v2\/members\/2\/bookings/);
-  assert.equal((await fetch(`${server.url}/api/v2/members/2/bookings`)).status, 200);
-  await server.close();
-});
-
-test('un apagón empieza y termina a la hora anunciada', () => {
-  assert.equal(isBrownout(new Date('2027-09-01T14:59:59Z')), false);
-  assert.equal(isBrownout(new Date('2027-09-01T15:00:00Z')), true);
-  assert.equal(isBrownout(new Date('2027-09-01T16:00:00Z')), false);
-});
diff --git a/test/v2.test.ts b/test/v2.test.ts
index 67946b3..9320e1a 100644
--- a/test/v2.test.ts
+++ b/test/v2.test.ts
@@ -3,7 +3,7 @@ import { after, before, describe, test } from 'node:test';
 import { postJson, startTestServer, type TestServer } from './helpers.ts';
 
 // El reloj de las pruebas marca el lunes 9 de marzo de 2026 a las 10:00.
-describe('las reservas de un vecino, en v1 y en v2', () => {
+describe('las reservas de un vecino, solo en v2', () => {
   let server: TestServer;
 
   before(async () => {
@@ -15,24 +15,20 @@ describe('las reservas de un vecino, en v1 y en v2', () => {
     await server.close();
   });
 
-  test('v1 responde lo mismo que antes y anuncia su fin', async () => {
+  test('la ruta vieja responde 410 y dice cuál usar', async () => {
     const response = await fetch(`${server.url}/api/members/2/bookings`);
-    const body = await response.json();
-    assert.equal(response.status, 200);
-    assert.ok(Array.isArray(body));
-    assert.equal(response.headers.get('deprecation'), '@1798761600');
-    assert.equal(response.headers.get('sunset'), 'Sat, 01 Jan 2028 00:00:00 GMT');
-    assert.equal(response.headers.get('link'), '</api/v2/members/2/bookings>; rel="successor-version"');
+    const { error } = (await response.json()) as { error: { code: string; message: string } };
+    assert.equal(response.status, 410);
+    assert.equal(error.code, 'ENDPOINT_REMOVED');
+    assert.match(error.message, /\/api\/v2\/members\/2\/bookings/);
   });
 
-  test('v2 devuelve las mismas reservas dentro de un objeto y sin aviso', async () => {
-    const v1 = await (await fetch(`${server.url}/api/members/2/bookings`)).json();
-    const response = await fetch(`${server.url}/api/v2/members/2/bookings`);
-    assert.deepEqual(await response.json(), { bookings: v1 });
-    assert.equal(response.headers.get('deprecation'), null);
+  test('v2 devuelve un objeto con las reservas', async () => {
+    const body = (await (await fetch(`${server.url}/api/v2/members/2/bookings`)).json()) as { bookings: { teamName: string }[] };
+    assert.deepEqual(body.bookings.map((b) => b.teamName), ['Real Barranco']);
   });
 
-  test('los errores no cambian entre versiones', async () => {
+  test('los errores de v2 siguen siendo los mismos', async () => {
     const response = await fetch(`${server.url}/api/v2/members/99/bookings`);
     assert.equal(response.status, 404);
     assert.equal(((await response.json()) as { error: { code: string } }).error.code, 'MEMBER_NOT_FOUND');