CLI reference

Install with brew install reearth/tap/ezu, or any of the other routes in install. Every command below also accepts --verbose for per-node evaluator logs.

ezu

Render Ezu Style documents to PNG

Usage: ezu [OPTIONS] <COMMAND>

Commands:
  tile       Render a single z/x/y tile to PNG
  bbox       Render the tile mosaic covering a lon/lat bounding box at a fixed zoom
  frame      Render a map at a print scale and paper size, cropped to that frame
  tiles      Bulk-render an XYZ tile pyramid into `<out>/<z>/<x>/<y>.png`
  check      Validate an Ezu Style document without rendering — exits non-zero on parse / graph / asset errors. Suitable for CI + pre-commit hooks
  graph      Emit a Mermaid `graph LR` diagram of the style's node dependencies — or, with `--tile`, an HTML page of the same graph with each node's own intermediate tile drawn on it
  legend     Emit the style's declared legend as JSON, for a host to lay out beside the map
  translate  Translate a map-engine style (MapLibre GL) into an ezu recipe
  serve      Start the live editor + tile server at `http://127.0.0.1:8080`
  schema     Print the Ezu Style JSON Schema, gathered from the registered ops
  help       Print this message or the help of the given subcommand(s)

Options:
  -v, --verbose  Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
  -h, --help     Print help
  -V, --version  Print version

ezu tile

Render a single z/x/y tile to PNG

Usage: ezu tile [OPTIONS] --style <STYLE> --tile <TILE>

Options:
      --style <STYLE>
          Ezu Style JSON document — local path or http(s):// URL
  -v, --verbose
          Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
      --assets-dir <ASSETS_DIR>
          Base directory for resolving asset `src` paths. Defaults to the style file's parent directory (or the current directory when `--style` is a URL)
      --pmtiles <PMTILES>
          PMTiles archive — local path or http(s):// URL. Stands in for the first `mvt`/`pmtiles` source the style declares; any others keep their own URLs
      --mvt <MVT>
          Templated MVT tile source containing `{z}`, `{x}`, `{y}` placeholders. Accepts an http(s):// URL or a local path template (e.g. `/tiles/{z}/{x}/{y}.pbf`). Stands in for the first `mvt`/`pmtiles` source the style declares; any others keep their own URLs
      --overzoom-levels <OVERZOOM_LEVELS>
          When a requested tile is missing, fall back to a parent tile up to this many zoom levels up and re-project its geometry onto the requested tile (MVT "overzoom"). `0` disables. A source past its declared `max-zoom` overzooms from that zoom regardless [default: 4]
      --param <NAME=VALUE>
          Override a document parameter, as `name=value` (repeatable). Values are validated against the style's `params` declarations: numbers respect `min`/`max`, colors are `#rrggbb[aa]`, bools are `true`/`false`, strings one of their `enum` when they declare one
      --strict
          Refuse to render a style that raises build warnings — an unnamed `source`, a `$param` baked in at build time. For CI, where a warning is a style that will surprise someone later
      --pad <PAD>
          Margin rendered around each tile before it is cropped, in pixels, in place of the style's `pad` raised to what its filters reach. Narrower than that reach, a tile's edge is computed from clamped data and seams against its neighbour
      --tile-size <TILE_SIZE>
          Render each tile this many pixels square instead of at the style's `tile-size`, covering the same ground. The style's own pixel sizes (line widths, text, `pad`) are not scaled with it, so they draw finer; for a hi-DPI tile of the same map use `--pixel-ratio`
      --pixel-ratio <PIXEL_RATIO>
          Device pixels per style pixel, from 1 to 4 (fractions allowed): `2` renders a retina tile, twice the tile size with every line width, text size, blur and `pad` doubled, as MapLibre's `@2x` tiles are
      --tile <TILE>
          Tile coordinate as `Z/X/Y`
      --out <OUT>
          Output path. Format is sniffed from the extension (`.png` / `.webp` / `.rgba`); use `--format` to override [default: out.png]
      --format <FORMAT>
          Output format. Defaults to whatever `--out`'s extension implies. `rgba` is straight (un-premultiplied) 8-bit RGBA, row-major from the top-left, with no header, as the embedding renderer returns it: tile size × tile size × 4 bytes, the size being `--tile-size` or the style's, which the file does not record [possible values: png, webp, rgba]
      --png-compression <PNG_COMPRESSION>
          Effort the PNG encoder spends: `fast` writes larger files sooner, `best` the smallest at two to four times the encoding time. The pixels are the same at every level. Other formats ignore it [default: default] [possible values: fast, default, best]
      --features <NODE=PATH>
          Write the features node NODE, as the tile's render held it, as a GeoJSON FeatureCollection at PATH: the collection the embedding packages' `renderTileWithFeatures` returns, with the node's id as `node` and the tile's size in its units as `extent`. Repeatable. `--features-key` belongs to `bbox` and `frame`, where neighbouring tiles each hold a copy of a feature they share; one tile's value is written as it is
      --features-coords <FEATURES_COORDS>
          Coordinates of the `--features` files: `tile`, the node's own units (whole numbers, `0..extent` across the tile, y down); `lonlat` (WGS84, 7 decimals); or `px`, pixels of the tile from its top-left corner, y down (2 decimals) [default: tile] [possible values: tile, lonlat, px]
  -h, --help
          Print help

