Datasets:

YY222
/

bench

@@ -58,7 +58,3 @@ saved_model/**/* 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
-outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/import/model.glb filter=lfs diff=lfs merge=lfs -text
-outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/model.glb filter=lfs diff=lfs merge=lfs -text
-outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/import/model.glb filter=lfs diff=lfs merge=lfs -text
-outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/model.glb 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

outputs/G039_sky_ring_flight/.generation/3d_object/meshy/obj200_meshy_tripo_20261015_v2/asset_task_index.json DELETED Viewed

@@ -1,30 +0,0 @@
-{
-  "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
-  "game_id": "G039_sky_ring_flight",
-  "provider": "meshy",
-  "scope": "3d_object_only_not_complete_stage2",
-  "tasks": [
-    {
-      "task": {
-        "game_id": "G039_sky_ring_flight",
-        "task_id": "G039_sky_ring_flight_obj_005",
-        "asset_name": "wind_stream_vane",
-        "name_zh": "风线仪",
-        "role": "prop",
-        "input_mode": "text_to_3d",
-        "prompt": "Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-        "seed": 1043,
-        "decimation_target": 8000,
-        "texture_size": 1024,
-        "rig": "none",
-        "animation_strategy": "procedural",
-        "spec_ref": "L01,F04",
-        "poly_policy": "low_poly_priority"
-      },
-      "shared_prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-      "reference": null,
-      "subject_group": "rigid",
-      "context_condition": "shared_short_context"
-    }
-  ]
-}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/meshy/621b2bacd581f2248e057e82e0c502db9e73ab8421bab5c360e2a8f915f854a1.meta.json DELETED Viewed

@@ -1,33 +0,0 @@
-{
-  "provider": "meshy",
-  "payload": {
-    "ai_model": "meshy-6",
-    "model_type": "standard",
-    "topology": "triangle",
-    "target_polycount": 8000,
-    "should_remesh": true,
-    "mode": "preview",
-    "prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-    "seed": 1043
-  },
-  "model": "meshy-6",
-  "task_id": "01a142f8-19ab-7259-962c-aade734abc46",
-  "task_ids": [
-    "01a142f7-70e3-73f4-ab13-bd13ef695829",
-    "01a142f8-19ab-7259-962c-aade734abc46"
-  ],
-  "elapsed_sec": 131.47,
-  "credits": null,
-  "cached": false,
-  "format": "glb",
-  "preview_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/preview.png?Expires=4945708800&Signature=pf9kXoRiecSv9ApuG7GkKsojX1hT~6QZiHhcSPaBUpSHPflxfcyPPssPN2mCsnUhKEkh7Mj3oJxnwhKVgNz5hVARIcMILE0zgXp~mT4YK6cmt4nr2C1NJmJvhf35MmMDJIhfOQiZtR8gVylqYs790e3HHRFqeY033CfPtlhybZRMVoefX4a50x1CkD-ar54OvG-HGWNdiCO6XfCuzXNJ2hN5ocbnWLEf32Ga8Lk4Kj4w5kmhOQsrS5XCowDuDBnk6k2-viXZcxOf4j~pUOr1PY7gaTWBZ1avXGZqH3B9IEUWvHzHP87J4XvSUpC8lnugxH1tnCmPufACYm26utxkhw__&Key-Pair-Id=K1VGYTHIYLM9UM",
-  "bytes": 9577000,
-  "triangles": 7880,
-  "meshes": 1,
-  "materials": 1,
-  "textures": 4,
-  "images": 4,
-  "nodes": 1,
-  "generator": "pygltflib@v1.16.5",
-  "cache_key": "621b2bacd581f2248e057e82e0c502db9e73ab8421bab5c360e2a8f915f854a1"
-}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/tripo/9d58e620c747b9213bdc1983dcf141fefb89ad92e884b7c832b36f21e3b84076.meta.json DELETED Viewed

@@ -1,30 +0,0 @@
-{
-  "provider": "tripo",
-  "payload": {
-    "model": "v3.1-20260211",
-    "texture": true,
-    "pbr": true,
-    "texture_quality": "standard",
-    "geometry_quality": "standard",
-    "smart_low_poly": true,
-    "face_limit": 8000,
-    "prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-    "model_seed": 1043,
-    "texture_seed": 1043
-  },
-  "model": "v3.1-20260211",
-  "task_id": "f242bcce-d29e-4a07-a20c-019277c9280b",
-  "elapsed_sec": 251.71,
-  "credits": 30.0,
-  "cached": false,
-  "preview_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/f242bcce-d29e-4a07-a20c-019277c9280b/legacy_mesh.webp?auth_key=1792224016-bibrcxrc-0-b77b51744d52f9e52e969d362bd4a51e",
-  "bytes": 3112864,
-  "triangles": 10929,
-  "meshes": 1,
-  "materials": 1,
-  "textures": 3,
-  "images": 3,
-  "nodes": 1,
-  "generator": "https://tripo3d.ai",
-  "cache_key": "9d58e620c747b9213bdc1983dcf141fefb89ad92e884b7c832b36f21e3b84076"
-}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/frozen_game_inputs.json DELETED Viewed

@@ -1,141 +0,0 @@
-{
-  "schema_version": "game_delivery_view_not_execution_plan_v1",
-  "batch_id": "obj200_meshy_tripo_20261015_v2",
-  "game_id": "G039_sky_ring_flight",
-  "parent_frozen_plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
-  "parent_frozen_plan_file_sha256": "3c4798c34345ab6f7fc07f850f25deca44051565185a1c8a80058819e1bbd685",
-  "task_count": 1,
-  "parent_plan_original": {
-    "archive": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/frozen_parent_plan_original.zip",
-    "archive_member": "bench/test_data/outputs/_asset_batches/obj200_meshy_tripo_20261015_v2/plan.json",
-    "original_file_sha256": "3c4798c34345ab6f7fc07f850f25deca44051565185a1c8a80058819e1bbd685",
-    "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d"
-  },
-  "scope": "3d_object_only_not_complete_stage2",
-  "providers": {
-    "meshy": {
-      "model": "meshy-6",
-      "api_base": "https://api.meshy.ai",
-      "options": {
-        "low_poly": false,
-        "texture": true,
-        "enable_pbr": true,
-        "should_remesh": true,
-        "topology": "triangle"
-      },
-      "credits": {
-        "text_preview": 20,
-        "text_refine": 10,
-        "image": 30
-      }
-    },
-    "tripo": {
-      "model": "v3.1-20260211",
-      "api_base": "https://openapi.tripo3d.com/v3",
-      "options": {
-        "low_poly": true,
-        "texture": true,
-        "pbr": true,
-        "texture_quality": "standard",
-        "geometry_quality": "standard"
-      },
-      "credits": {
-        "text": 30,
-        "image": 40
-      }
-    }
-  },
-  "postprocess": {
-    "tool": "gltf-transform-4.2.1_meshoptimizer-0.24.0",
-    "simplify_error": 0.01,
-    "simplify_passes": 1,
-    "triangle_budget": "per_task_decimation_target_at_most_8000",
-    "texture_budget": "per_task_texture_size_downsize_only",
-    "preserve_native_output": true
-  },
-  "runtime_sources": {
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/generate_3d_comparison.py": "70f8d79c8596908f7edcd7ff68120f558cea6881f23dc2f0e29ef62f2bab75c4",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/cloud_journal.py": "92d075ef9308e0d6496a901d85b7847b8f602f88de8e19caeaf85ac893081253",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/record_paths.py": "93c42e454d60d03c30b12e58e8e75453c7caa8fc92ff30bbc20aa645b3fc23dd",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/paths.py": "ed1cf1105f95c76b4893e98a84b3e37ef7d1f87c873c93c8e58413457104d28b",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/prompts/stage2_assets.md": "172339b9f6c6d834ef0d782c0d3dd779b62a12bd34acddc746b80d7cd99f63c2",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/operators/gen_3d_object/operator.py": "5f88c457ee58f73de5ddbd4d96fa91e474c29bd3ecefbb02f3faf18b93c4365a",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/meshy_model.py": "ef437ff79554469390c0d6c71f11788431fe4a1d1e51e92feae3adf296cebaec",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/tripo_model.py": "29ab3944260d62585a991f384eee4917368f97c4476abc3eda85299bc1a8089e",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/cloud_api.py": "a3c363a3439b3864e05e782340eb3059380c4b1c28eccb2524e9cbf9131fe996",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/glb_utils.py": "6f3ee0147b345415cb6d8b1b1433fa557d0d543bb92276840dc85b43cd7a66ad",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/process_mesh.mjs": "b1b6ada273a576083bb167772ec03fee6fe3275470180563722e56687688995c",
-    "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/package-lock.json": "0d9c3ad5898a78a0db22f361caa7242b48ff86586e898f5ae5c1bb4a7134631a"
-  },
-  "mesh_runtime": {
-    "status": "ready",
-    "node": "20.17.0",
-    "dependencies": {
-      "@gltf-transform/core": "4.2.1",
-      "@gltf-transform/extensions": "4.2.1",
-      "@gltf-transform/functions": "4.2.1",
-      "draco3dgltf": "1.5.7",
-      "meshoptimizer": "0.24.0",
-      "sharp": "0.35.5"
-    }
-  },
-  "documents": {
-    "general_requirement": {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
-      "sha256": "f6dcff2dc4ed2884a10fbe4dd372101607a1db35eb6101af83147dc67b427ca7",
-      "source": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt"
-    },
-    "object_requirement": {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
-      "sha256": "0e6baf23ec644632685288255be23927d404f458165c57cfe302a6b0c5df83f5",
-      "source": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt"
-    },
-    "context_excerpt": "空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。",
-    "context_method": "deterministic title/world/core-loop excerpts; full brief retained locally"
-  },
-  "tasks": [
-    {
-      "task": {
-        "game_id": "G039_sky_ring_flight",
-        "task_id": "G039_sky_ring_flight_obj_005",
-        "asset_name": "wind_stream_vane",
-        "name_zh": "风线仪",
-        "role": "prop",
-        "input_mode": "text_to_3d",
-        "prompt": "Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-        "seed": 1043,
-        "decimation_target": 8000,
-        "texture_size": 1024,
-        "rig": "none",
-        "animation_strategy": "procedural",
-        "spec_ref": "L01,F04",
-        "poly_policy": "low_poly_priority"
-      },
-      "shared_prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-      "reference": null,
-      "subject_group": "rigid",
-      "context_condition": "shared_short_context"
-    }
-  ],
-  "input_policy": "shared_short_context_and_reference_only",
-  "context_limitations": "Text APIs received shared short context plus asset prompt; image APIs received reference only. Full requirements retained as evidence, not sent to APIs.",
-  "benchmark_metrics": {
-    "C": {
-      "status": "UNKNOWN",
-      "value": null
-    },
-    "Q1": {
-      "status": "UNKNOWN",
-      "value": null
-    },
-    "Q2": {
-      "status": "UNKNOWN",
-      "value": null
-    },
-    "Q3": {
-      "status": "UNKNOWN",
-      "value": null
-    }
-  },
-  "view_sha256": "44294753e7e8b8e2c30cc912661baf651ed75b5a88a369b044eed120f1004483"
-}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt DELETED Viewed

@@ -1,285 +0,0 @@
-# 《空中群岛的风场穿环》｜三维飞行穿环机制输入规范
-```yaml
-case_id: G039
-base_case_id: G039
-title: 空中群岛的风场穿环
-category: Racing / Vehicle
-tier: M
-engine: unity3d
-report_track: Standard
-paired_conditions: [R, N]
-required_real_clients: 1
-fixed_seed: 1039
-spec_version: v3
-status: DRAFT_LOCAL
-mechanism_source: null
-task_spec_version: null
-task_spec_hash: null
-frozen_by: null
-frozen_at: null
-dependency_hashes: null
-```
-## 0. 标题、版本与使用说明
-- 作品名：《空中群岛的风场穿环》；版本：mechanics-v3（2026-10-11 完整性修订：吸收 yyy 反馈——空中环道世界设定、飞行手感冻结（俯仰/横滚/加速/失速预警/复位朝向）、风线与气流粒子、穿环脉冲与尾迹 VFX、穿环提示音、参考图绑定与正向范围清单）；运行引擎：**Unity 2022.3 LTS＋URP**——选择理由：飞行控制、触发器、风场与环形赛道原型在 URP 下便于确定性验证；目标构建：Windows/macOS 64 位桌面包；参考分辨率 1920×1080（1280×720 最低可用）；摄像机：第三人称追机镜头（机尾后上方）；输入：键盘与鼠标；构建启动：Unity 2022.3 打开工程、Build 出桌面可执行文件后直接运行。
-- 原创边界：本作全部名称、飞行器、环架、群岛、文案与美术必须原创，不使用任何商业作品的名称、角色或造型。
-- 规则优先级：本文件全局数值与规则 ＞ 机制章节 ＞ 航线实例 ＞ 生成器自由补充；未指定数值可作为明确标注的配置默认值。
-- 本文件用于游戏生成模型；文档存在不等于玩法完成，静态页面或演示视频不能单独证明可玩。
-## 1. 定位与完整流程 [S01–S06]
-- S01 类型：三维飞行穿环计时挑战（12 环三段航线）。
-- S02 核心循环一句话：调整姿态 → 穿环 → 应对风场/失速 → 碰撞复位 → 完成航线。
-- S03 流程：起飞 → 低空入门环（环 1–4）→ 风场区环链（环 5–8）→ 高空精密环（环 9–12）→ 终点结算。
-- S04 最低完整流程：开始界面、起飞、飞行 HUD、漏环警告、复位、结算、重开必须全部存在且有真实入口。
-- S05 失败恢复入口：碰撞回最近环前检查点（环序不回退）；超时或复位超限判负后一键重开；Esc 暂停。
-- S06 本局耦合边速览：碰撞复位系统→环序进度系统（复位不回退环序）；风场系统→飞行轨迹系统（区域风持续偏移航迹）。
-## 2. 完整核心循环与阶段 [S07–S12]
-完整循环：主菜单 → C01 起飞 → 低空入门环 → 风场区环链 → 高空精密环 → 终点结算 → 重开/返回菜单；任意飞行阶段可 Esc 暂停。每阶段六要素如下（引用本 spec §3–§7 对应规则）：
-- S07 主菜单
-  - input：系统启动，玩家确认进入
-  - precondition：程序启动完成（C01 可在首次入局前播放）
-  - state_change：显示主菜单（开始/退出）
-  - feedback：主菜单界面（F10）
-  - next_actions：点击「开始」→ S08
-  - outcome：无状态副作用
-- S08 起飞
-  - input：玩家按 Shift 加速并前推（W 俯仰）爬升（I01）
-  - precondition：C01 播完或跳过；滑翔机停于起飞平台、速度 0
-  - state_change：滑翔机离地爬升至巡航速度 60；起飞完成即开始 420 秒总计时（G05）
-  - feedback：尾迹展开、气流粒子掠过（F04/F05），HUD 见 I03
-  - next_actions：到达环 1 → S09
-  - outcome：起飞段用时计入总计时
-- S09 低空入门环（环 1–4）
-  - input：玩家俯仰/横滚/加速驾驶
-  - precondition：起飞完成
-  - state_change：按序穿环 1–4（半径 6）；漏环不计并出警告（M02）
-  - feedback：穿环脉冲与提示音（F05）
-  - next_actions：过环 4 → S10；碰撞 → 复位（M04）；Esc → S12
-  - outcome：环序推进 1→4，计时连续
-- S10 风场区环链（环 5–8）
-  - input：持续驾驶修正侧风偏航（G06）
-  - precondition：环 4 已过
-  - state_change：侧风 15/秒持续偏移航迹；2 个上升气流柱可借力爬升（G06）
-  - feedback：风线与气流粒子（F04/F05），HUD 风区提示（I03）
-  - next_actions：过环 8 → S11；失速 → 按 M01 恢复；Esc → S12
-  - outcome：环序推进 5→8；风区轨迹差分可导出（E02）
-- S11 高空精密环（环 9–12）→ 终点结算
-  - input：精密姿态调整（环半径收窄为 4）
-  - precondition：环 8 已过
-  - state_change：按序穿环 9–12；穿完环 12 → V01 结算（显示用时与复位次数）；复位第 11 次或 420 秒超时 → V02 判负
-  - feedback：C03 结算视频（双意象）＋结算面板
-  - next_actions：Enter 重开 → S07；返回菜单 → S07
-  - outcome：按 V01/V02 判定并结算
-- S12 暂停
-  - input：玩家按 Esc
-  - precondition：处于 S08–S11 任意飞行阶段
-  - state_change：冻结计时、风场与失速判定（G06）
-  - feedback：暂停菜单（继续/重开/返回/设置）
-  - next_actions：Esc/继续 → 返回原阶段；重开 → S07
-  - outcome：恢复后一切计时从冻结点连续累计，无漂移
-## 3. 数值口径与全局规则 [G01–G07]
-- G01 统一刻度：速度按单位/秒、坐标按单位计、角度为度；时间用游戏模拟秒（暂停冻结）。
-- G02 飞行与失速（本包冻结值）：基础巡航速度 60，速度区间 40–90（Shift 加速至 90、松键回落 60，回落为空气阻力自然衰减）；速度 <40 触发失速——垂直下坠 20/秒且操控力矩减半；俯冲或加速使速度回到 ≥50 才脱离失速；失速预警（速度 ≤45 时 HUD 黄色预警与预警音，G07）；W/S 俯仰、A/D 横滚，均为连续输入。
-- G03 航线与穿环（本包冻结值）：航线共 **12 环**——低空入门环 4（环 1–4）、风场区环链 4（环 5–8）、高空精密环 4（环 9–12）；环为半径 6 的圆环（高空环收窄为半径 4），飞行器中心穿环平面且距环心 ≤6（高空环 ≤4）才计入；必须按 1→12 顺序穿环，穿到未解锁环不计并出漏环警告；环位由 seed=1039 冻结。
-- G04 判定与独立 oracle（本包冻结值）：失速 oracle——速度降到 35 必然触发失速事件且下坠率 20；俯冲至 55 必然脱离失速。风场 oracle——无风区正对环 6 直线飞行 10 秒横向位移为 0（偏航 0）；风场区同操作 10 秒横向位移 150（±15 容差）。穿环 oracle——按序穿环 1、2 计入推进；直飞环 3 平面（跳过环 2）不计且出漏环警告。任何偏离即 FAIL。
-- G05 失败与复位（本包冻结值）：撞岛体/环架/水面 → 复位到最近已穿环后方检查点（每环配 1 个），复位次数上限 **10 次**（第 11 次判负）；航线总时限 **420 秒**（自起飞离地起算，暂停不计入），超时判负。
-- G06 风场与暂停（本包冻结值）：风场区（环 5–8 区段）持续侧风 15/秒（固定指向，seed 冻结）；区内另设 2 个上升气流柱（半径 10，垂直 +25/秒）；高空精密环区无风但环径收窄为半径 4。Esc 暂停冻结计时、风场与失速判定，UI 过渡不推进游戏状态。
-- G07 复位朝向与手感（本包冻结值）：复位后机头朝向下一目标环的航线方向（姿态角重置为航线切向，速度恢复 60 巡航）；横滚信息——相机地平线随横滚同步倾斜，HUD 提供俯仰角/横滚角读数；输入到姿态可见响应 ≤100 毫秒（I07）。
-## 4. 操作与输入 [I01–I07]
-- I01 键位：W/S＝俯仰（拉杆/推杆）；A/D＝横滚；Shift＝加速；R＝碰撞后手动确认复位；Esc＝暂停；结算界面 Enter＝重开。
-- I02 输入语义边界：失速期间操控输入仍接受但效果减半；暂停/结算期间输入无效；无鼠标瞄准需求。
-- I03 HUD 必须显示：速度、当前环序（下一目标环）、计时（420 秒剩余）、复位计数（0–10）、失速预警（黄）与失速警报（红）、风区提示（进入/离开风场区）、俯仰角/横滚角读数（G07）。
-- I04 输入优先级：暂停与结算状态阻断全部玩法输入；面板打开时玩法键不串入；同帧多输入按 §6 各机制声明的顺序结算。
-- I05 焦点与点击穿透规则：点击画布捕获输入焦点；面板层阻断点击穿透；窗口失焦自动暂停（G06）。
-- I06 UI 必须显示的状态：按 §3 G01 刻度与 §7 结算字段显示本 spec 各规则要求的状态（速度/环序/计时/复位/失速/风区），HUD 对照见 rubric。
-- I07 输入延迟目标：按键到姿态可见响应 ≤100 毫秒（桌面 P95，每类输入 ≥30 次采样）。
-## 5. 航线与内容清单 [L01–L04]
-- L01 生成对象：飞行器 1（原创造型）、穿环 12（套件实例化）、环前检查点浮标 12、上升气流柱标记 2、风线仪/风幡若干（风区边界）、起飞平台 1、HUD。
-- L02 航线（冻结布局）：单条三段穿环航线；环位、气流柱位置与风场向量由 seed=1039 冻结，不随机扩展；环前检查点位于每环后下方 20 单位处（复位用）。
-- L03 目标物/交互物/场景/UI 对象：本 spec §3–§7 引用的界面元素（菜单/HUD/结算面板）与交互物（穿环判定体、碰撞体、检查点复位体、气流柱判定体）逐类存在且运行时可进入；**程序性穿环判定体不得烘进装饰场景模型**——环架模型为外观件，判定体由引擎触发器构建（A 层资产诊断重点）。
-- L04 冻结需求 vs 实现默认 vs 生成自由度：本 spec 明确写出的数值与数量为冻结需求；未给数值的表现层（装饰造型、配色、粒子参数、音色）为生成自由度，不得评估为缺失；实现默认值必须明确标注且符合核心机制。音效为冻结需求（F06 ��单逐条交付，缺失按 FAIL 计）。
-## 6. 机制系统 [M01–M04]
-- M01 三维姿态与失速（主机制）
-  - input：俯仰/横滚/加速输入（玩家）
-  - precondition：处于飞行阶段（非暂停/结算/复位中）
-  - state_change：姿态角连续变化；速度 <40 → 失速（下坠 20/秒、操控减半）；速度 ≥50 → 恢复巡航；≤45 → 失速预警（黄）
-  - output：按 G02 结算飞行状态
-  - observable：失速进入/脱离/预警事件与速度、姿态采样流
-  - invalid_case：复位中与暂停中姿态输入无效；失速期间输入减半为规则而非错误
-  - recovery：俯冲或加速回到 ≥50 脱离失速（M01 自恢复）；撞体后走 M04
-- M02 有序穿环
-  - input：穿越环平面（系统判定体）
-  - precondition：环处于已解锁序号（前序环全部通过）
-  - state_change：仅当前序号环计入并推进环序；漏环不计
-  - output：按 G03 结算环序
-  - observable：ring_passed 事件（环号）与 miss_warning 事件
-  - invalid_case：越序穿环不计且出漏环警告（无副作用）；判定体半径按 G03 冻结值（6/高空 4）
-  - recovery：回头补穿被漏环后继续按序推进
-- M03 风场
-  - input：进入/离开风场区与气流柱（系统判定体）
-  - precondition：飞行器处于航线空间
-  - state_change：风区侧风 15/秒持续偏移航迹（偏航须修正）；气流柱内获得垂直速度 +25/秒
-  - output：按 G06 施加风与气流
-  - observable：风场进入/离开事件与位置差分流（10 秒横移 150±15 可复现）
-  - invalid_case：风区外无侧风（E02 对照探针）
-  - recovery：借气流柱爬升或常规俯冲恢复高度
-- M04 碰撞复位
-  - input：撞击岛体/环架/水面（系统）＋手动 R 确认
-  - precondition：发生碰撞且玩家确认（R）；或自动（水面）
-  - state_change：回到最近已穿环后方检查点；机头朝向下一目标环（G07）；速度恢复 60；环序进度保持不回退；复位计数 +1
-  - output：按 G05 计数与判定
-  - observable：respawn 事件（含检查点 ID、环序、复位计数、朝向）
-  - invalid_case：未碰撞时 R 无效；结算/暂停期间复位无效
-  - recovery：第 11 次碰撞 → V02 判负；复位为唯一恢复入口
-系统耦合边（玩法必需、可复现）：
-- E01 from_system=碰撞复位系统 → to_system=环序进度系统；changed_state=复位后环序不回退（已穿环保持、当前目标环不变），复位朝向指向下一目标环；验证方式=state_before/after 环序对照（复位前后环序差分=0）。
-- E02 from_system=风场系统 → to_system=飞行轨迹系统；changed_state=进入风场区后持续侧风改变航迹（无修正 10 秒横移 150±15），气流柱内垂直分量 +25/秒；验证方式=风区内外同操作轨迹差分采样。
-## 7. 成功、失败与恢复 [V01–V05]
-- V01 成功条件：按序穿完 12 环 → 终点结算（显示用时与复位次数）。
-- V02 失败条件：复位超过 10 次或 420 秒超时 → 失败结算（注明当前环序与原因）。
-- V03 恢复语义：碰撞回最近环前检查点继续（环序与计时不重置）；判负后一键重开全量重置（seed 复现）。
-- V04 persistent_state：局内（环序进度与复位计数局内保留；重开全量清空）。
-- V04 软锁与不可达处理：不设永久软锁——关键目标均可通过正常飞行达成，或触发 V02 失败路径进入结算；结算界面重开为最终恢复出路。
-- V05 persistent_state 生命周期：当前动作级状态即时结算；当前局级状态（环序/复位/计时）局内保留、重开清空；跨局状态无。
-## 8. 世界设定与创作基线 [W01–W08]
-- W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。
-- W02 场景所在地：悬浮于云海之上的群岛天路——起飞平台立于首岛崖顶，环 1–4 沿低空岛缘铺设，环 5–8 横穿风谷（侧风常驻、双气流柱），环 9–12 升入高空窄环，终点环悬于终岛灯塔上空。
-- W03 玩家身份与当前任务动机：玩家是群岛信使候补飞行员，须在 420 秒内按序穿完全部 12 环、且复位不超过 10 次，完成首次正式投递。
-- W04 失败代价与结局表达：超时或复位超限＝「信件延误」——灯塔灯暗、信封被风卷走（C03 失败意象）；完成航线＝灯塔点亮、信封送达（C03 胜利意象）。
-- W05 叙事来源：滑翔机＝信使邮翼机（双翼轻航风格）；穿环＝群岛灯塔联盟的悬空环门；气流柱＝风谷上升暖流；检查点浮标＝灯塔联盟的救援浮标。全部原创，不用商业作品命名。
-- W06 视觉风格与色彩材质：明快云���插画风；主色＝云白 #F4F7F2、邮翼红 #D9553F、灯塔金 #E8B84B、远岛青 #6A9C8F；材质为帆布翼面、轻木机身、铜色环架与半透明风线。
-- W07 环境氛围与声音语言：高空风啸与远处海鸟声为底；音效语言＝引擎、风线、穿环提示、失速警报、复位（F06 冻结清单）；混音优先级：失速警报 ＞ 漏环警告 ＞ 穿环提示 ＞ 引擎 ＞ 风环境。
-- W08 故事表达方式：C01 开场交代候鸟节与投递任务 → 过程中风线与环门脉冲承载航线推进 → C03 结算双意象收束；叙事只做包装不改数值。
-## 9. 演出、镜头与反馈 [F01–F10]
-- F01 视角与镜头：第三人称追机镜头，机尾后上方（距离 8 单位、高 3 单位、FOV 62°）；相机地平线随横滚同步倾斜（横滚信息，G07）；镜头平滑跟随（阻尼 0.1）；C 键复位镜头到正尾方；镜头不入岛体；1920×1080 下 HUD 不遮挡下一目标环，1280×720 保持可读（I03）。
-- F02 关键操作镜头变化：穿环瞬间轻微 FOV +4°（0.3 秒）；碰撞/复位 0.3 秒中幅震动；失速期间镜头下沉跟随表达下坠感；设置可关闭（F09）。
-- F03 输入与延迟：见 I07（≤100ms P95）；顿帧不改变计时口径。
-- F04 环境常驻效果：云海缓慢流动、风线在风区常驻飘移（方向＝侧风指向）、气流柱内上升粒子、岛缘瀑布雾、检查点浮标灯呼吸；均为纯表现层（判定体独立）。
-- F05 事件反馈表（事件 → 画面表现 → 音效 → 结束条件，全部冻结需求）：
-| 事件 | 画面表现 | 音效 | 结束条件 |
-|---|---|---|---|
-| 起飞离地 | 尾迹展开＋平台气流粒子 | wind_swell（短促） | 爬升至巡航 |
-| 穿环 | 环门脉冲光环＋FOV +4°（0.3 秒） | ring_pass_chime | 脉冲消散 |
-| 漏环 | 目标环号橙框提示＋屏幕边缘轻闪 | ring_miss_warning | 过下一合法环或复位 |
-| 进入风场区 | 风线密度提升＋HUD 风区提示 | wind_zone_loop 起 | 离开风区 |
-| 进入气流柱 | 上升粒子包裹机身 | thermal_whoosh | 离开气流柱 |
-| 失速预警（≤45） | HUD 速度表转黄 | stall_pre_warning | 速度回升或失速 |
-| 失速（<40） | HUD 红色警报＋镜头下沉＋风噪增强 | stall_alarm | 速度 ≥50 脱离 |
-| 碰撞 | 撞击白闪＋0.3 秒中震＋碎屑 | crash_impact | 复位确认 |
-| 复位 | 淡出淡入回检查点＋机头朝向目标环 | reset_woosh | 复位完成 |
-| 超时/判负 | 暗角＋「TIME OUT / RETRY LIMIT」横幅 | timeout_alarm | 进入判负结算 |
-| 结算 | C03 播放（双意象）＋结算面板 | victory_sting / defeat_sting | 进入结算面板 |
-- F06 关键音效清单（one_shot 11 条＋环境循环 3 条，全部冻结需求）：wind_swell、ring_pass_chime、ring_miss_warning、stall_pre_warning、stall_alarm、thermal_whoosh、crash_impact、reset_woosh、timeout_alarm、victory_sting、defeat_sting（one_shot 共 11 条）；环境循环：wind_loop（高空风啸）、wind_zone_loop（风区风噪，强度随位置）、engine_loop（邮翼机引擎，随速变调）。无配音需求。
-- F07 VFX 信息性与遮挡约束：目标环高亮、风线方向、失速警报框为信息类 VFX，必须清晰可辨；穿环脉冲与尾迹不得遮挡下一目标环与 HUD；非结算单个全屏遮挡 ≤0.5 秒。
-- F08 音画同步：穿环音与脉冲同帧；失速警报音与红色警报同帧；复位音与淡出淡入同帧；风区音与风线密度同帧变化。
-- F09 屏幕震动：碰撞/复位 0.3 秒中幅（幅度 6 px 等效）；穿环 0.1 秒轻微；暂停/结算取消未结束的震动；设置可关闭（镜头震动开/关）。
-- F10 前端界面：标题（开始/设置/退出）→ 飞行 HUD（速度/环序/计时/复位数/失速预警/风区提示/姿态角读数，见 I03）→ 暂停面板（继续/重开/返回/设置）→ 结算面板（用时、环序、复位次数、评级；Enter 重开）；关键状态图标＋文字并用；窗口失焦自动暂停。
-## 10. 过场视频 [C01–C03]
-- C01 候鸟节起飞（Opening，6 秒，1280×720@24fps）
-  - 触发时机：首次由标题点击「开始」后、起飞平台就位之前，每局一次
-  - 内容与角色场景：云海日出、群岛灯塔依次亮起、信使邮翼机在起飞平台展开帆布翼，镜头自灯塔上空掠到平台正后方
-  - 资产对应：邮翼机、环门、起飞平台与游戏内模型同源
-  - 可跳过：Esc/Enter 跳过 → 直接进入起飞平台待命；自然播完 → 进入起飞平台待命
-  - 状态一致：跳过与自然播完后初始状态一致；播放期间不推进任何游戏计时
-- C02 关键穿环与气流事件（Event，5 秒，1280×720@24fps）
-  - 触发时机：本局首次进入上升气流柱时插入一次（画中画、不打断操作），每局最多一次
-  - 内容与角色场景：机身被上升粒子托举、穿过风谷环门的脉冲光环、风线自侧方掠过镜头
-  - 资产对应：邮翼机与环门同源
-  - 可跳过：Esc/Enter 跳过 → 立即返回飞行视角；自然播完 → 自动返回
-  - 状态一致：不打断飞行控制权；播放期间游戏计时正常推进
-- C03 航线结果（Ending，6 秒，1280×720@24fps，双意象共用条目）
-  - 触发时机：V01/V02 成立、结算面板出现之前，每局一次
-  - 内容与角色场景：胜利意象＝终岛灯塔点亮、信封送达、邮翼机绕塔盘旋；失败意象＝灯塔灯暗、信封被风卷走、机身停在检查点浮标旁
-  - 资产对应：邮翼机、环门、浮标与游戏内模型同源
-  - 可跳过：Esc/Enter 跳过 → 直接进入对应结算面板；自然播完 → 进入对应结算面板
-  - 状态一致：仅在真实 V01/V02 后触发；播放期间不推进任何游戏计时
-## 11. 范围与正向能力清单 [N01–N06]
-- N01 玩法能力：玩家可以驾驶邮翼机完成起飞与三段航线（M01–M03）、按序穿 12 环（M02）、借气流柱爬升与修正侧风偏航（M03）、碰撞后复位且环序不回退（M04/E01），在 420 秒内完成投递（V01）。
-- N02 流程与界面能力：主菜单、起飞、三段航线、终点结算、超时/复位超限判负、暂停（含失焦自动暂停）、一键重开全部具备真实入口。
-- N03 演出能力：C01–C03 视频、F04 常驻环境、F05 事件反馈表全部行、F06 音效 14 条、F09 震动与设置开关。
-- N04 输入范围：键盘为完整输入方式；鼠标为菜单辅助；手柄/触控为表现层扩展，不进入验收分母。
-- N05 音频范围：F06 冻结音效清单（11 one_shot＋3 环境循环）；无配音需求。
-- N06 表现层自由度：未冻结的装饰造型、配色、粒子参数与音色为生成自由度，由 L04 承担，不评估为缺失。
-## 12. 参考图绑定 [A01–A02]
-- A01 绑定原则：参考图只约束对应资产的造型、配色与比例，不约束航线布局（环位/气流柱/风场以本 spec L02 与 seed 为准）；R 条件提供 images/ 参考图，N 条件仅有文字描述，评测不得因 N 条件未见参考而追加扣分项。
-- A02 绑定表（文件 → 对象）：
-| 参考图 | 绑定对象 | 用途 |
-|---|---|---|
-| images/ref_sky_glider_sketch.png | 信使邮翼机 | 3D_object image_to_3d |
-| images/ref_ring_gate_sketch.png | 悬空环门 | 3D_object image_to_3d |
-| images/ref_scene_sky_islands_sketch.png | 浮空群岛天路 | 3D_scene image_to_scene |
-参考图为程序化概念草图（1024×1024，无文字；生成参数与负向提示见 asset_tasks/racing_simulation/ref_images_manifest.jsonl），可按该 manifest 扩散重绘后原位覆盖。
-## 13. 复杂度档案
-```yaml
-difficulty:
-  tier: M
-  complexity_profile: {coupling: C2, persistence: P1, recovery: R2, runtime_complexity: B2, hidden_state: H0}
-  dominant_dimensions: [coupling, runtime_complexity]
-  rationale: "局内多系统耦合：碰撞复位→环序、风场→轨迹两条可复现 A→B 边（C2）；实时三维飞行与风场连续判定（B2）；环序进度局内推进（P1）；检查点复位且环序不回退、失速自恢复（R2）；状态全可见（H0）"
-  downgrade_boundary: "删去按序穿环与复位保留（任意穿环即计、碰撞重开）后降为 S"
-  upgrade_boundary: "若环序进度或成绩跨局保留并解锁新航线，升 L-Regular"
-  stress_axes: []
-```
-## 生成任务明确性补充（2026-10-12）
-> 本补充只约束游戏生成输入，不引用 rubric。所有生成器必须以本文件规则和下列 JSONL 任务为准；未列出的装饰细节可以自由发挥，但不得省略已列资产或生命周期。
-### 故事与流程最低合同
-- **玩家身份与当前冲突**：以 §1、§8 的角色/世界/冲突为唯一叙事入口；开局必须让玩家知道“我是谁、现在要解决什么问题”。
-- **阶段性目标**：必须有可操作的阶段目标、至少一次状态变化/升级，并在 §7 的胜利、失败、重开入口中闭环；不能只生成一个无结果的场景演示。
-- **结果承接**：胜利/失败都要有明确结果文案或演出，并回到可重开、暂停或标题入口；视频、音频和 VFX 不得推进未完成的玩法状态。
-### 生成任务清单（JSONL 冻结口径）
-- scene：1 个；必须生成连贯可游玩的空间，不得出现下半部文字、拼贴面板、物体 lineup 或 UI。
-- object：6 个（text-to-3D 4，image-to-3D 2）；object 任务资产为：sky_glider, ring_gate_kit, thermal_column_marker, checkpoint_beacon, wind_stream_vane, takeoff_skydeck。每项只允许一个物体；组合物必须拆成独立任务。
-- motion：1 个；覆盖动作：ring_bank_turn。
-- video/audio/mechanic/UI：分别为 3/14/1/1 个任务；若某项为 0，只能是本案例明确的 N/A，不得默默遗漏。
-### Video / motion / audio 生命周期
-- Video 每项必须写清 `trigger`、`start_condition`、`duration_sec`、`skippable`、`skip_behavior`、`end_condition` 和进入的下一个游戏状态；播放期间不得偷偷消耗计时或改变战斗/任务数值。
-- Motion 每项必须写清 `source_asset`、`trigger`、`start_condition`、`duration_sec`、`loop`、`end_condition` 和 `cancel_behavior`；动作要与对应输入/机制事件绑定，不可只写“walk animation”。
-- Audio 每项必须写清触发事件、时长、`loop`、`stop_condition`、优先级和 ducking；关键命中/提示音必须与事件帧同步，暂停/结算时按 §9 处理。
-### Mechanic / UI / 游玩手感
-- Mechanic JSON 与 §1–§7 配对：每个输入都要有 precondition、state_change、feedback、next_state；必须说明失败/禁用分支。
-- UI JSON 与 §9/F10 配对：HUD、菜单、结算、暂停、错误/禁用态要有 state binding；关键状态不能只用颜色表达。
-- 手感冻结：相机跟随/构图、FOV、碰撞/遮挡、镜头调整与镜头震动必须在 §9 说明；震动反馈必须写明触发、强度和持续时间，并提供关闭设置且不改变判定。
-### VFX 时机合同
-每个特效必须写清 `trigger event`、预备/前摇、active window、持续时间、结束条件、被打断/取消条件，以及和相机震动、音效、UI 的同步关系；命中特效、失败特效、胜利特效不能只写“有粒子”。

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/method_selection.md DELETED Viewed

