FIDGIT — HOW TO BUILD A GAME THAT WILL ACTUALLY UPLOAD AND RUN

Paste this whole file into any AI coding assistant (Claude, ChatGPT, Gemini, Cursor,
v0, etc.) along with a description of the game you want, and it will build something
that passes Fidgit's automated review and works for real players on the first try.

You are building a tiny browser game/toy to submit to Fidgit (fidgit.app), a platform for small, self-contained, neal.fun-style web experiences. Follow these constraints exactly — they are enforced by an automated system, not suggestions.

HARD TECHNICAL RULES
- One entry file named exactly "index.html". It must load and run the whole experience by itself.
- All files flat, no subfolders. Filenames: letters, digits, dots, dashes, underscores only, max 64 characters.
- Allowed file types ONLY: .html .css .js .json .png .jpg/.jpeg .webp .mp3 .ogg .wav
  NOT allowed: any other type, including .gif and .svg.
- Max 20 files, 20 MB total, 5 MB per individual file.
- Images over 4096×4096 will be rejected. They also get re-encoded from scratch on submit — so avoid relying on embedded metadata or steganography (it will be destroyed).
- Text files (.html/.css/.js/.json) must be valid UTF-8 with no null bytes.

ZERO NETWORK ACCESS — THIS IS THE BIG ONE
The game runs in a locked-down sandboxed iframe on a separate domain with a strict
Content-Security-Policy. It can ONLY load its own uploaded files. This means:
- NO external requests of any kind: no CDN scripts (no unpkg/jsdelivr/cdnjs), no Google
  Fonts, no external images/audio/video by URL, no analytics, no fetch()/XHR/WebSocket to
  anything outside the game's own files.
- Every library you want to use must be a plain, non-module <script> file you write or
  vendor inline/uploaded — no import from a URL, no package manager at runtime.
- Fonts: use system fonts (e.g. system-ui, sans-serif) or a font file you upload yourself.
  Do not link to Google Fonts or any other remote font service.

SANDBOX BEHAVIOR
- The iframe has sandbox="allow-scripts" ONLY. No same-origin access, no popups, no
  top-level navigation, no form submission targets outside the frame.
- SAVING PROGRESS WORKS — use localStorage normally. localStorage.setItem('best', 100),
  localStorage.getItem('best'), etc. all work, and Fidgit automatically makes the data
  persist between visits and sync across the player's devices when they're logged in. You
  don't need to do anything special (the platform swaps in a working storage for you), and
  you still must NOT load or save files over the network. sessionStorage and cookies also
  won't crash, but ONLY localStorage persists between visits.
- Canvas, Web Audio, requestAnimationFrame, pointer/touch/keyboard events, and CSS
  animations all work fine — build interactive, animated things freely.

THE fidgit HELPER (always available, no imports, no setup)
Fidgit injects a small global object you can call from anywhere in your game:
- fidgit.save(obj) — save any JSON-able object (progress, settings, a saved creation). It
  persists for the player and syncs across their devices when they're logged in.
- fidgit.load() — read back the last object you saved with fidgit.save (null if none yet).
- fidgit.enterFullscreen() — fill the screen. Requires a real user gesture (call it from
  inside a click/tap handler).
- fidgit.start({...}) — draw the standard start screen (see below).
- fidgit.onMenu — set this to a function and the platform's menu button opens YOUR
  pause/settings screen instead of the built-in one.
Plain localStorage works and persists the same way — fidgit.save/load is just a shortcut
for storing one whole object at once.

THE PLATFORM DRAWS TWO BUTTONS IN YOUR TOP-RIGHT CORNER
Every fidgit automatically gets a fullscreen button and a menu button, fixed in the
top-right, drawn by Fidgit over your game. So:
- KEEP THE TOP-RIGHT CORNER CLEAR. Put your score, timer, or controls anywhere else —
  top-left, or along the bottom. Anything you draw there will be covered.
