Meme lang composition: lossless pipeline with Pratt parser.

Pipeline: scanner → trivia-attacher → pratt-parser → cst-reader
The Pratt parser produces a lossless CST; the CST reader lowers it
to Clojure forms.

CST reader: walks CST nodes from the Pratt parser and produces Clojure forms.

This is the lowering step: CST → Clojure forms. It mirrors the classic
parser's output (same forms, same metadata, same AST node types) but
reads from a lossless tree instead of a token stream.

Pipeline: scanner → trivia-attacher → pratt-parser → **cst-reader**

Consistent error infrastructure for the meme reader/tokenizer.
All error throw sites should use `meme-error` to ensure uniform
location tracking and message formatting.

Syntax-quote expansion: MemeSyntaxQuote AST nodes → plain Clojure forms.
Called by runtime paths (run, repl) before eval. Not needed for tooling
(tooling works with AST nodes directly).

Canonical formatter: width-aware meme output.
Composes printer (form → Doc) with render (layout @ target width).
Used by `meme format` CLI command.

Flat formatter: single-line meme output.
Composes printer (form → Doc) with render (layout @ infinite width).

Shared form-level predicates and constructors.
Cross-stage contracts that both the parser and printer depend on.

Meme language grammar spec.

Maps characters to scanlets — the complete syntactic specification
of M-expression syntax as data. Lexlets provide the scanning layer,
parselets provide the compound constructs, and the parser engine
provides generic factories.

Meme lexical scanlets: character predicates, consume helpers,
and trivia consumers.

This file provides the lexical layer for the meme language. The grammar
spec in meme-grammar references these functions by name.
Generic scanlet builders (atom-scanlet, single-char-scanlet, delimited-scanlet)
live in meme.tools.lexer.

Meme-specific parselets for the Pratt parser.

Contains the compound parselets that handle meme's unique constructs:
call adjacency detection, dispatch (#) sub-routing, tilde (~/@),
and the M-expression call rule.

Meme printer: Clojure forms → Doc trees.
Builds Wadler-Lindig Doc trees from Clojure forms, handling meme syntax
(call notation, sugar, metadata, comments) and Clojure output mode.
Delegates to render for Doc algebra and layout.

Meme-specific REPL. Wires meme stages, error formatting, keyword resolution,
and syntax-quote resolution into the generic REPL infrastructure.
JVM/Babashka only.

Value resolution: converts raw token text to Clojure values.
All resolution is native — no delegation to read-string.

Meme-specific eval pipeline. Wires meme stages, syntax-quote resolution,
and BOM stripping into the generic run infrastructure.
JVM/Babashka only.

Composable pipeline stages for the lossless reader.

Pipeline: step-parse → step-read

Each stage is a ctx → ctx function operating on a shared context map:

| Key          | Type           | Written by  | Read by          |
|--------------|----------------|-------------|------------------|
| :source      | String         | caller      | parse            |
| :opts        | Map or nil     | caller      | parse, read      |
| :cst         | Vector         | parse       | read, (tooling)  |
| :forms       | Vector         | read        | caller           |

Stages are independent. Compose in any order respecting dependencies.
Skip step-read for tooling that works with CST directly.

Shared value → string serialization for the printer and rewrite emitter.
Handles atomic Clojure values (strings, numbers, chars, regex, etc.)
that both emit paths must render identically.