@@ -1,152 +0,0 @@
-# 优先资产：方法选择与执行边界
-核对日期：2026-10-15。本文是候选方法建议和开跑前检查，不是实验结果，也不是已验证的
-API 配置。评测口径以 `GameFactory-3A/eval/asset_evaluation_plan.md` 为准；
-本次没有改动该方案、原始全集或其他五份现有优先生成 JSONL。
-## 1. 建议首轮组合
-| 类别 | 首轮建议 | 放在哪组 | 选择理由 / 限制 |
-|---|---|---|---|
-| 3D Object | Meshy + Tripo + 腾讯云 Hunyuan3D Pro 商用 API | B1 商用生成 API；逐版本核对开放权重状态 | 三家即可；人物/刚体、T2/I2 分组，保持同输入和低模预算 |
-| 3D Scene | 新增 World Labs Marble World API；保留 WorldPlay/HY-World 2.1 Scene → WorldMirror → 导出，以及 LLM 布局/组合 | Marble 为 B2 商用 direct 候选；另两路为组合方法对照 | Marble 提供世界生成和 mesh 导出；不拿仅视频输出替代 3D 交付 |
-| 自然音 / SFX（看情况吧） | ElevenLabs Sound Effects v2 + Stable Audio 3.0 Large 商用 API | B4 Environment / Foley 子组 | 一个面向音效、一个通用音频基线；先用声音事件和环境音 pilot 验证，不跑成音乐任务 |
-| 中文人物语音 | MiniMax Speech（优先验证 `speech-2.8-hd`）+ ElevenLabs TTS 的固定中文支持版本 | B4 Speech 子组 | 当前 38 条都是中文；固定说话人、情绪映射和完整台词 |
-| CG | Seedance + MiniMax Hailuo（优先验证 `MiniMax-Hailuo-2.3`） | B3；T2V 与 I2V 分开 | 先跑两家即可，不急着加入第三家；按 API 的时长/分辨率能力冻结共同条件 |
-| Motion | MoMask + Puppeteer 对比 LLM 直出；可再加 Meshy Text-to-Motion | 前两路是开放模型链 / 系统对照；Meshy 是 B5 商用 API 候选 | 先满足用户要的两路比较；若 B5 必须有闭源专用生成 API，再加第三路 |
-| T-pose | 同一份冻结准备输入 | 不新增主表 | 两个动作方法共享角色输入，不把图像准备差异算成动作模型收益 |
-商用 API 不自动等于闭源模型。特别是 Hunyuan3D 必须登记云端实际版本，不能把本地
-开放权重版本包装成闭源行；MiniMax 的视频实验也要写清 Hailuo 的具体 ID，不能只写品牌。
-MoMask、Puppeteer、WorldPlay、WorldMirror 的源码/模型发布可在官方仓库核对 [R1–R4]。
-上述 API 的能力入口见文末官方来源；账户权限和实际可用版本仍需 pilot 确认。
-**规模建议**：B1 三家、CG 两家、音频按两种任务各两家；场景优先补 Marble，而不是
-为了凑三列加入不能导出场景的模型。B2 暂时只有一个确认能力范围的商用 direct 候选，
-如需至少两家闭源 direct API，仍须找到并实测第二家，不能用组合方法假充。
-## 2. 为什么按这些方法分组
-原方案 §1/§4 要求闭源专用生成 API、开放模型与多模型组合分开，首轮主表不混排。
-因此保留用户提出的系统比较，但不悄悄改掉主表含义：
-- B1/B3/B4：按相同任务和输入条件比较商用服务，记录模型的权重开放状态。
-- B2：Marble direct 与 WorldPlay + WorldMirror / LLM composition 分 panel 报告。
-- B5：MoMask 生成人形动作，Puppeteer 在本项目链路中主要承担绑骨/蒙皮准备；
-  LLM 直出是另一条系统方法。不能把它们标为两个闭源 motion API。
-- 如果研究问题改成“各种资产生成方法谁更适合游戏”，可以增加系统对照表，
-  但需要显式修改协议，而不是沿用 `Closed-source method` 表头。
-为了隔离动作生成能力，建议先冻结一套人形骨架和白模，两路动作采用同一个映射、
-retargeter、20 fps 和接触检查；角色网格、绑骨差异另在第三阶段端到端比较。
-LLM 直出必须交付轨迹/骨骼动画文件，只有 Blender 脚本、文字或预览视频不算交付成功。
-## 3. 与当前优先清单对齐的阻塞项
-### 3D Object：低模与上下文能力
-现有 200 条保留低模 prompt，且 `decimation_target` 最高 8000。
-建议统一保存原始 API mesh 和固定后处理后的导入 mesh，分别报告；不要只给一家减面，
-也不要把减面后生成的新几何缺陷完全归给原始模型。
-Hunyuan3D Pro 的普通模式中 `Prompt` 与图像输入互斥，不能假设 I2 能同时传游戏梗概。
-这类调用按原方案记为 `reference-only` 辅助组；T2 可以拼接冻结的短版梗概。
-其 3.0/3.1 的 LowPoly 支持不同，先确定使用的版本和后处理政策 [R5]。
-其他 I2 API 也逐一核对文本上下文能力，不能只在 judge 阶段补梗概。
-不要用 `latest` 当作冻结版本。Meshy 文档还提示其 `lowpoly` 模型类型将在
-2026-10-30 退役；现有清单的 `poly_policy: low_poly_priority` 只是实验政策，
-不等于必须调用这个即将退役的 API 类型 [R6]。
-### 3D Scene：交付要有真实场景
-69 条现有场景任���要求 `output_format: glb`。WorldPlay 的视频需经 WorldMirror 重建
-及场景导出后，才与场景任务对齐；只生成视频不能记 Delivery 成功。
-Marble 的世界接口返回 splats 和 collider mesh，并另提供高质量带纹理 GLB 导出。
-建议正式 B2/第三阶段使用后者，保存碰撞网格和世界尺度信息；不要拿无外观的 collider
-mesh 冒充完整美术场景，也不要把 splat 文件简单改后缀作为 GLB [R7]。
-生成和导出都计入耗时/成本；若导出不可用，保留该任务的未交付状态，不替换成全景图。
-LLM composition 固定资产池、资产提供者、坐标系统、规划调用数和修补预算；
-若它额外调用对象生成器，费用和调用全部计入系统方法，不能只记 LLM 的 token 成本。
-### Audio：需要按声音任务选方法，不是一种模型跑全部
-当前非语音 706 条：623 条 `one_shot`、83 条 `ambient_loop`；语音 38 条，全部中文。
-这是分类字段统计；实际循环要求仍以每条任务的 `loop` / 生命周期字段为准。
-非语音时长为 0.15–45 秒，其中 93 条短于 0.5 秒、281 条短于 1 秒、19 条长于 30 秒。
-ElevenLabs SFX API reference 写 0.5–30 秒，能力总览却写 0.1–30 秒，存在官方文档差异；
-开跑前应实测短音边界并保存实际请求/响应，不自行认定所有短音都支持 [R8, R9]。
-Stable Audio 的 API 时长范围也应从具体 endpoint 核对。这里建议验证 3.0 Large 商用服务，
-而不是把已开放权重的 3.0 Medium / Small / Small SFX 当作闭源方法 [R10]。
-若账户仍使用 2.5 API，则固定并单列 2.5 版本，不混写成 3.0 的结果 [R16]。
-共同能力子集用于配对排名；其余任务仍留在第三阶段完整清单中，标注能力缺口。
-解码、重采样到要求的 48 kHz / 24 kHz 可采用同一确定性工具并保存原件。
-短音裁切、长音拼接/循环、生成式延长不是无代价格式转换：如要使用，须预先冻结规则，
-单列 pipeline 结果及成本，不能悄悄改任务时长来让 API 通过。
-语音不得把“游戏梗概 + 角色介绍”拼进需要念出的台词。检查 API 是否有独立的
-instruction/style 通道；没有时仅可使用冻结的 voice/emotion 参数映射，单列标准 TTS
-条件，不宣称模型直接读取了梗概。MiniMax 的 TTS 参数和 ElevenLabs 版本入口见 [R11, R12]。
-### CG：现有任务与 reference-image 协议不一致
-194 条中 190 条 `text_to_video`、4 条 `image_to_video`，但当前全集和优先清单都没有
-参考图路径字段。不能用这批数据直接声称完成“194 条 reference-image-to-video”评测。
-建议明确选择：保留 T2V 子表、Q1 预声明 N/A；同时为 I2V 冻结真实的共同参考帧，
-补齐路径和来源后再运行 Q1。若要全部改成 I2V，应生成并冻结共享参考图，然后形成新的
-任务版本；不能各视频方法自行画图作为自己的参考。
-现有时长 4–12 秒、输出 1280×720/24 fps；Hailuo 2.3 文生接口的原生规格是
-768P 的 6/10 秒或 1080P 的 6 秒，不能把原 JSON 原样发出去 [R13]。
-先冻结共同能力 pilot 子集；非原生任务保留并标注，不隐式拉伸视频来满足事件时长。
-Seedance 使用已接入的实际 model ID，先验证能力矩阵，不将品牌名当成版本。
-### Motion：保留非人形与短动作
-新增 78 条中，76 条人形、G040 一条 vehicle、G030 一条 mechanical。
-两个非人形任务必须保留用于第三阶段，不能因为 MoMask 主要面向人形就删去。
-按 rig group 单列，不支持时明确记录；需要 procedural 交付时另列方法，不冒充 MoMask 结果。
-Meshy Text-to-Motion 的官方接口提供自然语言动作和 FBX/BVH，当前时长要求为
-2–10 秒且按 0.5 秒步长 [R14]。它适合补商用动作 API 对照，但不是现有所有短动作的
-无缝替换。LLM 直出也固定同一骨架、帧数和时长，不只比较好看的视频。
-## 4. 最小执行顺序
-1. 先为 13 个 L 级游戏准备第三阶段的全部既有资产任务；完整性与模型共同能力子集是两件事。
-2. 选 G003/G025/G040 等 3–5 个游戏做 pilot，覆盖中文语音、RTS 压力、机械/载具边界。
-   每类先挑少量代表任务；这不缩减 L 级正式导入清单。
-3. 冻结游戏梗概、任务/参考输入、适用指标、API 版本、调用次数、超时重试和后处理。
-4. 报 Delivery、C、Q1/Q2/Q3、Coverage 和成本，按游戏宏平均；不挑 best-of，也不将
-   未测能力缺口伪装成 API 生成失败。正式分母政策在开跑前固定。
-5. 第三阶段各 repair 方法共享同一冻结资产包。提前固定每类资产的交付来源，不能按
-   单条 judge 最高分挑选，也不能悄悄用 LLM 补产物来遮盖某个生成方法的失败。
-   若比较资产来源，另设因子并保持 repair 方法与预算一致。
-## 官方来源
-- [R1: MoMask](https://github.com/EricGuo5513/momask-codes)
-- [R2: Puppeteer](https://github.com/Seed3D/Puppeteer)
-- [R3: HY-WorldPlay](https://github.com/Tencent-Hunyuan/HY-WorldPlay)
-- [R4: HunyuanWorld-Mirror](https://github.com/Tencent-Hunyuan/HunyuanWorld-Mirror)
-- [R5: Hunyuan3D Pro API](https://intl.cloud.tencent.com/ind/document/product/1284/75540)
-- [R6: Meshy Text-to-3D](https://docs.meshy.ai/en/api/text-to-3d)
-- [R7: World Labs World API](https://docs.worldlabs.ai/api)
-- [R8: ElevenLabs Sound Effects API](https://elevenlabs.io/docs/api-reference/text-to-sound-effects/convert)
-- [R9: ElevenLabs Sound Effects 能力总览](https://elevenlabs.io/docs/overview/capabilities/sound-effects)
-- [R10: Stable Audio 模型及商用 API 入口](https://stability.ai/stable-audio)
-- [R11: MiniMax TTS](https://platform.minimax.io/docs/api-reference/speech-t2a-http)
-- [R12: ElevenLabs 模型](https://elevenlabs.io/docs/overview/models)
-- [R13: MiniMax Hailuo T2V](https://platform.minimax.io/docs/api-reference/video-generation-t2v)
-- [R14: Meshy Text-to-Motion](https://docs.meshy.ai/en/api/text-to-motion)
-- [R15: Tripo 开发者入口](https://developers.tripo3d.ai/)
-- [R16: Stable Audio 2.5 官方发布与 API 入口](https://stability.ai/news-updates/stability-ai-introduces-stable-audio-25-the-first-audio-model-built-for-enterprise-sound-production-at-scale)
-Seedance 的本地封装 `GameFactory-3A/models/gen_cg_video/seedance_model.py` 已登记
-model ID 和官方文档入口；本次网页抓取未能直接读取该火山引擎文档，因此不在本文
-宣称已核对其全部时长/分辨率规格，开跑前仍需 API pilot。

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt DELETED Viewed

@@ -1,11 +0,0 @@
-# G039_sky_ring_flight / 3D_object requirement
-Source of truth: ../general_requirement.txt
-Frozen task inputs:
-- sky_glider: Light twin-wing courier glider per reference image, canvas wings with postal red trim, light wood fuselage, brass propeller cowl, clear forward axis with origin at fuselage center of gravity, game-ready PBR, Y-up
-- ring_gate_kit: Floating sky-island ring gate per reference image, brass-framed torus with beacon lamps on rim and hanging pennants, decorative shell only for 12 instanced rings at radius 6 and 4, game-ready PBR, Y-up, pivot at ring center
-- thermal_column_marker: Semi-transparent rising air column marker with layered shimmer rings and small floating motes, cyan glow readable from distance, radius 10 zone visual, single object, Y-up
-- checkpoint_beacon: Sky rescue checkpoint buoy with breathing beacon lamp, small canvas pennant and brass chain, readable from flight distance, single object for 12 instanced beacons, Y-up
-- wind_stream_vane: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up
-- takeoff_skydeck: Cliff-top takeoff deck for a courier glider with wooden launch rail, canvas windbreak and beacon post, light timber construction with brass fittings, single object, Y-up

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/localization_integrity.json DELETED Viewed

@@ -1,91 +0,0 @@
-{
-  "created_at": "2026-10-16T11:10:14+00:00",
-  "parent_plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
-  "original_records_archive": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/records_before_localization_eb602026d1218ea6.zip",
-  "archive_sha256": "3c0dc12c14579072f183b445b9776221474a8d20b0ddfc7de5a2875c1cc4832f",
-  "records": [
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/meshy/obj200_meshy_tripo_20261015_v2/asset_task_index.json",
-      "before_sha256": "3052eb2d0b2ff9aedc6030e2996044f1fea814186097a824a412b2b6b6509f22",
-      "after_sha256": "3052eb2d0b2ff9aedc6030e2996044f1fea814186097a824a412b2b6b6509f22"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/tripo/obj200_meshy_tripo_20261015_v2/asset_task_index.json",
-      "before_sha256": "884815d60d19e1efdf310b046bf469b53cfc9c41a8a89abe410924ce0e9778de",
-      "after_sha256": "884815d60d19e1efdf310b046bf469b53cfc9c41a8a89abe410924ce0e9778de"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/meta.json",
-      "before_sha256": "9913773ebb52573ccc240e93c79adae32c5eab727ac4f6c7e9e8356aa188ddea",
-      "after_sha256": "9913773ebb52573ccc240e93c79adae32c5eab727ac4f6c7e9e8356aa188ddea"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/tripo/meta.json",
-      "before_sha256": "e4d9739a275ef147e3e6f1370d3b52ed913c6e56c518c2e2d51dc12644f56032",
-      "after_sha256": "986c5559e9e37e05572bc2de92223557e9d66c1497116d1a76b39194eaa95441"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/render_meta.json",
-      "before_sha256": "81ab429b16cbd258935bf7e191b69077096631c2d3c3ffc0c0ffd57693ecb7dc",
-      "after_sha256": "81ab429b16cbd258935bf7e191b69077096631c2d3c3ffc0c0ffd57693ecb7dc"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/render_meta.json",
-      "before_sha256": "55e1dc5cab226eaf8ba6d2de02458dac14e7599615d64aecbdcd3cf7309f3745",
-      "after_sha256": "55e1dc5cab226eaf8ba6d2de02458dac14e7599615d64aecbdcd3cf7309f3745"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/qa.json",
-      "before_sha256": "eecb95b04429594af21150fab8ea44b54a60a4e5289f6bcf8bfdefa04355f78c",
-      "after_sha256": "eecb95b04429594af21150fab8ea44b54a60a4e5289f6bcf8bfdefa04355f78c"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/previews/import/render_meta.json",
-      "before_sha256": "3979f171b0a2f3ea895844e15b97a09f7aeed7df8aba6a15af18a798cd8dc02b",
-      "after_sha256": "3979f171b0a2f3ea895844e15b97a09f7aeed7df8aba6a15af18a798cd8dc02b"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/previews/native/render_meta.json",
-      "before_sha256": "a4193e411ff5d22fa23707dfdc46b9dc2f5a296e5b8bd67e10e5a12592df674d",
-      "after_sha256": "a4193e411ff5d22fa23707dfdc46b9dc2f5a296e5b8bd67e10e5a12592df674d"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/qa.json",
-      "before_sha256": "3e8f5bbf4612683e4ff41378879a1c5afe1350214dc50d690eed7dc391d65e45",
-      "after_sha256": "3e8f5bbf4612683e4ff41378879a1c5afe1350214dc50d690eed7dc391d65e45"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/meshy/asset_generation_report.json",
-      "before_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3",
-      "after_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/meshy/asset_manifest.json",
-      "before_sha256": "325dca72cd066ac50607a41d7168f4ea52472c2afe2b92dee314b0de210fdeb3",
-      "after_sha256": "cbe68fba970df90e8334487798fc9ac20a5b95b7cddd44a6195dc721271e41f6"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/meshy/meta.json",
-      "before_sha256": "ac48050248f74b3e8050849fc0c6ed2b542c57526a0571fd141f6a4790beecee",
-      "after_sha256": "ac48050248f74b3e8050849fc0c6ed2b542c57526a0571fd141f6a4790beecee"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/tripo/asset_generation_report.json",
-      "before_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3",
-      "after_sha256": "2009bc32baac83014bf96be412895526010fae5e86e37b7c9286a5639cb59ca3"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/tripo/asset_manifest.json",
-      "before_sha256": "e2dcb107bfed3245da3925b14105c0c49901c0ba14ebdc4524dc1fe6e765f91a",
-      "after_sha256": "9a004e8c561a52c67498e559cf480dbc851c8d9e721cfadb820ead11f7855148"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/pipeline/G039_sky_ring_flight_pipeline/obj200_meshy_tripo_20261015_v2/tripo/meta.json",
-      "before_sha256": "3accc0be0e8fc146fca78033f2d1ef39cdf4c932bcadee5b0df030761585aab2",
-      "after_sha256": "3accc0be0e8fc146fca78033f2d1ef39cdf4c932bcadee5b0df030761585aab2"
-    }
-  ],
-  "api_calls": 0,
-  "meshes_changed": false,
-  "absent_artifact_links_cleared_for_undelivered_inventory_rows": true
-}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/frozen_parent_plan_original.zip DELETED Viewed

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

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/records_before_localization_d287b99e24e5c8fa.zip DELETED Viewed

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

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/records_before_localization_eb602026d1218ea6.zip DELETED Viewed

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

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/meshy/G039_sky_ring_flight__G039_sky_ring_flight_obj_005.json DELETED Viewed

@@ -1,88 +0,0 @@
-{
-  "submissions": {
-    "0d874e6bc269a6a97496fb701901483c7c0580491fe2d534a4658ff0e6a913d7": {
-      "endpoint": "/openapi/v2/text-to-3d",
-      "reserved_credits": 20,
-      "status": "created",
-      "remote_id": "01a142f7-70e3-73f4-ab13-bd13ef695829",
-      "response": {
-        "result": "01a142f7-70e3-73f4-ab13-bd13ef695829"
-      }
-    },
-    "c8e1ddfa9d9796f0b0f5f644db2b20facd0384f53d5a68b52b1463349bb1108d": {
-      "endpoint": "/openapi/v2/text-to-3d",
-      "reserved_credits": 10,
-      "status": "created",
-      "remote_id": "01a142f8-19ab-7259-962c-aade734abc46",
-      "response": {
-        "result": "01a142f8-19ab-7259-962c-aade734abc46"
-      }
-    }
-  },
-  "results": {
-    "/openapi/v2/text-to-3d/01a142f7-70e3-73f4-ab13-bd13ef695829": {
-      "id": "01a142f7-70e3-73f4-ab13-bd13ef695829",
-      "type": "text-to-3d-preview",
-      "mode": "preview",
-      "name": "",
-      "model_type": "standard",
-      "seed": 1043,
-      "prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-      "texture_prompt": "",
-      "texture_image_url": "",
-      "status": "SUCCEEDED",
-      "created_at": 1792124878520,
-      "progress": 100,
-      "started_at": 1792124878524,
-      "finished_at": 1792124916827,
-      "task_error": null,
-      "model_urls": {
-        "glb": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.glb?Expires=4945708800&Signature=atUIywbEpRp6NHnFvzkJAXcknbtm51g0GUOmJN6PGhet5JCvpKnj29KypFnqimi36dZl987L5N~pAu5B0YdcPbd8iEenpZkiaFhvi4z2ewoqAR~aqwH~OChGEyzuyvhSOGsSVyKCJTWcsHjIh54l4PUIh-P~uzX3YxL~LB4r6ci2cyzEZVcZKFdBkF33XfpsOM7FSUtbKa~3H~BvMd25f4EHCyC3ZKPwYhH6pbrGF4UR1LYxGpxPCqxBLTyqaUUndnrCNeaT9L65mcrGp8w4PRl43oK3ZkmlmTStqrMdKMGI55F9umWJ9z8v6lO5SpeXmQ7A2oMfglgr3NM3t4xCfA__&Key-Pair-Id=K1VGYTHIYLM9UM",
-        "fbx": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.fbx?Expires=4945708800&Signature=hvHZoOpP4oeyo5TLZO-pZeVVdc5VzcMRjIDTfBJUZFewZDhRPCDfm9iJoH6tnLBGYA~JFR69~vVRVE84ezhOgxz5Se~fZq48NizyT8zGDELpofdfjhGzknfawL~mqaqInXP4CBYSAVQKKgSCUKlTB2unaRNGObIxL21BCPgkzh83i5wazbXgkTKkuDTAi1AMdh-7FTvxPcP9n5RB~npky3asM7HVJfzoTHoIOY8dFRxCt4WvHvFBzJ8pmRpDsexnjyFzrGHLVYpVomYbKw9sBTbvk6d~7FA~C2i1ZyDS8-w8FRXSE2PpU0l-iLKPMXC9JdALx7nURYFbEMDAC8F5Xg__&Key-Pair-Id=K1VGYTHIYLM9UM",
-        "usdz": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.usdz?Expires=4945708800&Signature=W7juJGbjyLit0UPLJLFqpXcA35Mg7y4KfGYV16QUxWhoyRTCn2J-On5fLfD96BW3NadHV6aTQkSTB~oCGze31sZcIXDqtlbBBi0P9gvbCyz74oAga5EaSdNbROSJnvRp5OFsdeSDBnVBzTjwu4-5yXxEb~8nOsW~dk2P-ERw4li~g0XlzcGtRL14Fw~su~B6mZS0aChsqp0U-TNbJU9TzqVrY2~-jZdXeeMmthmyVP78D-QWNhGMUCFJcs8wNZe2V9p6PG-4KpXtno48jra-UArB4GBP~gUlKUK0fIbq6BGs3rgoSuaaOZ~9~Og8ME5PUfvu92iMdIwVVOzOdVMl4Q__&Key-Pair-Id=K1VGYTHIYLM9UM",
-        "obj": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.obj?Expires=4945708800&Signature=RTqtRPssU1XmHlhtzes2tbxuMsCBFRF9jzUU8ZIpIXjrMIqh4PB~jVHITS4A4Rq1UVc2LEPtz4zL0WN5Lt1~Ng3LTc4xu7-4MC1hhnPBbh8Hlb-Df-saqifI~ppqzciOAGck1tcJdduzxRlJ8Sfqi-lKqovbgTMC64xqDaE7hr15Zh1rApIqBPHd-pgfS3VkmuM7bAcovZlN6FN0MV32T6EGmTu6P78K5GMk0PaEv2Z~e1VyPt1xMDHxcBl2qCMFK~GFQ9XrHAqDqHUok0-4D3XZFOkMY-tVKNDd9PnZoDWbTg6LbPRVML2QkT-VmhRqag-P7GvyHSixltnYczuKAQ__&Key-Pair-Id=K1VGYTHIYLM9UM",
-        "stl": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/model.stl?Expires=4945708800&Signature=CMVmpymoRFfWtt9kyeuO3okbb89Cyt~x5fZDDAMcIUiMFpRpUneZ6jHz-NrNm-dUOtTNnF7aC7h8qTfytUZW57rw1Ee4XJrgEK0XeIK5QX96EHDecwWm0kA4XpwUexKn46e4CC~fDuEm2xYGbZopHozZJLbDu0cmAd-XlEUkjphos3464SLCc643t0ttAqLeUN83ivrGRN3ST2fndugr3hlvYcNTl19sqkGDxz2hbGsHO43xhH8T2xK3TEEm92MMqsUUYGZTv8uecBRTKh42Scyn5FbX-0WPWQcFfco5uTRsIOzRQ49GlzAn0~2d3OWqztJx~aWE7YBAg7k8OpLFPA__&Key-Pair-Id=K1VGYTHIYLM9UM"
-      },
-      "thumbnail_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f7-70e3-73f4-ab13-bd13ef695829/output/preview.png?Expires=4945708800&Signature=eGu0ZemuCL2gLjPZfQu0bAWDBbLH54OWdDO7RUTfXVAjYI3mZzLdOgJUHRfsP6IACTRLZlEgpe4rdzyz1RlhRtMnEInxRsxso3vFMQbndLzSfZPE94IiBv0xZVrzNgXUkjRNIF6wHWK32FVgK~Rxju8SE1nok6LAXrraW2vu-UZc-bj25GCqu2REPyrN60ERv50fJBeV5iyzUjMUh6F5XRK7B2d0zlEntwUwOnQwK32uG3RZ8Ra3Qk~jKTTnNyp3F-CgCl1bKHDAeQgonBGUtPzIwIYBTmTAMwKVB6O-OLJWkMHKPtgvn94~0SgvteM5zTy3E~0p2RbDslTEx~uwyg__&Key-Pair-Id=K1VGYTHIYLM9UM",
-      "texture_urls": [],
-      "consumed_credits": 20
-    },
-    "/openapi/v2/text-to-3d/01a142f8-19ab-7259-962c-aade734abc46": {
-      "id": "01a142f8-19ab-7259-962c-aade734abc46",
-      "type": "text-to-3d-refine",
-      "mode": "refine",
-      "name": "",
-      "model_type": "standard",
-      "seed": 1043,
-      "prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-      "texture_prompt": "",
-      "texture_image_url": "",
-      "status": "SUCCEEDED",
-      "created_at": 1792124918208,
-      "progress": 100,
-      "started_at": 1792124918215,
-      "finished_at": 1792125001169,
-      "task_error": null,
-      "model_urls": {
-        "glb": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.glb?Expires=4945708800&Signature=OS63L7aKhQAW9LjUM4S88caGUM46yvOfIQo2ohLkvL~nFADDPLJmRFRY49dMFY-PuW58XbO~2zyxsBBdPMlXFG1Ia3gAQQKZP-qLytUFlAyL3n0ifhAcgFeYWRb6B4Pj5mw07VLuFhdJOmGwITGyvqnNWrSFLtBQeQsWf8dUM1fJGGKirdFo0X9gRSPa94kzCxhdWOiqs~RDXr~DJbaCPdQnQJVluosgBAO08hZY2VkX2N4nT-LWdawMt8Dc0X27CRDr0s8YcKKvc~kSO70XDpIlc-oWT7scqsgFA1a5-VXWzSW5qJ0AuZVH3bzMs7HK~lESjd3uOTXAfvODS-wh8A__&Key-Pair-Id=K1VGYTHIYLM9UM",
-        "fbx": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.fbx?Expires=4945708800&Signature=pFAm5WARO6UJ9Iu7IcrmsXqbE7pqLhwljANqNBIFItjMtOwS1FNWs1S~jzPBrGXD1yjRtcv8cs5LyYGJRCx9SbkHrzILSXmGWYtwPAMVp1B0vpzTHCd8UHOURGRez8GiJbBjeowLJVrzKqZEW2k~hVTai6nzaXfwbh-E3-qXGNVWWPOk6oOae~kSad-yY-mPb0pBoISjw0KWSagFptceabbdawGAUKWl4DOj5vcsLzpi~GyxXndk-cAAR18pZ69Zhu8kxgEseWJz7VPWMdZciI92w6u8PDaN2zGijyBjLIhWc7gc0jM6-bMMKqlrOL3ZVg9E3ak1LBRXiu0T7b4Gcg__&Key-Pair-Id=K1VGYTHIYLM9UM",
-        "usdz": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.usdz?Expires=4945708800&Signature=kRJqBuAXQPdb~3xarxYG1tpyRN7HZTL4J7h0hToAEJBhdk-wCuxSzLymVVcVan-Yfvj9qO9ugAqdYMwKubyUARzcEQ81oEn8tIpPbEXsiKRltTriz5dt0MdW7FTcWUW8tfcJMizH~nBP6G~ej58J9nTgC1QtFsuErrTn5GSbk9atZBZ2GetSjK0ilgnZfHsRo6EuFuAKnpfQO28ZfFvPl8BWPFapbtY8qQIcXq9lo3wkLDCScZH1RSFX-S5QPtLEgwQq1IkSqtbicArnNsIV3mHnPznpxqR4AOVeNo2sO6YdddLiPpdgjgAxUCeQv0z8X36-t0F5qovLSwnXZIiWBQ__&Key-Pair-Id=K1VGYTHIYLM9UM",
-        "obj": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.obj?Expires=4945708800&Signature=gP9aGLq9ssk8YDqRqs4VSvxCsxkF4QDD4jLOEPZD~ufbR0CH8j4V5WISuUOsH1Y4MQJl4cY6RGsPEp9I26NGMLgzIpZsE0HIdCs6-Qul9nU3pB7BsNp5Pvum2itpvSYnb9rKKEte4zoNUBMUdTNTjxYtvjBVDIqSS4R1-pNy28sSZHubYJQeF0WxoUo-XlJGy9ahao9~QDkgegqp9xj3mUc3IDjKgJKJagNmruTlF543PLWgJnW5CUrzJhSei1Ua-gXiYRDWCgGwNZDiFdVdU-l7D5hOh3cdGUUtwvM2xgnXG3D1U8C~cNihc3yE4GZRD7N4IMGaziK4f~m7vM42sA__&Key-Pair-Id=K1VGYTHIYLM9UM",
-        "mtl": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.mtl?Expires=4945708800&Signature=Q7FKC~7lRps2Ie6dO5FDvr4TFLgBtY2uGiR6DY2iMk7eL3gFRnX439BFUzd4qZrOk-xDc2Yo3ahcw2r1CZQgyyqZroIIE1J7smxqrfNrqoZSqPCgV6ld6evkyjKPzdmB0Cp0T6DpRVIdU0umMGDvOa1GXqjT3mxnWAHYHLJovtB~4Ewif-PSDJRHElxiG4PrHUyUOvgx82PNEz9MrEpYpwvSOK4gy0~OKR3MKiqpfO0XMHcdZ4AhIJkJJe5pqvo6G6QajTF5IAziGIoOJHI5O0-0rQuASKpcCvRmhz8Tui9Nc2XBkfGwtNMSFlsKbjUPDUadR3iLVG-~st1QNa-0mw__&Key-Pair-Id=K1VGYTHIYLM9UM",
-        "stl": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/model.stl?Expires=4945708800&Signature=m89BWE2hHm0m01cPWlwHBpbSCX~neuwAaXr520OPM0oXqr7qe4c6f7zOq-J7b-M0R8uHsr0PC33NiBmNN4qMwsKDzijaZm6RVVyP4o5aRc2OjGEUmP4TggUpXb4qpAOaWV0-TAq26pL4eV8t5K6pi9AvAeHSJmXgyHIEzNxKgxOozQoBAt775pmFyUyj19GXok0YA6bj3eshj3BV0zVmLzFWcjee2AFrYPuTZjPhSpbdbnZObMWJJ3nasG3FTXQWoGib4TXfGGHcCtyrGSfiZwKVEqPDqj4253JcI2YFQ5dwid1XhuaTk6JghmDN85L~VowMTsiDFGqOqcSwlJ7R2w__&Key-Pair-Id=K1VGYTHIYLM9UM"
-      },
-      "thumbnail_url": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/preview.png?Expires=4945708800&Signature=pf9kXoRiecSv9ApuG7GkKsojX1hT~6QZiHhcSPaBUpSHPflxfcyPPssPN2mCsnUhKEkh7Mj3oJxnwhKVgNz5hVARIcMILE0zgXp~mT4YK6cmt4nr2C1NJmJvhf35MmMDJIhfOQiZtR8gVylqYs790e3HHRFqeY033CfPtlhybZRMVoefX4a50x1CkD-ar54OvG-HGWNdiCO6XfCuzXNJ2hN5ocbnWLEf32Ga8Lk4Kj4w5kmhOQsrS5XCowDuDBnk6k2-viXZcxOf4j~pUOr1PY7gaTWBZ1avXGZqH3B9IEUWvHzHP87J4XvSUpC8lnugxH1tnCmPufACYm26utxkhw__&Key-Pair-Id=K1VGYTHIYLM9UM",
-      "texture_urls": [
-        {
-          "base_color": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0.png?Expires=4945708800&Signature=OvK5Wpl5iaoO5bu~ZYWJY63LAmDF9aMsWwqvPkrGXf5xGrB2BY2gfYljAy5rXHhFG5zclXmY-Ro1e5sPtna2qemQCMJUX9j39gH9Uf~Ng5Ft59athq0EJbvtHFRMUQFnAajWuBiWssFSZrXdX6RBp~Nfbuxf2Zui54giDDqRPJXvXzVr3B9yqpP9tSbczyqZfIFh85GcQcKBGLgdi6UiqDvwC0Sjd271f0fO4VyLJOE3OmnuStCjq4xYYwlKMyqV990hLBQE9uPQINPj4~zkKt8S~gigBoqX0zbKI5HDgV0y53tekerM388wjz3-zniyE35IDKok~lkk1XIYhfbbhw__&Key-Pair-Id=K1VGYTHIYLM9UM",
-          "metallic": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0_metallic.png?Expires=4945708800&Signature=NLtsIYZ9qPwS2~BjVpwjNEIjq-NjBQVdaqou0SOsahxgSnOXSeVrTn6AE8IOPvMTDHzClo1jwfl4QY9gQbWXZe7pyf0rWStvUKEJi4G0UbrXAICfwdKTLtnSjtnZVSBHfSYEhy3wM7KNOjeIaP9uKbSg~oRWpzWp0GSsL7Ng1Az-ZvCQaGtUE9D8x-hBeTh9WH95VzDQ~jqEwSawmn8eJYvo7ehaDzHw-y1XNURcxxVJDBJEQtf8GGSTelbU~QTiuZNqoeCRgfwqEmiSxsfpA~Vsd3vkd6aP62xzr844Kln8r7NJwjyF8obSEaN4OslhxkNrYrnBpXkTk3jbKXh-1w__&Key-Pair-Id=K1VGYTHIYLM9UM",
-          "roughness": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0_roughness.png?Expires=4945708800&Signature=deDzr7dgztYg-qQCFF-vtq2GCVsokRaq10BK3hrkJU5yFaP3P-YNHmXV3WhCO1pfm1IYQiMBTvmfX2O1Tp2AdEOFIfJTv1ltgnxRUWaBEEAHLL3VgUOyHX-zN0UkFWgNV0OMOHzv2e0xsC6iX8yuY0~su6JUX8H1CvtF0jGKfxL4k1-M28ZzIwqlzGuD6tdi8WVso4FzNZ1tk3cvfivrTqjqKvrcmXjG0OVBV4oS6AMsYh2ZV9u-lWLocEn3-7gBbHxOzGqe2TVMhWeAlT~H8wyNn3jgMh6lL40Y8RHGpLizGNyN0DUHzEpWXdP6L5ZLCYd3hnCWqKy7qeb64lakcw__&Key-Pair-Id=K1VGYTHIYLM9UM",
-          "normal": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0_normal.png?Expires=4945708800&Signature=gbgobNdgUbtp4ZHyZDtHme~nmydZ9BwCkhZv2csiYszlN1IF1yYAPKUwAZPWqcMh-yMwjuzdpNkTvYL9zRH79OEtSD2hZuAkVkAMOOJeeI661oobBg3XGk0ts~IJInYkq8eaTv9JyC4omJY2SES5g97GtV25G0JsBYIPFLReoWzJOb3pltyXrxWQKcK-zaxVphBXOqJUrOrZPb--Ew7tH4PuTSeJUdbgDGi1M2iOcRVLictka5qfZ~OQylw81fgqw8wah0tv339~t3xS4-1OiNaOKLuS56jYumu7o0eHudIiAX-O9IkFWINWC0Zy0uaFdOZydmsnlqjc60Znvrf6KQ__&Key-Pair-Id=K1VGYTHIYLM9UM",
-          "emission": "https://assets.meshy.ai/8f6e5ce2-d8d8-44a6-a7ed-c92b05e979af/tasks/01a142f8-19ab-7259-962c-aade734abc46/output/texture_0_emission.png?Expires=4945708800&Signature=UEgmoyM1yklAGUtzK7Nr-AN5WL6OWzMabQ4HvgioweDTn7qrEF~CDHAbnd1mWPJeNL3eqJj42nj7l8ouB8B2Xmd86ieBvxESLBQOjHWlcwlM9xSU17p24AUC6W-rzAmeffWGF5~J~e8hs9r7EG4Rl22wxgqvyT99DbTf0xYLOvbs-uwQS5cdFgCnuDPJh9ztVISI7INJIIoW-6KsYj8-aN9gQJTPRzB0bV0c7A4n5xVWHHobmCSPdrkWrHJpOiIdMgHLa2aCkcCkQYwyJ75ifINjkMcW3SHRonwvZsri~tL4qb61HDVi2JHINNhJFy5vKy~VkNceNimz5kum~QcLgA__&Key-Pair-Id=K1VGYTHIYLM9UM"
-        }
-      ],
-      "remove_lighting": true,
-      "consumed_credits": 10
-    }
-  }
-}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/tripo/G039_sky_ring_flight__G039_sky_ring_flight_obj_005.json DELETED Viewed

@@ -1,54 +0,0 @@
-{
-  "submissions": {
-    "d27ea0c549f2f38bdf92e11e71c077f1d03d1930e6715a34f9e63e3f5649c127": {
-      "endpoint": "/generation/text-to-model",
-      "reserved_credits": 30,
-      "status": "created",
-      "remote_id": "f242bcce-d29e-4a07-a20c-019277c9280b",
-      "response": {
-        "code": 0,
-        "status": "success",
-        "data": {
-          "type": "text_to_model",
-          "status": "queued",
-          "task_id": "f242bcce-d29e-4a07-a20c-019277c9280b"
-        }
-      },
-      "reported_credits": 30.0
-    }
-  },
-  "results": {
-    "/tasks/f242bcce-d29e-4a07-a20c-019277c9280b": {
-      "code": 0,
-      "status": "success",
-      "data": {
-        "type": "text_to_model",
-        "status": "success",
-        "progress": 100,
-        "input": {
-          "pbr": true,
-          "prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-          "texture": true,
-          "export_uv": true,
-          "face_limit": 8000,
-          "model_seed": 1043,
-          "texture_seed": 1043,
-          "model_version": "v3.1-20260211",
-          "smart_low_poly": true,
-          "texture_quality": "standard",
-          "geometry_quality": "standard",
-          "texture_alignment": "geometry"
-        },
-        "output": {
-          "model_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/f242bcce-d29e-4a07-a20c-019277c9280b/tripo_pbr_model_f242bcce-d29e-4a07-a20c-019277c9280b.glb?auth_key=1792224016-ddtirljj-0-3396bfeef393d8fe2b5f9cf64c602863",
-          "rendered_image_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/f242bcce-d29e-4a07-a20c-019277c9280b/legacy_mesh.webp?auth_key=1792224016-bibrcxrc-0-b77b51744d52f9e52e969d362bd4a51e",
-          "generated_image_url": "https://openapi.cdn.tripo3d.com/tcli_8a234d301b1e472ebe10d73adcd43336/20261016/f242bcce-d29e-4a07-a20c-019277c9280b/text2image_f242bcce-d29e-4a07-a20c-019277c9280b.jpeg?auth_key=1792224016-htafmuue-0-d272e653024adc3a8b6359380251d71e"
-        },
-        "task_id": "f242bcce-d29e-4a07-a20c-019277c9280b",
-        "created_at": "2026-10-16T07:56:09.040945Z",
-        "completed_at": "2026-10-16T08:00:13.546338Z",
-        "credits_consumed": 30.0
-      }
-    }
-  }
-}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/cloud_api.py DELETED Viewed

@@ -1,557 +0,0 @@
-"""
-models/common/cloud_api.py
-Shared plumbing for closed-source ("cloud API") model wrappers — the part of
-Tripo / Meshy / Rodin / ElevenLabs / Kling wrappers that is identical no matter
-what the provider generates.
-Contract: `agent_skills/develop_harness/api_model_require.md` R9.
-This module owns R9.6 (submit → poll → download behind a blocking call),
-R9.7 (API key from the environment, at call time), R9.8 (response cache, so a
-re-run is not re-billed) and R9.9 (retry with backoff, retryable vs. terminal).
-It knows nothing about 3D, audio or video — only HTTP, money and failure modes.
-Dependencies: stdlib at import time; `requests` is imported lazily on first use
-so `test/harness/smoke.py` keeps working on a machine that does not have it.
-Usage:
-    from models.common import cloud_api
-    key = cloud_api.require_api_key(None, "TRIPO_API_KEY",
-                                    "https://platform.tripo3d.ai/api-keys")
-    client = cloud_api.CloudAPIClient("https://openapi.tripo3d.ai/v3", key)
-    data = client.request("POST", "/generation/text-to-model", json={...})
-"""
-from __future__ import annotations
-import hashlib
-import json
-import logging
-import os
-import time
-from pathlib import Path
-from typing import Any, Callable, Iterable, Optional
-logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
-#: HTTP statuses worth retrying — transient by nature.
-RETRYABLE_STATUS: frozenset[int] = frozenset({408, 409, 425, 429, 500, 502, 503, 504})
-#: HTTP statuses that will never succeed on retry: bad request, auth, quota.
-TERMINAL_STATUS: frozenset[int] = frozenset({400, 401, 402, 403, 404, 405, 413, 415, 422})
-# ── Errors ────────────────────────────────────────────────────────────────────
-class CloudAPIError(RuntimeError):
-    """
-    Base class for every cloud-API failure.
-    Attributes:
-        status:   HTTP status code, when the failure came from a response.
-        task_id:  Provider task id, when one had already been created — keep it,
-                  a timed-out task usually finishes anyway and can be fetched
-                  later (`api_model_require.md` R9.6).
-        payload:  Decoded response body, truncated for readability.
-    """
-    retryable = False
-    def __init__(self, message: str, *, status: Optional[int] = None,
-                 task_id: Optional[str] = None, payload: Any = None):
-        super().__init__(message)
-        self.status = status
-        self.task_id = task_id
-        self.payload = payload
-class CloudAPIAuthError(CloudAPIError):
-    """401 / 403 — the key is missing, wrong, or lacks the entitlement."""
-class CloudAPIQuotaError(CloudAPIError):
-    """402 or a provider-specific "insufficient credits" body. Terminal."""
-class CloudAPIRequestError(CloudAPIError):
-    """400 / 404 / 422 — the request itself is wrong. Terminal."""
-class CloudAPIServerError(CloudAPIError):
-    """5xx and connection-level failures. Retryable."""
-    retryable = True
-class CloudAPIRateLimitError(CloudAPIServerError):
-    """429 — retryable, honour `Retry-After` when present."""
-class CloudTaskFailed(CloudAPIError):
-    """The provider accepted the task and then reported failure."""
-class CloudTaskTimeout(CloudAPIError):
-    """The task did not reach a terminal state within `timeout` seconds."""
-# ── Credentials ───────────────────────────────────────────────────────────────
-def require_api_key(value: Optional[str], env_var: str, signup_url: str,
-                    *, who: str = "This model") -> str:
-    """
-    Resolve an API key, failing fast with an actionable message (R1.6 / R9.7).
-    Args:
-        value:      Explicit key passed to the constructor, or None.
-        env_var:    Environment variable to fall back to.
-        signup_url: Where a human gets a key.
-        who:        Name used in the error message.
-    Returns:
-        The key.
-    Raises:
-        CloudAPIAuthError: no key available.
-    """
-    key = value or os.environ.get(env_var)
-    if key:
-        return key.strip()
-    raise CloudAPIAuthError(
-        f"{who} needs an API key and none was found.\n"
-        f"  1. get one at {signup_url}\n"
-        f"  2. export {env_var}=<your key>          # never commit it\n"
-        f"     (or pass api_key=... to the constructor)"
-    )
-def redact(key: Optional[str]) -> str:
-    """Key fingerprint safe to put in a log line or `meta.json`."""
-    if not key:
-        return "<unset>"
-    return f"{key[:4]}…{key[-2:]} (len {len(key)})"
-# ── HTTP ───────���──────────────────────────────────────────────────────────────
-def _requests():
-    """Import `requests` lazily with an actionable message (R1.5 / R1.6)."""
-    try:
-        import requests  # noqa: PLC0415
-    except ImportError as e:  # pragma: no cover - environment dependent
-        raise ImportError(
-            "Cloud-API model wrappers need the `requests` package:\n"
-            "    bash scripts/asset_env_setup/cloud_api_install.sh\n"
-            "    # or simply: python -m pip install requests\n"
-            "(only needed for the API backends; the local-weight models and "
-            "test/harness/smoke.py do not import it.)"
-        ) from e
-    return requests
-def _truncate(payload: Any, limit: int = 600) -> Any:
-    text = payload if isinstance(payload, str) else json.dumps(payload, default=str)
-    return text if len(text) <= limit else text[:limit] + f"… (+{len(text) - limit} chars)"
-def classify_http_error(status: int, body: Any, *,
-                        task_id: Optional[str] = None) -> CloudAPIError:
-    """
-    Map an HTTP status onto the right exception class (R9.9).
-    The body is inspected too: providers happily answer 200/400 with a
-    "not enough credits" payload, which must not be retried.
-    """
-    text = _truncate(body)
-    low = str(text).lower()
-    # Providers phrase "you are out of money" in prose, and the status code alone
-    # does not distinguish it from a bad key: Tripo answers **403** with
-    # "You don't have enough credit to create this task". Matching the body first
-    # is what keeps "wrong key" and "no money" apart for the caller.
-    if any(s in low for s in ("insufficient", "enough credit", "enough credits",
-                              "out of credit", "purchase more credit",
-                              "quota exceeded", "no credits", "balance")):
-        return CloudAPIQuotaError(
-            f"HTTP {status}: out of credits — {text}", status=status,
-            task_id=task_id, payload=body)
-    if status in (401, 403):
-        return CloudAPIAuthError(
-            f"HTTP {status}: authentication rejected — {text}", status=status,
-            task_id=task_id, payload=body)
-    if status == 402:
-        return CloudAPIQuotaError(
-            f"HTTP {status}: payment required — {text}", status=status,
-            task_id=task_id, payload=body)
-    if status == 429:
-        return CloudAPIRateLimitError(
-            f"HTTP {status}: rate limited — {text}", status=status,
-            task_id=task_id, payload=body)
-    if status in TERMINAL_STATUS:
-        return CloudAPIRequestError(
-            f"HTTP {status}: request rejected — {text}", status=status,
-            task_id=task_id, payload=body)
-    if status in RETRYABLE_STATUS or status >= 500:
-        return CloudAPIServerError(
-            f"HTTP {status}: server error — {text}", status=status,
-            task_id=task_id, payload=body)
-    return CloudAPIError(
-        f"HTTP {status}: unexpected response — {text}", status=status,
-        task_id=task_id, payload=body)
-class CloudAPIClient:
-    """
-    Thin retrying HTTP client for one provider.
-    Args:
-        base_url:     Root of the API, without a trailing slash.
-        api_key:      Bearer token.
-        timeout:      Per-request socket timeout in seconds (not the task timeout).
-        max_retries:  Extra attempts after the first one, for retryable failures.
-        backoff:      Base of the exponential backoff, seconds.
-        auth_header:  Header name / value template, for providers that do not
-                      use `Authorization: Bearer <key>`.
-        user_agent:   Sent as-is; helps providers attribute traffic.
-    """
-    def __init__(
-        self,
-        base_url: str,
-        api_key: str,
-        *,
-        timeout: int = 60,
-        max_retries: int = 3,
-        backoff: float = 1.5,
-        auth_header: str = "Authorization",
-        auth_template: str = "Bearer {key}",
-        user_agent: str = "3AGameFactory/0.1 (+https://github.com/OpenDCAI/GameFactory-3A)",
-    ):
-        self.base_url = base_url.rstrip("/")
-        self._api_key = api_key
-        self.timeout = timeout
-        self.max_retries = max_retries
-        self.backoff = backoff
-        self.auth_header = auth_header
-        self.auth_template = auth_template
-        self.user_agent = user_agent
-        self._session = None
-    # -- session ---------------------------------------------------------------
-    @property
-    def session(self):
-        """Lazily created `requests.Session` (kept alive across polls)."""
-        if self._session is None:
-            requests = _requests()
-            self._session = requests.Session()
-            self._session.headers.update({
-                self.auth_header: self.auth_template.format(key=self._api_key),
-                "User-Agent": self.user_agent,
-            })
-        return self._session
-    def close(self) -> None:
-        """Idempotent — safe after a failed construction and safe to call twice."""
-        if self._session is not None:
-            try:
-                self._session.close()
-            finally:
-                self._session = None
-    # -- requests --------------------------------------------------------------
-    def request(
-        self,
-        method: str,
-        path: str,
-        *,
-        json_body: Optional[dict] = None,
-        files: Optional[dict] = None,
-        data: Optional[dict] = None,
-        params: Optional[dict] = None,
-        expect_json: bool = True,
-    ) -> Any:
-        """
-        Perform one API call, retrying retryable failures (R9.9).
-        Args:
-            method:      "GET" / "POST" / …
-            path:        Path appended to `base_url`, or a full URL.
-            json_body:   JSON payload.
-            files/data:  multipart payload (`requests` semantics).
-            params:      Query string.
-            expect_json: Parse the response as JSON; otherwise return `bytes`.
-        Returns:
-            Parsed JSON (dict / list) or raw `bytes`.
-        Raises:
-            CloudAPIError subclass — terminal errors immediately, retryable ones
-            after `max_retries` attempts.
-        """
-        requests = _requests()
-        url = path if path.startswith("http") else f"{self.base_url}/{path.lstrip('/')}"
-        last: Optional[CloudAPIError] = None
-        for attempt in range(self.max_retries + 1):
-            try:
-                resp = self.session.request(
-                    method, url, json=json_body, files=files, data=data,
-                    params=params, timeout=self.timeout,
-                )
-            except (requests.ConnectionError, requests.Timeout) as e:
-                last = CloudAPIServerError(f"{method} {url} failed at transport level: {e}")
-            else:
-                if resp.ok:
-                    if not expect_json:
-                        return resp.content
-                    try:
-                        return resp.json()
-                    except ValueError as e:
-                        raise CloudAPIError(
-                            f"{method} {url} returned {resp.status_code} with a "
-                            f"non-JSON body: {_truncate(resp.text)}"
-                        ) from e
-                try:
-                    body: Any = resp.json()
-                except ValueError:
-                    body = resp.text
-                err = classify_http_error(resp.status_code, body)
-                if not err.retryable:
-                    raise err
-                last = err
-                retry_after = resp.headers.get("Retry-After")
-                if retry_after:
-                    try:
-                        time.sleep(min(float(retry_after), 60.0))
-                    except ValueError:
-                        pass
-            if attempt < self.max_retries:
-                delay = self.backoff * (2 ** attempt)
-                logger.warning("[cloud_api] %s %s attempt %d/%d failed (%s); retrying in %.1fs",
-                               method, url, attempt + 1, self.max_retries + 1, last, delay)
-                time.sleep(delay)
-        assert last is not None
-        raise last
-    def download(self, url: str, *, max_bytes: Optional[int] = None) -> bytes:
-        """
-        Fetch a generated artifact. Signed asset URLs are short-lived — call this
-        immediately after the task reports success.
-        Args:
-            url: Absolute URL from the task output.
-            max_bytes: Reject anything larger, so a wrong URL cannot fill a disk.
-        Returns:
-            The file content.
-        """
-        content = self.request("GET", url, expect_json=False)
-        if max_bytes is not None and len(content) > max_bytes:
-            raise CloudAPIError(
-                f"downloaded artifact is {len(content)} bytes, over the "
-                f"{max_bytes} byte limit: {url}")
-        if not content:
-            raise CloudAPIError(f"downloaded artifact is empty: {url}")
-        return content
-# ── Polling ───────────────────────────────────────────────────────────────────
-def poll_task(
-    fetch: Callable[[], dict],
-    *,
-    task_id: str,
-    timeout: float = 300.0,
-    poll_interval: float = 3.0,
-    done_states: Iterable[str],
-    failed_states: Iterable[str],
-    state_key: str = "status",
-    progress_key: str = "progress",
-    verbose: bool = False,
-) -> dict:
-    """
-    Block until a provider task reaches a terminal state (R9.6).
-    Args:
-        fetch:         Callable returning the decoded task object.
-        task_id:       Only used for messages — every error carries it.
-        timeout:       Wall-clock budget in seconds.
-        poll_interval: Seconds between polls.
-        done_states:   States meaning success (compared case-insensitively).
-        failed_states: States meaning failure.
-        state_key:     Field holding the state.
-        progress_key:  Field holding 0-100 progress, when the provider sends one.
-        verbose:       Print progress; otherwise only DEBUG logs (R3.7).
-    Returns:
-        The task object in its successful terminal state.
-    Raises:
-        CloudTaskFailed:  provider reported failure.
-        CloudTaskTimeout: budget exhausted; the task may still finish server-side,
-                          the error carries `task_id` so it can be fetched later.
-    """
-    done = {s.lower() for s in done_states}
-    failed = {s.lower() for s in failed_states}
-    deadline = time.time() + timeout
-    last_progress = -1
-    while True:
-        task = fetch()
-        state = str(task.get(state_key, "")).lower()
-        progress = task.get(progress_key)
-        if progress != last_progress:
-            last_progress = progress
-            logger.debug("[cloud_api] task %s: %s (%s%%)", task_id, state, progress)
-            if verbose:
-                print(f"[cloud_api] task {task_id}: {state} ({progress}%)")
-        if state in done:
-            return task
-        if state in failed:
-            raise CloudTaskFailed(
-                f"task {task_id} ended as {state!r}: {_truncate(task)}",
-                task_id=task_id, payload=task)
-        remaining = deadline - time.time()
-        if remaining <= 0:
-            raise CloudTaskTimeout(
-                f"task {task_id} still {state!r} after {timeout:.0f}s. It may still "
-                f"finish server-side — query it with the task id above, or raise "
-                f"`timeout=` on the model.",
-                task_id=task_id, payload=task)
-        time.sleep(min(poll_interval, remaining))
-# ── Response cache ────────────────────────────────────────────────────────────
-def request_hash(payload: dict) -> str:
-    """
-    Stable sha256 over a request description (R9.8).
-    The payload must contain everything that changes the output — model version,
-    prompt, image bytes hash, every generation parameter, the output format.
-    Never put the API key in it.
-    """
-    canonical = json.dumps(payload, sort_keys=True, ensure_ascii=False, default=str)
-    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
-def bytes_hash(data: bytes) -> str:
-    """sha256 of a binary input, e.g. the reference image."""
-    return hashlib.sha256(data).hexdigest()
-class ResponseCache:
-    """
-    Content-addressed cache of generated artifacts.
-    A cloud call costs credits, so an identical request must never be sent twice
-    (R9.8). Layout::
-        <cache_dir>/<provider>/<hash>.<ext>        the artifact
-        <cache_dir>/<provider>/<hash>.meta.json    request description + task id
-    Args:
-        cache_dir: Root directory. `None` disables caching entirely.
-        provider:  Sub-directory name, so two providers never collide.
-    """
-    def __init__(self, cache_dir: Optional[str | Path], provider: str):
-        self.root = Path(cache_dir).expanduser() / provider if cache_dir else None
-        self.provider = provider
-    @property
-    def enabled(self) -> bool:
-        return self.root is not None
-    def _paths(self, key: str, ext: str) -> tuple[Path, Path]:
-        assert self.root is not None
-        return self.root / f"{key}.{ext}", self.root / f"{key}.meta.json"
-    def get(self, key: str, ext: str = "glb") -> Optional[bytes]:
-        """Cached artifact bytes, or None. Performs no network I/O, ever."""
-        if not self.enabled:
-            return None
-        blob, _ = self._paths(key, ext)
-        if blob.is_file() and blob.stat().st_size > 0:
-            logger.info("[cloud_api] cache hit (%s): %s", self.provider, blob.name)
-            return blob.read_bytes()
-        return None
-    def put(self, key: str, data: bytes, meta: dict, ext: str = "glb") -> Path:
-        """Store an artifact plus the request that produced it. Returns its path."""
-        if not self.enabled:
-            return Path()
-        blob, meta_path = self._paths(key, ext)
-        blob.parent.mkdir(parents=True, exist_ok=True)
-        blob.write_bytes(data)
-        meta_path.write_text(
-            json.dumps({**meta, "cache_key": key, "bytes": len(data)},
-                       indent=2, ensure_ascii=False, default=str),
-            encoding="utf-8",
-        )
-        return blob
-# ── Input encoding ────────────────────────────────────────────────────────────
-def image_to_png_bytes(image: Any) -> bytes:
-    """
-    Normalize an image input to PNG bytes.
-    Accepts a `PIL.Image.Image`, raw `bytes` (returned unchanged), or a
-    `np.ndarray`. Paths are rejected on purpose — `model_require.md` R3.2 says a
-    model takes the object, not a path.
-    Returns:
-        PNG-encoded bytes (RGBA preserved when present).
-    """
-    if isinstance(image, (bytes, bytearray)):
-        return bytes(image)
-    if isinstance(image, (str, Path)):
-        raise TypeError(
-            "models take an image object, not a path (model_require.md R3.2). "
-            "Open it in the operator: Image.open(path).convert('RGBA')"
-        )
-    from io import BytesIO  # noqa: PLC0415
-    from PIL import Image as PILImage  # noqa: PLC0415
-    if not isinstance(image, PILImage.Image):
-        try:
-            import numpy as np  # noqa: PLC0415
-        except ImportError:
-            np = None  # type: ignore[assignment]
-        if np is not None and isinstance(image, np.ndarray):
-            image = PILImage.fromarray(image)
-        else:
-            raise TypeError(
-                f"unsupported image type {type(image).__name__}; expected "
-                f"PIL.Image.Image, numpy.ndarray or bytes"
-            )
-    buf = BytesIO()
-    image.save(buf, format="PNG")
-    return buf.getvalue()
-def image_to_data_uri(image: Any, mime: str = "image/png") -> str:
-    """PNG data URI (`data:image/png;base64,…`) for providers that take one inline."""
-    import base64  # noqa: PLC0415
-    payload = base64.b64encode(image_to_png_bytes(image)).decode("ascii")
-    return f"data:{mime};base64,{payload}"

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/glb_utils.py DELETED Viewed

@@ -1,578 +0,0 @@
-"""
-models/common/glb_utils.py
-Dependency-free inspection of binary glTF (`.glb`) buffers.
-Why this exists instead of `trimesh.load(...)`: the API wrappers must report the
-triangle count of what they just paid for (`api_model_require.md` R9.8), and
-that number has to be available on a CPU-only box with nothing but the stdlib
-installed. Parsing the JSON chunk of a GLB is enough for counting.
-`glb_summary` and `glb_triangle_count` read the JSON chunk only. `read_glb_mesh`
-decodes vertex data as well, because a generated part has to be *composed* with
-primitives rather than merely counted, and that needs its triangles in the same
-coordinate frame as everything else.
-Usage:
-    from models.common.glb_utils import glb_summary, read_glb_mesh
-    info = glb_summary(open("model.glb", "rb").read())
-    print(info["triangles"], info["materials"])
-    mesh = read_glb_mesh(open("part.glb", "rb").read())
-    print(len(mesh["positions"]), mesh["low"], mesh["high"])
-"""
-from __future__ import annotations
-import json
-import math
-import struct
-from typing import Any, Optional, Sequence
-GLB_MAGIC = b"glTF"
-#: glTF primitive mode 4 == TRIANGLES. Only triangle primitives are counted.
-_MODE_TRIANGLES = 4
-#: glTF componentType -> (struct format, byte size). Indices are allowed to be
-#: any of the unsigned types; positions are float in every file worth reading.
-_COMPONENT_TYPES: dict[int, tuple[str, int]] = {
-    5120: ("b", 1),   # BYTE
-    5121: ("B", 1),   # UNSIGNED_BYTE
-    5122: ("h", 2),   # SHORT
-    5123: ("H", 2),   # UNSIGNED_SHORT
-    5125: ("I", 4),   # UNSIGNED_INT
-    5126: ("f", 4),   # FLOAT
-}
-#: glTF accessor type -> component count.
-_TYPE_COUNTS: dict[str, int] = {
-    "SCALAR": 1, "VEC2": 2, "VEC3": 3, "VEC4": 4,
-    "MAT2": 4, "MAT3": 9, "MAT4": 16,
-}
-class GLBParseError(ValueError):
-    """The buffer is not a GLB we can read."""
-def is_glb(data: bytes) -> bool:
-    """True when `data` starts with the 12-byte GLB header."""
-    return len(data) >= 12 and data[:4] == GLB_MAGIC
-def glb_json_chunk(data: bytes) -> dict[str, Any]:
-    """
-    Return the parsed JSON chunk of a GLB.
-    Args:
-        data: Whole `.glb` file content.
-    Returns:
-        The glTF document as a dict.
-    Raises:
-        GLBParseError: bad magic, truncated file, or a missing JSON chunk.
-    """
-    if not is_glb(data):
-        raise GLBParseError(
-            f"not a GLB: expected magic {GLB_MAGIC!r}, got {data[:4]!r}"
-        )
-    if len(data) < 20:
-        raise GLBParseError(f"GLB truncated: {len(data)} bytes")
-    _magic, version, total_len = struct.unpack_from("<4sII", data, 0)
-    if total_len > len(data):
-        raise GLBParseError(
-            f"GLB header claims {total_len} bytes, buffer holds {len(data)}"
-        )
-    offset = 12
-    while offset + 8 <= len(data):
-        chunk_len, chunk_type = struct.unpack_from("<I4s", data, offset)
-        offset += 8
-        chunk = data[offset:offset + chunk_len]
-        offset += chunk_len
-        if chunk_type == b"JSON":
-            try:
-                return json.loads(chunk.decode("utf-8"))
-            except (UnicodeDecodeError, json.JSONDecodeError) as e:
-                raise GLBParseError(f"GLB JSON chunk is not valid JSON: {e}") from e
-    raise GLBParseError(f"GLB (version {version}) has no JSON chunk")
-def glb_triangle_count(data: bytes) -> Optional[int]:
-    """
-    Triangle count of a GLB, or None when it cannot be determined.
-    Counts every triangle-mode primitive of every mesh once, i.e. the *asset's*
-    triangle budget, not the per-instance count after node duplication.
-    Returns:
-        int triangles, or None if the JSON chunk is unreadable.
-    """
-    try:
-        doc = glb_json_chunk(data)
-    except GLBParseError:
-        return None
-    accessors = doc.get("accessors", [])
-    total = 0
-    for mesh in doc.get("meshes", []):
-        for prim in mesh.get("primitives", []):
-            if prim.get("mode", _MODE_TRIANGLES) != _MODE_TRIANGLES:
-                continue
-            idx = prim.get("indices")
-            if idx is not None and idx < len(accessors):
-                count = accessors[idx].get("count", 0)
-            else:
-                pos = prim.get("attributes", {}).get("POSITION")
-                count = accessors[pos].get("count", 0) if pos is not None and pos < len(accessors) else 0
-            total += count // 3
-    return total
-def glb_summary(data: bytes) -> dict[str, Any]:
-    """
-    Cheap description of a GLB, for logs and `meta.json`.
-    Returns:
-        dict with keys:
-            bytes (int)            — buffer size
-            triangles (int | None) — see `glb_triangle_count`
-            meshes, materials, textures, images, nodes (int)
-            generator (str | None) — glTF `asset.generator`
-            error (str)            — present only when the JSON chunk is unreadable
-    """
-    out: dict[str, Any] = {"bytes": len(data)}
-    try:
-        doc = glb_json_chunk(data)
-    except GLBParseError as e:
-        out.update({"triangles": None, "error": str(e)})
-        return out
-    out.update({
-        "triangles": glb_triangle_count(data),
-        "meshes": len(doc.get("meshes", [])),
-        "materials": len(doc.get("materials", [])),
-        "textures": len(doc.get("textures", [])),
-        "images": len(doc.get("images", [])),
-        "nodes": len(doc.get("nodes", [])),
-        "generator": (doc.get("asset") or {}).get("generator"),
-    })
-    return out
-# --------------------------------------------------------------------------
-# Vertex decoding
-#
-# Needed to *compose* a generated part with primitives, as opposed to merely
-# reporting on it: composition means putting its triangles into the same
-# coordinate frame as the rest, and that requires reading them.
-# --------------------------------------------------------------------------
-def glb_binary_chunk(data: bytes) -> bytes:
-    """Return the BIN chunk of a GLB, or b"" when there is none."""
-    if not is_glb(data):
-        raise GLBParseError(f"not a GLB: got magic {data[:4]!r}")
-    offset = 12
-    while offset + 8 <= len(data):
-        chunk_len, chunk_type = struct.unpack_from("<I4s", data, offset)
-        offset += 8
-        if chunk_type == b"BIN\x00":
-            return data[offset:offset + chunk_len]
-        offset += chunk_len
-    return b""
-def _read_accessor(doc: dict[str, Any], binary: bytes, index: int) -> list[tuple]:
-    """Decode one accessor into a list of component tuples.
-    Honours ``byteStride``. Interleaved buffers are normal out of an
-    exporter, and reading one as tightly packed yields positions that are a
-    silent mixture of coordinates and normals — it parses, it renders, it is
-    garbage.
-    """
-    accessor = doc["accessors"][index]
-    component_type = accessor["componentType"]
-    if component_type not in _COMPONENT_TYPES:
-        raise GLBParseError(f"unsupported componentType {component_type}")
-    fmt, component_size = _COMPONENT_TYPES[component_type]
-    per_element = _TYPE_COUNTS[accessor["type"]]
-    count = accessor["count"]
-    view_index = accessor.get("bufferView")
-    if view_index is None:
-        # A sparse or zero-filled accessor. Legal, and not something a mesh
-        # we are about to weld into another asset should be relying on.
-        return [tuple([0] * per_element)] * count
-    view = doc["bufferViews"][view_index]
-    if view.get("buffer", 0) != 0:
-        raise GLBParseError("only single-buffer GLBs are supported")
-    base = view.get("byteOffset", 0) + accessor.get("byteOffset", 0)
-    packed = component_size * per_element
-    stride = view.get("byteStride") or packed
-    out: list[tuple] = []
-    element_format = "<" + fmt * per_element
-    for element in range(count):
-        start = base + element * stride
-        if start + packed > len(binary):
-            raise GLBParseError(
-                f"accessor {index} reads past the {len(binary)}-byte buffer"
-            )
-        out.append(struct.unpack_from(element_format, binary, start))
-    return out
-def _node_matrix(node: dict[str, Any]) -> list[float]:
-    """A node's local transform as a 16-float column-major matrix.
-    Handles both an explicit ``matrix`` and a TRS triple, since a file may use
-    either. Ignoring the transform looks like a modelling error: a mesh
-    authored Z-up whose node carries the -90 that stands it upright arrives on
-    its side, and the natural reaction is to rotate it back in the spec —
-    hard-coding a correction for something the file already stated.
-    """
-    if "matrix" in node:
-        return [float(value) for value in node["matrix"]]
-    tx, ty, tz = [float(value) for value in node.get("translation", (0, 0, 0))]
-    qx, qy, qz, qw = [float(value) for value in node.get("rotation", (0, 0, 0, 1))]
-    sx, sy, sz = [float(value) for value in node.get("scale", (1, 1, 1))]
-    # Quaternion to rotation matrix.
-    xx, yy, zz = qx * qx, qy * qy, qz * qz
-    xy, xz, yz = qx * qy, qx * qz, qy * qz
-    wx, wy, wz = qw * qx, qw * qy, qw * qz
-    rotation = (
-        (1 - 2 * (yy + zz), 2 * (xy + wz), 2 * (xz - wy)),
-        (2 * (xy - wz), 1 - 2 * (xx + zz), 2 * (yz + wx)),
-        (2 * (xz + wy), 2 * (yz - wx), 1 - 2 * (xx + yy)),
-    )
-    scale = (sx, sy, sz)
-    return [
-        rotation[0][0] * scale[0], rotation[0][1] * scale[0], rotation[0][2] * scale[0], 0.0,
-        rotation[1][0] * scale[1], rotation[1][1] * scale[1], rotation[1][2] * scale[1], 0.0,
-        rotation[2][0] * scale[2], rotation[2][1] * scale[2], rotation[2][2] * scale[2], 0.0,
-        tx, ty, tz, 1.0,
-    ]
-def _multiply(a: Sequence[float], b: Sequence[float]) -> list[float]:
-    """Column-major 4x4 product, applying `b` then `a`."""
-    out = [0.0] * 16
-    for column in range(4):
-        for row in range(4):
-            out[column * 4 + row] = sum(
-                a[k * 4 + row] * b[column * 4 + k] for k in range(4)
-            )
-    return out
-_IDENTITY = [1.0, 0, 0, 0, 0, 1.0, 0, 0, 0, 0, 1.0, 0, 0, 0, 0, 1.0]
-def read_glb_mesh(data: bytes) -> dict[str, Any]:
-    """Decode every triangle of a GLB into one flat, world-space mesh.
-    Walks the scene graph and applies each node's accumulated transform, so
-    the result is in the file's own world coordinates rather than in the
-    local frame of whichever mesh happened to be first.
-    The node hierarchy is deliberately *not* preserved. A part fetched from
-    a generator is one object as far as the composition is concerned — the
-    thing worth keeping addressable is the spec's part id, which the writer
-    attaches, and a generator's internal node names ("mesh_0", "Object_2")
-    are not names anything downstream can use.
-    Returns:
-        dict with ``positions`` and ``normals`` as lists of 3-tuples,
-        ``uvs`` as 2-tuples, ``indices`` as a flat list, ``low``/``high`` as
-        the axis-aligned bounds, and ``images`` / ``material_runs`` carrying
-        whatever textures the file brought with it. Normals are generated
-        per-face when the file omits them.
-    Textures come across because a generated part's whole contribution is
-    surface. Dropping them and letting the part inherit the spec's flat PBR
-    factors is consistent but throws away the thing that was paid for: the
-    stippling on a grip, the panel creases and decals on a car shell. That
-    needs three things travelling together — UVs per vertex, the image
-    bytes, and which triangles use which image — so ``material_runs``
-    records index ranges rather than a single material for the part.
-    """
-    doc = glb_json_chunk(data)
-    binary = glb_binary_chunk(data)
-    if not binary:
-        raise GLBParseError(
-            "the GLB has no BIN chunk, so its vertex data is external; "
-            "only self-contained GLBs can be composed"
-        )
-    positions: list[tuple[float, float, float]] = []
-    normals: list[tuple[float, float, float]] = []
-    uvs: list[tuple[float, float]] = []
-    indices: list[int] = []
-    material_runs: list[dict[str, Any]] = []
-    def add_mesh(mesh_index: int, matrix: Sequence[float]) -> None:
-        # The inverse transpose of the upper 3x3, for the normals. A non-uniform
-        # node scale makes the forward matrix wrong for them, and the symptom is
-        # lighting that reads as a modelling error rather than as a bad import.
-        normal_matrix = _inverse_transpose_3x3(matrix)
-        for primitive in doc["meshes"][mesh_index].get("primitives", []):
-            if primitive.get("mode", _MODE_TRIANGLES) != _MODE_TRIANGLES:
-                continue
-            attributes = primitive.get("attributes", {})
-            if "POSITION" not in attributes:
-                continue
-            local = _read_accessor(doc, binary, attributes["POSITION"])
-            base = len(positions)
-            for x, y, z in local:
-                positions.append((
-                    matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12],
-                    matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13],
-                    matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14],
-                ))
-            if "NORMAL" in attributes:
-                for nx, ny, nz in _read_accessor(doc, binary, attributes["NORMAL"]):
-                    tx = normal_matrix[0] * nx + normal_matrix[3] * ny + normal_matrix[6] * nz
-                    ty = normal_matrix[1] * nx + normal_matrix[4] * ny + normal_matrix[7] * nz
-                    tz = normal_matrix[2] * nx + normal_matrix[5] * ny + normal_matrix[8] * nz
-                    length = math.sqrt(tx * tx + ty * ty + tz * tz) or 1.0
-                    normals.append((tx / length, ty / length, tz / length))
-            else:
-                normals.extend([(0.0, 0.0, 0.0)] * len(local))
-            # UVs are per-vertex and must stay aligned with positions, so a
-            # primitive without them still contributes placeholders — a short
-            # UV list would silently shift every following part's texturing.
-            if "TEXCOORD_0" in attributes:
-                uvs.extend(
-                    (float(u), float(v))
-                    for u, v in _read_accessor(doc, binary, attributes["TEXCOORD_0"])
-                )
-            else:
-                uvs.extend([(0.0, 0.0)] * len(local))
-            if "indices" in primitive and primitive["indices"] is not None:
-                local_indices = [
-                    value[0] for value in
-                    _read_accessor(doc, binary, primitive["indices"])
-                ]
-            else:
-                local_indices = list(range(len(local)))
-            run_start = len(indices)
-            indices.extend(base + value for value in local_indices)
-            material_runs.append({
-                "start": run_start,
-                "count": len(local_indices),
-                "material": primitive.get("material"),
-            })
-    def walk(node_index: int, parent: Sequence[float]) -> None:
-        node = doc["nodes"][node_index]
-        matrix = _multiply(parent, _node_matrix(node))
-        if node.get("mesh") is not None:
-            add_mesh(node["mesh"], matrix)
-        for child in node.get("children", ()):
-            walk(child, matrix)
-    scenes = doc.get("scenes") or []
-    scene = scenes[doc.get("scene", 0)] if scenes else None
-    roots = scene.get("nodes", ()) if scene else range(len(doc.get("nodes", [])))
-    for root in roots:
-        walk(root, _IDENTITY)
-    if not positions:
-        raise GLBParseError("the GLB contains no triangle geometry")
-    # Fill in any face normals the file left out, so a consumer never has to
-    # ask whether normals are present.
-    _fill_missing_normals(positions, normals, indices)
-    low = tuple(min(point[axis] for point in positions) for axis in range(3))
-    high = tuple(max(point[axis] for point in positions) for axis in range(3))
-    return {
-        "positions": positions,
-        "normals": normals,
-        "uvs": uvs,
-        "indices": indices,
-        "triangles": len(indices) // 3,
-        "low": low,
-        "high": high,
-        "material_runs": material_runs,
-        "materials": _read_materials(doc, binary),
-        "has_uvs": any(u != 0.0 or v != 0.0 for u, v in uvs),
-    }
-def _read_materials(doc: dict[str, Any], binary: bytes) -> list[dict[str, Any]]:
-    """Each material's PBR factors, its base-colour image and its MR image.
-    Base colour and metallic-roughness. Not the normal or occlusion maps:
-    those would give the composed asset a texture set the primitives beside it
-    lack, and a car body with a normal map next to a flat-shaded spoiler reads
-    as two assets. Metallic-roughness is different in kind — it is not detail
-    on top of a surface, it is *which surface it is*.
-    Taking the map is what makes the factors trustworthy. An exporter that puts
-    those channels in a texture leaves the factors at glTF's default ``1.0`` to
-    multiply it, so the two only mean anything together. This function used to
-    take the colour alone and substitute dielectric defaults (``0.0``/``0.55``)
-    on the grounds that inherited factors would render a polymer grip as
-    sandblasted steel — true, but it threw away the answer to keep from
-    guessing wrong. Plate armour came out as grey plastic: every generated
-    piece of the knight had ``metallicFactor 1.0`` and an MR map in the file,
-    and both were discarded.
-    ``factors_from`` is still recorded, because a material with no map at all
-    still has to fall back and a caller needs to know which happened.
-    """
-    out: list[dict[str, Any]] = []
-    images = doc.get("images", [])
-    textures = doc.get("textures", [])
-    views = doc.get("bufferViews", [])
-    def image_bytes(reference: dict[str, Any]) -> tuple[bytes | None, str | None]:
-        index = reference.get("index")
-        if index is None or index >= len(textures):
-            return None, None
-        image_index = textures[index].get("source")
-        if image_index is None or image_index >= len(images):
-            return None, None
-        image = images[image_index]
-        view_index = image.get("bufferView")
-        if view_index is not None and view_index < len(views):
-            view = views[view_index]
-            start = view.get("byteOffset", 0)
-            return (
-                bytes(binary[start:start + view["byteLength"]]),
-                image.get("mimeType") or "image/png",
-            )
-        if str(image.get("uri", "")).startswith("data:"):
-            # A data URI is legal and some exporters emit one even in a GLB.
-            # Decoded here so the caller never has to care which form was used.
-            import base64
-            header, _, payload = image["uri"].partition(",")
-            return (
-                base64.b64decode(payload),
-                header.split(":")[1].split(";")[0] if ":" in header
-                else "image/png",
-            )
-        return None, None
-    for material in doc.get("materials", []):
-        pbr = material.get("pbrMetallicRoughness") or {}
-        colour_image, colour_mime = image_bytes(pbr.get("baseColorTexture") or {})
-        mr_image, mr_mime = image_bytes(
-            pbr.get("metallicRoughnessTexture") or {})
-        if mr_image is not None:
-            # The map is coming with us, so the factors mean what they say:
-            # they scale it. glTF's default is 1.0 for exactly this case.
-            metallic = float(pbr.get("metallicFactor", 1.0))
-            roughness = float(pbr.get("roughnessFactor", 1.0))
-            provenance = "file"
-        elif (pbr.get("metallicRoughnessTexture") or {}).get("index") is not None:
-            # A map is declared but its bytes could not be read. Falling back
-            # to dielectric defaults, because inheriting factors written to
-            # scale a map we do not have renders a polymer grip as steel.
-            metallic, roughness, provenance = 0.0, 0.55, "assumed"
-        else:
-            metallic = float(pbr.get("metallicFactor", 1.0))
-            roughness = float(pbr.get("roughnessFactor", 1.0))
-            provenance = "file"
-        out.append({
-            "name": material.get("name") or "",
-            "baseColor": [
-                float(value)
-                for value in pbr.get("baseColorFactor", [1.0, 1.0, 1.0, 1.0])
-            ],
-            "metallic": metallic,
-            "roughness": roughness,
-            "factors_from": provenance,
-            "image": colour_image,
-            "mimeType": colour_mime,
-            "mrImage": mr_image,
-            "mrMimeType": mr_mime,
-        })
-    return out
-def _inverse_transpose_3x3(matrix: Sequence[float]) -> list[float]:
-    """Inverse transpose of a column-major 4x4's rotation/scale block."""
-    a = (matrix[0], matrix[1], matrix[2])
-    b = (matrix[4], matrix[5], matrix[6])
-    c = (matrix[8], matrix[9], matrix[10])
-    determinant = (
-        a[0] * (b[1] * c[2] - b[2] * c[1])
-        - a[1] * (b[0] * c[2] - b[2] * c[0])
-        + a[2] * (b[0] * c[1] - b[1] * c[0])
-    )
-    if abs(determinant) < 1e-20:
-        return [1.0, 0, 0, 0, 1.0, 0, 0, 0, 1.0]
-    # cofactor / determinant, already the inverse transpose.
-    return [
-        (b[1] * c[2] - b[2] * c[1]) / determinant,
-        (b[2] * c[0] - b[0] * c[2]) / determinant,
-        (b[0] * c[1] - b[1] * c[0]) / determinant,
-        (a[2] * c[1] - a[1] * c[2]) / determinant,
-        (a[0] * c[2] - a[2] * c[0]) / determinant,
-        (a[1] * c[0] - a[0] * c[1]) / determinant,
-        (a[1] * b[2] - a[2] * b[1]) / determinant,
-        (a[2] * b[0] - a[0] * b[2]) / determinant,
-        (a[0] * b[1] - a[1] * b[0]) / determinant,
-    ]
-def _fill_missing_normals(
-    positions: list[tuple[float, float, float]],
-    normals: list[tuple[float, float, float]],
-    indices: list[int],
-) -> None:
-    """Replace zero-length normals with the area-weighted face average."""
-    missing = [
-        index for index, normal in enumerate(normals)
-        if normal[0] == 0.0 and normal[1] == 0.0 and normal[2] == 0.0
-    ]
-    if not missing:
-        return
-    accumulated = {index: [0.0, 0.0, 0.0] for index in missing}
-    needed = set(missing)
-    for triangle in range(len(indices) // 3):
-        ia, ib, ic = indices[triangle * 3:triangle * 3 + 3]
-        if not (ia in needed or ib in needed or ic in needed):
-            continue
-        pa, pb, pc = positions[ia], positions[ib], positions[ic]
-        e1 = (pb[0] - pa[0], pb[1] - pa[1], pb[2] - pa[2])
-        e2 = (pc[0] - pa[0], pc[1] - pa[1], pc[2] - pa[2])
-        cross = (
-            e1[1] * e2[2] - e1[2] * e2[1],
-            e1[2] * e2[0] - e1[0] * e2[2],
-            e1[0] * e2[1] - e1[1] * e2[0],
-        )
-        for index in (ia, ib, ic):
-            if index in accumulated:
-                for axis in range(3):
-                    accumulated[index][axis] += cross[axis]
-    for index, vector in accumulated.items():
-        length = math.sqrt(sum(value * value for value in vector))
-        normals[index] = (
-            (vector[0] / length, vector[1] / length, vector[2] / length)
-            if length > 1e-20 else (0.0, 1.0, 0.0)
-        )

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/meshy_model.py DELETED Viewed

@@ -1,463 +0,0 @@
-"""
-models/gen_3d_object/meshy_model.py
-MeshyModel — wrapper around Meshy's cloud 3D-generation API (image-to-3D and
-text-to-3D), producing GLB / FBX / OBJ / USDZ / STL.
-Reference: https://docs.meshy.ai/  (base https://api.meshy.ai)
-Second backend for the `gen_3d_object` slot. Its `infer` / `infer_and_save`
-signatures are identical to `TripoModel`'s and positionally identical to
-`Trellis2Model`'s, so `Gen3DObjectOperator` dispatches on class name alone
-(model_require.md R6).
-CONTRACT DEVIATIONS (model_require.md targets local-weight models; the rules that
-replace it live in agent_skills/develop_harness/api_model_require.md):
-  C1  R2.1/R2.2 → R9.1  `model_path` carries a *model version id* ("meshy-6").
-  C2  R2.3      → R9.2  `device` accepted for interface parity and ignored.
-  C3  R3.6/R5.5 → R9.3  no @torch.no_grad(); torch is not involved.
-  C4  R4.1-R4.3 → R9.4  `unload()` is a no-op that closes the HTTP session.
-  C5  R3.3/R3.4 → R9.5  `seed` is forwarded for text-to-3D only, where the API
-                        accepts it; image-to-3D has no seed. Reproducibility is
-                        NOT guaranteed server-side and is never faked locally.
-  C6  R3.1      → R9.6  task-based API (submit → poll → download); `infer()`
-                        blocks until completion or `timeout` (default 300 s).
-                        Text-to-3D runs two tasks (preview → refine) when a
-                        texture is requested; both ids are logged.
-  C7  R1.2             uses the documented `infer_and_save(..., output_path)`
-                        exception; the bytes-returning `infer()` exists alongside.
-  C8  (new)     → R9.8  `cache_dir` prevents re-billing an identical request.
-  C9  (new)     → R9.9  `max_retries` + exponential backoff; retryable and
-                        terminal failures are split.
-Environment:
-    MESHY_API_KEY   required at the first infer() call, not at construction.
-                    Get one at https://www.meshy.ai/api  (a `msy_dummy_...`
-                    test-mode key returns canned assets without spending credits).
-    MESHY_API_BASE  optional override of the API root.
-    `pip install requests` is needed for the API backends only.
-Usage:
-    from models.gen_3d_object.meshy_model import MeshyModel
-    model = MeshyModel(model_path="meshy-6", output_format="fbx")
-    path = model.infer_and_save(image, output_path="out/model.fbx", seed=42)
-"""
-from __future__ import annotations
-import logging
-import os
-import time
-from pathlib import Path
-from typing import Any, Optional
-from models.common import cloud_api
-from models.common.glb_utils import glb_summary
-logger = logging.getLogger(__name__)
-SIGNUP_URL = "https://www.meshy.ai/api"
-DEFAULT_API_BASE = "https://api.meshy.ai"
-#: Short names accepted for `model_path`. Unknown values pass through untouched.
-MODEL_ALIASES: dict[str, str] = {
-    "meshy": "meshy-6",
-    "meshy-6-text-to-3d": "meshy-6",
-    "meshy-6-image-to-3d": "meshy-6",
-    "meshy-5-text-to-3d": "meshy-5",
-    "meshy-5-image-to-3d": "meshy-5",
-}
-DEFAULT_MODEL = "meshy-6"
-DONE_STATES = ("succeeded", "success", "completed")
-FAILED_STATES = ("failed", "canceled", "cancelled", "expired")
-#: Meshy rejects a target_polycount outside this range with a 400 (terminal).
-POLYCOUNT_RANGE = (100, 300_000)
-#: Formats the API can return directly, i.e. keys of `model_urls`.
-SUPPORTED_FORMATS = ("glb", "fbx", "obj", "usdz", "stl", "mtl", "3mf")
-class MeshyModel:
-    """
-    Cloud image-to-3D / text-to-3D through Meshy.
-    Args:
-        model_path: [C1] Meshy `ai_model` id ("meshy-6", "meshy-5", "latest"),
-                    or an alias from `MODEL_ALIASES`.
-        device:     [C2] Accepted for interface parity, ignored. "cpu" is fine.
-        api_key:    Explicit key; defaults to `$MESHY_API_KEY`, read at first call.
-        timeout:    [C6] Seconds to wait for one generation task (each stage of
-                    the text-to-3D preview → refine chain gets the full budget).
-        poll_interval: Seconds between status polls.
-        max_retries: [C9] Extra attempts for retryable HTTP failures.
-        cache_dir:  [C8] Directory for the response cache. None disables it.
-        output_format: Any of `SUPPORTED_FORMATS`; picked out of `model_urls`.
-        low_poly:   [B4.3] Sets `model_type="lowpoly"`, i.e. the service produces
-                    a low-poly mesh instead of us decimating one locally.
-        texture / enable_pbr / topology / should_remesh:
-                    Forwarded to the generation endpoints.
-        refine:     Text-to-3D only. Meshy's preview stage returns an untextured
-                    mesh; the refine stage textures it and costs extra credits.
-                    Ignored when `texture=False`.
-        api_base:   Override the API root (defaults to `$MESHY_API_BASE`).
-        verbose:    Print task progress; off by default (R3.7).
-    """
-    PROVIDER = "meshy"
-    def __init__(
-        self,
-        model_path: str = DEFAULT_MODEL,
-        device: str = "cuda",
-        *,
-        api_key: Optional[str] = None,
-        # Measured: one image-to-3D with PBR textures took 283 s here, and the
-        # Tripo backend took 601 s for the same job. Timing out does not refund
-        # the credits, so the default errs long; the error carries the task_id.
-        timeout: int = 1800,
-        poll_interval: float = 3.0,
-        max_retries: int = 3,
-        cache_dir: Optional[str] = None,
-        output_format: str = "glb",
-        low_poly: bool = False,
-        texture: bool = True,
-        enable_pbr: bool = True,
-        topology: str = "triangle",
-        should_remesh: Optional[bool] = None,
-        refine: bool = True,
-        api_base: Optional[str] = None,
-        http_timeout: int = 60,
-        verbose: bool = False,
-        **model_specific: Any,
-    ):
-        # [CONTRACT-DEVIATION C1] model_path is a version id, not a weight location.
-        # [CONTRACT-DEVIATION C2] device accepted for interface parity, ignored.
-        self.model_path = MODEL_ALIASES.get(str(model_path).lower(), model_path)
-        self.device = device
-        # R2.4 — store everything before anything loads.
-        self.api_key = api_key
-        self.timeout = timeout
-        self.poll_interval = poll_interval
-        self.max_retries = max_retries
-        self.cache_dir = cache_dir
-        self.output_format = output_format.lower().lstrip(".")
-        self.low_poly = low_poly
-        self.texture = texture
-        self.enable_pbr = enable_pbr
-        self.topology = topology
-        self.should_remesh = should_remesh
-        self.refine = refine
-        self.api_base = (api_base or os.environ.get("MESHY_API_BASE")
-                         or DEFAULT_API_BASE)
-        self.http_timeout = http_timeout
-        self.verbose = verbose
-        self.model_specific = model_specific
-        if self.output_format not in SUPPORTED_FORMATS:
-            raise ValueError(
-                f"output_format={self.output_format!r} is not one of "
-                f"{SUPPORTED_FORMATS}. Meshy returns these directly in model_urls."
-            )
-        self._client: Optional[cloud_api.CloudAPIClient] = None
-        self._cache = cloud_api.ResponseCache(cache_dir, self.PROVIDER)
-        #: Record of the most recent **real** call — see `TripoModel.last_call_info`.
-        self.last_call_info: dict[str, Any] = {}
-    # ── plumbing ──────────────────────────────────────────────────────────────
-    @property
-    def client(self) -> cloud_api.CloudAPIClient:
-        """HTTP client, created on first use. [R9.7] The key is resolved here."""
-        if self._client is None:
-            key = cloud_api.require_api_key(
-                self.api_key, "MESHY_API_KEY", SIGNUP_URL, who="MeshyModel")
-            self._client = cloud_api.CloudAPIClient(
-                self.api_base, key,
-                timeout=self.http_timeout,
-                max_retries=self.max_retries,
-            )
-        return self._client
-    def unload(self) -> None:
-        """[C4] Close the HTTP session. Idempotent, and safe before any call."""
-        if self._client is not None:
-            self._client.close()
-            self._client = None
-    close = unload
-    @staticmethod
-    def _task_id_of(resp: Any) -> str:
-        """Meshy answers a creation call with `{"result": "<task id>"}`."""
-        if isinstance(resp, dict):
-            for key in ("result", "id", "task_id"):
-                value = resp.get(key)
-                if isinstance(value, str) and value:
-                    return value
-        raise cloud_api.CloudAPIError(
-            f"Meshy accepted the request but returned no task id: {resp!r}")
-    def _fetch_task(self, endpoint: str, task_id: str) -> dict:
-        task = self.client.request("GET", f"{endpoint}/{task_id}")
-        if not isinstance(task, dict):
-            raise cloud_api.CloudAPIError(
-                f"unexpected task payload for {task_id}: {task!r}", task_id=task_id)
-        return task
-    def _model_url(self, task: dict) -> str:
-        """URL of the requested format, with an actionable message when absent."""
-        urls = task.get("model_urls") or {}
-        url = urls.get(self.output_format)
-        if isinstance(url, str) and url.startswith("http"):
-            return url
-        raise cloud_api.CloudAPIError(
-            f"task {task.get('id')} finished but has no {self.output_format!r} "
-            f"URL. Available: {sorted(urls)}. Set output_format to one of those.",
-            task_id=task.get("id"), payload=task)
-    def _clamp_polycount(self, value: Optional[int]) -> Optional[int]:
-        """
-        Keep `target_polycount` inside the documented range.
-        `Gen3DObjectOperator` forwards TRELLIS.2's default of 1_000_000, which
-        Meshy rejects with a terminal 400. Clamping (loudly) keeps the operator
-        interchangeable (R6) instead of making the caller special-case backends.
-        """
-        if value is None:
-            return None
-        low, high = POLYCOUNT_RANGE
-        clamped = max(low, min(int(value), high))
-        if clamped != int(value):
-            logger.warning("[meshy] target_polycount %s clamped to %s (API range %s-%s)",
-                           value, clamped, low, high)
-        return clamped
-    # ── inference ─────────────────────────────────────────────────────────────
-    def infer(
-        self,
-        image: Any = None,
-        seed: int = 42,
-        decimation_target: Optional[int] = None,
-        texture_size: Optional[int] = None,
-        *,
-        prompt: Optional[str] = None,
-        negative_prompt: Optional[str] = None,
-        image_url: Optional[str] = None,
-        verbose: Optional[bool] = None,
-        **provider_kwargs: Any,
-    ) -> bytes:
-        """
-        Generate one 3D asset and return the model file bytes.
-        Args:
-            image: Reference image as `PIL.Image.Image`, `np.ndarray` or PNG
-                   `bytes` — sent inline as a base64 data URI. Not a path (R3.2).
-            seed: [C5] Forwarded for text-to-3D only; image-to-3D has no seed
-                   parameter. Reproducibility is not guaranteed.
-            decimation_target: Target face count → `target_polycount`, clamped to
-                   the API's 100-300000 range.
-            texture_size: Accepted for signature parity with `Trellis2Model` and
-                   **ignored** — Meshy exposes no texture resolution parameter.
-            prompt: Text prompt for text-to-3D. [A4 decision] Same rationale as
-                   `TripoModel`: keeps text-to-3D reachable without a second slot.
-            negative_prompt: Sent as `texture_prompt`'s counterpart is absent in
-                   the API — rejected explicitly rather than silently dropped.
-            image_url: Publicly reachable image URL, used instead of the data URI.
-            verbose: Override the constructor's verbosity for this call.
-            **provider_kwargs: Merged into the request body verbatim.
-        Returns:
-            The model file as `bytes`, in `output_format`.
-        Raises:
-            CloudAPIAuthError / CloudAPIQuotaError / CloudTaskFailed /
-            CloudTaskTimeout — see `models/common/cloud_api.py`.
-        """
-        verbose = self.verbose if verbose is None else verbose
-        if image is None and image_url is None and not prompt:
-            raise ValueError(
-                "MeshyModel.infer needs an image (`image=` / `image_url=`) or a "
-                "text `prompt=`; got neither.")
-        if negative_prompt:
-            raise ValueError(
-                "Meshy has no negative_prompt parameter. Fold the constraint into "
-                "`prompt`, or use TripoModel which supports it.")
-        if texture_size is not None:
-            logger.debug("[meshy] texture_size=%s ignored; the API has no equivalent",
-                         texture_size)
-        polycount = self._clamp_polycount(decimation_target)
-        use_image = image is not None or image_url is not None
-        payload: dict[str, Any] = {
-            "ai_model": self.model_path,
-            "model_type": "lowpoly" if self.low_poly else "standard",
-            "topology": self.topology,
-        }
-        if polycount is not None:
-            payload["target_polycount"] = polycount
-        if self.should_remesh is not None:
-            payload["should_remesh"] = self.should_remesh
-        if use_image:
-            payload["should_texture"] = self.texture
-            payload["enable_pbr"] = self.enable_pbr
-        else:
-            payload["mode"] = "preview"
-            payload["prompt"] = prompt
-            # [CONTRACT-DEVIATION C5] accepted by the text endpoint only.
-            payload["seed"] = int(seed)
-        payload.update(provider_kwargs)
-        # [C8] Everything that changes the output goes into the key; the image is
-        # represented by its hash, and the API key never appears.
-        png = cloud_api.image_to_png_bytes(image) if image is not None else None
-        cache_key = cloud_api.request_hash({
-            "provider": self.PROVIDER,
-            "payload": payload,
-            "image_sha256": cloud_api.bytes_hash(png) if png else None,
-            "image_url": image_url,
-            "refine": self.refine and self.texture and not use_image,
-            "output_format": self.output_format,
-        })
-        cached = self._cache.get(cache_key, ext=self.output_format)
-        if cached is not None:
-            self.last_call_info = {
-                "provider": self.PROVIDER, "cached": True, "cache_key": cache_key,
-                "bytes": len(cached),
-                **(glb_summary(cached) if self.output_format == "glb" else {}),
-            }
-            return cached
-        t0 = time.time()
-        task_ids: list[str] = []
-        if use_image:
-            endpoint = "/openapi/v1/image-to-3d"
-            payload["image_url"] = (
-                image_url if png is None else cloud_api.image_to_data_uri(image))
-            task = self._submit_and_wait(endpoint, payload, verbose=verbose,
-                                         task_ids=task_ids)
-        else:
-            endpoint = "/openapi/v2/text-to-3d"
-            task = self._submit_and_wait(endpoint, payload, verbose=verbose,
-                                         task_ids=task_ids)
-            if self.texture and self.refine:
-                # [C6] Preview geometry is untextured; refine is a second billed
-                # task that paints it. Skip with texture=False or refine=False.
-                refine_payload = {
-                    "mode": "refine",
-                    "preview_task_id": task_ids[-1],
-                    "ai_model": self.model_path,
-                    "enable_pbr": self.enable_pbr,
-                }
-                task = self._submit_and_wait(endpoint, refine_payload,
-                                             verbose=verbose, task_ids=task_ids)
-        data = self.client.download(self._model_url(task))
-        elapsed = time.time() - t0
-        info = glb_summary(data) if self.output_format == "glb" else {"bytes": len(data)}
-        self.last_call_info = {
-            "provider": self.PROVIDER,
-            "model": self.model_path,
-            "task_id": task_ids[-1],
-            "task_ids": task_ids,
-            "elapsed_sec": round(elapsed, 2),
-            "credits": task.get("credits_consumed", task.get("credits")),
-            "cached": False,
-            "cache_key": cache_key,
-            "format": self.output_format,
-            # The provider's own render of what it produced. Recording the URL
-            # (rather than downloading it here) keeps the model out of artifact
-            # placement (R1.2) while giving the caller a free visual check —
-            # "the asset exists" and "the asset is what was asked for" are
-            # different claims, and only a picture settles the second one.
-            "preview_url": task.get("thumbnail_url"),
-            **info,
-        }
-        # R9.8 — one line per billed call.
-        logger.info(
-            "[meshy] task=%s model=%s %.1fs credits=%s triangles=%s bytes=%s",
-            task_ids[-1], self.model_path, elapsed, self.last_call_info.get("credits"),
-            info.get("triangles"), len(data),
-        )
-        if verbose:
-            print(f"[meshy] {self.last_call_info}")
-        self._cache.put(cache_key, data, {
-            "provider": self.PROVIDER, "payload": payload,
-            **{k: v for k, v in self.last_call_info.items() if k != "cache_key"},
-        }, ext=self.output_format)
-        return data
-    def _submit_and_wait(self, endpoint: str, payload: dict, *,
-                         verbose: bool, task_ids: list[str]) -> dict:
-        """Create one task on `endpoint`, poll it to a terminal state, return it."""
-        created = self.client.request("POST", endpoint, json_body=payload)
-        task_id = self._task_id_of(created)
-        task_ids.append(task_id)
-        if verbose:
-            print(f"[meshy] task {task_id} submitted ({endpoint}, "
-                  f"mode={payload.get('mode', 'image')})")
-        return cloud_api.poll_task(
-            lambda: self._fetch_task(endpoint, task_id),
-            task_id=task_id,
-            timeout=self.timeout,
-            poll_interval=self.poll_interval,
-            done_states=DONE_STATES,
-            failed_states=FAILED_STATES,
-            verbose=verbose,
-        )
-    def infer_and_save(
-        self,
-        image: Any = None,
-        output_path: Optional[str] = None,
-        seed: int = 42,
-        decimation_target: Optional[int] = None,
-        texture_size: Optional[int] = None,
-        *,
-        prompt: Optional[str] = None,
-        negative_prompt: Optional[str] = None,
-        image_url: Optional[str] = None,
-        verbose: Optional[bool] = None,
-        **provider_kwargs: Any,
-    ) -> str:
-        """
-        [C7] The documented R1.2 exception: run `infer()` and write the result.
-        The path comes **in** from the caller and is never derived here.
-        Args:
-            output_path: Destination file. Parent directories are created.
-            (everything else: see `infer`)
-        Returns:
-            `str(output_path)`.
-        """
-        if not output_path:
-            raise ValueError("output_path is required (model_require.md R1.2)")
-        data = self.infer(
-            image, seed, decimation_target, texture_size,
-            prompt=prompt, negative_prompt=negative_prompt, image_url=image_url,
-            verbose=verbose, **provider_kwargs,
-        )
-        out = Path(output_path)
-        out.parent.mkdir(parents=True, exist_ok=True)
-        out.write_bytes(data)
-        return str(out)
-    # ── account ───────────────────────────────────────────────────────────────
-    def balance(self) -> dict:
-        """Remaining credits: ``{"balance": int}``. Cheap and unbilled."""
-        resp = self.client.request("GET", "/openapi/v1/balance")
-        return resp if isinstance(resp, dict) else {"balance": resp}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/tripo_model.py DELETED Viewed

@@ -1,532 +0,0 @@
-"""
-models/gen_3d_object/tripo_model.py
-TripoModel — wrapper around Tripo3D's cloud 3D-generation API (image-to-3D and
-text-to-3D), producing a GLB.
-Reference: https://developers.tripo3d.ai/  (v3 API, base https://openapi.tripo3d.ai/v3)
-CONTRACT DEVIATIONS (model_require.md targets local-weight models; the rules that
-replace it live in agent_skills/develop_harness/api_model_require.md):
-  C1  R2.1/R2.2 → R9.1  `model_path` carries a *model version id*
-                        ("v3.1-20260211"), not a weight location.
-  C2  R2.3      → R9.2  `device` accepted for interface parity and ignored.
-  C3  R3.6/R5.5 → R9.3  no @torch.no_grad(); torch is not involved.
-  C4  R4.1-R4.3 → R9.4  `unload()` is a no-op that closes the HTTP session.
-  C5  R3.3/R3.4 → R9.5  `seed` is forwarded as model_seed/texture_seed when the
-                        provider accepts it; server-side reproducibility is NOT
-                        guaranteed and is never faked locally.
-  C6  R3.1      → R9.6  task-based API (submit → poll → download); `infer()`
-                        blocks until completion or `timeout` (default 300 s).
-                        A timeout error carries the `task_id`.
-  C7  R1.2             uses the documented `infer_and_save(..., output_path)`
-                        exception; the bytes-returning `infer()` exists alongside.
-  C8  (new)     → R9.8  `cache_dir` prevents re-billing an identical request.
-  C9  (new)     → R9.9  `max_retries` + exponential backoff; retryable (5xx/429/
-                        transport) and terminal (400/401/402) failures are split.
-Environment:
-    TRIPO_API_KEY   required at the first infer() call, not at construction.
-                    Get one at https://platform.tripo3d.ai/api-keys
-    TRIPO_API_BASE  optional override of the API root.
-    `pip install requests` is needed for the API backends only.
-Usage:
-    from models.gen_3d_object.tripo_model import TripoModel
-    model = TripoModel(model_path="v3.1-20260211")
-    path = model.infer_and_save(image, output_path="out/model.glb", seed=42)
-    print(model.last_call_info)   # task_id, elapsed, credits, triangles
-"""
-from __future__ import annotations
-import logging
-import os
-import time
-from pathlib import Path
-from typing import Any, Optional
-from models.common import cloud_api
-from models.common.glb_utils import glb_summary
-logger = logging.getLogger(__name__)
-#: Where a human gets a key. Quoted verbatim in the fail-fast message (R1.6).
-SIGNUP_URL = "https://platform.tripo3d.ai/api-keys"
-DEFAULT_API_BASE = "https://openapi.tripo3d.ai/v3"
-#: Short names accepted for `model_path`, mapped to the ids the API expects.
-#: Unknown values are passed through untouched, so a version released after this
-#: file was written still works without a code change.
-MODEL_ALIASES: dict[str, str] = {
-    "tripo": "v3.1-20260211",
-    "tripo-v3.1": "v3.1-20260211",
-    "v3.1": "v3.1-20260211",
-    "tripo-v3.0": "v3.0-20250812",
-    "v3.0": "v3.0-20250812",
-    "tripo-v2.5": "v2.5-20250123",
-    "v2.5": "v2.5-20250123",
-    # P series — natively low-poly, the cheap option for mesh particles (B4.2).
-    "tripo-p1": "P1-20260311",
-    "p1": "P1-20260311",
-}
-DEFAULT_MODEL = "v3.1-20260211"
-#: Terminal task states. Tripo reports lower-case; compared case-insensitively.
-DONE_STATES = ("success", "succeeded", "finished", "completed")
-FAILED_STATES = ("failed", "cancelled", "canceled", "banned", "expired", "unknown")
-#: Output fields that have carried the download URL across API versions.
-_MODEL_URL_KEYS = ("model_url", "pbr_model", "model", "base_model", "glb", "gltf")
-#: `face_limit` range the service accepts **while `smart_low_poly` is on**.
-#: Outside it the request is rejected with a terminal 400:
-#:   "when smart_low_poly is enabled, face_limit must be between 500 and 20000
-#:    (triangle mesh), got 30000"
-#: Not in the public docs; found by calling it.
-LOW_POLY_FACE_LIMIT_RANGE = (500, 20_000)
-class TripoModel:
-    """
-    Cloud image-to-3D / text-to-3D through Tripo3D.
-    Interchangeable with `Trellis2Model` in `Gen3DObjectOperator`: the
-    `infer_and_save(image, output_path, seed, decimation_target, texture_size)`
-    call signature is positionally identical (model_require.md R6).
-    Args:
-        model_path: [C1] Tripo model version id, or an alias from `MODEL_ALIASES`.
-        device:     [C2] Accepted for interface parity, ignored. "cpu" is fine.
-        api_key:    Explicit key; defaults to `$TRIPO_API_KEY`, read at first call.
-        timeout:    [C6] Seconds to wait for one generation task.
-        poll_interval: Seconds between status polls.
-        max_retries: [C9] Extra attempts for retryable HTTP failures.
-        cache_dir:  [C8] Directory for the response cache. None disables it.
-        output_format: "glb" is produced natively. Any other format needs the
-                    conversion endpoint — see `convert_path`.
-        convert_path: API path of the format-conversion endpoint. Left as None
-                    because it is not pinned down in the public v3 docs; set it
-                    to enable `output_format="fbx"` without touching this file.
-        low_poly:   [B4.3] Ask the service for clean low-poly topology
-                    (`smart_low_poly`) instead of decimating locally.
-        texture / pbr / quad / texture_quality / geometry_quality:
-                    Forwarded verbatim to the generation endpoint.
-        api_base:   Override the API root (defaults to `$TRIPO_API_BASE`).
-        verbose:    Print task progress; off by default (R3.7).
-    """
-    #: Provider name, used for cache namespacing and log lines.
-    PROVIDER = "tripo"
-    def __init__(
-        self,
-        model_path: str = DEFAULT_MODEL,
-        device: str = "cuda",
-        *,
-        api_key: Optional[str] = None,
-        # Measured: image-to-3D with smart_low_poly took **601 s**, i.e. it would
-        # have died one second past a 600 s budget. Timing out does not refund
-        # the credits — the task finishes server-side and only the download is
-        # lost — so the default errs long. The error carries the task_id.
-        timeout: int = 1800,
-        poll_interval: float = 3.0,
-        max_retries: int = 3,
-        cache_dir: Optional[str] = None,
-        output_format: str = "glb",
-        convert_path: Optional[str] = None,
-        low_poly: bool = False,
-        texture: bool = True,
-        pbr: bool = True,
-        quad: bool = False,
-        texture_quality: str = "standard",
-        geometry_quality: str = "standard",
-        api_base: Optional[str] = None,
-        http_timeout: int = 60,
-        verbose: bool = False,
-        **model_specific: Any,
-    ):
-        # [CONTRACT-DEVIATION C1] model_path is a version id, not a weight location.
-        # [CONTRACT-DEVIATION C2] device accepted for interface parity, ignored.
-        self.model_path = MODEL_ALIASES.get(str(model_path).lower(), model_path)
-        self.device = device
-        # R2.4 — every constructor argument lands on self before anything loads,
-        # so unload()/reload round-trips without losing configuration.
-        self.api_key = api_key
-        self.timeout = timeout
-        self.poll_interval = poll_interval
-        self.max_retries = max_retries
-        self.cache_dir = cache_dir
-        self.output_format = output_format.lower().lstrip(".")
-        self.convert_path = convert_path
-        self.low_poly = low_poly
-        self.texture = texture
-        self.pbr = pbr
-        self.quad = quad
-        self.texture_quality = texture_quality
-        self.geometry_quality = geometry_quality
-        self.api_base = (api_base or os.environ.get("TRIPO_API_BASE")
-                         or DEFAULT_API_BASE)
-        self.http_timeout = http_timeout
-        self.verbose = verbose
-        self.model_specific = model_specific
-        self._client: Optional[cloud_api.CloudAPIClient] = None
-        self._cache = cloud_api.ResponseCache(cache_dir, self.PROVIDER)
-        #: Record of the most recent **real** call: task_id, elapsed_sec, credits,
-        #: triangles, bytes, cached. Operators copy it into meta.json (R9.8).
-        self.last_call_info: dict[str, Any] = {}
-    # ── plumbing ──────────────────────────────────────────────────────────────
-    @property
-    def client(self) -> cloud_api.CloudAPIClient:
-        """
-        HTTP client, created on first use.
-        [C6/R9.7] The API key is resolved here rather than in `__init__`, so the
-        wrapper can be imported and constructed on a machine with no credentials
-        (which is exactly what `test/harness/smoke.py` does).
-        """
-        if self._client is None:
-            key = cloud_api.require_api_key(
-                self.api_key, "TRIPO_API_KEY", SIGNUP_URL, who="TripoModel")
-            self._client = cloud_api.CloudAPIClient(
-                self.api_base, key,
-                timeout=self.http_timeout,
-                max_retries=self.max_retries,
-            )
-        return self._client
-    def unload(self) -> None:
-        """[C4] Close the HTTP session. Idempotent, and safe before any call."""
-        if self._client is not None:
-            self._client.close()
-            self._client = None
-    close = unload
-    @staticmethod
-    def _unwrap(resp: Any) -> dict:
-        """
-        Strip Tripo's `{"code": 0, "data": {...}}` envelope.
-        A non-zero `code` on an HTTP 200 is a terminal application error — the
-        same request will fail the same way, so it must not be retried (R9.9).
-        """
-        if not isinstance(resp, dict):
-            raise cloud_api.CloudAPIError(f"unexpected response type {type(resp).__name__}: {resp!r}")
-        code = resp.get("code")
-        if code not in (None, 0):
-            message = resp.get("message") or resp.get("msg") or resp
-            suggestion = resp.get("suggestion")
-            raise cloud_api.CloudAPIRequestError(
-                f"Tripo API error code={code}: {message}"
-                + (f" — {suggestion}" if suggestion else ""),
-                payload=resp,
-            )
-        data = resp.get("data")
-        return data if isinstance(data, dict) else resp
-    def _upload_image(self, png: bytes) -> str:
-        """Upload PNG bytes, return the `file_token` used as generation input."""
-        data = self._unwrap(self.client.request(
-            "POST", "/files",
-            files={"file": ("input.png", png, "image/png")},
-        ))
-        token = data.get("file_token") or data.get("image_token") or data.get("token")
-        if not token:
-            raise cloud_api.CloudAPIError(
-                f"upload succeeded but no file_token in the response: {data}")
-        return str(token)
-    @staticmethod
-    def _extract_model_url(task: dict) -> str:
-        """Find the artifact URL in a finished task, across output field names."""
-        output = task.get("output") or task.get("result") or {}
-        for key in _MODEL_URL_KEYS:
-            value = output.get(key)
-            if isinstance(value, str) and value.startswith("http"):
-                return value
-            if isinstance(value, dict) and isinstance(value.get("url"), str):
-                return value["url"]
-        raise cloud_api.CloudAPIError(
-            f"task {task.get('task_id')} reported success but carries no model URL. "
-            f"output={output!r}",
-            task_id=task.get("task_id"), payload=task)
-    def _fetch_task(self, task_id: str) -> dict:
-        return self._unwrap(self.client.request("GET", f"/tasks/{task_id}"))
-    # ── payload ───────────────────────────────────────────────────────────────
-    def _clamp_face_limit(self, value: int) -> int:
-        """
-        Keep `face_limit` inside the range the service accepts.
-        `Gen3DObjectOperator` forwards TRELLIS.2's default of 1 000 000, and with
-        `low_poly=True` anything outside 500-20 000 is a terminal 400. Clamping
-        (loudly) keeps the backends interchangeable (R6) rather than making the
-        caller special-case each provider.
-        """
-        value = int(value)
-        if not self.low_poly:
-            return value
-        low, high = LOW_POLY_FACE_LIMIT_RANGE
-        clamped = max(low, min(value, high))
-        if clamped != value:
-            logger.warning("[tripo] face_limit %s clamped to %s "
-                           "(smart_low_poly range %s-%s)", value, clamped, low, high)
-        return clamped
-    def _build_payload(
-        self,
-        *,
-        prompt: Optional[str],
-        negative_prompt: Optional[str],
-        seed: Optional[int],
-        decimation_target: Optional[int],
-        provider_kwargs: dict,
-    ) -> dict:
-        """Generation parameters shared by the image and text endpoints."""
-        payload: dict[str, Any] = {
-            "model": self.model_path,
-            "texture": self.texture,
-            "pbr": self.pbr,
-            "texture_quality": self.texture_quality,
-            "geometry_quality": self.geometry_quality,
-        }
-        if self.quad:
-            payload["quad"] = True
-        if self.low_poly:
-            # [B4.3] Ask the service for low-poly topology. Decimating a 2M-face
-            # mesh locally wrecks UVs and normals; generating low-poly does not.
-            payload["smart_low_poly"] = True
-        if decimation_target:
-            payload["face_limit"] = self._clamp_face_limit(decimation_target)
-        if prompt:
-            payload["prompt"] = prompt
-        if negative_prompt:
-            payload["negative_prompt"] = negative_prompt
-        if seed is not None:
-            # [CONTRACT-DEVIATION C5] forwarded, but the service does not promise
-            # that the same seed reproduces the same mesh. Never faked locally.
-            payload["model_seed"] = int(seed)
-            payload["texture_seed"] = int(seed)
-        payload.update(provider_kwargs)
-        return payload
-    # ── inference ─────────────────────────────────────────────────────────────
-    def infer(
-        self,
-        image: Any = None,
-        seed: int = 42,
-        decimation_target: Optional[int] = None,
-        texture_size: Optional[int] = None,
-        *,
-        prompt: Optional[str] = None,
-        negative_prompt: Optional[str] = None,
-        image_url: Optional[str] = None,
-        verbose: Optional[bool] = None,
-        **provider_kwargs: Any,
-    ) -> bytes:
-        """
-        Generate one 3D asset and return the model file bytes.
-        [C6] Submits the task, polls until it finishes, downloads the artifact —
-        all inside this call. Typical wall time is 20 s to 4 min.
-        Args:
-            image: Reference image as `PIL.Image.Image`, `np.ndarray` or PNG
-                   `bytes`. Not a path (R3.2). Give `image`, `image_url` or
-                   `prompt`; image wins when several are present.
-            seed: [C5] Forwarded as `model_seed` / `texture_seed`. Reproducibility
-                   is not guaranteed server-side.
-            decimation_target: Target face count, forwarded as `face_limit`.
-                   None leaves it to the service.
-            texture_size: Accepted for signature parity with `Trellis2Model` and
-                   **ignored** — Tripo exposes `texture_quality`, not a
-                   resolution. Pass `texture_quality=` to the constructor.
-            prompt: Text prompt for text-to-3D. [A4 decision] The operator slot is
-                   image-to-3D today; accepting `prompt` here keeps text-to-3D
-                   available without a second wrapper.
-            negative_prompt: Text-to-3D only.
-            image_url: Publicly reachable image URL, used instead of uploading.
-            verbose: Override the constructor's verbosity for this call.
-            **provider_kwargs: Merged into the request body verbatim, so a new
-                   API parameter needs no change here.
-        Returns:
-            The model file as `bytes` — GLB unless `output_format`/`convert_path`
-            say otherwise.
-        Raises:
-            CloudAPIAuthError: no or invalid `TRIPO_API_KEY`.
-            CloudAPIQuotaError: out of credits (terminal, never retried).
-            CloudTaskTimeout: not finished within `timeout`; carries `task_id`.
-            CloudTaskFailed: the service rejected or failed the task.
-        """
-        verbose = self.verbose if verbose is None else verbose
-        if image is None and image_url is None and not prompt:
-            raise ValueError(
-                "TripoModel.infer needs an image (`image=` / `image_url=`) or a "
-                "text `prompt=`; got neither.")
-        if texture_size is not None:
-            # [CONTRACT-DEVIATION C2-style] accepted for parity, ignored.
-            logger.debug("[tripo] texture_size=%s ignored; use texture_quality",
-                         texture_size)
-        if self.output_format != "glb" and not self.convert_path:
-            raise NotImplementedError(
-                f"TripoModel produces GLB; output_format={self.output_format!r} needs "
-                f"Tripo's conversion endpoint, whose path is not pinned in the public "
-                f"v3 docs. Either set convert_path=... on the constructor, use "
-                f"MeshyModel(output_format='fbx') which returns FBX natively, or "
-                f"convert the GLB with engine_adapters/blender/."
-            )
-        png = cloud_api.image_to_png_bytes(image) if image is not None else None
-        use_image = png is not None or bool(image_url)
-        payload = self._build_payload(
-            # The image endpoint has no prompt field — sending one is a terminal
-            # 400. An image plus a prompt means "use the image".
-            prompt=None if use_image else prompt,
-            negative_prompt=None if use_image else negative_prompt,
-            seed=seed,
-            decimation_target=decimation_target, provider_kwargs=provider_kwargs,
-        )
-        # [C8] Cache key covers everything that changes the output. The image is
-        # represented by its hash, never its bytes, and the key never sees the API key.
-        cache_key = cloud_api.request_hash({
-            "provider": self.PROVIDER,
-            "payload": payload,
-            "image_sha256": cloud_api.bytes_hash(png) if png else None,
-            "image_url": image_url,
-            "output_format": self.output_format,
-        })
-        cached = self._cache.get(cache_key, ext=self.output_format)
-        if cached is not None:
-            self.last_call_info = {
-                "provider": self.PROVIDER, "cached": True, "cache_key": cache_key,
-                "bytes": len(cached), **glb_summary(cached),
-            }
-            return cached
-        t0 = time.time()
-        if png is not None:
-            # `input` takes a file_token, a public URL or a previous task id.
-            payload["input"] = self._upload_image(png)
-            endpoint = "/generation/image-to-model"
-        elif image_url:
-            payload["input"] = image_url
-            endpoint = "/generation/image-to-model"
-        else:
-            endpoint = "/generation/text-to-model"
-        created = self._unwrap(self.client.request("POST", endpoint, json_body=payload))
-        task_id = str(created.get("task_id") or created.get("id") or "")
-        if not task_id:
-            raise cloud_api.CloudAPIError(
-                f"{endpoint} accepted the request but returned no task_id: {created}")
-        if verbose:
-            print(f"[tripo] task {task_id} submitted ({endpoint})")
-        # Some responses already carry a finished task; only poll when they do not.
-        state = str(created.get("status", "")).lower()
-        if state in DONE_STATES:
-            task = created
-        else:
-            task = cloud_api.poll_task(
-                lambda: self._fetch_task(task_id),
-                task_id=task_id,
-                timeout=self.timeout,
-                poll_interval=self.poll_interval,
-                done_states=DONE_STATES,
-                failed_states=FAILED_STATES,
-                verbose=verbose,
-            )
-        data = self.client.download(self._extract_model_url(task))
-        elapsed = time.time() - t0
-        info = glb_summary(data) if self.output_format == "glb" else {"bytes": len(data)}
-        self.last_call_info = {
-            "provider": self.PROVIDER,
-            "model": self.model_path,
-            "task_id": task_id,
-            "elapsed_sec": round(elapsed, 2),
-            "credits": task.get("credits_consumed", task.get("credits")),
-            "cached": False,
-            "cache_key": cache_key,
-            # The provider's own render — see the note in meshy_model.py.
-            "preview_url": (task.get("output") or {}).get("rendered_image_url"),
-            **info,
-        }
-        # R9.8 — one line per billed call: what it cost and what it produced.
-        logger.info(
-            "[tripo] task=%s model=%s %.1fs credits=%s triangles=%s bytes=%s",
-            task_id, self.model_path, elapsed, self.last_call_info.get("credits"),
-            info.get("triangles"), len(data),
-        )
-        if verbose:
-            print(f"[tripo] {self.last_call_info}")
-        self._cache.put(cache_key, data, {
-            "provider": self.PROVIDER, "payload": payload,
-            **{k: v for k, v in self.last_call_info.items() if k != "cache_key"},
-        }, ext=self.output_format)
-        return data
-    def infer_and_save(
-        self,
-        image: Any = None,
-        output_path: Optional[str] = None,
-        seed: int = 42,
-        decimation_target: Optional[int] = None,
-        texture_size: Optional[int] = None,
-        *,
-        prompt: Optional[str] = None,
-        negative_prompt: Optional[str] = None,
-        image_url: Optional[str] = None,
-        verbose: Optional[bool] = None,
-        **provider_kwargs: Any,
-    ) -> str:
-        """
-        [C7] The documented R1.2 exception: run `infer()` and write the result.
-        The path comes **in** from the caller and is never derived here — the
-        operator owns artifact placement.
-        Args:
-            output_path: Destination file. Parent directories are created.
-            (everything else: see `infer`)
-        Returns:
-            `str(output_path)`.
-        """
-        if not output_path:
-            raise ValueError("output_path is required (model_require.md R1.2)")
-        data = self.infer(
-            image, seed, decimation_target, texture_size,
-            prompt=prompt, negative_prompt=negative_prompt, image_url=image_url,
-            verbose=verbose, **provider_kwargs,
-        )
-        out = Path(output_path)
-        out.parent.mkdir(parents=True, exist_ok=True)
-        out.write_bytes(data)
-        return str(out)
-    # ── account ───────────────────────────────────────────────────────────────
-    def balance(self) -> dict:
-        """
-        Remaining credits: ``{"balance": float, "frozen": float}``.
-        Cheap and unbilled — call it before a batch to check the budget (C4 note:
-        this is the only method that talks to the API without generating).
-        """
-        return self._unwrap(self.client.request("GET", "/account/balance"))

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/operators/gen_3d_object/operator.py DELETED Viewed

@@ -1,596 +0,0 @@
-"""
-operators/gen_3d_object/operator.py
-Gen3DObjectOperator — accepts a loaded model and processes an input dict into a
-3D output (GLB file on disk).
-The operator is intentionally model-agnostic: you inject any object that
-implements the same interface as Trellis2Model.  New model wrappers can be
-swapped in without touching this file.
-Output layout — two modes, chosen by whether `output_dir` is given:
-  * **per-game (default, `output_dir=None`)** — resolved by
-    `pipeline.common.paths`, so artifacts are grouped by generated game project::
-        test_data/outputs/<game_id>/<run_id>/assets/3d_object/<task_id>/
-            ├── model.glb
-            └── meta.json
-  * **flat (legacy, `output_dir="..."`)** — writes `<output_dir>/<task_id>.glb`,
-    byte-for-byte the historical behaviour. Existing callers are unaffected.
-Usage:
-    from models.gen_3d_object.trellis_2_model import Trellis2Model
-    from operators.gen_3d_object.operator import Gen3DObjectOperator
-    model = Trellis2Model(model_path="...")
-    # per-game layout
-    op = Gen3DObjectOperator(model=model, run_id="20260731_1032")
-    # legacy flat layout (unchanged)
-    op = Gen3DObjectOperator(model=model, output_dir="outputs/3d_object")
-    result = op.run({
-        "game_id": "gameA_cyberpunk_shooter",   # optional, inferred when omitted
-        "task_id": "sword_001",
-        "image_path": "path/to/image.png",      # or "image": PIL.Image
-        "seed": 42,
-    })
-    print(result["glb_path"])
-Two optional extras, both additive and off unless asked for:
-  * naming an ``asset_id`` in the task hands the finished mesh to the
-    three.js adapter — staged, oriented, manifest rewritten;
-  * ``run_art_plan(game_id, image_model)`` generates a whole game's
-    recorded art plan (``funcs/art_plan.py``) that way in one call.
-``funcs/asset_pack.py`` covers the other case: three CC0 models,
-downloaded and imported in seconds, for when generating is overkill.
-A third route skips inference entirely. Passing ``spec`` instead of an
-image builds the mesh from a declarative part list
-(``funcs/code_asset.py``), which suits anything exactly describable — a
-crate, a sign, a wheel, a rifle. It needs no model and no GPU, states its
-own facing and size instead of leaving them to be guessed, and keeps its
-parts as named glTF nodes so gameplay can still move them::
-    op = Gen3DObjectOperator(model=None, run_id="20260826_1400")
-    op.run({
-        "game_id": "gameA_cyberpunk_shooter",
-        "task_id": "crate_001",
-        "spec": {
-            "subject": "wooden supply crate",
-            "units": "metres", "forward": "+z",
-            "asset_type": "prop", "height_metres": 0.6,
-            "parts": [{"id": "body", "kind": "box",
-                       "size": [0.6, 0.6, 0.6], "at": [0, 0.3, 0]}],
-        },
-    })
-The two can be mixed, which is usually the best available answer for a
-detailed hard-surface asset. A ``mesh`` part reads a GLB off disk — one
-component generated by a cloud model — and is placed, measured and gated
-exactly like a primitive. What each side contributes is not
-interchangeable: the generator supplies shapes no formula states (a
-moulded grip's finger swells), and the spec supplies the dimensions and
-placement a prompt cannot specify (a rail's 30 mm slot pitch). Spending
-generation on something a lathe states exactly buys an approximation at a
-hundred times the triangles, and the approximation is the part that can no
-longer be adjusted by editing a number — so the ``provenance`` gate
-reports what was delegated and at what cost::
-    op.run({
-        "game_id": "gameA_cyberpunk_shooter",
-        "task_id": "rifle_001",
-        "spec": {
-            "subject": "assault rifle",
-            "units": "metres", "forward": "+z",
-            "asset_type": "weapon", "height_metres": 0.24,
-            "parts": [
-                # exact dimensions: stated
-                {"id": "receiver", "kind": "box",
-                 "size": [0.04, 0.048, 0.30], "at": [0, 0.139, -0.03]},
-                # moulded surface: fetched, with a uniform `size` so the
-                # mesh keeps the proportions it was generated with
-                {"id": "grip", "kind": "mesh",
-                 "source": "parts/grip.glb",
-                 "size": [0.116, 0.116, 0.116], "at": [0, 0.045, -0.104]},
-            ],
-        },
-    })
-"""
-from __future__ import annotations
-import time
-from pathlib import Path
-from typing import Any, Optional
-from PIL import Image
-#: Registered task kind for this operator (see pipeline/common/paths.py).
-TASK_KIND = "3d_object"
-#: Artifact filename used by the per-game layout.
-GLB_FILENAME = "model.glb"
-class Gen3DObjectOperator:
-    """
-    Operator for 3D object generation.
-    Args:
-        model: A loaded model with an `infer_and_save(image, output_path, ...)` method.
-               Currently supports Trellis2Model; any model with the same interface works.
-        output_dir (str, optional): **Legacy flat mode.** When given, every GLB is
-               written as `<output_dir>/<task_id>.glb`, exactly as before. When
-               omitted (default), the per-game layout under
-               `test_data/outputs/<game_id>/<run_id>/assets/3d_object/<task_id>/`
-               is used instead.
-        run_id (str): Groups all artifacts of one generation run. Per-game mode only.
-        default_game_id (str, optional): Fallback game project for tasks that carry
-               no `game_id` and whose input paths reveal none. Per-game mode only.
-    """
-    def __init__(
-        self,
-        model: Any,
-        output_dir: Optional[str] = None,
-        run_id: str = "default",
-        default_game_id: Optional[str] = None,
-    ):
-        self.model = model
-        self.run_id = run_id
-        self.default_game_id = default_game_id
-        # Legacy flat mode is active only when an explicit output_dir is supplied.
-        self.output_dir = Path(output_dir) if output_dir else None
-        if self.output_dir is not None:
-            self.output_dir.mkdir(parents=True, exist_ok=True)
-    # --------------------------------------------------------------------------
-    def _load_image(self, inp: dict) -> Image.Image:
-        """Return a PIL image from an input dict that has 'image_path' or 'image'."""
-        if "image" in inp and isinstance(inp["image"], Image.Image):
-            return inp["image"]
-        if "image_path" in inp:
-            p = Path(inp["image_path"])
-            if not p.is_absolute() and not p.exists():
-                # resolve relative to repo root (codes_official/)
-                repo_root = Path(__file__).resolve().parents[2]
-                p = repo_root / inp["image_path"]
-            return Image.open(str(p)).convert("RGBA")
-        raise ValueError("Input must contain 'image_path' (str) or 'image' (PIL.Image).")
-    # --------------------------------------------------------------------------
-    def _artifact_suffix(self) -> str:
-        """
-        File extension for the artifact — GLB unless the injected model says
-        otherwise (the cloud backends can emit FBX / OBJ / USDZ).
-        The result dict keeps the ``glb_path`` key whatever the extension is:
-        renaming a returned key breaks `eval.py` and `test/`.
-        """
-        fmt = getattr(self.model, "output_format", None)
-        return str(fmt).lower().lstrip(".") if fmt else "glb"
-    def _resolve_out_path(self, inp: dict, task_id: str) -> tuple[str, Path, Path]:
-        """
-        Return ``(game_id, task_dir, glb_path)`` for either output mode.
-        Legacy flat mode keeps the historical `<output_dir>/<task_id>.glb`.
-        """
-        suffix = self._artifact_suffix()
-        if self.output_dir is not None:
-            game_id = str(inp.get("game_id") or inp.get("game") or "")
-            return game_id, self.output_dir, self.output_dir / f"{task_id}.{suffix}"
-        from pipeline.common import paths
-        game_id = paths.infer_game_id(inp, fallback=self.default_game_id)
-        task_dir = paths.task_output_dir(game_id, TASK_KIND, task_id, run_id=self.run_id)
-        filename = GLB_FILENAME if suffix == "glb" else f"model.{suffix}"
-        return game_id, task_dir, task_dir / filename
-    # --------------------------------------------------------------------------
-    def run(self, inp: dict) -> dict:
-        """
-        Generate a 3D object from an image prompt, or build one from a spec.
-        Args:
-            inp (dict):
-                - image_path (str): path to the reference / concept image
-                  OR image (PIL.Image): pre-loaded image
-                  OR spec (dict): a part spec, which builds the mesh instead
-                  of inferring it (see `funcs/code_asset.py`)
-                - compose (dict): combine_avatar arguments, including caller-defined
-                  socket_definitions, grip_templates and optional slot_definitions
-                - game_id (str, optional): game project this task belongs to;
-                  inferred from `image_path` when omitted
-                - task_id (str, optional): used to name the output file / directory
-                - seed (int, optional): random seed (default 42)
-                - decimation_target (int, optional)
-                - texture_size (int, optional)
-        Returns:
-            dict:
-                - task_id (str)
-                - glb_path (str): absolute path to the saved GLB file
-                - elapsed_sec (float)
-                - game_id (str), task_kind (str), output_dir (str)  ← additive
-        """
-        if inp.get("compose") is not None:
-            if inp.get("spec") is not None:
-                raise ValueError("provide compose or spec, not both")
-            return self._run_compose(inp)
-        if inp.get("spec") is not None:
-            return self._run_spec(inp)
-        task_id = inp.get("task_id", f"task_{int(time.time())}")
-        seed = inp.get("seed", 42)
-        decimation_target = inp.get("decimation_target", 1_000_000)
-        texture_size = inp.get("texture_size", 4096)
-        game_id, task_dir, out_path = self._resolve_out_path(inp, task_id)
-        text_mode = inp.get("input_mode") == "text_to_3d"
-        if text_mode and not str(inp.get("prompt") or "").strip():
-            raise ValueError("text_to_3d requires a non-empty prompt")
-        image = None if text_mode else self._load_image(inp)
-        inference_kwargs = {"prompt": inp["prompt"]} if text_mode else {}
-        t0 = time.time()
-        glb_path = self.model.infer_and_save(
-            image,
-            output_path=str(out_path),
-            seed=seed,
-            decimation_target=decimation_target,
-            texture_size=texture_size,
-            **inference_kwargs,
-        )
-        elapsed = time.time() - t0
-        result = {
-            "task_id": task_id,
-            "glb_path": glb_path,
-            "elapsed_sec": round(elapsed, 2),
-            "game_id": game_id,
-            "task_kind": TASK_KIND,
-            "output_dir": str(task_dir),
-        }
-        # Image-to-3D infers a floor under a subject that stands on the edge
-        # of its own crop, and it is never wanted: measured at a fifth of the
-        # triangle budget, and a grey pancake under the character in the
-        # scene. Removing it here means every consumer of this task output
-        # gets a clean mesh, rather than each game discovering the slab.
-        if inp.get("strip_ground_plate", True):
-            from .funcs.mesh_cleanup import strip_ground_plate
-            cleanup = strip_ground_plate(glb_path)
-            result["ground_plate"] = cleanup
-            if cleanup.get("applied"):
-                result.setdefault("warnings", []).append(
-                    f"removed an inferred floor: {cleanup['plate_count']} "
-                    f"sheets and {cleanup['debris_count']} loose lumps, "
-                    f"{cleanup['removed_fraction']:.0%} of the mesh"
-                )
-            elif cleanup.get("reason") and "nothing" not in cleanup["reason"]:
-                result.setdefault("warnings", []).append(
-                    f"left the mesh alone: {cleanup['reason']}"
-                )
-        # meta.json only in per-game mode, so legacy output dirs stay untouched.
-        if self.output_dir is None:
-            from pipeline.common import paths
-            meta = {
-                **result,
-                "run_id": self.run_id,
-                "prompt": inp.get("prompt"),
-                "source_image": inp.get("image_path"),
-                "seed": seed,
-                "decimation_target": decimation_target,
-                "texture_size": texture_size,
-                "model": type(self.model).__name__,
-            }
-            for key in ("asset_id", "asset_type", "forward_axis",
-                        "scale_hint_metres", "notes"):
-                if inp.get(key) is not None:
-                    meta[key] = inp[key]
-            # Cloud backends expose what the call cost and produced — task id,
-            # credits, triangle count (api_model_require.md R9.8). Recording it
-            # here is what makes a billed run reproducible after the fact.
-            call_info = getattr(self.model, "last_call_info", None)
-            if call_info:
-                meta["model_call"] = dict(call_info)
-            paths.write_task_meta(task_dir, meta)
-        # Optional handover to the engine adapter, active only when the task
-        # names an asset. A generated mesh is not part of a game until the
-        # adapter has staged it and recorded which way it faces.
-        if inp.get("asset_id") and self.output_dir is None:
-            from .funcs.asset_import import import_asset
-            result.update(
-                import_asset(
-                    game_id,
-                    task_id,
-                    asset_id=str(inp["asset_id"]),
-                    asset_type=str(inp.get("asset_type") or "prop"),
-                    run_id=self.run_id,
-                    forward_axis=str(inp.get("forward_axis") or ""),
-                    scale_hint_metres=inp.get("scale_hint_metres"),
-                    verified_by=str(inp.get("verified_by") or "heuristic"),
-                    notes=str(inp.get("notes") or ""),
-                    project_hint=str(inp.get("project_hint") or ""),
-                    preview=bool(inp.get("preview", True)),
-                )
-            )
-        return result
-    # --------------------------------------------------------------------------
-    def _run_compose(self, inp: dict) -> dict:
-        """Resolve caller-configured attachments, then build through the spec route."""
-        import json
-        from .funcs.code_asset_templates.human_template.combine import (
-            combine_avatar, write_report,
-        )
-        task_id = inp.get("task_id", f"task_{int(time.time())}")
-        _, _, out_path = self._resolve_out_path(inp, task_id)
-        directory = out_path.parent / f"{out_path.stem}_compose"
-        config = dict(inp["compose"])
-        config.setdefault("parts_dir", directory / "parts")
-        started = time.time()
-        combined = combine_avatar(**config)
-        result = self._run_spec({**inp, "task_id": task_id, "spec": combined["spec"]})
-        report_path = write_report(combined["report"], directory / "report.json")
-        sockets_path = directory / "sockets.json"
-        sockets_path.write_text(json.dumps(combined["report"]["sockets"], indent=2),
-                                encoding="utf-8")
-        result["compose"] = {**combined["report"], "report_path": report_path,
-                             "sockets_path": str(sockets_path)}
-        result["elapsed_sec"] = round(time.time() - started, 2)
-        return result
-    def _run_spec(self, inp: dict) -> dict:
-        """Build the asset from a declarative spec rather than an image.
-        Taken when the task carries a ``spec``. No model is loaded and no
-        image is read, so this path works with ``model=None`` — a crate
-        does not need a GPU, and requiring one to build a box is what makes
-        primitives feel like a defeat rather than a choice.
-        Three things come out of the spec that the generated path can only
-        guess at, which is the reason to prefer it wherever it applies:
-          * ``forward_axis`` is *stated*, so the import is recorded as
-            ``verified_by="spec"`` rather than ``"heuristic"``. Facing is
-            the one property `orientation_review` exists to establish, and
-            here there is nothing to establish.
-          * ``scale_hint_metres`` is stated, so the mesh has a real size
-            instead of a unit box someone has to scale by eye.
-          * parts keep their ids as glTF node names, so a wheel can be spun
-            after import. A reconstructed mesh is one fused body.
-        ``strip_ground_plate`` is deliberately not run: it removes a floor
-        that image-to-3D *invented*, and a spec cannot invent one. Running
-        it here would risk deleting a plinth that was asked for.
-        A spec may also carry ``mesh`` parts, which read a GLB off disk —
-        typically one component from a cloud model, composed in where no
-        formula states the shape. Those change one thing here and nothing
-        else: ``verified_by`` drops to ``"spec+generated"``, because a
-        generated part's facing was *asserted* by whoever placed it and not
-        established by anything. Claiming ``"spec"`` for a composition that
-        is largely fetched geometry would put an unverified facing behind the
-        one label that is supposed to mean it was not guessed.
-        """
-        from .funcs.code_asset import MESH_KIND, build_code_asset
-        task_id = inp.get("task_id", f"task_{int(time.time())}")
-        game_id, task_dir, out_path = self._resolve_out_path(inp, task_id)
-        # A spec always yields glTF, whatever output_format an injected
-        # model happens to advertise.
-        out_path = out_path.with_suffix(".glb")
-        task_dir.mkdir(parents=True, exist_ok=True)
-        t0 = time.time()
-        report = build_code_asset(
-            inp["spec"],
-            str(out_path),
-            revise=inp.get("revise"),
-            strict=bool(inp.get("strict", True)),
-        )
-        elapsed = time.time() - t0
-        # Which parts were fetched rather than derived. Carried on the result
-        # because after export the two are indistinguishable, and only one of
-        # them can still be changed by editing a number: a reviewer who wants
-        # the grip 4 mm thicker needs to know that means regenerating it.
-        # `long_axis` travels too, since a regenerated part is a new set of
-        # axes and the rotation that placed the old one will not place it.
-        generated_parts = [
-            {
-                "id": part["id"],
-                "source": part["source"],
-                "long_axis": part.get("long_axis"),
-            }
-            for part in report["spec"]["parts"]
-            if part.get("kind") == MESH_KIND
-        ]
-        result: dict[str, Any] = {
-            "task_id": task_id,
-            "glb_path": report["glb_path"],
-            "elapsed_sec": round(elapsed, 2),
-            "game_id": game_id,
-            "task_kind": TASK_KIND,
-            "output_dir": str(task_dir),
-            "source": "code_asset+generated" if generated_parts else "code_asset",
-            "spec_ok": report["ok"],
-            "gates": report["gates"],
-            "triangles": report["triangles"],
-            "bounds": report["bounds"],
-            "part_ids": report["part_ids"],
-            "generated_parts": generated_parts,
-            "stop_reason": report["stop_reason"],
-            "attempts": report["attempts"],
-        }
-        if report["warnings"]:
-            result.setdefault("warnings", []).extend(report["warnings"])
-        if report["failures"]:
-            # Surfaced as warnings on the result *and* kept in `gates`: a
-            # gate failure that only appears in a nested dict is the silent
-            # early return this whole module is shaped against.
-            result.setdefault("warnings", []).extend(
-                f"gate: {message}" for message in report["failures"]
-            )
-        if self.output_dir is None:
-            from pipeline.common import paths
-            meta = {
-                **result,
-                "run_id": self.run_id,
-                "spec": report["spec"],
-                "forward_axis": report["forward_axis"],
-                "scale_hint_metres": report["scale_hint_metres"],
-                "model": "code_asset",
-            }
-            for key in ("asset_id", "asset_type", "notes"):
-                if inp.get(key) is not None:
-                    meta[key] = inp[key]
-            paths.write_task_meta(task_dir, meta)
-        # A failed spec is not handed to the engine. An asset that exists
-        # gets used, so a gate failure has to stop it becoming an asset.
-        if inp.get("asset_id") and self.output_dir is None and report["ok"]:
-            from .funcs.asset_import import import_asset
-            result.update(
-                import_asset(
-                    game_id,
-                    task_id,
-                    asset_id=str(inp["asset_id"]),
-                    asset_type=str(
-                        inp.get("asset_type")
-                        or report["spec"].get("asset_type")
-                        or "prop"
-                    ),
-                    run_id=self.run_id,
-                    # Stated by the spec, not inferred from a view.
-                    forward_axis=report["forward_axis"],
-                    scale_hint_metres=report["scale_hint_metres"],
-                    # "spec" means the facing was stated rather than guessed.
-                    # With generated parts in the composition that is only
-                    # half true: the *placement* is stated, but the mesh
-                    # inside it came from a generator with no facing of its
-                    # own, and whoever wrote the rotation asserted one. Said
-                    # distinctly so a reviewer knows an orientation check is
-                    # still worth a look, instead of trusting a label that
-                    # was earned by a different route.
-                    verified_by="spec+generated" if generated_parts else "spec",
-                    notes=str(inp.get("notes") or "")
-                    or (
-                        f"Built from a spec: {report['subject']}."
-                        + (
-                            f" {len(generated_parts)} generated part(s): "
-                            f"{', '.join(part['id'] for part in generated_parts)}."
-                            if generated_parts else ""
-                        )
-                    ),
-                    project_hint=str(inp.get("project_hint") or ""),
-                    preview=bool(inp.get("preview", True)),
-                )
-            )
-        return result
-    # --------------------------------------------------------------------------
-    def run_art_plan(
-        self,
-        game_id: str,
-        image_model: Any = None,
-        plan: Optional[list[dict]] = None,
-        assets: tuple[str, ...] = (),
-    ) -> list[dict]:
-        """
-        Generate a game's recorded art plan and import each asset.
-        The plan lives in `funcs/art_plan.py`; it names a subject, an asset
-        type and a **height in metres**, because a mesh normalised into a
-        unit box has no size of its own. Concept images come from
-        `image_model` unless an entry points at one.
-        Facing is recorded as `heuristic`, never as verified: single-image
-        reconstruction puts the input view on a predictable axis, but a
-        guess labelled as checked stops anyone checking. Each import leaves
-        a review sheet for `agent_skills/asset_qa/`.
-        """
-        from .funcs.art_plan import concept_image, plan_for_game
-        entries = plan if plan is not None else plan_for_game(game_id)
-        if not entries:
-            raise ValueError(
-                f"No art plan for {game_id!r}; add one to "
-                "operators/gen_3d_object/funcs/art_plan.py"
-            )
-        results: list[dict] = []
-        for entry in entries:
-            if assets and entry["asset_id"] not in assets:
-                continue
-            image, provenance, framing = concept_image(entry, image_model)
-            task_dir = Path(
-                self._resolve_out_path(
-                    {"game_id": game_id}, entry["task_id"]
-                )[1]
-            )
-            task_dir.mkdir(parents=True, exist_ok=True)
-            # Keep the concept image beside the mesh it produced: a bad
-            # asset is almost always a bad concept image, and that is not
-            # diagnosable after the fact if the input was thrown away.
-            image.save(task_dir / "concept.png")
-            result = self.run(
-                {
-                    "game_id": game_id,
-                    "task_id": entry["task_id"],
-                    "image": image,
-                    "prompt": entry["full_prompt"],
-                    "seed": entry.get("seed", 42),
-                    "decimation_target": entry["triangles"],
-                    "texture_size": entry["texture"],
-                    "asset_id": entry["asset_id"],
-                    "asset_type": entry["type"],
-                    "forward_axis": entry["faces"],
-                    "scale_hint_metres": entry["height"],
-                    "verified_by": "heuristic",
-                    "notes": entry["notes"]
-                    or f"Generated from: {provenance}. Facing assumed "
-                    "from the input view.",
-                }
-            )
-            result["asset_id"] = entry["asset_id"]
-            result["concept_source"] = provenance
-            result["framing"] = framing
-            if framing.get("touched_border"):
-                # The subject ran off the edge of the generated image, so
-                # part of it was never drawn. Cropping cannot invent it.
-                result.setdefault("warnings", []).append(
-                    "the concept image was cropped at the border, so the "
-                    "mesh is probably truncated: regenerate with another "
-                    "seed"
-                )
-            results.append(result)
-        return results
-    # --------------------------------------------------------------------------
-    def run_batch(self, inputs: list[dict]) -> list[dict]:
-        """Run a list of input dicts sequentially and return results."""
-        return [self.run(inp) for inp in inputs]

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/paths.py DELETED Viewed

@@ -1,444 +0,0 @@
-"""
-pipeline/common/paths.py
-Single source of truth for every input / output path in 3AGameFactory.
-The benchmark is authored **per game project**, so outputs are organized the same
-way. An artifact is uniquely addressed by ``(game_id, run_id, task_kind, task_id)``::
-    test_data/test_samples/<game_id>/<TaskDir>/...                        # inputs (read-only)
-    test_data/outputs/<game_id>/<run_id>/<layer>/<task_kind>/<task_id>/   # outputs
-Full output tree::
-    test_data/outputs/                         # OUTPUT_ROOT ($AAAGF_OUTPUT_ROOT)
-    └── gameA_cyberpunk_shooter/               # one dir per generated game project
-        ├── latest -> 20260731_1032/           # symlink to the most recent run
-        └── <run_id>/                          # "default", or a timestamp
-            ├── run_meta.json                  # ckpts · seeds · git sha · argv
-            ├── assets/
-            │   ├── 3d_object/<task_id>/       # model.glb        + meta.json
-            │   ├── tpose/<task_id>/           # tpose_fg.png     + meta.json
-            │   ├── 3d_scene/<task_id>/
-            │   ├── motion/<task_id>/
-            │   ├── cg_video/<task_id>/
-            │   └── audio/<task_id>/            # dialogue / sound-effect audio + meta.json
-            ├── mechanic/<task_id>/            # engine project + demo_outputs/ + launch.sh
-            ├── ui/<task_id>/
-            ├── pipeline/<task_id>/            # end-to-end game-slice artifacts
-            └── eval/
-                ├── <task_kind>/<task_id>/     # metrics.json · build.log · judge_log.json
-                └── summary.json               # aggregate over the whole run
-The root stays next to the test set so any evaluator finds inputs and outputs side
-by side. Generated artifacts get large — point ``$AAAGF_OUTPUT_ROOT`` at a scratch
-disk to relocate the whole tree without touching code.
-This module has **no third-party dependencies** and imports no models, so it is
-safe to import from anywhere (including CPU-only tooling and tests).
-"""
-from __future__ import annotations
-import json
-import os
-import subprocess
-import sys
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Optional
-# ── Roots ─────────────────────────────────────────────────────────────────────
-REPO_ROOT = Path(__file__).resolve().parents[2]
-TEST_DATA_ROOT = REPO_ROOT / "test_data"
-TEST_SAMPLES_ROOT = TEST_DATA_ROOT / "test_samples"
-#: Output root. Override with ``export AAAGF_OUTPUT_ROOT=/scratch/aaagf_outputs``.
-OUTPUT_ROOT = Path(
-    os.environ.get("AAAGF_OUTPUT_ROOT", TEST_DATA_ROOT / "outputs")
-).expanduser()
-#: Used when a task carries no game association (ad-hoc single-image demos).
-UNASSIGNED_GAME = "_scratch"
-#: Run id used when the caller does not ask for a fresh timestamped one.
-DEFAULT_RUN_ID = "default"
-LATEST_LINK = "latest"
-# ── Task kinds ────────────────────────────────────────────────────────────────
-#: task_kind -> layer directory. Layer A = assets, B = mechanic, C = ui.
-TASK_LAYER: dict[str, str] = {
-    # Layer A — asset generation
-    "3d_object": "assets",
-    "tpose": "assets",
-    "3d_scene": "assets",
-    "motion": "assets",
-    "cg_video": "assets",
-    "audio": "assets",
-    # Game design (story / chapters / asset & screen plan) — A-layer diagnostic only
-    "design": "design",
-    # Layer B / C — code generation
-    "mechanic": "mechanic",
-    "ui": "ui",
-    # End-to-end vertical slice
-    "pipeline": "pipeline",
-    # Whitebox-stage game evaluation (stage-1 LLM/Agent whitebox rubric) —
-    # an eval-only kind: results land under ``eval/whitebox/<task_id>/``
-    "whitebox": "whitebox",
-}
-#: task_kind -> directory name inside ``test_samples/<game_id>/``.
-TASK_INPUT_DIR: dict[str, str] = {
-    "3d_object": "3D_object",
-    "tpose": "tpose",
-    "3d_scene": "3D_scene",
-    "motion": "motion",
-    "cg_video": "cg_video",
-    "audio": "audio",
-    "design": "design",
-    "mechanic": "mechanic",
-    "ui": "ui",
-    "pipeline": "pipeline",
-    # whitebox case inputs (game_spec/rubric/references) live under
-    # ``test_bench_example/<case>/``; this dir keeps the registration
-    # complete for the shared task-input helpers.
-    "whitebox": "whitebox",
-}
-#: task_kind -> per-game task list filename inside ``TASK_INPUT_DIR``.
-TASK_JSONL: dict[str, str] = {
-    "3d_object": "object_tasks.jsonl",
-    "tpose": "tpose_tasks.jsonl",
-    "3d_scene": "scene_tasks.jsonl",
-    "motion": "motion_tasks.jsonl",
-    "cg_video": "cg_tasks.jsonl",
-    "audio": "audio_tasks.jsonl",
-    "design": "design_tasks.jsonl",
-    "mechanic": "mechanic_tasks.jsonl",
-    "ui": "ui_tasks.jsonl",
-    "pipeline": "pipeline_task.jsonl",
-    "whitebox": "whitebox_tasks.jsonl",
-}
-#: task_kind -> cross-game aggregate jsonl under ``test_samples/``.
-TASK_COLLECT_JSONL: dict[str, str] = {
-    "3d_object": "3D_object_gen_collect.jsonl",
-    "tpose": "tpose_gen_collect.jsonl",
-    "3d_scene": "3D_scene_gen_collect.jsonl",
-    "motion": "motion_gen_collect.jsonl",
-    "cg_video": "cg_video_collect.jsonl",
-    "audio": "audio_gen_collect.jsonl",
-    "design": "design_collect.jsonl",
-    "mechanic": "mechanic_collect.jsonl",
-    "ui": "ui_collect.jsonl",
-    "pipeline": "pipeline_collect.jsonl",
-    "whitebox": "whitebox_collect.jsonl",
-}
-#: Layer-A kinds only — what ``pipeline/assets_gen/`` covers.
-ASSET_TASK_KINDS = tuple(k for k, v in TASK_LAYER.items() if v == "assets")
-def check_kind(task_kind: str) -> str:
-    """Raise a helpful error for an unregistered task kind."""
-    if task_kind not in TASK_LAYER:
-        raise ValueError(
-            f"Unknown task_kind {task_kind!r}. Register it in "
-            f"pipeline/common/paths.py first. Known: {sorted(TASK_LAYER)}"
-        )
-    return task_kind
-# ── Input paths ───────────────────────────────────────────────────────────────
-def game_input_dir(game_id: str) -> Path:
-    """``test_data/test_samples/<game_id>/``"""
-    return TEST_SAMPLES_ROOT / game_id
-def task_input_dir(game_id: str, task_kind: str) -> Path:
-    """``test_data/test_samples/<game_id>/<TaskDir>/``"""
-    return game_input_dir(game_id) / TASK_INPUT_DIR[check_kind(task_kind)]
-def task_jsonl(game_id: str, task_kind: str) -> Path:
-    """``test_data/test_samples/<game_id>/<TaskDir>/<kind>_tasks.jsonl``"""
-    return task_input_dir(game_id, task_kind) / TASK_JSONL[check_kind(task_kind)]
-def collect_jsonl(task_kind: str) -> Path:
-    """``test_data/test_samples/<kind>_collect.jsonl`` — cross-game task list."""
-    return TEST_SAMPLES_ROOT / TASK_COLLECT_JSONL[check_kind(task_kind)]
-def resolve_tasks_path(task_kind: str, tasks: str | None = None,
-                       game_id: str | None = None) -> Path:
-    """
-    Standard task-list resolution shared by every ``run.py`` / ``eval.py``:
-    explicit ``--tasks``  →  the game's own ``*_tasks.jsonl`` (if non-empty)
-                          →  the cross-game ``*_collect.jsonl``.
-    """
-    if tasks:
-        return resolve_input_path(tasks)
-    if game_id:
-        per_game = task_jsonl(game_id, task_kind)
-        if per_game.exists() and per_game.stat().st_size > 0:
-            return per_game
-    return collect_jsonl(task_kind)
-def list_games() -> list[str]:
-    """Every game project directory present in the test set."""
-    if not TEST_SAMPLES_ROOT.is_dir():
-        return []
-    return sorted(
-        p.name
-        for p in TEST_SAMPLES_ROOT.iterdir()
-        if p.is_dir() and not p.name.startswith((".", "_"))
-    )
-def infer_game_id(task: dict, fallback: Optional[str] = None) -> str:
-    """
-    Resolve which game project a task belongs to.
-    Priority: explicit ``game_id`` / ``game`` field  →  any path-like field that
-    sits under ``test_samples/<game_id>/``  →  ``fallback``  →  ``UNASSIGNED_GAME``.
-    """
-    for key in ("game_id", "game"):
-        if task.get(key):
-            return str(task[key])
-    for value in task.values():
-        if not isinstance(value, str) or "test_samples" not in value:
-            continue
-        parts = Path(value).parts
-        if "test_samples" in parts:
-            idx = parts.index("test_samples")
-            if idx + 1 < len(parts):
-                return parts[idx + 1]
-    return fallback or UNASSIGNED_GAME
-def iter_tasks(tasks_path: str | Path, game_filter: str | None = None):
-    """
-    Yield ``(task_dict, game_id)`` from a jsonl, skipping blanks and comments.
-    Every runner should iterate through this so `game_id` resolution and the
-    `--game` filter behave identically across tasks.
-    """
-    with open(tasks_path) as f:
-        for lineno, line in enumerate(f, 1):
-            line = line.strip()
-            if not line or line.startswith("//"):
-                continue
-            try:
-                task = json.loads(line)
-            except json.JSONDecodeError as e:
-                raise ValueError(f"{tasks_path}:{lineno} is not valid JSON: {e}") from e
-            game_id = infer_game_id(task)
-            if game_filter and game_id != game_filter:
-                continue
-            yield task, game_id
-# ── Output paths ──────────────────────────────────────────────────────────────
-def new_run_id(prefix: str = "") -> str:
-    """Timestamped run id, e.g. ``20260731_103200`` or ``qwen3b_20260731_103200``."""
-    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    return f"{prefix}_{stamp}" if prefix else stamp
-def game_output_dir(game_id: str) -> Path:
-    """``test_data/outputs/<game_id>/``"""
-    return OUTPUT_ROOT / game_id
-def run_dir(game_id: str, run_id: str = DEFAULT_RUN_ID) -> Path:
-    """``test_data/outputs/<game_id>/<run_id>/`` — root of one generation run."""
-    return game_output_dir(game_id) / run_id
-def task_output_dir(
-    game_id: str,
-    task_kind: str,
-    task_id: str,
-    run_id: str = DEFAULT_RUN_ID,
-    create: bool = True,
-) -> Path:
-    """
-    ``test_data/outputs/<game_id>/<run_id>/<layer>/[<task_kind>/]<task_id>/``
-    One directory per task, so an artifact ships alongside its preview,
-    intermediates and ``meta.json`` without filename mangling.
-    """
-    check_kind(task_kind)
-    layer = TASK_LAYER[task_kind]
-    base = run_dir(game_id, run_id) / layer
-    # assets/ is further split by kind; mechanic/ ui/ pipeline/ *are* the kind.
-    if layer == "assets":
-        base = base / task_kind
-    path = base / task_id
-    if create:
-        path.mkdir(parents=True, exist_ok=True)
-    return path
-def eval_output_dir(
-    game_id: str,
-    task_kind: str,
-    task_id: str,
-    run_id: str = DEFAULT_RUN_ID,
-    create: bool = True,
-) -> Path:
-    """``test_data/outputs/<game_id>/<run_id>/eval/<task_kind>/<task_id>/``"""
-    check_kind(task_kind)
-    path = run_dir(game_id, run_id) / "eval" / task_kind / task_id
-    if create:
-        path.mkdir(parents=True, exist_ok=True)
-    return path
-def eval_summary_path(game_id: str, run_id: str = DEFAULT_RUN_ID) -> Path:
-    """``test_data/outputs/<game_id>/<run_id>/eval/summary.json``"""
-    return run_dir(game_id, run_id) / "eval" / "summary.json"
-def results_summary_path(game_id: str, task_kind: str,
-                         run_id: str = DEFAULT_RUN_ID) -> Path:
-    """``test_data/outputs/<game_id>/<run_id>/<task_kind>_results_summary.json``"""
-    check_kind(task_kind)
-    return run_dir(game_id, run_id) / f"{task_kind}_results_summary.json"
-def run_meta_path(game_id: str, run_id: str = DEFAULT_RUN_ID) -> Path:
-    """``test_data/outputs/<game_id>/<run_id>/run_meta.json``"""
-    return run_dir(game_id, run_id) / "run_meta.json"
-# ── Run bookkeeping ───────────────────────────────────────────────────────────
-def _git_sha() -> Optional[str]:
-    try:
-        out = subprocess.run(
-            ["git", "-C", str(REPO_ROOT), "rev-parse", "--short", "HEAD"],
-            capture_output=True, text=True, timeout=5,
-        )
-        return out.stdout.strip() or None
-    except Exception:
-        return None
-def update_latest_link(game_id: str, run_id: str) -> None:
-    """Repoint ``<game_id>/latest`` at ``run_id`` (best effort, never fatal)."""
-    if run_id == LATEST_LINK:
-        return
-    link = game_output_dir(game_id) / LATEST_LINK
-    try:
-        link.parent.mkdir(parents=True, exist_ok=True)
-        if link.is_symlink() or link.exists():
-            link.unlink()
-        link.symlink_to(run_id, target_is_directory=True)
-    except OSError:
-        pass  # filesystem without symlink support — not fatal
-def write_run_meta(
-    game_id: str,
-    run_id: str = DEFAULT_RUN_ID,
-    *,
-    task_kind: Optional[str] = None,
-    extra: Optional[dict[str, Any]] = None,
-) -> Path:
-    """Record how a run was produced, so results stay reproducible."""
-    path = run_meta_path(game_id, run_id)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    meta: dict[str, Any] = {
-        "game_id": game_id,
-        "run_id": run_id,
-        "task_kind": task_kind,
-        "created_at": datetime.now().isoformat(timespec="seconds"),
-        "git_sha": _git_sha(),
-        "argv": sys.argv,
-    }
-    if extra:
-        meta.update(extra)
-    if path.exists():  # merge with an earlier task_kind in the same run
-        try:
-            prev = json.loads(path.read_text(encoding="utf-8"))
-            history = prev.pop("history", [])
-            history.append(prev)
-            meta["history"] = history
-        except (json.JSONDecodeError, OSError):
-            pass
-    path.write_text(json.dumps(meta, indent=2, ensure_ascii=False), encoding="utf-8")
-    return path
-def write_task_meta(task_dir: str | Path, meta: dict[str, Any]) -> Path:
-    """Write ``<task_dir>/meta.json`` next to the artifacts."""
-    d = Path(task_dir)
-    d.mkdir(parents=True, exist_ok=True)
-    path = d / "meta.json"
-    from .record_paths import portable_value
-    path.write_text(json.dumps(portable_value(meta, d), indent=2, ensure_ascii=False, default=str),
-                    encoding="utf-8")
-    return path
-def write_results_summary(results: list[dict], task_kind: str,
-                         run_id: str = DEFAULT_RUN_ID) -> list[Path]:
-    """
-    Group ``run()`` results by ``game_id`` and write one summary per game,
-    refresh ``run_meta.json`` and the ``latest`` symlink.
-    Returns the summary paths written.
-    """
-    check_kind(task_kind)
-    grouped: dict[str, list[dict]] = {}
-    for r in results:
-        grouped.setdefault(r.get("game_id") or UNASSIGNED_GAME, []).append(r)
-    written = []
-    for game_id, items in grouped.items():
-        path = results_summary_path(game_id, task_kind, run_id)
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(json.dumps(items, indent=2, ensure_ascii=False, default=str),
-                        encoding="utf-8")
-        write_run_meta(game_id, run_id, task_kind=task_kind,
-                       extra={"num_tasks": len(items)})
-        update_latest_link(game_id, run_id)
-        written.append(path)
-    return written
-# ── Misc ──────────────────────────────────────────────────────────────────────
-def resolve_input_path(path_like: str | Path) -> Path:
-    """Resolve a possibly repo-relative input path (jsonl paths are repo-relative)."""
-    if str(path_like).replace("\\", "/").startswith("bench/"):
-        from .record_paths import resolve_path
-        return resolve_path(path_like)
-    p = Path(path_like)
-    if p.is_absolute() or p.exists():
-        return p
-    return REPO_ROOT / p
-def rel_to_repo(path: str | Path) -> str:
-    """Repo-relative string if possible, else the absolute path — for logs / meta."""
-    p = Path(path).resolve()
-    try:
-        return str(p.relative_to(REPO_ROOT))
-    except ValueError:
-        return str(p)

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/record_paths.py DELETED Viewed

@@ -1,77 +0,0 @@
-"""Portable workspace paths for persisted records; resolve only when doing I/O."""
-from __future__ import annotations
-from pathlib import Path
-import re
-BENCH = Path(__file__).resolve().parents[3]
-_PREFIXES = ("test_data/", "GameFactory-3A/", "scripts/", "prompts/", "config/", "reports/")
-_ROOT = BENCH.as_posix()
-_INLINE_ROOT = re.compile(re.escape(_ROOT).replace("/", r"[\\/]"), re.IGNORECASE)
-def resolve_path(value: str | Path) -> Path:
-    text = str(value).replace("\\", "/")
-    if text == "bench" or text.startswith("bench/"):
-        path = (BENCH.parent / text).resolve()
-        path.relative_to(BENCH.resolve())
-        return path
-    path = Path(value)
-    return path if path.is_absolute() else BENCH / path
-def portable_path(value: str | Path, base: Path | None = None) -> str:
-    original = str(value)
-    text = original.replace("\\", "/")
-    if re.match(r"^[A-Za-z][A-Za-z0-9+.-]*:", text) and not re.match(r"^[A-Za-z]:/", text):
-        return original  # URLs, API URIs and dependency descriptors retain their meaning.
-    if text.casefold() == _ROOT.casefold() or text.casefold().startswith(_ROOT.casefold() + "/"):
-        return "bench" + text[len(_ROOT):]
-    if text == "bench" or text.startswith("bench/"):
-        path = resolve_path(text)
-        suffix = path.relative_to(BENCH.resolve()).as_posix()
-        return "bench" if suffix == "." else "bench/" + suffix
-    if text.startswith(_PREFIXES):
-        path = (BENCH / text).resolve()
-        path.relative_to(BENCH.resolve())
-        return "bench/" + path.relative_to(BENCH.resolve()).as_posix()
-    if base is not None and "/" in text and "\n" not in text and not text.startswith("/"):
-        candidate = base / text
-        try:
-            if candidate.exists():
-                return "bench/" + candidate.resolve().relative_to(BENCH.resolve()).as_posix()
-        except (OSError, ValueError):
-            pass
-    return original
-def portable_text(value: str) -> str:
-    """Convert workspace paths embedded in log/error text, leaving URLs intact."""
-    pattern = re.compile(r"(?:https?://[^\s<>]+)|(" + _INLINE_ROOT.pattern + r"(?:[\\/][^\r\n\"'<>|;,)]*)?)", re.IGNORECASE)
-    return pattern.sub(lambda match: portable_path(match.group(1)) if match.group(1) else match.group(0), value)
-def portable_value(value, base: Path | None = None):
-    if isinstance(value, dict):
-        return {portable_path(key) if isinstance(key, str) else key: portable_value(item, base)
-                for key, item in value.items()}
-    if isinstance(value, (list, tuple)):
-        return [portable_value(item, base) for item in value]
-    if isinstance(value, Path):
-        return portable_path(value, base)
-    if isinstance(value, str):
-        result = portable_path(value, base)
-        return portable_text(result)
-    return value
-def runtime_value(value):
-    """Hydrate a verified frozen plan for runtime use; never use before hashing."""
-    if isinstance(value, dict):
-        return {str(resolve_path(key)) if isinstance(key, str) and (key == "bench" or key.startswith("bench/")) else key:
-                runtime_value(item) for key, item in value.items()}
-    if isinstance(value, list):
-        return [runtime_value(item) for item in value]
-    if isinstance(value, str) and (value == "bench" or value.startswith("bench/")):
-        return str(resolve_path(value))
-    return value

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/prompts/stage2_assets.md DELETED Viewed

@@ -1,95 +0,0 @@
-# GameFactory-3A Stage 2 — asset generation
-你正在执行同一个游戏测例的第二阶段资产生成。**开始前必须先阅读 `{SETTING_OVERVIEW}`，并严格遵循其中的 asset refinement、asset QA 和 validation 流程。**
-## 测例输入
-- 游戏测例：`{GAME_ID}`
-- 测例目录：`{CASE_ROOT}`
-- GameFactory-3A 根目录：`{FRAMEWORK_ROOT}`
-- 总入口文档：`{SETTING_OVERVIEW}`
-- 目标引擎：`{ENGINE}`
-- 完整游戏需求：`{GENERAL_REQUIREMENT}`
-- 当前 run 根目录：`{RUN_ROOT}`
-- runner 控制面（冻结索引、prompt/packet/log）：`{GENERATION_CONTROL_ROOT}`
-- 第一阶段白模 run：`{WHITEBOX_RUN_ROOT}`
-- 第一阶段白模 workspace：`{WHITEBOX_WORKSPACE}`
-- 第一阶段资产接口：`{ASSET_SLOTS}`
-- 第一阶段计划/TODO：`{GENERATION_PLAN}`
-- 外部冻结的资产任务索引：`{ASSET_TASK_INDEX}`
-- 资产输出根目录：`{ASSET_OUTPUT_ROOT}`
-- 当前阶段 pipeline task 目录：`{STAGE_WORKSPACE}`
-- 资产 QA 证据根：`{RUN_ROOT}/eval/<task_kind>/<task_id>/`
-请读取游戏完整梗概和玩法，再读取 `{ASSET_TASK_INDEX}` 中列出的**每一条**资产任务、对应的 requirement、JSONL 和参考图片。**每一个资产生成任务都必须使用完整游戏梗概作为上下文**，不能只把孤立的资产 prompt 交给生成流程。
-## 本阶段任务
-1. 根据第一阶段的任务拆解、TODO 和 `asset_slots.json` 确认资产用途、生命周期、比例、朝向、挂点和风格；
-2. 按 `setting_overview.md` 路由到对应的 T-pose、3D object、3D scene、Motion、Audio、CG video 或其他资产 Skill；
-3. 逐项生成冻结任务索引中的所有资产，并执行对应的结构/视觉 QA；
-4. 保持第一阶段定义的 asset ID 和游戏/UI/mechanic contract 不变；
-5. 记录资产来源、配置、参考图、QA 和后续导入要求；
-6. 生成完整的资产 manifest，供第三阶段导入使用。
-## 限制
-- 不修改第一阶段核心游戏机制和需求；
-- 不擅自删除、合并或跳过资产任务；
-- 资产失败必须记录为失败，不能伪造成功；
-- 不将资产生成 QA 当成游戏已经完成；
-- 本阶段默认不执行 Agent repair。
-## 输出位置和 Layer 规则
-资产必须按框架标准布局写入：
-- `{ASSET_OUTPUT_ROOT}/tpose/<task_id>/`；
-- `{ASSET_OUTPUT_ROOT}/3d_object/<task_id>/`；
-- `{ASSET_OUTPUT_ROOT}/3d_scene/<task_id>/`；
-- `{ASSET_OUTPUT_ROOT}/motion/<task_id>/`；
-- `{ASSET_OUTPUT_ROOT}/audio/<task_id>/`；
-- `{ASSET_OUTPUT_ROOT}/cg_video/<task_id>/`。
-每个任务目录至少应有资产文件、`meta.json`、预览（若适用）和 QA 证据。资产 manifest 和阶段产物说明写入 `{ASSET_MANIFEST}`（位于标准 `pipeline/<task_id>/` task 目录）；冻结索引只读自 `{ASSET_TASK_INDEX}`，runner 控制文件写入 `{GENERATION_CONTROL_ROOT}`。每个资产任务的 QA 证据写入 `{RUN_ROOT}/eval/<task_kind>/<task_id>/`。至少生成：
-- `asset_manifest.json`；
-- `asset_generation_report.json`；
-- `asset_task_index.json`（由外部入口生成，不得删改任务）；
-- 失败任务及其失败原因。
-不要写入 case 输入目录、不要覆盖白模 run，也不要创建 `pipeline/assets/` stage 目录；真实资产必须按 `assets/<task_kind>/<task_id>/` 放置，不能把所有文件平铺在 pipeline task 目录。
-## 已确认的优先 3D Object 双服务对比
-当用户明确选择优先 200 条对象任务的 Meshy / Tripo API 对比时，使用
-`scripts/asset/generate_3d_comparison.py` 与 `config/asset_3d_comparison.json`，
-具体命令和费用见 `scripts/asset/README_3d_comparison.md`。这是跨游戏的对象生成实验；
-各游戏只包含 3D Object 子集，不能将其标为六类资产齐全的完整 Stage 2。
-- 输入以 `test_data/priority_gen/3d_object_priority_lowpoly_collect.jsonl` 的全部 200 条为准，
-  保留原 task ID、prompt、seed、参考图及最高 8000 三角面的既定政策。
-- 完整游戏需求保留在冻结输入包；两家文生调用使用完全相同的短梗概和原资产 prompt，
-  合计不超过 800 字符。API 未接收完整正文这一事实必须记录，不能宣称正文已送入模型。
-- 两家图生均使用同一冻结参考图，列入 `reference_only` 辅助组；不要为了补文字上下文
-  悄悄改图、另画参考图、改变原任务的输入模式或仅给一家添加贴图提示词。
-- 每家分别运行全部 200 条。按人物/刚体、文生/图生及上下文条件分组；Hunyuan3D Pro
-  仅保留后续接入口，本轮不启用、不消耗第三家额度。
-- 固定具体模型版本，不使用 `latest`；Meshy 本轮使用 standard + remesh，
-  不依赖将于 2026-10-30 退役的 `model_type=lowpoly`。
-- 原始 API mesh 写为 `model.glb`，统一后处理的导入 mesh 写为 `import/model.glb`。
-  两家使用同一固定工具、参数与贴���上限；分别记录原始和后处理 QA、耗时及缺陷。
-  减面未达到预算应如实记录失败，不增加生成次数、不换模型补齐或挑选 best-of。
-- 付费调用前需要用户确认预算并在环境中配置密钥。提交后立刻落盘任务 ID；
-  已知远端任务只续查结果，提交结果不确定时停下核对，不自动重发付费任务。
-- 本轮按游戏级共享资产目录落盘，在任务目录下加厂商一级：
-  `test_data/outputs/<game_id>/assets/3d_object/<task_id>/<provider>/`，
-  `<provider>` 为 `meshy` / `tripo`，不使用 `asset_comparison` 输出目录。
-  原始 `model.glb`、`import/model.glb`、`meta.json`、服务端预览均放在厂商目录内；
-  QA 写入 `test_data/outputs/<game_id>/eval/3d_object/<task_id>/<provider>/`。
-  manifest/阶段报告按游戏、批次、厂商放在
-  `test_data/outputs/<game_id>/pipeline/<game_id>_pipeline/<batch_id>/<provider>/`，
-  冻结输入、计费回执与跨游戏预览保存在 `test_data/outputs/_asset_batches/<batch_id>/`。
-  不覆盖不同批次已有的厂商资产，也不覆盖白模工程。
-  结构检查通过不等于视觉 QA 通过；C、Q1/Q2/Q3 的正式评分缺少证据时保持 UNKNOWN。
-  第三阶段的资产来源需要另行固定，不能按逐条最高评分混选两家产物。

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/cloud_journal.py DELETED Viewed

@@ -1,178 +0,0 @@
-"""Durable submit receipts for the comparison runner; no automatic POST retry.
-Uses the framework's HTTP plumbing. A lost create response is ambiguous: retain
-the credit reservation and require reconciliation instead of buying a new task.
-The runner holds one batch lock while using this client.
-"""
-from __future__ import annotations
-import json
-import math
-import os
-from pathlib import Path
-from typing import Any
-from models.common import cloud_api
-from pipeline.common.record_paths import portable_value, portable_text
-def read_json(path: Path, default=None):
-    return json.loads(path.read_text(encoding="utf-8")) if path.is_file() else default
-def write_json(path: Path, value: Any, *, portable: bool = True) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary = path.with_name(path.name + ".tmp")
-    with temporary.open("w", encoding="utf-8", newline="\n") as stream:
-        json.dump(portable_value(value, path.parent) if portable else value,
-                  stream, ensure_ascii=False, indent=2)
-        stream.write("\n")
-        stream.flush()
-        os.fsync(stream.fileno())
-    os.replace(temporary, path)
-def safe_error(exc: Exception) -> str:
-    value = str(exc)
-    for name in ("MESHY_API_KEY", "TRIPO_API_KEY"):
-        secret = os.environ.get(name)
-        if secret:
-            value = value.replace(secret, "[REDACTED]")
-    return portable_text(value)[:1600]
-class BudgetExceeded(RuntimeError):
-    pass
-class AmbiguousSubmission(RuntimeError):
-    pass
-def reserved_credits(directory: Path) -> int:
-    return sum(
-        int(item["reserved_credits"])
-        for path in directory.glob("*.json")
-        for item in read_json(path, {}).get("submissions", {}).values()
-        if item["status"] != "rejected"
-    )
-class JournalClient:
-    """Replay successful create receipts and query the same remote task on resume."""
-    def __init__(self, base: str, key: str, journal: Path, cap: int,
-                 prices: dict[str, int], provider: str, transport=None, resume_refused=False):
-        self.journal = journal
-        self.cap = cap
-        self.prices = prices
-        self.provider = provider
-        self.resume_refused = resume_refused
-        # GET is safe to retry. A billed POST gets exactly one transport attempt.
-        self.reader = transport or cloud_api.CloudAPIClient(base, key, max_retries=3)
-        self.writer = transport or cloud_api.CloudAPIClient(base, key, max_retries=0)
-        self.public = None
-    def _cost(self, endpoint: str, body: dict) -> int:
-        if endpoint == "/files":
-            return 0
-        if self.provider == "meshy":
-            if endpoint == "/openapi/v2/text-to-3d":
-                return self.prices["text_refine" if body.get("mode") == "refine" else "text_preview"]
-            if endpoint == "/openapi/v1/image-to-3d":
-                return self.prices["image"]
-        elif endpoint in ("/generation/text-to-model", "/generation/image-to-model"):
-            return self.prices["text" if "text-to" in endpoint else "image"]
-        raise ValueError(f"Unpriced POST endpoint: {endpoint}")
-    def request(self, method: str, endpoint: str, **kwargs):
-        state = read_json(self.journal, {"submissions": {}, "results": {}})
-        if method != "POST":
-            result = self.reader.request(method, endpoint, **kwargs)
-            if method == "GET" and isinstance(result, dict):
-                state["results"][endpoint] = result
-                payload = result.get("data", result)
-                if isinstance(payload, dict):
-                    remote_id = payload.get("task_id") or payload.get("id")
-                    reported = payload.get("credits_consumed", payload.get("credits"))
-                    for record in state["submissions"].values():
-                        if remote_id and record.get("remote_id") == remote_id and isinstance(reported, (int, float)):
-                            record["reported_credits"] = reported
-                            record["reserved_credits"] = max(record["reserved_credits"], math.ceil(reported))
-                write_json(self.journal, state)
-            return result
-        # Hash binary inputs; never persist image bytes or credentials in receipts.
-        descriptor = {"endpoint": endpoint, "body": kwargs.get("json_body"),
-                      "files": {name: cloud_api.bytes_hash(value[1])
-                                for name, value in (kwargs.get("files") or {}).items()}}
-        fingerprint = cloud_api.request_hash(descriptor)
-        previous = state["submissions"].get(fingerprint)
-        if previous:
-            if previous["status"] == "created":
-                return previous["response"]
-            if previous["status"] == "rejected" and not (self.resume_refused and previous.get("resource_refusal")):
-                raise cloud_api.CloudAPIRequestError(previous["error"])
-            if previous["status"] != "rejected":
-                raise AmbiguousSubmission(
-                    f"Unconfirmed submission {fingerprint} in {self.journal}. "
-                    "Reconcile its remote task ID; no automatic resubmission.")
-        cost = self._cost(endpoint, kwargs.get("json_body") or {})
-        used = reserved_credits(self.journal.parent)
-        if used + cost > self.cap:
-            raise BudgetExceeded(f"{self.provider}: {used} reserved + {cost} exceeds cap {self.cap}")
-        record = {"endpoint": endpoint, "reserved_credits": cost, "status": "submitting"}
-        if previous:
-            record["rejection_history"] = [*previous.get("rejection_history", []),
-                {k: v for k, v in previous.items() if k != "rejection_history"}]
-        state["submissions"][fingerprint] = record
-        write_json(self.journal, state)  # commit before the request can incur a charge
-        try:
-            response = self.writer.request(method, endpoint, **kwargs)
-        except cloud_api.CloudAPIError as exc:
-            # These are explicit refusals. 5xx/timeouts may have created a task.
-            if exc.status in (400, 401, 402, 403, 404, 405, 413, 415, 422, 429):
-                record.update(status="rejected", error=safe_error(exc), resource_refusal=isinstance(
-                    exc, (cloud_api.CloudAPIAuthError, cloud_api.CloudAPIQuotaError, cloud_api.CloudAPIRateLimitError)))
-            else:
-                record.update(status="uncertain", error=safe_error(exc))
-            write_json(self.journal, state)
-            if record["status"] == "uncertain":
-                raise AmbiguousSubmission(f"Unconfirmed POST {fingerprint}; {safe_error(exc)}") from exc
-            raise
-        rejected = isinstance(response, dict) and response.get("code") not in (None, 0)
-        envelope = response.get("data", response) if isinstance(response, dict) else {}
-        remote_id = (envelope.get("task_id") or envelope.get("id") or envelope.get("result")
-                     or envelope.get("file_token") or envelope.get("token")) if isinstance(envelope, dict) else None
-        if rejected:
-            rejection = cloud_api.classify_http_error(400, response)
-            record.update(status="rejected", error=safe_error(rejection), resource_refusal=isinstance(
-                rejection, (cloud_api.CloudAPIAuthError, cloud_api.CloudAPIQuotaError)))
-        elif not remote_id:
-            record.update(status="uncertain", error="Response contained no remote task/file ID")
-        else:
-            record.update(status="created", remote_id=remote_id, response=response)
-        write_json(self.journal, state)
-        if rejected:
-            raise rejection
-        if record["status"] == "uncertain":
-            raise AmbiguousSubmission(f"Unconfirmed POST {fingerprint}: missing task/file ID")
-        return response
-    def download(self, url: str, **kwargs) -> bytes:
-        # Signed CDN downloads must not receive the provider's Authorization key.
-        if not url.startswith("https://"):
-            raise ValueError("Artifact download must use HTTPS")
-        if self.public is None:
-            self.public = cloud_api.CloudAPIClient("", "", max_retries=3)
-            self.public.session.headers.pop("Authorization", None)
-        return self.public.download(url, **kwargs)
-    def close(self):
-        self.reader.close()
-        if self.writer is not self.reader:
-            self.writer.close()
-        if self.public is not None:
-            self.public.close()

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/generate_3d_comparison.py DELETED Viewed

@@ -1,603 +0,0 @@
-#!/usr/bin/env python3
-"""Prepare, run and resume the frozen Meshy/Tripo 200-object comparison.
-Prepare/status are offline. Run requires explicit spending caps and API keys.
-Native generation outputs remain unmodified. A shared postprocessor produces
-separate import meshes; visual acceptance is a separate review.
-"""
-from __future__ import annotations
-import argparse
-from collections import Counter, defaultdict
-from contextlib import contextmanager
-from datetime import datetime, timezone
-import hashlib
-import io
-import json
-import math
-import os
-from pathlib import Path
-import re
-import shutil
-import struct
-import subprocess
-import sys
-BENCH = Path(__file__).resolve().parents[2]
-FRAMEWORK = BENCH / "GameFactory-3A"
-sys.path.insert(0, str(FRAMEWORK))
-from pipeline.common import paths
-from pipeline.common.record_paths import portable_value, resolve_path, runtime_value
-from models.common import cloud_api
-from models.common.glb_utils import glb_json_chunk, glb_summary
-from cloud_journal import (AmbiguousSubmission, BudgetExceeded, JournalClient,
-                           read_json, reserved_credits, safe_error, write_json)
-DEFAULT_CONFIG = BENCH / "config/asset_3d_comparison.json"
-IDENTIFIER = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_-]{0,160}$")
-RUNTIME_FILES = [Path(__file__), Path(__file__).with_name("cloud_journal.py"),
-                 FRAMEWORK / "pipeline/common/record_paths.py",
-                 FRAMEWORK / "pipeline/common/paths.py",
-                 BENCH / "prompts/stage2_assets.md",
-                 FRAMEWORK / "operators/gen_3d_object/operator.py",
-                 FRAMEWORK / "models/gen_3d_object/meshy_model.py",
-                 FRAMEWORK / "models/gen_3d_object/tripo_model.py",
-                 FRAMEWORK / "models/common/cloud_api.py",
-                 FRAMEWORK / "models/common/glb_utils.py",
-                 Path(__file__).with_name("mesh_tools") / "process_mesh.mjs",
-                 Path(__file__).with_name("mesh_tools") / "package-lock.json"]
-MESH_TOOL = Path(__file__).with_name("mesh_tools") / "process_mesh.mjs"
-def now():
-    return datetime.now(timezone.utc).isoformat(timespec="seconds")
-def digest(path: Path):
-    return hashlib.sha256(path.read_bytes()).hexdigest()
-def checked_id(value: str):
-    if not IDENTIFIER.fullmatch(value):
-        raise ValueError(f"Invalid path identifier: {value!r}")
-    return value
-def bench_path(value: str):
-    result = resolve_path(value).resolve()
-    result.relative_to(BENCH.resolve())
-    return result
-def batch_directory(config: dict, batch_id: str):
-    return bench_path(config["output_root"]) / "_asset_batches" / checked_id(batch_id)
-@contextmanager
-def exclusive_batch(directory: Path):
-    """OS lock releases on process exit, including an interrupted run."""
-    directory.mkdir(parents=True, exist_ok=True)
-    with (directory / "batch.lock").open("a+b") as stream:
-        stream.seek(0, 2)
-        if stream.tell() == 0:
-            stream.write(b"0")
-            stream.flush()
-        stream.seek(0)
-        if os.name == "nt":
-            import msvcrt
-            msvcrt.locking(stream.fileno(), msvcrt.LK_NBLCK, 1)
-        else:
-            import fcntl
-            fcntl.flock(stream, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        try:
-            yield
-        finally:
-            stream.seek(0)
-            if os.name == "nt":
-                msvcrt.locking(stream.fileno(), msvcrt.LK_UNLCK, 1)
-            else:
-                fcntl.flock(stream, fcntl.LOCK_UN)
-def game_directory(plan: dict, game: str):
-    return Path(plan["output_root"]) / checked_id(game)
-def pipeline_directory(plan: dict, provider: str, game: str):
-    return (game_directory(plan, game) / "pipeline" / (game + "_pipeline")
-            / checked_id(plan["batch_id"]) / checked_id(provider))
-def generation_index(plan: dict, provider: str, game: str):
-    return (game_directory(plan, game) / ".generation/3d_object" / checked_id(provider)
-            / checked_id(plan["batch_id"]) / "asset_task_index.json")
-def short_context(text: str, limit: int):
-    """Declared deterministic excerpts, not a claim that the model read the brief."""
-    title = re.search(r"^title:\s*(.+)$", text, re.M)
-    lines = [line.strip() for line in text.splitlines() if line.strip()]
-    title_text = title.group(1) if title else next((s.lstrip("# ") for s in lines if s.startswith("#")), "")
-    world = next((line for line in lines if re.match(r"-\s*W01\b", line)), "")
-    loop = next((line for line in lines if any(word in line for word in ("核心循环：", "核心循环:", "核心玩法：", "核心玩法:"))), "")
-    if not loop:
-        loop = next((line for line in lines if re.match(r"-\s*S01\b", line)), "")
-    if not loop:
-        heading = re.search(r"^##[^\n]*(?:核心循环|一句话定位)[^\n]*\n([^#]+)", text, re.M)
-        loop = heading.group(1) if heading else ""
-    pieces = [re.sub(r"\s+", " ", value).strip()[:size]
-              for value, size in ((title_text, 70), (world, 110), (loop, 110)) if value]
-    value = " | ".join(pieces)
-    if not value:
-        raise ValueError("Cannot extract game context; provide a reviewed short context")
-    return value[:limit]
-def frozen_copy(source: Path, destination: Path):
-    if destination.exists() and digest(destination) != digest(source):
-        raise ValueError(f"Frozen input changed; use a new batch ID: {destination}")
-    destination.parent.mkdir(parents=True, exist_ok=True)
-    if not destination.exists():
-        shutil.copyfile(source, destination)
-    return {"path": str(destination.resolve()), "sha256": digest(destination),
-            "source": str(source.resolve())}
-def node_process(arguments: list[str], timeout: int):
-    node = shutil.which("node")
-    if not node:
-        raise ValueError("Node.js is required for the fixed mesh pipeline")
-    environment = os.environ.copy()
-    for key in ("MESHY_API_KEY", "TRIPO_API_KEY"):
-        environment.pop(key, None)
-    if os.name == "nt":
-        # Conda's DLLs can shadow sharp's libvips dependencies in child processes.
-        environment["PATH"] = str(Path(node).parent) + os.pathsep + str(Path(os.environ["SystemRoot"]) / "System32")
-    return subprocess.run([node, str(MESH_TOOL), *arguments], capture_output=True,
-                          text=True, encoding="utf-8", timeout=timeout, env=environment)
-def mesh_runtime():
-    result = node_process(["--check"], timeout=60)
-    if result.returncode:
-        raise ValueError("Mesh postprocessor unavailable; run npm ci in scripts/asset/mesh_tools. " + result.stderr[-500:])
-    return json.loads(result.stdout)
-def subject_group(task: dict):
-    role = task.get("role", "")
-    return "character" if task.get("rig", "none") != "none" or role in (
-        "character", "player", "event_figure", "npc", "creature", "unit_special") or role.startswith("enemy") else "rigid"
-def prepare(config: dict, batch_id: str):
-    if config["input_policy"] != "shared_short_context_and_reference_only" or not config["input_policy_confirmed"]:
-        raise ValueError("The input protocol must be confirmed before preparing this comparison")
-    directory = batch_directory(config, batch_id)
-    plan_file = directory / "plan.json"
-    if plan_file.exists():
-        raise ValueError(f"Batch is already frozen: {plan_file}. Use status/run or a new batch ID.")
-    source = bench_path(config["tasks"])
-    tasks = [json.loads(line) for line in source.read_text(encoding="utf-8-sig").splitlines() if line.strip()]
-    if len(tasks) != config["expected_tasks"]:
-        raise ValueError(f"Expected {config['expected_tasks']} tasks; got {len(tasks)}")
-    for task in tasks:
-        for provider in config["providers"]:
-            output = (bench_path(config["output_root"]) / checked_id(task["game_id"])
-                      / "assets/3d_object" / checked_id(task["task_id"]) / checked_id(provider))
-            if output.is_dir() and any(p.name != ".gitkeep" for p in output.iterdir()):
-                raise ValueError(f"Provider directory already contains assets; resume its batch: {output}")
-    seen = set()
-    frozen_tasks = []
-    documents = {}
-    tool_runtime = mesh_runtime()
-    for task in tasks:
-        game = checked_id(task["game_id"])
-        task_id = checked_id(task["task_id"])
-        identity = (game, task_id)
-        if identity in seen:
-            raise ValueError(f"Duplicate task: {identity}")
-        seen.add(identity)
-        case = BENCH / "test_data/test_samples" / game
-        if game not in documents:
-            requirement = case / "general_requirement.txt"
-            full_text = requirement.read_text(encoding="utf-8")
-            doc_root = directory / "inputs" / game
-            documents[game] = {
-                "general_requirement": frozen_copy(requirement, doc_root / "general_requirement.txt"),
-                "object_requirement": frozen_copy(case / "3D_object/requirement.txt", doc_root / "object_requirement.txt"),
-                "context_excerpt": short_context(full_text, config["context_excerpt_max_chars"]),
-                "context_method": "deterministic title/world/core-loop excerpts; full brief retained locally",
-            }
-        mode = task["input_mode"]
-        prompt = None
-        reference = None
-        if mode == "text_to_3d":
-            # Never shorten the asset prompt. Both providers receive this exact string.
-            prompt = f"Game context (excerpt): {documents[game]['context_excerpt']}\nAsset: {task['prompt']}"
-            if len(prompt) > config["shared_prompt_max_chars"]:
-                raise ValueError(f"Shared prompt exceeds limit: {task_id} ({len(prompt)} chars)")
-        elif mode == "image_to_3d":
-            source_image = bench_path(task["image_path"])
-            reference = frozen_copy(source_image, directory / "references" / (digest(source_image) + source_image.suffix.lower()))
-        else:
-            raise ValueError(f"Unsupported input mode: {mode}")
-        if not 500 <= task["decimation_target"] <= 8000:
-            raise ValueError(f"Unexpected triangle target: {task_id}")
-        frozen_tasks.append({"task": task, "shared_prompt": prompt, "reference": reference,
-                             "subject_group": subject_group(task),
-                             "context_condition": "shared_short_context" if prompt else "reference_only"})
-    output_root = bench_path(config["output_root"])
-    plan = {"schema_version": "asset_3d_comparison_plan_v1", "batch_id": batch_id,
-            "created_at": now(), "scope": "3d_object_only_not_complete_stage2",
-            "config": config, "output_root": str(output_root), "directory": str(directory),
-            "source": frozen_copy(source, directory / "inputs/source_tasks.jsonl"),
-            "method_reference": frozen_copy(bench_path(config["method_reference"]), directory / "inputs/method_selection.md"),
-            "documents": documents, "tasks": frozen_tasks,
-            "runtime_sources": {str(p.resolve()): digest(p) for p in RUNTIME_FILES},
-            "estimated_credits": {}, "recommended_credit_caps": {},
-            "qa_policy": "basic structural checks + pending visual review; no automatic acceptance",
-            "texture_policy": "preserve native output; same deterministic downsize for both import meshes",
-            "postprocess": config["postprocess"], "mesh_runtime": tool_runtime,
-            "deferred_providers": {"hunyuan3d_pro": {"status": "not_enabled", "adapter_contract":
-                "infer_and_save(image, output_path, seed, decimation_target, texture_size, *, prompt); requires pinned cloud version and input capability check"}}}
-    for provider, settings in config["providers"].items():
-        prices = settings["credits"]
-        estimate = sum((prices["text_preview"] + prices["text_refine"] if provider == "meshy" else prices["text"])
-                       if item["shared_prompt"] else prices["image"] for item in frozen_tasks)
-        plan["estimated_credits"][provider] = estimate
-        plan["recommended_credit_caps"][provider] = (estimate * 11 + 9) // 10
-    plan["plan_sha256"] = cloud_api.request_hash(portable_value(plan))
-    write_json(plan_file, plan)
-    write_json(directory / "asset_task_index.json", {"plan_sha256": plan["plan_sha256"],
-        "task_count": len(frozen_tasks), "tasks": frozen_tasks})
-    for provider in config["providers"]:
-        for game in documents:
-            write_json(generation_index(plan, provider, game), {
-                "plan_sha256": plan["plan_sha256"], "game_id": game, "provider": provider,
-                "scope": plan["scope"], "tasks": [item for item in frozen_tasks if item["task"]["game_id"] == game]})
-    refresh_reports(plan)
-    return plan
-def load_plan(config: dict, batch_id: str):
-    plan = read_json(batch_directory(config, batch_id) / "plan.json")
-    if not plan:
-        raise ValueError("Prepare this batch first")
-    claimed = plan["plan_sha256"]
-    if cloud_api.request_hash({k: v for k, v in plan.items() if k != "plan_sha256"}) != claimed:
-        raise ValueError("Frozen plan was modified")
-    return runtime_value(plan)
-def validate_inputs(plan: dict):
-    if mesh_runtime() != plan["mesh_runtime"]:
-        raise ValueError("Mesh runtime differs from the frozen version")
-    for filename, expected in plan["runtime_sources"].items():
-        if digest(Path(filename)) != expected:
-            raise ValueError(f"Runtime changed after freeze: {filename}; prepare a new batch")
-    files = [plan["source"], plan["method_reference"]]
-    files.extend(doc[field] for doc in plan["documents"].values()
-                 for field in ("general_requirement", "object_requirement"))
-    files.extend(item["reference"] for item in plan["tasks"] if item["reference"])
-    for entry in files:
-        if digest(Path(entry["path"])) != entry["sha256"]:
-            raise ValueError(f"Frozen input changed: {entry['path']}")
-def basic_qa(filename: Path, task: dict):
-    data = filename.read_bytes()
-    summary = glb_summary(data)
-    checks = {"parseable_glb": "error" not in summary}
-    if checks["parseable_glb"]:
-        doc = glb_json_chunk(data)
-        checks["glb_v2_exact_length"] = struct.unpack_from("<II", data, 4) == (2, len(data))
-        checks["positive_triangle_count"] = bool(summary["triangles"])
-        checks["triangle_budget"] = 0 < summary["triangles"] <= task["decimation_target"]
-        checks["materials_present"] = summary["materials"] > 0
-        checks["textures_present"] = summary["textures"] > 0 and summary["images"] > 0
-        primitives = [p for m in doc.get("meshes", []) for p in m.get("primitives", [])]
-        checks["uv_present"] = bool(primitives) and all("TEXCOORD_0" in p.get("attributes", {}) for p in primitives)
-        checks["self_contained"] = all("uri" not in b or b["uri"].startswith("data:") for b in doc.get("buffers", [])) and all(
-            "bufferView" in image or str(image.get("uri", "")).startswith("data:") for image in doc.get("images", []))
-    return {"status": "PASS" if all(checks.values()) else "FAIL", "checks": checks,
-            "summary": summary, "triangle_target": task["decimation_target"],
-            "requested_texture_size": task.get("texture_size"),
-            "texture_budget_verified": False, "visual_status": "PENDING",
-            "limitations": ["No visual, orientation, scale, rigging or engine acceptance yet",
-                            "Native texture resolution retained; task texture_size is not enforced",
-                            "Basic checks do not validate every accessor, topology defect or PBR channel"]}
-def process_import_mesh(source: Path, task: dict):
-    destination = source.parent / "import/model.glb"
-    result = node_process([str(source), str(destination), str(task["decimation_target"]),
-                           str(task["texture_size"])], timeout=300)
-    if result.returncode:
-        raise RuntimeError("Postprocessing failed: " + result.stderr[-1200:])
-    report = json.loads(result.stdout)
-    return destination, report
-def task_directories(plan: dict, provider: str, task: dict):
-    root = game_directory(plan, task["game_id"])
-    task_id, provider = checked_id(task["task_id"]), checked_id(provider)
-    output = root / "assets/3d_object" / task_id / provider
-    evaluation = root / "eval/3d_object" / task_id / provider
-    return output, evaluation
-def refresh_reports(plan: dict):
-    summary = {"batch_id": plan["batch_id"], "plan_sha256": plan["plan_sha256"],
-               "updated_at": now(), "expected_assets": len(plan["tasks"]) * len(plan["config"]["providers"]),
-               "estimated_credits": plan["estimated_credits"], "providers": {}}
-    for provider in plan["config"]["providers"]:
-        by_game = defaultdict(list)
-        for item in plan["tasks"]:
-            task = item["task"]
-            output, evaluation = task_directories(plan, provider, task)
-            meta = read_json(output / "meta.json", {})
-            by_game[task["game_id"]].append({"task_id": task["task_id"], "asset_name": task["asset_name"],
-                "task_kind": "3d_object", "status": meta.get("status", "prepared"),
-                "artifact": str(output / "import/model.glb"), "native_artifact": str(output / "model.glb"),
-                "meta": str(output / "meta.json"), "native_structural_qa": meta.get("native_structural_qa"),
-                "import_structural_qa": meta.get("import_structural_qa"),
-                "native_delivered": meta.get("native_delivered", False),
-                "import_delivered": meta.get("import_delivered", False),
-                "qa": str(evaluation / "qa.json"), "visual_status": "PENDING",
-                "context_condition": item["context_condition"], "subject_group": item["subject_group"],
-                "input_mode": task["input_mode"], "error": meta.get("error")})
-        all_entries = [entry for entries in by_game.values() for entry in entries]
-        summary["providers"][provider] = {"task_count": len(all_entries),
-            "status_counts": dict(Counter(entry["status"] for entry in all_entries)),
-            "reserved_credits": reserved_credits(Path(plan["directory"]) / "submissions" / provider),
-            "visual_accepted": 0, "method_group": plan["config"]["method_group"],
-            "benchmark_metrics": {name: {"status": "UNKNOWN", "value": None}
-                                  for name in ("C", "Q1", "Q2", "Q3")},
-            "subgroups": {key: dict(Counter(e[key] for e in all_entries))
-                          for key in ("subject_group", "input_mode", "context_condition")},
-            "game_macro_delivery": sum(sum(e["status"] == "delivered" for e in entries) / len(entries)
-                                       for entries in by_game.values()) / len(by_game),
-            "game_macro_native_delivery": sum(sum(e["native_delivered"] for e in entries) / len(entries)
-                                               for entries in by_game.values()) / len(by_game),
-            "native_structural_pass": sum(e["native_structural_qa"] == "PASS" for e in all_entries),
-            "import_structural_pass": sum(e["import_structural_qa"] == "PASS" for e in all_entries),
-            "delivery_metric_status": "NOT_RUN" if all(e["status"] == "prepared" for e in all_entries) else "PARTIAL"}
-        for game, entries in by_game.items():
-            pipeline = pipeline_directory(plan, provider, game)
-            manifest = {"game_id": game, "provider": provider, "batch_id": plan["batch_id"],
-                "plan_sha256": plan["plan_sha256"], "scope": plan["scope"], "assets": entries,
-                "full_context": plan["documents"][game], "status": "pending_visual_review"}
-            write_json(pipeline / "asset_manifest.json", manifest)
-            write_json(pipeline / "asset_generation_report.json", {
-                "task_count": len(entries), "status_counts": dict(Counter(e["status"] for e in entries)),
-                "failures": [e for e in entries if e["error"]], "visual_accepted": 0})
-            paths.write_task_meta(pipeline, {"game_id": game, "task_id": game + "_pipeline",
-                "task_kind": "pipeline", "run_id": plan["batch_id"], "status": "comparison_only",
-                "provider": provider, "scope": plan["scope"]})
-    write_json(Path(plan["directory"]) / "asset_generation_report.json", summary)
-    return summary
-def make_model(plan: dict, provider: str, task: dict, cap: int):
-    from models.gen_3d_object.meshy_model import MeshyModel
-    from models.gen_3d_object.tripo_model import TripoModel
-    settings = plan["config"]["providers"][provider]
-    cls = MeshyModel if provider == "meshy" else TripoModel
-    control = Path(plan["directory"])
-    model = cls(model_path=settings["model"], device="cpu", api_base=settings["api_base"],
-                cache_dir=str(control / "cache" / task["game_id"] / task["task_id"]),
-                timeout=1800, poll_interval=5, **settings["options"])
-    key = cloud_api.require_api_key(None, provider.upper() + "_API_KEY", "See the comparison README")
-    journal = control / "submissions" / provider / (task["game_id"] + "__" + task["task_id"] + ".json")
-    model._client = JournalClient(settings["api_base"], key, journal, cap, settings["credits"], provider,
-                                  resume_refused=True)
-    return model
-def download_preview(model, output: Path):
-    from PIL import Image
-    url = model.last_call_info.get("preview_url")
-    if not url:
-        return {"status": "unavailable"}
-    try:
-        data = model.client.download(url)
-        with Image.open(io.BytesIO(data)) as preview:
-            preview.verify()
-            extension = {"PNG": ".png", "JPEG": ".jpg", "WEBP": ".webp"}.get(preview.format)
-        if not extension:
-            return {"status": "unsupported_image_format"}
-        path = output / ("preview" + extension)
-        path.write_bytes(data)
-        return {"status": "downloaded", "path": str(path), "visual_review": "PENDING"}
-    except Exception as exc:
-        return {"status": "failed", "error": safe_error(exc)}
-def run(plan: dict, args):
-    from operators.gen_3d_object.operator import Gen3DObjectOperator
-    class SharedStoreOperator(Gen3DObjectOperator):
-        def _resolve_out_path(self, inp, task_id):
-            output, _ = task_directories(plan, provider, inp)
-            output.mkdir(parents=True, exist_ok=True)
-            return inp["game_id"], output, output / "model.glb"
-    if not args.allow_paid:
-        raise ValueError("Paid generation requires --allow-paid and explicit provider credit caps")
-    validate_inputs(plan)
-    selected = list(dict.fromkeys(args.provider or list(plan["config"]["providers"])))
-    caps = {p: getattr(args, p + "_credit_cap") for p in selected}
-    for provider in selected:
-        if not caps[provider] or caps[provider] < reserved_credits(Path(plan["directory"]) / "submissions" / provider):
-            raise ValueError(f"Supply a positive --{provider}-credit-cap covering existing reservations")
-        cloud_api.require_api_key(None, provider.upper() + "_API_KEY", "See scripts/asset/README_3d_comparison.md")
-    selection = set(args.task_id or [])
-    known = {item["task"]["task_id"] for item in plan["tasks"]}
-    if selection - known:
-        raise ValueError(f"Unknown task IDs: {sorted(selection - known)}")
-    jobs = [item for item in plan["tasks"] if not selection or item["task"]["task_id"] in selection]
-    if args.limit is not None:
-        if args.limit < 1:
-            raise ValueError("--limit must be positive")
-        jobs = jobs[:args.limit]
-    write_json(Path(plan["directory"]) / "spending_authorization.json", {
-        "plan_sha256": plan["plan_sha256"], "credit_caps": caps, "recorded_at": now(),
-        "selected_task_ids": [item["task"]["task_id"] for item in jobs],
-        "note": "Caps reserve estimated credits; account-side limits remain authoritative"})
-    interrupted = False
-    for provider in selected:
-        failures = 0
-        for item in jobs:
-            task = item["task"]
-            output, evaluation = task_directories(plan, provider, task)
-            previous = read_json(output / "meta.json", {})
-            if previous and previous.get("plan_sha256") != plan["plan_sha256"]:
-                raise ValueError(f"Another batch owns this provider directory; do not overwrite: {output}")
-            if not previous and output.is_dir() and any(p.name != ".gitkeep" for p in output.iterdir()):
-                raise ValueError(f"Untracked provider artifacts must not be overwritten: {output}")
-            if previous.get("status") == "delivered" and (output / "model.glb").is_file():
-                imported = output / "import/model.glb"
-                if previous.get("artifact_sha256") == digest(output / "model.glb") and imported.is_file() and previous.get("import_sha256") == digest(imported):
-                    continue
-            if previous.get("status") == "failed":
-                continue  # one generation attempt, no cherry-picking on rerun
-            output.mkdir(parents=True, exist_ok=True)
-            meta = {"game_id": task["game_id"], "task_id": task["task_id"], "asset_name": task["asset_name"],
-                "task_kind": "3d_object", "run_id": plan["batch_id"], "provider": provider,
-                "plan_sha256": plan["plan_sha256"], "context_condition": item["context_condition"],
-                "full_context": plan["documents"][task["game_id"]], "source_task": task,
-                "shared_prompt": item["shared_prompt"], "reference": item["reference"],
-                "status": "running", "updated_at": now(), "visual_status": "PENDING"}
-            write_json(output / "meta.json", meta)
-            model = None
-            stop = False
-            try:
-                model = make_model(plan, provider, task, caps[provider])
-                # Preserve native output for a fair comparison. No automatic mesh cleanup/import.
-                inp = {**task, "strip_ground_plate": False}
-                inp.pop("asset_id", None)
-                if item["reference"]:
-                    inp["image_path"] = item["reference"]["path"]
-                else:
-                    inp["prompt"] = item["shared_prompt"]
-                result = SharedStoreOperator(model, run_id=plan["batch_id"]).run(inp)
-                raw_qa = basic_qa(Path(result["glb_path"]), task)
-                meta.update(native_delivered=raw_qa["checks"]["parseable_glb"], result=result,
-                            native_structural_qa=raw_qa["status"], model_call=model.last_call_info,
-                            artifact_sha256=digest(output / "model.glb"))
-                write_json(evaluation / "qa.json", {"native": raw_qa, "import": {"status": "PENDING"},
-                                                     "visual_status": "PENDING"})
-                imported, postprocess = process_import_mesh(Path(result["glb_path"]), task)
-                import_qa = basic_qa(imported, task)
-                import_qa["texture_budget_verified"] = all(max(t["after"]) <= task["texture_size"] for t in postprocess["textures"])
-                import_qa["checks"]["texture_budget"] = import_qa["texture_budget_verified"]
-                import_qa["status"] = "PASS" if all(import_qa["checks"].values()) else "FAIL"
-                write_json(evaluation / "qa.json", {"native": raw_qa, "import": import_qa,
-                    "postprocess": postprocess, "visual_status": "PENDING"})
-                meta.update(status="delivered", result=result, model_call=model.last_call_info,
-                            import_delivered=import_qa["checks"]["parseable_glb"],
-                            artifact_sha256=digest(output / "model.glb"), import_sha256=digest(imported),
-                            native_structural_qa=raw_qa["status"], import_structural_qa=import_qa["status"],
-                            postprocess=postprocess,
-                            preview=download_preview(model, output))
-                failures = 0
-            except Exception as exc:
-                status = "failed"
-                if isinstance(exc, cloud_api.CloudTaskTimeout):
-                    status = "remote_pending"
-                elif isinstance(exc, AmbiguousSubmission):
-                    status, stop = "submission_uncertain", True
-                elif isinstance(exc, (BudgetExceeded, cloud_api.CloudAPIAuthError, cloud_api.CloudAPIQuotaError)):
-                    status, stop = "blocked", True
-                elif isinstance(exc, cloud_api.CloudAPIServerError):
-                    status = "resume_required"  # known receipts survive poll/download failures
-                elif not isinstance(exc, (cloud_api.CloudTaskFailed, cloud_api.CloudAPIRequestError, ValueError)):
-                    status = "resume_required"  # retain a downloaded asset after local/tool failures
-                meta.update(status=status, error=safe_error(exc), error_type=type(exc).__name__)
-                failures += 1
-                stop = stop or failures >= 3
-            finally:
-                if model is not None:
-                    model.unload()
-                meta["updated_at"] = now()
-                journal = read_json(Path(plan["directory"]) / "submissions" / provider /
-                    (task["game_id"] + "__" + task["task_id"] + ".json"), {})
-                meta["generation_cost"] = [{"endpoint": record["endpoint"], "remote_id": record.get("remote_id"),
-                    "reservation": record["reserved_credits"], "reported_credits": record.get("reported_credits"),
-                    "status": record["status"]} for record in journal.get("submissions", {}).values()]
-                write_json(output / "meta.json", meta)
-                refresh_reports(plan)
-            print(json.dumps({"provider": provider, "task_id": task["task_id"], "status": meta["status"],
-                              "error": meta.get("error")}, ensure_ascii=False), flush=True)
-            if stop:
-                interrupted = True
-                break
-        if interrupted:
-            break
-    incomplete = any(read_json(task_directories(plan, p, item["task"])[0] / "meta.json", {}).get("status") != "delivered"
-                     for p in selected for item in jobs)
-    return 2 if interrupted or incomplete else 0
-def recover(plan: dict, args):
-    """Attach an inspected remote ID to an ambiguous receipt; never submit here."""
-    checked_id(args.remote_task_id)
-    matches = [item["task"] for item in plan["tasks"] if item["task"]["task_id"] == args.task_id]
-    if len(matches) != 1:
-        raise ValueError("Recover requires exactly one known task")
-    task = matches[0]
-    journal = Path(plan["directory"]) / "submissions" / args.provider / (task["game_id"] + "__" + task["task_id"] + ".json")
-    state = read_json(journal, {})
-    record = state.get("submissions", {}).get(args.request_hash)
-    if not record or record["status"] not in ("submitting", "uncertain") or record["endpoint"] == "/files":
-        raise ValueError("Receipt is not an ambiguous generation submission")
-    record.update(status="created", remote_id=args.remote_task_id, reconciled_at=now(),
-                  response={"result": args.remote_task_id} if args.provider == "meshy" else
-                  {"code": 0, "data": {"task_id": args.remote_task_id}})
-    write_json(journal, state)
-    return {"recovered_task_id": args.remote_task_id, "network_requests": 0}
-def main(argv=None):
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
-    sub = parser.add_subparsers(dest="command", required=True)
-    for name in ("prepare", "status", "run", "recover"):
-        command = sub.add_parser(name)
-        command.add_argument("--batch-id", required=True)
-        if name == "run":
-            command.add_argument("--allow-paid", action="store_true")
-            command.add_argument("--meshy-credit-cap", type=int)
-            command.add_argument("--tripo-credit-cap", type=int)
-            command.add_argument("--provider", action="append", choices=("meshy", "tripo"))
-            command.add_argument("--task-id", action="append")
-            command.add_argument("--limit", type=int, help="Limit tasks per selected provider; full inventory is retained")
-        elif name == "recover":
-            command.add_argument("--provider", required=True, choices=("meshy", "tripo"))
-            command.add_argument("--task-id", required=True)
-            command.add_argument("--request-hash", required=True)
-            command.add_argument("--remote-task-id", required=True)
-    args = parser.parse_args(argv)
-    config = read_json(args.config)
-    with exclusive_batch(batch_directory(config, args.batch_id)):
-        if args.command == "prepare":
-            plan = prepare(config, args.batch_id)
-            print(json.dumps(portable_value({"plan": str(Path(plan["directory"]) / "plan.json"),
-                "tasks_per_provider": len(plan["tasks"]), "estimated_credits": plan["estimated_credits"],
-                "recommended_credit_caps": plan["recommended_credit_caps"]}), indent=2))
-        else:
-            plan = load_plan(config, args.batch_id)
-            if args.command == "run":
-                return run(plan, args)
-            value = recover(plan, args) if args.command == "recover" else refresh_reports(plan)
-            print(json.dumps(portable_value(value), indent=2, ensure_ascii=False))
-    return 0
-if __name__ == "__main__":
-    try:
-        raise SystemExit(main())
-    except (ValueError, OSError, cloud_api.CloudAPIError) as exc:
-        print(safe_error(exc), file=sys.stderr)
-        raise SystemExit(2)

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/package-lock.json DELETED Viewed

@@ -1,763 +0,0 @@
-{
-  "name": "bench-asset-comparison-mesh-tools",
-  "version": "1.0.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "bench-asset-comparison-mesh-tools",
-      "version": "1.0.0",
-      "dependencies": {
-        "@gltf-transform/core": "4.2.1",
-        "@gltf-transform/extensions": "4.2.1",
-        "@gltf-transform/functions": "4.2.1",
-        "draco3dgltf": "1.5.7",
-        "meshoptimizer": "0.24.0",
-        "sharp": "0.35.5"
-      }
-    },
-    "node_modules/@emnapi/runtime": {
-      "version": "1.11.3",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.3.tgz",
-      "integrity": "sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==",
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@gltf-transform/core": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/@gltf-transform/core/-/core-4.2.1.tgz",
-      "integrity": "sha512-qKhrQ29KJ9K6sz7xGoGRllqPBlROjPJMQPvCLBOfgMPH3S/Ph5E0e6fD5WmwTY5QPyBsDMRqKd1Vl0ncThTXGw==",
-      "license": "MIT",
-      "dependencies": {
-        "property-graph": "^3.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/donmccurdy"
-      }
-    },
-    "node_modules/@gltf-transform/extensions": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/@gltf-transform/extensions/-/extensions-4.2.1.tgz",
-      "integrity": "sha512-ieHSJU9qvb3ucWDxgHFcff+C7fLtFPa6G0Wtc/ki7GsN6Rh7o9eoyqi7Ggj2LO4i3ynCwLLPb/onbJKw2fBtsA==",
-      "license": "MIT",
-      "dependencies": {
-        "@gltf-transform/core": "^4.2.1",
-        "ktx-parse": "^1.0.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/donmccurdy"
-      }
-    },
-    "node_modules/@gltf-transform/functions": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/@gltf-transform/functions/-/functions-4.2.1.tgz",
-      "integrity": "sha512-hFCI80N6zt7yHlqXbzlYEYQbFwK+2OOZNvacrRtrWiCWKI0k1Ad5+nZFsmuIZZV03aXb5XG6UF7JINT3wETS1Q==",
-      "license": "MIT",
-      "dependencies": {
-        "@gltf-transform/core": "^4.2.1",
-        "@gltf-transform/extensions": "^4.2.1",
-        "ktx-parse": "^1.0.1",
-        "ndarray": "^1.0.19",
-        "ndarray-lanczos": "^0.3.0",
-        "ndarray-pixels": "^5.0.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/donmccurdy"
-      }
-    },
-    "node_modules/@img/colour": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz",
-      "integrity": "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@img/sharp-darwin-arm64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.35.5.tgz",
-      "integrity": "sha512-QRUlFQ0WxvdWyqqG/WtI3iupfD5rBzmCHXSdPsY91sAtVtTo7Q4cb6zOccZ3gqEqkr0f1As1ehLqmEpDsRf+lg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-darwin-arm64": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-darwin-x64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.35.5.tgz",
-      "integrity": "sha512-+BR255RhDlpygUpOc/Jdt1nT6DQ3XG/ERo5wbcdOf5Q320dKtPCKPLR1LJs9VGXRaMa8l1uUa0tkCNOXiAxZUw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-darwin-x64": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-freebsd-wasm32": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-freebsd-wasm32/-/sharp-freebsd-wasm32-0.35.5.tgz",
-      "integrity": "sha512-Y/z91nEZ4uIBX5X3nfTovjU9lHNKFYbL2lpHCLVNmXQK03VIZvXBBt0KxbPGp2SdGSF+2mQU4e+hQaWOt86iAw==",
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "dependencies": {
-        "@img/sharp-wasm32": "0.35.5"
-      },
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-freebsd-wasm32/node_modules/@img/sharp-wasm32": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.5.tgz",
-      "integrity": "sha512-Ptsga1su4tQx+LLF1ECS9U6nz5kmrXKo6XVbtR48Ke3ZRxxgaWBu7IDtEe1quo8hiupwm6WFqxVlXaSf7IINGQ==",
-      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
-      "optional": true,
-      "dependencies": {
-        "@emnapi/runtime": "^1.11.3"
-      },
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-darwin-arm64": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.3.4.tgz",
-      "integrity": "sha512-5R89nBYiRdUlSWJxPhO+GVtaXzXSxKnRu/xqMn3KTA3L9EB9Oy/P+Nn2f2vlhPuUdy/Zusb2DarbyTpGCfEDuw==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-darwin-x64": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.3.4.tgz",
-      "integrity": "sha512-iR2OKH80yi0U+dUplyh3/xdpFvps6YkCwsXenIJxqxR1v9o+xtKTGbS9H7cps+2Vxjc8B1j96p75NmTGjIhtpQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-linux-arm": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.3.4.tgz",
-      "integrity": "sha512-LmRtTsOHuvM2+wlO2Db37dx5MiZhB0FvSunciw48YjdOkZz9KAiRbm8ujeMOA1INqmei5NapFxYEK1D1ZSidmw==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-linux-arm64": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.3.4.tgz",
-      "integrity": "sha512-Y3dgX/6lE2QhQb+Gxy0WZxfg9MEm/JBjamZpS2IklP7xIQoKN4hzAm7KcMVGtaVDt3neE9OKBC7vAfonA/Lr1A==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-linux-ppc64": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.3.4.tgz",
-      "integrity": "sha512-Le6boB8Tai0Nis+gIxIpKx68UDVVIqdR8Tin5Yf1z2LJJQLDJvCDRqRu+jC2qCoD+eIomonmOwB4smBRxfVpYQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-linux-riscv64": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.3.4.tgz",
-      "integrity": "sha512-aHkkIEHPRdQEegJN20MLmGtxYD9R2wQr3Cwpddnu5+YKMt6Uzax7S9h5gpZTo8wyrGuZSlfQ63OevL5mTyOC7Q==",
-      "cpu": [
-        "riscv64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-linux-s390x": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.3.4.tgz",
-      "integrity": "sha512-ra/mB6MikESDUO7Yg+Mi95bFBb9GsObURuhnOv3OqknjGe9sZrG8tCe9q0xSIGrtLgvgw0gKnFWcK4blSgQOuQ==",
-      "cpu": [
-        "s390x"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-linux-x64": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.4.tgz",
-      "integrity": "sha512-GJ//SSXbnwSDes02umB3nDJLFcQzw8a18V8fyhqr6tV515tOEMdImjjxj1AoafMRz56F3PHgftnj1QEKSU1zkw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.3.4.tgz",
-      "integrity": "sha512-hvulFwtjUcagsis6BBxHwGFwWoNZjgYmULGVrZcyfNbjA8hKILbRxGg15/7w5HDyXHXUos/j6baAWqnCyQ2DWA==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-libvips-linuxmusl-x64": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.4.tgz",
-      "integrity": "sha512-6zXKeE/p39I1AmA3cJG35eyBGNqNddLnUXjhwBnsGjFPWqf5VKkDBEqaEkPDoTEtkxwi2vv8Tcr2mDyP4So7Fg==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-linux-arm": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.35.5.tgz",
-      "integrity": "sha512-LEaXK2WdXVK5ykcw0buWyPMsmLLL2vpHLD6yrNSW+JGEL3BZPA4tpKN6iaMc4AxTTAoaX/sU1rOL51lcIz48ZQ==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-linux-arm64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.35.5.tgz",
-      "integrity": "sha512-LYVx5JTsOM2CBzmxreh+nl64/3H6Xb09iSLknqH47z2T2DFFxDeFLP5y4dJwe6H7uGQlHPyEEtIqyo3DYsRwdQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm64": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-linux-ppc64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.35.5.tgz",
-      "integrity": "sha512-QVxAAq8evVRI9ia2vqgwrmWucn5Dfv+JdWzj75pD8omHLPSP7f8p20O8jxzjCcuCEQEOtYOZUmX1hkiZ0kdevA==",
-      "cpu": [
-        "ppc64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-ppc64": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-linux-riscv64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.35.5.tgz",
-      "integrity": "sha512-LtdreXguaavKODPIfzJ4kffx7UNt1omwtK0rch4EBbbSTXPnxWmYSayXdLJw0fJzQ97kHt1gL/yh4tvU+nCyRQ==",
-      "cpu": [
-        "riscv64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-riscv64": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-linux-s390x": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.35.5.tgz",
-      "integrity": "sha512-UZasTOFiYzotTsGOCu42BfUzP6Tu6Do/947iRm1RsLKvlllxwGcn4RN27LibGWceix4Y+Pmw3jsnTcCQIgWjqA==",
-      "cpu": [
-        "s390x"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-s390x": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-linux-x64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.5.tgz",
-      "integrity": "sha512-SxFtLTeJInhAA9Q836kux2vZNeOBQEx658qvbboZScr0wIARym3IcGmW7KpVD5sbVg0Ojy+udFQdayYIZyoNog==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-x64": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-linuxmusl-arm64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.35.5.tgz",
-      "integrity": "sha512-9HbMclmI1zlNkFRs3z9/eBtDjfD0sGlrX1z6b1qwmiFY5ElDLh4BC0LPBdVp7z1DXFiKlIcznf+ZlsuZzLxQqg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-arm64": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-linuxmusl-x64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.5.tgz",
-      "integrity": "sha512-4KOphqB035HrVdqLZfCgMzzERrQkkzOwRhl4OAkRO1YCldbaFjySXMaK534Mo0V+LndnlJk+sbUyLeU0ULyD1A==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-x64": "1.3.4"
-      }
-    },
-    "node_modules/@img/sharp-webcontainers-wasm32": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-webcontainers-wasm32/-/sharp-webcontainers-wasm32-0.35.5.tgz",
-      "integrity": "sha512-hfhF/FmoQyTUkA0bIKFOtw536BQSeBMe6BF6QyWlrPxT754+TFLaZ7sKKTfvvM0yJgKgaYTwnFCIZ/GuDw5SUA==",
-      "cpu": [
-        "wasm32"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "dependencies": {
-        "@img/sharp-wasm32": "0.35.5"
-      },
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-webcontainers-wasm32/node_modules/@img/sharp-wasm32": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.5.tgz",
-      "integrity": "sha512-Ptsga1su4tQx+LLF1ECS9U6nz5kmrXKo6XVbtR48Ke3ZRxxgaWBu7IDtEe1quo8hiupwm6WFqxVlXaSf7IINGQ==",
-      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
-      "optional": true,
-      "dependencies": {
-        "@emnapi/runtime": "^1.11.3"
-      },
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-win32-arm64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.35.5.tgz",
-      "integrity": "sha512-X4t7g+7ZA5DKblCBEXGjUqqemj4vczING/5viFwAL8h4N3qYeyjwdCvRLHi4EdOUI+2Z7UFlp1VM+p/AuEtm6Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-win32-ia32": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.35.5.tgz",
-      "integrity": "sha512-5Zm82LoBc43nhwNybZlG7Y1KO//Zhsn306fQl29ZOuStHLGTo3BWL83q3cznX0poxSAMuYL1On/BHBxkBeKr6A==",
-      "cpu": [
-        "ia32"
-      ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": "^20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@img/sharp-win32-x64": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.35.5.tgz",
-      "integrity": "sha512-x76eH0vEiHlcMQu8Y8IenntaACtddpT6W0wmXtWrnKcnKI7ME5DdgqhAD6SEWOEl1v2zDvkZDhFA9KnURwpfqg==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@types/ndarray": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@types/ndarray/-/ndarray-1.1.0.tgz",
-      "integrity": "sha512-go+C6vHBUuO9jH6Tj6qEZ63JEGoMSxFdmd+6QAtthGD6xumBfIz3RbNDDs2aoRVLf9naH8lk5jnWy2UHHKgYQQ==",
-      "license": "MIT"
-    },
-    "node_modules/cwise-compiler": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/cwise-compiler/-/cwise-compiler-1.1.3.tgz",
-      "integrity": "sha512-WXlK/m+Di8DMMcCjcWr4i+XzcQra9eCdXIJrgh4TUgh0pIS/yJduLxS9JgefsHJ/YVLdgPtXm9r62W92MvanEQ==",
-      "license": "MIT",
-      "dependencies": {
-        "uniq": "^1.0.0"
-      }
-    },
-    "node_modules/detect-libc": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
-      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/draco3dgltf": {
-      "version": "1.5.7",
-      "resolved": "https://registry.npmjs.org/draco3dgltf/-/draco3dgltf-1.5.7.tgz",
-      "integrity": "sha512-LeqcpmoHIyYUi0z70/H3tMkGj8QhqVxq6FJGPjlzR24BNkQ6jyMheMvFKJBI0dzGZrEOUyQEmZ8axM1xRrbRiw==",
-      "license": "Apache-2.0"
-    },
-    "node_modules/iota-array": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/iota-array/-/iota-array-1.0.0.tgz",
-      "integrity": "sha512-pZ2xT+LOHckCatGQ3DcG/a+QuEqvoxqkiL7tvE8nn3uuu+f6i1TtpB5/FtWFbxUuVr5PZCx8KskuGatbJDXOWA==",
-      "license": "MIT"
-    },
-    "node_modules/is-buffer": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
-      "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
-      "license": "MIT"
-    },
-    "node_modules/ktx-parse": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/ktx-parse/-/ktx-parse-1.1.0.tgz",
-      "integrity": "sha512-mKp3y+FaYgR7mXWAbyyzpa/r1zDWeaunH+INJO4fou3hb45XuNSwar+7llrRyvpMWafxSIi99RNFJ05MHedaJQ==",
-      "license": "MIT"
-    },
-    "node_modules/meshoptimizer": {
-      "version": "0.24.0",
-      "resolved": "https://registry.npmjs.org/meshoptimizer/-/meshoptimizer-0.24.0.tgz",
-      "integrity": "sha512-Iq/8cM5cK2B0P0QdKHexr30zEJn5sQxjXKtQJGp6LO7r1VUPwhgxau18pvybVDnEDsKE49GdlJYwqPX9A/P9Sw==",
-      "license": "MIT"
-    },
-    "node_modules/ndarray": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/ndarray/-/ndarray-1.1.1.tgz",
-      "integrity": "sha512-AsE8w/M2MS+0pD3nP5qbRRtJFeJJJaJ+qXZaZr0XjVGXhy6LIj2TERTlkpdK2AI3WufoOP+pwPk3q2ilAJcZ9g==",
-      "license": "MIT",
-      "dependencies": {
-        "iota-array": "^1.0.0",
-        "is-buffer": "^1.0.2"
-      }
-    },
-    "node_modules/ndarray-lanczos": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/ndarray-lanczos/-/ndarray-lanczos-0.3.0.tgz",
-      "integrity": "sha512-5kBmmG3Zvyj77qxIAC4QFLKuYdDIBJwCG+DukT6jQHNa1Ft74/hPH1z5mbQXeHBt8yvGPBGVrr3wEOdJPYYZYg==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/ndarray": "^1.0.11",
-        "ndarray": "^1.0.19"
-      }
-    },
-    "node_modules/ndarray-ops": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/ndarray-ops/-/ndarray-ops-1.2.2.tgz",
-      "integrity": "sha512-BppWAFRjMYF7N/r6Ie51q6D4fs0iiGmeXIACKY66fLpnwIui3Wc3CXiD/30mgLbDjPpSLrsqcp3Z62+IcHZsDw==",
-      "license": "MIT",
-      "dependencies": {
-        "cwise-compiler": "^1.0.0"
-      }
-    },
-    "node_modules/ndarray-pixels": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/ndarray-pixels/-/ndarray-pixels-5.2.0.tgz",
-      "integrity": "sha512-lTh4tFKziAatVTa9crIsidUyn+lqujVOQpzfdBWvdFu2wo9Uo6z261lVX7SgMyP89xGmj3TMTPbbxl9YDnV4SA==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/ndarray": "^1.0.14",
-        "ndarray": "^1.0.19",
-        "ndarray-ops": "^1.2.2",
-        "sharp": "^0.35.0"
-      }
-    },
-    "node_modules/property-graph": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/property-graph/-/property-graph-3.0.0.tgz",
-      "integrity": "sha512-TnzxUsttmGtw+OiU0LDw+0FlMbJ8vV8pOjyDI7+Kdni4Tj0hW5BFh7TatQu7Y68hcvvFmiFOHilKShsA4R82fA==",
-      "license": "MIT"
-    },
-    "node_modules/semver": {
-      "version": "7.8.5",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
-      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/sharp": {
-      "version": "0.35.5",
-      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.5.tgz",
-      "integrity": "sha512-Ywn4OnzGukp7CDMrp08RQ50YKmuwG47brZgIVPTvBaaAfQlRlygrRqSrxdCiL9M+LlzLBiJ68IR1QqvzHyjC7g==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@img/colour": "^1.1.0",
-        "detect-libc": "^2.1.2",
-        "semver": "^7.8.5"
-      },
-      "engines": {
-        "node": ">=20.9.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-darwin-arm64": "0.35.5",
-        "@img/sharp-darwin-x64": "0.35.5",
-        "@img/sharp-freebsd-wasm32": "0.35.5",
-        "@img/sharp-libvips-darwin-arm64": "1.3.4",
-        "@img/sharp-libvips-darwin-x64": "1.3.4",
-        "@img/sharp-libvips-linux-arm": "1.3.4",
-        "@img/sharp-libvips-linux-arm64": "1.3.4",
-        "@img/sharp-libvips-linux-ppc64": "1.3.4",
-        "@img/sharp-libvips-linux-riscv64": "1.3.4",
-        "@img/sharp-libvips-linux-s390x": "1.3.4",
-        "@img/sharp-libvips-linux-x64": "1.3.4",
-        "@img/sharp-libvips-linuxmusl-arm64": "1.3.4",
-        "@img/sharp-libvips-linuxmusl-x64": "1.3.4",
-        "@img/sharp-linux-arm": "0.35.5",
-        "@img/sharp-linux-arm64": "0.35.5",
-        "@img/sharp-linux-ppc64": "0.35.5",
-        "@img/sharp-linux-riscv64": "0.35.5",
-        "@img/sharp-linux-s390x": "0.35.5",
-        "@img/sharp-linux-x64": "0.35.5",
-        "@img/sharp-linuxmusl-arm64": "0.35.5",
-        "@img/sharp-linuxmusl-x64": "0.35.5",
-        "@img/sharp-webcontainers-wasm32": "0.35.5",
-        "@img/sharp-win32-arm64": "0.35.5",
-        "@img/sharp-win32-ia32": "0.35.5",
-        "@img/sharp-win32-x64": "0.35.5"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/tslib": {
-      "version": "2.8.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
-      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-      "license": "0BSD",
-      "optional": true
-    },
-    "node_modules/uniq": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/uniq/-/uniq-1.0.1.tgz",
-      "integrity": "sha512-Gw+zz50YNKPDKXs+9d+aKAjVwpjNwqzvNpLigIruT4HA9lMZNdMqs9x07kKHB/L9WRzqp4+DlTU5s4wG2esdoA==",
-      "license": "MIT"
-    }
-  }
-}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/process_mesh.mjs DELETED Viewed

