DOM ENGINEV0.27.0FIZLET
Start

0.27.0 RELEASE NOTES · LATEST

Fizlet 0.27.0

By Chris Cooley ↗ · · CHANGELOG.md ↗

  • @fzlt/core/debug: touchLog(), an on-screen log of pointer and touch events for real phones. Finding why a control doesn't answer on an iPhone needed an on-screen log, written per game. import { touchLog } from "@fzlt/core/debug"; touchLog({ lines = 14, moves = false, host }) → { el, lines, stop() }: a fixed <pre> (aria-hidden, pointer-events: none, so it never takes a touch) listing the last lines events, each as ms since start, type (pointerdown, pointerup, pointercancel, gotpointercapture, lostpointercapture, touchstart, touchend, touchcancel, click; plus pointermove and touchmove with moves), pointer type and id or the touch count, x, y, and the element hit (tag#id.class, from composedPath(), so inside open shadow roots too, with its host). Listeners are passive captures on window: nothing is cancelled or stopped. Nothing is saved or sent. Dev only: wire it to your own query flag. stop() removes the box and every listener. Size: debug 486 → 1,133 B gz (+647 B; goal was +400: the event names and the inline style are strings that barely compress; inside the 1,536 B budget, no budget change); guardLayout alone is unchanged. Tests: new tests/debug-touchlog.test.mjs (Node fake DOM: a line per event with the element hit, a touch event's count and place, a shadow root's target and host, the last N kept, no moves unless asked, listeners capture and are passive and cancel nothing, stop() removes the box and every listener, host), new tests/webkit-touchlog.mjs in Chromium and WebKit (npm run test:webkit: real taps log pointer and touch events and the click, an icon inside a shadow root names its host, a tap through the box lands on the key under it, the page still gets every click, stop() gives the page back).
  • Board UI kit: [hidden] wins kit-wide, and icons inside keys never take a touch. A component's own display (an overlay's, coach's inline grid, a game's grid or flex panel) beat the browser's [hidden], so the kit carried one rule per component and games patched the rest. Now one rule, .bui [hidden] { display: none !important }, replaces the overlay's and coach's: anything with hidden inside a .bui root has no box, and its own display is back as soon as hidden is off. An SVG icon inside a key or the pad (.bui button svg, .bui .bui-key svg, .bui .bui-pad svg) takes pointer-events: none, so a tap on the icon presses its key (in WebKit an unsized SVG lays out 300 × 150 and could swallow the thumb); icon sizes still come from the key. Migration: game-side [hidden] { display: none } rules for parts inside .bui can go; a part inside .bui that is meant to stay visible must not carry hidden. Size: ui css 5,139 → 5,141 B gz (+2 B, inside the 5,152 B budget); arcade unchanged. Tests: tests/ui.test.mjs (one kit-wide [hidden] rule with !important, no per-component rules left, the icon selectors), new tests/webkit-ui.mjs in Chromium and WebKit (npm run test:webkit: a hidden grid, flex and overlay have no box and the grid's display comes back; at each icon's centre the hit target is the key; a real tap on each icon presses its key; it fails on the old CSS).
  • @fzlt/core/terrain: haze on terrainView, and the far ring as a recipe. Endless grounds drew the horizon by hand: the near ground faded into a haze and a coarse copy of the same ground was drawn behind it. New view option haze: { from, to, color }: each face fades into color by its cell's distance in the floor plane from the camera's target (the player, under a chase camera): untouched before from, all color past to, 16 steps between, all made once as strings (33 shades × 17 haze steps a colour), so a draw mixes nothing. colors(bands, steepColor, kinds, haze) takes a new haze on a theme change (null turns it off). Shadows are not hazed. Without haze the shades and the order are the same as before (the 0.25.0 golden hashes hold). The far ring needs no new code: a second, coarse terrainWindow over the same ground (4-unit cells, 136 a side, step 4) with its own terrainView in a fixed cluster behind the near one (cluster: "far", fixed: -1) and the same haze as the near view, so the two grounds meet at the same haze level. Measured in Chromium (800 × 450 at 1×, this build machine, not a phone): a 160 × 160 near window at 0.5-unit cells (3,939 faces) draws in 9.3 ms, with haze 8.5 to 9.4 ms (no measurable cost), and with the far ring (+1,957 faces) 17.4 to 17.9 ms. What haze does not do: a hand-drawn far ring of discrete hazier ridgeline bands, each with a lighter crest line and one silhouette per screen column, is a different renderer. The terrain far ring is the ground itself, faded continuously, and costs a full second view. That look stays in the game until there is a measured need for a band renderer (none in this push). Size: terrainView alone 2,901 → 3,050 B gz (+149 B; goal ≤ +150); the whole module 5,366 → 5,511 B gz (+145 B; budget 5,440 → 5,568 B, scripts/sizes.mjs). Tests: tests/terrain.test.mjs (straight down over flat ground, every face: past to it is the haze colour exactly, before from it is the unhazed shade exactly, between it has moved; geometry and order are unchanged; two draws are the same, with no clock and nothing animated, so reduced motion changes nothing; a theme change takes the new colour and null brings back the plain shades; zero allocation over 3,000 hazed draws with level of detail).
  • @fzlt/core/terrain: terrainWindow, a terrain that streams an endless ground. Endless worlds slid a heightfield window by hand (copyWithin, then a pure height function for the new strip) and, to make it terrain-shaped, copied terrain's face query, so the drawn face and the ridden face were two copies of one rule; a game wrote it twice. New tree-shakable export terrainWindow({ cols, rows, cell, step, split, fill(i0, j0, i1, j1, t) }): a real Terrain (the same object terrain() makes: height, normal, sample, kindAt, at, version, and terrainView draws it) whose first vertex sits on the world lattice at origin ([i, j], with x0 = i × cell, z0 = j × cell). follow(x, z) keeps the point in the window's middle step, sliding by whole steps; moveTo(i, j) puts the first vertex anywhere. A move keeps what overlaps (heights and kinds, copyWithin) and calls fill only for the rows and columns it gains (each range takes one kept vertex line on its inner side so every new cell is inside it; a jump past the window refills it whole); version bumps once per move; stats counts moves and filled vertices. Only integers cross the fill call (a double argument boxes when a call is not inlined); fill must be a pure function of the place, so where the window sits is never game state. The adaptive split is the one rule in face(): terrain()'s queries now read the origin from x0/z0 (a window moves them) instead of a closure; heights, normals and the 0.25.0 golden hashes are unchanged. terrainView already re-read bounds on version and positions from x0/z0 every draw, so a view re-anchors on every slide (checked; in sort: "depth" chunk anchors come from the last update, one draw behind a slide as they are behind a camera move: tv.update() before the draw makes the slide frame exact). Migration: where a game slides its own window, make it terrainWindow({ cols, cell, step, split: "adaptive", fill }), move its strip loop into fill (world x = (t.origin[0] + i) × cell), and delete its copy of the face query. Measured in Node: 160 × 160 cells, step 16: 0.028 ms per slide with a hash ground (0.010 ms of it the copy), 2,737 vertices filled per slide; sample 38.5 ns (39.1 before). Size: the whole module 4,933 → 5,366 B gz (+433 B; budget 4,992 → 5,440 B); terrain() alone 2,191 → 2,199 B; new entry terrainWindow alone 2,630 B (budget 2,688 B, scripts/sizes.mjs). Tests: tests/terrain.test.mjs (after 200 random slides, follows, short and far moves, the window equals a fresh terrain built at its place bit for bit in heights, kinds and every query, fixed and adaptive; only the new strips are filled, with the exact ranges; version bumps once per move and not on a no-op; the same seed streams the same bytes; a kept point reads the same height after a slide and the seam between kept and filled columns has no step; its view draws the same faces, places and shades as a fixed terrain at that place in ground and depth sort, with level of detail; zero young GCs streaming 10 km with a sample every step), tests/terrain-drive.mjs (Chromium: the window's canvas equals a fixed terrain's pixel for pixel at five places, ground and depth sort).
  • @fzlt/core/diorama: eye() and occlude(), an occlusion helper for chase cameras. A chase camera in a town needs the buildings between the eye and the rider to fade; a game wrote about 80 lines for it and recomputed the eye from cam by hand. d.eye(out) gives the camera's world position (from the basis draw already builds). occlude(d, { objects, ghost = 0.16, t = 0.15, reduced, near = 0 }) (a tree-shakable export) returns { step(dt, pts, n?), reduced, tested }: each step casts rays from the eye to the target points (pts, [x, y, z, …] world) against each object's box (size from its bottom-centre pos, turned by rot[1]; root objects); one in the way eases its alpha toward ghost at dt / t a step, one the eye is inside toward 0, the rest back to 1; reduced (option and live field) snaps; near treats a box met within that distance of a target as touching it (a rider against a wall), not in the way. It returns true while anything is still fading, so the engine stays awake, and writes alpha only (render side, never the sim). Boxes off the bounds of the eye and the targets skip the ray test (tested counts the rest). Migration: where a game fades occluders by hand (its own eye from cam, box-vs-box rejects, slab tests and alpha easing), build occlude(d, { objects: buildings, near }) once and call busy = oc.step(dt, pts) before draw; keep the engine awake while it returns true. Measured in Node: 256 objects and 5 targets, 8 boxes ray-tested after the bounds check; zero allocation over 10,000 steps; two runs give the same alphas step for step. Size: diorama() alone 6,589 → 6,611 B gz (eye, +22 B; goal ≤ +30), budgeted on its own (scripts/diorama-card.ts, 6,656 B); the module with occlude 7,257 B (+646 B when imported, over the 600 B goal by 46 B: the slab test, the bounds check, the eye-inside case and the easing), budget 6,656 → 7,296 B. Tests: tests/diorama.test.mjs (eye on two cameras; a box in the way ghosts in three 50 ms steps then idles; clear, back to 1; the eye inside, 0; reduced snaps; n limits the targets; near keeps a touching box; the bounds skip boxes, determinism, zero allocation).
  • @fzlt/core/diorama: points with rank: "depth" sort among clusters by their own depth. A point pool sorted inside one cluster (by default after every cluster), so debris or dust drew over a figure wherever it was; a game worked around it with a twin pool per point pool in a back cluster, moving each point between the two every frame. New pool option and live field rank: "depth" (d.points({ cap, rank: "depth" }), pool.rank = "depth" | null): each live point ranks as if it were an unfixed cluster anchored on itself, so it draws after the fixed clusters and the unfixed ones at least as far as it, and before the nearer ones; its layer orders it among other depth-ranked points between the same two clusters, and cluster is ignored. Pools without rank keep today's order. Internally cluster ranks are now even (2i) and depth-ranked points take the odd rank between, found by a binary search over the ranked clusters (no allocation). Migration: where a game twins a point pool into a back cluster and moves points between the two pools by depth each frame, keep one pool, add rank: "depth", and delete the twin pool and the per-frame move. Measured in Node (fake canvas): 24 boxes in 25 clusters with 512 points, 0.086 ms per draw with the points in one cluster, 0.088 ms ranked by depth; the same faces, points and drops counted either way; zero allocation over 10,000 draws of 512 depth-ranked points. Size 6,511 → 6,589 B gz (+78 B; budget 6,528 → 6,656 B, scripts/sizes.mjs). Tests: tests/diorama.test.mjs (a fixed room, a far wall and a figure: points behind the wall, level with its anchor, between and in front draw in that order; a pool without rank still draws after every cluster, and turning rank on is live; a point walked in front re-ranks; the point's layer does not beat a nearer cluster; two draws paint the same sequence; maxFaces drops still counted; the measured cost; zero allocation).
  • @fzlt/core/input: gamepad(), standard-layout controllers into the same intents (opt-in export). Games polled navigator.getGamepads() by hand, each with its own dead zone and button map. import { gamepad } from "@fzlt/core/input"; gamepad(controls, { map, dead = 0.15, index }) → { connected, count, value(intent), stop() }: mapped buttons press their intents (down from half a pull; value is the analog pull past the dead zone, a trigger's gas), the left stick steers the controller's stick (rescaled past the dead zone), index reads one pad per seat (default: every pad, merged). It polls in the controller's read phase, before the edges latch (a pad press is hit by the first step of its frame), and only while a pad is connected (gamepadconnected / gamepaddisconnected, plus a check at setup for a pad already exposed): a page without a pad never polls. A connect wakes a settled engine; a pad that leaves, or stop(), lets go of what it held. No Gamepad API, or a frame whose permissions policy blocks it: no pads, no error. Size: the whole input module 1,343 → 1,909 B gz (+566 B; goal was +450: the analog values, the per-seat index and the connect check; budget 1,536 → 1,920); controls() alone, the page build (7,100 → 7,098 B) and arcade (24,153 → 24,154 B, inside its budget) do not carry it. Tests: tests/bricks.test.mjs (a fake navigator.getGamepads: no polling without a pad, a press hit once then held, any of an intent's buttons, a trigger inside and past the dead zone, the stick's dead zone, rescale and full tilt, disconnect lets go and polling stops, stop() removes its listeners, index ignores another seat's pad, a connect wakes a settled engine, zero young GCs over 1M frames with a pad connected), tests/webkit-gamepad.mjs in Chromium and WebKit (npm run test:webkit: the API is there, no polling without a pad, a press, a trigger, the stick, unplugging).
  • @fzlt/core/diorama: off hides an object and its whole subtree and skips their matrix work. hidden hides only the object (its children still draw), so a pooled composite (a building with its roof and windows, a camp with its tent and lamp) could only be let go with hidden + alpha = 0 + parking it at a hide spot, plus a probe for orphan parts that still drew; hidden objects also kept getting their matrices every draw. New def and live flag off (d.add({ …, off: true }), ob.off = true | false between draws): the object and every descendant draw no faces, cast no shadows, are not picked and their matrices are not computed (the matrix pass marks the subtree and every later pass skips it; M keeps its value from the last draw it was on in). hidden keeps its meaning, so nothing changes for existing scenes. stats.objects now counts the objects whose matrices were computed this draw (all of them unless something is off; it was the scene's object count). Migration: where a game lets go of a pooled object with ob.hidden = true; ob.alpha = 0; ob.pos[1] = -50 (or any hide spot), write ob.off = true, and ob.off = false to take it back (no position or alpha to restore); delete any test probe that looks for orphan parts still drawing. Measured in Node (fake canvas): 200 pooled three-part composites, 1.4 to 1.8 ms per draw on, 0.04 ms with every pool root off; zero allocation over 10,000 draws toggling one of the 200 each draw. Size 6,479 → 6,511 B gz (+32 B, inside the 6,528 B budget). Tests: tests/diorama.test.mjs (a group with three parts, off on the parent: no part's faces, no shadows, not picked, stats.objects leaves them out; a moved off parent and its children keep their M; on again: the same faces, shadows, objects and colours as before; off on a mid part takes its child; hidden still shows children; the def flag; the measured cost and the zero-allocation toggle).
  • @fzlt/core/presence/rollback (new, BETA, in-house; API may move): rollback on presence's wire, lifted from the copy three games carried. Presence's lockstep waits for every input, so on a phone's network the sim runs only as fast as the slowest round trip; three games had each copied one ~333-line rollback link to get round it. rollback(engine, { transport, slot, players, input(frame), step(inputs, frame, live, sure), bytes, confirm, rewind, gone, window, hashEvery, delay }) runs every frame at once on this screen's input and the last input heard from everyone else; a real input that differs loads that frame's snapshot (a ring of the sim's byte views, made once) and runs the frames since again; frames whose inputs are all real are final (confirm, once, in order) and their state hash is compared (desync); the input delay adapts 1..3 frames from the measured trip; a screen that runs ahead waits a frame now and then (lead, waits); a seat the room says left plays gone from the same frame on every screen. The same 12-byte INPUT and HASH messages (delay and lead in INPUT's spare bytes) and the same relay: nothing in the room server changes. Behaviour is the games' copy, bit for bit (the same frames, corrections, waits, delays and state over five latency set-ups, two to four screens); new: lead, a fraction seat and a delay outside 1..3 throw. 2,176 B gz (budget 2,304; goal was 2,560). Tests: tests/rollback.test.mjs (two and four screens at four latencies end byte for byte on the run with no network; a 3-minute match with random latency, two and four screens, hash equal on every final frame; local input runs at once and final frames are confirmed once, in order; a late input rewinds and lands on the straight run's bytes, one for a final frame is dropped; a forced difference is a desync on both screens at the next hash; a leaver plays gone from the same frame; the delay follows the latency; a screen that starts ahead slows until the leads meet; bad options; zero young GCs over 20,000 ticks of four screens with corrections every few frames).
  • @fzlt/core/input: a new touch always takes the stick, even when iOS never ended the old one; CI runs the touch and pointer tests in WebKit too. iOS Safari can end a touch with no pointerup or pointercancel (sometimes only lostpointercapture, sometimes nothing). controls() started the stick only while its slot was free, so after a dropped release the stick stayed dead for the rest of the run. Now a touch on the stick side also takes a held stick when it is the primary pointer (no other finger is down, so the old one is stale): the old finger is forgotten and the stick starts from the new press; a second finger while the stick is really held is still the pointer (multi-touch unchanged), and lostpointercapture still ends a finger. @fzlt/core/pad already did this. Size: input 1,335 → 1,343 B gz (+8 B); arcade 24,147 → 24,153 B (+6 B, budget 24,150 → 24,156) and the card build 18,200 → 18,207 B (+7 B, budget 18,201 → 18,208), raised by the measured delta (a fix); the page build 7,094 → 7,100 B (budget 7,104). New CI job webkit (ubuntu-24.04, npx playwright install --with-deps webkit, part of the required check) runs npm run test:webkit in Chromium and WebKit (BROWSERS=chromium,webkit) at 390 × 844 with touch: tests/webkit-input.mjs (a real tap is one pointer hit, the stick's push and clamp, a finger that ends with only lostpointercapture, one that ends with nothing, a second finger stays the pointer), tests/webkit-pad.mjs (stick, d-pad, hold key and toggle, the same two shapes, real taps, the key's icon inside the key, every key at least 44 px), tests/webkit-touch.mjs (lockTouch cancels gesture events and two-finger touches on slots and game hosts, never one finger or the page's copy; release(); touch-action; a real tap lands, the page scrolls, 390 wide). Fingers are synthetic PointerEvents (WebKit has no CDP touch) plus page.touchscreen.tap. Playwright's Linux WebKit is WebKit, not iOS Safari: it catches engine differences, not iOS's touch delivery; real devices stay manual. Node: tests/bricks.test.mjs (a finger with no release, then a new primary touch takes the stick at its own origin and the old finger's moves are ignored; a non-primary second finger stays the pointer); it fails before the fix.
  • @fzlt/core/math (new, BETA): trig with the same bits on every engine. The builtins differ between engines in the last bit (measured: Chromium 153's and WebKit 26's Math.sin and Math.cos differ from Node 24's in about 3% of results, Math.atan2 in 18%), and one bit in a heading is a different game online. sin, cos, atan, atan2 are fdlibm 5.3's algorithms (the ones V8 ports) from + − × ÷, Math.sqrt/abs/trunc, % and bit reads only; hypot is steer's exact Math.hypot, moved here (@fzlt/core/steer re-exports it, so every import keeps working and every brick that takes it stays within ±9 B: renamer noise). In Node they equal the builtins bit for bit (one million seeded arguments each, every exponent, the edges: ±0, multiples of π/2, NaN, ±Infinity, |y/x| past 2^60 either way; the copy one of our racing games carried missed that last one for x < 0); Chromium and WebKit give the same committed digests of 120,000 results and a table of exact values (tests/math-engines.mjs, run here on Chromium 153 and WebKit 26). Past 2^20·π/2 radians the argument is first taken mod 2π: the same everywhere, no longer the builtin's. Zero allocation wherever it is called from: a double crossing a call the JIT does not inline is boxed, so the fdlibm bodies take their arguments from one shared buffer and leave their result in it, and the exports are tiny wrappers that inline; branches a run may never take are written so no merged value is left without type feedback (measured: 42 to 50 young GCs per million calls of the copy it started from, 0 now). 1,746 B gz (budget 1,792; goal was 1,536: ~0.4 KB is fdlibm's constants); sin and cos alone 926 B, atan2 alone 949 B, hypot alone 143 B. Tests: tests/math.test.mjs (the builtins' bits for 1M arguments per function, the edges, past the exact range, the digests and table, no builtin transcendental call in the source, zero young GCs over 2M calls in step-sized functions), tests/math-engines.mjs (Chromium, and WebKit when installed; MATH_ENGINES=chromium,webkit makes a missing one fail).
  • @fzlt/core/steer: the step's heading trig is @fzlt/core/math's, so a seeded run gives the same bits in every browser. turn() and every behaviour's drive (seek, flee, arrive, arriveGoal, wander, patrol, drive) called Math.atan2, Math.sin and Math.cos; they call the brick's now. Measured: the same seeded run (four movers, every behaviour, a wall, 1,200 frames) ended on one digest in Node and another in Chromium 153 and WebKit 26 before; now all three agree. In Node nothing changes, bit for bit: the brick equals Node's builtins, so the frame-by-frame tests against Battlefield Blitz's own drive pass unchanged (no golden change), and the zero-allocation tests stay at 0. API unchanged. Size 1,151 → 2,759 B gz (+1,608 B: sin, cos and atan2; the plan's goal was +700 B); budget 1,280 → 2,816. Bricks that take only hypot from steer don't move (arcade 24,138 → 24,139, board-page 4,104 → 4,104). Tests: tests/math-engines.mjs runs the seeded steer run in Chromium and WebKit against Node's. @fzlt/core/dice: no code change; its doc now says what was so: the tumble is the look and keeps the builtins (Math.sin, cos, acos, **), the values are integer maths and the same everywhere, so an online sim reads value, never path (moving the tumble onto the brick would cost ~2.7 KB: sin, cos, atan2 for acos and a pow for the eases).
  • Site: the roadmap's three brick items read ALPHA, not EXPERIMENTAL, the same label the bricks page shows; contest week 2026-W47 is open (any prompt). site/roadmap.mjs (E10.bricks, E17.diorama, E17.bricks) and the engine's roadmap agree; site/contest/weeks/2026-W47.json is the week file, no winner until the week is judged.
  • Site: the bricks hero's copy back on the left; the 3D block hangs off the right edge and slides in (owner feedback). From 1000 px the eyebrow, headline, lead and keys sit in a left column and the periodic table to its right, the 2D block next to the copy. Wide screens (1440 and up) fit both blocks: the copy keeps the page's left edge and the table may grow up to 120 px past the page's right edge, the split widening a little. Narrower (1000 to 1399): the 2D block sizes to fit beside the copy and the 3D block hangs off the screen's right edge with a soft fade and a "3D →" key; a click or tap on it, Enter on the key, an arrow into a 3D brick or a swipe left slides the table left (one 350 ms CSS transition, instant under reduced motion) by whole columns, so the 3D block ends at the content's edge and the 2D block slides under the copy (masked at its edge; the 2D label and the legend step out); "← 2D", Esc, a swipe right or an arrow back under the copy slides it back. The quick view moves with it (beside the 3D block when slid). The hero clips sideways, so the page never scrolls horizontally; phones keep the table scrolling in its own box. site/periodic.ts measures on resize only (data-peek, --shift, data-slid): no frame loop, no layout shift on load. tests/periodic.mjs checks copy-left at 1024 to 1920, the fit at 1440 and 1920, the peek at 1024 and 1280, the slide by click, keys, arrows, Esc and swipe, the quick view on screen, reduced motion, CLS 0 and no sideways page scroll from 390 to 1920.
  • Site: the bricks page's periodic table in two blocks, 2D and 3D, at the page's full width; the EXPERIMENTAL flag reads ALPHA (owner feedback). The table moves under the hero copy and splits into a 2D block (Kernel, Input, Network, In-house, Motion, Render, Game, Page) and a 3D block (Motion, Render, Game: the ten tabletop bricks on diorama, site/bricks.mjs DIMS), so the longest column is seven rows (was nine, plus a dashed tail below the fold) and the roadmap tiles end the columns in one row. In-house moves beside Network; its column head and note get their colour back (--k-hurt is no token: the kit's --hurt). The legend and the quick view share the bay under the first four columns; the quick view keeps everything inside its border (one track, minmax(0, 1fr); the sticker clears the close key). Narrow screens: the table scrolls in its own box with a SWIPE label and an edge fade (data-scrolls, data-end, measured on resize and scroll, no frame loop); the quick view is a bottom sheet up to 840 px, at most 560 px wide. The experimental key stays (export doc tags @experimental, the factory's audit); only the label changes, in STATUS, the README tables and the tests. tests/periodic.mjs checks the blocks, the fit at 1440, the card's contents and the swipe hint.
  • Site: the first weekly winners (2026-W44 to W46). The contest's three finished weeks are closed with a winner per lane, generated from the engine's content model (site/contest/weeks/, never by hand): W44 micro ILOVEYOU (#065, 7,224 B live) and Hi-Fi Oodles o' Moles (#070); W45 micro Never Loses (#091, 6,878 B) and Hi-Fi Mirror Maze (#096); W46 Hi-Fi Tilt Maze (#110), no micro entries that week. Sizes are the live chunk gzip, measured as the site builds it. The people test checks the shipped week files' shape; the winners are checked by the site build against the measured gallery.
  • Site: creators on the people page (the Fizlet Studio pattern); HOLESHOT by David Cooley. A new contributor kind, creator (scripts/people.mjs KINDS, REAL): a real person who makes games on Fizlet, with a CREATOR sticker and eyebrow, the maker's avatar label (a stylized character, not a likeness), no handle and no one to report to, and games, a list of { title, url, pitch } checked at build (https, one line) and rendered on the profile ("Games", each linked to its site) and in the /people/ lead ("HOLESHOT is by creator David Cooley"); any profile may list games, so the next creator is one JSON file. site/contributors/david-cooley.json: teen game creator, HOLESHOT ↗; the avatar is the maker's pixel rider (same 32 × 32 grid, two frames) in a black helmet and blue riding gear, avatar tokens only. The profile's structured data is a Person. Tests: tests/people.test.mjs (kind, sticker, label, games list, lead, avatar, validation), tests/site.mjs (built index and profile).

Every release