Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
What the site's load numbers are, and the rules that keep them there
/play has its own boot-cost document because a coin world is a special case: a WebGL renderer, a physics solver and a multiplayer room all have to start before anything is playable. This document covers everything else. Every ordinary page on three.ws is a static HTML document plus a module graph, and the cost of opening one is almost entirely decided by four questions:
- How many bytes of JavaScript run before the page is usable?
- How much of the DOM does the browser lay out that nobody can see?
- What is on the critical path that has no business being there?
- How large is the media, and when is it decoded?
Each section below is an invariant with the measurement that produced it. Every number in this file came from a Lighthouse run against the live site, not from reading the source.
How to measure
Lighthouse CLI, one page at a time, performance category only:
export CHROME_PATH="$HOME/.cache/ms-playwright/chromium-1223/chrome-linux64/chrome"
npx lighthouse https://three.ws/marketplace \
--preset=desktop \
--only-categories=performance \
--output=json --output-path=./marketplace.json \
--chrome-flags="--headless=new --no-sandbox --disable-dev-shm-usage --disable-gpu" \
--quiet --max-wait-for-load=90000
Drop --preset=desktop for the mobile form factor, which is Lighthouse's default and applies a 4x CPU slowdown plus a throttled connection. The same page always scores far lower on mobile; compare a page against its own history, never against another page or another form factor.
Two things to know before reading a report:
- The score is not the byte count. Performance is weighted Total Blocking Time 30%, Largest Contentful Paint 25%, Cumulative Layout Shift 25%, First Contentful Paint 10%, Speed Index 10%. A page can ship 4 MB and score well if none of it blocks; a page can ship 900 KB and score badly if all of it runs at once.
- Lighthouse 13 removed the audits everyone quotes.
offscreen-images,uses-responsive-images,modern-image-formatsanddom-sizeare gone, replaced by the insight family:image-delivery-insight,render-blocking-insight,cache-insight,legacy-javascript-insight,cls-culprits-insight. A script that reads the old audit names throws onundefined. - Keep
--disable-gpu. Do not "improve" it to software WebGL. Swapping it for--use-gl=angle --use-angle=swiftshaderlooks more faithful, since the 3D pages then really run their renderers, and it does not survive contact with this site: in the 2026-08-15 sweep that flag set made/and/marketplaceabort withPAGE_HUNG,/playreportNO_FCP, and/marketplacestill fail withPROTOCOL_TIMEOUTat a 90s--max-wait-for-loadon a completely idle machine. The same pages complete in about two minutes each with--disable-gpu. Software rasterization of our own WebGL is slower than the throttling Lighthouse is trying to apply, so the run measures the rasterizer rather than the page. - Check
environment.benchmarkIndexin every report before quoting its score. A shared build machine swings it wildly: the 2026-08-15 sweep saw 108 on one/createrun and 2,398 on a/run twenty minutes later, and the low reading inflates every CPU-bound metric in that report. A run under roughly 800 is worth repeating on an idle machine rather than recording.
Where the numbers are
Three sweeps, same eight pages, same tool (Lighthouse 13.4.1), same flags. The first is the problem statement rules 1 to 6 were written against; the second is what those rules were worth; the third is what came back.
2026-08-14, against commit 0496089f0 (stamped 2026-08-14T01:24:52Z), which predates rules 1, 2, 3 and the model-viewer half of rule 4.
2026-08-15, against commit 7505b83ca (stamped 2026-08-15T07:08:00Z), which contains all of them.
| Page | Desktop 08-14 | Desktop 08-15 | Mobile 08-14 | Mobile 08-15 | Desktop TBT 08-14 | Desktop TBT 08-15 |
|---|---|---|---|---|---|---|
/ |
33 | 91 | 25 | 48 | 19,340ms | 134ms |
/create |
38 | 94 | 25 | 51 | 6,940ms | 0ms |
/forge |
32 | 75 | 20 | 31 | 12,560ms | 55ms |
/marketplace |
23 | 58 | 17 | 20 | 51,400ms | 168ms |
/play |
31 | 83 | 25 | 41 | 5,870ms | 101ms |
/docs |
39 | 93 | 35 | 47 | 4,490ms | 107ms |
/discover |
54 | 88 | 44 | 58 | 11,010ms | 266ms |
/chat |
28 | 60 | 25 | 55 | 6,390ms | 0ms |
Total blocking time was what held every score in the first column down, and it is 30% of the weighting on its own. It is now effectively gone from all eight pages. Read a Lighthouse report by which metric is losing the points, not by the score, because the answer changes once you fix something: on the three pages still under 80, blocking time now costs 4.2 points at worst and the loss has moved somewhere else entirely.
| Page still under 80 | Losing | To |
|---|---|---|
/forge 75 |
13.3 pts | CLS 0.260, of which 0.190 is one shift on the example-prompt row (rule 6) |
/marketplace 58 |
19.8 pts + 13.0 pts | LCP 3,649ms, and CLS 0.257 of which 0.178 is one shift on the podium (rule 5) |
/chat 60 |
21.0 + 9.9 + 9.0 pts | LCP, FCP and Speed Index, all of them one 4,277 KiB chunk (see the open items) |
Full desktop detail for the 2026-08-15 run: CLS / 0.002, /create 0.014, /forge 0.260, /marketplace 0.257, /play 0.000, /docs 0.043, /discover 0.044, /chat 0.001. Transferred bytes / 3,272 KiB, /create 1,804 KiB, /forge 8,254 KiB, /marketplace 3,987 KiB, /play 2,265 KiB, /docs 706 KiB, /discover 4,885 KiB, /chat 4,627 KiB.
All three sweeps were taken on a shared build machine, so single-page scores move a few points between runs; see the benchmarkIndex note above before quoting one.
2026-09-04: the 3D pages regressed, and the non-3D pages did not
Against commit c2148462e (stamped 2026-09-03T19:16:29Z). Desktop, best of two runs per page, keeping the run with the higher benchmarkIndex. Every score below was taken at 913 or above, so the note about repeating a low reading has already been applied to them.
| Page | Desktop 08-15 | Desktop 09-04 | benchmarkIndex |
TBT | CLS | Transferred |
|---|---|---|---|---|---|---|
/ |
91 | 55 | 1,296 | 29,980ms | 0.004 | 8,590 KiB |
/create |
94 | 59 | 1,170 | 5,723ms | 0.024 | 3,206 KiB |
/forge |
75 | 45 | 1,196 | 3,185ms | 0.226 | 3,335 KiB |
/marketplace |
58 | 38 | 1,183 | 22,560ms | 0.113 | 11,790 KiB |
/play |
83 | PAGE_HUNG |
1,096 | n/a | n/a | n/a |
/docs |
93 | 99 | 913 | 0ms | 0.029 | 467 KiB |
/discover |
88 | 51 | 1,335 | 5,621ms | 0.052 | 6,853 KiB |
/chat |
60 | 99 | 1,310 | 2ms | 0.0005 | 747 KiB |
Read the two pages that went up before concluding the machine did this. /chat (60 to 99) and /docs (93 to 99) are the two pages on the list that mount no WebGL, and they improved on the same machine, in the same sweep, minutes apart from the pages that collapsed. /chat's 4,277 KiB chunk, recorded as an open item after the 08-15 sweep, is gone: the page now transfers 747 KiB and blocks for 2ms. Every page that regressed renders 3D.
Blocking time is the whole story again, and it came back through the assets rather than through the scheduling the rules already cover. Two thirds of /'s 29,980ms was one 4.6 MB hero GLB (rule 7); /discover was building a WebGL renderer for a directory whose visible cards are all still images (rule 4); /forge's largest single bootup entry was the walk companion booting on top of the page (rule 8).
The mobile form factor could not be measured cleanly on this machine, and that is a finding about the machine. A first pass put every run between benchmarkIndex 176 and 760, all under the floor: / 26, /create 42, /forge 20, /marketplace 18, /play PAGE_HUNG, /docs 61, /discover 44, /chat 75. A best-of-two repeat rescued exactly two of them before the machine degraded further and the renderer itself began dying: / 31 at 1,384 and /create 40 at 1,318, both quotable, and then /marketplace and /discover returned TARGET_CRASHED and /chat returned nothing at all. Mobile applies a 4x CPU slowdown on top of whatever the host is already doing, so it is the form factor that fails first when the build machine is oversubscribed. Sweep mobile on an idle machine or not at all; a crashed target is not a score of zero.
/play is not comparable to its 83 and is not a regression on its own evidence. Profiled against production with a longtask observer, its render loop emits a 2.0 to 2.1 second long task every ~2.1 seconds, indefinitely: one frame per two seconds, which is what rasterizing a coin world on the CPU costs. Chrome's own unresponsiveness detector fires before Lighthouse can finish, which is PAGE_HUNG. That figure is a property of --disable-gpu, not of the page, and it is why the "How to measure" section refuses to trade that flag for software WebGL. /play needs a machine with a GPU to be measured at all.
1. A grid never lays out what nobody can see
Invariant: any grid that renders a whole catalogue in one pass gives its cards content-visibility: auto and a contain-intrinsic-size hint.
/marketplace renders the entire catalogue into #market-grid on first paint. A desktop trace measured that element at 31,196px tall, of which one 940px screenful is visible. The browser styled, laid out and painted all of it. In the sweep of 2026-08-14 that page spent 21,203ms in Style & Layout and 19,634ms in Rendering, roughly forty seconds of work for thirty screenfuls nobody had scrolled to, and it is why /marketplace is the worst-scoring page on the site (23 desktop, 51,400ms total blocking time). /discover has the same shape at smaller scale.
content-visibility: auto makes the browser skip that work for an element until it nears the viewport, and hand it back when the element leaves again. The rules live in public/marketplace.css and the .explore-card block of public/style.css.
Two things make it safe rather than clever:
- Paint containment has to already be true.
content-visibilityimpliescontain: layout style paint, and paint containment clips to the padding box. Every card it is applied to was already clipping its own contents, so nothing on screen changed. Applying it to a card with an overflowing badge or a hover glow that escapes its bounds would visibly cut that decoration off. - The size hint starts with
auto.contain-intrinsic-size: auto 250px auto 370pxtells the browser to assume that size for a card it has not rendered, and to replace the assumption with the real measurement once it has. Without the leadingautokeyword, a card that renders taller than the hint leaves a gap and jumps the scrollbar under the user's cursor.
If you add a new catalogue grid, add the rule with it. The cost of not doing it does not show up until the catalogue has a few hundred rows, which is exactly when nobody is looking for it.
2. Analytics never competes with the page
Invariant: the PostHog library loads at idle. The stub that queues events loads synchronously.
PostHog's stock snippet calls posthog.init(...) inline in <head>, and init() is the function that injects the <script src=".../static/array.js"> tag. That put the analytics library into the page-load window of every route on the site. A desktop trace of / measured 1,110ms of script evaluation and a 907ms long task for array.js; /create paid 837ms of its 5,400ms total blocking time for the same file. Nothing a visitor can see depends on it.
The snippet in vite.config.js is now the stock loader with one change: the trailing init() call is wrapped in a requestIdleCallback with a 2s timeout, falling back to a plain timer where the API is missing.
Nothing is dropped by moving it. The snippet's IIFE still runs synchronously, so window.posthog and every capture method exist from the first line of <head>; calls made before the real library arrives queue on the stub array and replay when it loads. That queueing is the entire purpose of PostHog's stub, and the init arguments ride along in posthog._i.
The 2s bound is the deliberate part. Waiting for the load event instead would have meant a 12s delay on the heaviest page, so a visitor who bounced early would be invisible. Two seconds costs the load window nothing and caps the blind spot.
Any third-party script you add follows the same rule. If a visitor cannot see it, it does not get to run while the page is still becoming usable.
3. The CDN bundle is minified, whatever Vite thinks
Invariant: dist-lib/agent-3d.js ships minified, via the threews-lib-minify-whitespace plugin in vite.config.js.
Vite hard-codes minifyWhitespace: false for every ES library build (resolveEsbuildTranspileOptions in vite/dist/node). The reasoning is sound for the usual case: a library output gets re-bundled by whoever installs it, and keeping the whitespace preserves /*#__PURE__*/ annotations for their tree-shaker.
Our lib output is not an npm dependency. It is the file a browser downloads from /agent-3d/latest/agent-3d.js when a third-party page drops in an <agent-3d> tag, and the homepage loads it too. Because the option is forced rather than defaulted, no build.minify or esbuild setting in the config can turn it back on.
A renderChunk pass that runs esbuild with minifyWhitespace: true (and identifiers and syntax left alone, since Vite's own pass already handled those) took the shipped bundle from 4,244,387 bytes to 3,433,103 raw, and from 1,031,741 to 853,007 gzipped at gzip -9. That is 811,284 fewer bytes, 19.1%. On the homepage, agent-3d.js was 2,293ms of script evaluation and two long tasks of 1,299ms and 526ms.
Measure the right file. dist-lib/ also holds agent-3d.umd.cjs, which is naturally smaller (2,761,457 bytes) because it is a different format, and quoting it makes the win look better than it is. scripts/publish-lib.mjs mirrors the ES build, dist-lib/agent-3d.js, to the moving channels (/agent-3d/latest/, /agent-3d/<major>/, /agent-3d/<major>.<minor>/), so that is the file a browser downloads. A pinned /agent-3d/<version>/ directory is never rebuilt: its bytes come from the write-once release archive recorded in data/agent-3d-releases.json, so a minifier change reaches pinned embedders only when a new version is cut with npm run release:lib.
Do not "simplify" this away by trusting build.minify. Check the byte count of dist-lib/agent-3d.js after any change to the lib config; a jump back over 4 MB means the plugin stopped running.
4. Below-the-fold sections load below the fold
Invariant: a heavy section is loaded by an IntersectionObserver on the section itself, not by a tag in <head>.
The homepage is 14,825px tall. Three of its sections are expensive enough that loading them eagerly dominated the whole page:
| Section | Offset | Cost when loaded eagerly |
|---|---|---|
| Dragon backdrop | 3,775px | 2,742ms script evaluation, 1,498ms long task |
| Mini forge | 1,246px | pulls model-viewer on first job |
| Pose demo | 8,724px | pulls Three.js, OrbitControls, the mannequin rig |
All three are gated in pages/home.html with a rootMargin: '200px' observer, so none of them costs anything until the visitor has scrolled to them. The gates are measurably honest: at DOMContentLoaded the dragon sits at 3,753px against a trigger threshold of viewport + 200px = 1,140px, so it does not fire on load.
The exception that proves the rule is the <agent-3d> loader. It stays eager in <head> on the homepage, and that is correct: bootHeroAvatar() in src/home-live-agents.js runs at module top level and the hero stage is the above-the-fold LCP element. Deferring the custom-element definition would not remove the work, it would move it behind the largest paint. Rule 3 is what makes that eager load affordable.
The same rule covers 3D viewers, and it needs its own mechanism because the platform default does not work. loading="lazy" on a <model-viewer> is not enough on a page that renders many of them. Slides in a carousel occupy one box and are hidden with opacity rather than display, so every one of them intersects the viewport at once and model-viewer's own lazy loading holds nothing back; a grid card is a different shape but the cost is the same once the cards are on screen.
So src/marketplace.js uses a data-src contract instead. A viewer ships data-src rather than src, and observeCardModelViewers() promotes it to src on first intersect at a 200px margin, adds auto-rotate there, and removes auto-rotate when the element leaves so an offscreen viewer is not running a raf loop. The grid cards and the hero carousel already worked this way. The themed-picks strip did not, and that made it the last eager viewer on the page. On /marketplace, model-viewer is the single most expensive script in the trace at 7,924ms of evaluation, across the grid, the hero and the strip together.
Measured honestly, that last one is the smallest of the three: at 1350x940 the strip sits at y=137, above the fold, so the observer promotes all six viewers immediately and a desktop first load is unchanged. It pays on a narrow viewport that pushes the strip down, on a filtered view that moves it, and on the rotation that used to keep running after the visitor scrolled past. Report a fix by what you measured it doing, not by the size of the number next to it.
A new <model-viewer> on a multi-viewer page ships data-src, or it is eager. There is no third option, and the attribute that looks like it should handle this does not.
The element bundle is part of that cost, not just the model
The rule above defers the model. The 253 KiB module that defines <model-viewer> is a separate download and a separate parse, and on 2026-09-04 two pages were still paying it on every visit from a tag in <head>.
/discover is the clearer case. It renders a directory of 48 cards, and only the handful that carry a GLB become a viewer at all: measured against production, four of them, the first at y=4991px on a 940px viewport. The other 44 are static R2 thumbnails. The bundle was fetched and evaluated on every visit regardless, and a Lighthouse desktop trace attributed 28,971ms of bootup time to it. The same page measured with the bundle absent scored 81 against 47 for the page as shipped (and did so on a slower sample of the shared machine, benchmarkIndex 709 against 958, so the gap is a floor rather than a ceiling).
/create is the smaller case and the more embarrassing one. It has exactly one viewer, in the hero card, and that viewer already deferred its model with data-src per the rule above. The bundle was still fetched and evaluated on load, 8,246ms of bootup, to build a WebGL renderer for a card most visitors never touch.
Both now load the element on demand, through the CDN failover chain (jsDelivr, then cdnjs, then unpkg, pinned to one version, 4.4.0 as of 2026-10-23) in src/shared/model-viewer-loader.js that the hardcoded <script> tags never had:
/createasks for it frompromoteSource()in src/shared/attended-rotation.js, the same first attention that promotesdata-src. Everydata-srcviewer on the platform inherits this./discoverasks for it when a card that actually carries a GLB comes within a screen of the viewport, in public/discover/discover.js.
An undefined custom element paints nothing, so the box has to be dressed for that window. <model-viewer> cannot show its own poster before it upgrades, so a :not(:defined) rule keeps each box the exact size the upgraded viewer will occupy and fills it: /create paints the same poster image as a background, /discover paints the card's surface tone. Verified in a browser at 1350x940: the /create viewer measures 278x238 before the hover and 278x238 after, and the bundle count goes 0 before, 1 after. On /discover, 0 at rest with the first 3D card at y=4991, 1 once it is scrolled into view, and the element upgrades and loads its GLB.
The meshopt shim stays eager on both pages, and has to. public/model-viewer-meshopt.js is a 2 KiB classic script that intercepts customElements.define(), so it registers its decoder whenever the bundle turns up; every server-baked GLB needs that decoder set before the first load starts.
A page that renders no viewer downloads no viewer. Check what a page actually mounts before you put a 3D engine in its <head>.
5. Media is lazy, sized by CSS, and decoded off the main thread
Invariant: every grid thumbnail carries loading="lazy" and decoding="async", and its container reserves the box in CSS.
Directory thumbnails are stored at 768x768 and painted into a 293px box; showcase thumbnails are full-size renders painted into a 200px-tall box. loading="lazy" keeps them off the wire, and decoding="async" keeps the decode of a grid's worth of them off the critical rendering path. Both are set in public/discover/discover.js and src/forge-showcase.js.
The box is reserved by CSS rather than by width/height attributes, because these thumbnails are square-cropped with object-fit: cover at a size the markup does not know: .explore-card-thumb is aspect-ratio: 1 / 1 and #showcase .creation .thumb is a fixed height. That is why the layout-shift numbers on both pages are near zero even though the images arrive late.
A reserved box is not optional. If you add a thumbnail whose container has no aspect-ratio and no fixed height, add one, or the late image will shift everything under it.
A skeleton only reserves the box if it is the same size as the thing it replaces
/marketplace had a skeleton, a comment saying it existed "so there's no layout jump when data arrives", and the largest layout shift on the page. Both halves of it were wrong, and each is worth recognising on sight.
A section that JavaScript reveals reserves nothing. #mkt-top-section shipped hidden, and loadTopPerformers() in src/marketplace.js cleared that only once it ran. hidden is display: none, so until the page bundle executed, the section occupied zero pixels; then the whole 271px of it appeared and pushed the grid, the pulse strip and everything below them down. That single reveal measured 0.178 of the page's 0.257 desktop CLS. The skeleton could not help, because the skeleton was inside the thing that did not exist yet.
A placeholder that is not the size of the real card is a second shift, not a fix. Measured on production at six viewport widths, the skeleton podium was 190px against a loaded podium of 235px on desktop, so the swap moved the page again by 45px.
Both are fixed in the markup rather than the module. The section ships visible with its three placeholder cards in pages/marketplace.html, so the box exists in the first frame; .mkt-top-card carries a min-height (235px, and 72px in the 640px query) that the placeholder and the loaded card both obey, so the swap is a no-op for layout. loadTopPerformers() now only replaces the podium's contents, clears the aria-busy it ships with, or hides the section when the feed is empty.
Below 640px the podium is a single column, which makes the placeholder count decide its height rather than just the card size, so the 640px query hides every placeholder after the first. Three placeholders there would have reserved three rows for a feed that currently returns one agent, and over-reserving shifts the page exactly as surely as under-reserving; that was a regression introduced and caught inside this change, not a pre-existing one.
Two residuals are measured and left, both smaller than what they replace. If the leaderboard starts returning three agents, the mobile column grows from one row to three (a 160px shift, against the 268px the same load costs today). And a name long enough to wrap grows a loaded card past the 72px floor at 390px and narrower, by 14px to 32px. Reserving for a count you do not know yet is not solvable in CSS; reserving for the card you do know is.
A loading state is a size before it is a shimmer. Build it out of the same element as the real thing, ship it in the HTML, and check both heights in the browser rather than assuming they match.
6. Whoever writes a node's text owns it, and i18n has to be told
Invariant: JavaScript that replaces the text of an element carrying data-i18n removes the attribute in the same statement.
/forge measured a CLS of 0.232 on desktop, and 0.1785 of it was a single shift. A probe of the live page found the cause: at DOMContentLoaded the example-prompt chips held their randomized prompts and the row was 168px tall, and about a second later they had reverted to the static English labels from the HTML at 99px. That 69px collapse moved the quality tiles, the composer row, the Generate button and everything below them.
The mechanism is ownership. The static chips carry data-i18n keys so a visitor with no JavaScript still gets translated copy. applyCatalog in src/i18n.js walks every [data-i18n] node whenever a catalog loads or the locale changes, and writes the keyed string back. Once the randomizer has replaced a chip's label, the key no longer describes that node, so i18n was faithfully undoing the rotation on every single load. The layout shift was the visible half of a functional bug: the "fresh set every visit" promise silently did not hold.
The fix is one line next to the write, in setChipPrompt() in src/forge-prompt-studio.js:
function setChipPrompt(chip, text) {
chip.textContent = text;
chip.removeAttribute('data-i18n');
}
Any node whose text becomes dynamic loses its data-i18n at the point it becomes dynamic. Not later, not in a cleanup pass. src/i18n.js uses the same guard for data-auth-name in the nav.
Since 2026-09-30 applyCatalog also backs this up on its own: primeOwnership() records what each annotated element held when the runtime first saw it, and a pass skips any element whose content now matches neither that, nor the runtime's own last write, nor the English source string, because the page wrote it. That catches writers that never opted out, but it is a safety net, not the contract. Removing the attribute at the write is still the rule, because it is explicit and does not depend on the boot order of the page's scripts.
That fixed the revert. It did not fix the growth.
The 2026-08-15 sweep ran against a build that already contained the fix above, and /forge still measured CLS 0.256 desktop, 0.263 mobile, with <div class="chips" id="examples"> still named as the largest single shift at 0.190. Removing the revert removed one direction of a shift that had two.
The remaining direction was the first one: static labels to seeded labels. The static markup shipped five short examples ("a potted monstera plant") totalling 132 characters, and seedChips() replaced them on every JS visit with generated prompts capped at 64 characters each. The generator's own distribution is the whole story: a prompt averages 53.5 characters and cannot go below 29, so the seeded row averaged 268 characters and could reach 320. The row a visitor sees was always more than twice as wide as the row first paint reserved for it, and .chips is flex-wrap, so the difference arrived as extra lines that pushed the composer and everything under it down.
There is no way to generate a row narrow enough to fit the old markup. Only three distinct prompts in the entire grammar are 37 characters or shorter, so a per-label cap tight enough to match the static copy would leave the row with duplicates. The reservation has to move to meet the content, not the other way round:
- The labels in pages/forge.html are now written at the 64-character cap, so first paint reserves the row's worst case. Both rows carry
data-no-i18n, which keepsscripts/i18n-annotate.mjsfrom re-adding the attribute the section above exists to remove. The generated replacements are English at every locale, so a translated label was only ever visible for the instant before it was overwritten. generateForgeChipSet()in src/forge-prompt-gen.js fits a rotation inside the character budget of the labels it replaces, so it can never exceed the reservation. It walks the candidate pool in generated order to keep the row varied, accepting a prompt only while the shortest remaining candidates could still fill the leftover slots.pinRowHeight()holds the row at its measured height across the swap, so a rotation that wraps onto fewer lines cannot shift the page upward either. The pin is released on the first resize, which relayouts the page anyway.
tests/forge-prompt-gen.test.js reads the labels out of pages/forge.html rather than copying them, so shortening the shipped copy fails the suite instead of silently restoring the shift.
Verified against the live page's own CSS by replacing the row's contents and measuring its height, six viewport widths, sixty random rotations each. The growth column is what the page shifts by:
| Viewport | Reserved, before | Seeded, before | Growth | Reserved, after | Seeded, after | Growth |
|---|---|---|---|---|---|---|
| 1440px | 99px | 202px | 103px | 202px | 202px | 0px |
| 1350px | 99px | 202px | 103px | 202px | 202px | 0px |
| 1024px | 63px | 99px | 36px | 99px | 99px | 0px |
| 768px | 64px | 167px | 103px | 133px | 133px | 0px |
| 390px | 194px | 295px | 101px | 295px | 295px | 0px |
| 320px | 244px | 295px | 51px | 295px | 295px | 0px |
A static placeholder is a space reservation before it is copy. If JavaScript is going to replace it, size the placeholder like the thing that replaces it, and make the replacement fit.
7. The hero's model is chosen inside a byte budget
Invariant: code that picks a GLB for a fixed slot picks it by size, not by whatever the feed returns first.
The homepage hero calls /api/avatars/featured and rendered the first entry that resolved. That list is curated by editorial flag and view count, and its members range from a 90 KB prop to a 10.7 MB scan. On 2026-09-04 the first entry was a 4.6 MB model, which is 4.6 MB of download, parse and GPU upload landing on the critical path of every homepage visit, while the page is still trying to become interactive. A Lighthouse desktop trace measured 29,660ms of total blocking time, against 9,649ms for the same page with only *.glb withheld. The hero was two thirds of the page's blocking time and 4.6 MB of its 6.9 MB.
Nothing about that was a scheduling problem. The hero is the above-the-fold LCP element and is correctly eager (see rule 4's exception); the defect was that no one chose how heavy it was allowed to be.
api/avatars/featured.js now reports each candidate's size_bytes, the column the detail endpoint already returned, so the choice is made from one response instead of a detail fetch per candidate. resolveFeaturedGlb() in src/home-live-agents.js takes the largest candidate inside a 2.5 MB budget, which is the richest model the page can afford, and falls back to the smallest when nothing fits, because an over-budget hero that renders beats an empty stage. Candidates the API reports no size for keep their curated order behind the sized ones; over-budget candidates stay in the list as fallbacks, so an outage of the affordable ones still fills the stage.
Verified against the live featured list: the old code took a 3.71 MB model, the new code takes a 2.06 MB rigged, textured, animated humanoid, and every one of the twelve candidates is still reachable in order with no duplicates.
The budget is a product lever, not just a performance one. It is HERO_GLB_BUDGET_BYTES, one named constant, and raising it is a decision about how much of the first visit the hero is allowed to spend. Curating a heavier avatar into the featured list no longer silently makes that decision for everyone.
8. Deferred work waits for a quiet main thread, not for a deadline
Invariant: a feature deferred for performance reasons resumes when the thread is actually free. requestIdleCallback(fn, { timeout }) is a deadline, and it fires whether or not the thread ever went idle.
The walk companion auto-summons for a first-time visitor: it loads Three.js core and addons (616 KiB), an avatar GLB, the shared clip library (idle.json alone is 421 KiB) and starts a WebGL render loop. It was scheduled setTimeout(2000) after load, then requestIdleCallback(summon, { timeout: 4000 }). The timeout is the bug. On a page that is still executing its own long tasks the callback fires anyway, so the companion's boot does not run instead of the page's work, it runs on top of it and both get slower. A Lighthouse desktop trace attributed 25,468ms of bootup on /forge to walk-companion.js, the single largest entry on that page, and the same page measured with the companion off scored 71 against 43.
public/nav.js now waits for real quiet: a PerformanceObserver on longtask entries, and the summon runs on the first idle callback after 1.2s with no long task. If the page never goes quiet within 20s the companion is simply not summoned there, and that is the intended outcome rather than a failure. The visitor's choice stays unrecorded, so the next page they open (or the nav's Walk button) summons it then. The promise is that their agent turns up on its own, not that it turns up while the page is still loading. Browsers without the longtask entry type (Safari) keep the old single deferred callback, because there is no way for them to tell busy from idle.
Verified in a browser against the dev server: /create and /forge still auto-summon (walk:companion:enabled becomes 1, walk-companion.js is fetched, window.__walkCompanion exists), and a measurement of the same pages puts the first 1.2s quiet gap at 1,386ms after load on /forge, so the wait costs a healthy page almost nothing and only bites the pages that were being hurt.
The same shape is worth auditing wherever it appears. Rule 2's PostHog snippet uses a 2s deadline for the same reason, and it is a defensible trade there: analytics has a blind spot to cap, and 89 KiB is an order of magnitude less than a 3D engine. The rule is not "never use a timeout", it is "know which one you are writing, and size the deadline against what fires when it expires."
The site footer is the lowest thing on every page, so its 3D bot loads last
The rule above was written about sections. The most expensive violation of it was not a section at all: it was the decorative robot in the site footer, and it was costing more than everything the rule had already caught.
public/footer.js injects /footer.html into any page holding <div id="footer-container">, which was roughly 175 pages when this rule was written and was 269 HTML files under pages/ and public/ on 2026-09-17 and is 328 as of 2026-10-23 (grep -rl footer-container pages/ public/ | wc -l). It only ever grows, which is the point of the rule. That markup contains #footer-bot-canvas, and the injector booted its renderer immediately, at DOMContentLoaded, down one of two branches:
- A page carrying
<meta name="has-three-bundle">(every Vite-built page) loaded/footer-bot.js, which builds aWebGLRenderer, claims a context off the shared budget in src/webgl-budget.js, and loadsrobotexpressive.glb. - A plain HTML page (login, register, the dashboard,
/docs,/discover) instead pulledmodel-viewerfromajax.googleapis.com, a second complete 3D engine, plus the meshopt shim and the same GLB.
Measured against production on 2026-08-15, that decoration was the single largest main-thread consumer on the page it landed on:
| Page | Branch | Cost, eager |
|---|---|---|
/forge |
footer-bot.js |
19,654ms of bootup, more than the page's own bundle (1,473ms) |
/docs |
model-viewer |
839ms of bootup and 253 KiB transferred, on a 701 KiB page |
/create |
footer-bot.js |
107 KiB GLB plus a WebGL context, on a page already running Three.js |
loading="lazy" on the <model-viewer> element did not help, and could not: it defers the model, while the 253 KiB module that defines the element had already been fetched and evaluated.
Both branches now sit behind whenNearViewport() in the same file, an IntersectionObserver on .h-footer-avatar at rootMargin: '600px 0px', so the bot loads a screenful before the footer arrives and is rendered by the time it is on screen. Browsers without IntersectionObserver load it on the first scroll instead, so it still appears on the way down rather than never.
Verified by loading the real production pages twice in the same browser, the second time with only /footer.js swapped for the working-tree file, then scrolling to the footer to confirm the bot still arrives:
| Page | Transferred, before | after | Long tasks, before | after | Footer bot loaded on open | after scrolling |
|---|---|---|---|---|---|---|
/docs |
675 KiB | 426 KiB | 62ms | 17ms | yes | yes |
/forge |
7,379 KiB | 7,283 KiB | 426ms | 138ms | yes | yes |
/create |
2,215 KiB | 1,528 KiB | 8,422ms | 2,510ms | yes | yes |
Deferring it also fixes an ordering bug nobody had filed. The footer bot reserved a WebGL context at DOMContentLoaded, ahead of the <agent-3d> instances the visitor came to look at; on a page near the browser's context limit the decoration could win and a real avatar lose. Now the content claims contexts first and the footer takes what is left, which is what reserveWebGLContext() was always for. The bot's own failure path already degrades to an empty canvas, so losing that race is silent and harmless.
Anything injected into a shared chrome partial follows this rule too. A cost paid in the footer is a cost paid on every page on the site, which makes it the most expensive place on the platform to be careless.
Before you gate something, check where it actually is. Paste this into DevTools:
['dragon-canvas-wrap', 'home-forge', 'home-pose'].forEach((id) => {
const el = document.getElementById(id);
if (el) console.log(id, Math.round(el.getBoundingClientRect().top + scrollY),
'trigger at', innerHeight + 200);
});
The phone
Everything above was written from desktop traces. On 2026-09-08 the same site
was measured on a Pixel 5 over slow 4G with scripts/mobile-perf.mjs and
scripts/mobile-touch-audit.mjs (Playwright field metrics, not Lighthouse
scores; see the harness header before quoting a number). The full run is in
prompts/quality-bar/_generated/08/.
Four of the five costs that run found were not slow code. They were a rule that never reached the page, a property that should never have been animated, a write that should never have happened, and an asset with only one size. Each is a rule now.
9. A stylesheet only applies to pages that link it
Invariant: anything that has to apply site-wide is injected by the build, not
hand-linked, and the injector covers public/ as well as Rollup's inputs.
public/mobile.css carries the site's tap-target floor, its canvas scroll
posture and its safe-area rules. It was reaching 192 of the 584 pages that
carry a stylesheet at all. The mobile-ergonomics plugin in
vite.config.js already injected it, and transformIndexHtml
only ever sees Rollup's HTML inputs: every file under public/ is copied into
dist/ byte-for-byte and never passes through that hook. Three of the fifteen
pages the mobile audit samples were in that blind spot, /changelog, /ar and
the entire /docs shell.
The measured cost is the part worth remembering. /docs/start-here reported
308 undersized touch targets, 296 of them sidebar links at 267x30, and
public/mobile.css had already contained a rule sizing .sidebar-link to 44px
for months. Nothing was wrong with the rule. It was not on the page. The audit
that found it could not tell the difference, and neither could anyone reading the
CSS.
The same plugin now also runs as a post-build sweep over every HTML file in
dist/, which is the one place both kinds of page meet. Both of its rewrites
(the stylesheet link and viewport-fit=cover) are idempotent, so a page that
went through transformIndexHtml is unchanged by the second pass. The build
prints how many static pages it patched; on the first run that was 210.
When you add something that must be true of every page, check dist/, not
pages/. A grep over the source directory that produced the page you were
thinking of will agree with you and be wrong.
10. Never animate a layout property
Invariant: a persistent overlay that moves, moves with transform.
#tws-corner-stack (public/corner-stack.js) is position: fixed, and it lifts
itself clear of a page's own bottom chrome by transitioning bottom and right.
Those are layout properties: the element is re-laid-out on every frame of the
transition, and every one of those frames is reported to the layout-instability
API. A fixed overlay that no page content is attached to was therefore charging
real CLS to the page underneath it, once per dock re-measure, and the stack
re-measures on a settle timer and on every body mutation.
Measured on a Pixel 5 against production: 0.0764 twice on /marketplace
(0.153 of that page's 0.4381 total, the worst CLS on the site), 0.0810 on
/launches, 0.0764 on /agents/:id, 0.0601 on /walk.
The fix lands on the same pixels: one transform: translate3d() driven by the
same custom properties, transitioned instead of the offsets. A composited
transform generates no layout shift at all. It also collapsed two rules into one,
because the phone breakpoint no longer has to restate the offsets, and it forced
one real change: the narrow layout can no longer pin the stack to both edges,
since a box anchored left AND right slides its left edge off screen when the
transform moves it. Room to grow leftward is a max-width now.
tests/corner-stack.test.js pins both halves.
11. Writing a value a node already holds re-dates the page's LCP
Invariant: a pass that walks the DOM writing values compares before it writes.
applyCatalog in src/i18n.js walks every [data-i18n],
[data-i18n-html] and [data-i18n-attr] node and writes the catalog's value
into it. On the default locale nearly every one of those writes is a no-op: the
markup ships the English source and the English catalog hands the same string
back.
It is not a no-op to the browser. Replacing an element's text destroys its text
node and creates a new one, and Chrome scores that as a fresh LCP candidate at
the moment it happens. The catalog arrives after an async fetch, several
seconds into a page on a phone, so every annotated page's LCP was re-dated to the
i18n pass. Measured on a Pixel 5 over slow 4G against production: / reported
LCP 10,188 ms on h1.hero-h, a static heading that had painted at an FCP of
2,336 ms; /docs/start-here reported 5,168 ms on a <p>. Not one pixel
changed at either moment.
The guard is an identity check before each write. Markup needs normalising first,
because the browser rewrites attribute quoting, entity forms and self-closing
tags on the way in and a raw catalog string never equals the innerHTML it
produced; round-tripping the candidate through a detached element puts both sides
in the same normal form.
tests/i18n-idempotent-writes.test.js
asserts on node identity, not on the resulting text, because surviving is the
only thing the browser's LCP bookkeeping cares about.
Any pass that rewrites a lot of nodes deserves the same question: how many of those writes change anything?
12. A curated asset gets a size per tier, not one size
Invariant: a large static asset chosen by us ships in a phone-sized copy, and the tier table decides which one is fetched.
Two of the three largest downloads on /play were assets nobody had ever chosen
a size for.
/hdri/outdoor.hdr was 1,435 KB of that page's 5,470 KB. The environment map
is PMREM-prefiltered into irradiance before it lights anything, so nearly all of
its resolution is discarded on the way in; only its energy has to survive.
QUALITY_TIERS in src/shared/cinematic-render.js
already had a tier that opted out of HDRIs entirely, and that tier is the weakest
one. A real mid-tier phone (coarse pointer, 4 GB of RAM, which is not "low") lands
on medium and was pulling the full file. medium now reads a 512x256 copy,
about 360 KB, and loadEnvironment defaults its tier from the same capability
probe the renderer uses, so every existing call site improved without an edit.
scripts/build-hdri-mobile.mjs regenerates and verifies those copies, and its two hard-won details are the transferable part:
zscale, notscale. swscale runs float input through a 16-bit fixed-point intermediate and clamps to 1.0, which takesoutdoor.hdr's peak radiance from 61,408 to exactly 1.00 and halves its mean. The output still loads, still looks like an image, and lights a scene completely wrong.bilinear, notlanczos. Image-based lighting cares about energy, not edges, and a windowed-sinc kernel rings around a sun disc with 60,000:1 contrast. Mean radiance against the original: bilinear -0.3%, bicubic +4.8%, lanczos +12.0%.
The other one was a URL. HOME_TOWN.image in
src/game/home-town.js is the coin art for the world
every first-time /play visitor lands in, and it was a literal /api/img?url=…
with no w=, so the proxy handed back all 581 KB of the pinned original to
texture a totem a few hundred pixels tall. mapCoins() had asked for w=512 for
exactly this reason since the feed path was written; the hand-written literal
predated it. Two more call sites in the community lobby had the same gap.
A proxy that can resize only resizes when asked. If you write an image URL by hand, write the width with it.
Open: three costs the 2026-08-15 sweep measured and did not fix
Each of these is the largest remaining number on the page it belongs to, and each one lands in a surface the sweep that found it had no business rewriting. They are recorded here with the measurement so the next pass starts from a number rather than a hunch.
/chat is one 4,277 KiB JavaScript chunk. Closed on 2026-09-04: the page now transfers 747 KiB, blocks for 2ms and scores 99 desktop. The measurement that follows is kept as the record of what it cost. The page made 23 requests and chat/assets/index-*.js was 4,277 KiB of them; nothing renders until it has parsed, which is the entire story of its FCP (3,901ms desktop, 23,105ms mobile) and of an LCP that lands 140ms later. Blocking time is one millisecond, so no amount of deferring helps: the work is a single parse of a single chunk. chat/vite.config.js sets no manualChunks and no inlineDynamicImports; the app simply imports everything statically from its entry, so Vite has nothing to split on. The fix is dynamic imports at the route and feature boundaries inside chat/src, which is a refactor of the sub-app rather than a build-config change.
/forge showcase thumbnails are full-size renders. Twelve images (served from pub-*.r2.dev when measured, from the same-origin /cdn/ proxy since 2026-10-24) account for 6,273 KiB of the page's 8,339 KiB, averaging 520 KB each. They are the 768x768 PNGs that api/_lib/forge-thumbs.js generates (THUMB_SIZE = 768), painted into a 200px-tall box. loading="lazy" and decoding="async" are already set per rule 5, so this is not a scheduling problem, it is a format and size problem: the same renders as WebP at a display-appropriate size are roughly a tenth of the bytes. The fix has to change the generator, re-run the backfill cron over existing rows, and handle the forge/thumb/<id>.png key extension that forgeThumbKeyFor() and the stored preview_image_url values both encode. One outlier in the same trace is a data-freshness artifact rather than a bug: a 2,358 KiB forge/<clientKey>/<id>.png is the untouched original for a row the backfill has not reached yet.
The brand mark is an 85 KB SVG rendered at 22 pixels. public/three.svg and the byte-identical public/favicon.svg are 85,257-byte SVGs wrapping two 800x436 PNGs behind feColorMatrix filters. They are referenced from 545 files as of 2026-09-17 (446 of them HTML: grep -rl '/three\.svg\|/favicon\.svg' pages/ public/ src/ | wc -l, up from 171 when this item was first measured), cost 62 KiB over the wire per page, and no call site in the repo renders the mark above 64 CSS px. Re-encoding the embedded rasters at exactly half resolution (800 to 400, lanczos3, no palette quantization) takes the file to 36,913 bytes and is visually indistinguishable at every size the site uses, with a maximum channel delta of 4 at 22px and 10 at 64px. It is not free above that: at 192px, which some platforms use for an SVG favicon, the delta reaches 105. Fractional downscales are much worse than the exact half (320px wide measured a delta of 78 at 22px), so this is a brand-asset decision with a measured cost attached, not a mechanical resize, and it needs the owner rather than a sweep.
/marketplace's hero was the site's worst CLS, and is closed as of 2026-09-08.
Not through the GLB budget guessed at below, which is still worth doing: through
the meta column. The hero rotates every 6.5s and updateHeroMeta() writes each
avatar's name and blurb into the same two boxes, which are different lengths for
every slide, so the actions row, the dots and the whole grid below moved on every
rotation, forever. Measured on a Pixel 5 against production, section#market-hero
was 0.1094 + 0.2045 of the page's 0.4381 CLS. Both boxes are now clamped AND
floored to the same line count, so every slide occupies identical space; the
"Start an agent" button ships in the markup at its final label instead of being
revealed into a flex-wrap row after first paint. Clamping without a floor is
only half a fix: it caps the tall case and lets the short case collapse.
/marketplace was not touched by the 2026-09-04 sweep and is the worst page on the list. It measured 38 desktop at a benchmarkIndex of 1,183, with 22,560ms of blocking time, an LCP of 3,272ms and 11,790 KiB transferred, which is more than the other seven pages put together. Its viewers already obey rule 4's data-src contract and its podium already obeys rule 5, and the page still mounts a hero carousel, a six-item themed strip and a card grid, all of them above the fold at 1350x940, so the contract has nothing left to defer. A single hero GLB was 3,341 KiB in that trace, which is rule 7's problem in a second place: renderHero() in src/marketplace.js takes whatever state.featured returns without asking how heavy it is. Applying rule 7's budget there is the obvious next move and it needs its own measurement, because unlike the homepage this page shows three avatars at once and the budget has to be shared.
Half-closed on 2026-10-13: directory thumbnails had no cache headers
The caching half is fixed; the sizing half is still open.
The measurement, kept as the record: /discover downloaded 28 images totalling 9,360 KiB, of which 27 were avatar thumbnails at roughly 280 KB each. Every one came from the Cloudflare pub-*.r2.dev public endpoint, which answers with no Cache-Control header at all: Lighthouse's cache-insight reported a cache lifetime of 0 for 29 resources, so a returning visitor re-downloaded all of it. /cdn/<key> (api/cdn-object.js) proxies the same bucket and answers public, max-age=3600, s-maxage=86400, stale-while-revalidate=604800 for thumb/ keys (other keys get max-age=86400, s-maxage=2592000).
What shipped: thumbnailUrl() in api/_lib/r2.js now resolves a stored key (or a legacy raw-bucket URL, via keyFromPublicUrl()) to an absolute <APP_ORIGIN>/cdn/<key> URL through cdnUrlOrNull(), so every first-party feed and the documented GET /api/explore image field carry the cached, same-origin URL. It is absolute rather than relative because /api/explore has third-party consumers and draft-mint.js bakes the URL into on-chain metadata. Stored forge_creations URL columns written before the change are rewritten on read by normalizeStoredUrl(), and the forge thumbnail writer (api/_lib/forge-thumbs.js) now writes the /cdn/ form. Serving through /cdn/ also removes the cross-origin r2.dev reads that Chrome's Opaque Response Blocking was rejecting. tests/thumbnail-url-guard.test.js and tests/r2-normalize-stored-url.test.js hold the split.
Still open: the thumbnails are stored at 768x768 and painted into a 293px box, so the byte cost per card is unchanged on a first visit.
Half-closed on 2026-09-08: /forge's composer growth
The coach half is fixed. .prompt-coach shipped EMPTY at min-height: 1.2em and
updateCoach() wrote grade('')'s message into it, which does not fit beside
its neighbours in the flex-wrap .prompt-tools row, so the row wrapped onto a
second line and grew. pages/forge.html now ships that exact message, with
data-no-i18n per rule 6, and
tests/forge-prompt-coach.test.js reads
both pages/forge.html and src/forge-prompt-studio.js so the two copies cannot
drift back apart.
The engine-pill half below is unchanged and still open. It is the harder one: the settled height is a function of how many lanes the catalog returns and how they wrap, which is between 29px and 219px across viewport widths, so there is no constant to reserve. The shape that would work is the one rule 5 used on the podium, rendering the lane set the server already knows about into the markup.
Open: /forge's composer grows 95px after first paint, and rule 6 does not cover it
Rule 6 fixed the example-prompt row. The 2026-09-04 sweep measured /forge at CLS 0.226 on a benchmarkIndex of 1,196, with <div class="chips" id="examples"> still named as the largest shift, and a per-frame trace of the live page shows why: #examples is not growing, it is being pushed. Two containers above it in .forge-rail grow after first paint, and the chips row is simply the biggest thing that moves as a result.
Sampled every frame against production at 1350x940:
| Time | What changes | Composer height |
|---|---|---|
| 247ms | first paint | 547px |
| 625ms | .prompt-tools 26px to 64px, as #prompt-coach receives its first message and wraps onto its own line |
585px |
| 684ms | .fq-row--engine 50px to 86px and .estimate 11px to 32px, as buildEngineButtons() fills the pill |
642px |
That is 95px of growth, and the two shifts it produces measure 0.1957 and 0.0081, which is the page's entire CLS. Both are the same defect rule 5 names: a placeholder smaller than the thing that replaces it. .engine-pill:empty { min-height: 50px } is already an attempt at the second one and is now under-sized, because the catalog wraps onto two rows at desktop widths.
Neither has a reservation that holds across viewport widths, which is why this is recorded rather than fixed. Measured settled heights at ten widths, the growth is not a constant and not monotonic: .prompt-tools grows 38px at 1200 to 1440, 0px at 768 to 1024, 38px at 480, and 12px at 320 to 390, because whether the coach fits inline depends on the column width. The engine row settles at 29px, 61px, 86px, 127px, 173px and 219px across the same widths as the pill wraps onto more rows. Reserving a fixed number over-reserves somewhere, and over-reserving shifts the page exactly as surely as under-reserving.
One candidate fix was built and measured and is recorded here so the next pass does not repeat it. Giving .prompt-coach its own row unconditionally (flex: 1 0 100%) cuts the growth from 38px to 2px at six of the ten widths, and it fails on the other four: 50px at 900px, 15px at 320px and 390px where the filled message wraps to a second line the empty one did not reserve, and it costs a permanent 48px of empty space under the prompt box on first paint at every width. Trading a shift for a visible gap plus a residual shift is not a fix.
The shape that would work is the one rule 5 used on the podium: ship the settled content in the HTML so the box exists in the first frame. For the coach that means the grade('') message living in pages/forge.html with data-no-i18n, plus a test that reads both files so the two copies cannot drift, the way tests/forge-prompt-gen.test.js already does for the chips. For the engine pill it means rendering the lane set the server already knows about into the markup instead of only into buildEngineButtons(). Both are edits to the creation surface's own contract, which is more than a measurement sweep should decide on its own.
Known costs that are not bugs
Two things in the numbers above are real and are not being fixed by tuning:
model-vieweris a 1,587ms third-party evaluation (measured when it still loaded fromajax.googleapis.com; since the 4.4.0 move it comes from the jsDelivr, cdnjs, unpkg failover chain in src/shared/model-viewer-loader.js, and the evaluation cost is the same). It is preconnected and loaded lazily (measured arriving at 12.2s on the homepage, long after first paint), but the evaluation itself is the vendor's. Self-hosting it would move the bytes onto our CDN and change nothing about the parse cost. What is avoidable is paying it on a page that never mounts a viewer, which is rule 4's bundle clause.- The homepage is a long page with a lot on it. 14,825px of content with live 3D in the hero is a product decision, not an oversight. The rules above are what keep the parts a visitor has not reached from being charged to the parts they have.