VGI-Bench data release (bench_data + eval_res)

.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,28 @@
+# VGI-Bench | Data
+
+[![arXiv](https://img.shields.io/badge/arXiv-2608.19583-b31b1b?style=for-the-badge&logo=arxiv&logoColor=white)](https://arxiv.org/abs/2608.19583)  [![Project Page](https://img.shields.io/badge/Project-Page-1f8acb?style=for-the-badge&logo=googlechrome&logoColor=white)](https://hexuan21.github.io/VGI-Bench/)
+
+This repository holds the **data** of VGI-Bench, in two subtrees:
+
+- `bench_data/` -- the benchmark itself: 27 tasks, each at 3
+  difficulty levels (`lv1`/`lv2`/`lv3`) with 10 instances for each level, where
+  an instance pairs an input image (16:9 -- also the first frame for video
+  models) with a text prompt. 16 of the tasks additionally ship an
+  image-generation prompt, the rest being video-only, and every task comes with
+  the rubric and completeness specs used for the VLM-as-judge evaluation.
+- `eval_res/` -- the raw generations every evaluated model produced on those
+  instances, plus the 640px previews the project page streams.
+
+```
+bench_data/<task>/
+  input_image/lv{1,2,3}/<task>_lv<N>_<id>.png   input image = first frame
+  prompt/video_gen_prompt/                       prompt for video-gen models
+  prompt/image_gen_prompt/                       prompt for image-gen models / UMM (optional)
+  judge_spec/_judge_rubric_<task>.json           VLM-as-judge checklist
+  judge_spec/_completeness_judge.txt             completeness scale (0 / 1 / 2)
+
+eval_res/
+  video_model_res/<model>/<task>/<task>_<lv>_<id>.mp4
+  image_model_res/<model>/<task>/<task>_<lv>_<id>.png
+  _preview/...                                   640px previews
+```

bench_data/block_assembly/judge_spec/_completeness_judge.txt

@@ -0,0 +1,8 @@
+Completeness scoring, three tiers (0 / 1 / 2), by how far the goal was carried out.
+Tier 2 does NOT require flawless / perfect execution: near-complete (goal essentially reached, minor imperfections allowed) still counts as 2.
+OVERRIDE (applies to every task): if the output changes drastically from the input image, unrelated new elements suddenly appear, or the scene differs wholesale from the input, score 0, regardless of any apparent task progress.
+GUIDING PRINCIPLE: generated video is uncontrollable and may sprout odd elements. As a rule of thumb, if the procedure is carried out step by step but the final answer is simply wrong, give 1 (not 0). Reserve 0 for: the procedure is not attempted at all, or the output breaks / deviates drastically from the input (see OVERRIDE).
+
+0: Blocks stay scattered / barely move (no assembly attempted), or blocks are added / lost, or the scene deviates drastically from the input.
+1: Blocks come together / stack (procedure carried out) but the assembly is incomplete or ends as a wrong structure that doesn't match the target inset.
+2: All input blocks are joined into the 3D assembly shown in the upper-left inset (correct overall shape and stacking). Minor misalignment of a block is fine as long as the whole structure clearly matches the target and uses every block.

bench_data/block_assembly/judge_spec/_judge_rubric_block_assembly.json

@@ -0,0 +1,392 @@
+[
+ {
+  "id": "block_assembly_lv1_001",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 2 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a short tower of two square bricks stacked vertically) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv1_002",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 2 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a wide slab with one small brick centred on top) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv1_003",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 2 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a wide slab with one brick stacked at one end forming a single step) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv1_004",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 3 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a tall tower of three square bricks stacked vertically) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv1_005",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 3 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a two-step staircase climbing in one direction) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv1_006",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 3 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a simple arch with two square columns and a horizontal lintel on top) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv1_007",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 3 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a tower with a wide base brick and two smaller bricks stacked on top) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv1_008",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 3 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a small chair: a flat seat with a two-brick backrest rising at one end) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv1_009",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 2 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a seesaw: a long plank balanced across a single low central brick) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv1_010",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 3 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a wide base brick with a small cube stacked on each end) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_001",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 5 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a simple four-legged table with a wide square top) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_002",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 5 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a winner's podium with a tall central platform flanked by two short side platforms) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_003",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 4 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a mushroom with a tall white stem and a wide red cap) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_004",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 5 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (the letter H, two bricks tall, with two thick uprights and a low cross-bar) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_005",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 5 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a flat roof slab with a tall chimney rising from one corner) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_006",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 5 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (the letter T standing two bricks tall with a wide top bar) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_007",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 3 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a three-tier stepped altar shrinking towards the top) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_008",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 5 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a bench: a long seat on two legs with two short backrest posts at the rear) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_009",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 5 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (the letter I standing upright with wide top and bottom bars and a small cap) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv2_010",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 3 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a three-tier layered cake shrinking towards the top) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_001",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 7 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a small church with a tall steeple topped by a small cross) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_002",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 7 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a water tower with four legs supporting a wide tank and a small cap) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_003",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 6 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (the letter E with three protruding arms) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_004",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 6 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a small tank with two treads, a hull, a turret, and a cannon barrel) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_005",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 7 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a lighthouse with a striped tower and a wide lamp room near the top) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_006",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 7 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a steam locomotive with a long chassis, a boiler, a cab, and a tall chimney) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_007",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 7 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a double archway with three thick pillars supporting one long top lintel) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_008",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 7 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a goalpost with two tall white uprights and a yellow horizontal crossbar) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_009",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 6 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a rocket on a launch pad: a wide pad supporting a tall white body with a red nose cone and one side booster) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ },
+ {
+  "id": "block_assembly_lv3_010",
+  "rubric": [
+   "Every scattered block visible in the input image is accounted for in the output: each one is either still on the table or is now part of the final assembly. The total block count matches the input's 7 blocks; no block from the input disappears, and no extra block that was not in the input appears.",
+   "The upper-left inset preview from the input image is still present in the output at the same position, same size, same border, and shows the same target, its content, framing, and orientation are unchanged.",
+   "Each block preserves its original identity throughout: same colour, same length × width × height in unit terms, and same surface type, a studded LEGO-style brick keeps the same stud pattern on its top face.",
+   "By the final frame the blocks on the table are joined into a single completed 3D assembly whose shape matches the target (a small robot with two legs, a torso, two side arms, a head, and an antenna) shown in the upper-left inset preview, same overall 3D form, same stacking, same orientation.",
+   "The relative colour layout of the final result matches the inset preview, blocks of each colour appear in the same positions / layers as they do in the inset.",
+   "All bricks have the same physical height (one brick layer); no plates or half-height pieces. Stacking is achieved by placing one full-height brick directly above another.",
+   "The table surface (colour, texture, position), the background, the camera viewpoint, and the lighting all stay fixed and unchanged from the input throughout the output.",
+   "No labels, no text, no arrows, no debugging overlays, no extra annotations, and no rendering glitches anywhere in the output."
+  ]
+ }
+]

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_001.txt