@@ -1,77 +0,0 @@
-// One fixed pipeline for both services; keep the original GLB separately.
-import {readFileSync, mkdirSync} from 'node:fs';
-import {dirname} from 'node:path';
-import {performance} from 'node:perf_hooks';
-import {NodeIO, Logger} from '@gltf-transform/core';
-import {ALL_EXTENSIONS} from '@gltf-transform/extensions';
-import {simplify, weld} from '@gltf-transform/functions';
-import {MeshoptDecoder, MeshoptSimplifier} from 'meshoptimizer';
-import draco from 'draco3dgltf';
-import sharp from 'sharp';
-const settings = JSON.parse(readFileSync(new URL('./package.json', import.meta.url)));
-await Promise.all([MeshoptDecoder.ready, MeshoptSimplifier.ready]);
-const runtime = {node: process.versions.node, dependencies: settings.dependencies};
-if (process.argv[2] === '--check') {
-  console.log(JSON.stringify({status: 'ready', ...runtime}));
-} else {
-  const [source, destination, triangleArg, textureArg] = process.argv.slice(2);
-  const triangleTarget = Number(triangleArg), textureTarget = Number(textureArg);
-  if (!source || !destination || !Number.isInteger(triangleTarget) || triangleTarget <= 0
-      || !Number.isInteger(textureTarget) || textureTarget <= 0) {
-    throw new Error('Expected: source.glb destination.glb triangle_target texture_size');
-  }
-  const started = performance.now();
-  const io = new NodeIO().registerExtensions(ALL_EXTENSIONS).registerDependencies({
-    'draco3d.decoder': await draco.createDecoderModule(),
-    'meshopt.decoder': MeshoptDecoder,
-  });
-  const document = await io.read(source);
-  document.setLogger(new Logger(Logger.Verbosity.SILENT));
-  // The decoded import GLB is not dependent on the provider's mesh codec.
-  for (const extension of document.getRoot().listExtensionsUsed()) {
-    if (['KHR_draco_mesh_compression', 'EXT_meshopt_compression'].includes(extension.extensionName)) {
-      extension.dispose();
-    }
-  }
-  function triangleCount() {
-    let count = 0;
-    for (const mesh of document.getRoot().listMeshes()) {
-      for (const primitive of mesh.listPrimitives()) {
-        if (primitive.getMode() !== 4) throw new Error('Only triangle primitives are supported');
-        const n = (primitive.getIndices() || primitive.getAttribute('POSITION')).getCount();
-        count += n / 3;
-      }
-    }
-    return count;
-  }
-  const before = triangleCount();
-  if (before > triangleTarget) {
-    await document.transform(weld(), simplify({simplifier: MeshoptSimplifier,
-      ratio: triangleTarget / before, error: 0.01, lockBorder: false}));
-  }
-  const textures = [];
-  for (const texture of document.getRoot().listTextures()) {
-    const image = texture.getImage();
-    if (!image) throw new Error('Texture has no decoded image');
-    const input = Buffer.from(image);
-    const info = await sharp(input).metadata();
-    let sizeAfter = [info.width, info.height];
-    if (Math.max(...sizeAfter) > textureTarget) {
-      const {data, info: resized} = await sharp(input).resize({width: textureTarget, height: textureTarget,
-        fit: 'inside', withoutEnlargement: true, kernel: 'lanczos3'}).png({compressionLevel: 9}).toBuffer({resolveWithObject: true});
-      texture.setImage(new Uint8Array(data)).setMimeType('image/png').setURI('');
-      sizeAfter = [resized.width, resized.height];
-    }
-    textures.push({name: texture.getName(), before: [info.width, info.height], after: sizeAfter});
-  }
-  const after = triangleCount();
-  mkdirSync(dirname(destination), {recursive: true});
-  await io.write(destination, document);
-  console.log(JSON.stringify({status: after <= triangleTarget ? 'PASS' : 'FAIL',
-    triangles_before: before, triangles_after: after, triangle_target: triangleTarget,
-    texture_target: textureTarget, textures, runtime,
-    policy: 'weld; one simplify pass at error 0.01 when over budget; downsize textures only; preserve UV/material/node data',
-    elapsed_sec: Math.round((performance.now() - started) / 10) / 100,
-    visual_review: 'PENDING'}));
-}

outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/sources_index.json DELETED Viewed

@@ -1,108 +0,0 @@
-{
-  "files": [
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/general_requirement.txt",
-      "sha256": "f6dcff2dc4ed2884a10fbe4dd372101607a1db35eb6101af83147dc67b427ca7",
-      "bytes": 26758
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/object_requirement.txt",
-      "sha256": "0e6baf23ec644632685288255be23927d404f458165c57cfe302a6b0c5df83f5",
-      "bytes": 1330
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/inputs/method_selection.md",
-      "sha256": "d9b0471f4c0e0f1e70c76e2bba676d3275d10530451435dc625972dbcea9abbe",
-      "bytes": 11846
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/generate_3d_comparison.py",
-      "sha256": "70f8d79c8596908f7edcd7ff68120f558cea6881f23dc2f0e29ef62f2bab75c4",
-      "bytes": 33749
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/cloud_journal.py",
-      "sha256": "92d075ef9308e0d6496a901d85b7847b8f602f88de8e19caeaf85ac893081253",
-      "bytes": 8458
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/record_paths.py",
-      "sha256": "93c42e454d60d03c30b12e58e8e75453c7caa8fc92ff30bbc20aa645b3fc23dd",
-      "bytes": 3390
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/pipeline/common/paths.py",
-      "sha256": "ed1cf1105f95c76b4893e98a84b3e37ef7d1f87c873c93c8e58413457104d28b",
-      "bytes": 17054
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/prompts/stage2_assets.md",
-      "sha256": "172339b9f6c6d834ef0d782c0d3dd779b62a12bd34acddc746b80d7cd99f63c2",
-      "bytes": 6384
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/operators/gen_3d_object/operator.py",
-      "sha256": "5f88c457ee58f73de5ddbd4d96fa91e474c29bd3ecefbb02f3faf18b93c4365a",
-      "bytes": 27332
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/meshy_model.py",
-      "sha256": "ef437ff79554469390c0d6c71f11788431fe4a1d1e51e92feae3adf296cebaec",
-      "bytes": 20927
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/gen_3d_object/tripo_model.py",
-      "sha256": "29ab3944260d62585a991f384eee4917368f97c4476abc3eda85299bc1a8089e",
-      "bytes": 24255
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/cloud_api.py",
-      "sha256": "a3c363a3439b3864e05e782340eb3059380c4b1c28eccb2524e9cbf9131fe996",
-      "bytes": 21838
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/GameFactory-3A/models/common/glb_utils.py",
-      "sha256": "6f3ee0147b345415cb6d8b1b1433fa557d0d543bb92276840dc85b43cd7a66ad",
-      "bytes": 23765
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/process_mesh.mjs",
-      "sha256": "b1b6ada273a576083bb167772ec03fee6fe3275470180563722e56687688995c",
-      "bytes": 3939
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/runtime/bench/scripts/asset/mesh_tools/package-lock.json",
-      "sha256": "0d9c3ad5898a78a0db22f361caa7242b48ff86586e898f5ae5c1bb4a7134631a",
-      "bytes": 26253
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/provenance/frozen_parent_plan_original.zip",
-      "sha256": "a72e49a29033d161d0ec0abd27dc003f34c8b7a190201c7e8b514e0afc4bce45",
-      "bytes": 60760,
-      "kind": "immutable_frozen_parent_plan_archive"
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/meshy/G039_sky_ring_flight__G039_sky_ring_flight_obj_005.json",
-      "sha256": "e41ec834db7ed651c3845b1f4fb9e8815778ca82a975b76f25560db16d60fffe",
-      "bytes": 13081
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/meshy/621b2bacd581f2248e057e82e0c502db9e73ab8421bab5c360e2a8f915f854a1.meta.json",
-      "sha256": "e40477fb6672d86566cd0b52422ba81560938720aee700c6cd007febac46e520",
-      "bytes": 1965
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/receipts/tripo/G039_sky_ring_flight__G039_sky_ring_flight_obj_005.json",
-      "sha256": "a6a1415ee18381e1302df7586d017bb3360a71cea4dd92be30a7c00e761c61fe",
-      "bytes": 2827
-    },
-    {
-      "path": "bench/test_data/outputs/G039_sky_ring_flight/.generation/3d_object/obj200_meshy_tripo_20261015_v2/delivery/cache_metadata/tripo/9d58e620c747b9213bdc1983dcf141fefb89ad92e884b7c832b36f21e3b84076.meta.json",
-      "sha256": "d3b46e10d8d43c1c003600d3828cca9f1a073d16a2cdb11585c0f668c2d18808",
-      "bytes": 1574
-    }
-  ],
-  "receipt_bytes_preserved": true,
-  "frozen_plan_unchanged": true,
-  "parent_plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d"
-}

