AkurAI-Framework / CHANGELOG.md

Latest change a4a1786d2033efcf9c512fc869ab3f45d2bc2c4e - feat(hero): live Three.js 3D hero — glass planes converge into glowing binary by Ólafur Búi Ólafsson

# Changelog

All notable changes to AkurAI-Framework are documented here.
The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Entries below the `## [Unreleased]` heading are maintained by hand during
development; `deploy.sh` cuts them into a versioned, dated section on release.

**Breaking changes** are called out in a `### Breaking` subsection for the version
and mirrored as a migration note in
[`site/content/docs/breaking-changes.md`](site/content/docs/breaking-changes.md).
Pre-1.0, minor versions may include breaking changes.

## [Unreleased]

### Added
- **Live 3D hero** — the landing-page hero is now a real-time Three.js (r185) WebGL
  scene recreating the original illustration: glass HTTP/DB/UI planes converging
  into a glowing single binary cube, with green flow nodes. Uses
  `MeshPhysicalMaterial` transmission/dispersion/iridescence + UnrealBloom + ACES.
  Three.js is vendored locally under `/vendor/three` (no CDN — keeps the
  zero-runtime-dependency promise). Progressive and non-blocking: upgrades the
  static `hero.svg` only when WebGL2 is present, keeps the SVG as fallback, honours
  `prefers-reduced-motion` (static pose), and pauses when scrolled out of view.

## [0.8.1] - 2026-06-26

### Changed
- **AkurAI default dark theme refreshed** — a deeper, more refined navy palette
  derived from akurai-drive: `--bg #060912`, `--panel #0e162b`, `--fg #eef3ff`,
  and a blue→mint accent gradient (`--accent #5b8cff` → `--accent-2 #7af0d0`).

### Docs
- Documented the v0.8.0 named theme system — new **Design System → Themes** page
  (all 17 themes, the base16→token mapping, `/themes.css` + `/themes.json`, the
  switcher, how to adopt it, how to add a theme); `foundations.md` updated.

## [0.8.0] - 2026-06-26