ezu bbox

Render the tile mosaic covering a lon/lat bounding box at a fixed zoom

Usage: ezu bbox [OPTIONS] --style <STYLE> --bbox <BBOX> --zoom <ZOOM>

Options:
      --style <STYLE>
          Ezu Style JSON document — local path or http(s):// URL
  -v, --verbose
          Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
      --assets-dir <ASSETS_DIR>
          Base directory for resolving asset `src` paths. Defaults to the style file's parent directory (or the current directory when `--style` is a URL)
      --pmtiles <PMTILES>
          PMTiles archive — local path or http(s):// URL. Stands in for the first `mvt`/`pmtiles` source the style declares; any others keep their own URLs
      --mvt <MVT>
          Templated MVT tile source containing `{z}`, `{x}`, `{y}` placeholders. Accepts an http(s):// URL or a local path template (e.g. `/tiles/{z}/{x}/{y}.pbf`). Stands in for the first `mvt`/`pmtiles` source the style declares; any others keep their own URLs
      --overzoom-levels <OVERZOOM_LEVELS>
          When a requested tile is missing, fall back to a parent tile up to this many zoom levels up and re-project its geometry onto the requested tile (MVT "overzoom"). `0` disables. A source past its declared `max-zoom` overzooms from that zoom regardless [default: 4]
      --param <NAME=VALUE>
          Override a document parameter, as `name=value` (repeatable). Values are validated against the style's `params` declarations: numbers respect `min`/`max`, colors are `#rrggbb[aa]`, bools are `true`/`false`, strings one of their `enum` when they declare one
      --strict
          Refuse to render a style that raises build warnings — an unnamed `source`, a `$param` baked in at build time. For CI, where a warning is a style that will surprise someone later
      --pad <PAD>
          Margin rendered around each tile before it is cropped, in pixels, in place of the style's `pad` raised to what its filters reach. Narrower than that reach, a tile's edge is computed from clamped data and seams against its neighbour
      --tile-size <TILE_SIZE>
          Render each tile this many pixels square instead of at the style's `tile-size`, covering the same ground. The style's own pixel sizes (line widths, text, `pad`) are not scaled with it, so they draw finer; for a hi-DPI tile of the same map use `--pixel-ratio`
      --pixel-ratio <PIXEL_RATIO>
          Device pixels per style pixel, from 1 to 4 (fractions allowed): `2` renders a retina tile, twice the tile size with every line width, text size, blur and `pad` doubled, as MapLibre's `@2x` tiles are
      --bbox <BBOX>
          Bounding box `min_lng,min_lat,max_lng,max_lat` (WGS84)
      --zoom <ZOOM>
          Zoom level
      --out <OUT>
          Output path. Format is sniffed from the extension (`.png` / `.webp` / `.rgba`); use `--format` to override [default: out.png]
      --format <FORMAT>
          Output format. Defaults to whatever `--out`'s extension implies. `rgba` is straight (un-premultiplied) 8-bit RGBA, row-major from the top-left, with no header: width × height × 4 bytes, each side the tiles across it times the tile size, which the file does not record (the log line naming the tiles covered does) [possible values: png, webp, rgba]
      --png-compression <PNG_COMPRESSION>
          Effort the PNG encoder spends: `fast` writes larger files sooner, `best` the smallest at two to four times the encoding time. The pixels are the same at every level. Other formats ignore it [default: default] [possible values: fast, default, best]
      --concurrency <CONCURRENCY>
          Number of tiles rendered in parallel. Defaults to the number of logical CPU cores
      --features <NODE=PATH>
          Write the features node NODE, gathered over every tile of the mosaic, as a GeoJSON FeatureCollection at PATH, the way `frame` writes a page's. Features whose bounding box lies wholly outside the mosaic are left out; the rest are written whole. Without `--features-key`, a feature several tiles see is written once per tile, and a shape cut at tile edges as its pieces. Repeatable
      --features-key <NODE=PROP[,PROP...]>
          Treat features of NODE whose listed properties are all equal as one feature, keeping the first in tile order (rows top to bottom, then left to right), and sort the file by those properties. For `label-boxes`: `--features-key boxes=label-id,part`. Repeatable, once per node
      --features-coords <FEATURES_COORDS>
          Coordinates of the `--features` files: `lonlat` (WGS84, 7 decimals) or `px`, pixels of the mosaic from its top-left corner, y down (2 decimals) [default: lonlat] [possible values: lonlat, px]
  -h, --help
          Print help

