LLD in TypeScript with erasable syntax only

A low-level design in TypeScript can run on Node.js 24 exactly as written, with no build step, if it uses only erasable syntax: TypeScript that becomes plain JavaScript when its type annotations are deleted. Node.js runs a .ts file by replacing every type with whitespace, a feature that has been stable since Node.js 24.12.0, and it checks none of the types. Syntax that needs generated JavaScript cannot be deleted, so Node.js refuses it: an enum, a namespace that holds code, a parameter property such as constructor(private seat: string), and an import x = require() alias. TypeScript 5.8 added --erasableSyntaxOnly, which makes tsc report the same constructs as error TS1294 before anything runs. The limits cost a design little. A closed set becomes a union of string literals, a lifecycle becomes a discriminated union and a table, a class declares its fields and assigns them in its constructor, and hidden state goes into #private fields that the JavaScript engine enforces.

Every example in this lesson ran on Node.js 24.21.0, and every file type-checks with TypeScript 6.0.3 under --strict and --erasableSyntaxOnly, except the ones that are meant to fail.

Erasable syntax in one example

Seat classes are a classic closed set. Written as an enum, they are a runtime object that the compiler would have to generate. Written as an object of constants marked as const, plus a union type derived from it, they are ordinary JavaScript once the types are gone:

import { node, version } from './session.mjs';

// The enum version is refused before anything runs; the erasable version runs as it is.
version();
node('enums/seat_class_enum.ts');
node('enums/seat_class.ts');

# Node.js v24.21.0
$ node enums/seat_class_enum.ts
SyntaxError [ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX]: TypeScript enum is not supported in strip-only mode
[exit status 1]
$ node enums/seat_class.ts
[ 'standard', 'premium', 'recliner' ] 5000 15000

// Seat classes as a TypeScript enum. An enum is a runtime object that the compiler generates,
// so there is nothing Node.js could strip: it refuses the file.
enum SeatClass {
  Standard = "standard",
  Premium = "premium",
  Recliner = "recliner",
}

function surcharge(seatClass: SeatClass): number {
  return seatClass === SeatClass.Recliner ? 15000 : seatClass === SeatClass.Premium ? 5000 : 0;
}

console.log(surcharge(SeatClass.Premium));

// The same closed set in erasable syntax: an object of constants marked as const, and a union type
// derived from it. Strip the types and plain JavaScript is left.
export const SeatClass = {
  Standard: "standard",
  Premium: "premium",
  Recliner: "recliner",
} as const;
export type SeatClass = (typeof SeatClass)[keyof typeof SeatClass];

// One row per class: tsc refuses this table when a class is missing (satisfies).
const SURCHARGE_PAISE = {
  standard: 0,
  premium: 5000,
  recliner: 15000,
} as const satisfies Record<SeatClass, number>;

export function surcharge(seatClass: SeatClass): number {
  return SURCHARGE_PAISE[seatClass];
}

console.log(Object.values(SeatClass), surcharge(SeatClass.Premium), surcharge("recliner"));

// Runs TypeScript files the way a terminal shows them: "$ node <file>", then what the program printed. Node.js runs a
// .ts file by stripping its types and checks none of them. When Node.js refuses a file or the program throws, only the
// error line is shown, followed by the exit status.
import { spawnSync } from 'node:child_process';

export function version() {
  console.log(`# Node.js ${process.version}`);
}

export function node(file) {
  console.log(`$ node ${file}`);
  const run = spawnSync(process.execPath, [file], { encoding: 'utf8' });
  process.stdout.write(run.stdout);
  if (run.status !== 0) {
    const lines = run.stderr.split('\n');
    console.log(lines.find((line) => /^\w*Error\b/.test(line)) ?? lines.filter(Boolean).at(-1));
    console.log(`[exit status ${run.status}]`);
  }
  return run.status;
}

The enum version never starts: Node.js stops at enum SeatClass with ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX. The rewrite keeps what callers used. SeatClass.Premium is still a name, the type SeatClass accepts exactly the three strings, and surcharge("recliner") type-checks while surcharge("vip") would not. The price table ends in satisfies Record<SeatClass, number>, so a fourth class added without a price fails the type check.

In a machine-coding round this saves more time than it seems to. A design that runs with node design.ts needs no bundler, no compile step and no configuration, so the first run happens minutes into the round, and the same files run in the tests. Keep the type checker in the loop anyway, because Node.js runs code whose types are wrong without a word.

The rest of a TypeScript design follows from the same rule:

• Closed sets and lifecycles are unions of literals plus tables that tsc checks for a missing state.
• Private state goes into #private fields, because TypeScript’s private disappears with the other types.
• Branded IDs make a ShowId and a SeatId two different types, although both are strings at run time.
• Modules import types with the type keyword, or Node.js looks for them as values that do not exist.
• Cleanup that must always happen goes into a using declaration with a [Symbol.dispose]() method.

Closed sets and lifecycles that tsc checks Pro: opens with a Pro, Premium or Ultimate pass