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

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

// Las dependencias entre las capas de Kallpa, leídas de los imports.
//
//   node layers.ts [carpeta src]     (por omisión, ../../kallpa/src)
//
// Una capa puede usar las de abajo, nunca las de arriba. Las de abajo no
// saben que existen las de arriba: por eso domain se prueba sin base de datos
// ni HTTP.
import { readdirSync, readFileSync } from 'node:fs';
import { dirname, join, relative, resolve, sep } from 'node:path';
import ts from 'typescript';

export const LEVEL: Record<string, number> = {
  domain: 0,
  store: 1,
  notifications: 1,
  services: 2,
  http: 3,
  '(raíz)': 4, // main.ts, config.ts y seed.ts arman todo
};

export type Edge = { from: string; to: string; file: string; target: string; typeOnly: boolean };

function layerOf(srcDir: string, file: string): string {
  const parts = relative(srcDir, file).split(sep);
  return parts.length === 1 ? '(raíz)' : parts[0];
}

function listTs(dir: string): string[] {
  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
    const path = join(dir, entry.name);
    if (entry.isDirectory()) return listTs(path);
    return entry.name.endsWith('.ts') ? [path] : [];
  });
}

export function edges(srcDir: string): Edge[] {
  const root = resolve(srcDir);
  const result: Edge[] = [];
  for (const file of listTs(root).sort()) {
    const source = ts.createSourceFile(file, readFileSync(file, 'utf8'), ts.ScriptTarget.Latest, true);
    for (const node of source.statements) {
      if (!ts.isImportDeclaration(node) || !ts.isStringLiteral(node.moduleSpecifier)) continue;
      const spec = node.moduleSpecifier.text;
      if (!spec.startsWith('.')) continue; // node:sqlite, node:http...
      const target = resolve(dirname(file), spec);
      const from = layerOf(root, file);
      const to = layerOf(root, target);
      if (from === to) continue;
      const clause = node.importClause;
      const typeOnly =
        clause !== undefined &&
        (clause.isTypeOnly ||
          (clause.name === undefined &&
            clause.namedBindings !== undefined &&
            ts.isNamedImports(clause.namedBindings) &&
            clause.namedBindings.elements.every((e) => e.isTypeOnly)));
      result.push({ from, to, file: relative(root, file), target: relative(root, target), typeOnly });
    }
  }
  return result;
}

// Una dependencia va "hacia arriba" si la capa importada no está más abajo.
export function violations(all: Edge[]): Edge[] {
  return all.filter((e) => !(LEVEL[e.to] < LEVEL[e.from]));
}

export function summary(all: Edge[]): string {
  const groups = new Map<string, Edge[]>();
  for (const e of all) {
    const key = `${e.from} → ${e.to}`;
    groups.set(key, [...(groups.get(key) ?? []), e]);
  }
  const lines = [...groups.entries()]
    .sort(([, a], [, b]) => LEVEL[b[0].from] - LEVEL[a[0].from] || LEVEL[b[0].to] - LEVEL[a[0].to])
    .map(([key, list]) => {
      const types = list.filter((e) => e.typeOnly).length;
      const note = types === list.length ? ' (solo tipos)' : types > 0 ? ` (${types} solo tipos)` : '';
      return `${key.padEnd(24)} ${String(list.length).padStart(2)} ${list.length === 1 ? 'import' : 'imports'}${note}`;
    });
  const bad = violations(all);
  lines.push(
    bad.length === 0
      ? 'Ninguna dependencia va hacia arriba.'
      : bad.map((e) => `HACIA ARRIBA: ${e.file} importa ${e.target}`).join('\n'),
  );
  return lines.join('\n');
}

if (import.meta.main) {
  const src = process.argv[2] ?? new URL('../../kallpa/src', import.meta.url).pathname;
  const all = edges(src);
  console.log(summary(all));
  if (violations(all).length > 0) process.exit(1);
}

// Busca métodos que solo reenvían la llamada (pass-through methods): su cuerpo
// es una sola llamada a un método de un campo del objeto. Usa el compilador de
// TypeScript para leer el código, no expresiones regulares.
//
//   node pass-through.ts archivo.ts [otro.ts ...]
import { readFileSync } from 'node:fs';
import { basename } from 'node:path';
import ts from 'typescript';

export type MethodReport = {
  name: string;
  params: string[];
  // A dónde reenvía ('this.#repo.findItem'), o null si hace algo más.
  forwardsTo: string | null;
  // true si pasa exactamente los mismos parámetros, en el mismo orden.
  sameArguments: boolean;
};

export type ClassReport = { name: string; lines: number; methods: MethodReport[] };

export function analyze(source: string, fileName = 'input.ts'): ClassReport[] {
  const file = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
  const classes: ClassReport[] = [];
  file.forEachChild((node) => {
    if (!ts.isClassDeclaration(node) || !node.name) return;
    const start = file.getLineAndCharacterOfPosition(node.getStart()).line;
    const end = file.getLineAndCharacterOfPosition(node.getEnd()).line;
    const methods = node.members
      .filter(ts.isMethodDeclaration)
      .filter((m) => !ts.isPrivateIdentifier(m.name) && !isPrivate(m))
      .map((m) => report(m, file));
    classes.push({ name: node.name.text, lines: end - start + 1, methods });
  });
  return classes;
}