- Do NOT build your own fullscreen button. You'd end up with two.
- If your fidgit has a settings or pause screen, wire the platform's menu button to it:
    fidgit.onMenu = () => openMySettingsPanel();
  Return false from that function when your panel isn't available yet (e.g. before the
  game starts) and the platform shows its own menu instead.

EVERY FIDGIT OPENS ON A START SCREEN, AND START GOES FULLSCREEN
Your fidgit first appears in a small frame on its Fidgit page, so it must open on a start
screen sized for that frame — a title, one line saying what it is, and one button. The
button fills the screen and THEN starts the experience. This ordering matters: if you
measure the window before going fullscreen you will cache the small size and the whole
thing will be laid out wrong.

The easy way — the platform draws a start screen in YOUR colours:
  fidgit.start({
    title: 'Grove',
    body: 'Plant a seed and watch a tree find its own shape.',
    cta: 'Plant it',
    hint: 'drag to bend the light',          // optional
    theme: { bg: '#f2ecd9', ink: '#2b2a1e', muted: '#6f6a52',
             accent: '#5a7a42', accentInk: '#f4f2e4',
             font: "'Baloo 2', system-ui, sans-serif" }   // font optional
  }).then(() => { boot(); });                 // boot AFTER this resolves

Pass your own palette so it looks like your fidgit, not like a generic dialog. The layout,
spacing and touch targets are handled for you.

If you'd rather draw your own start screen, that's fine — just make its button call
fidgit.enterFullscreen() before it starts anything.

If your fidgit sizes its board once at kick-off and must not re-layout mid-play, use
fidgit.begin(fn) instead — it goes fullscreen, waits for the frame to settle, then runs
your function, so you never lay out at the wrong size.

SHARING (encouraged — it's how fidgits spread)
- You CAN copy to the clipboard and open the native share sheet. The frame is granted
  allow="clipboard-write; web-share". A great pattern: let the user turn their creation
  into an image (draw the game to a <canvas>, canvas.toBlob(...)) and give them a "Copy
  image" and/or "Share" button.
  - Copy an image:  await navigator.clipboard.write([new ClipboardItem({ "image/png": blob })])
  - Copy text/link: await navigator.clipboard.writeText(text)
  - Native share (best on mobile): if (navigator.canShare?.({ files: [file] })) await navigator.share({ files: [file] })
- These require a real user gesture (call them from inside a click/tap handler) and can
  reject — always wrap in try/catch and fall back to offering the image as a download
  (an <a download> from a blob URL). Clipboard READ is not available and must not be used.
- Only ever put on the clipboard what the user asked to copy — no swapping in surprise
  links, addresses, or other content. Deceptive clipboard use gets a submission rejected.

WHAT MAKES A GOOD FIDGIT SUBMISSION
- One small, clear idea, done well. A player should be able to understand what to do
  within a few seconds and still be engaged after a minute — not just a static screen.
- Actually interactive: respond to clicks/drags/taps/keys, not just an animation loop.
- Self-contained and polished within its scope — no "TODO" states, no broken buttons.
- Keep code readable. Heavy obfuscation (minified-beyond-reason, packed/eval'd strings)
  gets flagged for manual human review even if harmless, which slows down approval.
- Absolutely no malicious code, deceptive UI, NSFW content, or hateful content — every
  submission is reviewed by an AI moderator before publishing, and clear violations are
  auto-rejected.

DELIVERABLE
Produce the actual files (index.html plus any .js/.css/.png/etc. it needs), all satisfying
the rules above. When you're done, go to fidgit.app/submit.html and upload them along with:
- a title (max 50 characters)
- a one-line tagline (max 60 characters, shown in the feed)
- a primary section it belongs to, and optionally one secondary section (from: Games, Educational, Interactive, Tools, Artistic)
- which device(s) it's best on: desktop, mobile, or both (a reviewer then rates how well it actually plays on each — build the input handling and layout to match)
- up to 5 tags
- an optional 16:9 thumbnail image (one is auto-generated if you skip it)