outputs/G039_sky_ring_flight/.generation/3d_object/tripo/obj200_meshy_tripo_20261015_v2/asset_task_index.json DELETED Viewed

@@ -1,30 +0,0 @@
-{
-  "plan_sha256": "5c287b8399f00fbb0dddf94c9e3f5ffcbcc2e679ff76882bc8fc369d6eae840d",
-  "game_id": "G039_sky_ring_flight",
-  "provider": "tripo",
-  "scope": "3d_object_only_not_complete_stage2",
-  "tasks": [
-    {
-      "task": {
-        "game_id": "G039_sky_ring_flight",
-        "task_id": "G039_sky_ring_flight_obj_005",
-        "asset_name": "wind_stream_vane",
-        "name_zh": "风线仪",
-        "role": "prop",
-        "input_mode": "text_to_3d",
-        "prompt": "Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-        "seed": 1043,
-        "decimation_target": 8000,
-        "texture_size": 1024,
-        "rig": "none",
-        "animation_strategy": "procedural",
-        "spec_ref": "L01,F04",
-        "poly_policy": "low_poly_priority"
-      },
-      "shared_prompt": "Game context (excerpt): 空中群岛的风场穿环 | - W01 世界与时代背景：「浮空群岛」的候鸟节——每年季风转向时，群岛信使驾驶滑翔机沿 12 环天路巡游，向各岛灯塔投递新年的第一封信；天路穿过风谷与云柱，是对飞行员技术的最高礼赞。 | - S01 类型：三维飞行穿环计时挑战（12 环三段航线）。\nAsset: Mast-mounted wind streamer array with thin pennant ribbons and a small brass anemometer cage, marks wind zone boundaries, single object, Y-up, low-poly style, minimal triangle count, flat faceted surfaces, clean silhouette, no fine surface detail",
-      "reference": null,
-      "subject_group": "rigid",
-      "context_condition": "shared_short_context"
-    }
-  ]
-}

