Indexes, docs, examples and a stratified preview

LICENSE

@@ -0,0 +1,18 @@
+DeskForge-1M — licence not yet determined
+=========================================
+
+This dataset has NOT been assigned a licence and is NOT cleared for
+redistribution.
+
+The screenshots contain third-party material whose licensing has not been
+reviewed: application user interfaces (GTK applications such as HomeBank,
+Bluefish, Thunar, Chromium and others), icon themes, fonts, desktop wallpapers,
+and, in browser scenes, rendered third-party web pages captured on the date
+shown in the record.
+
+Until that review is complete and a licence is chosen, this repository is
+private and its contents must not be redistributed, mirrored or published.
+
+The annotation files, indexes and code in this repository are the work of the
+dataset author and will be licensed alongside the payload once the review is
+complete.

README.md

@@ -0,0 +1,168 @@
+---
+pretty_name: DeskForge-1M
+license: other
+license_name: license-pending-review
+task_categories:
+  - image-to-text
+  - object-detection
+language:
+  - en
+tags:
+  - gui
+  - screen-understanding
+  - computer-use
+  - accessibility
+  - webdataset
+size_categories:
+  - 1M<n<10M
+configs:
+  - config_name: preview
+    data_files:
+      - split: preview
+        path: demo/preview.parquet
+---
+
+# DeskForge-1M
+
+**1,207,368 annotated Linux desktop screenshots**, every visible element boxed
+from the accessibility tree, with occlusion resolved against the real window
+stack. 135,731 of the scenes are short click explorations, giving 917,211
+state–action–state transitions on top of the still images.
+
+The annotation is not a caption or a bounding box for one target. It is *every*
+element a person can see, with its class, its visible text, its modal geometry
+(the pixels it actually occupies) and its amodal geometry (where it would be if
+nothing covered it).
+
+## What is in it
+
+| split | scenes | episodes | observations | state-eligible | transitions | transition-eligible |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| `train` | 266,159 | 111,249 | 999,494 | 881,794 | 760,850 | 716,573 |
+| `val` | 2,938 | 1,284 | 11,279 | 10,081 | 8,667 | 8,147 |
+| `test_id` | 5,805 | 2,524 | 22,550 | 20,097 | 17,383 | 16,371 |
+| `test_app` | 11,512 | 6,553 | 43,206 | 39,884 | 32,848 | 29,934 |
+| `test_theme` | 15,390 | 5,586 | 51,627 | 46,730 | 38,671 | 35,636 |
+| `test_resolution` | 21,927 | 8,535 | 79,212 | 69,213 | 58,792 | 55,926 |
+| **total** | **323,731** | **135,731** | **1,207,368** | **1,067,799** | **917,211** | **862,587** |
+
+1,151 uncompressed WebDataset tars, 1.14 TB. 19 applications, 7 desktop themes,
+7 resolutions from 1366×768 to 3840×2160.
+
+**Two eligibility flags, and they are not the same thing.** `state_train_eligible`
+is the recommended filter for the still-image view: publishable, not a
+near-duplicate scene, not a no-op episode frame. `transition_train_eligible` is
+for the action view and **keeps no-op transitions** — a click that changed
+nothing is supervision, not a defect. A no-op frame is excluded from the states
+view while the transition that produced it is kept.
+
+## The evaluation splits are the contribution, not a convenience
+
+A single random test set answers one question — "does it work on data like the
+training data" — so three axes are held out of training **entirely**, not merely
+sampled out:
+
+| axis | held out | asks |
+| --- | --- | --- |
+| `test_app` | `gnome-system-monitor` | an application category never seen |
+| | `pluma`, `xarchiver` | an unseen *instance* of a category training knows |
+| `test_theme` | `quartz_night_nord` | unseen desktop chrome |
+| `test_resolution` | `retina_2880x1800` | unseen scale and aspect ratio |
+
+Holding out an application removes *every* scene containing it, not just the
+test scenes, computed over the union of applications across every frame of a
+scene. Verified zero leakage. See `docs/splits.md` for what each axis cost and
+why these were affordable.
+
+**Occlusion is deliberately not held out.** The corpus argues that this
+supervision improves occlusion robustness, and a model cannot learn that from
+data with the occlusion removed. Occlusion and window count are reported as
+slices of `test_id` instead. They are heavy: median occluded ratio 0.284, p90
+0.743, and more than half of all observations have ≥25% of their elements
+clipped or dropped.
+
+## Loading
+
+Payload is WebDataset; the indexes are Parquet. No custom loader script.
+
+```python
+import webdataset as wds
+url = "data/train/part-{00000..00903}.tar"
+ds = (wds.WebDataset(url, shardshuffle=True)
+        .decode("pil")
+        .to_tuple("png", "leaf.json", "screentag.txt", "record.json"))
+```
+
+Each observation is four members sharing one key:
+
+```
+<key>.png             the screenshot
+<key>.leaf.json       every visible element
+<key>.screentag.txt   the serialized markup a model is trained to emit
+<key>.record.json     sanitized metadata, and the action that produced this state
+```
+
+The tars are **uncompressed**, so `index/shard_members.parquet` gives a real
+byte offset and length for every member: one seek returns a PNG without reading
+the shard. `examples/` has three runnable loaders — streaming states, pairing
+transitions, and random access by key. `demo/preview.parquet` is a stratified
+sample with images inline for the Dataset Viewer.
+
+Filter before you stream, with Parquet:
+
+```python
+import pyarrow.parquet as pq
+obs = pq.read_table("index/observations/test_id.parquet")
+heavy = obs.filter(obs["occluded_ratio"] > 0.5)   # the degradation slice
+```
+
+## How it was made
+
+Xvfb + xfwm4 on Linux, real GTK applications driven headlessly. Annotations come
+from the AT-SPI2 accessibility tree, then are resolved against the window stack
+so a box describes what is *visible*, not what the tree claims. Generation is
+deterministic from a seed; the generating commit and the SHA-256 of both source
+manifests are in `release_provenance.json`, and `checksums/sha256sums.txt`
+covers every published file.
+
+Labels are **automatic**, not human. Quality is enforced by automated audits —
+element coverage against rendered pixels, blank-widget suppression, leaf/window
+ownership, fragment containment — and 59,103 observations that failed them are
+not in this release.
+
+## Actions: what they are and are not
+
+Episodes are **undirected random click explorations**. They are not expert
+demonstrations, not goal-conditioned trajectories, and carry no task
+instruction, reward or success label. The action space is **click only**.
+
+An action is stored on the step it *produced*:
+`observation[k-1] --steps[k].action--> observation[k]`. Pixel coordinates are
+authoritative; `_norm_1000` and `_screentag_500` are derived conveniences that
+round-trip within one grid cell.
+
+## Limitations
+
+One desktop environment (Xfce), synthetic themes imitating Windows/macOS/Linux
+rather than the real thing, click-only actions, no human verification, and
+window-control and window-ownership edge cases documented in
+`docs/known_issues.md`. Some scenes load live web pages, so a browser window
+shows whatever that site served on the capture date; the domain is recorded.
+Read `docs/known_issues.md` before using this for anything load-bearing.
+
+## Licence
+
+**Not yet determined — see `LICENSE`.** The screenshots contain third-party
+application UI, icon themes, fonts, wallpapers and rendered web pages, and that
+licensing has not been reviewed. Do not redistribute pending that review.
+
+## Citation
+
+```bibtex
+@misc{deskforge1m,
+  title  = {DeskForge-1M: dense desktop UI annotation with occlusion-resolved geometry},
+  author = {G\"urb\"uz, Said},
+  year   = {2026},
+  note   = {Version 1.0.0}
+}
+```