ezu frame

Render a map at a print scale and paper size, cropped to that frame

Usage: ezu frame [OPTIONS] --style <STYLE>

Options:
      --style <STYLE>
          Ezu Style JSON document — local path or http(s):// URL
  -v, --verbose
          Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
      --assets-dir <ASSETS_DIR>
          Base directory for resolving asset `src` paths. Defaults to the style file's parent directory (or the current directory when `--style` is a URL)
      --pmtiles <PMTILES>
          PMTiles archive — local path or http(s):// URL. Stands in for the first `mvt`/`pmtiles` source the style declares; any others keep their own URLs
      --mvt <MVT>
          Templated MVT tile source containing `{z}`, `{x}`, `{y}` placeholders. Accepts an http(s):// URL or a local path template (e.g. `/tiles/{z}/{x}/{y}.pbf`). Stands in for the first `mvt`/`pmtiles` source the style declares; any others keep their own URLs
      --overzoom-levels <OVERZOOM_LEVELS>
          When a requested tile is missing, fall back to a parent tile up to this many zoom levels up and re-project its geometry onto the requested tile (MVT "overzoom"). `0` disables. A source past its declared `max-zoom` overzooms from that zoom regardless [default: 4]
      --param <NAME=VALUE>
          Override a document parameter, as `name=value` (repeatable). Values are validated against the style's `params` declarations: numbers respect `min`/`max`, colors are `#rrggbb[aa]`, bools are `true`/`false`, strings one of their `enum` when they declare one
      --strict
          Refuse to render a style that raises build warnings — an unnamed `source`, a `$param` baked in at build time. For CI, where a warning is a style that will surprise someone later
      --pad <PAD>
          Margin rendered around each tile before it is cropped, in pixels, in place of the style's `pad` raised to what its filters reach. Narrower than that reach, a tile's edge is computed from clamped data and seams against its neighbour
      --pages <PATH>
          Render every page a JSON file lists, in place of the one page the flags below describe. Each page takes the fields `center`, `scale`, `dpi`, `size-mm` or `size-px`, `zoom`, `out`, `format`, `features-coords` and `features` (`{NODE: {"out": PATH, "key": [PROP, ...]}}`), any of them but `out` from a `defaults` object. `center`, `size-mm` and `size-px` take an array (`[139.7, 35.66]`, `[245, 174]`) or the string their flag takes (`"139.7,35.66"`, `"245x174"`). The style is read once, and pages over the same tiles fetch them once
      --center <CENTER>
          Centre of the frame as `lng,lat` (WGS84). The scale is matched at this latitude
      --scale <SCALE>
          Scale denominator: `1000` for 1:1000
      --dpi <DPI>
          Output resolution in dots per inch. Always required: with the scale it fixes how many ground metres one pixel covers. It does not enlarge the style's own pixel sizes (line widths, text)
      --size-mm <SIZE_MM>
          Paper size as `WIDTHxHEIGHT` in millimetres, converted to pixels at `--dpi`
      --size-px <SIZE_PX>
          Output size as `WIDTHxHEIGHT` in pixels, in place of `--size-mm`
      --zoom <ZOOM>
          Render at this zoom, deriving the tile size from it. By default the zoom is the one whose tile size comes nearest the style's `tile-size`. This is how a frame's tile size is chosen: the scale fixes it for each zoom, so `frame` takes no `--tile-size`
      --out <OUT>
          Output path. Format is sniffed from the extension (`.png` / `.webp` / `.rgba`); use `--format` to override [default: out.png]
      --format <FORMAT>
          Output format. Defaults to whatever `--out`'s extension implies. `rgba` is straight (un-premultiplied) 8-bit RGBA, row-major from the top-left, with no header: width × height × 4 bytes of the page as `--size-px` or `--size-mm` sized it, which the file does not record [possible values: png, webp, rgba]
      --png-compression <PNG_COMPRESSION>
          Effort the PNG encoder spends: `fast` writes larger files sooner, `best` the smallest at two to four times the encoding time. The pixels are the same at every level. Other formats ignore it [default: default] [possible values: fast, default, best]
      --concurrency <CONCURRENCY>
          Number of tiles rendered in parallel. Defaults to the number of logical CPU cores
      --features <NODE=PATH>
          Write the features node NODE, gathered over every tile the frame renders, as a GeoJSON FeatureCollection at PATH. Features whose bounding box lies wholly outside the frame are left out; the rest are written whole, not clipped. Without `--features-key`, a feature several tiles see is written once per tile, and a shape cut at tile edges as its pieces. Repeatable
      --features-key <NODE=PROP[,PROP...]>
          Treat features of NODE whose listed properties are all equal as one feature, keeping the first in tile order (rows top to bottom, then left to right), and sort the file by those properties. For `label-boxes`: `--features-key boxes=label-id,part`. Repeatable, once per node
      --features-coords <FEATURES_COORDS>
          Coordinates of the `--features` files: `lonlat` (WGS84, 7 decimals) or `px`, pixels of the output image from its top-left corner, y down (2 decimals) [default: lonlat] [possible values: lonlat, px]
  -h, --help
          Print help

