Publish SmolScript 0.1.0 execution-unverified candidate

2000 generated examples; exact language/difficulty allocation, isolated runners and Hugging Face evaluation. Static audit passes. Full reference and negative-control execution remains unverified because a Docker/Podman sandbox is unavailable.

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+.venv/
+results*.json
+*.lock

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dotlabs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,110 @@
+---
+pretty_name: SmolScript
+license: mit
+language:
+- en
+tags:
+- code
+- code-generation
+- evaluation
+- multilingual
+configs:
+- config_name: default
+  data_files:
+  - split: test
+    path: data/smolscript.parquet
+---
+# SmolScript
+
+An original execution-based benchmark of basic programming for 25M–350M parameter language models. Version **0.1.0**, **2,000 examples**, nine languages, MIT license.
+
+**Release status: execution-unverified candidate.** All 2,000 records have been generated and statically validated. No complete reference execution run or model baseline is claimed. The authoring environment has no Docker/Podman daemon; all 2,000 reference solutions and their negative controls still require execution in the supplied sandbox image. See `validation_report.json` for the machine-readable audit. Do not treat this candidate as a validated leaderboard release until `python validate.py` succeeds.
+
+## Composition
+
+| Language | Easy | Medium | Moderate | Total |
+|---|---:|---:|---:|---:|
+| Python | 150 | 75 | 25 | 250 |
+| JavaScript | 150 | 75 | 25 | 250 |
+| HTML | 120 | 60 | 20 | 200 |
+| CSS | 120 | 60 | 20 | 200 |
+| C++ | 135 | 68 | 22 | 225 |
+| C | 135 | 68 | 22 | 225 |
+| Lua | 120 | 60 | 20 | 200 |
+| C# | 135 | 67 | 23 | 225 |
+| Rust | 135 | 67 | 23 | 225 |
+| **Total** | **1,200** | **600** | **200** | **2,000** |
+
+Programming tasks cover arithmetic and conditions, ASCII string transformations, filtered collection reductions, frequency tables, and short combinations of basic operations. JavaScript includes 20 browser DOM/event tasks. HTML tasks check elements, attributes, text, and nesting. CSS tasks check computed properties, selector scope, unaffected distractors, flex row/column geometry, and responsive breakpoints. No generated solution uses external packages.
+
+Tasks are original compositions from an explicit operation grammar, not scraped HumanEval/MBPP/MultiPL-E questions. Variants change operations and observable behavior, not just names or numbers. Shared tasks across programming languages are intentional translations for comparative coverage. Within each language, deterministic behavioral probe fingerprints reject equivalent programming tasks. Web tasks have unique structural specs. Trigram similarity flags are reported; the seven retained pairs differ in count versus sum and have distinct behavior. This is a finite behavioral/structural audit, not a mathematical proof of semantic uniqueness. Difficulty labels are design judgments; empirical calibration on small models remains future work.
+
+## Install and build the offline sandbox
+
+Requires Python 3.11+, Docker or Podman on Linux (or Docker Desktop's Linux VM), approximately 2 GB memory per concurrent container, and disk space for Chromium and compilers. GPU is optional for generation. All runtime downloads occur during image construction.
+
+```sh
+python -m venv .venv
+. .venv/bin/activate
+pip install -e '.[inference]'
+docker build -f sandbox/Dockerfile -t smolscript-runtime:0.1.0 .
+python validate.py
+```
+
+The image supplies CPython, Node.js, GCC/G++ (C11/C++17), Lua 5.4, Mono C#, Rust (edition 2021), and Playwright Chromium. Candidate functions use basic C# features supported by Mono. The base Playwright image and Python browser dependencies are pinned. OS compiler packages are resolved at build time; preserve/export the built image for exact runtime reproduction. Every evaluation records the immutable local image ID and available registry digests. Rebuilding later may produce a different image.
+
+Containers run as UID 1000 with network disabled, a read-only root, no Linux capabilities, no privilege escalation, 2 GB memory/swap ceiling, one CPU, 128 processes, bounded temporary filesystems, CPU/wall timeouts, and bounded output. Compilation has a separate 30-second limit; each program test has a three-second CPU limit plus a one-second wall allowance. Browser operations have three-second timeouts and a container supervisor limit. Candidates have access only to their code, fixture, and input values; expected answers remain in the host scorer. No host home, Docker socket, credentials, or full dataset is mounted. There is no host-execution fallback. Containers are the required isolation boundary; use a dedicated worker for adversarial submissions.
+
+The sandbox uses the documented [Docker resource and isolation options](https://docs.docker.com/reference/cli/docker/container/run/) and the [Playwright Python container image](https://playwright.dev/python/docs/docker). Evaluation requires no network after model/tokenizer weights and the image have been cached. To enforce offline Hugging Face loading, set `HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1`.
+
+## Validate
+
+```sh
+python validate.py                 # Full reference + negative-control execution
+python validate.py --static-only   # Counts, uniqueness, oracle cases, hashes, Parquet
+python -m unittest discover -s tests -v
+python generators/build.py         # Deterministically regenerate all artifacts
+```
+
+`validate.py` checks every reference against every hidden test and rejects a deliberately wrong solution for every task. For programming tasks it also checks a plausible near-miss mutation where the hidden inputs distinguish it (missing transformation stage, mapping, or filter). Failure stops validation with the task ID. Missing sandbox/runtime exits 2 and records unverified coverage. Static-only success never marks execution as passed. The reference ASTs for all 250 Python tasks are also parsed by the local unit suite.
+
+## Evaluate a model
+
+```sh
+python evaluate.py --model HuggingFaceTB/SmolLM2-135M --output results.json
+python evaluate.py --model HuggingFaceTB/SmolLM2-135M --output results.json --resume
+python evaluate.py --model HuggingFaceTB/SmolLM2-135M --language python rust --difficulty easy --output subset.json
+```
+
+One fixed completion prompt (`smolscript-completion-v1`), one generation, seed 0, greedy decoding, no beam search, and a fixed 384-token output cap. The same completion template is used for base and instruction models; no model-specific chat template is applied. The model revision resolves to an immutable commit and is retained on resume. Use `--revision SHA` for an explicit pin. Prompts contain only instructions, signature, input domain, and web fixture/base styles. References, public examples, hidden tests, and expected answers are never sent to the model.
+
+Existing files require `--resume`. Settings, dataset/runner hashes, image ID and selected IDs must match. Completed task results are checkpointed atomically; a generated response is saved before execution, so an execution interruption can reuse it. Partial runs never receive a full score. Use one process per output path (a file lock enforces this). Context overflow is an explicit failure; input prompts are never silently truncated.
+
+For externally generated code, create JSONL records `{"id":"...","code":"..."}` and use:
+
+```sh
+python evaluate.py --predictions predictions.jsonl --output results.json
+```
+
+Raw code or a single fenced code block is accepted. Multiple or unfinished fences are rejected. Function tasks receive fixed stdin/stdout wrappers. Compiled languages compile once per task, then run a fresh process per test. HTML is parsed with html5lib and checked in Chromium with document scripts disabled. CSS is parsed with tinycss2 and tested against a fixed fixture at the specified widths. Browser tests assert DOM/computed styles and geometry, without image similarity.
+
+## Metrics
+
+All metrics are on **0–100**. A task passes only when every hidden assertion passes. With one generation, per-language accuracy is Pass@1. **SmolScript Score and overall Pass@1 are the macro-average of the nine language accuracies.** Syntax Success is likewise macro-averaged across languages and measures parse/compile success, separately from behavior. `micro_accuracy` is an explicitly secondary count-weighted diagnostic. No score is chance-adjusted.
+
+Filters produce `filtered_macro_score` over selected languages rather than the official nine-language `smolscript_score`. Per-test outputs and pass/fail results are retained. Build failures count as syntax failures; runtime failures count as behavioral failures. Sandbox infrastructure errors stop the run instead of assigning a score.
+
+`examples/result-format.json` illustrates output structure using explicitly synthetic numbers; it is not a model result.
+
+## Files and Hugging Face
+
+`data/smolscript.jsonl` and `data/smolscript.parquet` contain the public test examples. To keep one consistent Parquet schema across modalities, `tests` and `metadata` are JSON strings in Parquet; JSONL uses native JSON values. Decode them with `json.loads` after loading through Hugging Face Datasets. Public `reference_solution` is null; full references are in `references/solutions.jsonl`. Hidden tests live in `private_tests/hidden.jsonl`, outside the public dataset split. These evaluation-only files are published for independent auditing; they are **not access-controlled secrets**. Never include them in model context. Offline evaluation requires downloading the complete repository, including these files.
+
+```python
+from datasets import load_dataset
+import json
+rows = load_dataset('dotlabs/smolscript', split='test')
+metadata = json.loads(rows[0]['metadata'])
+```
+
+The generator, runners and audit reports are included in this repository. Record the Hugging Face repository commit, manifest checksums, generation settings, dependency versions and image ID with any reported result.

SHA256SUMS

@@ -0,0 +1,38 @@
+ff73ee904edc9381bd1ea24847e41c6176aec22ba4b63321e8354562f24ba5ce  .gitignore
+8719af4397a8387b8f04140613943545f8ecd90f06529dcab9e68a94927d13fe  LICENSE
+24908849b2c3cac77e1c0cc1aa82b943c4f8c377bc3930b526f0e4f49e1fa7de  README.md
+1926bca1b0c6b2244554577135a9c3c305b18fd834c654803b4e8480fff0d3d9  data/smolscript.jsonl
+7bf25948750648aa036bdf277cfd7c38597c98aa06131e805628b9055a7938d9  data/smolscript.parquet
+9bd849e38e3e50d19fd2c8ccfae05b7c54060f8d151b832b2bc37c14ae8714c2  evaluate.py
+b6a465089448e1c2eb7f26c981a1ad3e962d73a0433a337d4e781f4ca9525b65  examples/local-test-report.json
+713855348ffc53f49b03a0df47b67294fe2d3593054636eec12b9f184fb3534e  examples/result-format.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  generators/__init__.py
+eeb947e9704931e5b23ed79aee180e4dd49708f9294d7481f51c7da2f5c33e7e  generators/build.py
+e1cf493b995f15470c56c097b73e7403ae06f74f5d12cbb3a43ce522514d8577  generators/code.py
+60be0a7ac6fcd3dfd8b663fc19af189aba3acfdd923219dc6cc1972033380240  generators/specs.py
+ae6a8d5109035027b71df7eb7297e7c0b811a4a98c649e1729a3fe2a2c09c5bf  generators/web.py
+62a01609810b5c488f4a5abe284063b41b780c382046a9da7cc2a6ca755b5488  manifest.json
+6bac32e6045f1788e8b68e96ff6ee41f1b2152cca1b17de24be405025f294930  metrics.py
+2447d09ae445094c1ae59df644b46e3ca2f4cc64de630966b94bd5db8b8bf0ac  private_tests/hidden.jsonl
+a2de1bc75c21817ba1883ee4c5aa04b60a0f4288f3f45893e1c7e71e435f1997  pyproject.toml
+84d3411fe45189c62ae50fbd31c1dc5795bc099d5037c3a817e3d280f6097e83  references/solutions.jsonl
+5a3cb2a82cf3784c41fc9f9046fe6806d5bbe7ce8ae415a9ed1c373abcfe7826  runners/__init__.py
+965bc9e3dabfc3fba4b745994b43118c456be477edcc34a3ba929ebf39e19ce9  runners/c_runner.py
+47eaf32ac4ce76fcfbd01d515f6befccfcd2bf6c277447a73e8b7b58fa7e96f8  runners/common.py
+17c846633f3730669790ee2f11fc93661648eedc950c96d47996d0db4514672b  runners/cpp_runner.py
+e87545f911f6f25238b1f84ed0ac1602900676b77cb3dd5f1560cd62e0b931e4  runners/csharp_runner.py
+96e542ceb76e18759aa8f19fd87beef3612e535f7b9f04944a6bdf1e2fddffec  runners/css_runner.py
+3a02716d96a0061567f50514b5e5df3b30812ed21b524f772ebcb12de915f585  runners/html_runner.py
+21c05c048f2cfcc6e263645b6322527cd8869e6530f3bc8dc11aaf54bb777f5e  runners/javascript_runner.py
+2941363382d517261153a7d38a9f49c63fd2dbb4c52b851bc0d1726f8196f4e9  runners/lua_runner.py
+217be73aeb9055bfcf897d4cc72eb7b06092b9da96202ac2eab95a26d9302b56  runners/protocol.py
+efabd7a4b829eb917116a2f51358a8fa8056370dbb57f6b6a9646c1cd342ffc5  runners/python_runner.py
+63514e35b2687742ea6453e15d089da5a6cb4ab57ca0100da6189b187511ecf7  runners/rust_runner.py
+824119581e0bf1c913059fdf506c26494c9aa2f65f718f08630ff5fe74779ff3  runners/sandbox.py
+4fb1552346d86503372e6762f3ddcb0fc7e7e0be2cc1209f419b7c5e37aeccdc  sandbox/Dockerfile
+39adc44592af2d485b8755baa0b90b94e987b8a76b37dd70cc7c879285b6faaa  sandbox/worker.py
+eb5c448ef50f2a7f4f08be8d9b6a0d9719180c6c144b56b8514803312338902b  tests/test_core.py
+44d0be27ea6bb4050d2e6cfdcc0926400999e8cea3f62ed0bba5303231a424ab  validate.py
+cb6e2f58736c45a63635c574ed989ff7910ad2cb81ad59f8a444594c78066ab4  validation_report.json
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  validators/__init__.py
+c21a19dd9e2b362c6634eac0334765d0b6edf0a567bba61a234b3d40bdb13612  validators/dataset.py

evaluate.py

@@ -0,0 +1,89 @@
+"""One deterministic generation per task, followed by isolated execution."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import sys
+from validators.dataset import load
+from runners import get_runner,LANGUAGES
+from runners.common import extract_code
+from runners.sandbox import Sandbox
+from metrics import aggregate
+ROOT=Path(__file__).resolve().parent
+PROMPT_VERSION='smolscript-completion-v1'
+
+def prompt(row):
+    # Only these public fields reach the model. No tests, answers or references.
+    fixture=row['metadata'].get('fixture','');base=row['metadata'].get('base_css','')
+    return ('Write code for the following task. Use the standard library only. Return code only.\n'
+        +row['prompt']+'\n'+row['output_format']+'\n'+(row['metadata'].get('input_domain') or '')
+        +('\nHTML fixture:\n'+fixture if fixture else '')+('\nExisting CSS:\n'+base if base else '')+'\nCode:\n')
+
+def save(path,value):
+    path.parent.mkdir(parents=True,exist_ok=True);temp=path.with_suffix('.tmp');temp.write_text(json.dumps(value,indent=2,allow_nan=False)+'\n');temp.replace(path)
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__);p.add_argument('--model');p.add_argument('--revision',default='main');p.add_argument('--output',type=Path,required=True)
+    p.add_argument('--language',nargs='+',choices=LANGUAGES);p.add_argument('--difficulty',nargs='+',choices=('easy','medium','moderate'))
+    p.add_argument('--resume',action='store_true');p.add_argument('--predictions',type=Path,help='JSONL with id and code; bypass model inference')
+    p.add_argument('--image',default='smolscript-runtime:0.1.0');p.add_argument('--engine',default='docker');p.add_argument('--max-new-tokens',type=int,default=384);p.add_argument('--device',default='auto');a=p.parse_args()
+    if not a.model and not a.predictions:p.error('--model or --predictions required')
+    if a.max_new_tokens<1:p.error('--max-new-tokens must be positive')
+    sandbox=Sandbox(a.image,a.engine)
+    rows=[r for r in load(ROOT/'data/smolscript.jsonl') if (not a.language or r['language'] in a.language) and (not a.difficulty or r['difficulty'] in a.difficulty)]
+    hidden={r['id']:r for r in load(ROOT/'private_tests/hidden.jsonl')}
+    files=['data/smolscript.jsonl','private_tests/hidden.jsonl','evaluate.py','metrics.py']+[str(p.relative_to(ROOT)) for p in sorted((ROOT/'runners').glob('*.py'))]+['sandbox/worker.py']
+    fingerprint={f:hashlib.sha256((ROOT/f).read_bytes()).hexdigest() for f in files}
+    settings={'model':a.model,'requested_revision':a.revision,'language':a.language,'difficulty':a.difficulty,
+       'max_new_tokens':a.max_new_tokens,'prompt_version':PROMPT_VERSION,'dataset':fingerprint,'sandbox':sandbox.identity,
+       'predictions_sha':hashlib.sha256(a.predictions.read_bytes()).hexdigest() if a.predictions else None}
+    if a.output.exists() and not a.resume:p.error('Output exists; use --resume or a new path')
+    state=json.loads(a.output.read_text()) if a.output.exists() else {'settings':settings,'results':[],'complete':False}
+    if state['settings']!=settings:p.error('Resume settings mismatch')
+    if a.resume and not a.output.exists():p.error('Resume output missing')
+    # Lock the output across processes to prevent concurrent checkpoint overwrites.
+    import fcntl
+    lock=a.output.with_suffix(a.output.suffix+'.lock');lock.parent.mkdir(parents=True,exist_ok=True)
+    with lock.open('a') as stream:
+        fcntl.flock(stream,fcntl.LOCK_EX|fcntl.LOCK_NB)
+        codes={}
+        if a.predictions:codes={r['id']:r['code'] for r in load(a.predictions)}
+        else:
+            import torch
+            from transformers import AutoTokenizer,AutoModelForCausalLM,AutoConfig
+            from huggingface_hub import HfApi
+            revision=state.get('resolved_revision') or HfApi().model_info(a.model,revision=a.revision).sha
+            state['resolved_revision']=revision
+            tokenizer=AutoTokenizer.from_pretrained(a.model,revision=revision)
+            model=AutoModelForCausalLM.from_pretrained(a.model,revision=revision,torch_dtype='auto',device_map=a.device)
+            model.eval();torch.manual_seed(0)
+            import importlib.metadata
+            state['environment']={'python':sys.version,'packages':{n:importlib.metadata.version(n) for n in ('torch','transformers','huggingface-hub')},'device':str(model.device)}
+        done={r['id'] for r in state['results']}
+        if len(done)!=len(state['results']) or done-set(r['id'] for r in rows):raise ValueError('Corrupt resume IDs')
+        save(a.output,state)
+        for row in rows:
+            if row['id'] in done:continue
+            if state.get('pending',{}).get('id')==row['id']:
+                text=state['pending']['generation']
+            elif a.predictions:
+                if row['id'] not in codes:raise ValueError('Missing prediction '+row['id'])
+                text=codes[row['id']]
+            else:
+                encoded=tokenizer(prompt(row),return_tensors='pt',return_token_type_ids=False).to(model.device)
+                native=getattr(model.config,'max_position_embeddings',getattr(model.config,'n_positions',4096))
+                if encoded['input_ids'].shape[1]+a.max_new_tokens>native:
+                    raise ValueError('Insufficient context for fixed generation settings: '+row['id'])
+                with torch.inference_mode():out=model.generate(**encoded,max_new_tokens=a.max_new_tokens,do_sample=False,num_beams=1,pad_token_id=tokenizer.pad_token_id if tokenizer.pad_token_id is not None else tokenizer.eos_token_id)
+                text=tokenizer.decode(out[0,encoded['input_ids'].shape[1]:],skip_special_tokens=True)
+            state['pending']={'id':row['id'],'generation':text};save(a.output,state)
+            try:code=extract_code(text)
+            except ValueError as e:result={'passed':False,'syntax_success':False,'tests':[],'error':str(e)}
+            else:result=get_runner(row['language']).evaluate(row,code,hidden[row['id']],sandbox)
+            state['results'].append({'id':row['id'],'language':row['language'],'difficulty':row['difficulty'],'generation':text,**result})
+            state.pop('pending',None)
+            save(a.output,state);print(f"{len(state['results'])}/{len(rows)} {row['id']} {'PASS' if result['passed'] else 'FAIL'}",flush=True)
+        state['metrics']=aggregate(state['results'],[r['id'] for r in rows],full_run=not(a.language or a.difficulty));state['complete']=True;save(a.output,state)
+        print(json.dumps(state['metrics'],indent=2))
+
+if __name__=='__main__':main()

examples/local-test-report.json

@@ -0,0 +1,25 @@
+{
+  "unit_tests": {
+    "passed": 8,
+    "command": "python -m unittest discover -s tests -q"
+  },
+  "python_reference_ast_parse": 250,
+  "candidate_execution_on_host": false,
+  "reference_execution": {
+    "verified": 0,
+    "unverified": 2000
+  },
+  "unverified_by_language": {
+    "python": 250,
+    "javascript": 250,
+    "html": 200,
+    "css": 200,
+    "cpp": 225,
+    "c": 225,
+    "lua": 200,
+    "csharp": 225,
+    "rust": 225
+  },
+  "blocked_reason": "Docker/Podman unavailable; no isolated runtime for reference and negative-control execution.",
+  "model_baselines": "not run"
+}

examples/result-format.json

@@ -0,0 +1,6 @@
+{
+  "illustrative_only": true,
+  "note": "Synthetic format illustration, not a measured model result.",
+  "complete": false,
+  "results": [{"id": "smolscript-python-0001", "language": "python", "syntax_success": true, "passed": false, "tests": [{"test": 0, "passed": false, "actual": {"stdout": "wrong\n", "exit_code": 0}}]}]
+}

generators/build.py

@@ -0,0 +1,114 @@
+"""Deterministically build 2,000 task records, references and separate hidden tests."""
+import hashlib
+import json
+from pathlib import Path
+import sys
+ROOT=Path(__file__).resolve().parents[1]
+sys.path.insert(0,str(ROOT))
+from generators.specs import task_specs,oracle,probes
+from generators.code import render,signature
+from generators.web import html_tasks,css_tasks,dom_tasks,BASE_CSS
+
+ALLOCATION={'python':(150,75,25),'javascript':(150,75,25),'html':(120,60,20),'css':(120,60,20),
+            'cpp':(135,68,22),'c':(135,68,22),'lua':(120,60,20),'csharp':(135,67,23),'rust':(135,67,23)}
+NAMES={'python':'Python','javascript':'JavaScript','html':'HTML','css':'CSS','cpp':'C++','c':'C','lua':'Lua','csharp':'C#','rust':'Rust'}
+VERSION='smolscript-0.1.0'
+
+def stable(value):return json.dumps(value,sort_keys=True,separators=(',',':'),ensure_ascii=False)
+def sha(value):return hashlib.sha256(stable(value).encode()).hexdigest()
+def write_rows(path,rows):path.write_text(''.join(stable(x)+'\n' for x in rows))
+
+def build():
+    public=[];private=[];references=[];specs=task_specs()
+    suites={}
+    for kind in ('scalar','string','array'):
+        candidates=[s for group in specs.values() for s in group if s['kind']==kind]
+        pool=probes(kind)
+        chosen=([-120,-11,-10,-5,-2,-1,0,1,2,5,10,11,120] if kind=='scalar' else pool[:13])+pool[-8:]
+        while True:
+            groups={}
+            for spec in candidates:
+                key=tuple(oracle(spec,v) for v in chosen)
+                groups.setdefault(key,[]).append(spec)
+            collisions=[g for g in groups.values() if len(g)>1]
+            if not collisions:break
+            def discrimination(v):
+                return sum(len(set(oracle(spec,v) for spec in group))-1 for group in collisions)
+            best=max(pool,key=discrimination)
+            if discrimination(best)==0:raise ValueError('Cannot distinguish hidden tasks')
+            chosen.append(best)
+        suites[kind]=chosen
+    for lang,counts in ALLOCATION.items():
+        items=[]
+        if lang in ('html','css'):items=html_tasks() if lang=='html' else css_tasks()
+        else:
+            for difficulty,count in zip(('easy','medium','moderate'),counts):
+                if lang=='javascript' and difficulty=='medium':count-=15
+                if lang=='javascript' and difficulty=='moderate':count-=5
+                for spec in specs[difficulty][:count]:items.append({'difficulty':difficulty,'spec':spec})
+            if lang=='javascript':items+=dom_tasks()
+        for i,item in enumerate(items,1):
+            spec=item['spec'];kind=spec['kind'];difficulty=item['difficulty']
+            rid=f'smolscript-{lang}-{i:04d}'
+            metadata={'protocol':VERSION,'family':kind,'semantic_id':sha(spec),'input_domain':None}
+            if kind in ('scalar','string','array'):
+                from generators.specs import instruction
+                prompt=f'In {NAMES[lang]}, '+instruction(spec)
+                sig=signature(lang,kind)
+                output_format='Return only the function '+sig+(' inside public class Solution.' if lang=='csharp' else '. Do not include a main program.')
+                metadata['input_domain']={'scalar':'Integer n from -120 to 120.','string':'ASCII s of at most 80 characters, without newlines.','array':'At most eight integers, each from -6 to 6.'}[kind]
+                reference=render(lang,spec)
+                values=probes(kind)
+                # Public examples do not use the hidden edge/adversarial inputs.
+                public_values={'scalar':[3,-2],'string':['Hello','  Code '],'array':[[1,2,3],[-2,0,2]]}[kind]
+                public_tests=[{'input':v,'expected':oracle(spec,v)} for v in public_values]
+                selected=[v for v in suites[kind] if v not in public_values]
+                hidden=[{'input':v,'expected':oracle(spec,v)} for v in selected]
+                category={'scalar':'arithmetic_conditions','string':'strings','array':'collections_loops'}[kind]
+                if spec.get('reduce')=='frequency':category='frequency_tables'
+                entry='Solve' if lang=='csharp' else 'solve'
+            else:
+                prompt='In '+NAMES[lang]+', '+item['prompt'];reference=item['reference'];entry='setup' if kind=='dom' else ''
+                output_format={'html':'Return an HTML fragment only.','css':'Return a stylesheet only.','dom':'Return function setup() only. The harness calls it once after loading the fixture.'}[kind]
+                public_tests=[];category={'html':'semantic_structure','css':'styles_layout','dom':'dom_events'}[kind]
+                metadata['fixture']=item['fixture']
+                metadata['base_css']=BASE_CSS if kind=='css' else ''
+                hidden=[{'checks':item['checks'],'steps':item.get('steps',[])}]
+                if kind=='dom':
+                    # A no-op toggler must not pass merely because two toggles cancel.
+                    from generators.web import DOM_ACTIONS
+                    action=spec['action'];check=item['checks']
+                    initial=[{'kind':'text','selector':'#output','value':'0'}, {'kind':'value','selector':'#input','value':''},
+                      {'kind':'count','selector':'#items > li','value':0}, {'kind':'property','selector':'#input','name':'disabled','value':False},
+                      {'kind':'property','selector':'#output','name':'hidden','value':False}, {'kind':'property','selector':'#check','name':'checked','value':False},
+                      {'kind':'attribute','selector':'#output','name':'class','value':None},{'kind':'attribute','selector':'#output','name':'title','value':None}]
+                    hidden.insert(0,{'checks':initial,'steps':[]})
+                    if action=='toggle_class':hidden.append({'steps':[{'action':'click','selector':'#action'}],'checks':[{'kind':'attribute','selector':'#output','name':'class','value':'active'}]})
+                    # Nonconstant input-dependent behaviors also tested with empty input.
+                    expected={'mirror':'','uppercase':'','length':'0','reverse':'','mark_empty':'Empty'}
+                    if action in expected:
+                        steps=[{'action':'event','selector':'#input','value':'input'}] if spec['event']=='input' else [{'action':'click','selector':'#action'}]
+                        hidden.append({'steps':steps,'checks':[{'kind':'text','selector':'#output','value':expected[action]}]})
+            row={'id':rid,'language':lang,'difficulty':difficulty,'category':category,'prompt':prompt,
+                 'output_format':output_format,'entry_point':entry,'reference_solution':None,'tests':public_tests,
+                 'timeout_seconds':3,'metadata':metadata}
+            public.append(row);private.append({'id':rid,'tests':hidden,'spec':spec});references.append({'id':rid,'reference_solution':reference})
+    assert len(public)==2000
+    for directory in ('data','private_tests','references'): (ROOT/directory).mkdir(exist_ok=True)
+    write_rows(ROOT/'data/smolscript.jsonl',public)
+    write_rows(ROOT/'private_tests/hidden.jsonl',private)
+    write_rows(ROOT/'references/solutions.jsonl',references)
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    # HF-compatible nested metadata; JSON strings give consistent test schemas across modalities.
+    parquet_rows=[{**r,'tests':stable(r['tests']),'metadata':stable(r['metadata'])} for r in public]
+    pq.write_table(pa.Table.from_pylist(parquet_rows),ROOT/'data/smolscript.parquet',compression='zstd')
+    manifest={'version':VERSION,'examples':2000,'languages':{k:sum(v) for k,v in ALLOCATION.items()},
+              'difficulty':{'easy':1200,'medium':600,'moderate':200},'generator_seed':7301,
+              'validation_status':'execution_unverified','files':{}}
+    for name in ('data/smolscript.jsonl','data/smolscript.parquet','private_tests/hidden.jsonl','references/solutions.jsonl'):
+        manifest['files'][name]=hashlib.sha256((ROOT/name).read_bytes()).hexdigest()
+    (ROOT/'manifest.json').write_text(json.dumps(manifest,indent=2)+'\n')
+    print('Generated exactly 2000 examples and matching private tests/references.')
+
+if __name__=='__main__':build()

generators/code.py

@@ -0,0 +1,169 @@
+"""Language renderers for the original task algebra; no eval/exec."""
+LANGS=('python','javascript','cpp','c','lua','csharp','rust')
+
+def scalar_expr(op,x,lang):
+    absx={'python':f'abs({x})','javascript':f'Math.abs({x})','cpp':f'std::abs({x})',
+          'c':f'llabs({x})','lua':f'math.abs({x})','csharp':f'Math.Abs({x})','rust':f'({x}).abs()'}[lang]
+    tern=lambda c,a,b: f'({a} if {c} else {b})' if lang=='python' else (f'(({c}) and {a} or {b})' if lang=='lua' else (f'(if {c} {{ {a} }} else {{ {b} }})' if lang=='rust' else f'(({c}) ? {a} : {b})'))
+    div=f'({absx} // 10)' if lang=='python' else (f'math.floor({absx} / 10)' if lang=='lua' else (f'Math.floor({absx} / 10)' if lang=='javascript' else f'({absx} / 10)'))
+    return {'double':f'({x} * 2)','negate':f'(-{x})','absolute':absx,'square':f'({x} * {x})',
+      'successor':f'({x} + 1)','sign':tern(f'{x} > 0','1',tern(f'{x} < 0','-1','0')),
+      'positive':tern(f'{x} > 0',x,'0'),'even':tern(f'{x} % 2 == 0','1','0'),
+      'clamp':tern(f'{x} < -5','-5',tern(f'{x} > 5','5',x)),
+      'ones':f'({absx} % 10)','tens':f'({div} % 10)',
+      'negative':tern(f'{x} < 0','1','0'),'complement':f'(10 - {x})'}[op]
+
+def signature(lang,kind):
+    return {
+     'python':{'scalar':'def solve(n: int) -> int:','string':'def solve(s: str) -> str:','array':'def solve(values: list[int]) -> int:'},
+     'javascript':{'scalar':'function solve(n)','string':'function solve(s)','array':'function solve(values)'},
+     'cpp':{'scalar':'long long solve(long long n)','string':'std::string solve(std::string s)','array':'long long solve(const std::vector<long long>& values)'},
+     'c':{'scalar':'long long solve(long long n)','string':'const char *solve(const char *input)','array':'long long solve(const long long *values, int length)'},
+     'lua':{'scalar':'function solve(n)','string':'function solve(s)','array':'function solve(values)'},
+     'csharp':{'scalar':'public static long Solve(long n)','string':'public static string Solve(string s)','array':'public static long Solve(long[] values)'},
+     'rust':{'scalar':'fn solve(mut n: i64) -> i64','string':'fn solve(mut s: String) -> String','array':'fn solve(values: Vec<i64>) -> i64'},
+    }[lang][kind]
+
+def wrap(lang,kind,lines):
+    sig=signature(lang,kind)
+    if lang=='python':return sig+'\n'+''.join('    '+x+'\n' for x in lines)
+    if lang=='lua':return sig+'\n'+''.join('  '+x+'\n' for x in lines)+'end\n'
+    code=sig+' {\n'+''.join('    '+x+'\n' for x in lines)+'}\n'
+    if lang=='csharp':code='public class Solution {\n'+code+'}\n'
+    return code
+
+def string_line(op,lang):
+    if lang=='python':return 's = '+{
+      'upper':'s.upper()','lower':'s.lower()','reverse':'s[::-1]','trim':"s.strip(' ')",
+      'letters':"''.join(c for c in s if ('a' <= c <= 'z') or ('A' <= c <= 'Z'))",
+      'digits':"''.join(c for c in s if '0' <= c <= '9')",
+      'no_vowels':"''.join(c for c in s if c.lower() not in 'aeiou')",
+      'no_spaces':"s.replace(' ', '')",'first_half':'s[:len(s)//2]','second_half':'s[len(s)//2:]',
+      'swap_case':'s.swapcase()','collapse':"' '.join(part for part in s.split(' ') if part) + (' ' if s.endswith(' ') and s.strip(' ') else '')"}[op] if op!='collapse' else "s = __import__('re').sub(' +', ' ', s)"
+    if lang=='javascript':return 's = '+{
+      'upper':'s.toUpperCase()','lower':'s.toLowerCase()', 'reverse':"s.split('').reverse().join('')",'trim':"s.replace(/^ +| +$/g, '')",
+      'letters':"s.replace(/[^a-zA-Z]/g, '')",'digits':"s.replace(/[^0-9]/g, '')",'no_vowels':"s.replace(/[aeiou]/gi, '')",
+      'no_spaces':"s.replace(/ /g, '')",'first_half':'s.slice(0, Math.floor(s.length/2))','second_half':'s.slice(Math.floor(s.length/2))',
+      'swap_case':"s.replace(/[a-zA-Z]/g, c => c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase())",
+      'collapse':"s.replace(/ +/g, ' ')"}[op]+';'
+    if lang=='lua':return 's = '+{
+      'upper':'string.upper(s)','lower':'string.lower(s)','reverse':'string.reverse(s)', 'trim':'(s:gsub("^ +", ""):gsub(" +$", ""))',
+      'letters':'(s:gsub("[^a-zA-Z]", ""))','digits':'(s:gsub("[^0-9]", ""))','no_vowels':'(s:gsub("[aeiouAEIOU]", ""))',
+      'no_spaces':'(s:gsub(" ", ""))','first_half':'s:sub(1, math.floor(#s/2))','second_half':'s:sub(math.floor(#s/2)+1)',
+      'swap_case':'(s:gsub("%a", function(c) if c == c:upper() then return c:lower() else return c:upper() end end))',
+      'collapse':'(s:gsub(" +", " "))'}[op]
+    if lang=='csharp':return 's = '+{
+      'upper':'s.ToUpperInvariant()','lower':'s.ToLowerInvariant()','reverse':'new string(s.Reverse().ToArray())','trim':"s.Trim(' ')",
+      'letters':"new string(s.Where(c => (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')).ToArray())",
+      'digits':"new string(s.Where(c => c >= '0' && c <= '9').ToArray())",
+      'no_vowels':'new string(s.Where(c => !"aeiouAEIOU".Contains(c)).ToArray())',
+      'no_spaces':'s.Replace(" ", "")','first_half':'s.Substring(0, s.Length/2)','second_half':'s.Substring(s.Length/2)',
+      'swap_case':'new string(s.Select(c => char.IsUpper(c) ? char.ToLowerInvariant(c) : char.ToUpperInvariant(c)).ToArray())',
+      'collapse':'System.Text.RegularExpressions.Regex.Replace(s, " +", " ")'}[op]+';'
+    if lang=='rust':return 's = '+{
+      'upper':'s.to_ascii_uppercase()','lower':'s.to_ascii_lowercase()','reverse':'s.chars().rev().collect()', 'trim':"s.trim_matches(' ').to_string()",
+      'letters':'s.chars().filter(|c| c.is_ascii_alphabetic()).collect()', 'digits':'s.chars().filter(|c| c.is_ascii_digit()).collect()',
+      'no_vowels':'s.chars().filter(|c| !"aeiouAEIOU".contains(*c)).collect()', 'no_spaces':"s.replace(' ', \"\")",
+      'first_half':'s[..s.len()/2].to_string()','second_half':'s[s.len()/2..].to_string()',
+      'swap_case':"s.chars().map(|c| if c.is_ascii_uppercase() { c.to_ascii_lowercase() } else { c.to_ascii_uppercase() }).collect()",
+      'collapse':"{ let mut t=String::new(); for c in s.chars() { if c != ' ' || !t.ends_with(' ') { t.push(c); } } t }"}[op]+';'
+    if lang=='cpp':
+        loop={
+          'upper':"t += (c >= 'a' && c <= 'z') ? char(c-32) : c;",
+          'lower':"t += (c >= 'A' && c <= 'Z') ? char(c+32) : c;",
+          'letters':"if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) t += c;",
+          'digits':"if (c >= '0' && c <= '9') t += c;",
+          'no_vowels':"if (std::string(\"aeiouAEIOU\").find(c) == std::string::npos) t += c;",
+          'no_spaces':"if (c != ' ') t += c;",
+          'swap_case':"t += (c >= 'a' && c <= 'z') ? char(c-32) : ((c >= 'A' && c <= 'Z') ? char(c+32) : c);",
+          'collapse':"if (c != ' ' || t.empty() || t.back() != ' ') t += c;",
+        }
+        if op in loop:return '{ std::string t; for (char c : s) { '+loop[op]+' } s=t; }'
+        return {'reverse':'std::reverse(s.begin(), s.end());','trim':"{ auto a=s.find_first_not_of(' '); auto b=s.find_last_not_of(' '); s=a==std::string::npos ? \"\" : s.substr(a,b-a+1); }",'first_half':'s=s.substr(0,s.size()/2);','second_half':'s=s.substr(s.size()/2);'}[op]
+    if lang=='c':
+        condition={ 'letters':"(c>='a' && c<='z') || (c>='A' && c<='Z')",'digits':"c>='0' && c<='9'",
+             'no_vowels':'strchr("aeiouAEIOU",c)==NULL','no_spaces':"c!=' '",'collapse':"c!=' ' || j==0 || t[j-1]!=' '"}
+        change={'upper':"c>='a' && c<='z' ? c-32 : c",'lower':"c>='A' && c<='Z' ? c+32 : c",
+             'swap_case':"c>='a' && c<='z' ? c-32 : (c>='A' && c<='Z' ? c+32 : c)"}
+        if op in condition:body=f'if ({condition[op]}) t[j++]=c;'
+        elif op in change:body=f't[j++]={change[op]};'
+        else:body={'reverse':'t[j++]=s[len-1-i];','first_half':'if (i<len/2) t[j++]=c;',
+          'second_half':'if (i>=len/2) t[j++]=c;','trim':'if (i>=a && i<b) t[j++]=c;'}[op]
+        init="int a=0,b=len; while(a<b && s[a]==' ') a++; while(b>a && s[b-1]==' ') b--; " if op=='trim' else ''
+        return '{ int len=(int)strlen(s), j=0; '+init+'for(int i=0;i<len;i++) { char c=s[i]; '+body+' } t[j]=0; strcpy(s,t); }'
+
+def filter_expr(key,lang):
+    ab=scalar_expr('absolute','x',lang)
+    cond={'all':'true','positive':'x>0','negative':'x<0','even':'x%2==0','odd':'x%2!=0','nonzero':'x!=0',
+          'small':ab+'<=3','large':ab+'>3','even_index':'i%2==0','odd_index':'i%2==1'}[key]
+    if lang=='python':cond=cond.replace('true','True')
+    if lang=='lua':cond=cond.replace('!=','~=')
+    return cond
+
+def render(lang,spec):
+    kind=spec['kind']
+    if kind=='scalar':
+        lines=['n = '+scalar_expr(op,'n',lang)+(';' if lang not in ('python','lua') else '') for op in spec['steps']]
+        lines+=['return n'+(';' if lang not in ('python','lua') else '')]
+        return wrap(lang,kind,lines)
+    if kind=='string':
+        lines=['static char s[512]; char t[512]; strcpy(s,input);'] if lang=='c' else []
+        lines += [string_line(op,lang) for op in spec['steps']]
+        return wrap(lang,kind,lines+['return s'+(';' if lang not in ('python','lua') else '')])
+    pred=filter_expr(spec['filter'],lang)
+    val=scalar_expr(spec['map'],'x',lang) if spec.get('map') else 'x'
+    r=spec['reduce']
+    if lang=='python':
+        lines=[f'a = [{val} for i, x in enumerate(values) if {pred}]']
+        if r=='frequency':lines+=['counts = {}','for x in a: counts[x] = counts.get(x, 0) + 1','return max(counts.values(), default=0)']
+        elif r=='product':lines+=['result = 1','for x in a: result *= x','return result']
+        else:lines+=['return '+{'sum':'sum(a)','count':'len(a)','min':'min(a, default=0)','max':'max(a, default=0)',
+             'first':'a[0] if a else 0','last':'a[-1] if a else 0','range':'max(a)-min(a) if a else 0','distinct':'len(set(a))'}[r]]
+        return wrap(lang,kind,lines)
+    if lang=='javascript':
+        lines=[f'const a = values.filter((x,i) => {pred}).map(x => {val});']
+        returns={'sum':'a.reduce((s,x)=>s+x,0)','count':'a.length','product':'a.reduce((s,x)=>s*x,1)',
+          'min':'a.length ? Math.min(...a) : 0','max':'a.length ? Math.max(...a) : 0','first':'a.length ? a[0] : 0',
+          'last':'a.length ? a[a.length-1] : 0','range':'a.length ? Math.max(...a)-Math.min(...a) : 0','distinct':'new Set(a).size'}
+        if r=='frequency':lines+=['const counts = new Map();','for (const x of a) counts.set(x, (counts.get(x)||0)+1);','return Math.max(0,...counts.values());']
+        else:lines+=['return '+returns[r]+';']
+        return wrap(lang,kind,lines)
+    if lang=='lua':
+        lines=['local a = {}',f'for k,x in ipairs(values) do local i=k-1; if {pred} then a[#a+1]={val} end end']
+        if r in ('distinct','frequency'):
+            lines+=['local counts = {}; local result = 0','for _,x in ipairs(a) do counts[x]=(counts[x] or 0)+1 end',
+             ('for _ in pairs(counts) do result=result+1 end' if r=='distinct' else 'for _,n in pairs(counts) do result=math.max(result,n) end'),'return result']
+        elif r in ('sum','product'):lines += ['local result = '+('1' if r=='product' else '0'),f'for _,x in ipairs(a) do result=result {"*" if r=="product" else "+"} x end','return result']
+        elif r=='count':lines+=['return #a']
+        else:
+            lines+=['if #a==0 then return 0 end']
+            if r in ('first','last'):lines+=['return a['+('1' if r=='first' else '#a')+']']
+            else:lines+=['local lo,hi=a[1],a[1]','for _,x in ipairs(a) do lo=math.min(lo,x); hi=math.max(hi,x) end','return '+{'min':'lo','max':'hi','range':'hi-lo'}[r]]
+        return wrap(lang,kind,lines)
+    if lang=='csharp':
+        lines=[f'var a = values.Where((x,i) => {pred}).Select(x => {val}).ToList();']
+        returns={'sum':'a.Sum()','count':'a.Count','product':'a.Aggregate(1L,(s,x)=>s*x)', 'min':'a.Count>0 ? a.Min() : 0',
+          'max':'a.Count>0 ? a.Max() : 0','first':'a.Count>0 ? a[0] : 0','last':'a.Count>0 ? a[a.Count-1] : 0',
+          'range':'a.Count>0 ? a.Max()-a.Min() : 0','distinct':'a.Distinct().Count()',
+          'frequency':'a.Count>0 ? a.GroupBy(x=>x).Max(g=>g.Count()) : 0'}
+        return wrap(lang,kind,lines+['return '+returns[r]+';'])
+    if lang=='rust':
+        lines=['let mut a: Vec<i64> = Vec::new();',f'for (i, &x) in values.iter().enumerate() {{ if {pred} {{ a.push({val}); }} }}']
+        returns={'sum':'a.iter().sum()','count':'a.len() as i64','product':'a.iter().product()',
+          'min':'*a.iter().min().unwrap_or(&0)','max':'*a.iter().max().unwrap_or(&0)',
+          'first':'*a.first().unwrap_or(&0)','last':'*a.last().unwrap_or(&0)',
+          'range':'a.iter().max().unwrap_or(&0)-a.iter().min().unwrap_or(&0)',
+          'distinct':'{ a.sort(); a.dedup(); a.len() as i64 }',
+          'frequency':'{ let mut counts=std::collections::HashMap::new(); for x in a { *counts.entry(x).or_insert(0i64)+=1; } *counts.values().max().unwrap_or(&0) }'}
+        return wrap(lang,kind,lines+['return '+returns[r]+';'])
+    lines=(['std::vector<long long> a;',f'for(size_t i=0;i<values.size();i++) {{ auto x=values[i]; if({pred}) a.push_back({val}); }}','int size=(int)a.size();'] if lang=='cpp' else
+           ['long long a[64]; int size=0;',f'for(int i=0;i<length;i++) {{ long long x=values[i]; if({pred}) a[size++]={val}; }}'])
+    if r in ('sum','product'):lines += ['long long result='+('1;' if r=='product' else '0;'),f'for(int i=0;i<size;i++) result {"*=" if r=="product" else "+="} a[i];','return result;']
+    elif r=='count':lines+=['return size;']
+    elif r in ('distinct','frequency'):
+        lines+=['long long result=0;','for(int i=0;i<size;i++) { int count=0, earlier=0; for(int j=0;j<size;j++) { if(a[j]==a[i]) { count++; if(j<i) earlier=1; } } '+('if(!earlier) result++;' if r=='distinct' else 'if(count>result) result=count;')+' }','return result;']
+    else:
+        lines+=['if(size==0) return 0;']
+        if r in ('first','last'):lines+=['return '+('a[0];' if r=='first' else 'a[size-1];')]
+        else:lines+=['long long lo=a[0],hi=a[0];','for(int i=0;i<size;i++) { if(a[i]<lo) lo=a[i]; if(a[i]>hi) hi=a[i]; }','return '+{'min':'lo;','max':'hi;','range':'hi-lo;'}[r]]
+    return wrap(lang,kind,lines)

generators/specs.py

@@ -0,0 +1,136 @@
+"""Original deterministic task algebra and independent Python behavioral oracle.
+No runtime-generated candidate code is executed by this module.
+"""
+import itertools
+import random
+import string
+
+SCALAR = {
+ 'double':('double it',lambda n:2*n),
+ 'negate':('negate it',lambda n:-n),
+ 'absolute':('take its absolute value',abs),
+ 'square':('square it',lambda n:n*n),
+ 'successor':('add one',lambda n:n+1),
+ 'sign':('replace it with -1, 0, or 1 according to its sign',lambda n:(n>0)-(n<0)),
+ 'positive':('replace negative values with zero',lambda n:max(n,0)),
+ 'even':('replace it with 1 if even, otherwise 0',lambda n:int(n%2==0)),
+ 'clamp':('clamp it to the inclusive range -5 to 5',lambda n:max(-5,min(5,n))),
+ 'ones':('take the last decimal digit of its absolute value',lambda n:abs(n)%10),
+ 'tens':('take the tens digit of its absolute value',lambda n:abs(n)//10%10),
+ 'negative':('replace it with 1 if negative, otherwise 0',lambda n:int(n<0)),
+ 'complement':('subtract it from ten',lambda n:10-n),
+}
+STRINGS = {
+ 'upper':('convert lowercase ASCII letters to uppercase',lambda s:s.upper()),
+ 'lower':('convert uppercase ASCII letters to lowercase',lambda s:s.lower()),
+ 'reverse':('reverse the characters',lambda s:s[::-1]),
+ 'trim':('remove leading and trailing spaces',lambda s:s.strip(' ')),
+ 'letters':('keep only ASCII letters',lambda s:''.join(c for c in s if c in string.ascii_letters)),
+ 'digits':('keep only decimal digits',lambda s:''.join(c for c in s if c in string.digits)),
+ 'no_vowels':('remove vowels aeiou in either case',lambda s:''.join(c for c in s if c.lower() not in 'aeiou')),
+ 'no_spaces':('remove every space',lambda s:s.replace(' ','')),
+ 'first_half':('keep the first floor(length/2) characters',lambda s:s[:len(s)//2]),
+ 'second_half':('keep characters from index floor(length/2) onward',lambda s:s[len(s)//2:]),
+ 'swap_case':('swap the case of ASCII letters',lambda s:s.swapcase()),
+ 'collapse':('replace each run of spaces with one space',lambda s:__import__('re').sub(' +',' ',s)),
+}
+FILTERS={
+ 'all':('all items',lambda x,i:True),
+ 'positive':('positive items',lambda x,i:x>0),
+ 'negative':('negative items',lambda x,i:x<0),
+ 'even':('even items',lambda x,i:x%2==0),
+ 'odd':('odd items',lambda x,i:x%2!=0),
+ 'nonzero':('nonzero items',lambda x,i:x!=0),
+ 'small':('items with absolute value at most three',lambda x,i:abs(x)<=3),
+ 'large':('items with absolute value greater than three',lambda x,i:abs(x)>3),
+ 'even_index':('items at even zero-based indices',lambda x,i:i%2==0),
+ 'odd_index':('items at odd zero-based indices',lambda x,i:i%2==1),
+}
+REDUCERS={
+ 'sum':'sum', 'count':'count', 'product':'product', 'min':'minimum', 'max':'maximum',
+ 'first':'first value','last':'last value','range':'maximum minus minimum',
+ 'distinct':'number of distinct values','frequency':'largest frequency of a value',
+}
+
+def reduce_values(key,values):
+    if key=='sum':return sum(values)
+    if key=='count':return len(values)
+    if key=='product':
+        import math
+        return math.prod(values)
+    if key=='distinct':return len(set(values))
+    if key=='frequency':
+        from collections import Counter
+        return max(Counter(values).values(),default=0)
+    if not values:return 0
+    return {'min':lambda:min(values),'max':lambda:max(values),'first':lambda:values[0],
+            'last':lambda:values[-1],'range':lambda:max(values)-min(values)}[key]()
+
+def oracle(spec,value):
+    if spec['kind'] in ('scalar','string'):
+        operations=SCALAR if spec['kind']=='scalar' else STRINGS
+        for step in spec['steps']:value=operations[step][1](value)
+        return value
+    selected=[x for i,x in enumerate(value) if FILTERS[spec['filter']][1](x,i)]
+    if spec.get('map'):selected=[SCALAR[spec['map']][1](x) for x in selected]
+    return reduce_values(spec['reduce'],selected)
+
+def probes(kind):
+    rng=random.Random(20261105)
+    if kind=='scalar':return list(range(-120,121))
+    if kind=='string':
+        return ['', 'a','A','0',' ', ' Ab9 eE!  02 ', 'aeiouAEIOU', 'xyzXYZ', '123456', '  a   b  ',
+                'odd!?', 'Aa0 !', 'bCdEf']+[''.join(rng.choice('aAbBcCeE019 !?') for _ in range(rng.randrange(1,24))) for _ in range(120)]
+    return [[],[0],[1],[-1],[2,-3,0,5,2],[-4,-4,-1],[1,2,3,4], [4,3,2,1], [0,0,0], [1,-1,1,-1]]+[
+        [rng.randint(-6,6) for _ in range(rng.randrange(1,9))] for _ in range(180)]
+
+def bank(kind):
+    if kind in ('scalar','string'):
+        ops=SCALAR if kind=='scalar' else STRINGS
+        candidates=[{'kind':kind,'steps':list(pair)} for pair in itertools.product(ops,repeat=2)]
+    else:
+        candidates=[{'kind':'array','filter':f,'reduce':r} for f,r in itertools.product(FILTERS,REDUCERS)]
+    # An exhaustive finite probe signature rejects algebraic/behavioral duplicates
+    # in this restricted grammar, including reordered commuting operations.
+    seen=set();out=[]
+    for spec in candidates:
+        signature=tuple(oracle(spec,x) for x in probes(kind))
+        if signature in seen:continue
+        seen.add(signature);out.append(spec)
+    return out
+
+def instruction(spec):
+    kind=spec['kind']
+    if kind in ('scalar','string'):
+        ops=SCALAR if kind=='scalar' else STRINGS
+        return ('Starting with n, ' if kind=='scalar' else 'Starting with ASCII string s, ')+', then '.join(ops[k][0] for k in spec['steps'])+'. Return the result.'
+    text='Select '+FILTERS[spec['filter']][0]+' from values in original order. '
+    if spec.get('map'):text+='For each selected item, '+SCALAR[spec['map']][0]+'. '
+    text+='Return their '+REDUCERS[spec['reduce']]+'. '
+    if spec['reduce']=='product':text+='The empty product is 1.'
+    elif spec['reduce'] not in ('sum','count','distinct','frequency'):text+='Return 0 when none are selected.'
+    return text
+
+def task_specs():
+    scalars=bank('scalar');strings=bank('string');arrays=bank('array')
+    assert len(scalars)>=80 and len(strings)>=70 and len(arrays)>=75,(len(scalars),len(strings),len(arrays))
+    # Interleave operation families so shorter language allocations retain diversity.
+    rng=random.Random(7301)
+    for b in (scalars,strings,arrays):rng.shuffle(b)
+    easy=[]
+    for i in range(80):
+        easy.append(scalars[i])
+        if i<70:easy.append(strings[i])
+    medium=arrays[:75]
+    seen={tuple(oracle(s,x) for x in probes('array')) for s in medium}
+    moderate=[]
+    candidates=[{'kind':'array','filter':f,'map':m,'reduce':r}
+        for f,m,r in itertools.product(FILTERS,('absolute','square','negate','double','sign','successor'),REDUCERS)
+        if r!='count']
+    rng.shuffle(candidates)
+    for s in candidates:
+        sig=tuple(oracle(s,x) for x in probes('array'))
+        if sig in seen:continue
+        seen.add(sig);moderate.append(s)
+        if len(moderate)==25:break
+    return {'easy':easy,'medium':medium,'moderate':moderate}

generators/web.py

@@ -0,0 +1,144 @@
+"""Browser tasks with explicit semantic DOM and computed-style checks."""
+from html import escape
+
+HTML_BASES=[
+ ('heading','h1','<h1>Welcome</h1>','an h1 heading reading Welcome',{}),
+ ('paragraph','p','<p>Hello reader</p>','a paragraph reading Hello reader',{}),
+ ('link','a','<a href="/help">Help</a>','a Help link to /help',{'href':'/help'}),
+ ('button','button','<button type="button">Save</button>','a Save button with type button',{'type':'button'}),
+ ('image','img','<img src="icon.png" alt="Star">','an image sourced from icon.png with alt text Star',{'src':'icon.png','alt':'Star'}),
+ ('email','input','<input type="email" name="email">','an email input named email',{'type':'email','name':'email'}),
+ ('checkbox','input','<input type="checkbox" name="agree">','a checkbox named agree',{'type':'checkbox','name':'agree'}),
+ ('form','form','<form action="/send" method="post"><button>Send</button></form>','a POST form targeting /send containing a Send button',{'action':'/send','method':'post'}),
+ ('list','ul','<ul><li>Tea</li><li>Water</li></ul>','an unordered list containing Tea then Water',{}),
+ ('ordered_list','ol','<ol><li>Open</li><li>Close</li></ol>','an ordered list containing Open then Close',{}),
+ ('navigation','nav','<nav><a href="/">Home</a></nav>','a navigation element with a Home link to /',{}),
+ ('article','article','<article><h2>News</h2><p>Today</p></article>','an article with an h2 News and a paragraph Today',{}),
+ ('footer','footer','<footer>Copyright</footer>','a footer reading Copyright',{}),
+ ('quote','blockquote','<blockquote cite="/source">Be kind</blockquote>','a blockquote reading Be kind citing /source',{'cite':'/source'}),
+ ('code','pre','<pre><code>x = 1</code></pre>','a preformatted code block reading x = 1',{}),
+ ('details','details','<details><summary>More</summary><p>Details</p></details>','a details element with summary More and paragraph Details',{}),
+ ('select','select','<select name="color"><option value="red">Red</option><option value="blue">Blue</option></select>','a select named color with Red/red and Blue/blue options',{'name':'color'}),
+ ('textarea','textarea','<textarea name="note" rows="3">Note</textarea>','a textarea named note with three rows initially reading Note',{'name':'note','rows':'3'}),
+ ('label','label','<label for="username">Name</label>','a Name label associated with input ID username',{'for':'username'}),
+ ('progress','progress','<progress max="10" value="4">4/10</progress>','a progress element with maximum 10 and value 4',{'max':'10','value':'4'}),
+]
+GLOBAL=[('title','Information','a title attribute of Information'),('lang','en','English language via lang'),
+ ('dir','rtl','right-to-left direction via dir'),('hidden','','the hidden attribute'),
+ ('tabindex','0','keyboard focus via tabindex 0'),('contenteditable','true','contenteditable set to true')]
+
+def html_assertions(markup,prefix=''):
+    # Derive structural checks from the authored spec tree, not candidate text.
+    from html.parser import HTMLParser
+    class Parse(HTMLParser):
+        def __init__(self):super().__init__();self.stack=[];self.counts={};self.out=[]
+        def handle_starttag(self,tag,attrs):
+            parent=self.stack[-1][0] if self.stack else prefix
+            key=(parent,tag);self.counts[key]=self.counts.get(key,0)+1
+            selector=(parent+' > ' if parent else '')+tag+f':nth-of-type({self.counts[key]})'
+            self.out.append({'kind':'exists','selector':selector})
+            for k,v in attrs:self.out.append({'kind':'attribute','selector':selector,'name':k,'value':v or ''})
+            if tag not in ('img','input','br','hr','meta','link'):self.stack.append((selector,tag))
+        def handle_endtag(self,tag):
+            if self.stack and self.stack[-1][1]==tag:self.stack.pop()
+        def handle_data(self,text):
+            if text.strip() and self.stack:self.out.append({'kind':'text','selector':self.stack[-1][0],'value':text})
+    p=Parse();p.feed(markup);return p.out
+
+def html_tasks():
+    tasks=[]
+    for name,tag,code,desc,attrs in HTML_BASES:
+        for attr,value,detail in GLOBAL:
+            markup=code.replace('<'+tag,'<'+tag+' '+attr+'="'+value+'"',1)
+            tasks.append(('easy',{'kind':'html','base':name,'feature':attr},'Create '+desc+'. On its outer element, set '+detail+'. Return an HTML fragment.',markup))
+    for i,(name,tag,code,desc,attrs) in enumerate(HTML_BASES):
+        for offset,wrapper in ((1,'section'),(4,'aside'),(9,'div')):
+            _,_,code2,desc2,_=HTML_BASES[(i+offset)%len(HTML_BASES)]
+            markup=f'<{wrapper}>{code}{code2}</{wrapper}>'
+            tasks.append(('medium',{'kind':'html','pair':[i,(i+offset)%20],'wrapper':wrapper},f'Create a {wrapper} containing {desc}, followed by {desc2}. Return an HTML fragment.',markup))
+    for i,(_,_,code,desc,_) in enumerate(HTML_BASES):
+        _,_,code2,desc2,_=HTML_BASES[(i+7)%20]
+        markup=f'<main><section>{code}</section><aside>{code2}</aside></main>'
+        tasks.append(('moderate',{'kind':'html','layout':[i,(i+7)%20]},f'Create a main element. Put {desc} inside its section, and {desc2} inside its following aside. Return an HTML fragment.',markup))
+    return [dict(difficulty=d,spec=s,prompt=p,reference=c,fixture='',checks=html_assertions(c)) for d,s,p,c in tasks]
+
+# Fixed values are chosen to have exact, stable computed representations.
+CSS_PROPERTIES=[
+ ('color','rgb(10, 20, 30)'),('background-color','rgb(240, 220, 200)'),('font-size','20px'),('font-weight','700'),
+ ('font-style','italic'),('text-align','center'),('text-transform','uppercase'),('letter-spacing','2px'),
+ ('word-spacing','4px'),('line-height','28px'),('text-indent','12px'),('white-space','pre'),
+ ('padding-top','8px'),('padding-right','10px'),('padding-bottom','12px'),('padding-left','14px'),
+ ('margin-top','6px'),('margin-right','8px'),('margin-bottom','10px'),('margin-left','12px'),
+ ('border-top-width','3px'),('border-bottom-color','rgb(0, 80, 120)'),('border-radius','6px'),('opacity','0.5'),
+ ('width','120px'),('height','60px'),('min-width','90px'),('max-width','180px'),('box-sizing','border-box'),
+ ('display','flex'),('flex-direction','column'),('justify-content','center'),('align-items','center'),('gap','8px'),
+ ('position','relative'),('top','5px'),('overflow-x','hidden'),('visibility','hidden'),('cursor','pointer'),('list-style-type','square')]
+BASE_CSS='* { box-sizing: content-box; } .target,.other { border: 1px solid black; width:200px; height:80px; min-width:0; max-width:none; margin:0; padding:0; display:block; position:static; }'
+FIXTURE='<div id="scope"><div id="target" class="target" data-kind="card">Alpha<span>One</span><span>Two</span></div><div class="other">Beta</div></div><div class="target" id="outside">Outside</div>'
+
+def css_tasks():
+    tasks=[]
+    for prop,val in CSS_PROPERTIES:
+        for sel,description,affected in [('.target','every element with class target',['#target','#outside']),('#target','only the element with ID target',['#target']),('#scope > .target','only direct children of #scope having class target',['#target'])]:
+            spec={'kind':'css','selector':sel,'declarations':{prop:val}}
+            checks=[{'kind':'style','selector':x,'property':prop,'value':val} for x in affected]
+            extra = 'display: flex;' if prop in ('flex-direction','justify-content','align-items','gap') else ('position: relative;' if prop=='top' else '')
+            if extra:
+                extra_prop='display' if prop!='top' else 'position'
+                extra_val='flex' if prop!='top' else 'relative'
+                checks += [{'kind':'style','selector':x,'property':extra_prop,'value':extra_val} for x in affected]
+                spec['declarations'][extra_prop]=extra_val
+            if prop=='flex-direction':checks += [{'kind':'layout_column','selector':x} for x in affected]
+            if prop=='display':checks += [{'kind':'layout_row','selector':x} for x in affected]
+            checks +=[{'kind':'unchanged','selector':'.other','property':prop}]
+            if len(affected)==1:checks +=[{'kind':'unchanged','selector':'#outside','property':prop}]
+            extra_instruction = ' Use flex display.' if extra.startswith('display') else (' Use relative positioning.' if extra else '')
+            tasks.append(dict(difficulty='easy',spec=spec,prompt=f'Style {description}: set {prop} to {val}.{extra_instruction} Leave other elements unchanged. Return CSS only.',reference=f'{sel} {{ {prop}: {val}; {extra} }}',fixture=FIXTURE,checks=checks))
+    pairs=[]
+    # Avoid interactions that would invalidate literal computed values.
+    for i in range(20):
+        for offset in (4,7,11):pairs.append((i,(i+offset)%20))
+    for i,j in pairs:
+        p,v=CSS_PROPERTIES[i];q,w=CSS_PROPERTIES[j]
+        spec={'kind':'css','selector':'#scope > .target','declarations':{p:v,q:w}}
+        checks=[{'kind':'style','selector':'#target','property':k,'value':x} for k,x in ((p,v),(q,w))]
+        checks +=[{'kind':'unchanged','selector':'.other','property':k} for k in (p,q)]
+        tasks.append(dict(difficulty='medium',spec=spec,prompt=f'For direct children of #scope with class target, set {p} to {v} and {q} to {w}. Leave .other unchanged. Return CSS only.',reference=f'#scope > .target {{ {p}: {v}; {q}: {w}; }}',fixture=FIXTURE,checks=checks))
+    for i,(prop,val) in enumerate(CSS_PROPERTIES[:20]):
+        # Baseline captured before candidate CSS; test both sides of the breakpoint.
+        spec={'kind':'css','selector':'#target','declarations':{prop:val},'max_width':600}
+        checks=[{'kind':'style','selector':'#target','property':prop,'value':val,'viewport':480},
+                {'kind':'unchanged','selector':'#target','property':prop,'viewport':900},
+                {'kind':'unchanged','selector':'.other','property':prop,'viewport':480}]
+        tasks.append(dict(difficulty='moderate',spec=spec,prompt=f'At viewport widths at most 600px, set {prop} to {val} on #target. At wider widths, preserve its original style. Never change .other. Return CSS only.',reference=f'@media (max-width: 600px) {{ #target {{ {prop}: {val}; }} }}',fixture=FIXTURE,checks=checks))
+    return tasks
+
+DOM_FIXTURE='<button id="action">Go</button><input id="input" value=""><p id="output">0</p><ul id="items"></ul><input id="check" type="checkbox">'
+DOM_ACTIONS=[
+ ('greeting','make #output read Hello',"o.textContent='Hello'",[{'kind':'text','selector':'#output','value':'Hello'}]),
+ ('increment','increase the integer in #output by one',"o.textContent=String(Number(o.textContent)+1)",[{'kind':'text','selector':'#output','value':'2'}]),
+ ('decrement','decrease the integer in #output by one',"o.textContent=String(Number(o.textContent)-1)",[{'kind':'text','selector':'#output','value':'-2'}]),
+ ('mirror','copy the input value into #output',"o.textContent=i.value",[{'kind':'text','selector':'#output','value':'Ab 9'}]),
+ ('uppercase','copy the uppercased input into #output',"o.textContent=i.value.toUpperCase()",[{'kind':'text','selector':'#output','value':'AB 9'}]),
+ ('length','put the input character count in #output',"o.textContent=String(i.value.length)",[{'kind':'text','selector':'#output','value':'4'}]),
+ ('clear_input','clear the input value',"i.value=''",[{'kind':'value','selector':'#input','value':''}]),
+ ('disable_input','disable the input',"i.disabled=true",[{'kind':'property','selector':'#input','name':'disabled','value':True}]),
+ ('hide_output','hide #output using its hidden property',"o.hidden=true",[{'kind':'property','selector':'#output','name':'hidden','value':True}]),
+ ('toggle_class','toggle class active on #output',"o.classList.toggle('active')",[{'kind':'attribute','selector':'#output','name':'class','value':''}]),
+ ('append_item','append a list item containing the input to #items',"const li=document.createElement('li'); li.textContent=i.value; document.querySelector('#items').appendChild(li)",[{'kind':'count','selector':'#items > li','value':2},{'kind':'text','selector':'#items > li:first-child','value':'Ab 9'}]),
+ ('check','check the checkbox',"document.querySelector('#check').checked=true",[{'kind':'property','selector':'#check','name':'checked','value':True}]),
+ ('title','set #output title to the input value',"o.title=i.value",[{'kind':'attribute','selector':'#output','name':'title','value':'Ab 9'}]),
+ ('reverse','copy the reversed input into #output',"o.textContent=i.value.split('').reverse().join('')",[{'kind':'text','selector':'#output','value':'9 bA'}]),
+ ('mark_empty','set #output to Empty if input is empty, otherwise Filled',"o.textContent=i.value.length ? 'Filled':'Empty'",[{'kind':'text','selector':'#output','value':'Filled'}]),
+]
+
+def dom_tasks():
+    tasks=[]
+    for name,desc,body,checks in DOM_ACTIONS:
+        spec={'kind':'dom','event':'click','action':name}
+        code="function setup() {\n  const i=document.querySelector('#input'), o=document.querySelector('#output');\n  document.querySelector('#action').addEventListener('click', () => { "+body+"; });\n}\n"
+        tasks.append(dict(difficulty='medium',spec=spec,prompt=f'Implement setup(). When #action is clicked, {desc}. Attach an event listener; do not perform the action before a click.',reference=code,fixture=DOM_FIXTURE,checks=checks,steps=[{'action':'fill','selector':'#input','value':'Ab 9'},{'action':'click','selector':'#action'},{'action':'click','selector':'#action'}]))
+    for name,desc,body,checks in DOM_ACTIONS[3:8]:
+        code="function setup() {\n  const i=document.querySelector('#input'), o=document.querySelector('#output');\n  i.addEventListener('input', () => { "+body+"; });\n}\n"
+        tasks.append(dict(difficulty='moderate',spec={'kind':'dom','event':'input','action':name},prompt=f'Implement setup(). On an input event from #input, {desc}. Use a listener, leave the initial page unchanged, and handle repeated events.',reference=code,fixture=DOM_FIXTURE,checks=checks,steps=[{'action':'set_value','selector':'#input','value':'Ab 9'},{'action':'event','selector':'#input','value':'input'}]))
+    return tasks

manifest.json

@@ -0,0 +1,28 @@
+{
+  "version": "smolscript-0.1.0",
+  "examples": 2000,
+  "languages": {
+    "python": 250,
+    "javascript": 250,
+    "html": 200,
+    "css": 200,
+    "cpp": 225,
+    "c": 225,
+    "lua": 200,
+    "csharp": 225,
+    "rust": 225
+  },
+  "difficulty": {
+    "easy": 1200,
+    "medium": 600,
+    "moderate": 200
+  },
+  "generator_seed": 7301,
+  "validation_status": "execution_unverified",
+  "files": {
+    "data/smolscript.jsonl": "1926bca1b0c6b2244554577135a9c3c305b18fd834c654803b4e8480fff0d3d9",
+    "data/smolscript.parquet": "7bf25948750648aa036bdf277cfd7c38597c98aa06131e805628b9055a7938d9",
+    "private_tests/hidden.jsonl": "2447d09ae445094c1ae59df644b46e3ca2f4cc64de630966b94bd5db8b8bf0ac",
+    "references/solutions.jsonl": "84d3411fe45189c62ae50fbd31c1dc5795bc099d5037c3a817e3d280f6097e83"
+  }
+}

metrics.py

@@ -0,0 +1,18 @@
+"""All published metrics are percentages; no incomplete full-benchmark index."""
+from collections import defaultdict
+from runners import LANGUAGES
+
+def aggregate(results,expected_ids,full_run=True):
+    if len({r['id'] for r in results})!=len(results):raise ValueError('Duplicate result IDs')
+    if {r['id'] for r in results}!=set(expected_ids):raise ValueError('Incomplete or extra results')
+    groups=defaultdict(list)
+    for r in results:groups[r['language']].append(r)
+    accuracy={lang:100*sum(bool(r['passed']) for r in group)/len(group) for lang,group in sorted(groups.items())}
+    syntax={lang:100*sum(bool(r['syntax_success']) for r in group)/len(group) for lang,group in sorted(groups.items())}
+    if full_run and set(groups)!=set(LANGUAGES):raise ValueError('Missing language')
+    score=sum(accuracy.values())/len(accuracy)
+    result={'scope':'full' if full_run else 'filtered','examples':len(results),'pass_at_1':score,
+      'syntax_success':sum(syntax.values())/len(syntax),'per_language_accuracy':accuracy,
+      'per_language_syntax_success':syntax,'micro_accuracy':100*sum(r['passed'] for r in results)/len(results)}
+    result['smolscript_score' if full_run else 'filtered_macro_score']=score
+    return result

pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "smolscript"
+version = "0.1.0"
+description = "A small-model multilingual execution benchmark"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+dependencies = ["pyarrow==19.0.1"]
+[project.optional-dependencies]
+inference = ["torch>=2.5,<3", "transformers>=4.57,<6", "huggingface-hub>=0.36,<2", "accelerate>=1,<2"]
+[tool.setuptools]
+packages = ["runners", "generators", "validators"]

runners/__init__.py

@@ -0,0 +1,5 @@
+from importlib import import_module
+LANGUAGES=('python','javascript','html','css','cpp','c','lua','csharp','rust')
+def get_runner(language):
+    if language not in LANGUAGES:raise ValueError('Unknown language '+language)
+    return import_module('runners.'+language+'_runner').Runner()

runners/c_runner.py

@@ -0,0 +1,5 @@
+"""c runner: executed only through the container boundary."""
+from runners.common import FunctionRunner
+
+class Runner(FunctionRunner):
+    pass

runners/common.py

@@ -0,0 +1,61 @@
+import re
+from decimal import Decimal,InvalidOperation
+
+
+def extract_code(text):
+    text=text.strip()
+    blocks=re.findall(r'```[^\n`]*\n(.*?)```',text,re.S)
+    if len(blocks)==1:return blocks[0].strip()+'\n'
+    if len(blocks)>1:raise ValueError('Multiple code blocks are ambiguous')
+    if '```' in text:raise ValueError('Unclosed code fence')
+    return text+'\n'
+
+
+def compare_output(actual,expected):
+    # Remove one terminal newline only: spaces in string results are observable.
+    value=actual.removesuffix('\n').removesuffix('\r')
+    if isinstance(expected,int):
+        try:return Decimal(value.strip())==expected and value.strip()!=''
+        except InvalidOperation:return False
+    return value==expected
+
+
+class FunctionRunner:
+    def evaluate(self,row,code,hidden,sandbox):
+        inputs=[t['input'] for t in hidden['tests']]
+        response=sandbox.run({'language':row['language'],'kind':row['metadata']['family'],
+             'code':code,'inputs':inputs,'timeout_seconds':row['timeout_seconds']},
+             timeout=50+len(inputs)*(row['timeout_seconds']+2))
+        results=[]
+        observations=response['observations']
+        for i,test in enumerate(hidden['tests']):
+            actual=observations[i] if i<len(observations) else None
+            passed=bool(actual and actual['exit_code']==0 and not actual['timeout'] and not actual['output_limit'] and compare_output(actual['stdout'],test['expected']))
+            results.append({'test':i,'passed':passed,'actual':actual})
+        return {'syntax_success':response['syntax_success'],'passed':bool(results) and all(t['passed'] for t in results),
+                'tests':results,'compilation':response.get('compilation')}
+
+
+class BrowserRunner:
+    def evaluate(self,row,code,hidden,sandbox):
+        scenarios=[];expected=[]
+        for t in hidden['tests']:
+            widths=sorted(set(c.get('viewport',800) for c in t['checks']))
+            for width in widths:
+                checks=[c for c in t['checks'] if c.get('viewport',800)==width]
+                # Deliberately do not send expected values into the sandbox.
+                scenarios.append({'viewport':width,'steps':t.get('steps',[]),
+                    'checks':[{k:v for k,v in c.items() if k not in ('value','viewport')} for c in checks]})
+                expected.append(checks)
+        response=sandbox.run({'language':row['language'],'kind':row['metadata']['family'],'code':code,
+            'fixture':row['metadata'].get('fixture',''),'base_css':row['metadata'].get('base_css',''),
+            'scenarios':scenarios,'timeout_seconds':row['timeout_seconds']},timeout=30+len(scenarios)*20)
+        results=[]
+        for i,checks in enumerate(expected):
+            actual=response['observations'][i] if i<len(response['observations']) else None
+            for j,c in enumerate(checks):
+                observed=actual['actual'][j] if actual and j<len(actual['actual']) else None
+                target=actual['baseline'][j] if actual and c['kind']=='unchanged' else c.get('value',True)
+                passed=bool(actual and not actual['error'] and j<len(actual['actual']) and observed==target)
+                results.append({'scenario':i,'test':j,'passed':passed,'actual':observed,'error':actual['error'] if actual else 'syntax failure'})
+        return {'syntax_success':response['syntax_success'],'passed':bool(results) and all(r['passed'] for r in results),'tests':results}

runners/cpp_runner.py

@@ -0,0 +1,5 @@
+"""cpp runner: executed only through the container boundary."""
+from runners.common import FunctionRunner
+
+class Runner(FunctionRunner):
+    pass

runners/csharp_runner.py

@@ -0,0 +1,5 @@
+"""csharp runner: executed only through the container boundary."""
+from runners.common import FunctionRunner
+
+class Runner(FunctionRunner):
+    pass

runners/css_runner.py

@@ -0,0 +1,5 @@
+"""css runner: executed only through the container boundary."""
+from runners.common import BrowserRunner
+
+class Runner(BrowserRunner):
+    pass

runners/html_runner.py

@@ -0,0 +1,5 @@
+"""html runner: executed only through the container boundary."""
+from runners.common import BrowserRunner
+
+class Runner(BrowserRunner):
+    pass

runners/javascript_runner.py

@@ -0,0 +1,6 @@
+"""Node function tasks and Chromium DOM tasks share one language score."""
+from runners.common import FunctionRunner,BrowserRunner
+class Runner:
+    def evaluate(self,row,code,hidden,sandbox):
+        runner=BrowserRunner() if row['metadata']['family']=='dom' else FunctionRunner()
+        return runner.evaluate(row,code,hidden,sandbox)

runners/lua_runner.py

@@ -0,0 +1,5 @@
+"""lua runner: executed only through the container boundary."""
+from runners.common import FunctionRunner
+
+class Runner(FunctionRunner):
+    pass

runners/protocol.py

@@ -0,0 +1,46 @@
+"""Runtime adapters: signature wrappers, no execution on the host."""
+HEADERS={
+ 'python':'', 'javascript':'', 'lua':'',
+ 'cpp':'#include <iostream>\n#include <string>\n#include <vector>\n#include <algorithm>\n#include <cstdlib>\n',
+ 'c':'#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n',
+ 'csharp':'using System;\nusing System.Linq;\nusing System.Collections.Generic;\n',
+ 'rust':'use std::io::{self, Read};\n',
+}
+
+def wrap_source(language,kind,code):
+    """Candidate function plus a fixed stdin/stdout adapter. No expected answers."""
+    if language=='python':
+        expr={'scalar':'int(line)','string':'line','array':'list(map(int,line.split())) if line else []'}[kind]
+        tail=f'\nimport sys\nline=sys.stdin.readline().rstrip("\\n")\nprint(solve({expr}))\n'
+    elif language=='javascript':
+        expr={'scalar':'Number(line)','string':'line','array':"line ? line.split(' ').map(Number) : []"}[kind]
+        tail=f"\nconst line=require('fs').readFileSync(0,'utf8').replace(/\\n$/, '');\nconsole.log(solve({expr}));\n"
+    elif language=='lua':
+        init={'scalar':'local v=tonumber(line)','string':'local v=line','array':'local v={}; for n in line:gmatch("%-?%d+") do v[#v+1]=tonumber(n) end'}[kind]
+        tail='\nlocal line=io.read("*l") or ""\n'+init+'\nprint(solve(v))\n'
+    elif language=='cpp':
+        init={'scalar':'long long v; std::cin>>v;','string':'std::string v; std::getline(std::cin,v);','array':'std::vector<long long> v; long long x; while(std::cin>>x) v.push_back(x);'}[kind]
+        tail='\nint main() { '+init+' std::cout << solve(v) << "\\n"; }\n'
+    elif language=='c':
+        init={'scalar':'long long v; scanf("%lld",&v); printf("%lld\\n",solve(v));',
+           'string':'char v[512]; if(!fgets(v,sizeof v,stdin)) v[0]=0; v[strcspn(v,"\\n")]=0; printf("%s\\n",solve(v));',
+           'array':'long long v[64]; int n=0; while(n<64 && scanf("%lld",&v[n])==1) n++; printf("%lld\\n",solve(v,n));'}[kind]
+        tail='\nint main(void) { '+init+' return 0; }\n'
+    elif language=='csharp':
+        expr={'scalar':'long.Parse(line)','string':'line','array':'line.Length==0 ? new long[0] : line.Split(\' \').Select(long.Parse).ToArray()'}[kind]
+        tail='\npublic class Harness { public static void Main() { string line=Console.ReadLine() ?? ""; Console.WriteLine(Solution.Solve('+expr+')); } }\n'
+    elif language=='rust':
+        expr={'scalar':'line.parse::<i64>().unwrap()','string':'line.to_string()','array':'line.split_whitespace().map(|x| x.parse::<i64>().unwrap()).collect()'}[kind]
+        tail='\nfn main() { let mut text=String::new(); io::stdin().read_to_string(&mut text).unwrap(); let line=text.strip_suffix("\\n").unwrap_or(&text); println!("{}",solve('+expr+')); }\n'
+    else:raise ValueError(language)
+    return HEADERS[language]+code+'\n'+tail
+
+COMMANDS={
+ 'python':('solution.py',['python3','-m','py_compile','solution.py'],['python3','-I','solution.py']),
+ 'javascript':('solution.js',['node','--check','solution.js'],['node','solution.js']),
+ 'lua':('solution.lua',['luac','-p','solution.lua'],['lua','solution.lua']),
+ 'cpp':('solution.cpp',['g++','-std=c++17','-O0','solution.cpp','-o','program'],['./program']),
+ 'c':('solution.c',['gcc','-std=c11','-O0','solution.c','-o','program'],['./program']),
+ 'csharp':('solution.cs',['mcs','-out:program.exe','solution.cs'],['mono','program.exe']),
+ 'rust':('solution.rs',['rustc','--edition=2021','-C','opt-level=0','solution.rs','-o','program'],['./program']),
+}

runners/python_runner.py

@@ -0,0 +1,5 @@
+"""python runner: executed only through the container boundary."""
+from runners.common import FunctionRunner
+
+class Runner(FunctionRunner):
+    pass

runners/rust_runner.py

@@ -0,0 +1,5 @@
+"""rust runner: executed only through the container boundary."""
+from runners.common import FunctionRunner
+
+class Runner(FunctionRunner):
+    pass

runners/sandbox.py

@@ -0,0 +1,46 @@
+"""Fail-closed container boundary. Candidate code never runs on the host."""
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import uuid
+
+class SandboxUnavailable(RuntimeError):pass
+
+class Sandbox:
+    def __init__(self,image='smolscript-runtime:0.1.0',engine='docker'):
+        if not shutil.which(engine):raise SandboxUnavailable(f'{engine} is unavailable; install Docker/Podman and build sandbox/Dockerfile. No host fallback exists.')
+        self.engine=engine
+        try:
+            info=json.loads(subprocess.check_output([engine,'image','inspect',image],timeout=15))[0]
+        except (subprocess.SubprocessError,ValueError,KeyError) as e:raise SandboxUnavailable('Sandbox image unavailable; build it before offline evaluation') from e
+        self.image=info['Id']  # Immutable local ID, not a moving tag.
+        self.identity={'engine':engine,'image_id':self.image,'repo_digests':info.get('RepoDigests',[])}
+
+    def run(self,payload,timeout):
+        # Only candidate, fixture, input values and observation selectors cross the
+        # boundary. Expected answers, references, credentials and dataset do not.
+        name='smolscript-'+uuid.uuid4().hex
+        with tempfile.TemporaryDirectory(prefix='smolscript-input-') as directory:
+            path=Path(directory)/'request.json'
+            path.write_text(json.dumps(payload));path.chmod(0o444);os.chmod(directory,0o755)
+            command=[self.engine,'run','--rm','--name',name,'--network','none','--read-only',
+              '--cap-drop','ALL','--security-opt','no-new-privileges','--user','1000:1000',
+              '--memory','2g','--memory-swap','2g','--cpus','1','--pids-limit','128',
+              '--ulimit','nofile=256:256','--ulimit','core=0:0',
+              '--tmpfs','/work:rw,exec,nosuid,size=256m,uid=1000,gid=1000',
+              '--tmpfs','/tmp:rw,nosuid,size=128m,uid=1000,gid=1000','--shm-size','128m',
+              '--mount',f'type=bind,src={directory},dst=/input,readonly',
+              self.image,'python3','/opt/smolscript/worker.py','/input/request.json']
+            try:
+                result=subprocess.run(command,capture_output=True,text=True,timeout=timeout)
+                if result.returncode:raise RuntimeError('Sandbox infrastructure failed: '+result.stderr[-2000:])
+                value=json.loads(result.stdout)
+                if 'infrastructure_error' in value:raise RuntimeError(value['infrastructure_error'])
+                return value
+            except subprocess.TimeoutExpired:
+                raise RuntimeError('Sandbox supervisor timed out; outcome incomplete')
+            finally:
+                subprocess.run([self.engine,'rm','-f',name],stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,timeout=15)

sandbox/Dockerfile

@@ -0,0 +1,14 @@
+# Build once with internet; inference/evaluation never downloads runtime assets.
+FROM mcr.microsoft.com/playwright/python:v1.56.0-noble
+USER root
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc g++ nodejs lua5.4 mono-mcs mono-runtime rustc && \
+    rm -rf /var/lib/apt/lists/*
+RUN python3 -m pip install --no-cache-dir playwright==1.56.0 html5lib==1.1 tinycss2==1.4.0
+RUN ln -sf /usr/bin/lua5.4 /usr/local/bin/lua && ln -sf /usr/bin/luac5.4 /usr/local/bin/luac
+COPY sandbox/worker.py /opt/smolscript/worker.py
+COPY runners/protocol.py /opt/smolscript/protocol.py
+RUN useradd --uid 1000 --create-home --non-unique benchmark 2>/dev/null || true
+ENV HOME=/tmp PYTHONHASHSEED=0 LANG=C.UTF-8 LC_ALL=C.UTF-8 TZ=UTC
+WORKDIR /work
+USER 1000:1000

sandbox/worker.py

@@ -0,0 +1,143 @@
+"""Trusted in-container supervisor. Never import or invoke this on host candidates."""
+import json
+import os
+from pathlib import Path
+import resource
+import signal
+import subprocess
+import sys
+import tempfile
+from protocol import COMMANDS,wrap_source
+
+
+def limits(seconds):
+    os.setsid()
+    resource.setrlimit(resource.RLIMIT_CPU,(seconds,seconds+1))
+    resource.setrlimit(resource.RLIMIT_FSIZE,(1024*1024,1024*1024))
+    resource.setrlimit(resource.RLIMIT_CORE,(0,0))
+
+
+def execute(command,stdin,seconds):
+    with tempfile.TemporaryFile() as out,tempfile.TemporaryFile() as err:
+        p=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=out,stderr=err,
+            preexec_fn=lambda:limits(seconds),env={'PATH':os.environ['PATH'],'HOME':'/tmp','LANG':'C.UTF-8',
+            'LC_ALL':'C.UTF-8','TZ':'UTC','PYTHONHASHSEED':'0','MONO_THREADS_PER_CPU':'1'})
+        timed_out=False
+        try:p.communicate(stdin.encode(),timeout=seconds+1)
+        except subprocess.TimeoutExpired:timed_out=True
+        finally:
+            try:os.killpg(p.pid,signal.SIGKILL)
+            except ProcessLookupError:pass
+            p.wait()
+        out.seek(0);err.seek(0)
+        output=out.read(65537)
+        return {'exit_code':p.returncode,'timeout':timed_out,'output_limit':len(output)>65536,
+                'stdout':output[:65536].decode('utf8','replace'),'stderr':err.read(2000).decode('utf8','replace')}
+
+
+def program(request):
+    filename,compile_cmd,run_cmd=COMMANDS[request['language']]
+    Path(filename).write_text(wrap_source(request['language'],request['kind'],request['code']))
+    compilation=execute(compile_cmd,'',30)
+    syntax=compilation['exit_code']==0 and not compilation['timeout']
+    if not syntax:return {'syntax_success':False,'compilation':compilation,'observations':[]}
+    observations=[]
+    for value in request['inputs']:
+        line=' '.join(map(str,value)) if isinstance(value,list) else str(value)
+        observations.append(execute(run_cmd,line+'\n',request['timeout_seconds']))
+    return {'syntax_success':True,'observations':observations}
+
+
+def observe(page,check):
+    loc=page.locator(check['selector']);kind=check['kind']
+    if kind=='count':return loc.count()
+    if kind in ('layout_column','layout_row'):
+        return loc.evaluate('''(e,kind) => { const a=e.querySelectorAll('span'); if(a.length!==2) return false;
+            const x=a[0].getBoundingClientRect(), y=a[1].getBoundingClientRect();
+            return kind==='layout_column' ? Math.abs(x.x-y.x)<1 && y.y>=x.bottom : Math.abs(x.y-y.y)<1 && y.x>=x.right; }''',kind)
+    if kind=='exists':return loc.count()>0
+    if loc.count()!=1:return {'error':'selector must resolve to exactly one element','count':loc.count()}
+    if kind=='text':return loc.text_content()
+    if kind=='attribute':return loc.get_attribute(check['name'])
+    if kind=='value':return loc.input_value()
+    if kind=='property':return loc.evaluate('(e,k)=>e[k]',check['name'])
+    if kind in ('style','unchanged'):return loc.evaluate('(e,p)=>getComputedStyle(e).getPropertyValue(p)',check['property'])
+    raise ValueError(kind)
+
+
+def browser(request):
+    from playwright.sync_api import sync_playwright,TimeoutError as BrowserTimeout
+    kind=request['kind'];code=request['code']
+    if kind=='html':
+        import html5lib
+        parser=html5lib.HTMLParser();parser.parseFragment(code)
+        syntax=not parser.errors
+    elif kind=='css':
+        import tinycss2
+        rules=tinycss2.parse_stylesheet(code,skip_comments=True,skip_whitespace=True)
+        def errors(nodes):
+            for n in nodes:
+                if n.type=='error':return True
+                if n.type=='qualified-rule':
+                    if any(x.type=='error' for x in tinycss2.parse_declaration_list(n.content)):return True
+                if n.type=='at-rule' and n.content is not None:
+                    if errors(tinycss2.parse_rule_list(n.content)):return True
+            return False
+        syntax=bool(rules) and not errors(rules)
+    else:
+        Path('candidate.js').write_text(code)
+        syntax=execute(['node','--check','candidate.js'],'',5)['exit_code']==0
+    if not syntax:return {'syntax_success':False,'observations':[]}
+    observations=[]
+    with sync_playwright() as p:
+        # Container namespace, seccomp, uid, cgroups and disabled networking are
+        # the mandatory boundary; no browser flag substitutes for that boundary.
+        b=p.chromium.launch(headless=True,args=['--disable-dev-shm-usage'])
+        try:
+            for scenario in request['scenarios']:
+                page=b.new_page(viewport={'width':scenario.get('viewport',800),'height':600},java_script_enabled=kind=='dom')
+                page.set_default_timeout(request['timeout_seconds']*1000)
+                page.route('**/*',lambda route:route.abort())
+                actual=[];baseline=[];error=None
+                try:
+                    page.set_content(request['fixture'],wait_until='domcontentloaded')
+                    if request.get('base_css'):page.add_style_tag(content=request['base_css'])
+                    baseline=[observe(page,c) if c['kind']=='unchanged' else None for c in scenario['checks']]
+                    if kind=='html':page.set_content(code,wait_until='domcontentloaded')
+                    elif kind=='css':page.add_style_tag(content=code)
+                    else:
+                        page.add_script_tag(content=code)
+                        page.evaluate('() => setup()')
+                    for step in scenario.get('steps',[]):
+                        loc=page.locator(step['selector']);action=step['action']
+                        if action=='fill':loc.fill(step['value'])
+                        elif action=='click':loc.click()
+                        elif action=='event':loc.dispatch_event(step['value'])
+                        elif action=='set_value':loc.evaluate('(e,v)=>{e.value=v}',step['value'])
+                        else:raise ValueError(action)
+                    actual=[observe(page,c) for c in scenario['checks']]
+                except Exception as e:error=type(e).__name__+': '+str(e)[:500]
+                observations.append({'actual':actual,'baseline':baseline,'error':error})
+                page.close()
+        finally:b.close()
+    return {'syntax_success':True,'observations':observations}
+
+
+def main():
+    r=json.loads(Path(sys.argv[1]).read_text())
+    if r.get('diagnostic'):
+        result={}
+        for lang,(_,cmd,run) in COMMANDS.items():
+            import shutil
+            result[lang]=bool(shutil.which(cmd[0]) and (run[0].startswith('./') or shutil.which(run[0])))
+        from playwright.sync_api import sync_playwright
+        with sync_playwright() as p:
+            b=p.chromium.launch();b.close()
+        result.update(html=True,css=True)
+        return {'runtimes':result}
+    return browser(r) if r['kind'] in ('html','css','dom') else program(r)
+
+if __name__=='__main__':
+    try:result=main()
+    except Exception as e:result={'infrastructure_error':type(e).__name__+': '+str(e)[:2000]}
+    print(json.dumps(result,allow_nan=False))

tests/test_core.py

@@ -0,0 +1,48 @@
+import ast
+import json
+from pathlib import Path
+import sys
+import unittest
+from unittest.mock import patch
+ROOT=Path(__file__).resolve().parents[1];sys.path.insert(0,str(ROOT))
+from evaluate import prompt
+from metrics import aggregate
+from runners.common import extract_code,compare_output,FunctionRunner,BrowserRunner
+from runners.sandbox import Sandbox,SandboxUnavailable
+from validators.dataset import load
+
+class CoreTests(unittest.TestCase):
+    def test_prompt_has_no_reference_or_tests(self):
+        row=load(ROOT/'data/smolscript.jsonl')[0];row['tests']=[{'input':'SECRET_TEST','expected':'SECRET_ANSWER'}];row['reference_solution']='SECRET_REFERENCE'
+        text=prompt(row)
+        for token in ('SECRET_TEST','SECRET_ANSWER','SECRET_REFERENCE'):self.assertNotIn(token,text)
+    def test_macro_not_micro(self):
+        rows=[{'id':str(i),'language':'python','passed':True,'syntax_success':True} for i in range(3)]
+        rows+=[{'id':'x','language':'rust','passed':False,'syntax_success':True}]
+        result=aggregate(rows,[r['id'] for r in rows],full_run=False)
+        self.assertEqual(result['filtered_macro_score'],50);self.assertEqual(result['micro_accuracy'],75)
+        self.assertNotIn('smolscript_score',result)
+    def test_incomplete_results_rejected(self):
+        with self.assertRaises(ValueError):aggregate([],['missing'])
+    def test_whitespace_observable_and_numeric_format(self):
+        self.assertTrue(compare_output('  a \n','  a '));self.assertFalse(compare_output('a\n',' a'))
+        self.assertTrue(compare_output('2.0\n',2));self.assertFalse(compare_output('NaN\n',2))
+    def test_extraction(self):
+        self.assertEqual(extract_code('```python\ndef solve(n): return n\n```'),'def solve(n): return n\n')
+        with self.assertRaises(ValueError):extract_code('```a\nx\n```\n```b\ny\n```')
+    def test_missing_engine_fails_closed(self):
+        with patch('runners.sandbox.shutil.which',return_value=None),self.assertRaises(SandboxUnavailable):Sandbox()
+    def test_python_reference_syntax(self):
+        ids={r['id'] for r in load(ROOT/'data/smolscript.jsonl') if r['language']=='python'}
+        for r in load(ROOT/'references/solutions.jsonl'):
+            if r['id'] in ids:ast.parse(r['reference_solution'])
+    def test_answers_not_sent_to_sandbox(self):
+        class Fake:
+            def run(self,payload,timeout):
+                self.payload=payload
+                return {'syntax_success':True,'observations':[{'exit_code':0,'timeout':False,'output_limit':False,'stdout':'9\n'}]}
+        fake=Fake();row={'language':'python','timeout_seconds':3,'metadata':{'family':'scalar'}}
+        result=FunctionRunner().evaluate(row,'def solve(n): return 9',{'tests':[{'input':3,'expected':9}]},fake)
+        self.assertTrue(result['passed']);self.assertNotIn('expected',json.dumps(fake.payload))
+
+if __name__=='__main__':unittest.main()

validate.py

@@ -0,0 +1,58 @@
+"""Validate structure, then run every reference and negative control in Docker."""
+import argparse
+import json
+from pathlib import Path
+from validators.dataset import check,load
+from runners import get_runner
+from runners.sandbox import Sandbox,SandboxUnavailable
+
+ROOT=Path(__file__).resolve().parent
+
+def main():
+    p=argparse.ArgumentParser();p.add_argument('--static-only',action='store_true');p.add_argument('--image',default='smolscript-runtime:0.1.0');p.add_argument('--engine',default='docker');p.add_argument('--output',type=Path,default=ROOT/'validation_report.json');a=p.parse_args()
+    report=check(ROOT);report['reference_execution']='unverified';report['negative_controls']='unverified'
+    try:
+        if a.static_only:
+            report['remaining']='All 2000 references and negative controls require sandbox execution.';return 0
+        sandbox=Sandbox(a.image,a.engine)
+        report['sandbox']=sandbox.identity
+        report['runtimes']=sandbox.run({'diagnostic':True},60)['runtimes']
+        if not all(report['runtimes'].values()):raise SandboxUnavailable('Missing language runtime')
+        hidden={r['id']:r for r in load(ROOT/'private_tests/hidden.jsonl')}
+        refs={r['id']:r['reference_solution'] for r in load(ROOT/'references/solutions.jsonl')}
+        results=[]
+        from generators.code import wrap
+        for row in load(ROOT/'data/smolscript.jsonl'):
+            rid=row['id'];runner=get_runner(row['language']);family=row['metadata']['family']
+            result=runner.evaluate(row,refs[rid],hidden[rid],sandbox)
+            if family in ('html','css'):wrong=''
+            elif family=='dom':wrong='function setup() {}'
+            else:
+                wrong=wrap(row['language'],family,[('return '+('"__wrong__"' if family=='string' else '-999999')+(';' if row['language'] not in ('python','lua') else ''))])
+            negative=runner.evaluate(row,wrong,hidden[rid],sandbox)
+            # Also reject a plausible near-miss: keep only the first composition
+            # stage, or remove the map/filter in collection tasks.
+            mutant=None
+            if family in ('scalar','string','array'):
+                from generators.code import render
+                spec=dict(hidden[rid]['spec'])
+                if family in ('scalar','string'):spec['steps']=spec['steps'][:1]
+                elif spec.get('map'):spec.pop('map')
+                else:spec['filter']='all' if spec['filter']!='all' else 'positive'
+                from generators.specs import oracle
+                if any(oracle(spec,t['input'])!=t['expected'] for t in hidden[rid]['tests']):
+                    mutant=runner.evaluate(row,render(row['language'],spec),hidden[rid],sandbox)
+            results.append({'id':rid,'reference_passed':result['passed'],'negative_rejected':not negative['passed'],
+                            'near_miss_rejected':not mutant['passed'] if mutant is not None else None})
+            report['execution_results']=results
+            if not result['passed'] or negative['passed'] or (mutant and mutant['passed']):
+                raise ValueError('Reference or negative control failed: '+rid)
+            if len(results)%25==0:
+                print(f'Validated {len(results)}/2000',flush=True);a.output.write_text(json.dumps(report,indent=2)+'\n')
+        report['reference_execution']='passed';report['negative_controls']='passed';return 0
+    except SandboxUnavailable as e:
+        report['blocked_reason']=str(e);report['unverified_languages']=['python','javascript','html','css','cpp','c','lua','csharp','rust'];print(str(e));return 2
+    except Exception as e:report['error']=str(e);raise
+    finally:a.output.write_text(json.dumps(report,indent=2)+'\n')
+
+if __name__=='__main__':raise SystemExit(main())

validation_report.json

@@ -0,0 +1,93 @@
+{
+  "static_validation": "passed",
+  "examples": 2000,
+  "languages": {
+    "python": 250,
+    "javascript": 250,
+    "html": 200,
+    "css": 200,
+    "cpp": 225,
+    "c": 225,
+    "lua": 200,
+    "csharp": 225,
+    "rust": 225
+  },
+  "difficulty": {
+    "easy": 1200,
+    "medium": 600,
+    "moderate": 200
+  },
+  "categories": {
+    "arithmetic_conditions": 492,
+    "strings": 468,
+    "collections_loops": 540,
+    "frequency_tables": 80,
+    "dom_events": 20,
+    "semantic_structure": 200,
+    "styles_layout": 200
+  },
+  "prompt_words": {
+    "min": 13,
+    "max": 38,
+    "over_50": 0
+  },
+  "solution_lines": {
+    "min": 1,
+    "max": 9
+  },
+  "exact_duplicates": 0,
+  "semantic_duplicates_within_language": 0,
+  "near_text_pairs": [
+    {
+      "a": "smolscript-python-0173",
+      "b": "smolscript-python-0188",
+      "trigram_jaccard": 0.8667
+    },
+    {
+      "a": "smolscript-javascript-0173",
+      "b": "smolscript-javascript-0188",
+      "trigram_jaccard": 0.8667
+    },
+    {
+      "a": "smolscript-cpp-0158",
+      "b": "smolscript-cpp-0173",
+      "trigram_jaccard": 0.8667
+    },
+    {
+      "a": "smolscript-c-0158",
+      "b": "smolscript-c-0173",
+      "trigram_jaccard": 0.8667
+    },
+    {
+      "a": "smolscript-lua-0143",
+      "b": "smolscript-lua-0158",
+      "trigram_jaccard": 0.8667
+    },
+    {
+      "a": "smolscript-csharp-0158",
+      "b": "smolscript-csharp-0173",
+      "trigram_jaccard": 0.8667
+    },
+    {
+      "a": "smolscript-rust-0158",
+      "b": "smolscript-rust-0173",
+      "trigram_jaccard": 0.8667
+    }
+  ],
+  "semantic_check_scope": "finite deterministic probes plus exact DSL/DOM/CSS spec equality; not a general equivalence proof",
+  "cross_language_policy": "Aligned original tasks intentionally recur across languages for comparable coverage.",
+  "reference_execution": "unverified",
+  "negative_controls": "unverified",
+  "blocked_reason": "docker is unavailable; install Docker/Podman and build sandbox/Dockerfile. No host fallback exists.",
+  "unverified_languages": [
+    "python",
+    "javascript",
+    "html",
+    "css",
+    "cpp",
+    "c",
+    "lua",
+    "csharp",
+    "rust"
+  ]
+}

validators/dataset.py

@@ -0,0 +1,69 @@
+"""Static checks are deliberately distinct from sandbox reference validation."""
+from collections import Counter,defaultdict
+import hashlib
+import json
+from pathlib import Path
+import re
+from generators.build import ALLOCATION
+from generators.specs import oracle,probes
+
+
+def load(path):
+    rows=[json.loads(x) for x in Path(path).read_text().splitlines() if x.strip()]
+    if len({r['id'] for r in rows})!=len(rows):raise ValueError('Duplicate IDs: '+str(path))
+    return rows
+
+
+def check(root):
+    rows=load(root/'data/smolscript.jsonl');hidden=load(root/'private_tests/hidden.jsonl');refs=load(root/'references/solutions.jsonl')
+    assert len(rows)==2000,'Expected exactly 2000 examples'
+    assert Counter(r['language'] for r in rows)=={k:sum(v) for k,v in ALLOCATION.items()},'Language allocation'
+    assert Counter(r['difficulty'] for r in rows)=={'easy':1200,'medium':600,'moderate':200},'Difficulty allocation'
+    assert {r['id'] for r in rows}=={r['id'] for r in hidden}=={r['id'] for r in refs},'Private/public ID mismatch'
+    assert len({r['prompt'] for r in rows})==2000,'Duplicate prompts'
+    hm={r['id']:r for r in hidden};rm={r['id']:r for r in refs}
+    hidden_behavior={};seen={};behavior={};categories=Counter();lengths=[];solutions=[];similarity=[]
+    by_language=defaultdict(list)
+    for r in rows:
+        rid=r['id'];spec=hm[rid]['spec'];kind=spec['kind'];categories[r['category']]+=1
+        assert r['reference_solution'] is None,'Public reference leakage'
+        assert 1<=r['timeout_seconds']<=10
+        assert r['difficulty'] in ('easy','medium','moderate')
+        assert r['output_format'] and r['prompt']
+        assert hm[rid]['tests'],'Missing hidden tests'
+        assert rm[rid]['reference_solution'].strip(),'Missing reference'
+        assert rm[rid]['reference_solution'] not in r['prompt'],'Reference in prompt'
+        lengths.append(len(r['prompt'].split()));solutions.append(len(rm[rid]['reference_solution'].splitlines()))
+        semantic=(r['language'],r['metadata']['semantic_id'])
+        assert semantic not in seen,('Duplicate semantic spec',rid,seen.get(semantic))
+        seen[semantic]=rid
+        # Input/output fingerprints catch algebraic identities in this bounded DSL.
+        if kind in ('scalar','string','array'):
+            fingerprint=(r['language'],kind,tuple(oracle(spec,x) for x in probes(kind)))
+            assert fingerprint not in behavior,('Equivalent behavior',rid,behavior.get(fingerprint))
+            behavior[fingerprint]=rid
+            suite_key=(r['language'],kind,tuple(t['expected'] for t in hm[rid]['tests']))
+            assert suite_key not in hidden_behavior,('Hidden-suite behavior collision',rid)
+            hidden_behavior[suite_key]=rid
+            for t in hm[rid]['tests']+r['tests']:
+                assert oracle(spec,t['input'])==t['expected'],('Oracle mismatch',rid)
+        normalized=re.sub(r'\d+','N',r['prompt'].lower())
+        words=normalized.split();grams={tuple(words[i:i+3]) for i in range(len(words)-2)}
+        for other,othergrams in by_language[r['language']]:
+            ratio=len(grams&othergrams)/max(1,len(grams|othergrams))
+            if ratio>=0.85:similarity.append({'a':other,'b':rid,'trigram_jaccard':round(ratio,4)})
+        by_language[r['language']].append((rid,grams))
+    # Near-text pairs are disclosed for review; no identical behavioral or semantic
+    # specifications are accepted. Translations across languages are intentional.
+    import pyarrow.parquet as pq
+    parquet=pq.read_table(root/'data/smolscript.parquet').to_pylist()
+    decoded=[{**r,'tests':json.loads(r['tests']),'metadata':json.loads(r['metadata'])} for r in parquet]
+    assert decoded==rows,'JSONL/Parquet mismatch'
+    manifest=json.loads((root/'manifest.json').read_text())
+    for name,digest in manifest['files'].items():assert hashlib.sha256((root/name).read_bytes()).hexdigest()==digest,('Hash mismatch',name)
+    return {'static_validation':'passed','examples':len(rows),'languages':dict(Counter(r['language'] for r in rows)),
+       'difficulty':dict(Counter(r['difficulty'] for r in rows)),'categories':dict(categories),
+       'prompt_words':{'min':min(lengths),'max':max(lengths),'over_50':sum(n>50 for n in lengths)},
+       'solution_lines':{'min':min(solutions),'max':max(solutions)},'exact_duplicates':0,'semantic_duplicates_within_language':0,
+       'near_text_pairs':similarity,'semantic_check_scope':'finite deterministic probes plus exact DSL/DOM/CSS spec equality; not a general equivalence proof',
+       'cross_language_policy':'Aligned original tasks intentionally recur across languages for comparable coverage.'}