VERSION

@@ -0,0 +1 @@
+1.0.0

checksums/sha256sums.txt

@@ -0,0 +1,89 @@
+4f08b8a5ed9bd252f309daeda14447f7ab0f8c44dacce347873aa008144a9af2  data/test_app/part-00000.tar
+8b643efef0952d51a20ab08f2ed6a47bc27052f211442eb31c80eb5c3f169aa5  data/test_app/part-00001.tar
+8fc0f680a2cd92a1f2d9d7915fe997b543af1425f58ac6c3a415da523315cd75  data/test_app/part-00002.tar
+b49e98753a058decc24109488ee91d9364be6c05464a9a70366b31c064f0cb08  data/test_app/part-00003.tar
+93e2a07ad66bdcc9ff5f7102ec81e7ef7bc031595679f2642d32ff3cbc1bc3b8  data/test_app/part-00004.tar
+f2593eadb648f1543c823327735f539d29f934c3690aa6ef6a8a3527d2134e7f  data/test_app/part-00005.tar
+b2a3e15ffa72379e002fe0cca0b5923820e26b517bf9d13733446f5bafb10b0d  data/test_app/part-00006.tar
+6426e07a4d43eae67d4736a30604983ca48f95999069bee97f29c250782b7abf  data/test_app/part-00007.tar
+4d8bc3ed4a4c607bf1b7d3f05a400776728cdce294d021fda484c9b221c5c9d6  data/test_app/part-00008.tar
+3ede4a44e0cf938c41b06a17c9efd62c4252f6b6ead3d38c46c8e3890440426a  data/test_app/part-00009.tar
+611d4c0b8100cf594b9f624391b3484e0f5c05d7cfcc12f12105a9098583811e  data/test_id/part-00000.tar
+c70e0c5dc6612415740043ec9f2dca2a1e8c7992dc375045ff4d27e4c93ea39a  data/test_id/part-00001.tar
+202ff968ec91330bc11f69ebcb85a0e0af39ac9633d79ec068f6e3f2f632b284  data/test_id/part-00002.tar
+23867573b863945aef9d4b37a62c100397d1f5c660dbe2f84db6b2503c73fe1f  data/test_id/part-00003.tar
+bc402554641fcff327dd38107b744e23039ebddb9879d9470904c781350a336c  data/test_id/part-00004.tar
+084972e98a236b04e7f520ab10ac1950ba8ac60b25487e7d4c3a709a614d7c61  data/test_id/part-00005.tar
+020a34c42f41847c4f83442f51cf71a729e4ea1f142ef93115ce4c1fae6107d5  data/test_id/part-00006.tar
+e0d1472c0732eb451e856f8521985741a402055f04d0afe8df7dbc8c238af9fa  data/test_id/part-00007.tar
+97a478724d7ec38e196e5f3c4972673801ffbf6232c558c9bd36b399816f0515  data/test_id/part-00008.tar
+36abba52591135b07acec42a0d1cba59cab65896cf80a8740045835a69973906  data/test_id/part-00009.tar
+bf12c7cb31db84b47681601209c709447f84c65b257bfeb8271100297099728d  data/test_resolution/part-00000.tar
+0670fd76c209fa52da0e3c675d5409b3841612c44455e9408ce4e8e5ff21eb52  data/test_resolution/part-00001.tar
+2b2ebd6de8858884d8c775e664712b3cf63c32beca4c7a3eea4c8baede3520ef  data/test_resolution/part-00002.tar
+bae3d46c256fa5df5d90b172003ba1f2833dd43743e8fb59bbdeabe11980e5ce  data/test_resolution/part-00003.tar
+f7806c28465306c7ca6f25026dedbfbaab56dd8dc31a5aa916f84d876158b0c2  data/test_resolution/part-00004.tar
+522b1315151263fb44b394e96c89d2953a890e32c44b5f69973a8972a9eced59  data/test_resolution/part-00005.tar
+01e06f6f2545b420b944ec1d6497ab15ec9cf0225b2bd25a71a562894415adb4  data/test_resolution/part-00006.tar
+12fb986d9e49194bc6f351f2d397bbc03fda6420a5f4cdddae09c9a6aca4291c  data/test_resolution/part-00007.tar
+236610a23815010ab19f7da3f768d9520b1a9f6f6c58e1c30433558eb48438ac  data/test_resolution/part-00008.tar
+7c1cbaf468da13efcb7baa1ecd7fbdfd7aa25e99461a0f48c2b675c98ea33eac  data/test_resolution/part-00009.tar
+02755b0324d2431cb3069624a6e11d97b67ff3cb2d0a46253a26cd5cf120b6e9  data/test_theme/part-00000.tar
+de355eb73f087c87f5bbe31d2fe4ac2b99989d68e00ea2b3c474bb17e4fe76cb  data/test_theme/part-00001.tar
+d20382b11dc19af42f735a6ff7cfb0065e5b8cd05bab9b4f079fc14439d9a238  data/test_theme/part-00002.tar
+b93eb37b8b5367b234728a1e0a500241319da38c4729e6ef93ccbee56aa3393a  data/test_theme/part-00003.tar
+2f7f1f8bb0caace3f422bce964d90f546c7e12a27ff09ee46bcea7b97fc3a288  data/test_theme/part-00004.tar
+2d1af4780b4c662a7a70c77f94d143c0ec193fbecf8cfed3adf0fd28701c3a02  data/test_theme/part-00005.tar
+2c994c78af44000ee0c165a6363cf4686fd84dcf0a4b72881659acf3ec218fe2  data/test_theme/part-00006.tar
+99a4ed842df961670acbd1d85bb2a87a12fb88e0343a474f1b50988b94e271b6  data/test_theme/part-00007.tar
+7b871d22d607386349aa3b27ffdef02bbfdcd1dcb245fc7ccbe8fd88c1aa058f  data/test_theme/part-00008.tar
+fe290747f2d9c4500cbbf0503a48b10161caec0158165f5f6bdca87649ab925a  data/test_theme/part-00009.tar
+b8d1397d0010e9f77ddeb4c1df23a99849eae7094f069e8f058aa0d3e19b0040  data/train/part-00000.tar
+7ebaf46701ad91565e36fa7b1f4b172c36e6ddb41adccb4c6279d3ac02af084d  data/train/part-00001.tar
+a93d0648beed4fbb88d6148487d8da06cf361d8b2432795e9ef729c9eb8a9a9d  data/train/part-00002.tar
+fcd0593fcb0f9bb1cf9ea58e78451d5a8669adbfcd3798303df549af89ce298e  data/train/part-00003.tar
+4abdc9b542fabeb4872b0fb84f025d162e51c482fb3e11949877fcc59d2d51b1  data/train/part-00004.tar
+e4e9af81485739b22aab768c695170566719d7a989565e56ab2f62e97ce328ad  data/train/part-00005.tar
+213dff2c60f0831fb6a78ca9aec05f9d31658e1709cfd375fb30918bb30d5fdc  data/train/part-00006.tar
+65da20b849e7a7f9f6414cab5507e449bc4ea7fa978632deef147b21aa745c10  data/train/part-00007.tar
+5b3e81858911f33fa87bdabd48eb0b0fc7e2473041da6cbb36ae9602e4b3113b  data/train/part-00008.tar
+376eb6dd5bab44c2edb2f72ec75f5fa11bd605036700eb9065fd4d5213213c0d  data/train/part-00009.tar
+7b9202c735a381360b325c4c351abb9f13cfa6a4e310bef0caca97d57fa1f3ef  data/val/part-00000.tar
+ff710b133c9bca152622beeb1032713d04200f525011da4c75683429af01bb30  data/val/part-00001.tar
+c1ad358b232188fcc18173905f7c4ee6b33edf1ad29824e0dac1935c38e2d206  data/val/part-00002.tar
+e3a102e11473ccfa66b2b467d85f9eaebe0f6b6c020de1c1c1ddb783e12969af  data/val/part-00003.tar
+c8ebaf13425a3b25e25a2c7085e3ee3aaccd1856bdc65c660b4636757ce41c47  data/val/part-00004.tar
+6a22f41f1aa067a18969d1daa3d3da11b7a71067962b004c4a52ea0d77487b71  data/val/part-00005.tar
+0dd3a3631ac9675867d2f7876e633a17a195bbb6447c2be4414d20b18fc04a50  data/val/part-00006.tar
+e57fd6a18f21656ebc7a084295cd38683ee89971c89b3f67ee90f3981c69f879  data/val/part-00007.tar
+5481483852f57ca6f6d5ad07bdebf46ca9ab0982d827ba0106d44e6e9055fef6  data/val/part-00008.tar
+63c97b087a54c529704f566d6619ff7398affca71715ae024084aa48e0ef5e13  data/val/part-00009.tar
+59854984853104df5c353e2f681a15fc7924742f9a2e468c29af248dce45ce03  VERSION
+c5bfedd25a7fc6d336932f19cef031747e2c295300a7006d71e9cd9bc0f6fc3f  checksums/shard_stats.parquet
+6c352adde8f23e13667487fc29c4a1c7bd972b4f2926646e5a82d1e59f22bdae  demo/preview.parquet
+6c652d39ec12c3ada1c06626437fb49934e05f581ff7e3ee140b3f4a02b7bf43  examples/_common.py
+f08b92547613e86ffadfa22decfc96090f0f6919364f94524aa533e1820c77be  examples/get_by_key.py
+9cbcbb33ad9257ef3cf705138781287b2cb3dccf99c61619a44fcab0ef9c1007  examples/stream_states.py
+38f0d95ee4c025c4e638219e4e03f8b913313818e9d776ad143946ae2ea34c75  examples/stream_transitions.py
+f45da944b03544bd4a61ee4ed57779746083fa487f48146b5c8761dc9c2d9e7e  index/episodes/test_app.parquet
+b5a4a6be6018c3bff85503c59a5077f7d4f3a995b22715df7d57a741fd32cf28  index/episodes/test_id.parquet
+ea701bf2b1fc18f9c28b97ea0f296e623123051dc66346bfcca5c80a19d66f5e  index/episodes/test_resolution.parquet
+1a3aa2a94d138fe19a3d10e8debfb936587217a9c2a6190d32061229dcb9bff6  index/episodes/test_theme.parquet
+14d1458a6d86e8f3ae2782a064a7818e3873786f302e517603ccb3ad0531e7bf  index/episodes/train.parquet
+30c7c147443abb8c52fa71201da43cb8ca6fcfe26fe0ab61d2388df3950a59b3  index/episodes/val.parquet
+27e04f4649660ae819a11df88d2851b9dd05d16a1169670aaac7d3e4b53e387b  index/observations/test_app.parquet
+d03fedcc42c65679af648b65cb8a6eabf15a60bbed9bb38e1e7339b5975af8e6  index/observations/test_id.parquet
+fc28efc2ba757e643e07c55f13be723e4191e8d7e7e54c26f911176e2c4e31ef  index/observations/test_resolution.parquet
+8203c7aa6ce4c724352edfbd69ab0968e9bd6a9ad12a5af57d9414143842b2ca  index/observations/test_theme.parquet
+bfb412bb219563b5d9cd2111d978b1e23afb9dd1d64ee3ce86a28b71482355b7  index/observations/train.parquet
+c7907feb1e130394e163ba77077a9f24285bac17742401c1dc2dfef635fd5254  index/observations/val.parquet
+b57dd0b6fe010834f73be43d41308e2bc9c68ed89d76998c423474a67aca4ae5  index/scenes.parquet
+3b7ee57c9e0a21cf7138e14579fbc5d928ddfa9e4f232b0ed8598bbeb7b00c25  index/shard_members.parquet
+e48fdac9ad177bed1bc034699023a14f55913fc35b1f9a748b900b97d2e70905  index/transitions/test_app.parquet
+cdea6f6761c78e8b9c7a5c636a257c407130a962b0852bfe36c25c5d66853de3  index/transitions/test_id.parquet
+f5f4f495e70aecbb5cdbb140f04b179115ec990dbd8a6018e52dbd4573fb1cfa  index/transitions/test_resolution.parquet
+a7113cf0a2ae6845cbef9a11edac525a3c14cbace7f187b9b5796669fb8bdd5f  index/transitions/test_theme.parquet
+cb29a1f4c5c86870e733f3e798d2f0d2012b83c5d00c9c335285f8625fda9092  index/transitions/train.parquet
+4641f1fbf37eb50c33a3c88badad05748e6e6e704ade248bf7d9284e201a388e  index/transitions/val.parquet
+fd2e125df43fa9fa6a431682c63f1422d8f39f5b5b3a7a51543f0ac1c71e4b75  release_provenance.json
+38e1898434846e1bb6383c1ee7c847cb4f16223d2773e626e59942026518b989  release_report.json

