# xeet: an X post drawn without a browser, and what "pixel-perfect" is checked against

> Satyajit Ghana — Head of Engineering @ Inkers Technology
> canonical: https://ai.satyajit.si/articles/xeet
> date: 2026-11-16
> tags: rust, webassembly, fonts, agentic-coding, developer-tools

On 16 November Guillermo Rauch [posted xeet](https://x.com/rauchg/status/2122184794209714368): "a hermetic, pixel-perfect X post renderer in safe Rust / wasm. Zero browser, network, filesystem, system fonts. Renders a post to PNG in ~1ms." The code is at [github.com/rauchg/xeet](https://github.com/rauchg/xeet) (Apache-2.0 for the code, with a separate note about the fonts that matters later), and a playground runs the WebAssembly build at [xeet-rs.vercel.app](https://xeet-rs.vercel.app).

The README's framing is that most preview tools boot headless Chromium, load a page, and take a screenshot. That costs a browser process and hundreds of milliseconds. xeet's bet is that a post only depends on a small part of the browser: X's client rules, text shaping, line breaking, a flexbox frame and an anti-aliased rasterizer. Rebuild exactly that part, prove it matches Chrome, and the screenshot becomes a function call.

I read the repository at commit `71079ff1`, ran its WebAssembly from the live site inside headless Chromium on five posts, measured what it downloads, and rebuilt its Chrome oracle to check one result that came out wrong. The post's own video first.

<Video
  src="https://ai.satyajit.si/articles/xeet/clip2"
  poster="https://media.thesatyajit.com/ai/articles/xeet/clip2-poster.jpg?v=e03dc2096001ceea"
  alt="A dark screen with code tabs labelled CLI, TypeScript and Rust. Each tab shows a short program that resolves or builds a post and renders it, and beside it the rendered post appears: jack's 'just setting up my twttr', a NASA Goddard post of scattered emoji and stars, and Matt Pocock's poll asking what matters more when building software."
  caption="The launch film's opening: the same render from the CLI, TypeScript and Rust, each with its output beside it. The timings drawn on screen are the authors' (video from @rauchg's post on X)."
/>

## What "hermetic" means in the code

The renderer is the crate `xeet-core`, and it does no I/O at all. It takes a `Post` (only `text` is required) and `RenderOptions` (surface, width, theme, device pixel ratio), and returns PNG bytes plus a `Report`. The four library crates (`xeet-core`, `xeet-text`, `xeet-resolve`, `xeet-resolve-net`) start with `#![forbid(unsafe_code)]`. `xeet-wasm` denies it everywhere except the `wasm-bindgen` glue module, whose generated shims need `unsafe`, and `tools/ship/check-unsafe.mjs` checks that nothing else opts out.

The network lives in a separate crate, `xeet-resolve`, which turns a pasted `x.com` URL into a `Post`. Even that one does not own a socket: the caller passes in `Fetch`, `Lookup`, `Cache` and `Clock` implementations. It crawls `t.co` as `Twitterbot/1.0` (the README notes that `t.co` answers that user agent with a `301` and browsers with an interstitial), follows redirects by hand up to 10 hops, honours `robots.txt`, and refuses private, loopback and cloud-metadata addresses on every DNS hop. The README states that the native and WASM builds produce byte-identical PNGs, with matching SHA-256 hashes on 24 of 24 cases.

So "zero network" is true of rendering. "Zero system fonts" is true too, but the fonts have to come from somewhere, and that is where the size goes.

## Where the bytes go

`crates/xeet-core/build.rs` embeds fonts with `include_bytes!`. With `XEET_FONT_PACKS=core`, which the WebAssembly build sets, only X's own font, Chirp, and Arial go into the module. Everything else becomes a pack that the host fetches and registers before rendering text that needs it: `emoji`, `cjk`, `math`, `latin`, `arabic`, `hebrew`. The native CLI embeds every face, about 49 MB according to `docs/PERF.md`.

I downloaded the live module three times, once per encoding. It is 6,455,325 bytes raw, 2,866,768 gzipped and 2,720,342 with brotli, which agrees with `PERF.md`'s "6.44 MB raw / 2.85 MB gzipped". Walking the module's section headers gives 2,951,775 bytes of code across 3,663 functions, a 3,008,585-byte data section, and a 484,169-byte name section, debug names a renderer never reads. To see what the data section holds, I searched the module for the first and last 4 KiB of every font file in the repository. The 28 Chirp `.ttf` subsets (4 weights × 7 Unicode ranges, 551,160 bytes) and Arial regular and bold (1,521,640 bytes) are in it, 2,072,800 bytes together. No other font is.

The packs are listed in `packs.json` with a SHA-256 each, and the loader checks it before registering a file. They come to 39,158,596 bytes raw, or 33,502,218 with brotli. Emoji alone is 20,930,352 bytes, because it is Apple Color Emoji, whose glyphs are PNG bitmaps in an `sbix` table that brotli can shrink by only 4%.

<SizeBudget />

The widget's point is the asymmetry. A post in Latin script costs the module and nothing else: 2.72 MB on the wire. One emoji adds 20 MB. The playground does not wait to find out which packs a post needs. `app/_lib/wasm.js` calls `preloadFonts` as soon as the module is ready, and that calls `prefetchAll`, which starts all six. I logged the requests on a fresh load: all six packs were requested within a second of the page loading, and the emoji pack finished at 2.7 s. A visitor who never types an emoji still downloads Apple's emoji font: 36.2 MB on the wire in all, counting the module. That is a demo's choice (a carousel slide never waits for a pack), not the library's: `ensureFonts` loads only what a post asks for.

<Figure
  src="https://media.thesatyajit.com/ai/articles/xeet/fig1.png?v=934c68a29ff96b61"
  alt="The xeet playground page. A serif heading 'xeet', a one-line description, three bullet points (X's own rules; small and fast, a WebAssembly core under 3 MB compressed; checked against Chrome, zero line-break differences across 13,440 text layouts), then an Examples carousel at 1 of 17 with an input holding https://x.com/jack/status/20, and three renders of jack's post at timeline 390, detail 390 and timeline 600, labelled 17.4 ms, 4.5 ms and 1.5 ms."
  caption="The playground in my headless Chromium run: four PNGs of jack's first post, 1.5 to 17.4 ms each, the slow one being the first render after load (screenshot of xeet-rs.vercel.app, 16 November 2026)."
/>

## Laying out text without a browser

The hard part of drawing a post is the paragraph. Chrome decides where lines break, and if you are a third of a pixel off, a word moves to the next line, the post gets 20 px taller, and "Show more" lands somewhere else. The README lists what xeet reproduces, and the code bears it out. In the order a paragraph goes through it:

1. **Rules first.** X's client decides what text is visible at all: reply mentions are hidden, a trailing status URL becomes a quote card, links display shortened. `xeet-text` reimplements the open-source `twitter-text` rules and the README says it passes all 2,119 of that project's conformance cases. The ruleset lives in `crates/xeet-core/rules/x-web.json`, each rule marked as read from X's shipped JavaScript, measured on captured payloads, or a prior.
2. **Runs.** UAX #9 bidi levels from `unicode-bidi`, then script runs the way Blink's `ScriptRunIterator` cuts them.
3. **A face per character.** `fonts.rs` walks X's font stack per character: Chirp first if any of its 28 files has the glyph in its CSS `unicode-range`, then Arial, Apple Color Emoji, and stand-ins for the Mac's system fallbacks (Hiragino Sans, STIX Two Math, Noto). Variation selectors decide `©` (text, Chirp) against `©️` (emoji).
4. **Shaping.** `harfrust`, the Rust port of HarfBuzz, shapes each run. Chrome receives a glyph's own advance from its font backend as a float truncated to 1/65536 px, while HarfBuzz scales kerning with rounding, so `shape.rs` converts both in 16.16 fixed point. The comment says why: the difference "decides lines whose width lands within 1/65536 px of the box edge".
5. **Break opportunities.** Between two ASCII characters Chrome uses its own pair table instead of Unicode's rules; `linebreak.rs` carries that table (regenerated from Chrome by `tools/oracle/breaks.mjs`) and falls back to ICU4X's UAX #14 segmenter for everything else.
6. **Fitting.** Here Blink's integer arithmetic matters. Widths are snapped up to Blink's layout unit, 1/64 px, and a line ending at a space gets exactly one unit of slack:

```rust
// crates/xeet-core/src/inline.rs
fn ceil64(w: f32) -> f32 {
    (w * 64.0).ceil() / 64.0
}

fn fits(width: f32, avail: f32, at_space: bool) -> bool {
    const UNIT: f32 = 1.0 / 64.0;
    ceil64(width) <= avail + if at_space { UNIT } else { 0.0 }
}
```

The comment above it says the rule was measured over 600 probes with `tools/oracle/fit-threshold.mjs`: "a 240.015625 px line fits a 240 px box when it ends before a space, and not when it ends after a hyphen."

The loop that uses it, `layout_hard_line`, has one more Chrome quirk in it. It finds the furthest break that fits using widths measured inside the whole paragraph, then shapes that line again on its own, because Chrome re-shapes the line end and kerning across the break disappears. If the re-shaped line no longer fits, it steps back one opportunity at a time. If nothing fits, it breaks inside the word.

<LineFit />

The widget runs that loop on a sentence from the post, with one honest substitution: the widths are your browser's sans-serif measured with canvas `measureText`, not Chirp, so the breaks are not X's. The arithmetic is xeet's. Drag the width by a quarter pixel and you can watch a word jump lines when its rounded width crosses the limit.

7. **Paint.** `paint/coverage.rs` replaces `tiny-skia`'s path anti-aliasing (four sub-samples per row, 16 coverage levels) with exact span overlap over 64 sub-rows per pixel, which the README says lands within 4/255 of the analytic area on a circle. Glyph outlines come from `skrifa`, unhinted, quantized to Skia's 1/4 px subpixel grid, with the baseline snapped to a whole CSS pixel as Blink does. Emoji are the `sbix` PNG strikes from Apple's font, placed at CoreText's em box and resampled with a premultiplied tent filter.

That is a lot of Chrome to copy, and none of it is guessed: almost every constant in those files has a comment naming the oracle script that measured it.

<Figure
  src="https://media.thesatyajit.com/ai/articles/xeet/fig2.png?v=ba254a360ebeb843"
  alt="NASA Goddard's post from November 2017 rendered by xeet: scattered stars, dots and emoji (a glowing star, a crescent moon, a satellite, sparkles, the Earth, a sun, a comet) laid out with runs of spaces across several lines, the line 'Thanks @Twitter, we can always use more space' with a rocket, and the hashtag #280characters, above counts of 880 replies, 109K reposts and 251K likes."
  caption="One of the four posts the project uses to break renderers: NASA Goddard's 2017 space field, where runs of preserved spaces and emoji widths are the layout (xeet's own render, from the gallery in the rauchg/xeet README)."
/>

## What "pixel-perfect" is checked against

xeet's tests compare every layer against something that is not xeet, and the authors are careful about what they commit: X's post text and screenshots stay in a private store, and only counts, deltas and hashes are in the repository. Three of the checks are worth reading closely.

**Text against Chrome.** `tools/oracle/text-parity.mjs` lays strings out in headless Chrome, inside the exact element X uses for post text with X's real stylesheet, and in xeet, and compares line by line. The README reports 0 line-break and 0 height mismatches across 13,440 layouts. The post's "tens of thousands of text layout rules" is presumably that, plus the 2,119 `twitter-text` cases and 3,029 more checked against X's client code: 18,588 in all. What CI can re-check without Chrome is smaller, `tests/golden/text.json`: 210 synthetic strings at six widths, 1,260 layouts. And the script that captures it says something the README does not. In `tools/ship/golden-capture.mjs`, the `styled` and `emoji` coverage sets are left out because they "still disagree with Chrome on line breaks", with the line "A golden records agreement we have, not agreement we want." One of the two documents is out of date. Either way, the golden that gates every push covers fuzzed and whitespace-heavy text, not emoji.

**Whole posts against captured pages.** `tools/ship/e2e.mjs` renders each post embedded in saved `x.com` pages and compares it with Chrome rendering that page. `tests/golden/e2e.json` records 159 compared, 159 passed, and 124 skipped (cards whose metadata the capture lacks, pinned rows, image-only posts). A pass means: height within 1 px, identical line breaks, and the share of pixels differing under the platform's budget, which is 3% on macOS. A pixel counts as differing only if it is more than 8 levels off in some channel and no neighbour within one pixel matches; the screenshot is taken with font smoothing forced to greyscale, and image rectangles are masked out, since Chrome gets a blank stub there. A post with an emoji that misses the budget is recorded as `raster:emoji` and not failed, under a comment that reads "Apple's emoji font cannot be shipped, so we draw Twemoji", which the paint code no longer does: it draws Apple's. From the committed golden I get a median pixel share of 1.41% and a maximum of 2.81% across the 159; 70 of them have a nonzero height difference, up to 0.97 px. The harness's own comment explains the 3%: it is the measured worst case, 2.809%, "with nothing to spare". On Linux the target is 0.5%. So "pixel-perfect" means "line-perfect, within a pixel of height, and within the anti-aliasing gap between two rasterizers", which is what a careful engineer means and not what the phrase says.

**Font choice against a Mac.** The header of `fonts.rs` is the most candid paragraph in the repository. Over 6,376 code points, characters Chrome draws with Chirp, Arial, the emoji font or STIX agree with xeet on family and advance 94% of the time. Characters Chrome gives to a Mac system font that cannot be bundled keep that device's advances, and xeet matches those only about 7% of the time; "★", "✈" and "♥" are named. The web target is Chrome on a Mac (there are also iOS surfaces, measured from iPhone captures). A post seen in Chrome on Windows, on Android, or in X's own embed is drawn differently, and xeet makes no claim about those.

## What I ran, and where it differed

xeet's resolve endpoint on the demo refuses automated requests ("automated requests are not allowed"), and `x.com` itself rendered an empty page to headless Chromium, so I could not compare against X's own timeline. Instead, I built five `Post` objects from the fxtwitter mirror's data (text, author, avatar bytes, counts, and the video's size and duration), opened the live demo in headless Chromium 158 on an Apple-silicon Mac, imported its `xeet_wasm.js`, registered all six packs, and called the module directly. Four posts are real: jack's first post, Rauch's launch post, a Japanese post by [@okhotskuma](https://x.com/okhotskuma/status/2121030966986842167) with full-width punctuation, and a Japanese post by [@ymt3d](https://x.com/ymt3d/status/2120718811838152721) with a long link and a hashtag. The fifth is mine: a long URL, a ZWJ emoji, two flags, Japanese and Arabic in one line.

Timings, 30 renders each after a warm-up, median, at a 390 px timeline width and device pixel ratio 2, PNG encoding included:

| post | render | what is in it |
|---|---|---|
| jack, 24 characters | 1.1 ms | an avatar |
| the stress line | 1.0 ms | default avatar, emoji, CJK, Arabic |
| okhotskuma | 1.9 ms | avatar, 8 lines of Japanese |
| ymt3d | 5.3 ms | avatar, 9 lines, a video placeholder |
| Rauch's launch post | 5.6 ms | avatar, Show more, a video placeholder |

The same launch post at the 600 px detail width, expanded to all 25 lines, took 16.7 ms. The browser rounds `performance.now()` here to 0.1 ms, so the small numbers carry about that much error, and `explain` (layout without pixels) came in at or near that floor. The post's "~1ms" holds for short text posts, in this setup. The README's own figure is 2.8 ms median for a text post at 390 px and 3× density, measured natively; the film's Tetris segment, where every frame is a post, shows 1.0 to 1.4 ms per frame at 382 px, natively. A post with media is several milliseconds, and `PERF.md` says four real 800×600 photos take 62 ms, twice the 30 ms budget its table sets.

<Video
  src="https://ai.satyajit.si/articles/xeet/clip1"
  poster="https://media.thesatyajit.com/ai/articles/xeet/clip1-poster.jpg?v=b79074c7df261f34"
  alt="A dark screen titled 'Tetris, every frame is a post'. In the middle is a post by Guillermo Rauch whose text is a Tetris board drawn in coloured square emoji, with NEXT, SCORE, LINES and LEVEL beside it, and the view count under the post climbing. A frame counter reads frame 117 of 241 and the corner shows 1.1 ms. The game plays, then the screen cuts to '241 frames in 260 ms. Every frame a post, rendered in as little as 1.0 ms. Native Rust. No browser.'"
  caption="Tetris played as a sequence of posts, each frame rendered by xeet natively, ending on 241 frames in 260 ms. The timings are the authors', from the native build, not the browser (video from @rauchg's post on X)."
/>

The output is right in the places I could check against X's own data. The link in the ymt3d post displays as `3dnchu.com/archives/spiru…`, which is exactly the `display` string X's API returns for it. Rauch's post is cut at "X is the global town square, and the" with Show more, and X's embed of the same post cuts at the same word. Counts abbreviate as X does (1.2K, 57K). xeet's report gives the weighted length X's composer would count: 263 of 280 for the okhotskuma post, because each Japanese character costs 2, and 1,127 for Rauch's long post, which is a premium account's post and flagged as over the standard limit.

<Figure
  src="https://media.thesatyajit.com/ai/articles/xeet/fig3.png?v=cecd073060af8a57"
  alt="Two renderings of the same post side by side. Left: X's embed widget, with the text 'Introducing xeet: xeet-rs.vercel.app. A hermetic, pixel-perfect X post renderer in safe Rust / wasm...' in a system font at a larger size, a Twemoji grin, 'Show more' inline after 'and the', a black video box with a play button, '1.2K' likes and 'Read 146 replies'. Right: xeet's timeline render at 390 px, in Chirp at a smaller size, an Apple emoji grin, 'Show more' on its own line, a grey video placeholder with a 00:37 pill, and counts 146, 68, 1.2K and 57K."
  caption="The same post on two surfaces, so different fonts and sizes are expected. Left, X's embed widget: system font at 20 px, Twemoji images, a 516 px text column. Right, xeet's web timeline at 390 px: Chirp at 15 px, Apple emoji, a 310 px column. Both cut the text at the same word (my screenshots, 16 November 2026)."
/>

For line breaks I needed Chrome laying out the same text with the same fonts. I wrote a small oracle: xeet's own `visible` text from its report, set in Chrome with Chirp loaded from the repository's `.woff2` files under the manifest's `unicode-range`s, at X's 15/20 px timeline type in a 310 px column (the 390 px frame minus 16 px padding each side, the 40 px avatar and its 8 px gap), and at 240 px and the 568 px detail column. Line counts agreed on 14 of 15 layouts. That is a count, not a comparison of where each break falls, so two errors that cancel would pass.

The 15th was the okhotskuma post at 390 px: xeet draws 8 lines and Chrome drew 9. Chrome broke the fourth line one kana earlier, after `マッチングっ`. Measured on its own, `SpirulaStudioで成功。LoMaのマッチングって` is 310.33 px in Chrome, a third of a pixel too wide for the column. To see whose fault that is, I rebuilt the project's own harness in place of mine: X's real stylesheet (fetched from the URL pinned in `assets/upstream.lock.json`), the element and classes `text-parity.mjs` uses, both of its fallback modes, and a third run with the text marked Japanese, sweeping the column from 308 to 312 px:

| fallback | fonts Chrome used for the Japanese | lines at 310 px | 8 lines from |
|---|---|---|---|
| `bundled` (xeet's own font files) | Hiragino Sans from the repo | 8 | 310 px |
| `system` (this Mac's fonts) | Hiragino Sans for 89 glyphs, PingFang SC for 27 | 9 | 312 px |
| `system`, with `lang="ja"` on the text | Hiragino Kaku Gothic ProN for all of it | 9 | 310.5 px |

With xeet's fonts, Chrome agrees with xeet exactly, flipping between 309.5 and 310 px. With the Mac's own fallback and the oracle's `lang="en"` page, Chrome draws 27 glyphs (all 25 kanji and two punctuation marks) from PingFang SC, the Chinese system font; I checked by querying the font used for a kanji-only span. Those glyphs have different advances, and the line no longer fits. So xeet's engine is right; the question is which fonts the real page uses. X marks post text with its language: in X's embed of this post the `tweetText` element carries `lang="ja"`, which I checked. With that attribute under X's stylesheet, Chrome on this Mac uses Hiragino Kaku Gothic ProN, a third family, for every Japanese character, and still draws 9 lines at 310 px; it needs half a pixel more. I did not see this post on x.com, so what a Mac reader gets there is unverified, but both system-font runs disagree with xeet. What it does show is the limit the `fonts.rs` header already admits: past Chirp, Arial and the emoji font, "pixel-perfect" depends on which system font Chrome picks, and xeet can only bundle one.

<Figure
  src="https://media.thesatyajit.com/ai/articles/xeet/fig4.png?v=5a24d2f886acde9c"
  alt="Three posts rendered by xeet at 390 px. Left: Toshiaki Kumaki's Japanese post about 4,066 panoramic images and SpirulaStudio, eight lines with full-width brackets and a trailing ellipsis, his name truncated with an ellipsis. Middle: 3D人-3dnchu's Japanese post recommending Spirula Studio, with the link shown as 3dnchu.com/archives/spiru… and the hashtag #3DGS in blue, above a grey video placeholder with a 00:14 pill. Right: a test post reading 'Long link: example.com/a/really/long/…' followed by a technologist emoji with a skin tone, a rainbow flag, a Japanese flag, Japanese text and right-to-left Arabic."
  caption="xeet's renders of the two Japanese posts and my stress line: long names and links are cut with an ellipsis, a ZWJ emoji and flags draw as single glyphs, and the Arabic runs right to left. The left one is the post whose line count differs from Chrome with system fonts (xeet's live WebAssembly, driven by me in headless Chromium)."
/>

## The autorepo, a day in

Rauch calls xeet an "autorepo": an oracle checks the port against Chrome, and "a CI canary then watches the evolution of the original, and files signed PRs for agents to act on." `docs/CI.md` describes it. `upstream-watch.yml` runs every six hours, probes logged-out x.com's stylesheet and server-rendered markup, and either opens an alarm issue or dispatches `sync.yml`. That one snapshots upstream, regenerates the design tokens, runs the gates, and ends in either a pull request committed through GitHub's `createCommitOnBranch` (so GitHub signs it) or "a repair-brief issue", which the workflow describes as "the brief an agent picks up". `CI.md` is upfront that this pipeline "is a skeleton with real seams" and that some policy decisions are still manual. As of this writing the repository has no pull requests at all, signed or otherwise; the canary's only output so far is an issue. Pull requests never run CI, so fork code never touches a runner.

The canary has already fired. Issue #1, opened by `github-actions[bot]` at 00:46 UTC on launch day, reports 22 of 23 checks passing, X's app version rotated from the pinned `89824c04` to `ec61450c`, a new stylesheet hash, and one failure: fetching a profile page returned HTTP 403 from the CI runner. The most recent commit at the time I cloned is a fix for exactly that ("Fall back to live x-web bundle when profile SSR returns 403 on CI runners"). The public history starts with an "initial commit" on 16 November, so the history of the agents' work is not visible. One loose end: the README describes the ruleset as `x-web@55591fe0`, while the live module reports `89824c04…` as its upstream; `SPEC.md` lists both as captured app versions.

A reply under the post put the cost plainly: pixel-perfect against X "is a subscription, not a milestone". X has already shipped a new stylesheet since the pin. The project's answer is the canary plus agents to do the port, and the verdict on that answer is months away.

## The fonts it ships

The repository commits `AppleColorEmoji.ttf`, the two Hiragino Sans files, Arial and Chirp under `assets/vendor/fonts/` (the comment at the top of `build.rs` still says they are "deliberately not committed"). The README's licence section says those fonts "remain under their respective upstream terms and are not covered by the Apache-2.0 license", and tells you to redistribute binaries "only with fonts you are licensed to ship". Apple's fonts are licensed for Apple devices, and Chirp is X's. The public demo serves the emoji and Hiragino packs to every visitor anyway. I am not a lawyer, and the authors flag this themselves, but it decides what anyone else can deploy: the engine is Apache-2.0, and the thing that makes it match a Mac is not yours to ship.

## Would this site use it?

This site does not render X posts today. I checked `components/` and `lib/`: there is no embed component, no `react-tweet`, no iframe. Articles link a post, credit its author, and embed the post's own images and videos as files on our media bucket. The one place a post appears as a picture is a screenshot, as in [the Modern Web Guidance piece](/articles/modern-web-guidance-static-embeddings).

So the question is whether xeet would be a better way to show a cited post. I don't think it would, for three reasons that stand on their own.

- A post drawn as a PNG is text turned into pixels. Every article here has a Markdown twin and goes into `llms-full.txt`; an image of a post is invisible to both, to search and to screen readers unless someone retypes it as alt text. A server-rendered HTML card keeps the text.
- At request time on Vercel there is nothing to gain. Article pages are statically generated and cached at the edge, so a render would happen once per build anyway; the module would sit in a function bundle (6.46 MB is fine against the 250 MB limit) to save no time at all.
- The fonts. Shipping xeet's packs from `ai.satyajit.si` means redistributing Apple's emoji font and Hiragino, which the README says not to do.

Where it would help is one step earlier, in the `/amplify` drafts. The amplifier writes X threads into `drafts/<date>/<slug>/x-thread.md` and nothing checks their length the way X counts it: a URL is 23, an emoji or a CJK character is 2. `xeet explain` returns exactly that (`length.weighted`, `length.valid`) plus where Show more would cut on the web timeline and on iOS, with no pixels and in well under a millisecond. Run as the CLI over each draft before Satyajit approves it, it answers the questions the post was written for: does this fit, and where does it fold. That is a tool run on a draft, so it can run on a server away from the site, and it ships no fonts.

## What was run and what was only read

Read: the repository at `71079ff1` (README, `SPEC.md`, `docs/PERF.md`, `docs/CI.md`, `docs/E2E.md`, `tests/golden/*`, `build.rs`, `fonts.rs`, `shape.rs`, `linebreak.rs`, `inline.rs`, `tools/oracle/*`, `tools/ship/*`), issue #1 and the commit list through the GitHub API, the post and its replies through the fxtwitter mirror. Ran, on an Apple-silicon Mac: the live module in headless Chromium 158 on five posts (timings, reports, PNGs), byte counts of the module and packs in three encodings, a section walk of the module, a search for each font file inside it, X's embed widget for four posts, and two Chrome oracles (mine, and a rebuild of the project's `text-parity.mjs` setup) on xeet's visible text. Not run: xeet's own test suite or oracle, and anything natively; the project's pinned Chrome is 141 and mine was 158. Not seen: any post on logged-in x.com.

Related reading here: [what an agent's web-font advice is worth on three real fonts](/articles/web-font-agent-prompt), [fframes, where a frame is also a function](/articles/fframes), and [three harnesses read for how they check an agent's work](/articles/agent-tools-week).
