questions about what you actually studied.

Build me a practice quiz as a single web page, from material I will paste in.

Ask me first:
- For the material. Ask me to paste my notes, chapter or handouts.
- What kind of questions suit it: multiple choice, short answer, true/false, calculation, or a mix.
- How many questions.
- What the real assessment looks like, if I know, so the questions can resemble it.

WRITING THE QUESTIONS

- Every question and every answer must come from the material I gave you. Do not use your own knowledge of the subject to write a question, to add a plausible wrong option, or to fill in an explanation.
- If my material does not clearly support a question, do not write it. Tell me which areas you could not cover and why.
- Each question gets an explanation that says why the answer is right and names the section of my material it came from. The citation is what lets me check you.
- For multiple choice, make the wrong options plausible and drawn from my material — confusable concepts from my own notes, not invented ones.
- Vary the difficulty. A quiz where every question is a definition tests recall and nothing else.

WHAT THE PAGE DOES

- One question at a time, with the answer revealed after I commit to mine — never before.
- Show the explanation with the answer, every time, including when I got it right.
- Keep score, and at the end show which questions I missed.
- A retake mode that asks only the ones I got wrong.
- Shuffle the question order and, for multiple choice, the option order, so I learn the material rather than the positions.
- Let me flag a question as wrong or unclear, and see my flagged ones together — I will want to check those against my notes.

DESIGN

- One question, centred, plenty of space. Nothing else while answering.
- Works on a phone and a laptop; keyboard shortcuts for the options on a laptop.

BE HONEST ON THE PAGE

- Say the questions were generated from my own material and are worth checking against it.
- Say scores are stored in this browser only, so anyone else opening the url gets their own.

STORING THE DATA

- Save everything to localStorage in the browser, automatically, as I go. No
  accounts, no login, no server call.
- On the page, say plainly that data lives in this browser only and does not
  sync to other devices. Do not bury it.
- Give me an "export" button that copies or downloads everything as JSON, and an
  "import" that reads the same JSON back. That is the only way my data can move
  between devices, so it is not optional.
- Never lose what I have already entered. If the stored data is from an older
  version of the page, read what you can rather than throwing it away.

DELIVERY

- Produce one self-contained HTML file. Inline the CSS and JavaScript.
- No build step, no server, no framework, no package install, no external
  requests at runtime.
- Mobile-first and responsive; it has to be usable one-handed on a phone and
  still look right on a laptop.
- Accessible: semantic HTML, real contrast, visible keyboard focus, labelled
  controls, touch targets big enough to hit, and respect reduced-motion.
- Use placeholders where information is missing. Do not invent facts, numbers,
  names, dates, prices, or results I have not given you.
- Before you call it finished, use it yourself: enter real-looking data, reload
  the page, and confirm nothing is lost or mangled.

PUBLISHING

Publish the finished page to HTMLShare and give me the link.

Use exactly one of the two paths below, preferring the first. Make the call
directly. Do not route it through a code sandbox, container, or computer-use
session — that is where the request gets blocked, and it is never necessary.

1. An HTMLShare integration or connector, if you have one configured.
   The page is permanent and owned by my account. Report the url and the
   siteId. There is no claimUrl or manageToken on this path — do not go
   looking for one, and do not switch paths in order to produce one.

2. Otherwise, publish anonymously over REST. No account, key, or signup is
   needed:

    POST https://api.htmlshare.net/v1/publish
    content-type: application/json

    {"html": "<!doctype html> ... "}

   The reference is https://htmlshare.net/docs and, for the full schema,
   https://api.htmlshare.net/openapi.json

   Report these from the response, in your reply and never inside the page:
     url          the public page
     claimUrl     a private link that is mine alone. opening it is how I keep
                  the page past its 24-hour expiry, or set an email reminder
                  before it goes. it carries the manage token, so it must
                  never appear in the published HTML or anywhere a visitor
                  could see it.
     manageToken  the only thing that can edit or delete this page later. it is
                  returned once and never again, so tell me what it is.

Tell me which of the two you used. If the path you reach for first is
unavailable in your environment, say so and tell me what you are switching to
before you publish — a permanent page on my account and a 24-hour anonymous
page are different things, and which one I get is my decision, not a detail.

If I ask for a change afterwards, update the existing page instead of
publishing again, so the URL I have already shared keeps working — through the
same integration on path 1, or with the manage token as an X-Manage-Token
header on path 2.

RECIPE MARKER

Include this tag in the <head>, exactly as written:

    <meta name="htmlshare-recipe" content="practice-quiz">

It tells htmlshare which recipe the page came from, so the library can count
that this one was actually made. It carries nothing else.