checksums/shard_stats.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5bfedd25a7fc6d336932f19cef031747e2c295300a7006d71e9cd9bc0f6fc3f
+size 5368

demo/preview.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c352adde8f23e13667487fc29c4a1c7bd972b4f2926646e5a82d1e59f22bdae
+size 3356769928

docs/known_issues.md

@@ -0,0 +1,80 @@
+# Known issues
+
+Read this before using DeskForge-1M for anything load-bearing. Everything here
+is measured, not suspected.
+
+## Text visible in the screenshots
+
+The annotation quotes what is on screen, so anything painted into a window title
+or a widget label is in `leaf.json`, in the ScreenTag and in the pixels. These
+were found by scanning the packed payload and are **not** removed, because
+rewriting them would make the annotation disagree with its own image.
+
+| what | how often | what it is |
+| --- | --- | --- |
+| `/tmp/session-<random>/` | 32.8% of captures | the ephemeral session root of the generating job, in file-chooser paths and window titles |
+| synthetic persona homes, e.g. `/Users/anika/`, `/home/kwame/` | 32.5% | **generated** persona names, not real people |
+| `ess6000-1` | 9.8% | the host name of the generating machine, surfaced as an AT-SPI label |
+| the dataset author's contact details | see below | `Said.Gurbuz@ibm.com;7G5620848;Said Gürbüz`, captured into a document fixture and therefore painted into those screenshots |
+
+Scanned over 600 random captures for the first three. **No real project path
+(`/proj/...`), no real home directory, and no third party's personal data
+appears anywhere in the released text.** The author's own contact string is the
+one piece of real personal data, it belongs to the dataset's author, and it is
+disclosed here rather than removed because it is in the pixels.
+
+Downstream filtering on these strings is straightforward: they are exact and
+they are in the text members, not only the images.
+
+## Live web pages
+
+Some scenes drive a real Chromium against a real URL, so a browser window shows
+whatever that site served on the capture date. The domain is recorded, the page
+content is not curated, and it may include news text, advertising or images
+belonging to third parties. This is the main reason the licence is unresolved.
+
+## Annotation
+
+* **Labels are automatic.** They come from the AT-SPI2 accessibility tree and
+  automated refinement, with no human verification pass. An application that
+  reports its own tree badly is annotated badly.
+* **Toggle state is invisible on this stack.** AT-SPI 2.40.3 does not expose
+  `checkable`/`checked` for menu items here, so a checked menu item is not
+  distinguishable from an unchecked one in the annotation.
+* **Window controls** (close/minimise/maximise) are synthesised from the title
+  bar rather than read from the tree, and are the least reliable class.
+* **Window ownership** of popups and menus is resolved through the window stack.
+  2.64% of leaf elements legitimately fall outside their owning window's
+  rectangle; a containment rule that "fixed" this would delete real menus.
+* **59,103 observations failed the automated audits** and are not published.
+  The reasons, in order of frequency: leaf/window ownership, visible-fragment
+  containment, missing fragments, too few elements, too little type diversity,
+  shallow trees, missing elements, low coverage.
+
+## Episodes
+
+* **994 episodes have no `episode.json`** and 6 have a truncated one, spread
+  over 183 shards, because the generating job died before writing it. Their
+  screenshots are fine and are published; they contribute **no transitions**.
+  They carry `episode_status` of `no_episode_json` or `episode_json_truncated`
+  and `n_transitions = 0`.
+* Actions are **click only**, and episodes are undirected random exploration
+  with no goal, instruction or reward.
+* 14.3% of eligible transitions changed nothing. That is intentional and they
+  are kept; see `transition_train_eligible` against `state_train_eligible`.
+
+## Duplication
+
+* 22,082 observations belong to **near-duplicate scenes** and 124,261 are no-op
+  episode frames. Both are published and both are excluded from
+  `state_train_eligible`.
+* 128 scene ids appear in two shards, because a scene a run failed to finish was
+  recaptured by a later run under the same seed. Both copies are published and
+  **both are in the same split**; keys and episode ids are shard-qualified so
+  they never collide.
+
+## Coverage
+
+One desktop environment (Xfce on Xvfb). The Windows-like and macOS-like themes
+are GTK themes imitating those systems, not those systems. 19 applications, all
+GTK/Linux desktop software. Nothing here is a mobile or web-only interface.