ezu tiles

Bulk-render an XYZ tile pyramid into `<out>/<z>/<x>/<y>.png`

Usage: ezu tiles [OPTIONS] --style <STYLE> --min-zoom <MIN_ZOOM> --max-zoom <MAX_ZOOM>

Options:
      --style <STYLE>
          Ezu Style JSON document — local path or http(s):// URL
  -v, --verbose
          Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
      --assets-dir <ASSETS_DIR>
          Base directory for resolving asset `src` paths. Defaults to the style file's parent directory (or the current directory when `--style` is a URL)
      --pmtiles <PMTILES>
          PMTiles archive — local path or http(s):// URL. Stands in for the first `mvt`/`pmtiles` source the style declares; any others keep their own URLs
      --mvt <MVT>
          Templated MVT tile source containing `{z}`, `{x}`, `{y}` placeholders. Accepts an http(s):// URL or a local path template (e.g. `/tiles/{z}/{x}/{y}.pbf`). Stands in for the first `mvt`/`pmtiles` source the style declares; any others keep their own URLs
      --overzoom-levels <OVERZOOM_LEVELS>
          When a requested tile is missing, fall back to a parent tile up to this many zoom levels up and re-project its geometry onto the requested tile (MVT "overzoom"). `0` disables. A source past its declared `max-zoom` overzooms from that zoom regardless [default: 4]
      --param <NAME=VALUE>
          Override a document parameter, as `name=value` (repeatable). Values are validated against the style's `params` declarations: numbers respect `min`/`max`, colors are `#rrggbb[aa]`, bools are `true`/`false`, strings one of their `enum` when they declare one
      --strict
          Refuse to render a style that raises build warnings — an unnamed `source`, a `$param` baked in at build time. For CI, where a warning is a style that will surprise someone later
      --pad <PAD>
          Margin rendered around each tile before it is cropped, in pixels, in place of the style's `pad` raised to what its filters reach. Narrower than that reach, a tile's edge is computed from clamped data and seams against its neighbour
      --tile-size <TILE_SIZE>
          Render each tile this many pixels square instead of at the style's `tile-size`, covering the same ground. The style's own pixel sizes (line widths, text, `pad`) are not scaled with it, so they draw finer; for a hi-DPI tile of the same map use `--pixel-ratio`
      --pixel-ratio <PIXEL_RATIO>
          Device pixels per style pixel, from 1 to 4 (fractions allowed): `2` renders a retina tile, twice the tile size with every line width, text size, blur and `pad` doubled, as MapLibre's `@2x` tiles are
      --bbox <BBOX>
          Bounding box `min_lng,min_lat,max_lng,max_lat` (WGS84). When omitted, every tile at each zoom is generated — at z=14 that is 268M tiles, so a bbox is strongly recommended
      --min-zoom <MIN_ZOOM>
          Minimum zoom level (inclusive)
      --max-zoom <MAX_ZOOM>
          Maximum zoom level (inclusive)
      --out <OUT>
          Output directory; tiles are written as `<out>/<z>/<x>/<y>.<ext>` (extension picked by `--format`) [default: tiles]
      --format <FORMAT>
          Output format. Defaults to PNG. `rgba` writes `<y>.rgba` files of straight (un-premultiplied) 8-bit RGBA, row-major from the top-left, with no header: tile size × tile size × 4 bytes each, the size being `--tile-size` or the style's, which the files do not record [default: png] [possible values: png, webp, rgba]
      --png-compression <PNG_COMPRESSION>
          Effort the PNG encoder spends: `fast` writes larger files sooner, `best` the smallest at two to four times the encoding time. The pixels are the same at every level. Other formats ignore it [default: default] [possible values: fast, default, best]
      --concurrency <CONCURRENCY>
          Number of tiles rendered in parallel. Defaults to the number of logical CPU cores
  -h, --help
          Print help