outputs/G039_sky_ring_flight/assets/3d_object/.gitattributes ADDED Viewed

	@@ -0,0 +1,4 @@

+G039_sky_ring_flight_obj_005/meshy/import/model.glb filter=lfs diff=lfs merge=lfs -text
+G039_sky_ring_flight_obj_005/meshy/model.glb filter=lfs diff=lfs merge=lfs -text
+G039_sky_ring_flight_obj_005/tripo/import/model.glb filter=lfs diff=lfs merge=lfs -text
+G039_sky_ring_flight_obj_005/tripo/model.glb filter=lfs diff=lfs merge=lfs -text

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/contact_sheet.jpg DELETED Viewed

Git LFS Details

SHA256: dd809a84ecacc18597c14cf7e73704191628b49f5a848a28136d070900647676
Pointer size: 130 Bytes
Size of remote file: 46.4 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/iso.png DELETED Viewed

Git LFS Details

SHA256: 0e9c62510c31774e5c8a6a957c088a91e4d30bb24971f8af2011388ee953976e
Pointer size: 130 Bytes
Size of remote file: 16.5 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/neg_x.png DELETED Viewed

Git LFS Details

SHA256: ef093611e16f1e7326f89ee9e5f51da43a70ea0c9946f7c85355086e86d1ba14
Pointer size: 130 Bytes
Size of remote file: 15.7 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/neg_z.png DELETED Viewed