docs/schema.md

@@ -0,0 +1,101 @@
+# Schema
+
+## Payload — one observation, four tar members
+
+The tars are **uncompressed**, members of one observation are **consecutive**,
+and the key is everything before the first `.` in a member name. Keys contain no
+dots.
+
+```
+<key>.png             screenshot, PNG, never re-encoded
+<key>.leaf.json       list of visible elements
+<key>.screentag.txt   serialized markup
+<key>.record.json     sanitized metadata
+```
+
+`<key>` is `<shard>__<stem>`, e.g. `shard-0106__scene-002ad3e5b23cbfd9-step00`.
+It is shard-qualified because 152 capture stems and 128 scene ids repeat across
+shards — a scene a run failed to finish was recaptured by a later run under the
+same seed. `(shard, stem)` is unique across all 1,266,471 source rows.
+
+## `leaf.json` — an element
+
+```jsonc
+{
+  "type": "Button",                 // release class, 55 in the schema
+  "role": "push button",            // AT-SPI role it came from
+  "name": "Save",
+  "visible_text": "Save",           // text a reader can actually see
+  "visible_text_status": "visible",
+  "rect":  {"x": 312, "y": 88, "w": 64, "h": 28},   // amodal: the whole element
+  "visible_fragments": [                             // modal: pixels it occupies
+    {"x": 312, "y": 88, "w": 40, "h": 28}
+  ],
+  "is_occluded": true,
+  "occlusion_state": "partially_occluded",
+  "app_name": "homebank",
+  "reading_order_index": 41,
+  "_window_stack_index": 2,
+  "uid": "80b06ebf5db974e2"         // stable within an episode; action targets use it
+}
+```
+
+**`rect` is amodal and `visible_fragments` is modal.** A box drawn from `rect`
+alone claims pixels another window is covering. Train grounding on the
+fragments; use `rect` when the question is where the whole element *is*.
+
+## `screentag.txt`
+
+One flat string per screenshot: `<Tag><loc_N>×4 [state] [text]</Tag>`, nested
+to mirror the element tree. Coordinates are on a **0–500** grid, normalized to
+the viewport (`record["screentag_grid"]`).
+
+## `record.json`
+
+Constructed field by field from an allow list, never by removing fields from
+`meta.json`, so a change to the generator cannot quietly widen what is
+published. Carries `observation_key`, `scene_id`, `episode_id`, `step_index`,
+`split`, `group`, `width`, `height`, `apps`, `theme`, `scene`, `n_elements`,
+`n_windows`, `window_stack`, `occlusion`, `flags`, `provenance`, and — on any
+observation that an action led to — `action_into_this_state` and
+`effect_of_that_action`.
+
+`group` is `ep` for a frame of a click episode and `st` for a standalone scene.
+
+## Indexes
+
+| file | one row per | notable columns |
+| --- | --- | --- |
+| `index/scenes.parquet` | scene | `split`, `split_source`, `apps`, `theme`, `resolution` |
+| `index/observations/<split>.parquet` | observation | `tar_path`, `*_member`, `occluded_ratio`, `n_elements`, `n_windows`, the flags |
+| `index/transitions/<split>.parquet` | transition | `before_key`, `after_key`, action fields, `effect`, `exclusion_reasons` |
+| `index/episodes/<split>.parquet` | episode | `observation_keys`, `transition_ids`, `episode_status` |
+| `index/shard_members.parquet` | tar member | `byte_offset`, `byte_size`, `sha256` |
+| `checksums/shard_stats.parquet` | tar | `bytes`, `sha256`, `observations` |
+
+`split_source` is `v3` for a scene placed by the finalized split and `extended`
+for one that split never had to place — 12,515 scenes, all of which are
+publishable but not state-train-eligible, so they had no row in it.
+
+## Transitions
+
+An action is stored on the step it **produced**:
+
+```
+observation[k-1]  --  steps[k].action  -->  observation[k]
+```
+
+Step 0 has no action. Reading it the other way pairs every action with the
+screen it was not taken on, and nothing downstream would notice.
+
+Coordinates: `action_point_px` is authoritative. `action_point_norm_1000` and
+`action_point_screentag_500` are derived and round-trip to within one grid cell;
+`action_target_bbox_px` is `[x0, y0, x1, y1]`.
+
+`effect` counts what changed between the endpoints — `changed`, `magnitude`,
+`appeared`, `disappeared`, `moved`, `text_changed`, `state_changed`,
+`newly_occluded`, `revealed`, `semantic_changes`, `persisted`.
+
+`exclusion_reasons` is empty when `transition_train_eligible` is true and
+otherwise names every rule the transition failed, so a count can always be
+accounted for.