### Added
- **Named multi-theme system** — `crates/css::theme` generates `/themes.css` with
  17 themes (Nord, Claude Code, Catppuccin, Solarized, Gruvbox, Tokyo Night,
  Rosé Pine, Dracula, AkurAI) in dark and light variants, each a
  `:root[data-theme="…"]` block over the existing semantic tokens. Themes are
  [base16](https://github.com/tinted-theming/schemes) schemes mapped to the token
  set once; the mapping is polarity-agnostic, so one rule covers light and dark.
  Registry served at `/themes.json`; a zero-dependency ESM switcher (`theme.js`)
  persists the choice and defaults to the OS `prefers-color-scheme`. Components are
  unchanged — they read the same token names. Pure `std`, generated at request
  time, no build step.

### Docs
- Added the AkurAI-RustAgent agent OS UI contract, covering Hermes-style channels,
  confirmations, questions, edit previews, artifacts, receipts, and the Framework
  component mappings for the dedicated agent workspace.

## [0.7.0] - 2026-06-26

### Added
- **AI chat UI + tool-result component library** — a 1:1 port (in native ESM, no
  React/Tailwind/Zod) of [assistant-ui](https://github.com/assistant-ui/assistant-ui)
  and [assistant-ui/tool-ui](https://github.com/assistant-ui/tool-ui):
  - **Streaming assistant backend** — new `crates/llm` (a plain-HTTP OpenAI-compatible
    `/v1/chat/completions` client with SSE token + tool-call streaming) and a
    `POST /api/assistant` endpoint that proxies a conversation to `AKURAI_LLM_URL`
    and streams `delta`/`tool_call`/`done`/`error` events. Graceful when unconfigured.
  - **Chat primitives** (`site/frontend/ai/chat/`) — Thread, Message, Composer,
    ActionBar as composable native-ESM modules with streaming, auto-scroll, retries,
    Markdown, code, keyboard shortcuts, and feature-detected voice dictation. Demo `/chat`.
  - **Generative-UI runtime** (`site/frontend/ai/runtime/`) — a registry that matches
    a tool payload to a component (`def = {name, category, title, match, render, example}`),
    fails safe to a JSON view, round-trips interaction "receipts", and ships inline
    approvals plus ThreadList / branch / reasoning / suggestions primitives.
  - **Payload schema validator** — new `crates/schema` (a std-only JSON-shape validator).
  - **27 tool-result components** across six categories (Display, Artifacts, Input,
    Progress, Confirmation, Media) — charts (inline SVG), tables, code/diff, forms,
    sliders, approvals, social cards, maps, media, and more. Live gallery at
    `/ai-components`; runtime demo at `/ai-runtime`.
  - Full docs under Docs → AI components, plus a root **`/llms.txt`** map for LLMs.

## [0.6.0] - 2026-06-26

### Added
- **SQL aggregates + GROUP BY** — the SQL engine now supports `COUNT(*)`, `COUNT(col)`, `SUM`, `AVG`, `MIN`, `MAX` and single-column `GROUP BY`, composing with `WHERE`/`ORDER BY`/`LIMIT`. NULL-aware; the parser stays total (malformed aggregates return a parse error, never panic).
- **Email-OTP login** — a passwordless sign-in flow at `/login/otp` alongside the
  existing password form. A request mints a 6-digit code and stores only a
  *salted hash* of it in the embedded B+tree (`data/otp.db`) with a 10-minute TTL
  and a 5-attempt cap; verification is single-use (the code is cleared on
  success) and then issues an ordinary session cookie. Delivery is a pluggable
  seam: the `OtpDeliver` trait is given the `(email, code)` pair, the default
  `LogDeliver` logs/records the code (fully testable offline, no email client
  shipped), and a real sender is injected via `auth::State::open_with_deliver`.
- **User roles** — user records carry a `Role` (`user`/`admin`). `current_user`
  now returns `{username, role}`, and `current_role`/`require_role` gate routes
  (an admin satisfies any required role). Passwordless OTP accounts are created
  with the `user` role (no password hash, so they cannot password-login). Records
  written before roles existed read back as `user`, so the existing demo/password
  user keeps working unchanged; the seeded demo user is now an admin.

## [0.5.0] - 2026-06-26

### Added
- **Static generation + ISR** — a route in `routes.json` may set `"prerender": true`
  (render once, serve cached) and/or `"revalidate": <seconds>` (stale-while-
  revalidate ISR). Rendered HTML is cached in `data/ssg.db` (storage B+tree) and
  regenerated on a background thread after the TTL; prerendered routes are warmed
  on startup. The site's `/welcome` is now SSG/ISR (5 min).
- **Internationalisation** — a new `akurai-i18n` crate loads per-locale message
  catalogs from `backend/locales/<locale>.json`; the template engine gained a
  `{{ t "key" }}` helper (with `{name=…}` interpolation), and the server negotiates
  the locale from `Accept-Language` and injects it into the render context.
- **Error & loading boundaries** (`site/frontend/boundaries.js`) — a top-of-page
  navigation progress bar plus a `withBoundary(el, asyncFn, opts)` helper that
  shows loading UI, renders the result, and surfaces a retryable error boundary on
  failure. Demo at `/boundaries-demo`.

## [0.4.0] - 2026-06-26

### Added
- **Collection relations** — a `relation` field references another collection by
  the target record's id; reads accept `?expand=<field>[,…]` to inline the
  referenced record under `<field>_expanded`. Relation ids are existence-checked
  on write.
- **File uploads** — `POST`/`PATCH` a collection record as `multipart/form-data`:
  file parts are stored in a content-addressed blob store (`data/blobs.db`, new
  `akurai-blobs` crate) and the `file` field becomes `{blob,filename,content_type,
  size}`; `GET …/records/<id>/<field>` streams the bytes back. `akurai-http` gained
  an RFC-7578 `multipart` parser. JSON requests are unchanged (8 MiB body cap).
- **Typed client SDK** — `site/frontend/akurai-client.js` exposes
  `createClient()` which reads `/api/_meta` and returns per-collection
  `list/create/get/update/delete/search` methods, fully JSDoc-typed, no build
  step. Demo at `/client-demo`.

### Changed
- **Landing page refresh** — a two-column hero with a custom isometric
  illustration (layered HTTP/DB/UI planes converging on a single binary) and
  brand-gradient line icons for the feature grid. All artwork is hand-authored
  SVG under `site/frontend/img/` (generated with codex/gpt-5.5), CSS-masked so the
  icons inherit the accent gradient; no raster assets, no external requests.

## [0.3.0] - 2026-06-26

### Added
- **SQL `UPDATE` and `DELETE`** — the parser (`crates/sql`) and executor
  (`crates/sqlexec`) now handle `UPDATE <t> SET <col> = <val>… [WHERE …]` and
  `DELETE FROM <t> [WHERE …]`: matching rows are rewritten in place (type-revalidated
  against the catalog) or removed, changes persist, and `Affected(n)` is returned.
- **CSS engine wired into `serve`/`dev`** — the server scans the project's frontend
  markup with `akurai-css` and serves a `utilities.css` of only the classes you use
  (regenerated live under `akurai dev`). Opt-in and harmless for projects that don't
  use utility classes.
- **Asset pipeline wired in** — static assets are minified and content-hash
  fingerprinted at startup and served with `Cache-Control: …immutable`; the manifest
  is exposed at `/api/_assets`. Plain paths still resolve raw (backward compatible).
- **Admin UI** (`/admin`) — a no-build, native-ESM page that reads `/api/_meta` and
  browses, creates, edits, searches, and deletes records in any collection through
  the auto-API.

## [0.2.0] - 2026-06-26

### Added
- **Auto-generated REST API** — declare collections in `backend/collections.toml`
  and the server mounts CRUD endpoints with no handler code:
  `GET /api/collections` (manifest), and per collection
  `GET|POST /api/collections/<name>/records` + `GET|PATCH|DELETE …/records/<id>`,
  with schema validation and the collection set merged into `/api/_meta`. Backed
  by three new pure-`std` crates: `akurai-toml` (a TOML parser), `akurai-collections`
  (typed records over the storage B+tree), and `akurai-vector` (below). A malformed
  `collections.toml` fails `serve` at startup with file + line; an absent file is a
  no-op (fully backward compatible).
- **Semantic search** — `?search=` over a collection ranks records by embedding
  similarity when `AKURAI_EMBED_URL` (an OpenAI-compatible, plain-HTTP embeddings
  endpoint) is set, and falls back to case-insensitive substring search otherwise.
  Embeddings are computed best-effort on write and stored alongside records;
  `akurai-vector` provides the cosine/top-k math, f32 byte codec, and embedding
  client (HTTPS is rejected — no TLS in `std`).

### Docs
- Split `AGENTS.md` into a slim domain index plus detailed `AGENTS_CRATES.md`,
  `AGENTS_DATA.md`, `AGENTS_FRONTEND.md`, `AGENTS_DEPLOY.md`, `AGENTS_TESTING.md`,
  and `AGENTS_DOCS.md`.
- Added a user-facing **breaking-changes & migration guide**
  (`/docs/breaking-changes`) and made "document every breaking change" a policy.
- Fixed stale status across the site (v0.1.0 versions, binary size, crate table,
  roadmap classification) and filed the remaining-roadmap batch ledger
  (`BATCHES.md`).

## [0.1.0] - 2026-06-26

### Added
- **SQL executor** (new `crates/sqlexec`, pure std) — runs a parsed `akurai-sql`
  AST over the `crates/storage` B+tree. `CREATE TABLE` persists a schema in the
  catalog; `INSERT` validates against it and materializes typed rows under
  auto-increment u64 rowid keys; `SELECT` scans the table, applies `WHERE`,
  projects columns, and honors `ORDER BY`/`LIMIT`. Catalog, rows, and the rowid
  sequence survive reopen. UPDATE/DELETE execution, joins, and indexes deferred.
- **Auth & sessions** (`akurai-cli`) — cookie-based sessions on the storage
  engine: `GET/POST /login`, a protected `/account`, and `POST /logout`.
  Sessions and users persist in B+trees (`data/sessions.db`, `data/users.db`);
  passwords are salted + stretched (std-only); the session cookie is `HttpOnly;
  SameSite=Lax` (TLS terminates at the nginx edge). Seeds a demo user
  (`demo` / `akurai`).
- **SSR islands & hydration** (`site/frontend/islands.js`) — selective client
  hydration over `signals.js`: only `[data-island]` regions become interactive,
  seeded from server-printed state so the first interactive paint equals the SSR
  paint (no flicker, no virtual DOM). `registerIsland(name, setup)` + idempotent
  `hydrate()`. Demo at `/islands`.
- **Live component previews in docs** (`crates/markdown`) — a new ` ```preview `
  fence renders the example markup as a live component inside `.preview-demo` and
  shows the copyable source beneath it; all other fences keep escaped-code
  behavior. The design-system component catalog (`/docs/design-system/components`)
  now renders real components, not just code. (First-party trusted content only.)
- **Copyable curl install widget** (`site/frontend`) — the landing-page hero
  install command now has a Copy button (`navigator.clipboard` with a fallback),
  and `/install.sh` is a real POSIX installer that downloads the latest release
  binary for the host platform and installs it to `~/.local/bin/akurai`.
- **`akurai update`** (`akurai-cli`) — a self-update subcommand (aliases
  `upgrade`, `self-update`). `--check` reports whether a newer release exists;
  without it, the CLI downloads the latest release binary for the host platform
  and atomically replaces the running executable. Network I/O shells out to the
  system `curl` (zero linked deps); the GitHub API response is parsed with the
  project's own `akurai-json`. Uses the same `akurai-<os>-<arch>` asset naming as
  `install.sh`. Requires a public repo + published release (degrades to a clear
  "no release found" message while the repo is private).
- **SQL engine core** (new `crates/sql`, pure std) — a lexer + recursive-descent
  parser turning SQL text into an AST: `SELECT <cols> FROM t [WHERE] [ORDER BY]
  [LIMIT]`, `INSERT INTO t (...) VALUES (...)`, `CREATE TABLE t (...)`; `WHERE`
  with comparisons, `AND`/`OR`/`NOT`, parens, and correct precedence. `parse(sql)
  -> Result<Statement, SqlError>` with positioned errors (no panics). The
  cornerstone of the data engine; an executor over the B+tree is the next slice.
- **Per-route data loaders** (`akurai-cli`) — a route in `routes.json` may name a
  `data` JSON file; the server loads `backend/<file>` (path-traversal-safe) and
  merges it into the render context, so a data-driven page needs no handler code
  (object keys spread at the root, plus the whole document under `data`). Demo at
  `/team`. The declarative step toward server `load` functions.
- **Client-side SPA router** (`site/frontend/spa.js`) — intercepts same-origin
  link clicks, fetches the target, swaps `<main>`, and updates history/scroll,
  using the View Transitions API when available. Pure progressive enhancement
  (links still work with no JS). Demo at `/spa`; emits a `spa:navigated` event.
- **Client reactivity runtime** (`site/frontend/signals.js`) — a tiny native-ESM
  signals + directives library, no build step, no dependencies. `signal()` /
  `effect()` reactive core plus `data-text`/`data-show`/`data-on`/`data-model`/
  `data-for` directives scoped per `[data-scope]`. Live demo at `/reactivity`
  (counter, two-way bind, conditional, list). The first piece of the
  Vue/Svelte-style reactivity gap, done by subtraction.
- **Route layouts** (`akurai-cli`) — a route in `routes.json` may declare an
  optional `layout`; the page template renders first and is composed into the
  shell layout via `{{{ content }}}` (the same pattern the docs use). Backward
  compatible — routes without a layout are byte-for-byte unchanged. Demo at
  `/welcome` (a content page wrapped in a `marketing` shell).
- **Asset pipeline** (new `crates/assets`, pure std) — content-hash
  fingerprinting (`fingerprint`, `hashed_name` → `app.<hash>.css`) and
  conservative, correctness-first CSS/JS minifiers that preserve string/`url()`
  contents. The basis for immutable long-cache static assets.
- Workspace scaffold, `deploy.sh` release engine, `AGENTS.md` index.
- `akurai-http` crate (pure std, zero deps): HTTP/1.1 request-head parser,
  response builder, thread pool, and a blocking thread-pooled `Server`.
- `akurai` CLI binary: `new` bootstraps a project from embedded templates;
  `serve`/`dev` runs a lean static server with `/api/health`, `/api/_meta`,
  SPA fallback, MIME detection, and path-traversal protection.
- Default starter page (client-first, native ESM, no build step) that renders
  and live-pings the server's health endpoint.
- `akurai-json` crate (pure std, zero deps): order-preserving `Value`, a
  recursive-descent parser (string escapes, `\uXXXX` + surrogate pairs,
  int/float kept distinct so IDs round-trip exactly), and a serializer.
- `serve` now builds `/api/health` and `/api/_meta` from real JSON `Value`s
  instead of hand-spun strings.
- `akurai-storage` crate (pure std, zero deps): single-file `Pager` — fixed
  4 KiB pages, read/write/allocate, and `sync` for durability. The storage
  bedrock the B+tree and SQL layers will build on. B+tree node encode/decode added.
- `akurai-storage` crash-safe copy-on-write `BTree`: get/insert/delete/range
  over byte keys, path-copying mutations, leaf+interior node splits, and a
  double-buffered checksummed (FNV-1a) meta page for atomic, WAL-free commits —
  a torn commit recovers the previous tree from the other meta slot. An inline,
  page-capped free list recycles orphaned pages so rewrites don't grow the file.
- `akurai-markdown` crate (pure std, zero deps): Markdown → HTML (headings,
  lists, code blocks, blockquotes, inline code/bold/italic/links).
- **Documentation** — new `/docs` guides under a "Building" section for every
  recently shipped capability: Routing, Forms & actions, Storage, Middleware,
  SEO, and Styling (the CSS engine); the CLI page now covers `akurai dev` +
  live-reload. Closes the principle-#10 gap where features shipped without docs.
- **`/docs/roadmap` page** — an honest status map of shipped vs in-progress vs
  planned capabilities (frontend-platform gaps against Next/Vue/Svelte, and the
  PocketBase-style data engine), grouped under the docs sidebar. Also corrected
  the `/guestbook` lede, which still claimed in-memory storage after durable
  B+tree persistence shipped.
- **HTTP middleware chain** (`akurai-http`) — a `Middleware` trait + ordered
  `MiddlewareStack` run via `Server::run_with` (additive; `run` is unchanged),
  with built-ins: `SecurityHeaders` (nosniff / `X-Frame-Options: DENY` /
  `Referrer-Policy`), `RequestLogger`, and `Timing` (`X-Response-Time-Us`). Now
  active on `serve` — every response is hardened.
- **Atomic CSS engine core** (new `crates/css`) — pure-std, scans `class="…"`
  tokens and emits only the used utility CSS (parametric spacing on a 4px scale,
  flex/display, text, CSS-variable colours). `akurai_css::build(&sources)`. The
  from-scratch, no-Tailwind-dependency engine the no-build frontend will use.
- **SEO essentials** (`akurai-cli`) — `GET /sitemap.xml` (generated from the
  static routes in `routes.json`, param/wildcard routes excluded) and
  `GET /robots.txt`, plus optional per-route `title`/`description` injected into
  `<head>` (OpenGraph too), driven by a `site_url` in `page.json`.
- **Durable storage wired into `serve`** — the embedded B+tree now backs live
  requests. A small `store.rs` appends/lists JSON records on `data/store.db`
  (monotonic u64 keys → insertion order; every append commits, so it's durable
  immediately). The guestbook now **persists to disk** instead of memory — entries
  survive a server restart (and a redeploy). The store opens once and is shared
  behind a mutex (the B+tree is single-writer). This is the seed of the
  per-collection storage the auto-API will grow into.
- **Request bodies + form actions** — the HTTP server now reads request bodies
  (`Content-Length`, 8 MiB cap, bytes already buffered past the head reused),
  exposed as `Request.body` / `body_str()`. A new `akurai_http::form` parses
  `application/x-www-form-urlencoded` (percent-decode, `+`→space). On top: a
  **guestbook** form-actions demo (`/guestbook`) — a plain `<form method="post">`
  the server validates, stores, and redirects back from (Post/Redirect/Get),
  working with JavaScript disabled; user input is HTML-escaped by the template
  engine (verified against an injected `<script>`). Entries are in-memory for
  now (durable B+tree storage is the next slice).
- **Dynamic routing wired into `serve`** — an optional declarative
  `backend/routes.json` maps URL patterns to templates through `akurai-router`;
  `:param`/`*wildcard` captures are injected into the render context as
  `params`, so a template at `/hello/:name` reads `{{ params.name }}`
  (server-rendered, HTML-escaped, no client framework). Without the file the
  server keeps its previous behaviour, so existing projects are unaffected. The
  framework's own site now routes through it, with a `/hello/:name` live demo.
- **`akurai dev` live-reload** — the dev server now watches `frontend/`,
  `content/`, and `backend/` on a background thread and pushes a `reload` over
  SSE to the browser on any change (one injected native-`EventSource` script, no
  build step, no client dep). Strictly dev-only: `akurai serve` starts no
  watcher, injects nothing, and 404s the reserved `/_dev/*` namespace.
- **`akurai-router` crate (core)** — pure-std URL pattern matcher: static,
  `:param`, and `*wildcard` segments → captured params, ranked by specificity
  (static > param > wildcard) so exact routes never get shadowed. Transport-
  agnostic; the first step toward file/convention routing with dynamic segments.
- **Expanded `/components` library** — ~22 new pure-HTML/CSS, native-first,
  accessible components, reorganised into category groups (Actions, Forms, Data
  display, Feedback, Navigation, Overlays, Utilities) with a category index:
  button group, icon button, dropdown menu, split button; switch, input group,
  search, validation fields, file dropzone; description list, metrics, tags,
  avatars, code block; toast, banner, progress, spinner, skeleton, empty state;
  tabs, breadcrumbs, pagination, stepper, menu list; modal, drawer, popover,
  tooltip. Built by parallel agents into isolated fragments, assembled in order,
  and verified in real Chrome via CDP (all interactions work, no console errors).
- **Realtime: WebSocket + Server-Sent Events**, both pure `std`, zero deps,
  standards-compliant. `akurai-http` gains a connection-upgrade primitive
  (`Reply::Upgrade`) that hands the raw socket to a dedicated thread, plus an
  SSE `text/event-stream` writer (`sse()` / `SseSink`, spec framing). New
  `akurai-ws` crate implements RFC 6455: the handshake (from-scratch SHA-1 +
  base64, verified against the RFC accept vector), §5 framing with required
  client masking, fragmentation reassembly, automatic ping/pong, the close
  handshake, and UTF-8 / size / protocol validation with correct close codes.
  Demo endpoints `GET /api/ws` (echo) and `GET /api/events` (tick stream); see
  the new Realtime docs page. End-to-end tests drive a real handshake + masked
  echo and a live SSE read over TCP.
- **Design system documentation** under `site/content/docs/design-system/`: an
  overview, a foundations page (colour/type/spacing/radius/elevation/motion/
  z-index/breakpoint/theming tokens), and an extensive component catalog (~60
  components across actions, forms, data display, feedback, navigation,
  overlays, layout primitives, and the PocketBase-style admin shell — each with
  variants, states, markup, accessibility contract, and tokens). Wired into the
  docs sidebar; the build spec for `crates/css` and the frontend layer.
- `deploy.sh` now cuts the repo and website changelogs in lockstep and publishes
  to EC2 at the tail of a release, so the live `/changelog` always matches the
  shipped version; `version` in `site/backend/page.json` is bumped too.
- **Framework website** under `site/`, served by the framework itself: an
  authentic landing page, sidebar `/docs` (rendered from markdown), `/changelog`,
  an API reference, and a categorized `/components` library. Live at
  akurai-framework.olibuijr.com. The `akurai new` starter is now a clean minimal
  page (the SaaS-style showcase moved to `/components`).
- `serve` renders markdown content pages (`/docs/*`, `/changelog`) into a layout.

- `akurai-template` crate (pure std + internal json): server-side HTML template
  engine — `{{ var }}` (escaped) / `{{{ raw }}}`, `{% if/else %}`, `{% for %}`,
  `{% include %}`, `{# comments #}`, dotted paths, against a JSON `Value` context.
- `serve` is now SSR: registers every `frontend/*.html` as a template and renders
  pages against `backend/page.json`; static assets and `/api` unchanged.
- Bootstrap scaffolds a real component showcase (nav, hero, full form, cards,
  data table, alerts, badges) built entirely from templates + a JSON context.

### Note
- Local git history was reset once after an unclean reboot zeroed half the
  object store. Working tree was intact and verified; re-initialized from it.

### Verified
- 25 unit/integration tests green; clippy `-D warnings` clean.
- End-to-end locally: `akurai new` → `akurai serve` → page renders, health
  endpoint responds, ESM client fetch works (visual confirmation captured).
- Release binary: ~438 KB, zero runtime dependencies.