function isPrivate(m: ts.MethodDeclaration): boolean {
  return (ts.getCombinedModifierFlags(m) & (ts.ModifierFlags.Private | ts.ModifierFlags.Protected)) !== 0;
}

function report(method: ts.MethodDeclaration, file: ts.SourceFile): MethodReport {
  const name = method.name.getText(file);
  const params = method.parameters.map((p) => p.name.getText(file));
  const call = singleCall(method.body);
  if (!call || !isFieldMethod(call.expression)) return { name, params, forwardsTo: null, sameArguments: false };
  const args = call.arguments.map((a) => a.getText(file));
  return {
    name,
    params,
    forwardsTo: call.expression.getText(file),
    sameArguments: args.length === params.length && args.every((a, i) => a === params[i]),
  };
}

// El cuerpo es `return x.y(...);` o `x.y(...);` y nada más.
function singleCall(body: ts.Block | undefined): ts.CallExpression | null {
  if (!body || body.statements.length !== 1) return null;
  const [statement] = body.statements;
  const expression = ts.isReturnStatement(statement)
    ? statement.expression
    : ts.isExpressionStatement(statement)
      ? statement.expression
      : undefined;
  return expression && ts.isCallExpression(expression) ? expression : null;
}

// this.campo.metodo o this.#campo.metodo
function isFieldMethod(callee: ts.Expression): boolean {
  return (
    ts.isPropertyAccessExpression(callee) &&
    ts.isPropertyAccessExpression(callee.expression) &&
    callee.expression.expression.kind === ts.SyntaxKind.ThisKeyword
  );
}

export function format(file: string, classes: ClassReport[]): string {
  const out: string[] = [];
  for (const c of classes) {
    const forwarding = c.methods.filter((m) => m.forwardsTo !== null);
    out.push(`${basename(file)}: clase ${c.name}, ${c.lines} líneas, ${c.methods.length} métodos públicos`);
    for (const m of c.methods) {
      const signature = `${m.name}(${m.params.join(', ')})`;
      const verdict = m.forwardsTo === null ? 'hace algo más' : `reenvía a ${m.forwardsTo}${m.sameArguments ? '' : ' (cambia los argumentos)'}`;
      out.push(`  ${signature.padEnd(36)} ${verdict}`);
    }
    out.push(`  ${forwarding.length} de ${c.methods.length} métodos solo reenvían la llamada`);
  }
  return out.join('\n');
}

if (import.meta.main) {
  const files = process.argv.slice(2);
  if (files.length === 0) {
    console.error('Uso: node pass-through.ts archivo.ts [otro.ts ...]');
    process.exit(2);
  }
  for (const file of files) console.log(format(file, analyze(readFileSync(file, 'utf8'), file)));
}