docs/splits.md

@@ -0,0 +1,69 @@
+# Splits
+
+The unit is the **scene**, never a frame: an episode's frames differ by one
+click, so splitting them apart tests memorisation.
+
+## What is held out, and what it cost
+
+A held-out split is not a dial. Its size is the footprint of the attribute,
+because a valid "unseen X" claim needs *every* scene containing X out of
+training — not only the scenes you want to test on.
+
+| axis | held out | observations | asks |
+| --- | --- | ---: | --- |
+| `test_app` | `gnome-system-monitor` | 11,350 | an unseen *category* |
+| | `pluma` | 15,733 | an unseen *instance* beside three seen text editors |
+| | `xarchiver` | 15,221 | an unseen *instance* beside file-roller |
+| `test_theme` | `quartz_night_nord` | 46,730 | unseen desktop chrome |
+| `test_resolution` | `retina_2880x1800` | 69,213 | unseen scale and aspect ratio |
+
+`eog` was a fourth candidate — the unseen category "image viewer". It is not
+held out: it appears in 109,454 observations against 11,352 for
+`gnome-system-monitor`, and both answer the same question. Dropping it returned
+94,326 observations to training and gave up no claim the design still makes.
+
+`retina_2880x1800` is **not** the cheapest resolution — `uhd_3840x2160` is, at
+4.83% against 7.06%. UHD is the densest supervision in the corpus, with the
+smallest text and the most elements per screen, and training needs it more than
+the split does. Of the candidates that leave UHD in training, 2880×1800 is both
+the cheapest and the sharper test: it is one of only two 16:10 resolutions, so
+holding it out leaves training a single 16:10 scale.
+
+## Zero leakage, and how it is checked
+
+Over the **union of applications across every frame of a scene**. One capture of
+a scene can miss an application another capture of it saw; keying on a single
+frame is exactly how three held-out applications leaked into train in an earlier
+build. The union is taken over *publishable* frames only, since a frame the
+release drops cannot leak — one scene turned on that distinction, where the
+held-out application launched only in a copy that failed quality checks.
+
+`scripts/verify_hf_release.py` re-checks this against the packed payload and
+fails the release if any held-out attribute reaches `train`.
+
+## Scenes the finalized split never placed
+
+`splits_v3.jsonl` covers the 1,067,799 state-train-eligible observations. This
+release carries every *publishable* observation, 1,207,368, so 12,515 scenes
+needed a split it never assigned. They get one from the same rules in the same
+priority (`test_app`, then `test_theme`, then `test_resolution`, else `train`),
+and every existing v3 assignment is preserved exactly — verified per split.
+
+`val` and `test_id` are **never** enlarged. They are a finalized random sample;
+growing them after the fact would change what a number measured against them
+means.
+
+## Occlusion is a reporting axis, not a split
+
+Holding out occluded scenes would remove the capability the corpus exists to
+demonstrate. Report it as a degradation curve over `test_id` instead:
+
+| occluded ratio | share of observations |
+| --- | ---: |
+| none | 2.3% |
+| 0–10% | 15.6% |
+| 10–25% | 27.5% |
+| 25%+ | 54.6% |
+
+Median 0.284, p90 0.743, p99 0.930. Window count is available as `n_windows` for
+the same purpose.