ezu check

Validate an Ezu Style document without rendering — exits non-zero on parse / graph / asset errors. Suitable for CI + pre-commit hooks

Usage: ezu check [OPTIONS] <STYLE>

Arguments:
  <STYLE>  Ezu Style JSON document — local path or http(s):// URL

Options:
      --assets-dir <ASSETS_DIR>  Base directory for resolving relative asset `src` paths. Defaults to the style file's parent directory (or the current directory when `--style` is a URL)
  -v, --verbose                  Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
      --no-fetch                 Skip fetching URL assets and reading local asset files — only run parse + `build_graph`. Faster and works offline; misses errors like an unreachable brush URL or a missing image file
      --json                     Write the report to stdout as JSON instead of log lines: name, version, counts, padding, attribution, and the style's params schema. Logs move to stderr so the stream stays parseable
      --strict                   Exit non-zero when the style raises build warnings, not just on errors. For CI, where a warning is a style that will surprise someone later
  -h, --help                     Print help

ezu graph

Emit a Mermaid `graph LR` diagram of the style's node dependencies — or, with `--tile`, an HTML page of the same graph with each node's own intermediate tile drawn on it

Usage: ezu graph [OPTIONS] <STYLE>

Arguments:
  <STYLE>  Ezu Style JSON document — local path or http(s):// URL

