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 lastlinesevents, each as ms since start, type (pointerdown,pointerup,pointercancel,gotpointercapture,lostpointercapture,touchstart,touchend,touchcancel,click; pluspointermoveandtouchmovewithmoves), pointer type and id or the touch count, x, y, and the element hit (tag#id.class, fromcomposedPath(), 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);guardLayoutalone is unchanged. Tests: newtests/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), newtests/webkit-touchlog.mjsin 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 owndisplay(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 withhiddeninside a.buiroot has no box, and its own display is back as soon ashiddenis off. An SVG icon inside a key or the pad (.bui button svg,.bui .bui-key svg,.bui .bui-pad svg) takespointer-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.buican go; a part inside.buithat is meant to stay visible must not carryhidden. 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), newtests/webkit-ui.mjsin 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:hazeonterrainView, 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 optionhaze: { from, to, color }: each face fades intocolorby its cell's distance in the floor plane from the camera's target (the player, under a chase camera): untouched beforefrom, allcolorpastto, 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 (nullturns it off). Shadows are not hazed. Withouthazethe 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, coarseterrainWindowover the same ground (4-unit cells, 136 a side, step 4) with its ownterrainViewin a fixed cluster behind the near one (cluster: "far", fixed: -1) and the samehazeas 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, withhaze8.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:terrainViewalone 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: pasttoit is the haze colour exactly, beforefromit 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 andnullbrings 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 exportterrainWindow({ cols, rows, cell, step, split, fill(i0, j0, i1, j1, t) }): a realTerrain(the same objectterrain()makes:height,normal,sample,kindAt,at,version, andterrainViewdraws it) whose first vertex sits on the world lattice atorigin([i, j], withx0 = i × cell,z0 = j × cell).follow(x, z)keeps the point in the window's middle step, sliding by wholesteps;moveTo(i, j)puts the first vertex anywhere. A move keeps what overlaps (heights and kinds,copyWithin) and callsfillonly 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);versionbumps once per move;statscounts moves and filled vertices. Only integers cross thefillcall (a double argument boxes when a call is not inlined);fillmust be a pure function of the place, so where the window sits is never game state. The adaptive split is the one rule inface():terrain()'s queries now read the origin fromx0/z0(a window moves them) instead of a closure; heights, normals and the 0.25.0 golden hashes are unchanged.terrainViewalready re-read bounds onversionand positions fromx0/z0every draw, so a view re-anchors on every slide (checked; insort: "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 itterrainWindow({ cols, cell, step, split: "adaptive", fill }), move its strip loop intofill(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;sample38.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 entryterrainWindowalone 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()andocclude(), 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 fromcamby hand.d.eye(out)gives the camera's world position (from the basisdrawalready 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 (sizefrom its bottom-centrepos, turned byrot[1]; root objects); one in the way eases itsalphatowardghostatdt / ta step, one the eye is inside toward 0, the rest back to 1;reduced(option and live field) snaps;neartreats 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 writesalphaonly (render side, never the sim). Boxes off the bounds of the eye and the targets skip the ray test (testedcounts the rest). Migration: where a game fades occluders by hand (its own eye fromcam, box-vs-box rejects, slab tests and alpha easing), buildocclude(d, { objects: buildings, near })once and callbusy = oc.step(dt, pts)beforedraw; 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 withocclude7,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(eyeon 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;nlimits the targets;nearkeeps a touching box; the bounds skip boxes, determinism, zero allocation).@fzlt/core/diorama: points withrank: "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 fieldrank: "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; itslayerorders it among other depth-ranked points between the same two clusters, andclusteris ignored. Pools withoutrankkeep 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, addrank: "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;maxFacesdrops still counted; the measured cost; zero allocation).@fzlt/core/input:gamepad(), standard-layout controllers into the same intents (opt-in export). Games pollednavigator.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 buttonspresstheir intents (down from half a pull;valueis the analog pull past the dead zone, a trigger's gas), the left sticksteers the controller's stick (rescaled past the dead zone),indexreads 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, orstop(), 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 fakenavigator.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,indexignores another seat's pad, a connect wakes a settled engine, zero young GCs over 1M frames with a pad connected),tests/webkit-gamepad.mjsin 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:offhides an object and its whole subtree and skips their matrix work.hiddenhides 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 withhidden+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 flagoff(d.add({ …, off: true }),ob.off = true | falsebetween 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;Mkeeps its value from the last draw it was on in).hiddenkeeps its meaning, so nothing changes for existing scenes.stats.objectsnow counts the objects whose matrices were computed this draw (all of them unless something isoff; it was the scene's object count). Migration: where a game lets go of a pooled object withob.hidden = true; ob.alpha = 0; ob.pos[1] = -50(or any hide spot), writeob.off = true, andob.off = falseto 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 rootoff; 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,offon the parent: no part's faces, no shadows, not picked,stats.objectsleaves them out; a moved off parent and its children keep theirM; on again: the same faces, shadows, objects and colours as before;offon a mid part takes its child;hiddenstill 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 playsgonefrom 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 playsgonefrom 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 nopointeruporpointercancel(sometimes onlylostpointercapture, 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), andlostpointercapturestill ends a finger.@fzlt/core/padalready 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 jobwebkit(ubuntu-24.04,npx playwright install --with-deps webkit, part of the requiredcheck) runsnpm run test:webkitin 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 onlylostpointercapture, 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(lockTouchcancels 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 syntheticPointerEvents (WebKit has no CDP touch) pluspage.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'sMath.sinandMath.cosdiffer from Node 24's in about 3% of results,Math.atan2in 18%), and one bit in a heading is a different game online.sin,cos,atan,atan2are fdlibm 5.3's algorithms (the ones V8 ports) from + − × ÷,Math.sqrt/abs/trunc,%and bit reads only;hypotis steer's exactMath.hypot, moved here (@fzlt/core/steerre-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,webkitmakes 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) calledMath.atan2,Math.sinandMath.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 onlyhypotfrom steer don't move (arcade 24,138 → 24,139, board-page 4,104 → 4,104). Tests:tests/math-engines.mjsruns 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 readsvalue, neverpath(moving the tumble onto the brick would cost ~2.7 KB: sin, cos, atan2 foracosand apowfor 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.jsonis 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.tsmeasures on resize only (data-peek,--shift,data-slid): no frame loop, no layout shift on load.tests/periodic.mjschecks 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.mjsDIMS), 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-hurtis 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. Theexperimentalkey stays (export doc tags@experimental, the factory's audit); only the label changes, inSTATUS, the README tables and the tests.tests/periodic.mjschecks 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.mjsKINDS,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, andgames, 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).