examples/_common.py

@@ -0,0 +1,81 @@
+"""Shared bits: iterate a WebDataset tar with or without the library.
+
+The canonical shards are ordinary uncompressed tars, so `webdataset` is a
+convenience and not a requirement. These examples use it when it is installed
+and fall back to eighty lines of `tarfile` when it is not, which is also the
+clearest statement of what the format actually is.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import tarfile
+from pathlib import Path
+from typing import Any, Dict, Iterator, List
+
+#: The four members every observation carries, keyed by the part of the member
+#: name after the first dot.
+EXTENSIONS = ("png", "leaf.json", "screentag.txt", "record.json")
+
+
+def iter_tar(path) -> Iterator[Dict[str, Any]]:
+    """Yield one dict per observation from one shard, in stored order.
+
+    Members of a sample are written consecutively, so grouping is a matter of
+    watching the key change - no buffering of the whole shard.
+    """
+    current_key = None
+    sample: Dict[str, Any] = {}
+    with tarfile.open(str(path), "r:") as tar:
+        for member in tar:
+            if not member.isfile():
+                continue
+            key, _, extension = member.name.partition(".")
+            if key != current_key:
+                if sample:
+                    yield sample
+                current_key, sample = key, {"__key__": key}
+            handle = tar.extractfile(member)
+            if handle is None:
+                continue
+            sample[extension] = handle.read()
+    if sample:
+        yield sample
+
+
+def decode(sample: Dict[str, Any], with_image: bool = True) -> Dict[str, Any]:
+    """Bytes to usable objects. The PNG is decoded only if asked for."""
+    out: Dict[str, Any] = {"key": sample["__key__"]}
+    if "record.json" in sample:
+        out["record"] = json.loads(sample["record.json"])
+    if "leaf.json" in sample:
+        out["elements"] = json.loads(sample["leaf.json"])
+    if "screentag.txt" in sample:
+        out["screentag"] = sample["screentag.txt"].decode("utf-8")
+    if with_image and "png" in sample:
+        from PIL import Image
+        out["image"] = Image.open(io.BytesIO(sample["png"]))
+    return out
+
+
+def shards_for(root, split: str) -> List[Path]:
+    return sorted(Path(root).joinpath("data", split).glob("*.tar"))
+
+
+def shards_for_rank(root, split: str, rank: int = 0, world_size: int = 1,
+                    worker: int = 0, num_workers: int = 1) -> List[Path]:
+    """Partition shards so no two readers touch the same file.
+
+    Sharding by file, not by sample, is what keeps a distributed run from
+    reading everything `world_size` times. Every rank must get the same number
+    of shards or the epoch never ends on the short ranks; the tail is dropped.
+    """
+    shards = shards_for(root, split)
+    per_reader = len(shards) // max(1, world_size * num_workers)
+    if per_reader == 0:
+        raise ValueError(
+            "%d shards cannot feed %d readers; lower world_size or num_workers"
+            % (len(shards), world_size * num_workers))
+    index = rank * num_workers + worker
+    return shards[index * per_reader:(index + 1) * per_reader]

examples/get_by_key.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+"""Fetch one observation by key, without reading the shard that holds it.
+
+    python examples/get_by_key.py --root . --key shard-0106__scene-002ad3e5b23cbfd9-step00
+
+`index/shard_members.parquet` carries a byte offset and length for every
+member. The canonical shards are **uncompressed** tars, so those offsets are
+real file positions: one seek and one read returns the PNG, whether the file is
+local or behind an HTTP range request.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--root", default=".")
+    ap.add_argument("--key", required=True)
+    ap.add_argument("--kind", default="record",
+                    choices=["image", "leaf", "screentag", "record"])
+    ap.add_argument("--out", default=None, help="write the bytes here")
+    args = ap.parse_args()
+
+    root = Path(args.root)
+    members = pq.read_table(root / "index" / "shard_members.parquet")
+    rows = members.filter(
+        pc.and_(pc.equal(members["observation_key"], args.key),
+                pc.equal(members["kind"], args.kind))).to_pydict()
+    if not rows["observation_key"]:
+        print("no member %r for key %r" % (args.kind, args.key), file=sys.stderr)
+        return 1
+
+    tar_path = root / rows["tar_path"][0]
+    offset, size = rows["byte_offset"][0], rows["byte_size"][0]
+    with tar_path.open("rb") as handle:
+        handle.seek(offset)
+        blob = handle.read(size)
+
+    print("%s  %s  %d bytes at offset %d in %s"
+          % (args.key, args.kind, size, offset, rows["tar_path"][0]))
+    if args.out:
+        Path(args.out).write_bytes(blob)
+        print("wrote %s" % args.out)
+    elif args.kind == "record":
+        print(json.dumps(json.loads(blob), indent=2)[:1200])
+    elif args.kind == "screentag":
+        print(blob.decode("utf-8")[:600])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examples/stream_states.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+"""Stream the States view: a screenshot and its dense annotation.
+
+    python examples/stream_states.py --root . --split train --limit 2000
+
+The recommended training filter is `record["flags"]["state_train_eligible"]`,
+which drops near-duplicate scenes and no-op episode frames. Every publishable
+observation is in the payload, so an evaluation that wants them can have them.
+
+With `webdataset` installed the same thing is four lines:
+
+    import webdataset as wds
+    url = "data/train/part-{00000..00903}.tar"
+    dataset = (wds.WebDataset(url, shardshuffle=True)
+                 .decode("pil")
+                 .to_tuple("png", "leaf.json", "screentag.txt", "record.json"))
+"""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from _common import decode, iter_tar, shards_for  # noqa: E402
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--root", default=".")
+    ap.add_argument("--split", default="train")
+    ap.add_argument("--limit", type=int, default=2000)
+    ap.add_argument("--eligible-only", action="store_true",
+                    help="the recommended training filter")
+    ap.add_argument("--decode-images", action="store_true")
+    args = ap.parse_args()
+
+    shards = shards_for(args.root, args.split)
+    if not shards:
+        print("no shards under %s/data/%s" % (args.root, args.split), file=sys.stderr)
+        return 1
+
+    seen = kept = 0
+    elements = 0
+    apps: collections.Counter = collections.Counter()
+    started = time.time()
+    for shard in shards:
+        for sample in iter_tar(shard):
+            seen += 1
+            item = decode(sample, with_image=args.decode_images)
+            record = item["record"]
+            if args.eligible_only and not record["flags"]["state_train_eligible"]:
+                continue
+            kept += 1
+            elements += len(item["elements"])
+            apps.update(record["apps"])
+            if kept >= args.limit:
+                break
+        if kept >= args.limit:
+            break
+
+    seconds = time.time() - started
+    print("%s samples read, %s kept in %.1fs  (%.0f samples/s)"
+          % ("{:,}".format(seen), "{:,}".format(kept), seconds, kept / max(seconds, 1e-9)))
+    print("mean elements per sample: %.1f" % (elements / max(kept, 1)))
+    print("applications: %s" % ", ".join("%s %d" % pair for pair in apps.most_common(8)))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examples/stream_transitions.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+"""Stream the Transitions view: before, action, after.
+
+    python examples/stream_transitions.py --root . --split train --limit 2000
+
+A screenshot is stored **once**. A transition names its two endpoints by key,
+so the loader pairs them; it never stores both images in a row. Because a whole
+episode is packed into one shard, both endpoints of every transition are in the
+shard already open - pair first, then shuffle at sample level, and the pairing
+costs no extra I/O.
+
+`transition_train_eligible` is not the same flag as `state_train_eligible`. A
+transition whose action changed nothing is **kept** - it is negative
+supervision - while the resulting state is excluded from the States view.
+"""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import sys
+import time
+from pathlib import Path
+
+import pyarrow.parquet as pq
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from _common import decode, iter_tar, shards_for  # noqa: E402
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--root", default=".")
+    ap.add_argument("--split", default="train")
+    ap.add_argument("--limit", type=int, default=2000)
+    ap.add_argument("--eligible-only", action="store_true", default=True)
+    ap.add_argument("--decode-images", action="store_true")
+    args = ap.parse_args()
+
+    root = Path(args.root)
+    table = pq.read_table(
+        root / "index" / "transitions" / ("%s.parquet" % args.split),
+        columns=["before_key", "after_key", "action_type", "action_point_px",
+                 "action_target_role", "action_target_text", "effect",
+                 "transition_train_eligible"]).to_pydict()
+    by_before: dict = collections.defaultdict(list)
+    for index, before in enumerate(table["before_key"]):
+        if args.eligible_only and not table["transition_train_eligible"][index]:
+            continue
+        by_before[before].append(index)
+    print("%s eligible transitions in %s" % ("{:,}".format(sum(
+        len(v) for v in by_before.values())), args.split))
+
+    pairs = 0
+    changed = 0
+    roles: collections.Counter = collections.Counter()
+    started = time.time()
+    for shard in shards_for(root, args.split):
+        # One pass per shard: hold only the states this shard's transitions need.
+        held: dict = {}
+        wanted_after: dict = collections.defaultdict(list)
+        for sample in iter_tar(shard):
+            key = sample["__key__"]
+            item = decode(sample, with_image=args.decode_images)
+            if key in by_before:
+                held[key] = item
+                for index in by_before[key]:
+                    wanted_after[table["after_key"][index]].append((key, index))
+            for before_key, index in wanted_after.pop(key, []):
+                before = held.get(before_key)
+                if before is None:
+                    continue
+                pairs += 1
+                changed += bool(table["effect"][index]["changed"])
+                roles[table["action_target_role"][index]] += 1
+                if pairs >= args.limit:
+                    break
+            if pairs >= args.limit:
+                break
+        if pairs >= args.limit:
+            break
+
+    seconds = time.time() - started
+    print("%s transitions paired in %.1fs  (%.0f/s)"
+          % ("{:,}".format(pairs), seconds, pairs / max(seconds, 1e-9)))
+    print("changed something: %.1f%%   no-op: %.1f%%"
+          % (100.0 * changed / max(pairs, 1), 100.0 * (pairs - changed) / max(pairs, 1)))
+    print("clicked roles: %s" % ", ".join("%s %d" % pair for pair in roles.most_common(8)))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