@@ -0,0 +1,10 @@
+The input image shows 2 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a short tower of two square bricks stacked vertically. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 2 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a short tower of two square bricks stacked vertically), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_002.txt

@@ -0,0 +1,10 @@
+The input image shows 2 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a wide slab with one small brick centred on top. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 2 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a wide slab with one small brick centred on top), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_003.txt

@@ -0,0 +1,10 @@
+The input image shows 2 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a wide slab with one brick stacked at one end forming a single step. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 2 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a wide slab with one brick stacked at one end forming a single step), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_004.txt

@@ -0,0 +1,10 @@
+The input image shows 7 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a small church with a tall steeple topped by a small cross. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 7 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a small church with a tall steeple topped by a small cross), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_005.txt

@@ -0,0 +1,10 @@
+The input image shows 7 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a lighthouse with a striped tower and a wide lamp room near the top. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 7 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a lighthouse with a striped tower and a wide lamp room near the top), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_006.txt

@@ -0,0 +1,10 @@
+The input image shows 3 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a simple arch with two square columns and a horizontal lintel on top. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 3 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a simple arch with two square columns and a horizontal lintel on top), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_007.txt

@@ -0,0 +1,10 @@
+The input image shows 3 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a tower with a wide base brick and two smaller bricks stacked on top. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 3 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a tower with a wide base brick and two smaller bricks stacked on top), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_008.txt