Git LFS Details

SHA256: 92ce61456a2845406a719a28bacae882dbfb20809b3106bb70fccbe5154ce275
Pointer size: 130 Bytes
Size of remote file: 16.2 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/pos_x.png DELETED Viewed

Git LFS Details

SHA256: 4171ef263c481e5d22d146012c898bb2c8db7b4f36a70958e0d0919313374685
Pointer size: 130 Bytes
Size of remote file: 15.9 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/pos_y.png DELETED Viewed

Git LFS Details

SHA256: 038b8f5bbcee7b894d4152092164ba9128b68c088a849ece4f1927cf14e0405f
Pointer size: 130 Bytes
Size of remote file: 13.4 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/pos_z.png DELETED Viewed

Git LFS Details

SHA256: 5946b04576f26afa0e8b953277df7b336ea204c4445f0a4f654b99109b0a3f25
Pointer size: 130 Bytes
Size of remote file: 15.9 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/render_meta.json DELETED Viewed

@@ -1,60 +0,0 @@
-{
-  "label": "meshy_G039_sky_ring_flight_obj_005_import",
-  "source": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/import/model.glb",
-  "output": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import",
-  "provider": "meshy",
-  "task_id": "G039_sky_ring_flight_obj_005",
-  "variant": "import",
-  "source_sha256": "61407909da58fd9808dc88d62e3820ec1edf0570199e5e78c33e1c7d57f9545c",
-  "views": [
-    {
-      "axis": "+z",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/pos_z.png"
-    },
-    {
-      "axis": "-z",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/neg_z.png"
-    },
-    {
-      "axis": "+x",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/pos_x.png"
-    },
-    {
-      "axis": "-x",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/neg_x.png"
-    },
-    {
-      "axis": "+y",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/pos_y.png"
-    },
-    {
-      "axis": "iso",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/import/iso.png"
-    }
-  ],
-  "geometry": {
-    "bounds": [
-      0.8493079841136932,
-      1.8995019793510437,
-      0.6107359826564789
-    ],
-    "bounds_min": [
-      -0.4268819987773895,
-      -0.9507899880409241,
-      -0.3067989945411682
-    ],
-    "bounds_max": [
-      0.4224259853363037,
-      0.9487119913101196,
-      0.30393698811531067
-    ],
-    "meshes": 1,
-    "triangles": 7880,
-    "skinned": 0,
-    "force_front_side": false,
-    "renderer": "WebKit WebGL",
-    "three": "180",
-    "animation_clips": 0
-  },
-  "status": "rendered"
-}

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/contact_sheet.jpg DELETED Viewed