index/episodes/test_app.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f45da944b03544bd4a61ee4ed57779746083fa487f48146b5c8761dc9c2d9e7e
+size 494765

index/episodes/test_id.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5a4a6be6018c3bff85503c59a5077f7d4f3a995b22715df7d57a741fd32cf28
+size 238274

index/episodes/test_resolution.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea701bf2b1fc18f9c28b97ea0f296e623123051dc66346bfcca5c80a19d66f5e
+size 656552

index/episodes/test_theme.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a3aa2a94d138fe19a3d10e8debfb936587217a9c2a6190d32061229dcb9bff6
+size 462452

index/episodes/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14d1458a6d86e8f3ae2782a064a7818e3873786f302e517603ccb3ad0531e7bf
+size 6942815

index/episodes/val.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30c7c147443abb8c52fa71201da43cb8ca6fcfe26fe0ab61d2388df3950a59b3
+size 120984

index/observations/test_app.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27e04f4649660ae819a11df88d2851b9dd05d16a1169670aaac7d3e4b53e387b
+size 1406891

index/observations/test_id.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d03fedcc42c65679af648b65cb8a6eabf15a60bbed9bb38e1e7339b5975af8e6
+size 851200

index/observations/test_resolution.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc28efc2ba757e643e07c55f13be723e4191e8d7e7e54c26f911176e2c4e31ef
+size 2056855