Options:
      --out <OUT>
          Output file. Writes to stdout when omitted
  -v, --verbose
          Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
      --tile <TILE>
          Render this tile as `Z/X/Y` and draw each node's own intermediate result onto the diagram. Switches the output from Mermaid to a self-contained HTML viewer; `--out` is required
      --assets-dir <ASSETS_DIR>
          Base directory for resolving asset `src` paths. Defaults to the style file's parent directory (or the current directory when the style is a URL)
      --pmtiles <PMTILES>
          PMTiles archive — local path or http(s):// URL
      --mvt <MVT>
          Templated MVT tile source containing `{z}`, `{x}`, `{y}`
      --overzoom-levels <OVERZOOM_LEVELS>
          Overzoom fallback depth for a missing tile, as in `ezu tile` [default: 4]
      --param <NAME=VALUE>
          Override a document parameter, as `name=value` (repeatable)
      --image-size <IMAGE_SIZE>
          Long edge of each embedded node image, in pixels. `0` embeds them at the style's own tile size — sharper, and a much larger file on a graph of any size [default: 256]
      --sidecar
          Write the node images as PNG files beside the HTML (in `<out>.assets/`) instead of embedding them. Keeps the page small; pair with `--image-size 0` for full-size pictures
      --png-compression <PNG_COMPRESSION>
          Effort the PNG encoder spends on the node images. `fast` by default here, unlike the render commands: there is one image per node, and they are for looking at. The pixels are the same at every level [default: fast] [possible values: fast, default, best]
  -h, --help
          Print help

ezu legend

Emit the style's declared legend as JSON, for a host to lay out beside the map

Usage: ezu legend [OPTIONS] <STYLE>

Arguments:
  <STYLE>  Ezu Style JSON document — local path or http(s):// URL

Options:
  -v, --verbose
          Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
      --zoom <ZOOM>
          Keep only the entries that apply at this zoom. Also the zoom the swatches are drawn at, since a symbol may change with scale
      --out <OUT>
          Output file. Writes to stdout when omitted
      --pretty
          Pretty-print the emitted JSON
      --swatch-dir <SWATCH_DIR>
          Draw each entry's symbol into this directory as a PNG, and add its path to that entry in the emitted JSON
      --swatch-size <SWATCH_SIZE>
          Swatch size as `WIDTHxHEIGHT` (or one number for a square) [default: 48x32]
      --assets-dir <ASSETS_DIR>
          Base directory for resolving relative asset `src` paths, for swatches whose symbol needs a brush, font or sprite
      --png-compression <PNG_COMPRESSION>
          Effort the PNG encoder spends: `fast` writes larger files sooner, `best` the smallest at two to four times the encoding time. The pixels are the same at every level. Other formats ignore it [default: default] [possible values: fast, default, best]
  -h, --help
          Print help

ezu translate

Translate a map-engine style (MapLibre GL) into an ezu recipe

Usage: ezu translate [OPTIONS] <STYLE>

Arguments:
  <STYLE>  Source map-engine style (MapLibre GL JSON) — local path or http(s):// URL