Git LFS Details

SHA256: d917215e435340139b4863851ddf54d5b309adc833d74dfdf6b4f91b934caa7f
Pointer size: 130 Bytes
Size of remote file: 46.4 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/iso.png DELETED Viewed

Git LFS Details

SHA256: b62166ce79da14266095076ae862c57fe9df28828e0ef28c97fa948c10dfddca
Pointer size: 130 Bytes
Size of remote file: 16.5 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/neg_x.png DELETED Viewed

Git LFS Details

SHA256: d0b9a6b5039b0d3450bff5332500fc288f16afb8e63e6eef8d8e52f7e49f5384
Pointer size: 130 Bytes
Size of remote file: 15.8 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/neg_z.png DELETED Viewed

Git LFS Details

SHA256: 576d6b464da8a7a3bb7e820e042d00887042e379625ba9b38f5aa1602f79c253
Pointer size: 130 Bytes
Size of remote file: 16.2 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/pos_x.png DELETED Viewed

Git LFS Details

SHA256: 0a0460d5793fadd363426018232435e7f1d67dfa4be48d157f5aebeb86456b2a
Pointer size: 130 Bytes
Size of remote file: 15.9 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/pos_y.png DELETED Viewed

Git LFS Details

SHA256: 7663c01b63c03a1636b7871aa75b1d8da7c4c24ce3aa22053613202d535da3a0
Pointer size: 130 Bytes
Size of remote file: 13.4 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/pos_z.png DELETED Viewed

Git LFS Details

SHA256: f2be340944ff7c60e7d41c2a805647b4c15225fcf4adc0737a7e6e3a03692796
Pointer size: 130 Bytes
Size of remote file: 15.8 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/render_meta.json DELETED Viewed

@@ -1,60 +0,0 @@
-{
-  "label": "meshy_G039_sky_ring_flight_obj_005_native",
-  "source": "bench/test_data/outputs/G039_sky_ring_flight/assets/3d_object/G039_sky_ring_flight_obj_005/meshy/model.glb",
-  "output": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native",
-  "provider": "meshy",
-  "task_id": "G039_sky_ring_flight_obj_005",
-  "variant": "native",
-  "source_sha256": "6b0eab059bd1e619ca24e6e6ef32d2b1380faa094b778c7df2451bc4673d19d4",
-  "views": [
-    {
-      "axis": "+z",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/pos_z.png"
-    },
-    {
-      "axis": "-z",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/neg_z.png"
-    },
-    {
-      "axis": "+x",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/pos_x.png"
-    },
-    {
-      "axis": "-x",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/neg_x.png"
-    },
-    {
-      "axis": "+y",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/pos_y.png"
-    },
-    {
-      "axis": "iso",
-      "file": "bench/test_data/outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/previews/native/iso.png"
-    }
-  ],
-  "geometry": {
-    "bounds": [
-      0.8493079841136932,
-      1.8995019793510437,
-      0.6107359826564789
-    ],
-    "bounds_min": [
-      -0.4268819987773895,
-      -0.9507899880409241,
-      -0.3067989945411682
-    ],
-    "bounds_max": [
-      0.4224259853363037,
-      0.9487119913101196,
-      0.30393698811531067
-    ],
-    "meshes": 1,
-    "triangles": 7880,
-    "skinned": 0,
-    "force_front_side": false,
-    "renderer": "WebKit WebGL",
-    "three": "180",
-    "animation_clips": 0
-  },
-  "status": "rendered"
-}

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/meshy/qa.json DELETED Viewed

@@ -1,135 +0,0 @@
-{
-  "native": {
-    "status": "PASS",
-    "checks": {
-      "parseable_glb": true,
-      "glb_v2_exact_length": true,
-      "positive_triangle_count": true,
-      "triangle_budget": true,
-      "materials_present": true,
-      "textures_present": true,
-      "uv_present": true,
-      "self_contained": true
-    },
-    "summary": {
-      "bytes": 9577000,
-      "triangles": 7880,
-      "meshes": 1,
-      "materials": 1,
-      "textures": 4,
-      "images": 4,
-      "nodes": 1,
-      "generator": "pygltflib@v1.16.5"
-    },
-    "triangle_target": 8000,
-    "requested_texture_size": 1024,
-    "texture_budget_verified": false,
-    "visual_status": "PENDING",
-    "limitations": [
-      "No visual, orientation, scale, rigging or engine acceptance yet",
-      "Native texture resolution retained; task texture_size is not enforced",
-      "Basic checks do not validate every accessor, topology defect or PBR channel"
-    ]
-  },
-  "import": {
-    "status": "PASS",
-    "checks": {
-      "parseable_glb": true,
-      "glb_v2_exact_length": true,
-      "positive_triangle_count": true,
-      "triangle_budget": true,
-      "materials_present": true,
-      "textures_present": true,
-      "uv_present": true,
-      "self_contained": true,
-      "texture_budget": true
-    },
-    "summary": {
-      "bytes": 6271868,
-      "triangles": 7880,
-      "meshes": 1,
-      "materials": 1,
-      "textures": 4,
-      "images": 4,
-      "nodes": 1,
-      "generator": "glTF-Transform v4.2.1"
-    },
-    "triangle_target": 8000,
-    "requested_texture_size": 1024,
-    "texture_budget_verified": true,
-    "visual_status": "PENDING",
-    "limitations": [
-      "No visual, orientation, scale, rigging or engine acceptance yet",
-      "Native texture resolution retained; task texture_size is not enforced",
-      "Basic checks do not validate every accessor, topology defect or PBR channel"
-    ]
-  },
-  "postprocess": {
-    "status": "PASS",
-    "triangles_before": 7880,
-    "triangles_after": 7880,
-    "triangle_target": 8000,
-    "texture_target": 1024,
-    "textures": [
-      {
-        "name": "",
-        "before": [
-          2048,
-          2048
-        ],
-        "after": [
-          1024,
-          1024
-        ]
-      },
-      {
-        "name": "",
-        "before": [
-          2048,
-          2048
-        ],
-        "after": [
-          1024,
-          1024
-        ]
-      },
-      {
-        "name": "",
-        "before": [
-          2048,
-          2048
-        ],
-        "after": [
-          1024,
-          1024
-        ]
-      },
-      {
-        "name": "",
-        "before": [
-          2048,
-          2048
-        ],
-        "after": [
-          1024,
-          1024
-        ]
-      }
-    ],
-    "runtime": {
-      "node": "20.17.0",
-      "dependencies": {
-        "@gltf-transform/core": "4.2.1",
-        "@gltf-transform/extensions": "4.2.1",
-        "@gltf-transform/functions": "4.2.1",
-        "draco3dgltf": "1.5.7",
-        "meshoptimizer": "0.24.0",
-        "sharp": "0.35.5"
-      }
-    },
-    "policy": "weld; one simplify pass at error 0.01 when over budget; downsize textures only; preserve UV/material/node data",
-    "elapsed_sec": 0.72,
-    "visual_review": "PENDING"
-  },
-  "visual_status": "PENDING"
-}

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/previews/import/contact_sheet.jpg DELETED Viewed

Git LFS Details

SHA256: 5b75e257b389cc735361c3eef76a27d56e77c5651c0b94134a18e84c7322febc
Pointer size: 130 Bytes
Size of remote file: 69.2 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/previews/import/iso.png DELETED Viewed

Git LFS Details

SHA256: 88ffab9105229d7d3a2a91504d43b7f66cc204a250c67ff6479f8920ea8b30bd
Pointer size: 130 Bytes
Size of remote file: 50.8 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/previews/import/neg_x.png DELETED Viewed

Git LFS Details

SHA256: 78e90e02b123ea04a73e20d769b830bd6f0cc27e84a2160b54ba7c97ca1d1449
Pointer size: 130 Bytes
Size of remote file: 40 kB

outputs/G039_sky_ring_flight/eval/3d_object/G039_sky_ring_flight_obj_005/tripo/previews/import/neg_z.png DELETED Viewed

Git LFS Details

SHA256: 64bffca26c0f5897d098889cc119a210c243f69c1fb7cd0e97be604a4f105081
Pointer size: 130 Bytes
Size of remote file: 35.6 kB