v0.2.0

v0.2.0 turns ant serve from a one-route JSON endpoint into a full web console, adds YouTube as a domain, and makes every page fast: a cached record renders from disk instantly, a slow fetch shows a self-reloading loading screen instead of timing out, and the next click is often already warm.

The machine-facing JSON API is preserved byte for byte under content negotiation, so anything that scripts ant serve today keeps working.

The web console

Open http://localhost:7777 and you get a browser GUI over the entire ant URI namespace, server-rendered in pure Go and styled to match shadcn/ui. No Node, no build step, no CDN, no client framework, no API key. Everything is embedded in the one binary.

• Dashboard lists every registered domain as a card, with example URIs and a count of what is already cached on disk.
• Resource pages render a record's envelope, its data as a readable key/value table, its @links as clickable chips you can follow across sites, its body as Markdown, and a raw-JSON disclosure.
• Collections list as cards; links and the graph render the cross-site connections, with an interactive node diagram and a DOT download.
• Browse walks the on-disk data tree as plain folders, so you can see exactly what ant already knows without typing a URI.
• Search gives every domain that supports it a free-text box, and each hit opens its record.
• Resolve and live URL turn any id, URL, or URI into the canonical form and back out to the source.

The console is read-only and local-first. It holds no sessions, stores no credentials, and changes nothing on the network. The on-disk data tree is the only state, and the console reads it freely and writes it only through the explicit export action.

YouTube as a domain

youtube://video/<id>, youtube://channel/<id>, and friends now resolve, dereference, and link like every other domain, so a graph walk can hop from a record into YouTube and back. It is a blank-import driver like the rest: one line wires it in.

Every page is fast, and nothing times out

The old serve dereferenced synchronously with a request timeout, so a slow upstream could block a page until it died with context deadline exceeded. That is gone. The read path is now:

• Cache-first. A record already on disk renders with no goroutine, no queue, and no network. This is the common case once a URI has been seen, and it is effectively instant.
• A grace race on a miss. A fetch that finishes quickly renders inline with no spinner and no redirect. Only a genuinely slow fetch hands off to a loading screen, which polls in the background and reloads itself the moment the data is ready. With JavaScript off, a meta refresh does the same job.
• Fetched once, shared. Several tabs (or several viewers) of the same slow URI share a single upstream fetch, and a finished result is kept briefly so a reload reads memory.
• The next click, prewarmed. Viewing a record quietly warms the records it links to, within strict bounds, so the likely next page is already cached.

The result: a page renders the data, a loading screen, or a clean error, but it never hangs and never times out. The only deliberate wait left is the export button, which writes to disk on a clear bounded timeout.

Heads up: serve now binds to localhost by default

A console that renders external content and runs locally should not listen on every interface. ant serve now binds to 127.0.0.1:7777 by default. To expose it on a LAN, pass it explicitly:

ant serve --addr 0.0.0.0:7777

Install and upgrade

Every tagged version builds the same artifacts: archives for Linux, macOS, Windows, and FreeBSD, Linux packages (deb, rpm, apk), a multi-arch container image on GHCR, and package-manager entries. The binaries are pure Go, so there is nothing to install alongside them.

go install github.com/tamnd/ant/cmd/[email protected]

Or grab a binary from the release page, or pull the image:

docker run --rm -p 7777:7777 ghcr.io/tamnd/ant:0.2.0 serve --addr 0.0.0.0:7777