DataInventor: open-source Invent a Dataset recreation

Dockerfile

@@ -1,2 +1,12 @@
-FROM huggingface/autotrain-advanced:latest
-CMD autotrain api --port 7860 --host 0.0.0.0
+FROM python:3.12-slim
+ENV PYTHONUNBUFFERED=1 PORT=7860
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+WORKDIR /home/user/app
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY --chown=user app ./app
+COPY --chown=user static ./static
+WORKDIR /home/user/app/app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,9 +1,34 @@
 ---
-title: photo-lora
-emoji: 🚀
-colorFrom: green
-colorTo: indigo
+title: DataInventor
+emoji: 🧪
+colorFrom: indigo
+colorTo: pink
 sdk: docker
+app_port: 7860
 pinned: false
-duplicated_from: autotrain-projects/autotrain-advanced
+short_description: Describe a dataset in plain words, get training rows back.
 ---
+
+# DataInventor
+
+An open-source recreation of the [Invent a Dataset](https://adaptionlabs.ai/invent-a-dataset) workflow. Describe the data you want, choose a format, domains and languages, preview a blueprint, and get an instruction or preference dataset back as CSV or JSONL.
+
+It works with any OpenAI-compatible endpoint. The default is a free model served through Hugging Face Inference Providers.
+
+## How it writes rows
+
+1. **Blueprint.** The model turns your description into topics, personas, who answers and the shapes questions take.
+2. **Sampling.** Unique combinations of topic, persona, shape, difficulty, length and language.
+3. **Writing.** One message per combination, then the reply (preference pairs get two replies and a ranking).
+4. **Filters.** Cut-off or degenerate text, requests for many items at once, and near-duplicate questions are rejected.
+
+## Run it yourself
+
+```bash
+pip install -r requirements.txt
+cd app && HF_TOKEN=hf_... uvicorn main:app --port 7860
+```
+
+Settings: `MAX_ROWS` (default 1000), `MAX_RUNNING` (default 2), `HF_TOKEN` (used only for the Hugging Face router).
+
+Not affiliated with Adaption Labs.

app/engine.py

@@ -0,0 +1,328 @@
+"""DataInventor engine: one sentence in, a training dataset out, on any OpenAI-compatible endpoint.
+
+Pipeline: blueprint (taxonomy + personas + question shapes) -> sampled combinations ->
+question -> answer (or two answers + a ranking for preference pairs) -> filters -> near-duplicate rejection.
+"""
+from __future__ import annotations
+
+import json
+import random
+import re
+import threading
+import time
+import urllib.request
+import urllib.error
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field
+from typing import Callable, Optional
+
+HF_BASE = "https://router.huggingface.co/v1"
+HF_MODEL = "prism-ml/Ternary-Bonsai-27B-AWQ-4bit:together"
+
+
+@dataclass
+class Endpoint:
+    base_url: str = HF_BASE
+    api_key: str = ""
+    model: str = HF_MODEL
+    disable_thinking: bool = True
+    workers: int = 4
+
+    def chat(self, prompt: str, max_tokens: int = 1500, temperature: float = 0.8, retries: int = 5,
+             validate: Optional[Callable[[str], bool]] = None) -> str:
+        body = {"model": self.model, "max_tokens": max_tokens, "temperature": temperature,
+                "messages": [{"role": "user", "content": prompt}]}
+        if self.disable_thinking:
+            body["chat_template_kwargs"] = {"enable_thinking": False}
+        data = json.dumps(body).encode()
+        url = self.base_url.rstrip("/") + "/chat/completions"
+        last = "no attempt"
+        for attempt in range(retries):
+            try:
+                req = urllib.request.Request(url, data, {"Content-Type": "application/json", "User-Agent": "DataInventor/1.0",
+                                                         "Authorization": "Bearer " + self.api_key})
+                resp = json.load(urllib.request.urlopen(req, timeout=180))
+                choice = (resp.get("choices") or [{}])[0] or {}
+                if choice.get("finish_reason") == "length":
+                    last = "reply cut off at max_tokens"
+                    time.sleep(1.5)
+                    continue
+                text = ((choice.get("message") or {}).get("content") or "").strip()
+                text = re.sub(r"<think>.*?</think>", "", text, flags=re.S).strip()
+                if text and (validate is None or validate(text)):
+                    return text
+                last = "reply rejected by a quality check"
+            except urllib.error.HTTPError as e:
+                detail = ""
+                try:
+                    detail = e.read().decode()[:200]
+                except Exception:
+                    pass
+                last = f"HTTP {e.code} {detail}"
+                if e.code in (401, 403):
+                    raise EndpointError(f"The endpoint refused the key (HTTP {e.code}). Check the API key.")
+                if e.code == 404:
+                    raise EndpointError("The endpoint or model was not found (HTTP 404). Check the base URL and model name.")
+                time.sleep(min(30, 2 ** attempt * 2) if e.code == 429 else 3 * (attempt + 1))
+            except Exception as e:  # timeouts, resets
+                last = str(e)[:160]
+                time.sleep(3 * (attempt + 1))
+        raise EndpointError(last)
+
+    def ping(self) -> dict:
+        t = time.time()
+        text = self.chat("Reply with the single word ready.", max_tokens=16, temperature=0, retries=2)
+        return {"ok": True, "latency_ms": int((time.time() - t) * 1000), "sample": text[:40]}
+
+
+class EndpointError(Exception):
+    pass
+
+
+# ---------------------------------------------------------------- blueprint
+
+def _s(x) -> str:
+    """Models sometimes return {"persona": "..."} instead of a bare string."""
+    if isinstance(x, dict):
+        for k in ("name", "persona", "role", "format", "shape", "topic", "description", "title"):
+            if isinstance(x.get(k), str):
+                return x[k].strip()
+        return " ".join(str(v) for v in x.values() if isinstance(v, str)).strip()
+    return str(x).strip()
+
+
+def normalize_blueprint(bp: dict) -> dict:
+    out = {"topics": [], "personas": [_s(p) for p in bp.get("personas", []) if _s(p)],
+           "formats": [_s(f) for f in bp.get("formats", []) if _s(f)],
+           "difficulty": [_s(d) for d in bp.get("difficulty", []) if _s(d)] or ["basic", "intermediate", "advanced"],
+           "assistant_role": _s(bp.get("assistant_role") or "an excellent, accurate AI assistant")[:300]}
+    for a in bp.get("topics", []):
+        subs = []
+        for sub in a.get("subtopics", []):
+            leaves = [_s(l) for l in sub.get("leaf_topics", []) if _s(l)]
+            if leaves:
+                subs.append({"subtopic": _s(sub.get("subtopic", "")), "leaf_topics": leaves})
+        if subs:
+            out["topics"].append({"area": _s(a.get("area", "")), "subtopics": subs})
+    if len(out["topics"]) < 1 or len(out["personas"]) < 2 or len(out["formats"]) < 2:
+        raise ValueError("the blueprint is missing topics, personas or formats")
+    return out
+
+
+def _json_from(text: str):
+    m = re.search(r"\{.*\}", text, re.S)
+    if not m:
+        raise ValueError("no JSON object in the reply")
+    return json.loads(m.group(0))
+
+
+def make_blueprint(ep: Endpoint, request: str, domains: list[str], subdomains: list[str], languages: list[str],
+                   constraints: str, rows: int) -> dict:
+    scope = ""
+    if domains:
+        scope += f"Domains: {', '.join(domains)}.\n"
+    if subdomains:
+        scope += f"Subdomains: {', '.join(subdomains)}.\n"
+    if constraints.strip():
+        scope += f"Output requirements: {constraints.strip()}\n"
+    areas = 6 if rows <= 500 else 8
+    prompt = f"""You are planning a training dataset. Dataset request: "{request}"
+{scope}
+Return ONLY JSON with these keys:
+"topics": a list of {areas} objects {{"area": str, "subtopics": [4 objects {{"subtopic": str, "leaf_topics": [4 specific, concrete strings]}}]}}. Cover the whole request evenly.
+"personas": 10 different kinds of people who would write the user side of this dataset (for a customer-support dataset, 10 different kinds of customer; for a coding dataset, 10 kinds of developer).
+"assistant_role": one sentence describing who answers in this dataset and in what voice (for example "a friendly support agent at a small online bookshop who gives concrete next steps").
+"formats": 6 different shapes the instruction could take (for example a short direct ask, a detailed brief, a request with a concrete example, a request with constraints, a follow-up, a comparison).
+"difficulty": ["basic","intermediate","advanced"].
+No commentary, no code fences."""
+    last = None
+    for _ in range(4):
+        try:
+            return normalize_blueprint(_json_from(ep.chat(prompt, max_tokens=5000, temperature=0.7)))
+        except EndpointError:
+            raise
+        except Exception as e:
+            last = e
+    raise EndpointError(f"The model did not return a usable blueprint: {last}")
+
+
+# ---------------------------------------------------------------- generation
+
+LEAK = re.compile(r"the user (asks|wants)|write one|return only|^okay|^sure,|^here is|^here's|^as an ai", re.I)
+END = re.compile(r"[.?!)\"”’'।:。！？]$")
+MULTI = re.compile(r"\b(generate|draft|write|compile|create|give me|produce)\s+(\d+|several|multiple|a set of|a list of)\b", re.I)
+LENGTHS = ["one blunt sentence", "two sentences with one specific detail",
+           "three or four sentences with concrete specifics", "a short paragraph that sounds a little rushed"]
+
+
+def degenerate(t: str) -> bool:
+    w = t.lower().split()
+    return bool(re.search(r"(.)\1{7,}", t)) or (len(w) >= 8 and len(set(w)) / len(w) < 0.5)
+
+
+def grams(t: str, n: int = 3) -> set:
+    w = t.lower().split()
+    return set(zip(*[w[i:] for i in range(n)])) if len(w) >= n else {tuple(w)}
+
+
+@dataclass
+class Job:
+    id: str
+    config: dict
+    state: str = "queued"  # queued | planning | generating | done | failed | stopped
+    message: str = ""
+    blueprint: Optional[dict] = None
+    rows: list = field(default_factory=list)
+    target: int = 0
+    attempts: int = 0
+    rejected: dict = field(default_factory=dict)
+    started: float = field(default_factory=time.time)
+    finished: float = 0.0
+    stop: threading.Event = field(default_factory=threading.Event)
+    lock: threading.Lock = field(default_factory=threading.Lock)
+
+    def reject(self, why: str):
+        with self.lock:
+            self.rejected[why] = self.rejected.get(why, 0) + 1
+
+
+def run_job(job: Job, ep: Endpoint):
+    cfg = job.config
+    rows_n = int(cfg["rows"])
+    job.target = rows_n
+    kind = cfg.get("format", "instruction")
+    request = cfg["request"]
+    languages = cfg.get("languages") or ["English"]
+    constraints = cfg.get("constraints", "")
+    try:
+        job.state, job.message = "planning", "Drafting the blueprint"
+        bp = normalize_blueprint(cfg["blueprint"]) if cfg.get("blueprint") else make_blueprint(
+            ep, request, cfg.get("domains", []), cfg.get("subdomains", []), languages, constraints, rows_n)
+        job.blueprint = bp
+        leaves = [(a["area"], s["subtopic"], l) for a in bp["topics"] for s in a["subtopics"] for l in s["leaf_topics"]]
+        rng = random.Random(cfg.get("seed", 7))
+        combos, seen = [], set()
+        want = int(rows_n * 1.8) + 20
+        guard = 0
+        while len(combos) < want and guard < want * 30:
+            guard += 1
+            c = (rng.choice(leaves), rng.choice(bp["personas"]), rng.choice(bp["formats"]), rng.choice(bp["difficulty"]),
+                 rng.choice(LENGTHS), rng.choice(languages))
+            if c not in seen:
+                seen.add(c)
+                combos.append(c)
+
+        scope = f'The dataset being built: "{request}"'
+        if constraints.strip():
+            scope += f"\nEvery example must satisfy: {constraints.strip()}"
+
+        def ok_q(t):
+            t = t.strip().strip('"')
+            return 15 <= len(t) <= 1500 and END.search(t) and not degenerate(t) and not LEAK.search(t[:150]) and not MULTI.search(t[:120])
+
+        def ok_a(t):
+            return len(t.split()) >= 12 and not degenerate(t[:600]) and not LEAK.search(t[:100])
+
+        kept_grams: list[set] = []
+        job.state, job.message = "generating", "Writing examples"
+
+        def work(idx_combo):
+            idx, ((area, sub, leaf), persona, fmt, diff, length, lang) = idx_combo
+            if job.stop.is_set():
+                return
+            with job.lock:
+                if len(job.rows) >= rows_n:
+                    return
+                job.attempts += 1
+            try:
+                role = bp.get("assistant_role", "an excellent AI assistant")
+                q = ep.chat(f"""{scope}
+Write ONE realistic message that {persona} would send to {role}, for this dataset, about: {leaf} ({area}, {sub}).
+Shape: {fmt}. Difficulty: {diff}. Length: {length}. Language: {lang}.
+It should sound like a real person typing, specific and a little imperfect, not a textbook prompt. It must be ONE question or ONE task whose answer fits in a single reply: never ask for a list of many items, a set of Q&A pairs, or a dataset. Do not name the shape or the persona.
+Return only the message.""", max_tokens=700, temperature=1.0, validate=ok_q).strip().strip('"')
+                g = grams(q)
+                with job.lock:
+                    if any(len(g & k) / max(1, len(g | k)) > 0.5 for k in kept_grams):
+                        job.reject("near-duplicate question")
+                        return
+                answer_prompt = f"""You are {role}. Reply to the message below. The reply is a training example for this dataset: "{request}".
+Language: {lang}. Be accurate, specific and complete. Start directly with the content, with no preamble about who you are. Do not invent statistics or facts you cannot know.
+{('Requirements: ' + constraints.strip()) if constraints.strip() else ''}
+
+Message: {q}"""
+                a1 = ep.chat(answer_prompt, max_tokens=2500, temperature=0.7, validate=ok_a)
+                row = {"area": area, "subtopic": sub, "topic": leaf, "persona": persona, "shape": fmt,
+                       "difficulty": diff, "language": lang, "prompt": q}
+                if kind == "preference":
+                    a2 = ep.chat(answer_prompt + "\n\nWrite a different answer from the obvious one, in a different structure and with different emphasis.",
+                                 max_tokens=2500, temperature=1.0, validate=ok_a)
+                    verdict = ep.chat(f"""Which answer is better for the message? Judge accuracy, completeness and clarity.
+Message: {q}
+
+Answer A:
+{a1[:3000]}
+
+Answer B:
+{a2[:3000]}
+
+Reply with only the single letter A or B.""", max_tokens=8, temperature=0, validate=lambda s: s.strip()[:1].upper() in ("A", "B"))
+                    a_wins = verdict.strip()[:1].upper() == "A"
+                    row["chosen"], row["rejected"] = (a1, a2) if a_wins else (a2, a1)
+                else:
+                    row["completion"] = a1
+                with job.lock:
+                    if len(job.rows) >= rows_n:
+                        return
+                    if any(len(g & k) / max(1, len(g | k)) > 0.5 for k in kept_grams):
+                        job.reject("near-duplicate question")
+                        return
+                    row["id"] = len(job.rows) + 1
+                    job.rows.append(row)
+                    kept_grams.append(g)
+                    job.message = f"{len(job.rows)} of {rows_n} written"
+                    if len(job.rows) >= rows_n:
+                        job.state, job.message, job.finished = "done", f"{len(job.rows)} rows ready", time.time()
+                        job.stop.set()
+            except EndpointError as e:
+                if "refused the key" in str(e) or "not found" in str(e):
+                    job.state, job.message = "failed", str(e)
+                    job.stop.set()
+                else:
+                    job.reject("model call failed")
+            except Exception:
+                job.reject("model call failed")
+
+        with ThreadPoolExecutor(max_workers=max(1, min(ep.workers, 16))) as pool:
+            list(pool.map(work, enumerate(combos)))
+        if job.state in ("failed", "done"):
+            return
+        if job.stop.is_set():
+            job.state, job.message = "stopped", f"Stopped with {len(job.rows)} rows"
+        elif len(job.rows) < rows_n:
+            job.state = "done"
+            job.message = f"Finished with {len(job.rows)} of {rows_n} rows. The model rejected too many attempts to fill the rest."
+        else:
+            job.state, job.message = "done", f"{len(job.rows)} rows ready"
+    except EndpointError as e:
+        job.state, job.message = "failed", str(e)
+    except Exception as e:  # never leave a job hanging
+        job.state, job.message = "failed", f"Unexpected error: {e}"
+    finally:
+        job.finished = time.time()
+
+
+# ---------------------------------------------------------------- stats
+
+def stats(rows: list) -> dict:
+    if not rows:
+        return {}
+    text = "\n".join(r["prompt"] for r in rows).lower().split()
+    tri = list(zip(text, text[1:], text[2:]))
+    area_counts: dict = {}
+    for r in rows:
+        area_counts[r["area"]] = area_counts.get(r["area"], 0) + 1
+    comp = [len((r.get("completion") or r.get("chosen") or "").split()) for r in rows]
+    return {"rows": len(rows), "distinct3_prompts": round(len(set(tri)) / max(1, len(tri)), 3),
+            "avg_prompt_words": round(sum(len(r["prompt"].split()) for r in rows) / len(rows), 1),
+            "avg_answer_words": round(sum(comp) / len(rows), 1), "areas": area_counts}

app/main.py

@@ -0,0 +1,168 @@
+"""DataInventor: an open-source recreation of the Invent a Dataset workflow. Bring any OpenAI-compatible endpoint."""
+from __future__ import annotations
+
+import csv
+import io
+import json
+import os
+import threading
+import time
+import uuid
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse, JSONResponse, Response
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, Field
+
+from engine import HF_BASE, HF_MODEL, Endpoint, EndpointError, Job, make_blueprint, run_job, stats
+
+ROOT = Path(__file__).resolve().parent.parent
+STATIC = ROOT / "static"
+MAX_ROWS = int(os.environ.get("MAX_ROWS", "1000"))
+MAX_RUNNING = int(os.environ.get("MAX_RUNNING", "2"))
+SERVER_KEY = os.environ.get("HF_TOKEN", "")
+
+app = FastAPI(title="DataInventor")
+JOBS: dict[str, Job] = {}
+ENDPOINTS: dict[str, Endpoint] = {}  # kept apart from Job so a key never lands in a response
+GUARD = threading.Lock()
+
+
+class EngineIn(BaseModel):
+    base_url: str = HF_BASE
+    api_key: str = ""
+    model: str = HF_MODEL
+    disable_thinking: bool = True
+    workers: int = 4
+
+
+class SpecIn(BaseModel):
+    engine: EngineIn = Field(default_factory=EngineIn)
+    format: str = "instruction"
+    request: str
+    domains: list[str] = []
+    subdomains: list[str] = []
+    languages: list[str] = ["English"]
+    constraints: str = ""
+    rows: int = 100
+    blueprint: dict | None = None
+
+
+def make_endpoint(e: EngineIn) -> Endpoint:
+    base = e.base_url.strip().rstrip("/")
+    if not base.startswith(("http://", "https://")):
+        raise HTTPException(400, "The base URL must start with http:// or https://.")
+    key = e.api_key.strip()
+    if not key:
+        if base == HF_BASE and SERVER_KEY:
+            key = SERVER_KEY  # the hosted default only ever talks to the Hugging Face router
+        else:
+            raise HTTPException(400, "Add an API key for this endpoint.")
+    return Endpoint(base_url=base, api_key=key, model=e.model.strip() or HF_MODEL,
+                    disable_thinking=e.disable_thinking, workers=max(1, min(e.workers, 8)))
+
+
+@app.get("/api/defaults")
+def defaults():
+    return {"base_url": HF_BASE, "model": HF_MODEL, "hosted_key": bool(SERVER_KEY), "max_rows": MAX_ROWS}
+
+
+@app.get("/api/domains")
+def domains():
+    return JSONResponse(json.loads((STATIC / "domains.json").read_text()))
+
+
+@app.post("/api/ping")
+def ping(e: EngineIn):
+    try:
+        return make_endpoint(e).ping()
+    except EndpointError as err:
+        raise HTTPException(502, str(err))
+
+
+@app.post("/api/blueprint")
+def blueprint(s: SpecIn):
+    ep = make_endpoint(s.engine)
+    if not s.request.strip():
+        raise HTTPException(400, "Describe the dataset first.")
+    try:
+        return make_blueprint(ep, s.request, s.domains, s.subdomains, s.languages, s.constraints, s.rows)
+    except EndpointError as err:
+        raise HTTPException(502, str(err))
+
+
+@app.post("/api/jobs")
+def start(s: SpecIn):
+    ep = make_endpoint(s.engine)
+    if not s.request.strip():
+        raise HTTPException(400, "Describe the dataset first.")
+    if not 1 <= s.rows <= MAX_ROWS:
+        raise HTTPException(400, f"Rows must be between 1 and {MAX_ROWS} on this host.")
+    with GUARD:
+        running = sum(1 for j in JOBS.values() if j.state in ("queued", "planning", "generating"))
+        if running >= MAX_RUNNING:
+            raise HTTPException(429, "Two datasets are already being written. Wait for one to finish.")
+        jid = uuid.uuid4().hex[:10]
+        cfg = s.model_dump(exclude={"engine"})
+        job = Job(id=jid, config=cfg)
+        JOBS[jid] = job
+        ENDPOINTS[jid] = ep
+        for old in sorted(JOBS, key=lambda k: JOBS[k].started)[:-20]:
+            JOBS.pop(old, None); ENDPOINTS.pop(old, None)
+    threading.Thread(target=run_job, args=(job, ep), daemon=True).start()
+    return {"id": jid}
+
+
+def get_job(jid: str) -> Job:
+    if jid not in JOBS:
+        raise HTTPException(404, "That dataset is no longer here. Start a new run.")
+    return JOBS[jid]
+
+
+@app.get("/api/jobs/{jid}")
+def status(jid: str, since: int = 0):
+    j = get_job(jid)
+    with j.lock:
+        rows = list(j.rows)
+        out = {"id": j.id, "state": j.state, "message": j.message, "target": j.target, "count": len(rows), "attempts": j.attempts,
+               "rejected": dict(j.rejected), "elapsed": round((j.finished or time.time()) - j.started, 1), "new_rows": rows[since:since + 50]}
+    if j.state in ("done", "stopped", "failed"):
+        out["stats"] = stats(rows)
+        out["blueprint"] = j.blueprint
+    return out
+
+
+@app.post("/api/jobs/{jid}/stop")
+def stop(jid: str):
+    get_job(jid).stop.set()
+    return {"ok": True}
+
+
+@app.get("/api/jobs/{jid}/download")
+def download(jid: str, format: str = "csv"):
+    j = get_job(jid)
+    rows = list(j.rows)
+    if not rows:
+        raise HTTPException(404, "There are no rows to download yet.")
+    pref = "chosen" in rows[0]
+    cols = ["prompt", "chosen", "rejected"] if pref else ["prompt", "completion"]
+    meta = ["area", "subtopic", "topic", "persona", "shape", "difficulty", "language"]
+    name = f"datainventor-{jid}"
+    if format == "jsonl":
+        body = "\n".join(json.dumps({k: r.get(k) for k in cols + meta}, ensure_ascii=False) for r in rows)
+        return Response(body, media_type="application/jsonl", headers={"Content-Disposition": f'attachment; filename="{name}.jsonl"'})
+    buf = io.StringIO()
+    w = csv.writer(buf)
+    w.writerow(cols + meta)
+    for r in rows:
+        w.writerow([r.get(k, "") for k in cols + meta])
+    return Response(buf.getvalue().encode("utf-8-sig"), media_type="text/csv", headers={"Content-Disposition": f'attachment; filename="{name}.csv"'})
+
+
+@app.get("/")
+def index():
+    return FileResponse(STATIC / "index.html")
+
+
+app.mount("/static", StaticFiles(directory=STATIC), name="static")

requirements.txt

@@ -0,0 +1,3 @@
+fastapi==0.115.*
+uvicorn[standard]==0.32.*
+pydantic>=2.7

static/app.css

@@ -0,0 +1,190 @@
+:root {
+  --paper: #e7e8ea;
+  --paper-2: #f1f2f4;
+  --ink: #1d2036;
+  --blue: #3a4bff;
+  --pink: #ff5c8f;
+  --slate: #5d6376;
+  --rule: #c5c8d1;
+  --ok: #1f7a55;
+  --bad: #b3261e;
+  --ui: "Familjen Grotesk", system-ui, sans-serif;
+  --doc: "Literata", Georgia, serif;
+  --r: 3px;
+}
+* { box-sizing: border-box; }
+html { color-scheme: light; }
+body {
+  margin: 0; background: var(--paper); color: var(--ink);
+  font: 400 16px/1.5 var(--ui);
+  -webkit-font-smoothing: antialiased;
+}
+.skip { position: absolute; left: -999px; top: 0; background: var(--ink); color: #fff; padding: 8px 12px; z-index: 10; }
+.skip:focus { left: 8px; top: 8px; }
+:focus-visible { outline: 3px solid var(--blue); outline-offset: 2px; border-radius: var(--r); }
+button, input, textarea, select { font: inherit; color: inherit; }
+h1, h2, h3, p { margin: 0; }
+
+/* top bar */
+.top { display: flex; align-items: center; gap: 28px; padding: 22px 36px 18px; border-bottom: 1px solid var(--rule); }
+.brand { display: flex; align-items: center; gap: 12px; flex: none; }
+.mark { position: relative; width: 30px; height: 30px; display: inline-block; }
+.mark i { position: absolute; inset: 0; border-radius: 50%; mix-blend-mode: multiply; }
+.mark i:first-child { background: var(--blue); transform: translate(-3px, -2px); }
+.mark i:last-child { background: var(--pink); transform: translate(4px, 3px); }
+.name { font-size: 26px; font-weight: 700; letter-spacing: -0.02em; }
+.tag { color: var(--slate); max-width: 62ch; font-size: 15px; }
+
+/* layout */
+.shell { display: grid; grid-template-columns: 210px minmax(0, 1fr) 330px; gap: 0; min-height: calc(100vh - 140px); }
+.ledger { border-right: 1px solid var(--rule); padding: 26px 0 26px 36px; }
+.panel { padding: 30px 44px 60px; min-width: 0; outline: none; }
+.sheet { border-left: 1px solid var(--rule); padding: 30px 28px 40px; position: sticky; top: 0; align-self: start; max-height: 100vh; overflow: auto; }
+
+/* ledger */
+#steps { list-style: none; margin: 0; padding: 0; }
+#steps li { position: relative; }
+#steps button {
+  display: grid; grid-template-columns: 26px 1fr; align-items: baseline; gap: 6px; width: 100%;
+  text-align: left; background: none; border: 0; padding: 9px 12px 9px 0; cursor: pointer; color: var(--slate);
+}
+#steps .n { font-variant-numeric: tabular-nums; font-weight: 600; }
+#steps li.done button { color: var(--ink); }
+#steps li.done .n { color: var(--blue); }
+#steps li.on button { color: var(--ink); font-weight: 600; }
+#steps li.on::before { content: ""; position: absolute; left: -36px; top: 8px; bottom: 8px; width: 4px; background: var(--blue); }
+#steps button:disabled { cursor: default; opacity: .55; }
+
+/* type */
+.panel h1 { font-size: clamp(30px, 4.2vw, 46px); line-height: 1.06; letter-spacing: -0.03em; font-weight: 700; max-width: 18ch; }
+.panel h2 { font-size: 26px; line-height: 1.15; letter-spacing: -0.02em; font-weight: 700; max-width: 26ch; }
+.lede { color: var(--slate); margin-top: 12px; max-width: 58ch; }
+.group { margin-top: 30px; }
+.group > h3 { font-size: 15px; font-weight: 600; margin-bottom: 4px; }
+.hint { color: var(--slate); font-size: 14px; }
+
+/* format specimens */
+.specimens { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 22px; margin-top: 30px; }
+.spec {
+  position: relative; text-align: left; background: var(--paper-2); border: 1px solid var(--rule);
+  border-radius: var(--r); padding: 20px 20px 22px; cursor: pointer;
+}
+.spec[aria-pressed="true"] { border-color: var(--ink); box-shadow: 5px 5px 0 -1px var(--blue), -3px -3px 0 -1px var(--pink); }
+.spec b { display: block; font-size: 18px; margin-bottom: 4px; }
+.spec .eg { font-family: var(--doc); font-size: 14.5px; line-height: 1.5; margin-top: 14px; color: #2b2f48; }
+.spec .eg u { text-decoration: none; display: block; font-style: italic; color: var(--slate); margin-bottom: 2px; }
+.spec .eg p + p { margin-top: 8px; }
+
+/* choice lists */
+.choices { list-style: none; margin: 14px 0 0; padding: 0; columns: 3 190px; column-gap: 28px; }
+.choices li { break-inside: avoid; }
+.choice {
+  display: grid; grid-template-columns: 18px 1fr; gap: 10px; align-items: start; width: 100%; text-align: left;
+  background: none; border: 0; padding: 7px 0; cursor: pointer;
+}
+.box { width: 16px; height: 16px; margin-top: 3px; border: 1.5px solid var(--ink); border-radius: 2px; background: var(--paper-2); display: grid; place-items: center; }
+.choice[aria-pressed="true"] .box { background: var(--blue); border-color: var(--blue); }
+.choice[aria-pressed="true"] .box::after { content: ""; width: 8px; height: 4px; border-left: 2px solid #fff; border-bottom: 2px solid #fff; transform: rotate(-45deg) translate(1px, -1px); }
+.choice[aria-pressed="true"] span:last-child { font-weight: 600; }
+.sub-block { margin-top: 26px; padding-top: 18px; border-top: 1px solid var(--rule); }
+.sub-block h3 { font-size: 17px; }
+
+/* fields */
+label.f { display: block; margin-top: 22px; }
+label.f > span { display: block; font-weight: 600; font-size: 15px; margin-bottom: 6px; }
+.in, textarea.in, select.in {
+  width: 100%; background: var(--paper-2); border: 1px solid #aeb2bf; border-radius: var(--r); padding: 11px 13px;
+}
+textarea.in { min-height: 118px; resize: vertical; font-family: var(--doc); font-size: 16.5px; line-height: 1.55; }
+.in:hover { border-color: var(--ink); }
+.row2 { display: grid; grid-template-columns: 1fr 1fr; gap: 22px; }
+.seg { display: inline-flex; flex-wrap: wrap; gap: 8px; margin-top: 8px; }
+.seg button { background: var(--paper-2); border: 1px solid #aeb2bf; border-radius: var(--r); padding: 8px 15px; cursor: pointer; font-variant-numeric: tabular-nums; }
+.seg button[aria-pressed="true"] { background: var(--ink); color: #fff; border-color: var(--ink); }
+.check { display: flex; gap: 10px; align-items: flex-start; margin-top: 18px; }
+.check input { margin-top: 5px; accent-color: var(--blue); width: 16px; height: 16px; }
+
+/* buttons */
+.actions { display: flex; flex-wrap: wrap; align-items: center; gap: 14px; margin-top: 36px; }
+.btn { border: 1.5px solid var(--ink); background: var(--paper-2); border-radius: var(--r); padding: 11px 20px; font-weight: 600; cursor: pointer; }
+.btn:hover:not(:disabled) { background: #fff; }
+.btn.go { background: var(--blue); border-color: var(--blue); color: #fff; }
+.btn.go:hover:not(:disabled) { background: #2a39e6; }
+.btn:disabled { opacity: .45; cursor: not-allowed; }
+.linkish { background: none; border: 0; padding: 0; color: var(--blue); font-weight: 600; cursor: pointer; text-decoration: underline; text-underline-offset: 3px; }
+
+/* blueprint */
+.bp { margin-top: 22px; border-top: 1px solid var(--ink); }
+.bp-row { display: grid; grid-template-columns: 150px 1fr; gap: 18px; padding: 14px 0; border-bottom: 1px solid var(--rule); }
+.bp-row > b { font-size: 14px; }
+.bp ul { margin: 0; padding: 0; list-style: none; display: flex; flex-wrap: wrap; gap: 6px 8px; }
+.bp li { background: var(--paper-2); border: 1px solid var(--rule); border-radius: 2px; padding: 3px 9px; font-size: 14px; }
+.bp .tree { display: grid; gap: 8px; }
+.bp .tree div > strong { font-weight: 600; }
+.bp .tree small { color: var(--slate); }
+.note { margin-top: 14px; padding: 10px 14px; border-left: 4px solid var(--pink); background: var(--paper-2); font-size: 14.5px; }
+.note.bad { border-left-color: var(--bad); }
+.note.ok { border-left-color: var(--ok); }
+
+/* spec sheet */
+.sheet h2 { font-size: 18px; margin-bottom: 14px; }
+.sheet dl { margin: 0; }
+.sheet .line { display: grid; grid-template-columns: 96px 1fr; gap: 10px; padding: 9px 0; border-top: 1px solid var(--rule); font-size: 14.5px; }
+.sheet dt { color: var(--slate); }
+.sheet dd { margin: 0; overflow-wrap: anywhere; }
+.sheet .est { margin-top: 18px; font-size: 14.5px; color: var(--slate); }
+.sheet .est b { color: var(--ink); }
+
+/* run: the printed deck */
+.count { display: flex; align-items: baseline; gap: 10px; margin-top: 24px; }
+.count .big { font-size: clamp(54px, 9vw, 92px); line-height: 1; font-weight: 700; letter-spacing: -0.04em; font-variant-numeric: tabular-nums; }
+.count .of { font-size: 22px; color: var(--slate); }
+.bar { height: 6px; background: var(--rule); margin-top: 14px; border-radius: 3px; overflow: hidden; }
+.bar > i { display: block; height: 100%; width: 0; background: var(--ink); transition: width .5s ease; }
+.state { margin-top: 10px; color: var(--slate); }
+.press { position: relative; height: 230px; margin: 30px 0 8px; }
+.card {
+  position: absolute; left: 0; top: 0; width: min(100%, 640px); padding: 18px 22px 20px; background: #fbfbfc; border: 1px solid #aeb2bf; border-radius: 2px;
+  font-family: var(--doc); font-size: 15px; line-height: 1.5; overflow: hidden; height: 190px;
+}
+.card::before, .card::after { content: ""; position: absolute; inset: -1px; border-radius: 2px; pointer-events: none; mix-blend-mode: multiply; }
+.card::before { box-shadow: 4px 3px 0 0 var(--pink); z-index: -1; }
+.card::after { box-shadow: -3px -2px 0 0 var(--blue); z-index: -1; }
+.card em { display: block; font-style: italic; color: var(--slate); font-size: 13px; margin-bottom: 3px; font-family: var(--ui); }
+.card .a { margin-top: 10px; color: #3a3f5a; }
+.card .clip { display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; }
+.card.print { animation: print .45s cubic-bezier(.2,.8,.2,1) both; }
+@keyframes print { from { transform: translate(14px, -10px); opacity: 0; } to { opacity: 1; } }
+@media (prefers-reduced-motion: reduce) { .card.print { animation: none; } .bar > i { transition: none; } }
+
+.table { margin-top: 28px; border-top: 1px solid var(--ink); }
+.trow { display: grid; grid-template-columns: 44px minmax(0, 1fr); gap: 14px; padding: 12px 0; border-bottom: 1px solid var(--rule); }
+.trow .id { color: var(--slate); font-variant-numeric: tabular-nums; }
+.trow .p { font-family: var(--doc); }
+.trow .meta { color: var(--slate); font-size: 13px; margin-top: 2px; }
+.trow details { margin-top: 6px; }
+.trow summary { cursor: pointer; color: var(--blue); font-weight: 600; font-size: 14px; }
+.trow .full { font-family: var(--doc); white-space: pre-wrap; margin-top: 8px; font-size: 15px; line-height: 1.55; }
+.stats { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 0; margin-top: 26px; border-top: 1px solid var(--ink); }
+.stats div { padding: 14px 14px 14px 0; border-bottom: 1px solid var(--rule); }
+.stats b { display: block; font-size: 24px; letter-spacing: -0.02em; font-variant-numeric: tabular-nums; }
+.stats span { color: var(--slate); font-size: 13.5px; }
+
+.foot { display: flex; justify-content: space-between; gap: 20px; padding: 18px 36px 26px; border-top: 1px solid var(--rule); color: var(--slate); font-size: 13.5px; flex-wrap: wrap; }
+
+@media (max-width: 1100px) {
+  .shell { grid-template-columns: 1fr; }
+  .ledger { border: 0; border-bottom: 1px solid var(--rule); padding: 10px 20px; overflow-x: auto; }
+  #steps { display: flex; gap: 4px; }
+  #steps button { grid-template-columns: auto auto; white-space: nowrap; padding: 8px 12px; }
+  #steps li.on::before { left: 0; right: 0; top: auto; bottom: 0; height: 3px; width: auto; }
+  .sheet { position: static; border: 0; border-top: 1px solid var(--rule); max-height: none; }
+  .panel { padding: 24px 20px 40px; }
+  .top { padding: 18px 20px 14px; flex-wrap: wrap; gap: 8px 18px; }
+}
+@media (max-width: 640px) {
+  .specimens, .row2 { grid-template-columns: 1fr; }
+  .bp-row { grid-template-columns: 1fr; gap: 6px; }
+  .stats { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  .press { height: 250px; }
+}

static/app.js

@@ -0,0 +1,255 @@
+"use strict";
+const STEPS = ["Format", "Domains", "Subdomains", "Languages", "Summary", "Engine", "Run"];
+const LANGS = ["English", "Spanish", "French", "German", "Portuguese", "Italian", "Dutch", "Hindi", "Bengali", "Arabic", "Turkish", "Russian", "Polish", "Ukrainian",
+  "Chinese", "Japanese", "Korean", "Vietnamese", "Indonesian", "Thai", "Swahili", "Serbian", "Greek", "Hebrew"];
+const PRESETS = {
+  hf: { label: "Hugging Face, free", base_url: "https://router.huggingface.co/v1", model: "prism-ml/Ternary-Bonsai-27B-AWQ-4bit:together", disable_thinking: true },
+  openai: { label: "OpenAI", base_url: "https://api.openai.com/v1", model: "gpt-4o-mini", disable_thinking: false },
+  local: { label: "Local server", base_url: "http://localhost:11434/v1", model: "llama3.1", disable_thinking: false },
+};
+const FORMATS = {
+  instruction: { name: "Instruction pairs", blurb: "A prompt and the reply you want a model to learn. Use it for supervised fine-tuning.",
+    eg: [["Prompt", "My hardcover arrived with a bent corner. Can I swap it?"], ["Completion", "Sorry about that. Yes, send a photo of the corner and we will ship a replacement today, no need to return the damaged copy."]] },
+  preference: { name: "Preference pairs", blurb: "A prompt with a chosen and a rejected reply, ranked by the model. Use it for preference tuning.",
+    eg: [["Prompt", "Where is order 8824? It was due Monday."], ["Chosen", "It left our warehouse Saturday and is with the courier. Tracking shows delivery Thursday."], ["Rejected", "Orders usually take a while. Please be patient."]] },
+};
+
+const S = {
+  step: 0, maxStep: 0, format: "instruction", domains: [], subs: {}, languages: ["English"], request: "", constraints: "", rows: 100,
+  blueprint: null, bpBusy: false, bpError: "", engine: { base_url: PRESETS.hf.base_url, model: PRESETS.hf.model, api_key: "", disable_thinking: true, workers: 4 },
+  preset: "hf", ping: null, pinging: false, job: null, jobRows: [], jobState: null, drawn: 0, printed: 0, hosted: false, maxRows: 1000, domainData: [], runError: "",
+};
+const $ = (s, el = document) => el.querySelector(s);
+const esc = (t) => String(t ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+const sentence = (t) => (t ? t.charAt(0).toUpperCase() + t.slice(1) : t);
+
+async function api(path, body, method) {
+  const r = await fetch(path, { method: method || (body ? "POST" : "GET"), headers: body ? { "Content-Type": "application/json" } : {}, body: body ? JSON.stringify(body) : undefined });
+  let data = null; try { data = await r.json(); } catch (e) { /* not json */ }
+  if (!r.ok) throw new Error((data && (data.detail || data.message)) || `Request failed (${r.status})`);
+  return data;
+}
+const spec = () => ({ engine: S.engine, format: S.format, request: S.request.trim(), domains: S.domains, subdomains: Object.values(S.subs).flat(),
+  languages: S.languages, constraints: S.constraints, rows: S.rows, blueprint: S.blueprint });
+
+/* ------------------------------------------------------------ chrome */
+function renderLedger() {
+  $("#steps").innerHTML = STEPS.map((n, i) => {
+    const cls = i === S.step ? "on" : i < S.step ? "done" : "";
+    return `<li class="${cls}"><button data-go="${i}" ${i > S.maxStep ? "disabled" : ""} ${i === S.step ? 'aria-current="step"' : ""}><span class="n">${i + 1}</span><span>${n}</span></button></li>`;
+  }).join("");
+}
+function estimate() {
+  const per = S.format === "preference" ? 4.4 : 2.5, lat = (S.ping && S.ping.latency_ms) || 1800;
+  const calls = Math.round(S.rows * per + 2);
+  const secs = Math.max(10, Math.round((calls * lat) / 1000 / Math.max(1, S.engine.workers)));
+  const t = secs >= 3600 ? `${(secs / 3600).toFixed(1)} hours` : secs >= 90 ? `${Math.round(secs / 60)} minutes` : `${secs} seconds`;
+  return { calls, time: t };
+}
+function renderSheet() {
+  const e = estimate(), subs = Object.values(S.subs).flat();
+  const line = (k, v) => `<div class="line"><dt>${k}</dt><dd>${v}</dd></div>`;
+  $("#sheet").innerHTML = `<h2>Your dataset</h2><dl>
+    ${line("Format", esc(FORMATS[S.format].name))}
+    ${line("Domains", S.domains.length ? esc(S.domains.join(", ")) : '<span class="hint">None chosen. The description will guide it.</span>')}
+    ${line("Subdomains", subs.length ? esc(subs.slice(0, 6).join(", ")) + (subs.length > 6 ? ` and ${subs.length - 6} more` : "") : '<span class="hint">All</span>')}
+    ${line("Languages", esc(S.languages.join(", ")))}
+    ${line("Rows", S.rows.toLocaleString())}
+    ${line("Model", esc(S.engine.model))}
+  </dl><p class="est">About <b>${e.calls.toLocaleString()}</b> model calls and <b>${e.time}</b> on this setup.</p>`;
+}
+function go(i) { S.step = i; S.maxStep = Math.max(S.maxStep, i); render(); $("#panel").focus({ preventScroll: true }); window.scrollTo({ top: 0 }); }
+function actions(back, nextLabel, nextOk = true, extra = "") {
+  return `<div class="actions">${back ? `<button class="btn" data-act="back">Back</button>` : ""}${nextLabel ? `<button class="btn go" data-act="next" ${nextOk ? "" : "disabled"}>${nextLabel}</button>` : ""}${extra}</div>`;
+}
+
+/* ------------------------------------------------------------ steps */
+function stepFormat() {
+  return `<h1>What kind of rows do you need?</h1>
+  <p class="lede">Pick the shape of each example. You can describe the content in the steps that follow.</p>
+  <div class="specimens">${Object.entries(FORMATS).map(([k, f]) => `
+    <button class="spec" data-format="${k}" aria-pressed="${S.format === k}"><b>${f.name}</b><span class="hint">${f.blurb}</span>
+      <div class="eg">${f.eg.map(([l, t]) => `<p><u>${l}</u>${esc(t)}</p>`).join("")}</div></button>`).join("")}</div>
+  ${actions(false, "Continue")}`;
+}
+function stepDomains() {
+  return `<h2>Which areas should the data cover?</h2>
+  <p class="lede">Choose any number, or skip this and describe the data yourself in the summary.</p>
+  <ul class="choices">${S.domainData.map((d) => `<li><button class="choice" data-domain="${esc(d.name)}" aria-pressed="${S.domains.includes(d.name)}"><span class="box"></span><span>${esc(d.name)}</span></button></li>`).join("")}</ul>
+  ${actions(true, "Continue")}`;
+}
+function stepSubs() {
+  if (!S.domains.length) return `<h2>Subdomains</h2><p class="lede">No domains chosen, so there is nothing to narrow. Continue to the languages, or go back and pick a domain.</p>${actions(true, "Continue")}`;
+  return `<h2>Narrow it down</h2><p class="lede">Pick the subdomains you care about. Leave a domain empty to cover all of it.</p>
+  ${S.domains.map((name) => { const d = S.domainData.find((x) => x.name === name); const sel = S.subs[name] || [];
+    return `<div class="sub-block"><h3>${esc(name)}</h3><ul class="choices">${d.subdomains.map((s) => `<li><button class="choice" data-sub="${esc(name)}|${esc(s)}" aria-pressed="${sel.includes(s)}"><span class="box"></span><span>${esc(sentence(s))}</span></button></li>`).join("")}</ul></div>`; }).join("")}
+  ${actions(true, "Continue")}`;
+}
+function stepLangs() {
+  return `<h2>Which languages?</h2><p class="lede">Rows are written directly in each language you choose, split evenly. English is the default.</p>
+  <ul class="choices">${LANGS.map((l) => `<li><button class="choice" data-lang="${l}" aria-pressed="${S.languages.includes(l)}"><span class="box"></span><span>${l}</span></button></li>`).join("")}</ul>
+  ${actions(true, "Continue", S.languages.length > 0)}`;
+}
+function bpView() {
+  const bp = S.blueprint; if (!bp) return "";
+  return `<div class="bp">
+    <div class="bp-row"><b>Who answers</b><span>${esc(bp.assistant_role)}</span></div>
+    <div class="bp-row"><b>Topics</b><div class="tree">${bp.topics.map((a) => `<div><strong>${esc(a.area)}</strong> <small>${a.subtopics.map((s) => esc(s.subtopic)).join(", ")}</small></div>`).join("")}</div></div>
+    <div class="bp-row"><b>Who asks</b><ul>${bp.personas.map((p) => `<li>${esc(p)}</li>`).join("")}</ul></div>
+    <div class="bp-row"><b>Question shapes</b><ul>${bp.formats.map((p) => `<li>${esc(p)}</li>`).join("")}</ul></div>
+  </div>`;
+}
+function stepSummary() {
+  const suggest = () => { const d = S.domains.length ? ` covering ${S.domains.join(", ").toLowerCase()}` : ""; return `A dataset of ${S.format === "preference" ? "prompts with a better and a worse reply" : "prompts and ideal replies"}${d}.`; };
+  return `<h2>Describe the dataset</h2>
+  <p class="lede">Say what you want in your own words. The more specific you are about who asks and who answers, the better the rows.</p>
+  <label class="f"><span>What should the dataset contain?</span>
+    <textarea class="in" id="request" placeholder="Customer support conversations for a small online bookshop: order status, returns, damaged books and gift wrapping.">${esc(S.request)}</textarea></label>
+  <p style="margin-top:8px"><button class="linkish" data-act="suggest">Draft a description from my choices</button> <span class="hint" data-suggest="${esc(suggest())}"></span></p>
+  <label class="f"><span>Rules every row must follow <span class="hint">(optional)</span></span>
+    <textarea class="in" id="constraints" style="min-height:76px" placeholder="Replies must be under 120 words. Use plain text, no markdown.">${esc(S.constraints)}</textarea></label>
+  <div class="group"><h3>How many rows?</h3>
+    <div class="seg" role="group" aria-label="Rows">${[25, 100, 250, 500, 1000].filter((n) => n <= S.maxRows).map((n) => `<button data-rows="${n}" aria-pressed="${S.rows === n}">${n.toLocaleString()}</button>`).join("")}</div>
+    <p class="hint" style="margin-top:8px">Hosted runs are capped at ${S.maxRows.toLocaleString()} rows. Run it yourself for more.</p></div>
+  <div class="group"><h3>Blueprint</h3>
+    <p class="hint">A plan for coverage: topics, who asks, who answers, and the shapes questions take. Preview it before you spend model calls on rows.</p>
+    <div class="actions" style="margin-top:12px"><button class="btn" data-act="blueprint" ${S.bpBusy || !S.request.trim() ? "disabled" : ""}>${S.bpBusy ? "Drafting the blueprint" : S.blueprint ? "Draft it again" : "Preview the blueprint"}</button></div>
+    ${S.bpError ? `<p class="note bad">${esc(S.bpError)}</p>` : ""}${bpView()}</div>
+  ${actions(true, "Continue", !!S.request.trim())}`;
+}
+function stepEngine() {
+  const p = S.ping;
+  return `<h2>Choose the model that writes the rows</h2>
+  <p class="lede">DataInventor works with any OpenAI-compatible endpoint. The default is a free model on Hugging Face.</p>
+  <div class="seg" role="group" aria-label="Presets">${Object.entries(PRESETS).map(([k, v]) => `<button data-preset="${k}" aria-pressed="${S.preset === k}">${v.label}</button>`).join("")}</div>
+  <label class="f"><span>Base URL</span><input class="in" id="base_url" value="${esc(S.engine.base_url)}" spellcheck="false"></label>
+  <div class="row2"><label class="f"><span>Model</span><input class="in" id="model" value="${esc(S.engine.model)}" spellcheck="false"></label>
+    <label class="f"><span>API key</span><input class="in" id="api_key" type="password" autocomplete="off" placeholder="${S.preset === "hf" && S.hosted ? "Optional here. The host supplies one." : "Paste a key"}" value="${esc(S.engine.api_key)}"></label></div>
+  <p class="hint" style="margin-top:6px">The key is used for this run only. It is not stored.${S.preset === "local" ? " A hosted Space cannot reach localhost. Run DataInventor on your machine to use a local server." : ""}</p>
+  <label class="check"><input type="checkbox" id="think" ${S.engine.disable_thinking ? "checked" : ""}><span><b>Turn thinking off</b><br><span class="hint">For reasoning models that return empty text until they finish thinking. It makes each call several times faster. Leave it off for endpoints that reject the setting.</span></span></label>
+  <label class="f" style="max-width:240px"><span>Parallel calls</span><input class="in" id="workers" type="number" min="1" max="8" value="${S.engine.workers}"></label>
+  <div class="actions"><button class="btn" data-act="ping" ${S.pinging ? "disabled" : ""}>${S.pinging ? "Testing" : "Test the connection"}</button>
+    ${p ? (p.ok ? `<span class="note ok" style="margin:0">Connected. One call took ${p.latency_ms} ms.</span>` : `<span class="note bad" style="margin:0">${esc(p.error)}</span>`) : ""}</div>
+  ${actions(true, "Review and start")}`;
+}
+const isFinal = (j) => j && ["done", "stopped", "failed"].includes(j.state);
+function rowHtml(r) {
+  const pref = S.format === "preference";
+  return `<div class="trow"><span class="id">${r.id}</span><div><div class="p">${esc(r.prompt)}</div><div class="meta">${esc(r.area)}, ${esc(r.persona)}${r.language && r.language !== "English" ? ", " + esc(r.language) : ""}</div>
+    <details><summary>${pref ? "Read both replies" : "Read the reply"}</summary><div class="full">${pref ? "Chosen\n" + esc(r.chosen) + "\n\nRejected\n" + esc(r.rejected) : esc(r.completion)}</div></details></div></div>`;
+}
+function deckHtml() {
+  const pref = S.format === "preference", latest = S.jobRows.slice(-3);
+  const fresh = latest.length ? latest[latest.length - 1].id : 0;
+  const out = latest.map((r, i) => `<div class="card ${i === latest.length - 1 && fresh > S.printed ? "print" : ""}" style="transform:translate(${i * 16}px, ${i * 14}px);z-index:${i}"><em>${esc(r.persona)}, ${esc(r.topic)}</em><div class="clip">${esc(r.prompt)}</div><div class="a clip">${esc(pref ? r.chosen : r.completion)}</div></div>`).join("");
+  S.printed = Math.max(S.printed, fresh);
+  return out;
+}
+function headParts() {
+  const j = S.jobState, n = j ? j.count : 0, t = j ? j.target || S.rows : S.rows, pct = t ? Math.min(100, Math.round((n / t) * 100)) : 0, fin = isFinal(j);
+  const st = j && j.stats && j.stats.rows ? j.stats : null;
+  return {
+    h2: fin ? (j.state === "failed" ? "The run stopped" : "Your dataset is ready") : "Writing your dataset",
+    count: `<span class="big">${n.toLocaleString()}</span><span class="of">of ${t.toLocaleString()} rows</span>`, pct,
+    state: `${j ? esc(j.message) : "Starting"}${j && !fin ? ` Elapsed ${Math.round(j.elapsed)} s.` : ""}`,
+    note: j && j.state === "failed" ? `<p class="note bad">${esc(j.message)}</p>` : j && j.state === "done" && j.count < j.target ? `<p class="note">${esc(j.message)}</p>` : "",
+    actions: fin ? `${j.count ? `<a class="btn go" href="/api/jobs/${j.id}/download?format=csv" style="text-decoration:none">Download CSV</a><a class="btn" href="/api/jobs/${j.id}/download?format=jsonl" style="text-decoration:none">Download JSONL</a>` : ""}<button class="btn" data-act="again">Start another</button>` : `<button class="btn" data-act="stop">Stop and keep what is written</button>`,
+    stats: st ? `<div class="stats"><div><b>${st.rows.toLocaleString()}</b><span>rows</span></div><div><b>${st.distinct3_prompts}</b><span>distinct 3-grams in prompts</span></div><div><b>${st.avg_prompt_words}</b><span>words per prompt</span></div><div><b>${st.avg_answer_words}</b><span>words per reply</span></div></div>` : "",
+    filtered: j && j.rejected && Object.keys(j.rejected).length ? `<p class="hint" style="margin-top:12px">Filtered out: ${Object.entries(j.rejected).map(([k, v]) => `${v} ${esc(k)}`).join(", ")}.</p>` : "",
+  };
+}
+function stepRun() {
+  if (S.runError && !S.jobState) return `<h2>The run did not start</h2><p class="note bad">${esc(S.runError)}</p>${actions(true, "Try again")}`;
+  const h = headParts(); S.drawn = S.jobRows.length;
+  return `<div id="runroot"><h2 id="run-h2">${h.h2}</h2>
+  <div class="count" id="run-count" aria-live="polite">${h.count}</div>
+  <div class="bar" role="progressbar" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${h.pct}"><i id="run-bar" style="width:${h.pct}%"></i></div>
+  <p class="state" id="run-state">${h.state}</p><div id="run-note">${h.note}</div>
+  <div class="actions" id="run-actions">${h.actions}</div><div id="run-stats">${h.stats}</div><div id="run-filtered">${h.filtered}</div>
+  <div class="press" id="run-deck" aria-hidden="true">${deckHtml()}</div>
+  <div class="table" id="run-rows">${S.jobRows.slice().reverse().map(rowHtml).join("")}</div></div>`;
+}
+/* patch the run view in place so open replies stay open and only a new card prints */
+function updateRun() {
+  const h = headParts(), set = (id, html) => { const el = document.getElementById(id); if (el && el.innerHTML !== html) el.innerHTML = html; };
+  set("run-h2", h.h2); set("run-count", h.count); set("run-state", h.state); set("run-note", h.note); set("run-actions", h.actions); set("run-stats", h.stats); set("run-filtered", h.filtered);
+  const bar = document.getElementById("run-bar"); if (bar) { bar.style.width = h.pct + "%"; bar.parentElement.setAttribute("aria-valuenow", h.pct); }
+  const deck = document.getElementById("run-deck"); if (deck) deck.innerHTML = deckHtml();
+  const rows = document.getElementById("run-rows");
+  if (rows && S.jobRows.length > S.drawn) { rows.insertAdjacentHTML("afterbegin", S.jobRows.slice(S.drawn).reverse().map(rowHtml).join("")); S.drawn = S.jobRows.length; }
+}
+
+/* ------------------------------------------------------------ render + events */
+function render() {
+  renderLedger(); renderSheet();
+  const fn = [stepFormat, stepDomains, stepSubs, stepLangs, stepSummary, stepEngine, stepRun][S.step];
+  const keep = document.activeElement && document.activeElement.id;
+  $("#panel").innerHTML = fn();
+  if (keep) { const el = document.getElementById(keep); if (el) { el.focus(); if (el.setSelectionRange && el.type !== "number") { const l = el.value.length; try { el.setSelectionRange(l, l); } catch (e) { /* ok */ } } } }
+}
+document.addEventListener("click", async (ev) => {
+  const t = ev.target.closest("button, a"); if (!t) return;
+  if (t.dataset.go !== undefined) return go(+t.dataset.go);
+  if (t.dataset.format) { S.format = t.dataset.format; S.blueprint = null; return render(); }
+  if (t.dataset.domain) { const d = t.dataset.domain; S.domains = S.domains.includes(d) ? S.domains.filter((x) => x !== d) : [...S.domains, d]; if (!S.domains.includes(d)) delete S.subs[d]; S.blueprint = null; return render(); }
+  if (t.dataset.sub) { const [d, s] = t.dataset.sub.split("|"); const cur = S.subs[d] || []; S.subs[d] = cur.includes(s) ? cur.filter((x) => x !== s) : [...cur, s]; S.blueprint = null; return render(); }
+  if (t.dataset.lang) { const l = t.dataset.lang; S.languages = S.languages.includes(l) ? S.languages.filter((x) => x !== l) : [...S.languages, l]; S.blueprint = null; return render(); }
+  if (t.dataset.rows) { S.rows = +t.dataset.rows; return render(); }
+  if (t.dataset.preset) { const p = PRESETS[t.dataset.preset]; S.preset = t.dataset.preset; S.engine = { ...S.engine, base_url: p.base_url, model: p.model, disable_thinking: p.disable_thinking }; S.ping = null; return render(); }
+  const act = t.dataset.act; if (!act) return;
+  if (act === "next") return void go(S.step + 1);
+  if (act === "back") return go(Math.max(0, S.step - 1));
+  if (act === "suggest") { S.request = S.request.trim() ? S.request : $("[data-suggest]").dataset.suggest; return render(); }
+  if (act === "blueprint") return doBlueprint();
+  if (act === "ping") return doPing();
+  if (act === "stop") { if (S.job) await api(`/api/jobs/${S.job}/stop`, {}); return; }
+  if (act === "again") { S.job = null; S.jobState = null; S.jobRows = []; S.drawn = 0; S.printed = 0; S.runError = ""; return go(4); }
+});
+document.addEventListener("input", (ev) => {
+  const id = ev.target.id;
+  if (id === "request") { S.request = ev.target.value; S.blueprint = null; const b = $('[data-act="next"]'); if (b) b.disabled = !S.request.trim(); const bp = $('[data-act="blueprint"]'); if (bp) bp.disabled = S.bpBusy || !S.request.trim(); }
+  else if (id === "constraints") { S.constraints = ev.target.value; S.blueprint = null; }
+  else if (id === "base_url") { S.engine.base_url = ev.target.value; S.preset = ""; }
+  else if (id === "model") S.engine.model = ev.target.value;
+  else if (id === "api_key") S.engine.api_key = ev.target.value;
+  else if (id === "workers") { S.engine.workers = Math.max(1, Math.min(8, +ev.target.value || 1)); renderSheet(); }
+  else if (id === "think") S.engine.disable_thinking = ev.target.checked;
+  if (id === "model") renderSheet();
+});
+document.addEventListener("change", (ev) => { if (ev.target.id === "think") S.engine.disable_thinking = ev.target.checked; });
+
+async function doBlueprint() {
+  S.bpBusy = true; S.bpError = ""; render();
+  try { S.blueprint = await api("/api/blueprint", spec()); } catch (e) { S.bpError = e.message; }
+  S.bpBusy = false; render();
+}
+async function doPing() {
+  S.pinging = true; S.ping = null; render();
+  try { S.ping = await api("/api/ping", S.engine); } catch (e) { S.ping = { ok: false, error: e.message }; }
+  S.pinging = false; render();
+}
+async function startRun() {
+  S.runError = ""; S.jobRows = []; S.jobState = null; S.drawn = 0; S.printed = 0;
+  try { const r = await api("/api/jobs", spec()); S.job = r.id; poll(); } catch (e) { S.runError = e.message; }
+  render();
+}
+async function poll() {
+  const id = S.job; if (!id) return;
+  try {
+    const j = await api(`/api/jobs/${id}?since=${S.jobRows.length}`);
+    if (id !== S.job) return;
+    const wasFinal = isFinal(S.jobState); S.jobRows.push(...j.new_rows); S.jobState = j;
+    if (S.step === 6) { if (document.getElementById("runroot") && !wasFinal) updateRun(); else render(); }
+    if (!["done", "stopped", "failed"].includes(j.state) || j.count > S.jobRows.length) return void setTimeout(poll, j.count > S.jobRows.length ? 200 : 1500);
+    if (j.stats && j.stats.rows) S.maxStep = 6;
+  } catch (e) { console.error(e.stack); S.jobState = { state: "failed", message: e.message, count: S.jobRows.length, target: S.rows, elapsed: 0, id }; if (S.step === 6) render(); }
+}
+/* "Review and start" on the engine step starts the run */
+const _go = go;
+go = function (i) { const wasEngine = S.step === 5; _go(i); if (i === 6 && wasEngine && !S.jobState) startRun(); return true; };
+
+(async function init() {
+  try { const d = await api("/api/defaults"); S.hosted = d.hosted_key; S.maxRows = d.max_rows; if (S.rows > S.maxRows) S.rows = S.maxRows; $("#hostnote").textContent = d.hosted_key ? "Hosted model key supplied by the Space." : ""; } catch (e) { /* offline */ }
+  try { S.domainData = await api("/api/domains"); } catch (e) { S.domainData = []; }
+  render();
+})();

static/domains.json

@@ -0,0 +1,716 @@
+[
+ {
+  "name": "Academic education",
+  "subdomains": [
+   "online learning",
+   "virtual classrooms",
+   "open educational resources",
+   "blended learning",
+   "microlearning",
+   "flipped classroom",
+   "adaptive learning",
+   "peer tutoring",
+   "competency based education",
+   "digital literacy",
+   "collaborative learning",
+   "personalized education"
+  ]
+ },
+ {
+  "name": "Agriculture",
+  "subdomains": [
+   "Precision Farming",
+   "Sustainable Agriculture",
+   "Agroecology",
+   "Vertical Farming",
+   "Regenerative Agriculture",
+   "Organic Farming",
+   "Aquaculture",
+   "Permaculture",
+   "Agroforestry",
+   "Hydroponics",
+   "Biotechnology in Agriculture",
+   "Climate-Smart Agriculture"
+  ]
+ },
+ {
+  "name": "Animal and nature",
+  "subdomains": [
+   "Wildlife Conservation",
+   "Botanical Gardens",
+   "Marine Biology",
+   "Bird Watching",
+   "Insect Ecology",
+   "Forest Preservation",
+   "Zoo Management",
+   "Nature Photography",
+   "Habitat Restoration",
+   "Mammal Studies",
+   "Desert Ecosystems",
+   "Aquatic Life"
+  ]
+ },
+ {
+  "name": "Architecture and design",
+  "subdomains": [
+   "residential architecture",
+   "commercial design",
+   "sustainable building",
+   "urban planning",
+   "interior design",
+   "landscape architecture",
+   "industrial design",
+   "digital architecture",
+   "adaptive reuse",
+   "smart cities",
+   "biophilic design",
+   "modular construction"
+  ]
+ },
+ {
+  "name": "Art",
+  "subdomains": [
+   "Art History",
+   "Modern Art",
+   "Contemporary Art",
+   "Digital Art",
+   "Abstract Art",
+   "Sculpture Art",
+   "Photography Art",
+   "Street Art",
+   "Pop Art",
+   "Minimalist Art",
+   "Installation Art",
+   "Folk Art"
+  ]
+ },
+ {
+  "name": "Career and workplace",
+  "subdomains": [
+   "Resume Writing",
+   "Interview Skills",
+   "Career Planning",
+   "Workplace Communication",
+   "Professional Development",
+   "Leadership Training",
+   "Time Management",
+   "Conflict Resolution",
+   "Team Collaboration",
+   "Job Search Strategies",
+   "Salary Negotiation",
+   "Remote Work Etiquette"
+  ]
+ },
+ {
+  "name": "Code",
+  "subdomains": [
+   "Code Review",
+   "Code Analysis",
+   "Code Optimization",
+   "Code Refactoring",
+   "Code Documentation",
+   "Code Testing",
+   "Code Security",
+   "Code Generation",
+   "Code Quality",
+   "Code Architecture",
+   "Code Maintenance",
+   "Code Education"
+  ]
+ },
+ {
+  "name": "Cooking",
+  "subdomains": [
+   "quick recipes",
+   "healthy meals",
+   "baking basics",
+   "vegan cooking",
+   "meal prep",
+   "dessert ideas",
+   "kitchen tips",
+   "international cuisine",
+   "slow cooker",
+   "budget cooking",
+   "food safety",
+   "pasta dishes"
+  ]
+ },
+ {
+  "name": "Corporate and business",
+  "subdomains": [
+   "Corporate Governance",
+   "Business Strategy",
+   "Financial Management",
+   "Human Resources",
+   "Marketing Analytics",
+   "Supply Chain",
+   "Risk Management",
+   "Customer Service",
+   "Legal Compliance",
+   "Project Management",
+   "Leadership Development",
+   "Operational Efficiency"
+  ]
+ },
+ {
+  "name": "Culture",
+  "subdomains": [
+   "Visual Arts",
+   "Music History",
+   "Literary Traditions",
+   "Performing Arts",
+   "Cultural Anthropology",
+   "Digital Culture",
+   "Food Culture",
+   "Religious Practices",
+   "Fashion Trends",
+   "Architectural Heritage",
+   "Folklore Studies",
+   "Media Studies"
+  ]
+ },
+ {
+  "name": "Data analysis and visualization",
+  "subdomains": [
+   "Data Cleaning Techniques",
+   "Statistical Analysis Methods",
+   "Machine Learning Algorithms",
+   "Data Visualization Tools",
+   "Database Management Systems",
+   "Big Data Processing",
+   "Predictive Analytics Models",
+   "Exploratory Data Analysis",
+   "Data Mining Strategies",
+   "Information Visualization Design",
+   "Natural Language Processing",
+   "Real-time Data Streaming"
+  ]
+ },
+ {
+  "name": "Dating",
+  "subdomains": [
+   "dating apps",
+   "online dating",
+   "dating sites",
+   "dating advice",
+   "dating tips",
+   "dating culture",
+   "dating trends",
+   "dating psychology",
+   "dating safety",
+   "dating etiquette",
+   "dating apps",
+   "dating strategies"
+  ]
+ },
+ {
+  "name": "Entertainment",
+  "subdomains": [
+   "Movie Reviews",
+   "TV Series",
+   "Music Charts",
+   "Celebrity News",
+   "Streaming Platforms",
+   "Concert Tickets",
+   "Theme Parks",
+   "Podcast Shows",
+   "Video Games",
+   "Live Events",
+   "Book Adaptations",
+   "Comedy Specials"
+  ]
+ },
+ {
+  "name": "Fashion and beauty",
+  "subdomains": [
+   "Skincare Basics",
+   "Makeup Tutorials",
+   "Hairstyle Ideas",
+   "Fashion Trends",
+   "Beauty Products",
+   "Style Guides",
+   "Wellness Tips",
+   "Beauty Hacks",
+   "Fashion History",
+   "Skincare Routines",
+   "Makeup Reviews",
+   "Fashion Inspiration"
+  ]
+ },
+ {
+  "name": "Fitness and sports",
+  "subdomains": [
+   "home fitness",
+   "outdoor sports",
+   "team sports",
+   "individual training",
+   "strength training",
+   "cardiovascular fitness",
+   "yoga and pilates",
+   "martial arts",
+   "swimming fitness",
+   "cycling sports",
+   "running training",
+   "flexibility exercises"
+  ]
+ },
+ {
+  "name": "Games",
+  "subdomains": [
+   "mobile games",
+   "indie games",
+   "racing games",
+   "strategy games",
+   "role playing games",
+   "shooter games",
+   "puzzle games",
+   "sports games",
+   "simulation games",
+   "board games",
+   "card games",
+   "party games"
+  ]
+ },
+ {
+  "name": "Geography",
+  "subdomains": [
+   "Physical Geography",
+   "Human Geography",
+   "Cartography",
+   "Geomorphology",
+   "Biogeography",
+   "Economic Geography",
+   "Political Geography",
+   "Cultural Geography",
+   "Urban Geography",
+   "Environmental Geography",
+   "Social Geography",
+   "Historical Geography"
+  ]
+ },
+ {
+  "name": "Governance",
+  "subdomains": [
+   "Public Administration",
+   "Corporate Governance",
+   "Government Accountability",
+   "Policy Implementation",
+   "Regulatory Compliance",
+   "Ethical Leadership",
+   "Stakeholder Engagement",
+   "Decision Making",
+   "Organizational Strategy",
+   "Transparency Practices",
+   "Governance Frameworks",
+   "Accountability Mechanisms"
+  ]
+ },
+ {
+  "name": "History",
+  "subdomains": [
+   "Ancient Civilizations",
+   "Medieval Europe",
+   "World War II",
+   "Cold War Era",
+   "American Revolution",
+   "Renaissance Period",
+   "Industrial Revolution",
+   "Civil Rights Movement",
+   "Ancient Egypt",
+   "Classical Greece",
+   "Cold War Diplomacy",
+   "Colonial America"
+  ]
+ },
+ {
+  "name": "How-to",
+  "subdomains": [
+   "how-to-fix",
+   "how-to-cook",
+   "how-to-program",
+   "how-to-travel",
+   "how-to-clean",
+   "how-to-build",
+   "how-to-save",
+   "how-to-learn",
+   "how-to-organize",
+   "how-to-design",
+   "how-to-market",
+   "how-to-lead"
+  ]
+ },
+ {
+  "name": "HR",
+  "subdomains": [
+   "Human Resources",
+   "Recruitment Services",
+   "Employee Relations",
+   "Performance Management",
+   "Compensation Benefits",
+   "Training Development",
+   "Organizational Development",
+   "Workforce Planning",
+   "Employee Engagement",
+   "HR Analytics",
+   "Compliance Legal",
+   "Diversity Inclusion"
+  ]
+ },
+ {
+  "name": "Language",
+  "subdomains": [
+   "Natural Language Processing",
+   "Computational Linguistics",
+   "Machine Translation",
+   "Speech Recognition",
+   "Text Generation",
+   "Sentiment Analysis",
+   "Machine Learning",
+   "Deep Learning",
+   "Neural Networks",
+   "Data Annotation",
+   "Language Modeling",
+   "Natural Language Inference"
+  ]
+ },
+ {
+  "name": "Legal",
+  "subdomains": [
+   "legal research",
+   "case law",
+   "statutory interpretation",
+   "legal ethics",
+   "contract law",
+   "tort law",
+   "criminal procedure",
+   "civil procedure",
+   "legal writing",
+   "legal argumentation",
+   "legal reasoning",
+   "legal ethics"
+  ]
+ },
+ {
+  "name": "Market analysis",
+  "subdomains": [
+   "Market Trends Analysis",
+   "Consumer Behavior Study",
+   "Competitive Intelligence Report",
+   "Industry Growth Forecast",
+   "Product Market Fit",
+   "Market Segmentation Strategy",
+   "Demand Supply Analysis",
+   "Pricing Strategy Review",
+   "Brand Positioning Analysis",
+   "Customer Acquisition Cost",
+   "Market Share Evaluation",
+   "Economic Impact Study"
+  ]
+ },
+ {
+  "name": "Marketing",
+  "subdomains": [
+   "Digital Marketing",
+   "Content Marketing",
+   "Social Media Marketing",
+   "Email Marketing",
+   "Search Engine Marketing",
+   "Performance Marketing",
+   "Brand Marketing",
+   "Growth Marketing",
+   "Content Strategy",
+   "Marketing Automation",
+   "Marketing Analytics",
+   "Influencer Marketing"
+  ]
+ },
+ {
+  "name": "Math",
+  "subdomains": [
+   "Linear Algebra",
+   "Calculus",
+   "Statistics",
+   "Number Theory",
+   "Topology",
+   "Probability",
+   "Differential Equations",
+   "Abstract Algebra",
+   "Geometry",
+   "Combinatorics",
+   "Analysis",
+   "Graph Theory"
+  ]
+ },
+ {
+  "name": "Medical",
+  "subdomains": [
+   "medical research",
+   "clinical trials",
+   "medical education",
+   "medical devices",
+   "medical imaging",
+   "medical diagnostics",
+   "medical treatments",
+   "medical ethics",
+   "medical statistics",
+   "medical informatics",
+   "medical genetics",
+   "medical psychology"
+  ]
+ },
+ {
+  "name": "Music",
+  "subdomains": [
+   "Music Theory Basics",
+   "Jazz Harmony Guide",
+   "Classical Music History",
+   "Electronic Music Production",
+   "Songwriting Techniques",
+   "Music Performance Skills",
+   "Music Technology Tools",
+   "Music Education Methods",
+   "Music Psychology Insights",
+   "Music Marketing Strategies",
+   "Music Copyright Laws",
+   "Music Streaming Platforms"
+  ]
+ },
+ {
+  "name": "News",
+  "subdomains": [
+   "Breaking News",
+   "World News",
+   "Sports News",
+   "Tech News",
+   "Business News",
+   "Health News",
+   "Entertainment News",
+   "Local News",
+   "Science News",
+   "Political News",
+   "Climate News",
+   "Opinion News"
+  ]
+ },
+ {
+  "name": "Parenting and family",
+  "subdomains": [
+   "Child Development Stages",
+   "Family Communication Skills",
+   "Parenting Styles Overview",
+   "Emotional Intelligence Training",
+   "Conflict Resolution Techniques",
+   "Positive Discipline Methods",
+   "Teen Parenting Challenges",
+   "Single Parent Support",
+   "Blended Family Dynamics",
+   "Early Childhood Education",
+   "Family Rituals and Traditions",
+   "Parental Self-Care Practices"
+  ]
+ },
+ {
+  "name": "Personal finance",
+  "subdomains": [
+   "budgeting basics",
+   "debt management",
+   "investment strategies",
+   "retirement planning",
+   "tax optimization",
+   "credit score improvement",
+   "financial literacy",
+   "emergency fund building",
+   "real estate investing",
+   "cryptocurrency basics",
+   "insurance coverage",
+   "financial independence"
+  ]
+ },
+ {
+  "name": "Personal growth",
+  "subdomains": [
+   "Mindset Mastery",
+   "Habit Formation",
+   "Emotional Intelligence",
+   "Goal Setting",
+   "Self Awareness",
+   "Productivity Systems",
+   "Communication Skills",
+   "Resilience Building",
+   "Time Management",
+   "Confidence Development",
+   "Critical Thinking",
+   "Work Life Balance"
+  ]
+ },
+ {
+  "name": "Product advice",
+  "subdomains": [
+   "Product Advice",
+   "Product Reviews",
+   "Product Comparison",
+   "Product Ratings",
+   "Product Specs",
+   "Product Deals",
+   "Product Tips",
+   "Product Guides",
+   "Product Q&A",
+   "Product News",
+   "Product Updates",
+   "Product Support"
+  ]
+ },
+ {
+  "name": "Religion",
+  "subdomains": [
+   "Christian Theology",
+   "Islamic Jurisprudence",
+   "Buddhist Philosophy",
+   "Jewish Law",
+   "Hindu Mythology",
+   "Sikh Beliefs",
+   "Daoist Practices",
+   "Zoroastrianism",
+   "Jainism",
+   "Secular Humanism",
+   "Comparative Religion",
+   "Religious Ethics"
+  ]
+ },
+ {
+  "name": "Roleplay",
+  "subdomains": [
+   "Creative Writing Roleplay",
+   "Fantasy Roleplay Community",
+   "Sci-Fi Roleplay Hub",
+   "Historical Roleplay Forum",
+   "Romance Roleplay Network",
+   "Horror Roleplay Group",
+   "Mystery Roleplay Space",
+   "Adventure Roleplay Zone",
+   "Daily Roleplay Challenges",
+   "Roleplay Tips and Tricks",
+   "Beginner Roleplay Guide",
+   "Advanced Roleplay Techniques"
+  ]
+ },
+ {
+  "name": "Science",
+  "subdomains": [
+   "Space Exploration",
+   "Quantum Physics",
+   "Marine Biology",
+   "Climate Science",
+   "Neuroscience Research",
+   "Astrophysics Studies",
+   "Genetics Analysis",
+   "Chemistry Education",
+   "Environmental Science",
+   "Mathematics Theory",
+   "Robotics Development",
+   "Virology Studies"
+  ]
+ },
+ {
+  "name": "Social media",
+  "subdomains": [
+   "Social Networking",
+   "Content Sharing",
+   "Video Streaming",
+   "Micro Blogging",
+   "Photo Sharing",
+   "Audio Podcasting",
+   "Professional Networking",
+   "Community Forums",
+   "Live Streaming",
+   "Text Messaging",
+   "Photo Editing",
+   "Social Commerce"
+  ]
+ },
+ {
+  "name": "Sports",
+  "subdomains": [
+   "Olympic Games",
+   "Professional Leagues",
+   "College Athletics",
+   "Youth Sports",
+   "Extreme Sports",
+   "Adaptive Sports",
+   "Esports",
+   "Martial Arts",
+   "Winter Sports",
+   "Outdoor Adventures",
+   "Fitness Training",
+   "Sports Psychology"
+  ]
+ },
+ {
+  "name": "Technology",
+  "subdomains": [
+   "Artificial Intelligence",
+   "Cybersecurity",
+   "Cloud Computing",
+   "Data Science",
+   "Internet of Things",
+   "Machine Learning",
+   "Mobile Development",
+   "Robotics",
+   "Software Engineering",
+   "Virtual Reality",
+   "Web Development",
+   "Blockchain Technology"
+  ]
+ },
+ {
+  "name": "Transportation",
+  "subdomains": [
+   "Public Transit Systems",
+   "Freight Logistics Management",
+   "Urban Mobility Solutions",
+   "Railway Network Operations",
+   "Aviation Safety Protocols",
+   "Maritime Shipping Routes",
+   "Electric Vehicle Infrastructure",
+   "Traffic Flow Optimization",
+   "Autonomous Vehicle Testing",
+   "Pedestrian Safety Measures",
+   "Cycling Infrastructure Development",
+   "Supply Chain Coordination"
+  ]
+ },
+ {
+  "name": "Travel",
+  "subdomains": [
+   "budget travel",
+   "luxury travel",
+   "adventure travel",
+   "eco travel",
+   "solo travel",
+   "family travel",
+   "cruise travel",
+   "road trip",
+   "backpacking travel",
+   "cultural travel",
+   "business travel",
+   "beach travel"
+  ]
+ },
+ {
+  "name": "Writing and editing",
+  "subdomains": [
+   "style guides",
+   "grammar rules",
+   "punctuation usage",
+   "sentence structure",
+   "paragraph organization",
+   "narrative techniques",
+   "academic writing",
+   "business correspondence",
+   "creative storytelling",
+   "technical documentation",
+   "editing strategies",
+   "proofreading methods"
+  ]
+ }
+]

static/index.html

@@ -0,0 +1,35 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>DataInventor</title>
+<meta name="description" content="Describe a dataset in plain words and get training data back. Open source, works with any OpenAI-compatible model.">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Familjen+Grotesk:ital,wght@0,400..700;1,400..700&family=Literata:ital,opsz,wght@0,7..72,400..600;1,7..72,400..600&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="/static/app.css">
+</head>
+<body>
+<a class="skip" href="#panel">Skip to the step</a>
+<header class="top">
+  <div class="brand">
+    <span class="mark" aria-hidden="true"><i></i><i></i></span>
+    <span class="name">DataInventor</span>
+  </div>
+  <p class="tag">Describe the data you wish existed. Get training rows back. Bring any OpenAI-compatible model.</p>
+</header>
+
+<main class="shell">
+  <nav class="ledger" aria-label="Steps"><ol id="steps"></ol></nav>
+  <section class="panel" id="panel" tabindex="-1" aria-live="polite"></section>
+  <aside class="sheet" id="sheet" aria-label="Your dataset so far"></aside>
+</main>
+
+<footer class="foot">
+  <span>Open source recreation of the Invent a Dataset workflow. Not affiliated with Adaption Labs.</span>
+  <span id="hostnote"></span>
+</footer>
+<script src="/static/app.js"></script>
+</body>
+</html>