Options:
      --out <OUT>              Output file for the ezu recipe. Writes to stdout when omitted
  -v, --verbose                Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
      --tile-size <TILE_SIZE>  Emitted `tile-size` (MapLibre uses 512) [default: 512]
      --pad <PAD>              Emitted `pad` — the margin for geometry painted wider than its own extent (a thick stroke) before the crop. Filter reach (blur, warp, mosaic, label extent) is sized by the renderer from the graph, so this is only about paint width, which an expression can decide per feature. The default covers a typical basemap's line widths [default: 16]
      --keep-hidden            Keep `visibility: none` layers in the recipe, gated off behind a `switch` (instead of dropping them)
      --migrate                Migrate the style's legacy forms to expressions first (legacy filters, `{stops}` function objects, `{token}` label strings, non-standard `hsl()` colours), as MapLibre's own `migrate` does. Without it a legacy form is passed through untouched, with a warning naming it. Requires a `version: 8` style
      --font <NAME=SOURCE>     Map a MapLibre fontstack entry to a font source, as `NAME=SOURCE` (repeatable). SOURCE is an installed-font reference (`system:Helvetica`, optionally `?weight=700&style=italic`) or a font-file URL (`http(s)://…`, `file:…`, `data:…`) — e.g. `--font "Noto Sans Regular=system:Noto Sans"` or `--font "Noto Sans Regular=https://example.com/NotoSans-Regular.ttf"`. Optional: unmapped `text-font` stacks fall back to the style's `glyphs` endpoint (SDF glyph ranges); a mapping wins where present and renders from the real font
      --pretty                 Pretty-print the emitted JSON
  -h, --help                   Print help

ezu serve

Start the live editor + tile server at `http://127.0.0.1:8080`

Usage: ezu serve [OPTIONS] [STYLE]

Arguments:
  [STYLE]  Initial Ezu Style document — local path or http(s):// URL. Accepts either a positional argument (`ezu serve foo.json`) or `--style`. Positional wins when both are given

Options:
      --pmtiles <PMTILES>
          PMTiles archive — local path or http(s):// URL [env: EZU_PMTILES_URL=]
  -v, --verbose
          Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
      --mvt <MVT>
          Templated MVT tile source (URL or path) containing `{z}`, `{x}`, `{y}` placeholders; or a `.json` TileJSON document [env: EZU_MVT_URL=]
      --style <STYLE_FLAG>
          Same as the positional `STYLE` argument; kept for back-compat and so `EZU_STYLE` still works [env: EZU_STYLE=] [default: crates/ezu/examples/styles/watercolor.json]
      --assets-dir <ASSETS_DIR>
          Base directory for resolving asset `src` paths (brushes, images). Defaults to the style file's parent directory (or the current directory when the style is a URL) [env: EZU_ASSETS=]
      --bind <BIND>
          Bind address [env: EZU_BIND=] [default: 127.0.0.1:8080]
      --overzoom-levels <OVERZOOM_LEVELS>
          When a requested tile is missing, fall back to a parent tile up to this many zoom levels up and re-project its geometry onto the requested tile (MVT "overzoom"). `0` disables [default: 4]
      --tile-size <TILE_SIZE>
          Render each tile this many pixels square instead of at the style's `tile-size`. The style's own pixel sizes (line widths, text, `pad`) are not scaled with it, so they draw finer
      --pixel-ratio <PIXEL_RATIO>
          Device pixels per style pixel for a tile requested without `@Nx`, from 1 to 4. A request asks for its own with `@2x` (up to `@4x`) before the extension: the same map at that density, its line widths, text and blurs scaled with it, as MapLibre's retina tiles
      --pad <PAD>
          Margin rendered around each tile before it is cropped, in pixels, in place of the style's `pad` raised to what its filters reach, for every style the server loads. Narrower than that reach, a tile's edge seams against its neighbour
      --png-compression <PNG_COMPRESSION>
          Effort the PNG encoder spends: `fast` writes larger files sooner, `best` the smallest at two to four times the encoding time. The pixels are the same at every level. Other formats ignore it [default: default] [possible values: fast, default, best]
  -h, --help
          Print help

ezu schema

Print the Ezu Style JSON Schema, gathered from the registered ops

Usage: ezu schema [OPTIONS]

Options:
      --out <OUT>  Write to this path instead of stdout
  -v, --verbose    Emit per-node debug logs from the graph evaluator (op name, cache hit/miss, output shape, eval duration). Overrides `RUST_LOG` for this run
  -h, --help       Print help