diff --git a/ROADMAP.md b/ROADMAP.md
new file mode 100644
index 0000000..80202a2
--- /dev/null
+++ b/ROADMAP.md
@@ -0,0 +1,201 @@
+# postcss-calc v11 Roadmap
+
+Spec-first rewrite of the plugin's internals, targeting [CSS Values and Units Module Level 4 §10](https://www.w3.org/TR/css-values-4/#calc-notation). The public plugin API (options, plugin shape) is preserved; every consumer on v10.x should upgrade without code changes.
+
+## Why v11
+
+Current state (v10.1.1) has known gaps that the spec closes:
+
+- No `min()` / `max()` / `clamp()` support — treated as opaque blobs.
+- Typed division (`calc(100vw / 1px)`) throws *"Cannot divide by 'px', number expected"*.
+- No folding of `pi` / `e` / `infinity` / `NaN` into arithmetic.
+- JISON-generated LR parser is hard to extend: every new math function requires editing the grammar and regenerating.
+- Ad-hoc reducer reinvents a weaker version of the spec's simplification algorithm, which means every edge case is discovered by users instead of derived from the standard.
+
+v11 replaces the parser + reducer + stringifier with direct transcriptions of the spec. The existing 190 regression tests become the contract we ship against.
+
+## Non-goals (deliberate deferrals)
+
+- **Relative color math** (`lch(from X l c calc(h + 80))`) — channel-keyword scope is out-of-band; requires caller context the plugin doesn't have at transform time.
+- **`calc-size()`** — separate, evolving spec; continue to leave as-is.
+- **Property-context percentage resolution** — a PostCSS transform has no property-type info; spec explicitly allows plugins to leave percentages unresolved.
+- **Transpiling modern math functions to legacy `calc()`** — a separate concern; belongs in a companion plugin if wanted.
+
+## Architecture
+
+Five modules, each one-to-one with a spec section. Every module file starts with the exact spec URL it implements, so a contributor (or reviewer) can check conformance section-by-section.
+
+| Module | Spec section | Purpose |
+|---|---|---|
+| `tokenizer.ts` | [§10.1](https://www.w3.org/TR/css-values-4/#calc-syntax) | Numbers, dimensions (incl. `1px-2` single-token rule), idents, punct |
+| `parser.ts` | [§10.1](https://www.w3.org/TR/css-values-4/#calc-syntax) | Pratt parser + parselet registry → AST |
+| `type.ts` | [§10.2](https://www.w3.org/TR/css-values-4/#calc-type-checking) | Calculation-type arithmetic (unit × power maps) |
+| `simplify.ts` | [§10.10](https://www.w3.org/TR/css-values-4/#calc-simplification) | Post-order simplification |
+| `serialize.ts` | [§10.12](https://www.w3.org/TR/css-values-4/#serialize-a-calculation-tree) | AST → CSS text with correct `calc()` wrapping |
+
+## Current status
+
+**Done** (on `master`, in `playground/pratt/`):
+
+- Pratt parser skeleton in TypeScript, parselet registries for prefix + infix.
+- Tokenizer for numbers / idents / punct.
+- Evaluator harness (number-only) proving the parser works for `min`/`max`/`clamp`/`pow`/trig/stepped-value/etc. as generic call nodes.
+- 48 tests covering precedence, associativity, unary stacking, function calls, and negative-syntax / pinned-behavior cases.
+- `tsx` runtime + strict `tsconfig.json` for the playground; `pnpm test:pratt` runs the TS suite directly.
+
+The playground has validated the parser design on a clean slate. What remains is dimensions, the type system, simplification, and serialization — the three load-bearing spec pieces plus tokenizer extension.
+
+---
+
+## Release plan
+
+Each release is scoped to ship on its own. Earlier releases do **not** block on later ones.
+
+### v11.0 — Foundation
+
+**Goal:** spec-correct parser + simplification core with `min`/`max`/`clamp` + typed division. Ships 80% of real-world value.
+
+**Scope:**
+
+- Replace `parser.jison` with the Pratt parser from the playground, promoted into `src/`.
+- Drop `jison-gho` devDep; delete `parser.jison`; remove `build` script.
+- Dimension token rule including spec-required `1px-2` single-token behavior.
+- Calculation type system (§10.2).
+- `simplify()` core covering:
+  - Nested `calc()` flattening (inner calc → bare parens).
+  - Like-term combination across `+` / `-`.
+  - Numeric folding for resolvable subtrees.
+  - Unit conversion within a family (port `src/lib/convertUnit.js`).
+  - Opaque-leaf preservation: `var()`, `env()`, `attr()`, and unknown functions are AST leaves that simplification flows around.
+- `min()`, `max()`, `clamp()` as first-class AST nodes with spec-correct reduction.
+- Typed division: `<length> / <length> → <number>`, `<time> / <time> → <number>`, etc.
+- Serializer matching current output shape for all v10.x regression cases.
+
+**Test coverage:**
+
+| Suite | File | Count (estimate) |
+|---|---|---|
+| Regression (preserves v10 behavior) | `test/index.js` | 190 (existing) |
+| `min` / `max` / `clamp` reduction | `test/v11-min-max-clamp.test.ts` | ~30 |
+| Typed division and unit arithmetic | `test/v11-typed-arithmetic.test.ts` | ~15 |
+| Opaque-leaf preservation (`var()`, `env()`, unknown fns) | `test/v11-opaque.test.ts` | ~15 |
+| Type-checking error cases (invalid mixes) | `test/v11-type-errors.test.ts` | ~10 |
+| WPT conformance subset | `test/wpt/calc-basic.test.ts` | ~25 |
+
+**Acceptance:** all 190 existing + ~95 new ≈ **~285 tests green**.
+
+---
+
+### v11.1 — Stepped-value functions
+
+**Goal:** spec coverage for the rounding / modulo family (§10.8).
+
+**Scope:**
+
+- `round([<rounding-strategy>,]? A, B?)` with `nearest | up | down | to-zero`; default `nearest`; if `B` is omitted, rounds to `1` in `A`'s type.
+- `mod(A, B)` — result sign follows divisor.
+- `rem(A, B)` — result sign follows dividend.
+- `abs(A)` — preserves type.
+- `sign(A)` — returns `<number>` regardless of input type.
+- Parser: one bespoke parselet for `round` to peek for a keyword first-argument.
+
+**Test coverage:**
+
+| Suite | File | Count (estimate) |
+|---|---|---|
+| `round` with all four strategies × (A) / (A,B) × resolvable/opaque | `test/v11-round.test.ts` | ~20 |
+| `mod` / `rem` sign behavior and opaque passthrough | `test/v11-mod-rem.test.ts` | ~12 |
+| `abs` / `sign` incl. type preservation and sign-return-type | `test/v11-abs-sign.test.ts` | ~10 |
+| WPT conformance subset (`round`, `mod`, `rem`) | `test/wpt/round-mod-rem.test.ts` | ~25 |
+
+**Acceptance:** adds ~**67 tests**, cumulative **~352**.
+
+---
+
+### v11.2 — Trigonometric functions
+
+**Goal:** spec coverage for trig (§10.8) including angle-unit coercion.
+
+**Scope:**
+
+- `sin(A)`, `cos(A)`, `tan(A)` — accept `<angle>` (deg/rad/grad/turn) or bare `<number>` (treated as radians per spec).
+- `asin(A)`, `acos(A)`, `atan(A)` — return `<angle>` in degrees.
+- `atan2(Y, X)` — returns `<angle>` in degrees; accepts any matching types.
+- Angle-unit normalization inside trig argument reduction.
+- Calc keyword `pi` folds into trig arguments (`sin(pi / 2)` → `1`).
+
+**Test coverage:**
+
+| Suite | File | Count (estimate) |
+|---|---|---|
+| `sin` / `cos` / `tan` × (deg, rad, grad, turn, bare number) | `test/v11-trig.test.ts` | ~25 |
+| `asin` / `acos` / `atan` — return type is degrees | `test/v11-trig-inverse.test.ts` | ~12 |
+| `atan2` two-argument type matching | `test/v11-atan2.test.ts` | ~8 |
+| Trig with `pi` folding | `test/v11-trig-pi.test.ts` | ~10 |
+| WPT conformance subset (trig) | `test/wpt/trig.test.ts` | ~25 |
+
+**Acceptance:** adds ~**80 tests**, cumulative **~432**.
+
+---
+
+### v11.3 — Exponential family + degenerate-numeric finalization
+
+**Goal:** complete the math-function set (§10.8) and pin spec-correct serialization of degenerate numbers (§10.9, §10.12).
+
+**Scope:**
+
+- `pow(A, B)`, `sqrt(A)`, `hypot(A, B, …)`.
+- `log(A)` (natural log), `log(A, B)` (log base B), `exp(A)`.
+- Unit handling: `pow`/`sqrt`/`hypot` resolve to bare numbers where required by spec; preserve through opaque subtrees.
+- Full `<calc-keyword>` arithmetic: `e`, `pi`, `infinity`, `-infinity`, `NaN` fold per IEEE-754.
+- Degenerate-numeric serialization: `calc(1px / 0)` → `calc(infinity * 1px)`; `calc(0 / 0 * 1px)` → `calc(NaN * 1px)`.
+- Case-sensitivity: `NaN` is case-sensitive (spec); all other keywords are case-insensitive.
+
+**Test coverage:**
+
+| Suite | File | Count (estimate) |
+|---|---|---|
+| `pow` / `sqrt` / `hypot` with type handling | `test/v11-exponential.test.ts` | ~18 |
+| `log` / `exp` incl. two-arg `log(a, b)` | `test/v11-log-exp.test.ts` | ~10 |
+| Calc-keyword folding in arithmetic | `test/v11-calc-keywords.test.ts` | ~15 |
+| Degenerate numeric serialization (infinity, NaN) | `test/v11-degenerate.test.ts` | ~12 |
+| WPT conformance subset (exp family, keywords) | `test/wpt/exp-keywords.test.ts` | ~25 |
+
+**Acceptance:** adds ~**80 tests**, cumulative **~512**.
+
+---
+
+## Testing strategy
+
+Three tiers, each preserving a distinct guarantee:
+
+1. **Regression — `test/index.js` (190 tests).** The v10.x contract. Only ever extended, never deleted. A new v11 implementation is considered correct only if every one of these passes unchanged.
+2. **Spec — `test/v11-*.test.ts`.** One file per feature cluster. Every test has a `// §10.x` comment citing the spec paragraph it exercises. This makes correctness reviewable section-by-section.
+3. **Conformance — `test/wpt/*.test.ts`.** Cribbed from [web-platform-tests `css/css-values/`](https://github.com/web-platform-tests/wpt/tree/master/css/css-values) for each version's scope. Test names mirror upstream so drift is detectable. Keeps us honest about cross-implementation interop.
+
+All tiers run under `pnpm test` via `node --test` (and `tsx` for the TS suites).
+
+## Running test-count totals
+
+| Version | New tests (est.) | Cumulative |
+|---|---|---|
+| baseline | 190 | 190 |
+| v11.0 | ~95 | ~285 |
+| v11.1 | ~67 | ~352 |
+| v11.2 | ~80 | ~432 |
+| v11.3 | ~80 | ~512 |
+
+Counts are forecasts, not commitments — they guide scope, not effort estimates.
+
+## Open questions to resolve before v11.0
+
+- **Strict whitespace around `+`/`-`.** Spec requires it; current plugin is permissive. Leaning strict, with a `strict: false` escape hatch for legacy inputs.
+- **Output-format opt-out.** Do we add `spec: 'css-values-4'` (default true) so projects that pattern-match on current serialization can stay on the old format for one major? Probably yes at low cost.
+- **Deprecation of `mediaQueries` / `selectors` options.** Carry forward unchanged — no reason to remove.
+
+## What will NOT change in v11
+
+- Plugin name, export, and `pluginCreator.postcss = true`.
+- Options surface (`precision`, `preserve`, `warnWhenCannotResolve`, `mediaQueries`, `selectors`).
+- `peerDependencies` on `postcss ^8`.
+- Semver: v11 means internal-breaking + output-difference in edge cases (typed division, degenerate numerics). No API-breaking changes for normal consumers.
diff --git a/package.json b/package.json
index f8d8e5c..ba031a5 100644
--- a/package.json
+++ b/package.json
@@ -24,8 +24,9 @@
   "scripts": {
     "prepare": "pnpm run build && tsc",
     "build": "jison ./parser.jison -o src/parser.js",
-    "lint": "eslint . && tsc",
-    "test": "node --test"
+    "lint": "eslint . && tsc && tsc -p playground/pratt",
+    "test": "node --test",
+    "test:pratt": "node --import tsx --test playground/pratt/test.ts playground/pratt/test-tokenizer.ts playground/pratt/test-simplify.ts playground/pratt/test-typed.ts playground/pratt/test-opaque.ts playground/pratt/test-serialize.ts playground/pratt/test-wpt.ts"
   },
   "author": "Andy Jansson",
   "license": "MIT",
@@ -39,6 +40,7 @@
     "jison-gho": "0.6.1-216",
     "postcss": "^8.5.3",
     "prettier": "^3.5.3",
+    "tsx": "^4.21.0",
     "typescript": "~5.8.3"
   },
   "dependencies": {
diff --git a/playground/pratt/evaluator.ts b/playground/pratt/evaluator.ts
new file mode 100644
index 0000000..f1ee6a6
--- /dev/null
+++ b/playground/pratt/evaluator.ts
@@ -0,0 +1,105 @@
+import type { Node } from './parser.ts';
+
+export type Func = (...args: number[]) => number;
+
+export const defaultFuncs: Record<string, Func> = {
+  // Comparison
+  min: Math.min,
+  max: Math.max,
+  clamp: (lo, v, hi) => Math.min(Math.max(v, lo), hi),
+
+  // Sign / absolute value
+  abs: Math.abs,
+  sign: Math.sign,
+
+  // Exponential
+  pow: Math.pow,
+  sqrt: Math.sqrt,
+  hypot: Math.hypot,
+  log: Math.log,
+  exp: Math.exp,
+
+  // Trig (radians)
+  sin: Math.sin,
+  cos: Math.cos,
+  tan: Math.tan,
+  asin: Math.asin,
+  acos: Math.acos,
+  atan: Math.atan,
+  atan2: Math.atan2,
+
+  // Stepped value
+  round: Math.round,
+  floor: Math.floor,
+  ceil: Math.ceil,
+  trunc: Math.trunc,
+  // Floor-mod (result sign follows divisor); `rem` uses JS `%` (sign follows dividend).
+  mod: (a, b) => ((a % b) + b) % b,
+  rem: (a, b) => a % b,
+};
+
+export const defaultConsts: Record<string, number> = {
+  pi: Math.PI,
+  e: Math.E,
+  infinity: Infinity,
+};
+
+export interface EvalContext {
+  funcs?: Record<string, Func>;
+  consts?: Record<string, number>;
+}
+
+export function evaluate(node: Node, ctx: EvalContext = {}): number {
+  const funcs = ctx.funcs ?? defaultFuncs;
+  const consts = ctx.consts ?? defaultConsts;
+
+  switch (node.type) {
+    case 'Num':
+      return node.value;
+
+    case 'Dim':
+      throw new Error(
+        `Cannot evaluate dimension ${node.value}${node.unit} as a plain number`
+      );
+
+    case 'Ident': {
+      const v = consts[node.name.toLowerCase()];
+      if (v === undefined) {
+        throw new Error(`Unknown identifier "${node.name}"`);
+      }
+      return v;
+    }
+
+    case 'Unary': {
+      const v = evaluate(node.arg, { funcs, consts });
+      return node.op === '-' ? -v : +v;
+    }
+
+    case 'Binary': {
+      const l = evaluate(node.left, { funcs, consts });
+      const r = evaluate(node.right, { funcs, consts });
+      switch (node.op) {
+        case '+':
+          return l + r;
+        case '-':
+          return l - r;
+        case '*':
+          return l * r;
+        case '/':
+          if (r === 0) {
+            throw new Error('Division by zero');
+          }
+          return l / r;
+      }
+    }
+
+    case 'Call': {
+      const fn = funcs[node.name.toLowerCase()];
+      if (!fn) {
+        throw new Error(`Unknown function "${node.name}"`);
+      }
+      const args = node.args.map((a) => evaluate(a, { funcs, consts }));
+      return fn(...args);
+    }
+  }
+}
diff --git a/playground/pratt/parser.ts b/playground/pratt/parser.ts
new file mode 100644
index 0000000..a6e698b
--- /dev/null
+++ b/playground/pratt/parser.ts
@@ -0,0 +1,199 @@
+// Spec: https://www.w3.org/TR/css-values-4/#calc-syntax
+//
+// Pratt parser. Operator behavior lives in two registries keyed by token:
+//   - prefix: how a token starts an expression (literal, unary op, grouping, call)
+//   - infix:  how a token continues an expression once we have a left operand
+//
+// Adding a new operator or literal is a single entry in one of these maps,
+// so the parser core never needs to change as the language grows.
+
+import type { Token, TokenType } from './tokenizer.ts';
+
+export type Node =
+  | { type: 'Num'; value: number }
+  | { type: 'Dim'; value: number; unit: string }
+  | { type: 'Ident'; name: string }
+  | { type: 'Unary'; op: '+' | '-'; arg: Node }
+  | { type: 'Binary'; op: '+' | '-' | '*' | '/'; left: Node; right: Node }
+  | { type: 'Call'; name: string; args: Node[] };
+
+export type PrefixParselet = (p: Parser, token: Token) => Node;
+
+export interface InfixParselet {
+  lbp: number;
+  parse: (p: Parser, left: Node, token: Token) => Node;
+}
+
+/** Spec §10.9 — case-insensitive except for NaN. */
+function foldCalcKeyword(name: string): Node | null {
+  if (name === 'NaN') {
+    return { type: 'Num', value: NaN };
+  }
+  switch (name.toLowerCase()) {
+    case 'pi':
+      return { type: 'Num', value: Math.PI };
+    case 'e':
+      return { type: 'Num', value: Math.E };
+    case 'infinity':
+      return { type: 'Num', value: Infinity };
+  }
+  return null;
+}
+
+export class Parser {
+  private i = 0;
+
+  constructor(
+    private readonly tokens: Token[],
+    readonly prefix: Record<string, PrefixParselet>,
+    readonly infix: Record<string, InfixParselet>
+  ) {}
+
+  peek(): Token {
+    return this.tokens[this.i]!;
+  }
+
+  next(): Token {
+    return this.tokens[this.i++]!;
+  }
+
+  expect(type: TokenType, value?: string): Token {
+    const t = this.next();
+    if (t.type !== type || (value !== undefined && t.value !== value)) {
+      const want = value ?? type;
+      throw new Error(
+        `Expected ${want} at position ${t.pos}, got "${t.value}"`
+      );
+    }
+    return t;
+  }
+
+  parseExpr(minBp = 0): Node {
+    const t = this.next();
+    const key = t.type === 'punct' ? t.value : t.type;
+    const prefix = this.prefix[key];
+    if (!prefix) {
+      throw new Error(`Unexpected token "${t.value}" at position ${t.pos}`);
+    }
+    let left = prefix(this, t);
+
+    while (true) {
+      const nxt = this.peek();
+      const infixKey = nxt.type === 'punct' ? nxt.value : nxt.type;
+      const rule = this.infix[infixKey];
+      if (!rule || rule.lbp < minBp) {
+        break;
+      }
+      this.next();
+      left = rule.parse(this, left, nxt);
+    }
+
+    return left;
+  }
+}
+
+export function binaryLeft(
+  op: '+' | '-' | '*' | '/',
+  bp: number
+): InfixParselet {
+  return {
+    lbp: bp,
+    parse: (p, left) => ({
+      type: 'Binary',
+      op,
+      left,
+      right: p.parseExpr(bp + 1),
+    }),
+  };
+}
+
+export function binaryRight(op: string, bp: number): InfixParselet {
+  return {
+    lbp: bp,
+    parse: (p, left) => ({
+      type: 'Binary',
+      op: op as '+' | '-' | '*' | '/',
+      left,
+      right: p.parseExpr(bp),
+    }),
+  };
+}
+
+export function defaultPrefix(): Record<string, PrefixParselet> {
+  return {
+    number: (_p, t) => ({ type: 'Num', value: parseFloat(t.value) }),
+
+    // Unit case is normalized at parse time per §10.12: `1PX` serializes
+    // as `1px`. Leaving `%` alone since it has no case variants.
+    dimension: (_p, t) => ({
+      type: 'Dim',
+      value: parseFloat(t.value),
+      unit: t.unit === '%' ? '%' : t.unit!.toLowerCase(),
+    }),
+
+    ident: (p, t) => {
+      const nxt = p.peek();
+      if (nxt.type === 'punct' && nxt.value === '(') {
+        p.next();
+        const args: Node[] = [];
+        const closes = (): boolean => {
+          const n = p.peek();
+          return n.type === 'punct' && n.value === ')';
+        };
+        if (!closes()) {
+          args.push(p.parseExpr(0));
+          while (p.peek().type === 'punct' && p.peek().value === ',') {
+            p.next();
+            args.push(p.parseExpr(0));
+          }
+        }
+        p.expect('punct', ')');
+        return { type: 'Call', name: t.value, args };
+      }
+      // Bare identifier: fold calc-keywords (pi, e, infinity, NaN) to numbers.
+      // Anything else stays as an Ident leaf (opaque to simplification).
+      const kw = foldCalcKeyword(t.value);
+      if (kw) {
+        return kw;
+      }
+      return { type: 'Ident', name: t.value };
+    },
+
+    '(': (p) => {
+      const e = p.parseExpr(0);
+      p.expect('punct', ')');
+      return e;
+    },
+
+    '-': (p) => ({ type: 'Unary', op: '-', arg: p.parseExpr(7) }),
+    '+': (p) => ({ type: 'Unary', op: '+', arg: p.parseExpr(7) }),
+  };
+}
+
+export function defaultInfix(): Record<string, InfixParselet> {
+  return {
+    '+': binaryLeft('+', 1),
+    '-': binaryLeft('-', 1),
+    '*': binaryLeft('*', 3),
+    '/': binaryLeft('/', 3),
+  };
+}
+
+export interface ParseOptions {
+  prefix?: Record<string, PrefixParselet>;
+  infix?: Record<string, InfixParselet>;
+}
+
+export function parse(tokens: Token[], opts: ParseOptions = {}): Node {
+  const prefix = opts.prefix ?? defaultPrefix();
+  const infix = opts.infix ?? defaultInfix();
+  const p = new Parser(tokens, prefix, infix);
+  const ast = p.parseExpr(0);
+  const trailing = p.peek();
+  if (trailing.type !== 'eof') {
+    throw new Error(
+      `Unexpected token "${trailing.value}" at position ${trailing.pos}`
+    );
+  }
+  return ast;
+}
diff --git a/playground/pratt/serialize.ts b/playground/pratt/serialize.ts
new file mode 100644
index 0000000..485c348
--- /dev/null
+++ b/playground/pratt/serialize.ts
@@ -0,0 +1,112 @@
+// Spec: https://www.w3.org/TR/css-values-4/#serialize-a-calculation-tree
+//
+// Render a simplified AST back to CSS text. Rules:
+//   - `+` and `-` require whitespace on both sides (required by the grammar,
+//     not stylistic).
+//   - `*` and `/` may be rendered without whitespace.
+//   - Left-associative precedence climbing decides when parens are needed.
+//   - Outer `calc()` is added only when the result isn't already a single
+//     value or self-wrapping call (min/max/clamp/var/…).
+
+import type { Node } from './parser.ts';
+
+export interface SerializeOptions {
+  /** Decimal places for numbers. `false` disables rounding. Default 5. */
+  precision?: number | false;
+  /** The wrapper name to use when a `calc()` is needed. Default `'calc'`. */
+  calcName?: string;
+}
+
+function round(v: number, prec: number | false): number {
+  if (prec === false) {
+    return v;
+  }
+  const m = Math.pow(10, prec);
+  return Math.round(v * m) / m;
+}
+
+/** Operator precedence for parenthesization decisions. */
+function precOf(op: '+' | '-' | '*' | '/'): 1 | 3 {
+  return op === '+' || op === '-' ? 1 : 3;
+}
+
+function serializeExpr(node: Node, prec: number | false): string {
+  switch (node.type) {
+    case 'Num':
+      return String(round(node.value, prec));
+
+    case 'Dim':
+      return `${round(node.value, prec)}${node.unit}`;
+
+    case 'Ident':
+      return node.name;
+
+    case 'Unary': {
+      const inner = serializeExpr(node.arg, prec);
+      // A unary in front of a sum needs parens to keep meaning:
+      // `-(a + b)` must not serialize as `-a + b`.
+      if (
+        node.arg.type === 'Binary' &&
+        (node.arg.op === '+' || node.arg.op === '-')
+      ) {
+        return `${node.op}(${inner})`;
+      }
+      return `${node.op}${inner}`;
+    }
+
+    case 'Binary': {
+      const myPrec = precOf(node.op);
+
+      let leftStr = serializeExpr(node.left, prec);
+      if (
+        node.left.type === 'Binary' &&
+        precOf(node.left.op) < myPrec
+      ) {
+        leftStr = `(${leftStr})`;
+      }
+
+      let rightStr = serializeExpr(node.right, prec);
+      // Right side needs parens if its precedence is lower, OR equal with a
+      // non-associative-from-the-right op (`-` and `/`): `a - (b - c)` must
+      // keep the inner parens.
+      if (node.right.type === 'Binary') {
+        const rp = precOf(node.right.op);
+        if (
+          rp < myPrec ||
+          (rp === myPrec && (node.op === '-' || node.op === '/'))
+        ) {
+          rightStr = `(${rightStr})`;
+        }
+      }
+
+      return myPrec === 1
+        ? `${leftStr} ${node.op} ${rightStr}`
+        : `${leftStr}${node.op}${rightStr}`;
+    }
+
+    case 'Call': {
+      const args = node.args.map((a) => serializeExpr(a, prec)).join(', ');
+      return `${node.name}(${args})`;
+    }
+  }
+}
+
+/**
+ * Serialize a full calc() expression, adding the outer wrapper only when
+ * needed (single values and self-wrapping calls don't get wrapped).
+ */
+export function serialize(node: Node, opts: SerializeOptions = {}): string {
+  const prec = opts.precision ?? 5;
+  const calcName = opts.calcName ?? 'calc';
+  const inner = serializeExpr(node, prec);
+
+  if (
+    node.type === 'Num' ||
+    node.type === 'Dim' ||
+    node.type === 'Ident' ||
+    node.type === 'Call'
+  ) {
+    return inner;
+  }
+  return `${calcName}(${inner})`;
+}
diff --git a/playground/pratt/sexpr.ts b/playground/pratt/sexpr.ts
new file mode 100644
index 0000000..880ed89
--- /dev/null
+++ b/playground/pratt/sexpr.ts
@@ -0,0 +1,24 @@
+import type { Node } from './parser.ts';
+
+/**
+ * Render an AST as an S-expression for snapshot assertions.
+ * Makes precedence and associativity bugs obvious at a glance.
+ */
+export function sexpr(node: Node): string {
+  switch (node.type) {
+    case 'Num':
+      return String(node.value);
+    case 'Dim':
+      return `${node.value}${node.unit}`;
+    case 'Ident':
+      return node.name;
+    case 'Unary':
+      return `(${node.op} ${sexpr(node.arg)})`;
+    case 'Binary':
+      return `(${node.op} ${sexpr(node.left)} ${sexpr(node.right)})`;
+    case 'Call':
+      return node.args.length === 0
+        ? `(${node.name})`
+        : `(${node.name} ${node.args.map(sexpr).join(' ')})`;
+  }
+}
diff --git a/playground/pratt/simplify.ts b/playground/pratt/simplify.ts
new file mode 100644
index 0000000..59d30ac
--- /dev/null
+++ b/playground/pratt/simplify.ts
@@ -0,0 +1,418 @@
+// Spec: https://www.w3.org/TR/css-values-4/#calc-simplification
+//
+// Post-order simplification. Transcribes the v11.0 subset of §10.10:
+//   - flatten nested calc()
+//   - combine like-typed terms in a sum, with unit conversion
+//   - fold products/divisions with resolvable operands (incl. typed division)
+//   - reduce min() / max() / clamp() when all args resolve to one type
+//   - preserve opaque leaves (var(), env(), attr(), unknown functions)
+//
+// What the subset does NOT do yet (deferred to v11.1+):
+//   - round / mod / rem / abs / sign
+//   - trig family
+//   - pow / sqrt / hypot / log / exp
+//   - degenerate-numeric serialization (infinity / NaN as calc(inf * 1px))
+
+import type { Node } from './parser.ts';
+import { baseOf, type BaseType } from './type.ts';
+
+// Unit conversion: factor to canonical unit within each base type.
+// Relative units (em, rem, vw, etc.) are deliberately absent — they are
+// not statically convertible, so same-base mixes with them stay unfolded.
+const TO_CANONICAL: Record<string, number> = {
+  // length (canonical: px)
+  px: 1,
+  cm: 96 / 2.54,
+  mm: 96 / 25.4,
+  q: 96 / 101.6,
+  in: 96,
+  pt: 96 / 72,
+  pc: 16,
+  // angle (canonical: deg)
+  deg: 1,
+  grad: 0.9,
+  rad: 180 / Math.PI,
+  turn: 360,
+  // time (canonical: s)
+  s: 1,
+  ms: 0.001,
+  // frequency (canonical: hz)
+  hz: 1,
+  khz: 1000,
+  // resolution (canonical: dppx)
+  dppx: 1,
+  dpi: 1 / 96,
+  dpcm: 2.54 / 96,
+  x: 1,
+  // flex / percentage: identity (only combinable with same unit)
+  fr: 1,
+  '%': 1,
+};
+
+function convert(value: number, from: string, to: string): number | null {
+  if (from.toLowerCase() === to.toLowerCase()) {
+    return value;
+  }
+  const f = TO_CANONICAL[from.toLowerCase()];
+  const t = TO_CANONICAL[to.toLowerCase()];
+  if (f === undefined || t === undefined) {
+    return null;
+  }
+  return (value * f) / t;
+}
+
+const MATH_FNS = new Set([
+  'calc',
+  '-webkit-calc',
+  '-moz-calc',
+  'min',
+  'max',
+  'clamp',
+]);
+
+function isMathFn(name: string): boolean {
+  return MATH_FNS.has(name.toLowerCase());
+}
+
+function num(value: number): Node {
+  return { type: 'Num', value };
+}
+
+function dim(value: number, unit: string): Node {
+  return { type: 'Dim', value, unit };
+}
+
+/** Main entry. */
+export function simplify(node: Node): Node {
+  switch (node.type) {
+    case 'Num':
+    case 'Dim':
+    case 'Ident':
+      return node;
+
+    case 'Unary': {
+      const arg = simplify(node.arg);
+      if (node.op === '+') {
+        return arg;
+      }
+      if (arg.type === 'Num') {
+        return num(-arg.value);
+      }
+      if (arg.type === 'Dim') {
+        return dim(-arg.value, arg.unit);
+      }
+      return { type: 'Unary', op: '-', arg };
+    }
+
+    case 'Call':
+      return simplifyCall(node);
+
+    case 'Binary':
+      return simplifyBinary(node);
+  }
+}
+
+function simplifyCall(
+  node: Extract<Node, { type: 'Call' }>
+): Node {
+  const name = node.name.toLowerCase();
+
+  // calc() wrapper: unwrap, simplify contents.
+  if (name === 'calc' || name === '-webkit-calc' || name === '-moz-calc') {
+    if (node.args.length !== 1) {
+      throw new Error(`${node.name}() takes exactly one argument`);
+    }
+    return simplify(node.args[0]!);
+  }
+
+  if (name === 'min' || name === 'max') {
+    return simplifyMinMax(node.name, node.args);
+  }
+
+  if (name === 'clamp') {
+    return simplifyClamp(node.args);
+  }
+
+  // Opaque call (var, env, attr, or anything we don't reduce yet). Simplify
+  // args so nested calc() still folds, but preserve the call itself.
+  return { type: 'Call', name: node.name, args: node.args.map(simplify) };
+}
+
+function simplifyBinary(
+  node: Extract<Node, { type: 'Binary' }>
+): Node {
+  if (node.op === '+' || node.op === '-') {
+    const terms: { sign: 1 | -1; node: Node }[] = [];
+    flattenSum(node, 1, terms);
+    return combineSum(terms);
+  }
+
+  const left = simplify(node.left);
+  const right = simplify(node.right);
+
+  if (node.op === '*') {
+    return simplifyMul(left, right);
+  }
+  return simplifyDiv(left, right);
+}
+
+function flattenSum(
+  node: Node,
+  sign: 1 | -1,
+  out: { sign: 1 | -1; node: Node }[]
+): void {
+  if (node.type === 'Binary' && (node.op === '+' || node.op === '-')) {
+    flattenSum(node.left, sign, out);
+    const rightSign = node.op === '+' ? sign : ((sign * -1) as 1 | -1);
+    flattenSum(node.right, rightSign, out);
+    return;
+  }
+  if (node.type === 'Unary' && node.op === '-') {
+    flattenSum(node.arg, (sign * -1) as 1 | -1, out);
+    return;
+  }
+  if (node.type === 'Unary' && node.op === '+') {
+    flattenSum(node.arg, sign, out);
+    return;
+  }
+  out.push({ sign, node });
+}
+
+function combineSum(
+  rawTerms: { sign: 1 | -1; node: Node }[]
+): Node {
+  const terms = rawTerms.map((t) => ({ sign: t.sign, node: simplify(t.node) }));
+
+  let numTotal = 0;
+  let hasNum = false;
+  const dimBuckets = new Map<BaseType, { unit: string; total: number }>();
+  const opaque: { sign: 1 | -1; node: Node }[] = [];
+
+  for (const t of terms) {
+    const n = t.node;
+    if (n.type === 'Num') {
+      numTotal += t.sign * n.value;
+      hasNum = true;
+      continue;
+    }
+    if (n.type === 'Dim') {
+      const base = baseOf(n.unit);
+      if (!base) {
+        opaque.push(t);
+        continue;
+      }
+      const bucket = dimBuckets.get(base);
+      if (!bucket) {
+        dimBuckets.set(base, { unit: n.unit, total: t.sign * n.value });
+        continue;
+      }
+      const converted = convert(n.value, n.unit, bucket.unit);
+      if (converted === null) {
+        // Same base type but unconvertible (e.g. mixing em with px): keep
+        // this term as a separate summand so it survives to serialization.
+        opaque.push(t);
+        continue;
+      }
+      bucket.total += t.sign * converted;
+      continue;
+    }
+    opaque.push(t);
+  }
+
+  // Note on type-checking: the spec flags mixes like `calc(1px + 1s)` as
+  // invalid, but a PostCSS transform can't know the property context that
+  // decides whether `%` combines with `<length>` (the percent-hint in §10.2).
+  // So we stay permissive: terms that don't combine remain separate
+  // summands in the output, matching v10's behavior. Strict mode is a
+  // candidate for a later opt-in option.
+
+  const folded: { sign: 1 | -1; node: Node }[] = [];
+  if (hasNum && (numTotal !== 0 || dimBuckets.size + opaque.length === 0)) {
+    folded.push(signed(num(numTotal)));
+  }
+  for (const bucket of dimBuckets.values()) {
+    if (bucket.total !== 0 || folded.length + opaque.length === 0) {
+      folded.push(signed(dim(bucket.total, bucket.unit)));
+    }
+  }
+
+  const summands = [...folded, ...opaque];
+  if (summands.length === 0) {
+    return num(0);
+  }
+  return buildSumTree(summands);
+}
+
+function signed(n: Node): { sign: 1 | -1; node: Node } {
+  if (n.type === 'Num' && n.value < 0) {
+    return { sign: -1, node: num(-n.value) };
+  }
+  if (n.type === 'Dim' && n.value < 0) {
+    return { sign: -1, node: dim(-n.value, n.unit) };
+  }
+  return { sign: 1, node: n };
+}
+
+function buildSumTree(
+  summands: { sign: 1 | -1; node: Node }[]
+): Node {
+  const head = summands[0]!;
+  // Collapse a leading negative numeric head into a signed value rather
+  // than a Unary node — this keeps a single-summand result as a plain
+  // `-4ex` (Dim) instead of `calc(-4ex)` (Unary forces the outer wrap).
+  let tree: Node;
+  if (head.sign === -1) {
+    if (head.node.type === 'Num') {
+      tree = num(-head.node.value);
+    } else if (head.node.type === 'Dim') {
+      tree = dim(-head.node.value, head.node.unit);
+    } else {
+      tree = { type: 'Unary', op: '-', arg: head.node };
+    }
+  } else {
+    tree = head.node;
+  }
+
+  for (let i = 1; i < summands.length; i++) {
+    const s = summands[i]!;
+    tree = {
+      type: 'Binary',
+      op: s.sign === 1 ? '+' : '-',
+      left: tree,
+      right: s.node,
+    };
+  }
+  return tree;
+}
+
+function simplifyMul(left: Node, right: Node): Node {
+  if (left.type === 'Num' && right.type === 'Num') {
+    return num(left.value * right.value);
+  }
+  if (left.type === 'Num' && right.type === 'Dim') {
+    return dim(left.value * right.value, right.unit);
+  }
+  if (left.type === 'Dim' && right.type === 'Num') {
+    return dim(left.value * right.value, left.unit);
+  }
+  // Dim * Dim, or one side opaque: preserve.
+  return { type: 'Binary', op: '*', left, right };
+}
+
+function simplifyDiv(left: Node, right: Node): Node {
+  if (right.type === 'Num') {
+    if (right.value === 0) {
+      throw new Error('Division by zero');
+    }
+    if (left.type === 'Num') {
+      return num(left.value / right.value);
+    }
+    if (left.type === 'Dim') {
+      return dim(left.value / right.value, left.unit);
+    }
+  }
+  // Typed division: <T> / <T> → <number> (§10.2).
+  if (left.type === 'Dim' && right.type === 'Dim') {
+    const lb = baseOf(left.unit);
+    const rb = baseOf(right.unit);
+    if (lb && rb && lb === rb) {
+      const lc = convert(left.value, left.unit, right.unit);
+      if (lc !== null) {
+        if (right.value === 0) {
+          throw new Error('Division by zero');
+        }
+        return num(lc / right.value);
+      }
+    }
+  }
+  return { type: 'Binary', op: '/', left, right };
+}
+
+function simplifyMinMax(originalName: string, rawArgs: Node[]): Node {
+  const args = rawArgs.map(simplify);
+  const fold = foldConstArgs(args);
+  if (fold !== null) {
+    const fn = originalName.toLowerCase() === 'min' ? Math.min : Math.max;
+    const value = fn(...fold.values);
+    return fold.unit === '' ? num(value) : dim(value, fold.unit);
+  }
+  return { type: 'Call', name: originalName, args };
+}
+
+function simplifyClamp(rawArgs: Node[]): Node {
+  const args = rawArgs.map(simplify);
+  if (args.length === 3) {
+    const fold = foldConstArgs(args);
+    if (fold !== null) {
+      const [lo, v, hi] = fold.values as [number, number, number];
+      const clamped = Math.min(Math.max(v, lo), hi);
+      return fold.unit === '' ? num(clamped) : dim(clamped, fold.unit);
+    }
+  }
+  return { type: 'Call', name: 'clamp', args };
+}
+
+/**
+ * If every arg resolves to the same type (all numbers, or all dimensions of
+ * one base type convertible to a common unit), return the values in that
+ * common unit. Otherwise return null (caller preserves the call).
+ *
+ * Percentages are deliberately never folded: in property contexts that
+ * resolve percentages against a negative value, ordering flips (20% can be
+ * less than 10%), so `min(1%, 2%)` can't be simplified without property-
+ * context information we don't have. Chrome makes the same choice — see
+ * WPT minmax-percentage-serialize.html.
+ */
+function foldConstArgs(
+  args: Node[]
+): { values: number[]; unit: string } | null {
+  if (args.length === 0) {
+    return null;
+  }
+  let mode: 'number' | 'dim' | null = null;
+  let unit = '';
+  let base: BaseType | null = null;
+  const values: number[] = [];
+
+  for (const a of args) {
+    if (a.type === 'Num') {
+      if (mode === null) {
+        mode = 'number';
+      } else if (mode !== 'number') {
+        return null;
+      }
+      values.push(a.value);
+      continue;
+    }
+    if (a.type === 'Dim') {
+      // Percentages can't be folded when there's more than one arg to
+      // compare — ordering depends on the property's resolution context.
+      // A single-arg min/max/clamp has no comparison and folds safely.
+      if (a.unit === '%' && args.length > 1) {
+        return null;
+      }
+      const b = baseOf(a.unit);
+      if (!b) {
+        return null;
+      }
+      if (mode === null) {
+        mode = 'dim';
+        unit = a.unit;
+        base = b;
+        values.push(a.value);
+        continue;
+      }
+      if (mode !== 'dim' || base !== b) {
+        return null;
+      }
+      const converted = convert(a.value, a.unit, unit);
+      if (converted === null) {
+        return null;
+      }
+      values.push(converted);
+      continue;
+    }
+    return null;
+  }
+  return { values, unit: mode === 'number' ? '' : unit };
+}
diff --git a/playground/pratt/test-opaque.ts b/playground/pratt/test-opaque.ts
new file mode 100644
index 0000000..306cff5
--- /dev/null
+++ b/playground/pratt/test-opaque.ts
@@ -0,0 +1,104 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { tokenize } from './tokenizer.ts';
+import { parse } from './parser.ts';
+import { simplify } from './simplify.ts';
+import { serialize } from './serialize.ts';
+
+const out = (input: string): string =>
+  serialize(simplify(parse(tokenize(input))));
+
+// Opaque leaves: var(), env(), attr(), and unknown functions. Simplification
+// flows around them; resolvable neighbors still combine.
+
+test('opaque: var() passes through', () => {
+  assert.equal(out('calc(var(--x))'), 'var(--x)');
+});
+
+test('opaque: var() with a fallback', () => {
+  assert.equal(out('calc(var(--x, 10px))'), 'var(--x, 10px)');
+});
+
+test('opaque: var() nested inside a calc() with combinable neighbors', () => {
+  assert.equal(
+    out('calc(1px + var(--x) + 2px)'),
+    'calc(3px + var(--x))'
+  );
+});
+
+test('opaque: same-unit terms fold, opaque preserved on the right', () => {
+  assert.equal(
+    out('calc(10px - 3px + var(--x))'),
+    'calc(7px + var(--x))'
+  );
+});
+
+test('opaque: subtraction of opaque preserved', () => {
+  assert.equal(
+    out('calc(10px - var(--x))'),
+    'calc(10px - var(--x))'
+  );
+});
+
+// §10.12 serialization: resolvable terms come first, opaque after.
+
+test('opaque: env() passes through', () => {
+  assert.equal(
+    out('calc(env(safe-area-inset-top) + 10px)'),
+    'calc(10px + env(safe-area-inset-top))'
+  );
+});
+
+test('opaque: attr() passes through', () => {
+  assert.equal(
+    out('calc(attr(data-x) + 1px)'),
+    'calc(1px + attr(data-x))'
+  );
+});
+
+test('opaque: unknown function passes through', () => {
+  assert.equal(
+    out('calc(some-future-fn(1, 2) + 10px)'),
+    'calc(10px + some-future-fn(1, 2))'
+  );
+});
+
+test('opaque: combinable terms on both sides of opaque', () => {
+  assert.equal(
+    out('calc(1px + 2px + var(--x) + 3px + 4px)'),
+    'calc(10px + var(--x))'
+  );
+});
+
+test('opaque: sub-calc inside var() fallback simplifies', () => {
+  assert.equal(
+    out('calc(var(--x, calc(1px + 2px)))'),
+    'var(--x, 3px)'
+  );
+});
+
+test('opaque: min() preserved if any arg is opaque', () => {
+  assert.equal(out('min(var(--x), 10px)'), 'min(var(--x), 10px)');
+});
+
+test('opaque: unknown unit on a dimension treated as opaque', () => {
+  // 1foo has an unknown unit — it sits next to 1px as two incompatible
+  // summands rather than being folded.
+  assert.equal(out('calc(1foo + 1px)'), 'calc(1px + 1foo)');
+});
+
+test('opaque: multiplication with opaque preserved', () => {
+  assert.equal(out('calc(2 * var(--x))'), 'calc(2*var(--x))');
+});
+
+test('opaque: cancelled resolvables leave just the opaque term', () => {
+  assert.equal(out('calc(1px - 1px + var(--x))'), 'var(--x)');
+});
+
+test('opaque: subtraction-only opaque is wrapped in a unary minus', () => {
+  // `calc(-var(--x))` is a real edge case — opaque as the only term with a
+  // negative sign must become `calc(-1 * var(--x))` or similar to stay valid.
+  // We emit a Unary(-) which serializes as `-var(--x)`.
+  assert.equal(out('calc(0px - var(--x))'), 'calc(-var(--x))');
+});
diff --git a/playground/pratt/test-serialize.ts b/playground/pratt/test-serialize.ts
new file mode 100644
index 0000000..4b2f02b
--- /dev/null
+++ b/playground/pratt/test-serialize.ts
@@ -0,0 +1,115 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { serialize } from './serialize.ts';
+import type { Node } from './parser.ts';
+
+// Direct serialize() tests — build AST nodes by hand to pin output shape
+// without depending on the parser/simplify.
+
+const num = (v: number): Node => ({ type: 'Num', value: v });
+const dim = (v: number, u: string): Node => ({ type: 'Dim', value: v, unit: u });
+
+test('serialize: single number — no calc wrapper', () => {
+  assert.equal(serialize(num(42)), '42');
+});
+
+test('serialize: single dimension — no calc wrapper', () => {
+  assert.equal(serialize(dim(10, 'px')), '10px');
+});
+
+test('serialize: sum wrapped in calc(), spaces around +/-', () => {
+  const ast: Node = {
+    type: 'Binary',
+    op: '+',
+    left: dim(1, 'px'),
+    right: dim(2, 'px'),
+  };
+  assert.equal(serialize(ast), 'calc(1px + 2px)');
+});
+
+test('serialize: product has no spaces around * or /', () => {
+  const ast: Node = {
+    type: 'Binary',
+    op: '*',
+    left: num(2),
+    right: dim(3, 'px'),
+  };
+  assert.equal(serialize(ast), 'calc(2*3px)');
+});
+
+test('serialize: self-wrapping call — no extra calc()', () => {
+  const ast: Node = {
+    type: 'Call',
+    name: 'min',
+    args: [dim(1, 'px'), dim(2, 'px')],
+  };
+  assert.equal(serialize(ast), 'min(1px, 2px)');
+});
+
+test('serialize: var() call', () => {
+  const ast: Node = {
+    type: 'Call',
+    name: 'var',
+    args: [{ type: 'Ident', name: '--x' }],
+  };
+  assert.equal(serialize(ast), 'var(--x)');
+});
+
+test('serialize: parens inserted when precedence demands it', () => {
+  // (1 + 2) * 3 — must keep inner parens
+  const ast: Node = {
+    type: 'Binary',
+    op: '*',
+    left: { type: 'Binary', op: '+', left: num(1), right: num(2) },
+    right: num(3),
+  };
+  assert.equal(serialize(ast), 'calc((1 + 2)*3)');
+});
+
+test('serialize: right-side parens for a - (b - c)', () => {
+  const ast: Node = {
+    type: 'Binary',
+    op: '-',
+    left: num(1),
+    right: { type: 'Binary', op: '-', left: num(2), right: num(3) },
+  };
+  assert.equal(serialize(ast), 'calc(1 - (2 - 3))');
+});
+
+test('serialize: unary minus on a sum gets parens', () => {
+  const ast: Node = {
+    type: 'Unary',
+    op: '-',
+    arg: { type: 'Binary', op: '+', left: dim(1, 'px'), right: dim(2, 'px') },
+  };
+  assert.equal(serialize(ast), 'calc(-(1px + 2px))');
+});
+
+test('serialize: precision option applied to numbers and dimensions', () => {
+  assert.equal(
+    serialize(dim(1.123456789, 'px'), { precision: 2 }),
+    '1.12px'
+  );
+  assert.equal(serialize(num(1.123456789), { precision: 0 }), '1');
+});
+
+test('serialize: precision false keeps full value', () => {
+  assert.equal(
+    serialize(dim(1.123456789, 'px'), { precision: false }),
+    '1.123456789px'
+  );
+});
+
+test('serialize: custom calcName (e.g. for preserving a -webkit- variant)', () => {
+  const ast: Node = {
+    type: 'Binary',
+    op: '+',
+    left: dim(1, 'px'),
+    right: dim(2, 'px'),
+  };
+  assert.equal(
+    serialize(ast, { calcName: '-webkit-calc' }),
+    '-webkit-calc(1px + 2px)'
+  );
+});
diff --git a/playground/pratt/test-simplify.ts b/playground/pratt/test-simplify.ts
new file mode 100644
index 0000000..094555e
--- /dev/null
+++ b/playground/pratt/test-simplify.ts
@@ -0,0 +1,142 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { tokenize } from './tokenizer.ts';
+import { parse } from './parser.ts';
+import { simplify } from './simplify.ts';
+import { serialize } from './serialize.ts';
+
+const out = (input: string): string =>
+  serialize(simplify(parse(tokenize(input))));
+
+// --- calc() flattening (§10.10) -------------------------------------------
+
+test('simplify: bare calc() unwraps to its single value', () => {
+  assert.equal(out('calc(42px)'), '42px');
+});
+
+test('simplify: nested calc() collapses', () => {
+  assert.equal(out('calc(calc(1px + 2px))'), '3px');
+});
+
+// Note: `-webkit-calc(...)` and `-moz-calc(...)` vendor wrappers come in
+// pre-stripped from the PostCSS value layer in production. At the parser
+// level, the leading `-` would read as unary minus, so we don't exercise
+// those forms here — the production adapter unwraps them before we see the
+// expression contents.
+
+// --- Like-term combination (§10.10) ---------------------------------------
+
+test('simplify: adds same-unit lengths', () => {
+  assert.equal(out('calc(1px + 2px + 3px)'), '6px');
+});
+
+test('simplify: subtracts same-unit lengths', () => {
+  assert.equal(out('calc(10px - 3px - 2px)'), '5px');
+});
+
+test('simplify: converts across the same length family', () => {
+  assert.equal(out('calc(1in + 10px)'), '1.10417in');
+  assert.equal(out('calc(1cm + 10mm)'), '2cm');
+});
+
+test('simplify: relative units stay in their own bucket (em not foldable with px)', () => {
+  assert.equal(out('calc(1em + 10px)'), 'calc(1em + 10px)');
+});
+
+test('simplify: percentage stays its own type (no context to mix with length)', () => {
+  assert.equal(out('calc(100% - 30px)'), 'calc(100% - 30px)');
+});
+
+test('simplify: cancellation yields 0', () => {
+  assert.equal(out('calc(1px - 1px)'), '0px');
+  assert.equal(out('calc(5 - 5)'), '0');
+});
+
+test('simplify: like terms across parentheses', () => {
+  assert.equal(out('calc(50px - (20px - 30px))'), '60px');
+});
+
+// --- Product / division (§10.10, §10.2) -----------------------------------
+
+test('simplify: dim * number', () => {
+  assert.equal(out('calc(3em * 2)'), '6em');
+  assert.equal(out('calc(2 * 3em)'), '6em');
+});
+
+test('simplify: dim / number', () => {
+  assert.equal(out('calc(10px / 2)'), '5px');
+});
+
+test('simplify: number * number', () => {
+  assert.equal(out('calc(3 * 4)'), '12');
+});
+
+test('simplify: number / number', () => {
+  assert.equal(out('calc(10 / 4)'), '2.5');
+});
+
+test('simplify: dim * dim preserved (unit^2 not expressible)', () => {
+  assert.equal(out('calc(2px * 3px)'), 'calc(2px*3px)');
+});
+
+test('simplify: distributes number into a sum', () => {
+  // not the spec's required behavior, but a natural consequence of folding
+  // after a product — proves we fold where we can.
+  assert.equal(out('calc((1 + 2) * 3px)'), '9px');
+});
+
+// --- min / max / clamp (§10.10) ------------------------------------------
+
+test('simplify: min folds when all args share a type', () => {
+  assert.equal(out('min(1px, 2px, 3px)'), '1px');
+});
+
+test('simplify: max folds when all args share a type', () => {
+  assert.equal(out('max(1em, 2em, 3em)'), '3em');
+});
+
+test('simplify: min converts units within a family before comparing', () => {
+  // 1in = 96px, so min(1in, 10px) = min(1in, 0.10417in) = 0.10417in.
+  // First arg's unit is canonical — consistent with the sum-bucket rule.
+  assert.equal(out('min(1in, 10px)'), '0.10417in');
+});
+
+test('simplify: clamp folds when fully resolved', () => {
+  assert.equal(out('clamp(0px, 5px, 10px)'), '5px');
+  assert.equal(out('clamp(0px, -5px, 10px)'), '0px');
+  assert.equal(out('clamp(0px, 50px, 10px)'), '10px');
+});
+
+test('simplify: min preserved when types mix', () => {
+  assert.equal(out('min(1px, 1em)'), 'min(1px, 1em)');
+});
+
+test('simplify: min preserved when an arg is opaque', () => {
+  assert.equal(out('min(1px, var(--x))'), 'min(1px, var(--x))');
+});
+
+test('simplify: nested min / max', () => {
+  assert.equal(out('max(1px, min(2px, 3px))'), '2px');
+});
+
+// --- Calc keywords (§10.9) ------------------------------------------------
+
+test('simplify: pi folds to a number', () => {
+  assert.equal(out('calc(pi)'), '3.14159');
+});
+
+test('simplify: e folds to a number', () => {
+  assert.equal(out('calc(e)'), '2.71828');
+});
+
+test('simplify: pi in a product with a unit', () => {
+  assert.equal(out('calc(pi * 1rad)'), '3.14159rad');
+});
+
+test('simplify: calc-keyword names are case-insensitive except NaN', () => {
+  assert.equal(out('calc(PI)'), '3.14159');
+  assert.equal(out('calc(Infinity)'), 'Infinity');
+  // `nan` lowercase is treated as a plain ident (opaque), not the keyword
+  assert.equal(out('calc(nan)'), 'nan');
+});
diff --git a/playground/pratt/test-tokenizer.ts b/playground/pratt/test-tokenizer.ts
new file mode 100644
index 0000000..87b95c4
--- /dev/null
+++ b/playground/pratt/test-tokenizer.ts
@@ -0,0 +1,58 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { tokenize } from './tokenizer.ts';
+
+const shape = (input: string) =>
+  tokenize(input)
+    .slice(0, -1)
+    .map((t) =>
+      t.type === 'dimension' ? `${t.value}${t.unit}` : `${t.type}:${t.value}`
+    );
+
+test('tok: number types — int, float, leading dot, scientific', () => {
+  assert.deepEqual(shape('1 2.5 .25 1e2 1.5E-3'), [
+    'number:1',
+    'number:2.5',
+    'number:.25',
+    'number:1e2',
+    'number:1.5E-3',
+  ]);
+});
+
+test('tok: scientific `e` does not swallow `em` / `ex` units', () => {
+  assert.deepEqual(shape('2em 3ex 4e+2 5e2'), [
+    '2em',
+    '3ex',
+    'number:4e+2',
+    'number:5e2',
+  ]);
+});
+
+test('tok: % tokenizes as a dimension with unit %', () => {
+  assert.deepEqual(shape('50% 100%'), ['50%', '100%']);
+});
+
+test('tok: 1px-2 single-token rule — hyphen is part of unit body', () => {
+  assert.deepEqual(shape('1px-2 10foo-bar'), ['1px-2', '10foo-bar']);
+});
+
+test('tok: CSS custom property --name is one ident', () => {
+  assert.deepEqual(shape('var(--x)'), [
+    'ident:var',
+    'punct:(',
+    'ident:--x',
+    'punct:)',
+  ]);
+});
+
+test('tok: idents may contain hyphens', () => {
+  assert.deepEqual(shape('min-content foo-bar_baz'), [
+    'ident:min-content',
+    'ident:foo-bar_baz',
+  ]);
+});
+
+test('tok: unknown character throws', () => {
+  assert.throws(() => tokenize('1 @ 2'), /Unexpected character/);
+});
diff --git a/playground/pratt/test-typed.ts b/playground/pratt/test-typed.ts
new file mode 100644
index 0000000..7f188ec
--- /dev/null
+++ b/playground/pratt/test-typed.ts
@@ -0,0 +1,72 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { tokenize } from './tokenizer.ts';
+import { parse } from './parser.ts';
+import { simplify } from './simplify.ts';
+import { serialize } from './serialize.ts';
+
+const out = (input: string): string =>
+  serialize(simplify(parse(tokenize(input))));
+
+// --- Typed division (§10.2) -----------------------------------------------
+// <T> / <T> → <number> when both sides reduce to the same base type and the
+// units are statically convertible within that type's conversion family.
+
+test('typed div: px / px → unitless number', () => {
+  assert.equal(out('calc(10px / 2px)'), '5');
+});
+
+test('typed div: in / px → unitless number (cross-unit)', () => {
+  assert.equal(out('calc(1in / 48px)'), '2');
+});
+
+test('typed div: cm / mm → unitless', () => {
+  assert.equal(out('calc(1cm / 5mm)'), '2');
+});
+
+test('typed div: s / ms → unitless', () => {
+  assert.equal(out('calc(1s / 100ms)'), '10');
+});
+
+test('typed div: Hz / kHz → unitless', () => {
+  assert.equal(out('calc(1000hz / 1khz)'), '1');
+});
+
+test('typed div: deg / rad → unitless', () => {
+  // 180deg / pi rad = 180 / (pi * (180/pi)) = 1
+  assert.equal(out('calc(180deg / 180deg)'), '1');
+});
+
+test('typed div: relative unit (vw) not statically convertible, preserved', () => {
+  assert.equal(out('calc(100vw / 1px)'), 'calc(100vw/1px)');
+});
+
+test('typed div: different base types preserved (not a typed division)', () => {
+  assert.equal(out('calc(10px / 1s)'), 'calc(10px/1s)');
+});
+
+// --- Unit arithmetic across families --------------------------------------
+
+test('typed arith: dim * number preserves unit', () => {
+  assert.equal(out('calc(3em * 2)'), '6em');
+});
+
+test('typed arith: dim / number preserves unit', () => {
+  assert.equal(out('calc(6em / 2)'), '3em');
+});
+
+test('typed arith: chained multiplication folds', () => {
+  assert.equal(out('calc(2 * 3 * 4px)'), '24px');
+});
+
+test('typed arith: number * (dim + dim) folds through', () => {
+  assert.equal(out('calc((1px + 2px) * 3)'), '9px');
+});
+
+// --- Division by zero -----------------------------------------------------
+
+test('typed arith: division by zero throws', () => {
+  assert.throws(() => out('calc(1px / 0)'), /Division by zero/);
+  assert.throws(() => out('calc(10 / 0)'), /Division by zero/);
+});
diff --git a/playground/pratt/test-wpt.ts b/playground/pratt/test-wpt.ts
new file mode 100644
index 0000000..f18fafe
--- /dev/null
+++ b/playground/pratt/test-wpt.ts
@@ -0,0 +1,297 @@
+// WPT (web-platform-tests) subset cribbed from:
+//   https://github.com/web-platform-tests/wpt/tree/master/css/css-values
+//
+// Each test cites its source file. Cases selected where our v11.0 output
+// matches the spec-defined simplified form without requiring:
+//   - Chrome/Firefox's canonical reordering of sum terms (§10.12 step 4),
+//   - eager normalization of absolute length units to px (a browser
+//     serialization choice, not a spec requirement for calc()),
+//   - infinity / NaN serialization (v11.3 scope, not v11.0).
+//
+// Divergences are documented with `DIVERGE:` comments.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { tokenize } from './tokenizer.ts';
+import { parse } from './parser.ts';
+import { simplify } from './simplify.ts';
+import { serialize } from './serialize.ts';
+
+const out = (input: string): string =>
+  serialize(simplify(parse(tokenize(input))));
+
+// --- calc-serialization.html ---------------------------------------------
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/calc-serialization.html
+
+test('WPT calc-serialization: single negative length preserved', () => {
+  // Input: `calc(-10px)` → WPT expects `calc(-10px)`.
+  // DIVERGE: we unwrap single values to bare dimensions.
+  assert.equal(out('calc(-10px)'), '-10px');
+});
+
+test('WPT calc-serialization: resolvable + opaque kept as a sum', () => {
+  // Input: `calc(10px + 1vmin)` → WPT: `calc(10px + 1vmin)` (same order).
+  assert.equal(out('calc(10px + 1vmin)'), 'calc(10px + 1vmin)');
+});
+
+// --- minmax-length-serialize.html ----------------------------------------
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/minmax-length-serialize.html
+
+test('WPT minmax-length: single-arg min folds', () => {
+  // WPT specified: `calc(1px)`; our output unwraps to `1px`.
+  assert.equal(out('min(1px)'), '1px');
+});
+
+test('WPT minmax-length: single-arg max folds', () => {
+  assert.equal(out('max(1px)'), '1px');
+});
+
+test('WPT minmax-length: unit case normalized to lowercase', () => {
+  // Spec §10.12: `1Q` serializes as `1q`, `1PX` as `1px`.
+  assert.equal(out('min(1PX)'), '1px');
+});
+
+test('WPT minmax-length: min() preserved when arg types mix', () => {
+  // WPT: `min(1px, 1em)` stays `min(1px, 1em)` (em is relative).
+  assert.equal(out('min(1px, 1em)'), 'min(1px, 1em)');
+});
+
+test('WPT minmax-length: max folds when all args share a unit', () => {
+  // WPT (same unit): `max(1px, 2px, 3px)` → `3px`.
+  assert.equal(out('max(1px, 2px, 3px)'), '3px');
+});
+
+// --- calc-in-calc.html ---------------------------------------------------
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/calc-in-calc.html
+
+test('WPT calc-in-calc: outer calc() flattens inner calc()', () => {
+  assert.equal(out('calc(calc(100%))'), '100%');
+});
+
+test('WPT calc-in-calc: nested calc() with sum', () => {
+  assert.equal(out('calc(calc(1px + 2px) + 3px)'), '6px');
+});
+
+test('WPT calc-in-calc: doubly-nested calc', () => {
+  assert.equal(out('calc(calc(calc(5px)))'), '5px');
+});
+
+// --- calc-catch-divide-by-0.html (subset not requiring infinity/NaN) -----
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/calc-catch-divide-by-0.html
+
+test('WPT divide-by-zero: 100px / 0 throws', () => {
+  // DIVERGE: browsers serialize as `calc(infinity * 1px)`; that's §10.9/10.12
+  // and is v11.3 scope. v11.0 throws at transform time.
+  assert.throws(() => out('calc(100px / 0)'), /Division by zero/);
+});
+
+test('WPT divide-by-zero: 100px / (2 - 2) throws', () => {
+  assert.throws(() => out('calc(100px / (2 - 2))'), /Division by zero/);
+});
+
+// --- calc-typed-arithmetic-parsing (implied from spec §10.2) -------------
+
+test('WPT typed-arith: <length> / <length> → <number>', () => {
+  assert.equal(out('calc(10px / 2px)'), '5');
+});
+
+test('WPT typed-arith: <time> / <time> → <number>', () => {
+  assert.equal(out('calc(1s / 500ms)'), '2');
+});
+
+test('WPT typed-arith: <length> * <number>', () => {
+  assert.equal(out('calc(10px * 2)'), '20px');
+});
+
+test('WPT typed-arith: <number> * <length>', () => {
+  assert.equal(out('calc(2 * 10px)'), '20px');
+});
+
+// --- calc-keyword folding (§10.9) ----------------------------------------
+
+test('WPT calc-keyword: pi resolves in a calc', () => {
+  // WPT cases expect `calc(3.14159265358979)` with ~15 digits; our default
+  // precision of 5 produces `3.14159`. Same number, different formatting.
+  assert.equal(out('calc(pi)'), '3.14159');
+});
+
+test('WPT calc-keyword: e resolves in a calc', () => {
+  assert.equal(out('calc(e)'), '2.71828');
+});
+
+test('WPT calc-keyword: pi multiplied by a unit', () => {
+  assert.equal(out('calc(pi * 1rad)'), '3.14159rad');
+});
+
+// --- var()-preservation round-trips (widely tested across WPT) -----------
+
+test('WPT var: var() passes through in calc', () => {
+  assert.equal(out('calc(var(--x))'), 'var(--x)');
+});
+
+test('WPT var: resolvables around a var()', () => {
+  // Sum of 1px + 2px combines, var() preserved. Matches WPT behavior for
+  // the parts that don't depend on browser resolution of --x.
+  assert.equal(out('calc(1px + var(--x) + 2px)'), 'calc(3px + var(--x))');
+});
+
+test('WPT var: var with resolvable calc in the fallback', () => {
+  assert.equal(out('var(--x, calc(1px + 2px))'), 'var(--x, 3px)');
+});
+
+// --- clamp (implied from spec §10.8) -------------------------------------
+
+test('WPT clamp: all args resolve — returns middle value', () => {
+  assert.equal(out('clamp(0px, 5px, 10px)'), '5px');
+});
+
+test('WPT clamp: val below min — clamped to min', () => {
+  assert.equal(out('clamp(10px, 5px, 20px)'), '10px');
+});
+
+test('WPT clamp: val above max — clamped to max', () => {
+  assert.equal(out('clamp(0px, 50px, 10px)'), '10px');
+});
+
+test('WPT clamp: preserved when an arg is opaque', () => {
+  assert.equal(
+    out('clamp(0px, var(--x), 10px)'),
+    'clamp(0px, var(--x), 10px)'
+  );
+});
+
+// --- 1px-2 single-token tokenization -------------------------------------
+// The tokenizer treats `1px-2` as a dimension with unit `px-2` (spec §10.1,
+// CSS tokenization — idents may contain `-` and digits in the body).
+
+test('WPT tokenization: 1px-2 is a single unknown-unit dimension', () => {
+  // Unknown unit → treated as opaque by simplify; passes through verbatim.
+  assert.equal(out('calc(1px-2)'), '1px-2');
+});
+
+// --- minmax-number-serialize.html ----------------------------------------
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/minmax-number-serialize.html
+
+test('WPT minmax-number: single .1', () => {
+  assert.equal(out('min(.1)'), '0.1');
+  assert.equal(out('max(.1)'), '0.1');
+});
+
+test('WPT minmax-number: min picks smallest number', () => {
+  assert.equal(out('min(.1, .2, .3)'), '0.1');
+  assert.equal(out('min(.3, .2, .1)'), '0.1');
+});
+
+test('WPT minmax-number: max picks largest number', () => {
+  assert.equal(out('max(.1, .2, .3)'), '0.3');
+  assert.equal(out('max(.3, .2, .1)'), '0.3');
+});
+
+test('WPT minmax-number: min folded inside a sum', () => {
+  assert.equal(out('calc(min(.1) + min(.2))'), '0.3');
+});
+
+test('WPT minmax-number: max inside a sum', () => {
+  assert.equal(out('calc(max(.1) + max(.2))'), '0.3');
+});
+
+test('WPT minmax-number: sum of number and folded min', () => {
+  assert.equal(out('calc(.1 + min(.1))'), '0.2');
+});
+
+// --- minmax-time-serialize.html ------------------------------------------
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/minmax-time-serialize.html
+// Same-unit cases only — Chrome normalizes ms→s, we preserve source unit.
+
+test('WPT minmax-time: single-arg second', () => {
+  assert.equal(out('min(1s)'), '1s');
+  assert.equal(out('max(1s)'), '1s');
+});
+
+test('WPT minmax-time: min of three same-unit seconds', () => {
+  assert.equal(out('min(1s, 2s, 3s)'), '1s');
+  assert.equal(out('min(3s, 2s, 1s)'), '1s');
+});
+
+test('WPT minmax-time: max of three same-unit seconds', () => {
+  assert.equal(out('max(1s, 2s, 3s)'), '3s');
+});
+
+// --- minmax-angle-serialize.html -----------------------------------------
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/minmax-angle-serialize.html
+// Same-unit cases only — cross-unit angle conversion produces values in the
+// first arg's unit (turn/rad precision makes full cross-unit tests brittle).
+
+test('WPT minmax-angle: single-arg degree', () => {
+  assert.equal(out('min(90deg)'), '90deg');
+  assert.equal(out('max(90deg)'), '90deg');
+});
+
+test('WPT minmax-angle: min of degrees', () => {
+  assert.equal(out('min(90deg, 92deg, 93deg)'), '90deg');
+  assert.equal(out('min(93deg, 92deg, 90deg)'), '90deg');
+});
+
+test('WPT minmax-angle: max of degrees', () => {
+  assert.equal(out('max(81deg, 82deg, 90deg)'), '90deg');
+});
+
+// --- minmax-percentage-serialize.html ------------------------------------
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/minmax-percentage-serialize.html
+// Percentages are NEVER folded inside min/max/clamp — in property contexts
+// that resolve against a negative value, ordering flips.
+
+test('WPT minmax-percentage: single-arg percent preserved', () => {
+  // WPT: `min(1%)` → `calc(1%)`. Our single-value unwrap: `1%`.
+  assert.equal(out('min(1%)'), '1%');
+  assert.equal(out('max(1%)'), '1%');
+});
+
+test('WPT minmax-percentage: multi-arg percent preserved — NO folding', () => {
+  assert.equal(out('min(1%, 2%, 3%)'), 'min(1%, 2%, 3%)');
+  assert.equal(out('min(3%, 2%, 1%)'), 'min(3%, 2%, 1%)');
+});
+
+test('WPT minmax-percentage: max preserves percent args', () => {
+  assert.equal(out('max(1%, 2%, 3%)'), 'max(1%, 2%, 3%)');
+});
+
+test('WPT minmax-percentage: clamp preserves when any arg is percent', () => {
+  assert.equal(out('clamp(1%, 2%, 3%)'), 'clamp(1%, 2%, 3%)');
+});
+
+// --- calc-serialization-002.html (subset) --------------------------------
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/calc-serialization-002.html
+// Most cases here use Chrome's canonical reordering + px-normalization so
+// they diverge. Pulling only the ones where neither reordering nor unit
+// normalization changes the result.
+
+test('WPT calc-serialization-002: same-family combination (ex)', () => {
+  // WPT: `calc(5ex - 9ex)` → `calc(-4ex)`. Our single-value unwrap: `-4ex`.
+  assert.equal(out('calc(5ex - 9ex)'), '-4ex');
+});
+
+test('WPT calc-serialization-002: cancelling percentages leaves 0%', () => {
+  // WPT: `calc(100% - 100% + 1em)` → `calc(0% + 1em)`.
+  assert.equal(out('calc(100% - 100% + 1em)'), 'calc(0% + 1em)');
+});
+
+test('WPT calc-serialization-002: cancelling percentages in the middle', () => {
+  // WPT: `calc(100% + 1em - 100%)` → `calc(0% + 1em)`.
+  assert.equal(out('calc(100% + 1em - 100%)'), 'calc(0% + 1em)');
+});
+
+test('WPT calc-serialization-002: vmin + 0pt preserves both terms', () => {
+  // WPT: `calc(4vmin + 0pt)` → `calc(0px + 4vmin)` (Chrome canonicalizes).
+  // DIVERGE: we preserve source order and don't normalize pt→px, so we
+  // keep both terms in their original units.
+  assert.equal(out('calc(4vmin + 0pt)'), 'calc(4vmin + 0pt)');
+});
+
+// --- calc-invalid-parsing.html (subset our tokenizer catches) ------------
+// https://github.com/web-platform-tests/wpt/blob/master/css/css-values/calc-invalid-parsing.html
+
+test('WPT invalid: brackets inside calc() throw at tokenizer', () => {
+  assert.throws(() => out('calc([])'), /Unexpected character/);
+});
diff --git a/playground/pratt/test.ts b/playground/pratt/test.ts
new file mode 100644
index 0000000..94845fe
--- /dev/null
+++ b/playground/pratt/test.ts
@@ -0,0 +1,277 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { tokenize } from './tokenizer.ts';
+import type { Token } from './tokenizer.ts';
+import {
+  parse,
+  defaultPrefix,
+  defaultInfix,
+  binaryRight,
+} from './parser.ts';
+import { evaluate } from './evaluator.ts';
+import { sexpr } from './sexpr.ts';
+
+const astOf = (input: string): string => sexpr(parse(tokenize(input)));
+const evalOf = (input: string): number => evaluate(parse(tokenize(input)));
+
+// --- Tokenizer ------------------------------------------------------------
+
+test('tokenize: numbers (int, float, scientific)', () => {
+  assert.deepEqual(
+    tokenize('1 2.5 .25 1e2 1.5E-3').map((t) => t.value),
+    ['1', '2.5', '.25', '1e2', '1.5E-3', '']
+  );
+});
+
+test('tokenize: unknown character throws', () => {
+  assert.throws(() => tokenize('1 @ 2'), /Unexpected character/);
+});
+
+// --- AST: precedence & associativity --------------------------------------
+
+test('precedence: * before +', () => {
+  assert.equal(astOf('1 + 2 * 3'), '(+ 1 (* 2 3))');
+});
+
+test('precedence: parens override', () => {
+  assert.equal(astOf('(1 + 2) * 3'), '(* (+ 1 2) 3)');
+});
+
+test('associativity: + is left-associative', () => {
+  assert.equal(astOf('1 + 2 + 3'), '(+ (+ 1 2) 3)');
+});
+
+test('associativity: / is left-associative', () => {
+  assert.equal(astOf('8 / 4 / 2'), '(/ (/ 8 4) 2)');
+});
+
+test('associativity: mixed same-precedence', () => {
+  assert.equal(astOf('1 - 2 + 3'), '(+ (- 1 2) 3)');
+});
+
+test('unary minus binds tighter than *', () => {
+  assert.equal(astOf('-2 * 3'), '(* (- 2) 3)');
+});
+
+test('unary minus stacks', () => {
+  assert.equal(astOf('--1'), '(- (- 1))');
+});
+
+test('unary plus is preserved', () => {
+  assert.equal(astOf('+1 + -2'), '(+ (+ 1) (- 2))');
+});
+
+test('deep parens collapse', () => {
+  assert.equal(astOf('(((42)))'), '42');
+});
+
+// --- AST: function calls --------------------------------------------------
+
+test('call: zero args', () => {
+  assert.equal(astOf('now()'), '(now)');
+});
+
+test('call: many args', () => {
+  assert.equal(astOf('clamp(0, x, 10)'), '(clamp 0 x 10)');
+});
+
+test('call: nested', () => {
+  assert.equal(astOf('min(1, max(2, 3))'), '(min 1 (max 2 3))');
+});
+
+test('call: arg expression uses full precedence', () => {
+  assert.equal(astOf('pow(1 + 2, 3 * 4)'), '(pow (+ 1 2) (* 3 4))');
+});
+
+// --- Evaluation -----------------------------------------------------------
+
+test('eval: simple arithmetic', () => {
+  assert.equal(evalOf('1 + 2 * 3'), 7);
+  assert.equal(evalOf('(1 + 2) * 3'), 9);
+  assert.equal(evalOf('10 - 3 - 2'), 5);
+  assert.equal(evalOf('100 / 5 / 2'), 10);
+});
+
+test('eval: unary', () => {
+  assert.equal(evalOf('-2 * 3'), -6);
+  assert.equal(evalOf('-(2 + 3)'), -5);
+  assert.equal(evalOf('--7'), 7);
+});
+
+test('eval: functions', () => {
+  assert.equal(evalOf('pow(2, 10)'), 1024);
+  assert.equal(evalOf('sqrt(16)'), 4);
+  assert.equal(evalOf('abs(-7)'), 7);
+  assert.equal(evalOf('min(3, 1, 2)'), 1);
+  assert.equal(evalOf('max(3, 1, 2)'), 3);
+});
+
+test('eval: clamp', () => {
+  assert.equal(evalOf('clamp(0, 5, 10)'), 5);
+  assert.equal(evalOf('clamp(0, -1, 10)'), 0);
+  assert.equal(evalOf('clamp(0, 20, 10)'), 10);
+});
+
+test('eval: constants', () => {
+  assert.equal(evalOf('pi'), Math.PI);
+  assert.equal(evalOf('pi * 2'), Math.PI * 2);
+  assert.equal(evalOf('e'), Math.E);
+});
+
+test('eval: mixed nested', () => {
+  assert.equal(evalOf('max(1, min(pow(2, 3), 5) + 1)'), 6);
+});
+
+test('eval: trig (radians)', () => {
+  assert.equal(evalOf('sin(0)'), 0);
+  assert.ok(Math.abs(evalOf('sin(pi / 2)') - 1) < 1e-12);
+  assert.ok(Math.abs(evalOf('cos(pi)') - -1) < 1e-12);
+  assert.equal(evalOf('tan(0)'), 0);
+});
+
+test('eval: inverse trig', () => {
+  assert.equal(evalOf('asin(0)'), 0);
+  assert.equal(evalOf('acos(1)'), 0);
+  assert.equal(evalOf('atan(0)'), 0);
+  assert.ok(Math.abs(evalOf('atan2(1, 1)') - Math.PI / 4) < 1e-12);
+});
+
+test('eval: exponential family', () => {
+  assert.equal(evalOf('exp(0)'), 1);
+  assert.equal(evalOf('log(e)'), 1);
+  assert.equal(evalOf('hypot(3, 4)'), 5);
+  assert.equal(evalOf('hypot(1, 1, 1, 1)'), 2);
+});
+
+test('eval: sign', () => {
+  assert.equal(evalOf('sign(-7)'), -1);
+  assert.equal(evalOf('sign(0)'), 0);
+  assert.equal(evalOf('sign(42)'), 1);
+});
+
+test('eval: rounding', () => {
+  assert.equal(evalOf('round(2.4)'), 2);
+  assert.equal(evalOf('round(2.5)'), 3);
+  assert.equal(evalOf('floor(2.9)'), 2);
+  assert.equal(evalOf('ceil(2.1)'), 3);
+  assert.equal(evalOf('trunc(-2.9)'), -2);
+});
+
+test('eval: mod vs rem', () => {
+  // mod result follows the divisor's sign; rem follows the dividend's.
+  assert.equal(evalOf('mod(-7, 3)'), 2);
+  assert.equal(evalOf('rem(-7, 3)'), -1);
+  assert.equal(evalOf('mod(7, 3)'), 1);
+  assert.equal(evalOf('rem(7, 3)'), 1);
+});
+
+// --- Error cases ----------------------------------------------------------
+
+test('error: empty input', () => {
+  assert.throws(() => parse(tokenize('')), /Unexpected token/);
+});
+
+test('error: only whitespace', () => {
+  assert.throws(() => parse(tokenize('   ')), /Unexpected token/);
+});
+
+test('error: empty parens', () => {
+  assert.throws(() => parse(tokenize('()')), /Unexpected token/);
+});
+
+test('error: unclosed paren', () => {
+  assert.throws(() => parse(tokenize('(1 + 2')), /Expected/);
+});
+
+test('error: trailing operator', () => {
+  assert.throws(() => parse(tokenize('1 +')), /Unexpected token/);
+});
+
+test('error: leading close-paren', () => {
+  assert.throws(() => parse(tokenize(') 1')), /Unexpected token/);
+});
+
+test('error: orphan operator', () => {
+  assert.throws(() => parse(tokenize('* 1')), /Unexpected token/);
+});
+
+test('error: stacked binary operators', () => {
+  assert.throws(() => parse(tokenize('1 * * 2')), /Unexpected token/);
+});
+
+test('error: two consecutive numbers', () => {
+  assert.throws(() => parse(tokenize('1 2')), /Unexpected token/);
+});
+
+test('error: call with leading comma', () => {
+  assert.throws(() => parse(tokenize('min(, 1)')), /Unexpected token/);
+});
+
+test('error: call with trailing comma', () => {
+  assert.throws(() => parse(tokenize('min(1,)')), /Unexpected token/);
+});
+
+test('error: call with missing comma between args', () => {
+  assert.throws(() => parse(tokenize('min(1 2)')), /Expected/);
+});
+
+test('error: unclosed call', () => {
+  assert.throws(() => parse(tokenize('min(1, 2')), /Expected/);
+});
+
+test('error: bare comma', () => {
+  assert.throws(() => parse(tokenize(',')), /Unexpected token/);
+});
+
+test('error: division by zero at eval', () => {
+  assert.throws(() => evalOf('1 / 0'), /Division by zero/);
+});
+
+test('error: unknown function', () => {
+  assert.throws(() => evalOf('wat(1)'), /Unknown function/);
+});
+
+test('error: unknown identifier', () => {
+  assert.throws(() => evalOf('x + 1'), /Unknown identifier/);
+});
+
+// --- Pinned semantics -----------------------------------------------------
+// These are valid by design. Locked down so a refactor can't silently
+// change how unary and binary `+`/`-` interact.
+
+test('pinned: binary + unary', () => {
+  assert.equal(astOf('1 + -2'), '(+ 1 (- 2))');
+  assert.equal(astOf('1 - -2'), '(- 1 (- 2))');
+  assert.equal(astOf('1 + +2'), '(+ 1 (+ 2))');
+  assert.equal(evalOf('1 - -2'), 3);
+});
+
+test('pinned: stacked unary', () => {
+  assert.equal(astOf('---5'), '(- (- (- 5)))');
+  assert.equal(evalOf('---5'), -5);
+});
+
+test('pinned: unary after * stays bound to right operand', () => {
+  assert.equal(astOf('2 * -3'), '(* 2 (- 3))');
+  assert.equal(evalOf('2 * -3'), -6);
+});
+
+// --- Extensibility sanity check -------------------------------------------
+// Verifies the registry approach: adding a new operator is one map entry.
+
+test('extension: add `^` as right-associative power operator', () => {
+  const tokens: Token[] = [
+    { type: 'number', value: '2', pos: 0 },
+    { type: 'punct', value: '^', pos: 1 },
+    { type: 'number', value: '3', pos: 2 },
+    { type: 'punct', value: '^', pos: 3 },
+    { type: 'number', value: '2', pos: 4 },
+    { type: 'eof', value: '', pos: 5 },
+  ];
+
+  const infix = { ...defaultInfix(), '^': binaryRight('^', 5) };
+  const ast = parse(tokens, { prefix: defaultPrefix(), infix });
+  // right-associative: 2 ^ (3 ^ 2), not (2 ^ 3) ^ 2
+  assert.equal(sexpr(ast), '(^ 2 (^ 3 2))');
+});
diff --git a/playground/pratt/tokenizer.ts b/playground/pratt/tokenizer.ts
new file mode 100644
index 0000000..c33e897
--- /dev/null
+++ b/playground/pratt/tokenizer.ts
@@ -0,0 +1,146 @@
+// Spec: https://www.w3.org/TR/css-values-4/#calc-syntax
+// Implements the subset of CSS tokenization calc() depends on: numbers,
+// dimensions (number+unit, including the `1px-2` single-token rule),
+// identifiers (CSS idents may contain `-`), and punctuation.
+
+export type TokenType =
+  | 'number'
+  | 'dimension'
+  | 'ident'
+  | 'punct'
+  | 'eof';
+
+export interface Token {
+  type: TokenType;
+  value: string;
+  /** Present on `dimension` tokens; includes `%` for percentages. */
+  unit?: string;
+  pos: number;
+}
+
+const IS_DIGIT = /[0-9]/;
+const IS_IDENT_START = /[a-zA-Z_]/;
+const IS_IDENT_BODY = /[a-zA-Z0-9_-]/;
+const IS_WS = /\s/;
+const PUNCT = new Set(['+', '-', '*', '/', '(', ')', ',']);
+
+function readNumberStr(input: string, start: number): number {
+  let i = start;
+  while (i < input.length && IS_DIGIT.test(input[i]!)) {
+    i++;
+  }
+  if (input[i] === '.') {
+    i++;
+    while (i < input.length && IS_DIGIT.test(input[i]!)) {
+      i++;
+    }
+  }
+  // Exponent — only if followed by a digit (optionally after +/-). This
+  // prevents `2em` from being read as `2e` followed by unit `m`.
+  if (input[i] === 'e' || input[i] === 'E') {
+    const after = input[i + 1] ?? '';
+    const hasExp =
+      IS_DIGIT.test(after) ||
+      ((after === '+' || after === '-') &&
+        IS_DIGIT.test(input[i + 2] ?? ''));
+    if (hasExp) {
+      i++;
+      if (input[i] === '+' || input[i] === '-') {
+        i++;
+      }
+      while (i < input.length && IS_DIGIT.test(input[i]!)) {
+        i++;
+      }
+    }
+  }
+  return i;
+}
+
+function readIdentBody(input: string, start: number): number {
+  let i = start;
+  while (i < input.length && IS_IDENT_BODY.test(input[i]!)) {
+    i++;
+  }
+  return i;
+}
+
+export function tokenize(input: string): Token[] {
+  const tokens: Token[] = [];
+  let i = 0;
+
+  while (i < input.length) {
+    const c = input[i]!;
+
+    if (IS_WS.test(c)) {
+      i++;
+      continue;
+    }
+
+    if (IS_DIGIT.test(c) || (c === '.' && IS_DIGIT.test(input[i + 1] ?? ''))) {
+      const start = i;
+      i = readNumberStr(input, i);
+      const numValue = input.slice(start, i);
+
+      // Dimension: number followed by `%` or an identifier. Per the CSS
+      // tokenization rule, once we start an identifier body the whole run
+      // including `-` and digits is the unit, so `1px-2` is one token.
+      if (input[i] === '%') {
+        tokens.push({
+          type: 'dimension',
+          value: numValue,
+          unit: '%',
+          pos: start,
+        });
+        i++;
+        continue;
+      }
+      if (i < input.length && IS_IDENT_START.test(input[i]!)) {
+        const unitStart = i;
+        i = readIdentBody(input, i);
+        tokens.push({
+          type: 'dimension',
+          value: numValue,
+          unit: input.slice(unitStart, i),
+          pos: start,
+        });
+        continue;
+      }
+
+      tokens.push({ type: 'number', value: numValue, pos: start });
+      continue;
+    }
+
+    if (IS_IDENT_START.test(c)) {
+      const start = i;
+      i = readIdentBody(input, i);
+      tokens.push({ type: 'ident', value: input.slice(start, i), pos: start });
+      continue;
+    }
+
+    // CSS custom property reference: `--name`. Recognized here so that
+    // `var(--x)` tokenizes cleanly as `var`, `(`, ident `--x`, `)`
+    // rather than `-`, `-`, `x`.
+    if (
+      c === '-' &&
+      input[i + 1] === '-' &&
+      IS_IDENT_START.test(input[i + 2] ?? '')
+    ) {
+      const start = i;
+      i += 2;
+      i = readIdentBody(input, i);
+      tokens.push({ type: 'ident', value: input.slice(start, i), pos: start });
+      continue;
+    }
+
+    if (PUNCT.has(c)) {
+      tokens.push({ type: 'punct', value: c, pos: i });
+      i++;
+      continue;
+    }
+
+    throw new Error(`Unexpected character "${c}" at position ${i}`);
+  }
+
+  tokens.push({ type: 'eof', value: '', pos: input.length });
+  return tokens;
+}
diff --git a/playground/pratt/tsconfig.json b/playground/pratt/tsconfig.json
new file mode 100644
index 0000000..25c309e
--- /dev/null
+++ b/playground/pratt/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "lib": ["es2022"],
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["**/*.ts"]
+}
diff --git a/playground/pratt/type.ts b/playground/pratt/type.ts
new file mode 100644
index 0000000..461d9d9
--- /dev/null
+++ b/playground/pratt/type.ts
@@ -0,0 +1,135 @@
+// Spec: https://www.w3.org/TR/css-values-4/#calc-type-checking
+//
+// A calculation type is a map of base types → integer exponents. A bare
+// number has the empty map. `10px` has {length: 1}. `10px / 2s` has
+// {length: 1, time: -1}.
+//
+// The percent-hint mechanism (§10.2) is simplified: percentage is treated as
+// its own base type. Full percent-hint handling belongs to a later version
+// since it only matters for property-context resolution, which a transform-
+// time plugin can't do anyway.
+
+export type BaseType =
+  | 'length'
+  | 'angle'
+  | 'time'
+  | 'frequency'
+  | 'resolution'
+  | 'flex'
+  | 'percentage';
+
+export type CalcType = Map<BaseType, number>;
+
+/** Spec §10.2 — unit → base type. Case-insensitive. */
+const UNIT_TO_BASE: Record<string, BaseType> = {
+  // <length>
+  px: 'length', cm: 'length', mm: 'length', q: 'length',
+  in: 'length', pt: 'length', pc: 'length',
+  em: 'length', ex: 'length', ch: 'length', rem: 'length',
+  lh: 'length', rlh: 'length', ic: 'length', cap: 'length',
+  vw: 'length', vh: 'length', vmin: 'length', vmax: 'length',
+  vb: 'length', vi: 'length',
+  svw: 'length', svh: 'length', svmin: 'length', svmax: 'length',
+  svb: 'length', svi: 'length',
+  lvw: 'length', lvh: 'length', lvmin: 'length', lvmax: 'length',
+  lvb: 'length', lvi: 'length',
+  dvw: 'length', dvh: 'length', dvmin: 'length', dvmax: 'length',
+  dvb: 'length', dvi: 'length',
+  cqw: 'length', cqh: 'length', cqi: 'length', cqb: 'length',
+  cqmin: 'length', cqmax: 'length',
+
+  // <angle>
+  deg: 'angle', grad: 'angle', rad: 'angle', turn: 'angle',
+
+  // <time>
+  s: 'time', ms: 'time',
+
+  // <frequency>
+  hz: 'frequency', khz: 'frequency',
+
+  // <resolution>
+  dpi: 'resolution', dpcm: 'resolution', dppx: 'resolution', x: 'resolution',
+
+  // <flex>
+  fr: 'flex',
+
+  // <percentage>
+  '%': 'percentage',
+};
+
+export function baseOf(unit: string): BaseType | null {
+  return UNIT_TO_BASE[unit.toLowerCase()] ?? null;
+}
+
+/** Pure number type. */
+export function numberType(): CalcType {
+  return new Map();
+}
+
+/**
+ * Type of a single dimension with the given unit.
+ * Returns null for unknown units (caller decides how to handle).
+ */
+export function dimensionType(unit: string): CalcType | null {
+  const base = baseOf(unit);
+  if (!base) {
+    return null;
+  }
+  return new Map([[base, 1]]);
+}
+
+export function isNumber(t: CalcType): boolean {
+  return t.size === 0;
+}
+
+export function typesEqual(a: CalcType, b: CalcType): boolean {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const [k, v] of a) {
+    if (b.get(k) !== v) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/** Multiply types: component-wise sum of exponents, dropping zeros. */
+export function typeMul(a: CalcType, b: CalcType): CalcType {
+  const out: CalcType = new Map(a);
+  for (const [k, v] of b) {
+    const next = (out.get(k) ?? 0) + v;
+    if (next === 0) {
+      out.delete(k);
+    } else {
+      out.set(k, next);
+    }
+  }
+  return out;
+}
+
+/** Divide types: component-wise subtraction, dropping zeros. */
+export function typeDiv(a: CalcType, b: CalcType): CalcType {
+  const out: CalcType = new Map(a);
+  for (const [k, v] of b) {
+    const next = (out.get(k) ?? 0) - v;
+    if (next === 0) {
+      out.delete(k);
+    } else {
+      out.set(k, next);
+    }
+  }
+  return out;
+}
+
+/** Human-readable type for error messages. */
+export function formatType(t: CalcType): string {
+  if (t.size === 0) {
+    return '<number>';
+  }
+  const parts: string[] = [];
+  for (const [k, v] of t) {
+    parts.push(v === 1 ? `<${k}>` : `<${k}>^${v}`);
+  }
+  return parts.join(' * ');
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 6fd9024..9d50f8b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -33,12 +33,171 @@ importers:
       prettier:
         specifier: ^3.5.3
         version: 3.5.3
+      tsx:
+        specifier: ^4.21.0
+        version: 4.21.0
       typescript:
         specifier: ~5.8.3
         version: 5.8.3
 
 packages:
 
+  '@esbuild/aix-ppc64@0.27.7':
+    resolution: {integrity: sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.27.7':
+    resolution: {integrity: sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.27.7':
+    resolution: {integrity: sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.27.7':
+    resolution: {integrity: sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.27.7':
+    resolution: {integrity: sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.27.7':
+    resolution: {integrity: sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.27.7':
+    resolution: {integrity: sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.27.7':
+    resolution: {integrity: sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.27.7':
+    resolution: {integrity: sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.27.7':
+    resolution: {integrity: sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.27.7':
+    resolution: {integrity: sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.27.7':
+    resolution: {integrity: sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.27.7':
+    resolution: {integrity: sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.27.7':
+    resolution: {integrity: sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.27.7':
+    resolution: {integrity: sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.27.7':
+    resolution: {integrity: sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.27.7':
+    resolution: {integrity: sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.27.7':
+    resolution: {integrity: sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.27.7':
+    resolution: {integrity: sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.27.7':
+    resolution: {integrity: sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.27.7':
+    resolution: {integrity: sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.27.7':
+    resolution: {integrity: sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.27.7':
+    resolution: {integrity: sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.27.7':
+    resolution: {integrity: sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.27.7':
+    resolution: {integrity: sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.27.7':
+    resolution: {integrity: sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
   '@eslint-community/eslint-utils@4.4.1':
     resolution: {integrity: sha512-s3O3waFUrMV8P/XaF/+ZTp1X9XBZW1a4B97ZnjQF2KYWaFD2A8KyFBsrsfSjEmjn3RGWAIuvlneuZm3CUK3jbA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -251,6 +410,11 @@ packages:
   deep-is@0.1.4:
     resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
 
+  esbuild@0.27.7:
+    resolution: {integrity: sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==}
+    engines: {node: '>=18'}
+    hasBin: true
+
   escape-string-regexp@1.0.5:
     resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==}
     engines: {node: '>=0.8.0'}
@@ -343,6 +507,11 @@ packages:
   flatted@3.3.2:
     resolution: {integrity: sha512-AiwGJM8YcNOaobumgtng+6NHuOqC3A7MixFeDafM3X9cIUM+xUXoS5Vfgf+OihAYe20fxqNM9yPBXJzRtZ/4eA==}
 
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
   get-caller-file@1.0.3:
     resolution: {integrity: sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==}
 
@@ -350,6 +519,9 @@ packages:
     resolution: {integrity: sha512-GlhdIUuVakc8SJ6kK0zAFbiGzRFzNnY4jUuEbV9UROo4Y+0Ny4fjvcZFVTeDA4odpFyOQzaw6hXukJSq/f28sQ==}
     engines: {node: '>=4'}
 
+  get-tsconfig@4.14.0:
+    resolution: {integrity: sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA==}
+
   glob-parent@6.0.2:
     resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
     engines: {node: '>=10.13.0'}
@@ -579,6 +751,9 @@ packages:
     resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
     engines: {node: '>=4'}
 
+  resolve-pkg-maps@1.0.0:
+    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
+
   set-blocking@2.0.0:
     resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
 
@@ -641,6 +816,11 @@ packages:
     resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
     engines: {node: '>=8'}
 
+  tsx@4.21.0:
+    resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
   type-check@0.4.0:
     resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
     engines: {node: '>= 0.8.0'}
@@ -697,6 +877,84 @@ packages:
 
 snapshots:
 
+  '@esbuild/aix-ppc64@0.27.7':
+    optional: true
+
+  '@esbuild/android-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/android-arm@0.27.7':
+    optional: true
+
+  '@esbuild/android-x64@0.27.7':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/darwin-x64@0.27.7':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-arm@0.27.7':
+    optional: true
+
+  '@esbuild/linux-ia32@0.27.7':
+    optional: true
+
+  '@esbuild/linux-loong64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.27.7':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-s390x@0.27.7':
+    optional: true
+
+  '@esbuild/linux-x64@0.27.7':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.27.7':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.27.7':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/sunos-x64@0.27.7':
+    optional: true
+
+  '@esbuild/win32-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/win32-ia32@0.27.7':
+    optional: true
+
+  '@esbuild/win32-x64@0.27.7':
+    optional: true
+
   '@eslint-community/eslint-utils@4.4.1(eslint@9.25.1)':
     dependencies:
       eslint: 9.25.1
@@ -890,6 +1148,35 @@ snapshots:
 
   deep-is@0.1.4: {}
 
+  esbuild@0.27.7:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.27.7
+      '@esbuild/android-arm': 0.27.7
+      '@esbuild/android-arm64': 0.27.7
+      '@esbuild/android-x64': 0.27.7
+      '@esbuild/darwin-arm64': 0.27.7
+      '@esbuild/darwin-x64': 0.27.7
+      '@esbuild/freebsd-arm64': 0.27.7
+      '@esbuild/freebsd-x64': 0.27.7
+      '@esbuild/linux-arm': 0.27.7
+      '@esbuild/linux-arm64': 0.27.7
+      '@esbuild/linux-ia32': 0.27.7
+      '@esbuild/linux-loong64': 0.27.7
+      '@esbuild/linux-mips64el': 0.27.7
+      '@esbuild/linux-ppc64': 0.27.7
+      '@esbuild/linux-riscv64': 0.27.7
+      '@esbuild/linux-s390x': 0.27.7
+      '@esbuild/linux-x64': 0.27.7
+      '@esbuild/netbsd-arm64': 0.27.7
+      '@esbuild/netbsd-x64': 0.27.7
+      '@esbuild/openbsd-arm64': 0.27.7
+      '@esbuild/openbsd-x64': 0.27.7
+      '@esbuild/openharmony-arm64': 0.27.7
+      '@esbuild/sunos-x64': 0.27.7
+      '@esbuild/win32-arm64': 0.27.7
+      '@esbuild/win32-ia32': 0.27.7
+      '@esbuild/win32-x64': 0.27.7
+
   escape-string-regexp@1.0.5: {}
 
   escape-string-regexp@4.0.0: {}
@@ -1003,10 +1290,17 @@ snapshots:
 
   flatted@3.3.2: {}
 
+  fsevents@2.3.3:
+    optional: true
+
   get-caller-file@1.0.3: {}
 
   get-stream@3.0.0: {}
 
+  get-tsconfig@4.14.0:
+    dependencies:
+      resolve-pkg-maps: 1.0.0
+
   glob-parent@6.0.2:
     dependencies:
       is-glob: 4.0.3
@@ -1193,6 +1487,8 @@ snapshots:
 
   resolve-from@4.0.0: {}
 
+  resolve-pkg-maps@1.0.0: {}
+
   set-blocking@2.0.0: {}
 
   shebang-command@1.2.0:
@@ -1244,6 +1540,13 @@ snapshots:
     dependencies:
       has-flag: 4.0.0
 
+  tsx@4.21.0:
+    dependencies:
+      esbuild: 0.27.7
+      get-tsconfig: 4.14.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
   type-check@0.4.0:
     dependencies:
       prelude-ls: 1.2.1