@@ -0,0 +1,10 @@
+The input image shows 3 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a small chair: a flat seat with a two-brick backrest rising at one end. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 3 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a small chair: a flat seat with a two-brick backrest rising at one end), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_009.txt

@@ -0,0 +1,10 @@
+The input image shows 2 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a seesaw: a long plank balanced across a single low central brick. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 2 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a seesaw: a long plank balanced across a single low central brick), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv1_010.txt

@@ -0,0 +1,10 @@
+The input image shows 3 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a wide base brick with a small cube stacked on each end. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 3 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a wide base brick with a small cube stacked on each end), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv2_001.txt

@@ -0,0 +1,10 @@
+The input image shows 5 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a simple four-legged table with a wide square top. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 5 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a simple four-legged table with a wide square top), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv2_002.txt

@@ -0,0 +1,10 @@
+The input image shows 3 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a tall tower of three square bricks stacked vertically. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 3 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a tall tower of three square bricks stacked vertically), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv2_003.txt

@@ -0,0 +1,10 @@
+The input image shows 7 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a water tower with four legs supporting a wide tank and a small cap. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 7 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a water tower with four legs supporting a wide tank and a small cap), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv2_004.txt

@@ -0,0 +1,10 @@
+The input image shows 5 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: the letter H, two bricks tall, with two thick uprights and a low cross-bar. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 5 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (the letter H, two bricks tall, with two thick uprights and a low cross-bar), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv2_005.txt

@@ -0,0 +1,10 @@
+The input image shows 5 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: a flat roof slab with a tall chimney rising from one corner. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 5 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (a flat roof slab with a tall chimney rising from one corner), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.

bench_data/block_assembly/prompt/video_gen_prompt/block_assembly_lv2_006.txt

@@ -0,0 +1,10 @@
+The input image shows 5 scattered LEGO-style building blocks on a flat table surface. In the upper-left corner of the input image there is a small bordered inset preview showing the target 3D assembly, what those blocks should be assembled into: the letter T standing two bricks tall with a wide top bar. Generate a video continuing from the input: every scattered block on the table autonomously slides, lifts, rotates, and stacks together until all 5 of them are joined into exactly the 3D assembly shown in the upper-left inset preview.
+Mandatory:
+- Every single scattered block from the input must end up used in the final assembly; no extra blocks appear, no block disappears, no block is left behind on the table. Each block keeps its exact colour, dimensions, and shape (a studded brick keeps the same stud pattern on its top face).
+- The final assembled structure on the table must visually match the target preview in the upper-left inset: same overall 3D shape (the letter T standing two bricks tall with a wide top bar), same stacking, same relative colour layout, same orientation as the inset shows.
+- The upper-left inset preview stays perfectly stationary, unchanged, and intact for the entire video, same content, same border, same position, same size. It is a reference card, not part of the scene being assembled.
+- No human hand, no finger, no arm, no robot, no tool, no string, no gripper, no extra object enters the frame at any time. The blocks move on their own.
+- The table surface, background, camera viewpoint, and lighting all stay perfectly fixed throughout the video.
+- Motion is one continuous physical assembly sequence, blocks slide / lift smoothly into place. No jump cuts, no teleporting, no morphing into different shapes, no blocks duplicating or fading.
+- By the final frame the assembly is complete and stable, sitting on the table where the scattered blocks used to be.
+- No labels, no text, no arrows, no annotations, no glitches.