SOLID at a glance, with LSP and ISP in TypeScript

A customer books "group B or similar" and plans the trip from what group B promises: five seats, motorway speed, a boot for two cases.

At the car-hire branch	In code
any car handed over for a group B booking must keep group B's promises; a bigger boot is fine, a smaller one is not	a subtype may accept more and deliver more, never less (steps 4–5)
a group B car whose boot will not open passes the desk's paperwork, which checks only the group letter, and fails at the kerb	an override that throws passes tsc, which checks only signatures (steps 6–7)
staff who learn of it keep a note: "if it's that car, warn the customer"	instanceof branches in callers (step 9)
one 20-page agreement for cars, vans, minibuses and trailers, re-signed by every car renter when the towing clause changes	a fat interface: any change reaches every client (steps 11–12)
a car agreement and a van agreement, with the fuel policy in both	one interface per kind of client, a shared method in each (step 13)
a separate agreement written for every customer	the overdone version (step 14)

In real terms: tsc compares an override's parameter and return types with the base's and never reads its body; a client typed against an interface must be given, and faked with, every member of it.

Breaks down when: the desk can lift the boot lid before handing over the keys. Nothing in TypeScript looks inside a method for a broken promise; only running it, or a test, does.

Contrasting case: a firm with one car model and one kind of customer has nothing to substitute and nothing to segregate, so neither principle has work to do there (step 2).

4.1 ExamHall EXH-2500: a read-only attempt in the autosave flush

A proctor reviewing a closed exam reopens an attempt as ReadOnlyAttempt, whose save() throws. The autosave flush is typed against Attempt, and its queue of five holds the review attempt third:

export const store = new Map<string, string[]>();

export class Attempt {
  constructor(public id: string, protected answers: string[]) {}
  // Stores the answers and returns how many were saved.
  save(): number { store.set(this.id, [...this.answers]); return this.answers.length; }
}
export class ReadOnlyAttempt extends Attempt {
  save(): number { throw new Error(`attempt ${this.id} is closed for review`); }
}

export function flush(queue: Attempt[]): number {
  let saved = 0;
  for (const a of queue) saved += a.save();
  return saved;
}

4.1 EXH-2500 ReadOnlyAttempt extends Attempt: tsc no diagnostics · flush threw Error · stored a-1, a-2 · not stored a-4, a-5
4.1 MR !2800 both implement AttemptView, only Attempt has save(): tsc TS2741 queue.ts:2 (the line that queues a-3)

The override kept the signature, so tsc passed it; at run time it ran in the base's place, and the flush stopped there (steps 6–7). MR !2800 stops claiming the subtype: a read-only attempt is an AttemptView, which has no save(), and tsc now rejects queueing it (step 10).

4.2 ExamHall EXH-2501: a 20-method port behind a 2-method badge

The proctor console's ProctorPort has 20 methods. alertBadge calls two of them, and its test builds a fake with those two:

export interface ProctorPort {
  onAlert(cb: (seat: string) => void): void;  unreadCount(): number;    markRead(id: string): void;
  pauseExam(examId: string): void;            resumeExam(examId: string): void;  extendTime(seat: string, min: number): void;
  flagSeat(seat: string, why: string): void;  clearFlag(seat: string): void;     messageSeat(seat: string, text: string): void;
  broadcast(text: string): void;              lockBrowser(seat: string): void;   unlockBrowser(seat: string): void;
  admit(seat: string): void;                  eject(seat: string): void;         seatPhoto(seat: string): string;
  roster(examId: string): string[];           incidents(examId: string): string[];  exportLog(examId: string): string;
  handOver(toProctor: string): void;          endExam(examId: string): void;
}
// alert-badge.ts: alertBadge(port: ProctorPort) calls port.onAlert and port.unreadCount
// alert-badge.test.ts: const fake = { onAlert: (cb) => cb('S-12'), unreadCount: () => 3 }, typed like the parameter

4.2 EXH-2501 alertBadge(port: ProctorPort), fake with 2 methods: TS2740 alert-badge.test.ts:3 (the fake lacks the other 18)

Typed against the whole port, the badge depends on 18 methods it never calls, and so does its fake (steps 11–12). MR !2801 applies step 13 to the badge.