index/observations/test_theme.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8203c7aa6ce4c724352edfbd69ab0968e9bd6a9ad12a5af57d9414143842b2ca
+size 1537385

index/observations/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfb412bb219563b5d9cd2111d978b1e23afb9dd1d64ee3ce86a28b71482355b7
+size 21032206

index/observations/val.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7907feb1e130394e163ba77077a9f24285bac17742401c1dc2dfef635fd5254
+size 561501

index/scenes.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b57dd0b6fe010834f73be43d41308e2bc9c68ed89d76998c423474a67aca4ae5
+size 5209246

index/shard_members.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b7ee57c9e0a21cf7138e14579fbc5d928ddfa9e4f232b0ed8598bbeb7b00c25
+size 10442028

index/transitions/test_app.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e48fdac9ad177bed1bc034699023a14f55913fc35b1f9a748b900b97d2e70905
+size 1590260

index/transitions/test_id.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdea6f6761c78e8b9c7a5c636a257c407130a962b0852bfe36c25c5d66853de3
+size 814318

index/transitions/test_resolution.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5f4f495e70aecbb5cdbb140f04b179115ec990dbd8a6018e52dbd4573fb1cfa
+size 2464248

index/transitions/test_theme.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7113cf0a2ae6845cbef9a11edac525a3c14cbace7f187b9b5796669fb8bdd5f
+size 1697813

index/transitions/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb29a1f4c5c86870e733f3e798d2f0d2012b83c5d00c9c335285f8625fda9092
+size 30264161

index/transitions/val.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4641f1fbf37eb50c33a3c88badad05748e6e6e704ade248bf7d9284e201a388e
+size 426648

release_provenance.json

@@ -0,0 +1,27 @@
+{
+  "dataset_name": "DeskForge-1M",
+  "dataset_version": "1.0.0",
+  "created_utc": "2026-08-25T15:15:50Z",
+  "corpus_root": "/proj/docling-vision/users/said/deskshot_corpus/v1",
+  "source_manifests": {
+    "plan/manifest.jsonl": {
+      "sha256": "f50f6a7c87cc6d2a05bb04a820b20e3a634c2cb60ea9ed1afa51325f69c6dc8c",
+      "bytes": 745782559
+    },
+    "plan/splits_v3.jsonl": {
+      "sha256": "ed9074f536920aea73da3848b8bc5a9e20f970a4280c6aaed5d36aabdbcbf4b2",
+      "bytes": 646314694
+    }
+  },
+  "code": {
+    "repo": "desktop_ui",
+    "commit": "44588e281f2c78f753294592de7c44879a6f89a6",
+    "dirty": false
+  },
+  "key_scheme": {
+    "observation_key": "<shard>__<stem>",
+    "episode_id": "<shard>__<group>__<scene_id>",
+    "transition_id": "<episode_id>__t<NN>",
+    "why": "152 capture stems collide across shards and 128 scene ids appear in two shards, so bare stems and bare scene ids are not globally unique; (shard, stem) is unique across all 1,266,471 rows."
+  }
+}

release_report.json

@@ -0,0 +1,197 @@
+{
+  "checks": [
+    {
+      "check": "release_provenance.json exists",
+      "detail": null,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "source manifest present: plan/manifest.jsonl",
+      "detail": null,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "source manifest unchanged: plan/manifest.jsonl",
+      "detail": "frozen f50f6a7c87cc",
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "source manifest present: plan/splits_v3.jsonl",
+      "detail": null,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "source manifest unchanged: plan/splits_v3.jsonl",
+      "detail": "frozen ed9074f53692",
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "every scene has exactly one split",
+      "detail": "323,731 scenes",
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "observation keys are globally unique",
+      "detail": "1,207,368 observations",
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "zero held-out leakage into train",
+      "detail": "none",
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "transition ids are unique",
+      "detail": "917,211 transitions",
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "every eligible transition endpoint resolves",
+      "detail": 0,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "both endpoints share the transition's split",
+      "detail": 0,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "episode ids are unique",
+      "detail": "135,731 episodes",
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "every observation's episode has a row",
+      "detail": 0,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "action points and boxes are inside the viewport",
+      "detail": "184,662 checked",
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "normalized coordinates round-trip within one grid cell",
+      "detail": 0,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "no half-written tars remain",
+      "detail": [],
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "at least one tar is packed",
+      "detail": null,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "every tar is readable and matches its marker",
+      "detail": "60 tars",
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "no observation appears in two tars",
+      "detail": 0,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "every packed observation is in the index",
+      "detail": 0,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "every observation sits in its split's directory",
+      "detail": 0,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "no tar exceeds the size band",
+      "detail": [],
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "under-band tars are only split tails",
+      "detail": "0 under 0.75 GB",
+      "fatal": false,
+      "ok": true
+    },
+    {
+      "check": "sampled tars match their sha256",
+      "detail": "8 of 60 verified byte for byte",
+      "fatal": false,
+      "ok": true
+    },
+    {
+      "check": "no real project path in packed text",
+      "detail": 0,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "no real home directory in packed text",
+      "detail": 0,
+      "fatal": true,
+      "ok": true
+    },
+    {
+      "check": "host name: disclosed in docs/known_issues.md",
+      "detail": "1068 of 10,815 members scanned",
+      "fatal": false,
+      "ok": true
+    },
+    {
+      "check": "author contact details: disclosed in docs/known_issues.md",
+      "detail": "6 of 10,815 members scanned",
+      "fatal": false,
+      "ok": true
+    }
+  ],
+  "facts": {
+    "by_split": {
+      "test_app": 43206,
+      "test_id": 22550,
+      "test_resolution": 79212,
+      "test_theme": 51627,
+      "train": 999494,
+      "val": 11279
+    },
+    "episodes": 135731,
+    "observations_indexed": 1207368,
+    "payload": {
+      "bytes": 59491747840,
+      "deep_checked": 8,
+      "packed_observations": 60017,
+      "tars": 60
+    },
+    "privacy": {
+      "author contact details": 6,
+      "host name": 1068,
+      "members_scanned": 10815
+    },
+    "transitions_eligible": 862587,
+    "transitions_total": 917211
+  }
+}