--- a/src/http/handlers.ts
+++ b/src/http/handlers.ts
@@ -59,10 +59,7 @@
 export function courtAvailability(deps: AppDependencies): Handler {
   return ({ res, url, params }) => {
     const courtId = Number(params.id);
-    const date = url.searchParams.get('date');
-    if (!isValidDate(date)) {
-      throw new HttpError(400, 'INVALID_DATE', 'Indiquen la fecha con el formato AAAA-MM-DD (?date=2026-03-14).');
-    }
+    const date = requireDate(url);
     const taken = deps.service.bookingsForCourt(courtId, date).filter((b) => b.status === 'confirmed');
     const slots = [];
     for (let hour = OPENING_HOUR; hour < CLOSING_HOUR; hour++) {
@@ -155,15 +152,22 @@
 // GET /api/reports/daily?date=YYYY-MM-DD: la caja del día, para la administración.
 export function dailyReport(deps: AppDependencies): Handler {
   return ({ res, url }) => {
-    const date = url.searchParams.get('date');
-    if (!isValidDate(date)) {
-      throw new HttpError(400, 'INVALID_DATE', 'Indiquen la fecha con el formato AAAA-MM-DD (?date=2026-03-14).');
-    }
+    const date = requireDate(url);
     const bookings = deps.service.bookingsOn(date).map(toBookingJson);
     sendJson(res, 200, dailySummary(date, deps.service.listCourts(), bookings));
   };
 }
 
+// La fecha de la consulta (?date=AAAA-MM-DD): la piden la disponibilidad y la
+// caja del día.
+function requireDate(url: URL): string {
+  const date = url.searchParams.get('date');
+  if (!isValidDate(date)) {
+    throw new HttpError(400, 'INVALID_DATE', 'Indiquen la fecha con el formato AAAA-MM-DD (?date=2026-03-14).');
+  }
+  return date;
+}
+
 // Revisa la forma del cuerpo; las reglas del negocio se revisan después.
 function parseBookingRequest(body: unknown): BookingRequest {
   if (typeof body !== 'object' || body === null || Array.isArray(body)) {

// Una aplicación pequeña armada con tres conceptos independientes. Ningún
// concepto importa a otro: solo este archivo los conoce y los sincroniza.
//
//   cuando Reserva.reserve(u, cancha, bloque) devuelve id
//     entonces Plazo.register(id, inicio del bloque)
//          y   Notificación.notify(u, "reserva confirmada")
//   cuando alguien pide cancelar id
//     si Plazo.stillOpen(id, ahora) entonces Reserva.cancel(id)
import { Deadline } from './deadline.ts';
import { Notification } from './notification.ts';
import { Reservation, type Slot } from './reservation.ts';

export type WallTime = { day: string; hour: number; minute: number };

// Minutos desde un origen fijo, para comparar dos horas de pared.
function minutes({ day, hour, minute }: WallTime): number {
  const [y, m, d] = day.split('-').map(Number);
  return Date.UTC(y, m - 1, d, hour, minute) / 60_000;
}

export class CourtApp {
  readonly reservations = new Reservation<number, string>(); // cancha, celular
  readonly deadlines = new Deadline<number>(3);
  readonly notifications = new Notification<string>();

  book(phone: string, courtId: number, slot: Slot): number | 'taken' {
    const result = this.reservations.reserve(phone, courtId, slot);
    if (!result.ok) return 'taken';
    this.deadlines.register(result.id, minutes({ day: slot.day, hour: slot.from, minute: 0 }));
    this.notifications.notify(phone, `Reserva confirmada: cancha ${courtId}, ${slot.day} de ${slot.from}:00 a ${slot.to}:00.`);
    return result.id;
  }

  cancel(id: number, now: WallTime): 'cancelled' | 'too-late' | 'unknown' {
    if (this.reservations.slotOf(id) === undefined) return 'unknown';
    if (!this.deadlines.stillOpen(id, minutes(now))) return 'too-late';
    return this.reservations.cancel(id) ? 'cancelled' : 'unknown';
  }
}

// concepto Plazo [Cosa]
//
// propósito  dejar que alguien se arrepienta sin que el otro lado se entere
//            a último momento
// principio  si una cosa empieza en el instante t y el plazo es de h horas,
//            antes de t - h todavía se puede deshacer; desde t - h, ya no
// estado     inicio: Cosa -> instante; horas de aviso (fijas)
// acciones   register(cosa, inicio)
//            stillOpen(cosa, ahora) -> sí | no
//
// Tampoco sabe de reservas: el mismo concepto sirve para devolver una compra
// o para retirarse de un curso. Los instantes son minutos contados desde un
// origen cualquiera; quien lo usa decide cuál.

export class Deadline<T> {
  #noticeMinutes: number;
  #startsAt = new Map<T, number>();

  constructor(noticeHours: number) {
    this.#noticeMinutes = noticeHours * 60;
  }

  register(thing: T, startsAt: number): void {
    this.#startsAt.set(thing, startsAt);
  }

  stillOpen(thing: T, now: number): boolean {
    const start = this.#startsAt.get(thing);
    return start !== undefined && start - now >= this.#noticeMinutes;
  }
}

// concepto Notificación [Destinatario]
//
// propósito  avisar a alguien de algo que le importa sin que tenga que
//            revisar la aplicación
// principio  si se notifica a un destinatario, el mensaje le llega por su
//            canal
// estado     enviados: lista de (destinatario, texto)
// acciones   notify(destinatario, texto)
//
// El canal (WhatsApp, correo, la consola) es un detalle de la implementación:
// aquí los mensajes se guardan en una lista para poder revisarlos.

export class Notification<To> {
  readonly sent: { to: To; text: string }[] = [];

  notify(to: To, text: string): void {
    this.sent.push({ to, text });
  }
}

// concepto Reserva [Recurso, Usuario]
//
// propósito  asegurar a alguien el uso exclusivo de un recurso durante un
//            tiempo
// principio  si reservo un recurso para un bloque de horas, en esas horas el
//            recurso es mío: nadie más lo puede reservar; si cancelo, el
//            bloque vuelve a estar libre
// estado     reservas: Id -> (recurso, usuario, día, desde, hasta, activa)
// acciones   reserve(usuario, recurso, día, desde, hasta) -> Id | ocupado
//            cancel(id)
//            holder(recurso, día, hora) -> Usuario | nadie
//
// Es genérico: no sabe qué es una cancha ni qué es un vecino. Funcionaría
// igual para salas de reuniones o para la parrilla del club.

export type Slot = { day: string; from: number; to: number };

type Entry<R, U> = { resource: R; user: U; slot: Slot; active: boolean };

export class Reservation<R, U> {
  #entries = new Map<number, Entry<R, U>>();
  #nextId = 1;

  reserve(user: U, resource: R, slot: Slot): { ok: true; id: number } | { ok: false } {
    for (const e of this.#entries.values()) {
      if (e.active && e.resource === resource && e.slot.day === slot.day && e.slot.from < slot.to && slot.from < e.slot.to) {
        return { ok: false };
      }
    }
    const id = this.#nextId++;
    this.#entries.set(id, { resource, user, slot, active: true });
    return { ok: true, id };
  }

  cancel(id: number): boolean {
    const entry = this.#entries.get(id);
    if (!entry || !entry.active) return false;
    entry.active = false;
    return true;
  }

  holder(resource: R, day: string, hour: number): U | undefined {
    for (const e of this.#entries.values()) {
      if (e.active && e.resource === resource && e.slot.day === day && e.slot.from <= hour && hour < e.slot.to) return e.user;
    }
    return undefined;
  }

  slotOf(id: number): Slot | undefined {
    return this.#entries.get(id)?.slot;
  }
}

// El índice KWIC de Parnas (1972), dividido como un diagrama de flujo: un
// módulo por paso (leer, rotar, ordenar, imprimir). Los módulos se pasan
// arreglos y todos conocen su formato.

// El formato compartido: todas las palabras en un solo texto, cada una
// terminada en END; lineStart[i] es dónde empieza la línea i en ese texto.
export const END = '\u0000';

export type Store = { chars: string; lineStart: number[] };

// Un corrimiento circular: [línea, posición en chars donde empieza].
export type Shift = [line: number, start: number];

// Módulo 1, entrada: lee las líneas y las guarda en el formato de arriba.
export function input(text: string): Store {
  let chars = '';
  const lineStart: number[] = [];
  for (const line of text.split('\n').filter((l) => l.trim() !== '')) {
    lineStart.push(chars.length);
    for (const word of line.trim().split(/\s+/)) chars += word + END;
  }
  return { chars, lineStart };
}

// Módulo 2, corrimientos circulares: un par por cada palabra de cada línea.
export function circularShift(store: Store): Shift[] {
  const shifts: Shift[] = [];
  store.lineStart.forEach((start, line) => {
    const end = store.lineStart[line + 1] ?? store.chars.length;
    shifts.push([line, start]);
    for (let i = start; i < end - 1; i++) if (store.chars[i] === END) shifts.push([line, i + 1]);
  });
  return shifts;
}

// Para comparar, rearma el texto de un corrimiento: tiene que saber cómo
// están guardadas las palabras y dónde termina cada línea.
function shiftText(store: Store, [line, start]: Shift): string {
  const lineBegin = store.lineStart[line];
  const lineEnd = store.lineStart[line + 1] ?? store.chars.length;
  const rotated = store.chars.slice(start, lineEnd) + store.chars.slice(lineBegin, start);
  return rotated.split(END).filter(Boolean).join(' ');
}

// Módulo 3, orden alfabético: recibe los arreglos de los módulos 1 y 2.
export function alphabetize(store: Store, shifts: Shift[]): Shift[] {
  return [...shifts].sort((a, b) => compare(shiftText(store, a), shiftText(store, b)));
}

export function compare(a: string, b: string): number {
  const x = a.toLowerCase();
  const y = b.toLowerCase();
  return x < y ? -1 : x > y ? 1 : 0;
}

// Módulo 4, salida: vuelve a leer chars y lineStart para imprimir.
export function output(store: Store, sorted: Shift[]): string {
  return sorted.map((shift) => shiftText(store, shift)).join('\n');
}

// Módulo 5, control: llama a los demás en orden.
export function kwic(text: string): string {
  const store = input(text);
  return output(store, alphabetize(store, circularShift(store)));
}

// El mismo índice KWIC dividido según lo que cada módulo esconde (la segunda
// propuesta de Parnas). Nadie fuera de LineStorage sabe cómo se guardan las
// palabras; nadie fuera de CircularShifter sabe si los corrimientos se
// guardan o se calculan; nadie fuera de Alphabetizer sabe cuándo se ordena.
import { compare } from './flowchart.ts';

// Lo que los demás ven del almacenamiento de líneas.
export type Lines = {
  addLine(words: string[]): void;
  lineCount(): number;
  wordCount(line: number): number;
  word(line: number, w: number): string;
};

// Esconde el formato: aquí, el mismo texto empaquetado de flowchart.ts.
export class PackedLines implements Lines {
  #chars = '';
  #wordStarts: number[][] = [];

  addLine(words: string[]): void {
    const starts: number[] = [];
    for (const word of words) {
      starts.push(this.#chars.length);
      this.#chars += word + '\u0000';
    }
    this.#wordStarts.push(starts);
  }
  lineCount(): number {
    return this.#wordStarts.length;
  }
  wordCount(line: number): number {
    return this.#wordStarts[line].length;
  }
  word(line: number, w: number): string {
    const start = this.#wordStarts[line][w];
    return this.#chars.slice(start, this.#chars.indexOf('\u0000', start));
  }
}

// Otra decisión, la misma interfaz: un arreglo de palabras por línea.
export class ArrayLines implements Lines {
  #lines: string[][] = [];

  addLine(words: string[]): void {
    this.#lines.push([...words]);
  }
  lineCount(): number {
    return this.#lines.length;
  }
  wordCount(line: number): number {
    return this.#lines[line].length;
  }
  word(line: number, w: number): string {
    return this.#lines[line][w];
  }
}

export function input(text: string, lines: Lines): void {
  for (const line of text.split('\n').filter((l) => l.trim() !== '')) lines.addLine(line.trim().split(/\s+/));
}

// Lo que los demás ven de los corrimientos: "como si" estuvieran guardados.
export type Shifts = { count(): number; words(i: number): string[] };

// Esconde que guarda un índice [línea, primera palabra] en vez de copias.
export class IndexedShifter implements Shifts {
  #lines: Lines;
  #index: [line: number, first: number][] = [];

  constructor(lines: Lines) {
    this.#lines = lines;
    for (let line = 0; line < lines.lineCount(); line++) {
      for (let first = 0; first < lines.wordCount(line); first++) this.#index.push([line, first]);
    }
  }
  count(): number {
    return this.#index.length;
  }
  words(i: number): string[] {
    const [line, first] = this.#index[i];
    const n = this.#lines.wordCount(line);
    return Array.from({ length: n }, (_, k) => this.#lines.word(line, (first + k) % n));
  }
}

// Esconde el orden: se ordena una vez, al construirlo; ith(i) es el i-ésimo.
export class Alphabetizer {
  #order: number[];

  constructor(shifts: Shifts) {
    const text = (i: number) => shifts.words(i).join(' ');
    this.#order = Array.from({ length: shifts.count() }, (_, i) => i).sort((a, b) => compare(text(a), text(b)));
  }
  ith(i: number): number {
    return this.#order[i];
  }
}

export function output(shifts: Shifts, alphabetizer: Alphabetizer): string {
  return Array.from({ length: shifts.count() }, (_, i) => shifts.words(alphabetizer.ith(i)).join(' ')).join('\n');
}

export function kwic(text: string, lines: Lines = new PackedLines()): string {
  input(text, lines);
  const shifts = new IndexedShifter(lines);
  return output(shifts, new Alphabetizer(shifts));
}

import type { DatabaseSync } from 'node:sqlite';
import type { Now, Request, Response } from './schema.ts';

// Versión profunda. Mismo comportamiento que shallow.ts, pero un solo módulo
// sabe cómo se guardan los préstamos y cuándo un préstamo está abierto.

export type Loan = {
  id: number;
  itemId: number;
  memberId: number;
  lentAt: string;
  returnedAt: string | null;
};

export type ItemStatus = { id: number; name: string; available: boolean };

export type LoanError = {
  code: 'ITEM_NOT_FOUND' | 'ITEM_LENT' | 'MEMBER_HAS_LOAN' | 'LOAN_NOT_FOUND' | 'ALREADY_RETURNED';
  message: string;
};

export type LoanResult = { ok: true; loan: Loan } | { ok: false; error: LoanError };

type LoanRow = { id: number; item_id: number; member_id: number; lent_at: string; returned_at: string | null };

// Interfaz: tres operaciones. Esconde la tabla y sus columnas, la regla de
// qué préstamo está abierto (está escrita una sola vez, en el SQL de abajo),
// el reloj y el orden en que se revisan las reglas.
export class Loans {
  #db: DatabaseSync;
  #now: Now;

  constructor(db: DatabaseSync, now: Now) {
    this.#db = db;
    this.#now = now;
  }

  // Los implementos con su estado: disponible si no tiene un préstamo abierto.
  items(): ItemStatus[] {
    const rows = this.#db
      .prepare(
        `SELECT id, name, NOT EXISTS (SELECT 1 FROM loans WHERE ${OPEN} AND loans.item_id = items.id) AS available
         FROM items ORDER BY id`,
      )
      .all() as { id: number; name: string; available: number }[];
    return rows.map((r) => ({ id: r.id, name: r.name, available: r.available === 1 }));
  }

  // Presta el implemento si existe, está libre y el vecino no tiene otro.
  lend(itemId: number, memberId: number): LoanResult {
    if (!this.#db.prepare('SELECT 1 FROM items WHERE id = ?').get(itemId)) {
      return fail('ITEM_NOT_FOUND', `No existe el implemento ${itemId}.`);
    }
    if (this.#openLoan('item_id', itemId)) return fail('ITEM_LENT', 'El implemento está prestado.');
    if (this.#openLoan('member_id', memberId)) {
      return fail('MEMBER_HAS_LOAN', 'Primero hay que devolver el implemento anterior.');
    }
    const { lastInsertRowid } = this.#db
      .prepare('INSERT INTO loans (item_id, member_id, lent_at) VALUES (?, ?, ?)')
      .run(itemId, memberId, this.#now());
    return { ok: true, loan: this.#find(Number(lastInsertRowid))! };
  }

  // Registra la devolución; un préstamo se devuelve una sola vez.
  giveBack(loanId: number): LoanResult {
    const loan = this.#find(loanId);
    if (!loan) return fail('LOAN_NOT_FOUND', `No existe el préstamo ${loanId}.`);
    if (loan.returnedAt !== null) return fail('ALREADY_RETURNED', 'El implemento ya fue devuelto.');
    this.#db.prepare('UPDATE loans SET returned_at = ? WHERE id = ?').run(this.#now(), loanId);
    return { ok: true, loan: this.#find(loanId)! };
  }

  #openLoan(column: 'item_id' | 'member_id', id: number): boolean {
    return this.#db.prepare(`SELECT 1 FROM loans WHERE ${OPEN} AND ${column} = ?`).get(id) !== undefined;
  }

  #find(id: number): Loan | undefined {
    const row = this.#db.prepare('SELECT * FROM loans WHERE id = ?').get(id) as LoanRow | undefined;
    return row && { id: row.id, itemId: row.item_id, memberId: row.member_id, lentAt: row.lent_at, returnedAt: row.returned_at };
  }
}

// La regla "un préstamo está abierto", en un solo lugar.
const OPEN = 'returned_at IS NULL';

function fail(code: LoanError['code'], message: string): LoanResult {
  return { ok: false, error: { code, message } };
}

// La capa HTTP solo traduce: lee la solicitud, llama al módulo y elige el
// código HTTP.
const STATUS: Record<LoanError['code'], number> = {
  ITEM_NOT_FOUND: 404,
  LOAN_NOT_FOUND: 404,
  ITEM_LENT: 409,
  MEMBER_HAS_LOAN: 409,
  ALREADY_RETURNED: 409,
};

function respond(result: LoanResult): Response {
  return result.ok
    ? { status: 200, body: { loan: result.loan } }
    : { status: STATUS[result.error.code], body: { error: result.error } };
}

export function handleDeep(loans: Loans, req: Request): Response {
  if (req.method === 'GET' && req.path === '/items') return { status: 200, body: { items: loans.items() } };
  if (req.method === 'POST' && req.path === '/loans') {
    return respond(loans.lend(Number(req.body?.itemId), Number(req.body?.memberId)));
  }
  const match = /^\/loans\/(\d+)\/return$/.exec(req.path);
  if (req.method === 'POST' && match) return respond(loans.giveBack(Number(match[1])));
  return { status: 404, body: { error: { code: 'NOT_FOUND', message: `No existe la ruta ${req.path}.` } } };
}

import { DatabaseSync } from 'node:sqlite';

// Préstamo de implementos: en la administración del complejo se prestan
// pelotas y redes a quien tiene una reserva. Las dos versiones del ejemplo
// (shallow.ts y deep.ts) usan este mismo esquema y los mismos datos.
export function openLoansDatabase(): DatabaseSync {
  const db = new DatabaseSync(':memory:');
  db.exec(`
    CREATE TABLE items (
      id   INTEGER PRIMARY KEY,
      name TEXT NOT NULL
    );
    CREATE TABLE loans (
      id          INTEGER PRIMARY KEY,
      item_id     INTEGER NOT NULL REFERENCES items (id),
      member_id   INTEGER NOT NULL,
      lent_at     TEXT NOT NULL,
      returned_at TEXT
    );
  `);
  const insert = db.prepare('INSERT INTO items (name) VALUES (?)');
  for (const name of ['Pelota de fulbito', 'Pelota de vóley', 'Red de vóley']) insert.run(name);
  return db;
}

// Lo que ve quien llama: una solicitud y una respuesta, sin servidor HTTP de
// por medio. Alcanza para comparar las dos versiones con el mismo guion.
export type Request = { method: 'GET' | 'POST'; path: string; body?: Record<string, unknown> };
export type Response = { status: number; body: unknown };

// "Ahora", inyectable como en Kallpa: las pruebas fijan la hora.
export type Now = () => string;

import type { DatabaseSync } from 'node:sqlite';
import type { Now, Request, Response } from './schema.ts';

// Versión superficial. Funciona y pasa sus pruebas, pero el diseño reparte el
// conocimiento: las columnas de la tabla, la regla "un préstamo está abierto
// si no tiene returned_at" y los códigos HTTP aparecen en varios lugares.

export type ItemRow = { id: number; name: string };

export type LoanRow = {
  id: number;
  item_id: number;
  member_id: number;
  lent_at: string;
  returned_at: string | null;
};

export class LoanRepository {
  #db: DatabaseSync;

  constructor(db: DatabaseSync) {
    this.#db = db;
  }

  listItems(): ItemRow[] {
    return this.#db.prepare('SELECT id, name FROM items ORDER BY id').all() as ItemRow[];
  }

  findItem(id: number): ItemRow | undefined {
    return this.#db.prepare('SELECT id, name FROM items WHERE id = ?').get(id) as ItemRow | undefined;
  }

  findLoan(id: number): LoanRow | undefined {
    return this.#db.prepare('SELECT * FROM loans WHERE id = ?').get(id) as LoanRow | undefined;
  }

  // Todos los préstamos del implemento, también los ya devueltos.
  loansForItem(itemId: number): LoanRow[] {
    return this.#db.prepare('SELECT * FROM loans WHERE item_id = ?').all(itemId) as LoanRow[];
  }

  loansForMember(memberId: number): LoanRow[] {
    return this.#db.prepare('SELECT * FROM loans WHERE member_id = ?').all(memberId) as LoanRow[];
  }

  insert(itemId: number, memberId: number, lentAt: string): number {
    const result = this.#db
      .prepare('INSERT INTO loans (item_id, member_id, lent_at) VALUES (?, ?, ?)')
      .run(itemId, memberId, lentAt);
    return Number(result.lastInsertRowid);
  }

  setReturnedAt(id: number, returnedAt: string): void {
    this.#db.prepare('UPDATE loans SET returned_at = ? WHERE id = ?').run(returnedAt, id);
  }
}

// La "capa de servicios": cada método reenvía la llamada al repositorio.
export class LoanService {
  #repo: LoanRepository;

  constructor(db: DatabaseSync) {
    this.#repo = new LoanRepository(db);
  }

  listItems(): ItemRow[] {
    return this.#repo.listItems();
  }

  findItem(id: number): ItemRow | undefined {
    return this.#repo.findItem(id);
  }

  findLoan(id: number): LoanRow | undefined {
    return this.#repo.findLoan(id);
  }

  loansForItem(itemId: number): LoanRow[] {
    return this.#repo.loansForItem(itemId);
  }

  loansForMember(memberId: number): LoanRow[] {
    return this.#repo.loansForMember(memberId);
  }

  saveLoan(itemId: number, memberId: number, lentAt: string): number {
    return this.#repo.insert(itemId, memberId, lentAt);
  }

  markReturned(id: number, returnedAt: string): void {
    this.#repo.setReturnedAt(id, returnedAt);
  }
}

function toLoanJson(row: LoanRow) {
  return { id: row.id, itemId: row.item_id, memberId: row.member_id, lentAt: row.lent_at, returnedAt: row.returned_at };
}

function error(status: number, code: string, message: string): Response {
  return { status, body: { error: { code, message } } };
}

// Los "handlers" deciden todo: qué préstamo está abierto, qué se puede prestar
// y qué se guarda.
export function handleShallow(service: LoanService, now: Now, req: Request): Response {
  if (req.method === 'GET' && req.path === '/items') {
    const items = service.listItems().map((item) => ({
      ...item,
      available: !service.loansForItem(item.id).some((l) => l.returned_at === null),
    }));
    return { status: 200, body: { items } };
  }
  if (req.method === 'POST' && req.path === '/loans') {
    const itemId = Number(req.body?.itemId);
    const memberId = Number(req.body?.memberId);
    const item = service.findItem(itemId);
    if (!item) return error(404, 'ITEM_NOT_FOUND', `No existe el implemento ${itemId}.`);
    if (service.loansForItem(itemId).some((l) => l.returned_at === null)) {
      return error(409, 'ITEM_LENT', 'El implemento está prestado.');
    }
    if (service.loansForMember(memberId).some((l) => !l.returned_at)) {
      return error(409, 'MEMBER_HAS_LOAN', 'Primero hay que devolver el implemento anterior.');
    }
    const id = service.saveLoan(itemId, memberId, now());
    return { status: 200, body: { loan: toLoanJson(service.findLoan(id)!) } };
  }
  const match = /^\/loans\/(\d+)\/return$/.exec(req.path);
  if (req.method === 'POST' && match) {
    const loan = service.findLoan(Number(match[1]));
    if (!loan) return error(404, 'LOAN_NOT_FOUND', `No existe el préstamo ${match[1]}.`);
    if (loan.returned_at !== null) return error(409, 'ALREADY_RETURNED', 'El implemento ya fue devuelto.');
    service.markReturned(loan.id, now());
    return { status: 200, body: { loan: toLoanJson(service.findLoan(loan.id)!) } };
  }
  return error(404, 'NOT_FOUND', `No existe la ruta ${req.path}.`);
}

import assert from 'node:assert/strict';
import { spawnSync } from 'node:child_process';
import { cpSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { test } from 'node:test';

// Amplificación de cambios, medida: en una copia de Kallpa se cambia el cierre
// de las 22:00 a las 23:00 en la única línea que lo define, y se corren las
// pruebas. El código entero se entera del cambio; fallan las dos pruebas que
// tienen el horario escrito a mano (15 horas libres, y 21:00 + 2 horas como
// "después del cierre").
test('cerrar a las 23:00 cambia una constante y rompe dos pruebas', () => {
  const copy = mkdtempSync(join(tmpdir(), 'kallpa-23-'));
  try {
    cpSync(new URL('../../kallpa', import.meta.url).pathname, copy, { recursive: true });
    const file = join(copy, 'src/domain/booking.ts');
    const source = readFileSync(file, 'utf8');
    assert.match(source, /export const CLOSING_HOUR = 22;/);
    writeFileSync(file, source.replace('export const CLOSING_HOUR = 22;', 'export const CLOSING_HOUR = 23;'));

    // Sin NODE_TEST_CONTEXT: si no, el node --test de adentro le habla al de
    // afuera por otro canal y no escribe nada en stdout.
    const env = { ...process.env };
    delete env.NODE_TEST_CONTEXT;
    const run = spawnSync('node', ['--test', '--test-reporter=tap', 'test/**/*.test.ts'], { cwd: copy, env, encoding: 'utf8' });
    assert.match(run.stdout, /# fail 2\n/);
    assert.match(run.stdout, /not ok \d+ - rechaza una reserva que termina después del cierre/);
    assert.match(run.stdout, /not ok \d+ - una cancha sin reservas está libre todo el día/);
    assert.match(run.stdout, /16 !== 15/);
  } finally {
    rmSync(copy, { recursive: true });
  }
});

import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import { describe, test } from 'node:test';
import { CourtApp } from './concepts/app.ts';
import { Deadline } from './concepts/deadline.ts';
import { Reservation } from './concepts/reservation.ts';

// Cada principio operacional, escrito como una prueba.
describe('principios operacionales', () => {
  test('Reserva: si reservo de 19 a 21, a esa hora nadie más puede reservar; si cancelo, queda libre', () => {
    const r = new Reservation<string, string>();
    const mine = r.reserve('Rosa', 'Fulbito 1', { day: '2026-03-14', from: 19, to: 21 });
    assert.ok(mine.ok);
    assert.equal(r.holder('Fulbito 1', '2026-03-14', 20), 'Rosa');
    assert.deepEqual(r.reserve('Luis', 'Fulbito 1', { day: '2026-03-14', from: 20, to: 22 }), { ok: false });
    r.cancel(mine.id);
    assert.equal(r.reserve('Luis', 'Fulbito 1', { day: '2026-03-14', from: 20, to: 22 }).ok, true);
  });

  test('Reserva es genérica: sirve igual para la parrilla del club', () => {
    const grill = new Reservation<'parrilla', number>();
    assert.equal(grill.reserve(7, 'parrilla', { day: '2026-03-15', from: 12, to: 16 }).ok, true);
    assert.equal(grill.holder('parrilla', '2026-03-15', 13), 7);
  });

  test('Plazo: con 3 horas de aviso, a las 15:00 se deshace algo de las 18:00; a las 15:01, ya no', () => {
    const d = new Deadline<string>(3);
    d.register('reserva', 18 * 60);
    assert.equal(d.stillOpen('reserva', 15 * 60), true);
    assert.equal(d.stillOpen('reserva', 15 * 60 + 1), false);
  });
});

describe('la aplicación: tres conceptos y sus sincronizaciones', () => {
  test('al reservar se avisa; al cancelar a tiempo se libera la cancha', () => {
    const app = new CourtApp();
    const id = app.book('987654321', 1, { day: '2026-03-14', from: 19, to: 21 });
    assert.equal(typeof id, 'number');
    assert.deepEqual(app.notifications.sent, [
      { to: '987654321', text: 'Reserva confirmada: cancha 1, 2026-03-14 de 19:00 a 21:00.' },
    ]);
    assert.equal(app.book('912345678', 1, { day: '2026-03-14', from: 20, to: 21 }), 'taken');
    assert.equal(app.cancel(id as number, { day: '2026-03-14', hour: 16, minute: 30 }), 'too-late');
    assert.equal(app.cancel(id as number, { day: '2026-03-14', hour: 16, minute: 0 }), 'cancelled');
    assert.equal(app.reservations.holder(1, '2026-03-14', 20), undefined);
  });

  test('ningún concepto importa a otro', () => {
    for (const name of ['reservation', 'deadline', 'notification']) {
      const source = readFileSync(new URL(`./concepts/${name}.ts`, import.meta.url), 'utf8');
      assert.doesNotMatch(source, /^import /m, `${name}.ts no debería importar nada`);
    }
  });
});

import assert from 'node:assert/strict';
import { describe, test } from 'node:test';
import { kwic as kwicFlowchart } from './kwic/flowchart.ts';
import { ArrayLines, kwic as kwicHiding, PackedLines } from './kwic/hiding.ts';

const TEXT = `Kallpa reserva canchas
canchas de vóley
reserva confirmada por WhatsApp`;

describe('índice KWIC', () => {
  test('lista cada corrimiento circular en orden alfabético', () => {
    assert.equal(
      kwicFlowchart(TEXT),
      [
        'canchas de vóley',
        'canchas Kallpa reserva',
        'confirmada por WhatsApp reserva',
        'de vóley canchas',
        'Kallpa reserva canchas',
        'por WhatsApp reserva confirmada',
        'reserva canchas Kallpa',
        'reserva confirmada por WhatsApp',
        'vóley canchas de',
        'WhatsApp reserva confirmada por',
      ].join('\n'),
    );
  });

  test('las dos divisiones en módulos dan exactamente la misma salida', () => {
    assert.equal(kwicHiding(TEXT), kwicFlowchart(TEXT));
  });

  test('cambiar cómo se guardan las líneas no cambia la salida', () => {
    assert.equal(kwicHiding(TEXT, new ArrayLines()), kwicHiding(TEXT, new PackedLines()));
  });
});