From f6d3362ed2353ff9e042bac0b74c8fef9b0ec2f7 Mon Sep 17 00:00:00 2001 From: selune <35337584+0xlillith@users.noreply.github.com> Date: Fri, 30 Oct 2026 13:11:54 +0100 Subject: [PATCH] docs(render): checkpoint complete current53-path C12 candidate without validation claims --- .../2026-10-30/c12-complete-source/README.md | 9 + .../c12-complete-source/candidate.patch | 6220 +++++++++++++++++ .../c12-complete-source/manifest.json | 119 + 3 files changed, 6348 insertions(+) create mode 100644 proposals/render/2026-10-30/c12-complete-source/README.md create mode 100644 proposals/render/2026-10-30/c12-complete-source/candidate.patch create mode 100644 proposals/render/2026-10-30/c12-complete-source/manifest.json diff --git a/proposals/render/2026-10-30/c12-complete-source/README.md b/proposals/render/2026-10-30/c12-complete-source/README.md new file mode 100644 index 000000000..5ddeb818e --- /dev/null +++ b/proposals/render/2026-10-30/c12-complete-source/README.md @@ -0,0 +1,9 @@ +# Complete current local Render candidate: C12 source checkpoint + +Reviewable WIP against production draft base a077906234972dbbf11e80c54893f85ece97c8b7. The single patch includes all53 modified/new project paths, including existing core corrections, complete Interactive request/identity/cache controls, waiting/input/layout corrections, preview-help translations, GPU failure reasons, progressive Area/LED and the two real light E2E tests. It supersedes manual composition of earlier incremental patches for this exact snapshot; do not apply both. + +C12 is still executing on this frozen source. Formatting/check and repository-list precheck completed; no new Clippy, wasm or selected-test result is claimed at publication. Planned native selection is53 cases/35positive CPU markers, not the full repository gate. The real i18n gate internally invokes a release CLI-registry build; an exterior success alone cannot establish registry success when its error is swallowed. Final actual results remain a separate obligation. + +This archive is not production registration, a ready PR, an installed-app fix or a validation waiver. The53path manifest contains raw input hashes; the patch is LF-normalized as explained there. No private controller/lease data, logs, executable, user design or profile is included. + +CPU nested-glass V2/engine follow-up, EV/HDR two-test follow-up and Raster main perspective fix remain separate proposals and are NOT included. No full glass/GPU/Raster parity is claimed. Fresh current-source desktop build, native pointer/keyboard acceptance, the actual full gate and maintainer process remain pending. diff --git a/proposals/render/2026-10-30/c12-complete-source/candidate.patch b/proposals/render/2026-10-30/c12-complete-source/candidate.patch new file mode 100644 index 000000000..ddc277c90 --- /dev/null +++ b/proposals/render/2026-10-30/c12-complete-source/candidate.patch @@ -0,0 +1,6220 @@ +diff --git a/assets/locales/ar.json b/assets/locales/ar.json +index 0f6d7c30..ca2ada40 100644 +--- a/assets/locales/ar.json ++++ b/assets/locales/ar.json +@@ -2296,7 +2296,7 @@ + "render.cpu_point_help": "حتى ثمانية أضواء نقطية تُضاف إلى الإضاءة الاتجاهية المختارة. المسافات بالمليمتر؛ ويجب ألا يتجاوز الحد الأدنى المسافة المرجعية.", + "render.cpu_primary_samples": "عيّنات الحواف لكل بكسل", + "render.cpu_progressive": "CPU تدريجي", +- "render.cpu_progressive_help": "يُراكم مُكامل CPU الحالي على تمريرات من عيّنة أساسية واحدة. الانعكاسات المختارة تتطلب عيّنة واحدة؛ والأضواء المساحية والعوازل وتباين الخواص تتطلب «صورة واحدة».", ++ "render.cpu_progressive_help": "يُراكم مُكامل CPU الحالي على تمريرات من عيّنة أساسية واحدة. الانعكاسات المختارة تتطلب عيّنة واحدة؛ والعوازل وتباين الخواص تتطلب «صورة واحدة».", + "render.cpu_progressive_limits": "بحد أقصى 1,048,576 بكسل و16,777,216 عملية تقييم بكسل × عيّنة. تغيير العيّنات لا يغيّر حجم الصورة تلقائيًا أبدًا.", + "render.cpu_progressive_seed": "بذرة عيّنات CPU", + "render.cpu_progressive_spp": "عيّنات لكل بكسل", +@@ -2925,8 +2925,8 @@ + "render.post_vignette": "التعتيم الطرفي", + "render.preview": "المعاينة المدمجة", + "render.preview_help": "تظليل نقطي وشفافية ممزوجة. الانكسار وHDRI والتصيير النهائي غير متاحة بعد.", +- "render.preview_image_settings_help": "تحافظ المعاينة الحية على إضاءة استوديو ثابتة. يُطبّق التعريض وإضاءة الصورة على مهمة الصورة عند «فحص» أو «بدء».", +- "render.preview_lighting_help": "المعاينة الحية تعرض الضوء المباشر فقط وبلا ظلال.", ++ "render.preview_image_settings_help": "تستخدم معاينة النموذج إضاءة مباشرة تقريبية. عند تفعيله، يحدّث التصيير التفاعلي على CPU صورة مؤقتة باستخدام إعدادات الصورة المدعومة، بما فيها التعريض. التصيير النهائي منفصل.", ++ "render.preview_lighting_help": "تستخدم معاينة النموذج إضاءة مباشرة بلا ظلال. يستخدم التصيير التفاعلي على CPU إعدادات الصورة المدعومة لصورته المؤقتة.", + "render.preview_retry": "إعادة محاولة المعاينة الحية", + "render.preview_unavailable_help": "المعاينة الحية غير متاحة. تبقى الإعدادات المحفوظة وعناصر التحكم في مهمة الصورة متاحة. غيّر المشهد أو أعد المحاولة صراحةً؛ لا يُعاد بناء المشهد المرفوض في كل إطار.", + "render.preview_upload": "حمولة رؤوس المعاينة الحية", +@@ -3190,7 +3190,7 @@ + "render.stage_panels.use_budget": "استخدام هذه الميزانية", + "render.stage_panels.use_maps": "استخدام خرائط GPU", + "render.stage_panels.use_uniform": "استخدام المظهر الموحّد", +- "render.stage_preview_note": "معاينة مدمجة · ضوء مباشر", ++ "render.stage_preview_note": "معاينة التصيير", + "render.state_completed": "صورة مكتملة", + "render.state_in_progress": "صورة قيد الإنجاز", + "render.state_model": "معاينة النموذج", +diff --git a/assets/locales/bs.json b/assets/locales/bs.json +index 1b0720a0..5f004b3a 100644 +--- a/assets/locales/bs.json ++++ b/assets/locales/bs.json +@@ -2159,7 +2159,7 @@ + "render.cpu_point_help": "Do osam tačkastih svjetala, dodanih izabranom usmjerenom osvjetljenju. Udaljenosti su u mm; minimalna ne smije premašiti referentnu udaljenost.", + "render.cpu_primary_samples": "Uzorci ivica po pikselu", + "render.cpu_progressive": "CPU progresivno", +- "render.cpu_progressive_help": "Akumulira postojeći CPU integrator u prolazima od po jednog primarnog uzorka. Izabrane refleksije zahtijevaju jedan uzorak; površinska svjetla, dielektrici i anizotropija zahtijevaju Jedna slika.", ++ "render.cpu_progressive_help": "Akumulira postojeći CPU integrator u prolazima od po jednog primarnog uzorka. Izabrane refleksije zahtijevaju jedan uzorak; dielektrici i anizotropija zahtijevaju Jedna slika.", + "render.cpu_progressive_limits": "Najviše 1.048.576 piksela i 16.777.216 izračunavanja piksel × uzorak. Promjena uzoraka nikad automatski ne mijenja veličinu slike.", + "render.cpu_progressive_seed": "CPU sjeme uzorkovanja", + "render.cpu_progressive_spp": "uzoraka po pikselu", +@@ -2677,8 +2677,8 @@ + "render.post_vignette": "Vinjeta", + "render.preview": "Integrisani pregled", + "render.preview_help": "Raster sjenčenje i miješana prozirnost. Prelamanje, HDRI i završno renderovanje još nisu dostupni.", +- "render.preview_image_settings_help": "Pregled uživo zadržava fiksno osvjetljenje studija. Ekspozicija i osvjetljenje slike primjenjuju se na posao slike kada kliknete Provjeri ili Pokreni.", +- "render.preview_lighting_help": "Pregled uživo prikazuje samo direktno svjetlo, bez sjena.", ++ "render.preview_image_settings_help": "Pregled modela koristi približno direktno osvjetljenje. Kada je uključeno, interaktivno renderiranje na CPU-u ažurira privremenu sliku koristeći podržane postavke slike, uključujući ekspoziciju. Završno renderiranje je odvojeno.", ++ "render.preview_lighting_help": "Pregled modela koristi direktno osvjetljenje bez sjena. Interaktivno renderiranje na CPU-u koristi podržane postavke slike za privremenu sliku.", + "render.preview_retry": "Ponovo pokušaj pregled uživo", + "render.preview_unavailable_help": "Pregled uživo nije dostupan. Sačuvane postavke i kontrole posla slike ostaju dostupne. Promijenite scenu ili izričito pokušajte ponovo; odbijena scena se ne gradi ponovo u svakom kadru.", + "render.preview_upload": "Podaci vrhova pregleda uživo", +@@ -2906,7 +2906,7 @@ + "render.stage_panels.use_budget": "Koristi ovaj budžet", + "render.stage_panels.use_maps": "Koristi GPU mape", + "render.stage_panels.use_uniform": "Koristi ujednačeno", +- "render.stage_preview_note": "Integrisani pregled · direktno svjetlo", ++ "render.stage_preview_note": "Pregled renderiranja", + "render.state_completed": "Završena slika", + "render.state_in_progress": "Slika u izradi", + "render.state_model": "Pregled modela", +diff --git a/assets/locales/cs.json b/assets/locales/cs.json +index aa8f35ac..a4c5b4b3 100644 +--- a/assets/locales/cs.json ++++ b/assets/locales/cs.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "Nejvýše osm bodových světel, přidaných k vybranému směrovému osvětlení. Vzdálenosti jsou v mm; minimum nesmí překročit referenční vzdálenost.", + "render.cpu_primary_samples": "Vzorky hran na pixel", + "render.cpu_progressive": "Progresivní CPU", +- "render.cpu_progressive_help": "Akumuluje stávající integrátor CPU v průchodech po jednom primárním vzorku. Vybrané odrazy vyžadují jeden vzorek; plošná světla, dielektrika a anizotropie vyžadují režim Jeden obrázek.", ++ "render.cpu_progressive_help": "Akumuluje stávající integrátor CPU v průchodech po jednom primárním vzorku. Vybrané odrazy vyžadují jeden vzorek; dielektrika a anizotropie vyžadují režim Jeden obrázek.", + "render.cpu_progressive_limits": "Nejvýše 1 048 576 pixelů a 16 777 216 vyhodnocení pixel × vzorek. Změna počtu vzorků nikdy automaticky nezmění velikost obrázku.", + "render.cpu_progressive_seed": "Náhodné semeno vzorkování CPU", + "render.cpu_progressive_spp": "vzorků na pixel", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "Vinětace", + "render.preview": "Integrovaný náhled", + "render.preview_help": "Rastrové stínování a smíšená průhlednost. Lom světla, HDRI a finální render zatím nejsou k dispozici.", +- "render.preview_image_settings_help": "Živý náhled zachovává pevné studiové osvětlení. Expozice a osvětlení obrazu se použijí na úlohu obrazu při kontrole nebo spuštění.", +- "render.preview_lighting_help": "Živý náhled zobrazuje pouze přímé světlo a žádné stíny.", ++ "render.preview_image_settings_help": "Náhled modelu používá přibližné přímé osvětlení. Po zapnutí interaktivní renderování na CPU aktualizuje prozatímní obraz pomocí podporovaných nastavení obrazu včetně expozice. Finální renderování je samostatné.", ++ "render.preview_lighting_help": "Náhled modelu používá přímé osvětlení bez stínů. Interaktivní renderování na CPU používá pro prozatímní obraz podporovaná nastavení obrazu.", + "render.preview_retry": "Zkusit znovu živý náhled", + "render.preview_unavailable_help": "Živý náhled není k dispozici. Uložená nastavení a ovládací prvky úlohy obrazu zůstávají přístupné. Změňte scénu nebo to výslovně zkuste znovu; odmítnutá scéna se nesestavuje při každém snímku.", + "render.preview_upload": "Data vrcholů živého náhledu", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "Použít tento rozpočet", + "render.stage_panels.use_maps": "Použít mapy GPU", + "render.stage_panels.use_uniform": "Použít jednotný", +- "render.stage_preview_note": "Integrovaný náhled · přímé světlo", ++ "render.stage_preview_note": "Náhled renderování", + "render.state_completed": "Dokončený obrázek", + "render.state_in_progress": "Obrázek se vykresluje", + "render.state_model": "Náhled modelu", +diff --git a/assets/locales/de.json b/assets/locales/de.json +index fe1933bd..d3b04d71 100644 +--- a/assets/locales/de.json ++++ b/assets/locales/de.json +@@ -2460,7 +2460,8 @@ + "render.pick_waiting": "Die Produktauswahl wird noch nicht unterstützt.", + "render.preview": "Integrierte Vorschau", + "render.preview_help": "Rasterdarstellung mit gemischter Transparenz. Brechung, HDRI und finales Rendering sind noch nicht verfügbar.", +- "render.preview_lighting_help": "Die Live-Vorschau zeigt nur direktes Licht und keine Schatten.", ++ "render.preview_image_settings_help": "Die Modellvorschau verwendet eine Näherung der direkten Beleuchtung. Wenn aktiviert, aktualisiert Interaktives Rendering auf der CPU ein vorläufiges Bild mit den unterstützten Bildeinstellungen, einschließlich Belichtung. Das endgültige Rendering erfolgt separat.", ++ "render.preview_lighting_help": "Die Modellvorschau verwendet direkte Beleuchtung ohne Schatten. Interaktives Rendering auf der CPU nutzt die unterstützten Bildeinstellungen für sein vorläufiges Bild.", + "render.property_conditions": "Bedingungen: {value}", + "render.property_fallback": "Eigenschaft", + "render.property_qualifier": "Qualifikator: {value}", +@@ -2664,7 +2665,7 @@ + "render.stage_panels.use_budget": "Dieses Budget verwenden", + "render.stage_panels.use_maps": "GPU-Texturen verwenden", + "render.stage_panels.use_uniform": "Einheitlich verwenden", +- "render.stage_preview_note": "Integrierte Vorschau · direktes Licht", ++ "render.stage_preview_note": "Render-Vorschau", + "render.state_completed": "Fertiges Bild", + "render.state_in_progress": "Bild in Bearbeitung", + "render.state_model": "Modellvorschau", +diff --git a/assets/locales/en.json b/assets/locales/en.json +index dc30868c..449d6939 100644 +--- a/assets/locales/en.json ++++ b/assets/locales/en.json +@@ -2296,7 +2296,7 @@ + "render.cpu_point_help": "Up to eight point lights, added to the selected directional lighting. Distances are in mm; the minimum must not exceed the reference distance.", + "render.cpu_primary_samples": "Edge samples per pixel", + "render.cpu_progressive": "CPU progressive", +- "render.cpu_progressive_help": "Accumulate the existing CPU integrator in passes of one primary sample. Selected reflections require one sample; area lights, dielectrics and anisotropy require Single image.", ++ "render.cpu_progressive_help": "Accumulate the existing CPU integrator in passes of one primary sample. Selected reflections require one sample; dielectrics and anisotropy require Single image.", + "render.cpu_progressive_limits": "At most 1,048,576 pixels and 16,777,216 pixel × sample evaluations. Changing samples never resizes the image automatically.", + "render.cpu_progressive_seed": "CPU sampling seed", + "render.cpu_progressive_spp": "samples per pixel", +@@ -2925,8 +2925,8 @@ + "render.post_vignette": "Vignette", + "render.preview": "Integrated preview", + "render.preview_help": "Raster shading and blended transparency. Refraction, HDRI and final rendering are not available yet.", +- "render.preview_image_settings_help": "Live Preview keeps fixed studio lighting. Exposure and image lighting apply to the image job when you Check or Start.", +- "render.preview_lighting_help": "The live preview shows direct light only and no shadows.", ++ "render.preview_image_settings_help": "Model Preview uses approximate direct lighting. When enabled, Interactive Render on the CPU updates a provisional image using supported image settings, including exposure. Final rendering is separate.", ++ "render.preview_lighting_help": "Model Preview uses direct lighting without shadows. Interactive Render on the CPU uses supported image settings for its provisional image.", + "render.preview_retry": "Retry live preview", + "render.preview_unavailable_help": "The live preview is unavailable. Saved setups and image-job controls remain accessible. Change the scene or explicitly retry; a refused scene is not rebuilt on every frame.", + "render.preview_upload": "Live-preview vertex payload", +@@ -3190,7 +3190,7 @@ + "render.stage_panels.use_budget": "Use this budget", + "render.stage_panels.use_maps": "Use GPU maps", + "render.stage_panels.use_uniform": "Use uniform", +- "render.stage_preview_note": "Integrated preview · direct light", ++ "render.stage_preview_note": "Render preview", + "render.state_completed": "Completed image", + "render.state_in_progress": "Image in progress", + "render.state_model": "Model Preview", +diff --git a/assets/locales/es.json b/assets/locales/es.json +index 811cc0f0..1e74e259 100644 +--- a/assets/locales/es.json ++++ b/assets/locales/es.json +@@ -1954,7 +1954,7 @@ + "render.cpu_point_help": "Hasta ocho luces puntuales, añadidas a la iluminación direccional elegida. Las distancias están en mm; la mínima no puede superar la de referencia.", + "render.cpu_primary_samples": "Muestras de borde por píxel", + "render.cpu_progressive": "CPU progresivo", +- "render.cpu_progressive_help": "Acumula el integrador CPU actual en pasadas de una muestra primaria. Los reflejos seleccionados requieren una muestra; luces de área, dieléctricos y anisotropía requieren Imagen fija.", ++ "render.cpu_progressive_help": "Acumula el integrador CPU actual en pasadas de una muestra primaria. Los reflejos seleccionados requieren una muestra; dieléctricos y anisotropía requieren Imagen fija.", + "render.cpu_progressive_limits": "Máximo de 1.048.576 píxeles y 16.777.216 evaluaciones de píxel × muestra. Cambiar las muestras nunca redimensiona la imagen automáticamente.", + "render.cpu_progressive_seed": "Semilla de muestreo CPU", + "render.cpu_progressive_spp": "muestras por píxel", +@@ -2258,8 +2258,8 @@ + "render.post_vignette": "Viñeta", + "render.preview": "Vista previa integrada", + "render.preview_help": "Sombreado por rasterización y transparencia combinada. La refracción, HDRI y el renderizado final aún no están disponibles.", +- "render.preview_image_settings_help": "La vista previa mantiene una iluminación de estudio fija. La exposición y la iluminación de imagen se aplican al trabajo al Comprobar o Iniciar.", +- "render.preview_lighting_help": "La vista previa en vivo muestra solo luz directa y nada de sombras.", ++ "render.preview_image_settings_help": "La vista previa del modelo usa una aproximación de la iluminación directa. Al activarse, el render interactivo en CPU actualiza una imagen provisional con los ajustes de imagen compatibles, incluida la exposición. El render final es independiente.", ++ "render.preview_lighting_help": "La vista previa del modelo usa iluminación directa sin sombras. El render interactivo en CPU usa los ajustes de imagen compatibles para su imagen provisional.", + "render.preview_retry": "Reintentar vista previa", + "render.preview_unavailable_help": "La vista previa no está disponible. Los ajustes guardados y los controles de imagen siguen accesibles. Cambia la escena o reintenta expresamente; una escena rechazada no se reconstruye en cada fotograma.", + "render.preview_upload": "Datos de vértices de la vista previa", +@@ -2364,7 +2364,7 @@ + "render.stage_orthographic": "Ortográfica", + "render.stage_output": "Salida", + "render.stage_panel_count": "Paneles guardados", +- "render.stage_preview_note": "Vista previa integrada · luz directa", ++ "render.stage_preview_note": "Vista previa del render", + "render.strip_label": "Tira", + "render.studio_add_area": "Añadir luz de área", + "render.studio_ambient": "Radiancia constante del entorno", +diff --git a/assets/locales/fr.json b/assets/locales/fr.json +index 0a9667dd..51baea23 100644 +--- a/assets/locales/fr.json ++++ b/assets/locales/fr.json +@@ -2169,7 +2169,7 @@ + "render.cpu_point_help": "Jusqu'à huit lumières ponctuelles, ajoutées à l'éclairage directionnel choisi. Les distances sont en mm ; la distance minimale ne doit pas dépasser la distance de référence.", + "render.cpu_primary_samples": "Échantillons de bord par pixel", + "render.cpu_progressive": "CPU progressif", +- "render.cpu_progressive_help": "Accumuler l'intégrateur CPU existant par passes d'un échantillon primaire. Les réflexions sélectionnées exigent un échantillon ; les lumières surfaciques, les diélectriques et l'anisotropie exigent Image unique.", ++ "render.cpu_progressive_help": "Accumuler l'intégrateur CPU existant par passes d'un échantillon primaire. Les réflexions sélectionnées exigent un échantillon ; les diélectriques et l'anisotropie exigent Image unique.", + "render.cpu_progressive_limits": "Au plus 1 048 576 pixels et 16 777 216 évaluations pixel × échantillon. Changer le nombre d'échantillons ne redimensionne jamais l'image automatiquement.", + "render.cpu_progressive_seed": "Graine d'échantillonnage CPU", + "render.cpu_progressive_spp": "échantillons par pixel", +@@ -2687,8 +2687,8 @@ + "render.post_vignette": "Vignettage", + "render.preview": "Aperçu intégré", + "render.preview_help": "Ombrage par rastérisation et transparence mélangée. La réfraction, l'HDRI et le rendu final ne sont pas encore disponibles.", +- "render.preview_image_settings_help": "L'aperçu en direct garde un éclairage de studio fixe. L'exposition et l'éclairage de l'image s'appliquent à la tâche d'image quand vous cliquez sur Vérifier ou Démarrer.", +- "render.preview_lighting_help": "L'aperçu en direct n'affiche que la lumière directe, sans ombres.", ++ "render.preview_image_settings_help": "L’aperçu du modèle utilise une approximation de l’éclairage direct. Lorsqu’il est activé, le rendu interactif sur CPU actualise une image provisoire avec les paramètres d’image pris en charge, dont l’exposition. Le rendu final est distinct.", ++ "render.preview_lighting_help": "L’aperçu du modèle utilise un éclairage direct sans ombres. Le rendu interactif sur CPU utilise les paramètres d’image pris en charge pour son image provisoire.", + "render.preview_retry": "Réessayer l'aperçu en direct", + "render.preview_unavailable_help": "L'aperçu en direct est indisponible. Les préréglages enregistrés et les réglages de tâche d'image restent accessibles. Modifiez la scène ou réessayez explicitement ; une scène refusée n'est pas reconstruite à chaque image.", + "render.preview_upload": "Charge de sommets de l'aperçu en direct", +@@ -2916,7 +2916,7 @@ + "render.stage_panels.use_budget": "Utiliser ce budget", + "render.stage_panels.use_maps": "Utiliser les textures GPU", + "render.stage_panels.use_uniform": "Utiliser l'uniforme", +- "render.stage_preview_note": "Aperçu intégré · lumière directe", ++ "render.stage_preview_note": "Aperçu du rendu", + "render.state_completed": "Image terminée", + "render.state_in_progress": "Image en cours", + "render.state_model": "Aperçu du modèle", +diff --git a/assets/locales/gl.json b/assets/locales/gl.json +index 6902de5c..dadadbea 100644 +--- a/assets/locales/gl.json ++++ b/assets/locales/gl.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "Ata oito luces puntuais, engadidas á iluminación direccional seleccionada. As distancias están en mm; a mínima non pode superar a distancia de referencia.", + "render.cpu_primary_samples": "Mostras de bordo por píxel", + "render.cpu_progressive": "Progresivo da CPU", +- "render.cpu_progressive_help": "Acumula o integrador da CPU existente en pasadas dunha mostra primaria. As reflexións seleccionadas requiren unha mostra; as luces de área, os dieléctricos e a anisotropía requiren Imaxe única.", ++ "render.cpu_progressive_help": "Acumula o integrador da CPU existente en pasadas dunha mostra primaria. As reflexións seleccionadas requiren unha mostra; os dieléctricos e a anisotropía requiren Imaxe única.", + "render.cpu_progressive_limits": "Como máximo 1.048.576 píxeles e 16.777.216 avaliacións de píxel × mostra. Cambiar as mostras nunca redimensiona a imaxe automaticamente.", + "render.cpu_progressive_seed": "Semente de mostraxe da CPU", + "render.cpu_progressive_spp": "mostras por píxel", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "Viñeta", + "render.preview": "Previsualización integrada", + "render.preview_help": "Sombreado ráster e transparencia mesturada. A refracción, o HDRI e o render final aínda non están dispoñibles.", +- "render.preview_image_settings_help": "A vista previa en directo mantén unha iluminación de estudo fixa. A exposición e a iluminación da imaxe aplícanse á tarefa de imaxe ao usar Comprobar ou Iniciar.", +- "render.preview_lighting_help": "A vista previa en directo só mostra luz directa e non hai sombras.", ++ "render.preview_image_settings_help": "A previsualización do modelo usa unha aproximación da iluminación directa. Ao activarse, a renderización interactiva na CPU actualiza unha imaxe provisional cos axustes de imaxe compatibles, incluída a exposición. A renderización final é independente.", ++ "render.preview_lighting_help": "A previsualización do modelo usa iluminación directa sen sombras. A renderización interactiva na CPU usa os axustes de imaxe compatibles para a súa imaxe provisional.", + "render.preview_retry": "Reintentar a vista previa en directo", + "render.preview_unavailable_help": "A vista previa en directo non está dispoñible. As configuracións gardadas e os controis das tarefas de imaxe seguen accesibles. Cambia a escena ou reinténtao explicitamente; unha escena rexeitada non se reconstrúe en cada fotograma.", + "render.preview_upload": "Datos de vértices da vista previa en directo", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "Usar este orzamento", + "render.stage_panels.use_maps": "Usar os mapas da GPU", + "render.stage_panels.use_uniform": "Usar uniforme", +- "render.stage_preview_note": "Vista previa integrada · luz directa", ++ "render.stage_preview_note": "Previsualización da renderización", + "render.state_completed": "Imaxe completada", + "render.state_in_progress": "Imaxe en curso", + "render.state_model": "Vista previa do modelo", +diff --git a/assets/locales/he.json b/assets/locales/he.json +index 2581608f..c39c1a7d 100644 +--- a/assets/locales/he.json ++++ b/assets/locales/he.json +@@ -2296,7 +2296,7 @@ + "render.cpu_point_help": "עד שמונה אורות נקודתיים, המתווספים לתאורה הכיוונית שנבחרה. המרחקים במילימטרים; המינימום אינו יכול לעלות על מרחק הייחוס.", + "render.cpu_primary_samples": "דגימות קצה לכל פיקסל", + "render.cpu_progressive": "CPU הדרגתי", +- "render.cpu_progressive_help": "צבירה של אינטגרטור ה־CPU הקיים במעברים של דגימה ראשית אחת. החזרות שנבחרו דורשות דגימה אחת; אורות שטח, דיאלקטריים ואנאיזוטרופיה דורשים תמונה בודדת.", ++ "render.cpu_progressive_help": "צבירה של אינטגרטור ה־CPU הקיים במעברים של דגימה ראשית אחת. החזרות שנבחרו דורשות דגימה אחת; דיאלקטריים ואנאיזוטרופיה דורשים תמונה בודדת.", + "render.cpu_progressive_limits": "לכל היותר 1,048,576 פיקסלים ו־16,777,216 הערכות פיקסל × דגימה. שינוי הדגימות לעולם אינו משנה את גודל התמונה אוטומטית.", + "render.cpu_progressive_seed": "זרע דגימה ב־CPU", + "render.cpu_progressive_spp": "דגימות לכל פיקסל", +@@ -2925,8 +2925,8 @@ + "render.post_vignette": "הצללת שוליים", + "render.preview": "תצוגה מקדימה מובנית", + "render.preview_help": "הצללת רסטר ושקיפות ממוזגת. שבירת אור, HDRI והדמיה סופית עדיין אינם זמינים.", +- "render.preview_image_settings_help": "התצוגה המקדימה החיה שומרת על תאורת סטודיו קבועה. החשיפה ותאורת התמונה חלות על משימת התמונה בעת בדיקה או התחלה.", +- "render.preview_lighting_help": "התצוגה המקדימה החיה מציגה אור ישיר בלבד וללא צללים.", ++ "render.preview_image_settings_help": "התצוגה המקדימה של המודל משתמשת בקירוב של תאורה ישירה. כאשר הוא מופעל, רינדור אינטראקטיבי במעבד CPU מעדכן תמונה זמנית באמצעות הגדרות התמונה הנתמכות, כולל חשיפה. הרינדור הסופי נפרד.", ++ "render.preview_lighting_help": "התצוגה המקדימה של המודל משתמשת בתאורה ישירה ללא צללים. רינדור אינטראקטיבי במעבד CPU משתמש בהגדרות התמונה הנתמכות לתמונה הזמנית שלו.", + "render.preview_retry": "ניסיון חוזר של התצוגה המקדימה החיה", + "render.preview_unavailable_help": "התצוגה המקדימה החיה אינה זמינה. ההגדרות השמורות ופקדי משימת התמונה נשארים זמינים. יש לשנות את הסצנה או לנסות שוב במפורש; סצנה שנדחתה אינה נבנית מחדש בכל פריים.", + "render.preview_upload": "מטען הקודקודים של התצוגה המקדימה החיה", +@@ -3190,7 +3190,7 @@ + "render.stage_panels.use_budget": "שימוש בתקציב זה", + "render.stage_panels.use_maps": "שימוש במפות GPU", + "render.stage_panels.use_uniform": "שימוש במראה אחיד", +- "render.stage_preview_note": "תצוגה מקדימה משולבת · אור ישיר", ++ "render.stage_preview_note": "תצוגה מקדימה של הרינדור", + "render.state_completed": "תמונה שהושלמה", + "render.state_in_progress": "תמונה בתהליך", + "render.state_model": "תצוגת מודל", +diff --git a/assets/locales/hr.json b/assets/locales/hr.json +index fc3293f5..51082091 100644 +--- a/assets/locales/hr.json ++++ b/assets/locales/hr.json +@@ -2159,7 +2159,7 @@ + "render.cpu_point_help": "Do osam točkastih svjetala, dodanih odabranom usmjerenom osvjetljenju. Udaljenosti su u mm; minimalna ne smije premašiti referentnu udaljenost.", + "render.cpu_primary_samples": "Uzorci rubova po pikselu", + "render.cpu_progressive": "CPU progresivno", +- "render.cpu_progressive_help": "Akumulira postojeći CPU integrator u prolazima od po jednog primarnog uzorka. Odabrane refleksije zahtijevaju jedan uzorak; površinska svjetla, dielektrici i anizotropija zahtijevaju Jedna slika.", ++ "render.cpu_progressive_help": "Akumulira postojeći CPU integrator u prolazima od po jednog primarnog uzorka. Odabrane refleksije zahtijevaju jedan uzorak; dielektrici i anizotropija zahtijevaju Jedna slika.", + "render.cpu_progressive_limits": "Najviše 1.048.576 piksela i 16.777.216 izračuna piksel × uzorak. Promjena uzoraka nikad automatski ne mijenja veličinu slike.", + "render.cpu_progressive_seed": "CPU sjeme uzorkovanja", + "render.cpu_progressive_spp": "uzoraka po pikselu", +@@ -2677,8 +2677,8 @@ + "render.post_vignette": "Vinjeta", + "render.preview": "Integrirani pregled", + "render.preview_help": "Raster sjenčanje i miješana prozirnost. Lom, HDRI i završno renderiranje još nisu dostupni.", +- "render.preview_image_settings_help": "Pregled uživo zadržava fiksno osvjetljenje studija. Ekspozicija i osvjetljenje slike primjenjuju se na posao slike kad kliknete Provjeri ili Pokreni.", +- "render.preview_lighting_help": "Pregled uživo prikazuje samo izravno svjetlo, bez sjena.", ++ "render.preview_image_settings_help": "Pregled modela koristi približno izravno osvjetljenje. Kada je uključeno, interaktivno renderiranje na CPU-u ažurira privremenu sliku pomoću podržanih postavki slike, uključujući ekspoziciju. Završno renderiranje je odvojeno.", ++ "render.preview_lighting_help": "Pregled modela koristi izravno osvjetljenje bez sjena. Interaktivno renderiranje na CPU-u koristi podržane postavke slike za privremenu sliku.", + "render.preview_retry": "Ponovno pokušaj pregled uživo", + "render.preview_unavailable_help": "Pregled uživo nije dostupan. Spremljene postavke i kontrole posla slike ostaju dostupne. Promijenite scenu ili izričito pokušajte ponovno; odbijena scena ne gradi se ponovno u svakom kadru.", + "render.preview_upload": "Podaci vrhova pregleda uživo", +@@ -2906,7 +2906,7 @@ + "render.stage_panels.use_budget": "Upotrijebi ovaj proračun", + "render.stage_panels.use_maps": "Upotrijebi GPU mape", + "render.stage_panels.use_uniform": "Upotrijebi jednoliko", +- "render.stage_preview_note": "Integrirani pregled · izravno svjetlo", ++ "render.stage_preview_note": "Pregled renderiranja", + "render.state_completed": "Dovršena slika", + "render.state_in_progress": "Slika u izradi", + "render.state_model": "Pregled modela", +diff --git a/assets/locales/hu.json b/assets/locales/hu.json +index 111f9e84..9ef2c38f 100644 +--- a/assets/locales/hu.json ++++ b/assets/locales/hu.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "Legfeljebb nyolc pontfény, amelyek a kijelölt irányított megvilágításhoz adódnak hozzá. A távolságok mm-ben értendők; a minimum nem haladhatja meg a referenciatávolságot.", + "render.cpu_primary_samples": "Élminták pixelenként", + "render.cpu_progressive": "Progresszív CPU", +- "render.cpu_progressive_help": "A meglévő CPU-integrátor eredményeinek felhalmozása egy elsődleges mintából álló menetekben. A kijelölt tükröződésekhez egy minta szükséges; a területi fényekhez, a dielektrikumokhoz és az anizotrópiához az Egyetlen kép mód kell.", ++ "render.cpu_progressive_help": "A meglévő CPU-integrátor eredményeinek felhalmozása egy elsődleges mintából álló menetekben. A kijelölt tükröződésekhez egy minta szükséges; a dielektrikumokhoz és az anizotrópiához az Egyetlen kép mód kell.", + "render.cpu_progressive_limits": "Legfeljebb 1 048 576 képpont és 16 777 216 képpont × minta kiértékelés. A minták módosítása sosem méretezi át automatikusan a képet.", + "render.cpu_progressive_seed": "CPU-mintavételi kezdőérték", + "render.cpu_progressive_spp": "minta pixelenként", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "Vignetta", + "render.preview": "Beépített előnézet", + "render.preview_help": "Raszteres árnyalás és kevert átlátszóság. A fénytörés, a HDRI és a végső renderelés még nem érhető el.", +- "render.preview_image_settings_help": "Az élő előnézet rögzített stúdiómegvilágítást használ. Az expozíció és a képmegvilágítás az Ellenőrzéskor vagy az Indításkor érvényesül a képfeladaton.", +- "render.preview_lighting_help": "Az élő előnézet csak közvetlen fényt mutat, árnyékok nélkül.", ++ "render.preview_image_settings_help": "A modell előnézete közelítő közvetlen megvilágítást használ. Bekapcsolva a CPU-n futó interaktív renderelés a támogatott képbeállításokkal, köztük az expozícióval frissít egy ideiglenes képet. A végső renderelés külön történik.", ++ "render.preview_lighting_help": "A modell előnézete árnyékok nélküli közvetlen megvilágítást használ. A CPU-n futó interaktív renderelés a támogatott képbeállításokat használja az ideiglenes képhez.", + "render.preview_retry": "Élő előnézet újrapróbálása", + "render.preview_unavailable_help": "Az élő előnézet nem érhető el. A mentett beállítások és a képfeladat vezérlői továbbra is elérhetők. Módosítsa a jelenetet, vagy kifejezetten próbálja újra; az elutasított jelenetet a program nem építi újra minden képkockánál.", + "render.preview_upload": "Élő előnézet csúcspontadatai", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "Ezen keret használata", + "render.stage_panels.use_maps": "GPU-s térképek használata", + "render.stage_panels.use_uniform": "Egyenletes érték használata", +- "render.stage_preview_note": "Integrált előnézet · közvetlen fény", ++ "render.stage_preview_note": "Renderelési előnézet", + "render.state_completed": "Kész kép", + "render.state_in_progress": "Kép készül", + "render.state_model": "Modell előnézete", +diff --git a/assets/locales/id.json b/assets/locales/id.json +index 9c93853d..1924c567 100644 +--- a/assets/locales/id.json ++++ b/assets/locales/id.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "Hingga delapan lampu titik, ditambahkan ke pencahayaan arah yang dipilih. Jarak dalam mm; minimum tidak boleh melebihi jarak referensi.", + "render.cpu_primary_samples": "Sampel tepi per piksel", + "render.cpu_progressive": "CPU progresif", +- "render.cpu_progressive_help": "Akumulasikan integrator CPU yang ada dalam pass berisi satu sampel primer. Pantulan yang dipilih memerlukan satu sampel; lampu area, dielektrik, dan anisotropi memerlukan Gambar tunggal.", ++ "render.cpu_progressive_help": "Akumulasikan integrator CPU yang ada dalam pass berisi satu sampel primer. Pantulan yang dipilih memerlukan satu sampel; dielektrik dan anisotropi memerlukan Gambar tunggal.", + "render.cpu_progressive_limits": "Paling banyak 1.048.576 piksel dan 16.777.216 evaluasi piksel × sampel. Mengubah sampel tidak pernah mengubah ukuran gambar secara otomatis.", + "render.cpu_progressive_seed": "Seed sampling CPU", + "render.cpu_progressive_spp": "sampel per piksel", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "Vinyet", + "render.preview": "Pratinjau terintegrasi", + "render.preview_help": "Shading raster dan transparansi campuran. Refraksi, HDRI, dan render akhir belum tersedia.", +- "render.preview_image_settings_help": "Pratinjau Langsung mempertahankan pencahayaan studio yang tetap. Eksposur dan pencahayaan gambar berlaku untuk tugas gambar saat Anda memilih Periksa atau Mulai.", +- "render.preview_lighting_help": "Pratinjau langsung hanya menampilkan cahaya langsung dan tanpa bayangan.", ++ "render.preview_image_settings_help": "Pratinjau model menggunakan perkiraan pencahayaan langsung. Saat diaktifkan, render interaktif pada CPU memperbarui gambar sementara dengan pengaturan gambar yang didukung, termasuk eksposur. Render akhir dilakukan secara terpisah.", ++ "render.preview_lighting_help": "Pratinjau model menggunakan pencahayaan langsung tanpa bayangan. Render interaktif pada CPU menggunakan pengaturan gambar yang didukung untuk gambar sementaranya.", + "render.preview_retry": "Coba lagi pratinjau langsung", + "render.preview_unavailable_help": "Pratinjau langsung tidak tersedia. Setup tersimpan dan kontrol tugas gambar tetap dapat diakses. Ubah adegan atau coba lagi secara eksplisit; adegan yang ditolak tidak dibangun ulang di setiap frame.", + "render.preview_upload": "Payload vertex pratinjau langsung", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "Gunakan anggaran ini", + "render.stage_panels.use_maps": "Gunakan peta GPU", + "render.stage_panels.use_uniform": "Gunakan seragam", +- "render.stage_preview_note": "Pratinjau terintegrasi · cahaya langsung", ++ "render.stage_preview_note": "Pratinjau render", + "render.state_completed": "Gambar selesai", + "render.state_in_progress": "Gambar sedang diproses", + "render.state_model": "Pratinjau Model", +diff --git a/assets/locales/it.json b/assets/locales/it.json +index 923cdf72..3864a6ac 100644 +--- a/assets/locales/it.json ++++ b/assets/locales/it.json +@@ -2150,7 +2150,7 @@ + "render.cpu_point_help": "Fino a otto luci puntiformi, aggiunte all'illuminazione direzionale selezionata. Le distanze sono in mm; il minimo non deve superare la distanza di riferimento.", + "render.cpu_primary_samples": "Campioni dei bordi per pixel", + "render.cpu_progressive": "CPU progressiva", +- "render.cpu_progressive_help": "Accumula l'integratore CPU esistente in passate di un campione primario. Le riflessioni selezionate richiedono un solo campione; luci d'area, dielettrici e anisotropia richiedono Immagine singola.", ++ "render.cpu_progressive_help": "Accumula l'integratore CPU esistente in passate di un campione primario. Le riflessioni selezionate richiedono un solo campione; dielettrici e anisotropia richiedono Immagine singola.", + "render.cpu_progressive_limits": "Al massimo 1,048,576 pixel e 16,777,216 valutazioni pixel × campione. Cambiare i campioni non ridimensiona mai automaticamente l'immagine.", + "render.cpu_progressive_seed": "Seme di campionamento CPU", + "render.cpu_progressive_spp": "campioni per pixel", +@@ -2668,8 +2668,8 @@ + "render.post_vignette": "Vignettatura", + "render.preview": "Anteprima integrata", + "render.preview_help": "Ombreggiatura raster e trasparenza miscelata. Rifrazione, HDRI e rendering finale non sono ancora disponibili.", +- "render.preview_image_settings_help": "L'anteprima live mantiene un'illuminazione da studio fissa. L'esposizione e l'illuminazione dell'immagine si applicano al lavoro immagine quando scegli Verifica o Avvia.", +- "render.preview_lighting_help": "L'anteprima live mostra solo la luce diretta e nessuna ombra.", ++ "render.preview_image_settings_help": "L’anteprima del modello usa un’approssimazione dell’illuminazione diretta. Quando è attivo, il rendering interattivo sulla CPU aggiorna un’immagine provvisoria con le impostazioni immagine supportate, inclusa l’esposizione. Il rendering finale è separato.", ++ "render.preview_lighting_help": "L’anteprima del modello usa illuminazione diretta senza ombre. Il rendering interattivo sulla CPU usa le impostazioni immagine supportate per l’immagine provvisoria.", + "render.preview_retry": "Riprova l'anteprima live", + "render.preview_unavailable_help": "L'anteprima live non è disponibile. Le impostazioni salvate e i controlli del lavoro immagine restano accessibili. Modifica la scena o riprova esplicitamente; una scena rifiutata non viene ricostruita a ogni fotogramma.", + "render.preview_upload": "Payload dei vertici dell'anteprima live", +@@ -2897,7 +2897,7 @@ + "render.stage_panels.use_budget": "Usa questo budget", + "render.stage_panels.use_maps": "Usa mappe GPU", + "render.stage_panels.use_uniform": "Usa uniforme", +- "render.stage_preview_note": "Anteprima integrata · luce diretta", ++ "render.stage_preview_note": "Anteprima del rendering", + "render.state_completed": "Immagine completata", + "render.state_in_progress": "Immagine in corso", + "render.state_model": "Anteprima del modello", +diff --git a/assets/locales/ja.json b/assets/locales/ja.json +index 6a7e82d3..6ba6cba4 100644 +--- a/assets/locales/ja.json ++++ b/assets/locales/ja.json +@@ -2296,7 +2296,7 @@ + "render.cpu_point_help": "選択した平行光に最大8個の点光源を追加できます。距離はmmで、最小距離は基準距離以下にしてください。", + "render.cpu_primary_samples": "輪郭サンプル数/ピクセル", + "render.cpu_progressive": "CPUプログレッシブ", +- "render.cpu_progressive_help": "既存のCPU積分器を、一次サンプル1個ずつのパスで累積します。選択した反射は1サンプルが必要です。面光源、誘電体、異方性には固定画像を使用してください。", ++ "render.cpu_progressive_help": "既存のCPU積分器を、一次サンプル1個ずつのパスで累積します。選択した反射は1サンプルが必要です。誘電体、異方性には固定画像を使用してください。", + "render.cpu_progressive_limits": "最大1,048,576ピクセル、ピクセル×サンプルの合計は16,777,216以下です。サンプル数を変えても画像サイズは自動変更されません。", + "render.cpu_progressive_seed": "CPUサンプリングシード", + "render.cpu_progressive_spp": "サンプル/ピクセル", +@@ -2925,8 +2925,8 @@ + "render.post_vignette": "ビネット", + "render.preview": "統合プレビュー", + "render.preview_help": "ラスタシェーディングとブレンド透明度を使用します。屈折、HDRI、最終レンダリングはまだ利用できません。", +- "render.preview_image_settings_help": "ライブプレビューは固定のスタジオ照明を使用します。画像の露出と照明は、確認または開始時に画像ジョブへ適用されます。", +- "render.preview_lighting_help": "ライブプレビューは直接光のみを表示し、影は表示しません。", ++ "render.preview_image_settings_help": "モデルプレビューは近似的な直接照明を使用します。CPUのインタラクティブレンダリングを有効にすると、露出などの対応する画像設定を使って暫定画像を更新します。最終レンダリングは別に行います。", ++ "render.preview_lighting_help": "モデルプレビューは影のない直接照明を使用します。CPUのインタラクティブレンダリングは、対応する画像設定を暫定画像に使用します。", + "render.preview_retry": "ライブプレビューを再試行", + "render.preview_unavailable_help": "ライブプレビューは利用できません。保存設定と画像ジョブの操作は使用できます。シーンを変更するか明示的に再試行してください。拒否されたシーンを毎フレーム再構築しません。", + "render.preview_upload": "ライブプレビューの頂点データ量", +@@ -3190,7 +3190,7 @@ + "render.stage_panels.use_budget": "この予算を使用", + "render.stage_panels.use_maps": "GPUマップを使用", + "render.stage_panels.use_uniform": "均一な外観を使用", +- "render.stage_preview_note": "統合プレビュー · 直接光", ++ "render.stage_preview_note": "レンダリングプレビュー", + "render.state_completed": "完成画像", + "render.state_in_progress": "画像を生成中", + "render.state_model": "モデルプレビュー", +diff --git a/assets/locales/ko.json b/assets/locales/ko.json +index 96ea8be4..ec5a66bf 100644 +--- a/assets/locales/ko.json ++++ b/assets/locales/ko.json +@@ -2244,7 +2244,8 @@ + "render.pick_waiting": "제품 선택은 아직 지원되지 않습니다.", + "render.preview": "통합 미리보기", + "render.preview_help": "래스터 셰이딩과 블렌딩 투명도를 사용합니다. 굴절, HDRI 및 최종 렌더링은 아직 지원하지 않습니다.", +- "render.preview_lighting_help": "실시간 미리 보기에는 직접 조명만 표시되며 그림자는 표시되지 않습니다.", ++ "render.preview_image_settings_help": "모델 미리 보기는 근사 직접 조명을 사용합니다. CPU 대화형 렌더링을 켜면 노출을 비롯한 지원 이미지 설정으로 임시 이미지를 갱신합니다. 최종 렌더링은 별도입니다.", ++ "render.preview_lighting_help": "모델 미리 보기는 그림자 없는 직접 조명을 사용합니다. CPU 대화형 렌더링은 임시 이미지에 지원 이미지 설정을 사용합니다.", + "render.property_conditions": "조건: {value}", + "render.property_fallback": "속성", + "render.property_qualifier": "한정 조건: {value}", +@@ -2448,7 +2449,7 @@ + "render.stage_panels.use_budget": "이 예산 사용", + "render.stage_panels.use_maps": "GPU 맵 사용", + "render.stage_panels.use_uniform": "균일한 외관 사용", +- "render.stage_preview_note": "통합 미리 보기 · 직접광", ++ "render.stage_preview_note": "렌더링 미리 보기", + "render.state_completed": "완료된 이미지", + "render.state_in_progress": "이미지 생성 중", + "render.state_model": "모델 미리보기", +diff --git a/assets/locales/ms.json b/assets/locales/ms.json +index 97aa6a3f..5265cf23 100644 +--- a/assets/locales/ms.json ++++ b/assets/locales/ms.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "Sehingga lapan lampu titik, ditambah pada pencahayaan berarah yang dipilih. Jarak dalam mm; jarak minimum tidak boleh melebihi jarak rujukan.", + "render.cpu_primary_samples": "Sampel tepi setiap piksel", + "render.cpu_progressive": "CPU progresif", +- "render.cpu_progressive_help": "Kumpulkan hasil penyepadu CPU sedia ada dalam pas satu sampel utama. Pantulan yang dipilih memerlukan satu sampel; lampu kawasan, dielektrik dan anisotropi memerlukan Imej tunggal.", ++ "render.cpu_progressive_help": "Kumpulkan hasil penyepadu CPU sedia ada dalam pas satu sampel utama. Pantulan yang dipilih memerlukan satu sampel; dielektrik dan anisotropi memerlukan Imej tunggal.", + "render.cpu_progressive_limits": "Paling banyak 1,048,576 piksel dan 16,777,216 penilaian piksel × sampel. Menukar sampel tidak mengubah saiz imej secara automatik.", + "render.cpu_progressive_seed": "Benih pensampelan CPU", + "render.cpu_progressive_spp": "sampel setiap piksel", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "Vinyet", + "render.preview": "Pratonton bersepadu", + "render.preview_help": "Lorekan raster dan ketelusan campuran. Pembiasan, HDRI dan render akhir belum tersedia.", +- "render.preview_image_settings_help": "Pratonton Langsung mengekalkan pencahayaan studio tetap. Pendedahan dan pencahayaan imej digunakan pada kerja imej apabila anda menekan Semak atau Mula.", +- "render.preview_lighting_help": "Pratonton langsung hanya menunjukkan cahaya langsung dan tiada bayang.", ++ "render.preview_image_settings_help": "Pratonton model menggunakan anggaran pencahayaan langsung. Apabila diaktifkan, render interaktif pada CPU mengemas kini imej sementara dengan tetapan imej yang disokong, termasuk dedahan. Render akhir dibuat secara berasingan.", ++ "render.preview_lighting_help": "Pratonton model menggunakan pencahayaan langsung tanpa bayang. Render interaktif pada CPU menggunakan tetapan imej yang disokong untuk imej sementaranya.", + "render.preview_retry": "Cuba semula pratonton langsung", + "render.preview_unavailable_help": "Pratonton langsung tidak tersedia. Persediaan tersimpan dan kawalan kerja imej kekal boleh diakses. Ubah adegan atau cuba semula secara eksplisit; adegan yang ditolak tidak dibina semula pada setiap bingkai.", + "render.preview_upload": "Muatan bucu pratonton langsung", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "Gunakan bajet ini", + "render.stage_panels.use_maps": "Gunakan peta GPU", + "render.stage_panels.use_uniform": "Gunakan seragam", +- "render.stage_preview_note": "Pratonton bersepadu · cahaya langsung", ++ "render.stage_preview_note": "Pratonton render", + "render.state_completed": "Imej siap", + "render.state_in_progress": "Imej dalam proses", + "render.state_model": "Pratonton Model", +diff --git a/assets/locales/nb.json b/assets/locales/nb.json +index 163dc559..a248902e 100644 +--- a/assets/locales/nb.json ++++ b/assets/locales/nb.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "Opptil åtte punktlys, lagt til i den valgte retningsbelysningen. Avstander er i mm; minimumsavstanden må ikke overstige referanseavstanden.", + "render.cpu_primary_samples": "Kantprøver per piksel", + "render.cpu_progressive": "Progressiv CPU", +- "render.cpu_progressive_help": "Akkumuler den eksisterende CPU-integratoren i omganger på én primærprøve. Valgte refleksjoner krever én prøve; arealys, dielektriske materialer og anisotropi krever Enkeltbilde.", ++ "render.cpu_progressive_help": "Akkumuler den eksisterende CPU-integratoren i omganger på én primærprøve. Valgte refleksjoner krever én prøve; dielektriske materialer og anisotropi krever Enkeltbilde.", + "render.cpu_progressive_limits": "Maksimalt 1 048 576 piksler og 16 777 216 evalueringer av piksel × prøve. Endring av antall prøver endrer aldri bildestørrelsen automatisk.", + "render.cpu_progressive_seed": "Startverdi for CPU-prøvetaking", + "render.cpu_progressive_spp": "prøver per piksel", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "Vignettering", + "render.preview": "Integrert forhåndsvisning", + "render.preview_help": "Rasterskyggelegging og blandet transparens. Lysbrytning, HDRI og sluttrendring er ikke tilgjengelig ennå.", +- "render.preview_image_settings_help": "Live-forhåndsvisningen beholder fast studiobelysning. Eksponering og bildebelysning gjelder for bildejobben når du velger Sjekk eller Start.", +- "render.preview_lighting_help": "Live-forhåndsvisningen viser bare direkte lys og ingen skygger.", ++ "render.preview_image_settings_help": "Modellforhåndsvisningen bruker en tilnærming av direkte belysning. Når interaktiv gjengivelse på CPU er aktivert, oppdateres et foreløpig bilde med støttede bildeinnstillinger, inkludert eksponering. Endelig gjengivelse kjøres separat.", ++ "render.preview_lighting_help": "Modellforhåndsvisningen bruker direkte belysning uten skygger. Interaktiv gjengivelse på CPU bruker støttede bildeinnstillinger for det foreløpige bildet.", + "render.preview_retry": "Prøv live-forhåndsvisning igjen", + "render.preview_unavailable_help": "Live-forhåndsvisningen er utilgjengelig. Lagrede oppsett og kontroller for bildejobber er fortsatt tilgjengelige. Endre scenen eller prøv eksplisitt på nytt; en avvist scene bygges ikke på nytt for hver bilderute.", + "render.preview_upload": "Verteksdata for live-forhåndsvisning", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "Bruk dette budsjettet", + "render.stage_panels.use_maps": "Bruk GPU-kart", + "render.stage_panels.use_uniform": "Bruk ensartet", +- "render.stage_preview_note": "Integrert forhåndsvisning · direkte lys", ++ "render.stage_preview_note": "Forhåndsvisning av gjengivelse", + "render.state_completed": "Ferdig bilde", + "render.state_in_progress": "Bilde under arbeid", + "render.state_model": "Modellforhåndsvisning", +diff --git a/assets/locales/nl.json b/assets/locales/nl.json +index 15b124b8..313659f8 100644 +--- a/assets/locales/nl.json ++++ b/assets/locales/nl.json +@@ -2148,7 +2148,7 @@ + "render.cpu_point_help": "Maximaal acht puntlichten, toegevoegd aan de gekozen richtingsverlichting. Afstanden zijn in mm; het minimum mag de referentieafstand niet overschrijden.", + "render.cpu_primary_samples": "Randsamples per pixel", + "render.cpu_progressive": "CPU progressief", +- "render.cpu_progressive_help": "Accumuleert de bestaande CPU-integrator in passes van één primaire sample. Gekozen reflecties vereisen één sample; vlaklichten, diëlektrica en anisotropie vereisen Enkele afbeelding.", ++ "render.cpu_progressive_help": "Accumuleert de bestaande CPU-integrator in passes van één primaire sample. Gekozen reflecties vereisen één sample; diëlektrica en anisotropie vereisen Enkele afbeelding.", + "render.cpu_progressive_limits": "Maximaal 1.048.576 pixels en 16.777.216 evaluaties van pixel × sample. Het wijzigen van samples verandert de afbeeldingsgrootte nooit automatisch.", + "render.cpu_progressive_seed": "Seed voor CPU-sampling", + "render.cpu_progressive_spp": "samples per pixel", +@@ -2666,8 +2666,8 @@ + "render.post_vignette": "Vignettering", + "render.preview": "Geïntegreerd voorbeeld", + "render.preview_help": "Rasterschaduw en gemengde transparantie. Breking, HDRI en eindrendering zijn nog niet beschikbaar.", +- "render.preview_image_settings_help": "Het live voorbeeld behoudt vaste studioverlichting. Belichting en beeldverlichting gelden voor de afbeeldingstaak wanneer je Controleren of Starten kiest.", +- "render.preview_lighting_help": "Het live voorbeeld toont alleen direct licht en geen schaduwen.", ++ "render.preview_image_settings_help": "Het modelvoorbeeld gebruikt een benadering van directe verlichting. Als interactief renderen op de CPU is ingeschakeld, wordt een voorlopig beeld bijgewerkt met de ondersteunde beeldinstellingen, waaronder belichting. De definitieve rendering staat hier los van.", ++ "render.preview_lighting_help": "Het modelvoorbeeld gebruikt directe verlichting zonder schaduwen. Interactief renderen op de CPU gebruikt de ondersteunde beeldinstellingen voor het voorlopige beeld.", + "render.preview_retry": "Live voorbeeld opnieuw proberen", + "render.preview_unavailable_help": "Het live voorbeeld is niet beschikbaar. Opgeslagen opstellingen en de besturing van afbeeldingstaken blijven toegankelijk. Wijzig de scène of probeer het expliciet opnieuw; een geweigerde scène wordt niet bij elk frame opnieuw opgebouwd.", + "render.preview_upload": "Hoekpuntgegevens van live voorbeeld", +@@ -2895,7 +2895,7 @@ + "render.stage_panels.use_budget": "Dit budget gebruiken", + "render.stage_panels.use_maps": "GPU-kaarten gebruiken", + "render.stage_panels.use_uniform": "Uniform gebruiken", +- "render.stage_preview_note": "Geïntegreerd voorbeeld · direct licht", ++ "render.stage_preview_note": "Rendervoorbeeld", + "render.state_completed": "Voltooide afbeelding", + "render.state_in_progress": "Afbeelding in uitvoering", + "render.state_model": "Modelvoorbeeld", +diff --git a/assets/locales/ro.json b/assets/locales/ro.json +index e87f7761..b4b9926f 100644 +--- a/assets/locales/ro.json ++++ b/assets/locales/ro.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "Până la opt lumini punctiforme, adăugate la iluminarea direcțională selectată. Distanțele sunt în mm; minimul nu trebuie să depășească distanța de referință.", + "render.cpu_primary_samples": "Eșantioane de margine per pixel", + "render.cpu_progressive": "CPU progresiv", +- "render.cpu_progressive_help": "Acumulează cu integratorul CPU existent, în treceri de câte un eșantion primar. Reflexiile selectate necesită un singur eșantion; luminile de arie, dielectricii și anizotropia necesită modul Imagine unică.", ++ "render.cpu_progressive_help": "Acumulează cu integratorul CPU existent, în treceri de câte un eșantion primar. Reflexiile selectate necesită un singur eșantion; dielectricii și anizotropia necesită modul Imagine unică.", + "render.cpu_progressive_limits": "Cel mult 1.048.576 de pixeli și 16.777.216 de evaluări pixel × eșantion. Modificarea eșantioanelor nu redimensionează niciodată automat imaginea.", + "render.cpu_progressive_seed": "Sămânță de eșantionare CPU", + "render.cpu_progressive_spp": "eșantioane per pixel", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "Vinietă", + "render.preview": "Previzualizare integrată", + "render.preview_help": "Umbrire raster și transparență amestecată. Refracția, HDRI și randarea finală nu sunt încă disponibile.", +- "render.preview_image_settings_help": "Previzualizarea live păstrează iluminarea fixă de studio. Expunerea și iluminarea imaginii se aplică sarcinii de imagine când o verificați sau o porniți.", +- "render.preview_lighting_help": "Previzualizarea live afișează doar lumina directă, fără umbre.", ++ "render.preview_image_settings_help": "Previzualizarea modelului folosește o aproximare a iluminării directe. Când este activată, randarea interactivă pe CPU actualizează o imagine provizorie cu setările de imagine acceptate, inclusiv expunerea. Randarea finală este separată.", ++ "render.preview_lighting_help": "Previzualizarea modelului folosește iluminare directă fără umbre. Randarea interactivă pe CPU folosește setările de imagine acceptate pentru imaginea provizorie.", + "render.preview_retry": "Reîncearcă previzualizarea live", + "render.preview_unavailable_help": "Previzualizarea live nu este disponibilă. Configurațiile salvate și comenzile sarcinii de imagine rămân accesibile. Modificați scena sau reîncercați explicit; o scenă refuzată nu este reconstruită la fiecare cadru.", + "render.preview_upload": "Date de vârfuri pentru previzualizarea live", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "Folosește acest buget", + "render.stage_panels.use_maps": "Folosește hărțile GPU", + "render.stage_panels.use_uniform": "Folosește uniform", +- "render.stage_preview_note": "Previzualizare integrată · lumină directă", ++ "render.stage_preview_note": "Previzualizarea randării", + "render.state_completed": "Imagine finalizată", + "render.state_in_progress": "Imagine în curs", + "render.state_model": "Previzualizare model", +diff --git a/assets/locales/ru.json b/assets/locales/ru.json +index 1ff46fc6..1bdb0137 100644 +--- a/assets/locales/ru.json ++++ b/assets/locales/ru.json +@@ -2111,7 +2111,7 @@ + "render.cpu_point_help": "До восьми точечных источников света в дополнение к выбранному направленному освещению. Расстояния в мм; минимальное не должно превышать опорное.", + "render.cpu_primary_samples": "Сэмплов краёв на пиксель", + "render.cpu_progressive": "Прогрессивный CPU", +- "render.cpu_progressive_help": "Накопление существующим интегратором CPU проходами по одному основному сэмплу. Выбранные отражения требуют одного сэмпла; площадные источники света, диэлектрики и анизотропия требуют режима «Одно изображение».", ++ "render.cpu_progressive_help": "Накопление существующим интегратором CPU проходами по одному основному сэмплу. Выбранные отражения требуют одного сэмпла; диэлектрики и анизотропия требуют режима «Одно изображение».", + "render.cpu_progressive_limits": "Не более 1 048 576 пикселей и 16 777 216 вычислений «пиксель × сэмпл». Изменение числа сэмплов никогда не меняет размер изображения автоматически.", + "render.cpu_progressive_seed": "Начальное значение сэмплирования CPU", + "render.cpu_progressive_spp": "сэмплов на пиксель", +@@ -2527,8 +2527,8 @@ + "render.post_vignette": "Виньетирование", + "render.preview": "Встроенный предпросмотр", + "render.preview_help": "Растровое затенение и смешанная прозрачность. Преломление, HDRI и финальный рендеринг пока недоступны.", +- "render.preview_image_settings_help": "Интерактивный просмотр использует фиксированное студийное освещение. Экспозиция и освещение изображения применяются к задаче рендера при «Проверить» или «Начать».", +- "render.preview_lighting_help": "Интерактивный просмотр показывает только прямой свет, без теней.", ++ "render.preview_image_settings_help": "Предпросмотр модели использует приближённое прямое освещение. При включении интерактивный рендеринг на CPU обновляет предварительное изображение с поддерживаемыми настройками изображения, включая экспозицию. Финальный рендеринг выполняется отдельно.", ++ "render.preview_lighting_help": "Предпросмотр модели использует прямое освещение без теней. Интерактивный рендеринг на CPU использует поддерживаемые настройки изображения для предварительного изображения.", + "render.preview_retry": "Повторить интерактивный просмотр", + "render.preview_unavailable_help": "Интерактивный просмотр недоступен. Сохранённые настройки и элементы управления задачей рендера остаются доступными. Измените сцену или явно повторите попытку; отклонённая сцена не перестраивается при каждой перерисовке.", + "render.preview_upload": "Вершинные данные интерактивного просмотра", +@@ -2655,7 +2655,7 @@ + "render.stage_orthographic": "Ортографическая", + "render.stage_output": "Вывод", + "render.stage_panel_count": "Сохранённые панели", +- "render.stage_preview_note": "Встроенный просмотр · прямой свет", ++ "render.stage_preview_note": "Предпросмотр рендеринга", + "render.strip_label": "Лента", + "render.studio_add_area": "Добавить площадной источник света", + "render.studio_ambient": "Постоянная яркость окружения", +diff --git a/assets/locales/sr.json b/assets/locales/sr.json +index 247fe30b..732104ca 100644 +--- a/assets/locales/sr.json ++++ b/assets/locales/sr.json +@@ -2159,7 +2159,7 @@ + "render.cpu_point_help": "До осам тачкастих светала, додатих изабраном усмереном осветљењу. Растојања су у mm; минимално не сме премашити референтно растојање.", + "render.cpu_primary_samples": "Узорци ивица по пикселу", + "render.cpu_progressive": "CPU прогресивно", +- "render.cpu_progressive_help": "Акумулира постојећи CPU интегратор у пролазима од по једног примарног узорка. Изабране рефлексије захтевају један узорак; површинска светла, диелектрици и анизотропија захтевају Једна слика.", ++ "render.cpu_progressive_help": "Акумулира постојећи CPU интегратор у пролазима од по једног примарног узорка. Изабране рефлексије захтевају један узорак; диелектрици и анизотропија захтевају Једна слика.", + "render.cpu_progressive_limits": "Највише 1.048.576 пиксела и 16.777.216 израчунавања пиксел × узорак. Промена узорака никад аутоматски не мења величину слике.", + "render.cpu_progressive_seed": "CPU семе узорковања", + "render.cpu_progressive_spp": "узорака по пикселу", +@@ -2677,8 +2677,8 @@ + "render.post_vignette": "Вињета", + "render.preview": "Интегрисани преглед", + "render.preview_help": "Растер сенчење и мешана провидност. Преламање, HDRI и завршно рендеровање још нису доступни.", +- "render.preview_image_settings_help": "Преглед уживо задржава фиксно осветљење студија. Експозиција и осветљење слике примењују се на посао слике када кликнете Провери или Покрени.", +- "render.preview_lighting_help": "Преглед уживо приказује само директно светло, без сенки.", ++ "render.preview_image_settings_help": "Преглед модела користи приближно директно осветљење. Када је укључено, интерактивно рендеровање на CPU ажурира привремену слику помоћу подржаних поставки слике, укључујући експозицију. Завршно рендеровање је одвојено.", ++ "render.preview_lighting_help": "Преглед модела користи директно осветљење без сенки. Интерактивно рендеровање на CPU користи подржане поставке слике за привремену слику.", + "render.preview_retry": "Поново покушај преглед уживо", + "render.preview_unavailable_help": "Преглед уживо није доступан. Сачувана подешавања и контроле посла слике остају доступни. Промените сцену или изричито покушајте поново; одбијена сцена се не гради поново у сваком кадру.", + "render.preview_upload": "Подаци врхова прегледа уживо", +@@ -2906,7 +2906,7 @@ + "render.stage_panels.use_budget": "Користи овај буџет", + "render.stage_panels.use_maps": "Користи GPU мапе", + "render.stage_panels.use_uniform": "Користи уједначено", +- "render.stage_preview_note": "Интегрисани преглед · директно светло", ++ "render.stage_preview_note": "Преглед рендеровања", + "render.state_completed": "Завршена слика", + "render.state_in_progress": "Слика у току", + "render.state_model": "Преглед модела", +diff --git a/assets/locales/sv.json b/assets/locales/sv.json +index f5b76fd4..ec070913 100644 +--- a/assets/locales/sv.json ++++ b/assets/locales/sv.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "Upp till åtta punktljus, som läggs till den valda riktade belysningen. Avstånd anges i mm; minimiavståndet får inte överstiga referensavståndet.", + "render.cpu_primary_samples": "Kantprov per pixel", + "render.cpu_progressive": "Progressiv CPU", +- "render.cpu_progressive_help": "Ackumulera den befintliga CPU-integratorn i omgångar om ett primärt prov. Valda reflektioner kräver ett prov; ytljus, dielektrika och anisotropi kräver Enstaka bild.", ++ "render.cpu_progressive_help": "Ackumulera den befintliga CPU-integratorn i omgångar om ett primärt prov. Valda reflektioner kräver ett prov; dielektrika och anisotropi kräver Enstaka bild.", + "render.cpu_progressive_limits": "Högst 1 048 576 pixlar och 16 777 216 utvärderingar av pixel × prov. Ändrat antal prov ändrar aldrig bildens storlek automatiskt.", + "render.cpu_progressive_seed": "Startvärde för CPU-sampling", + "render.cpu_progressive_spp": "prov per pixel", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "Vinjettering", + "render.preview": "Integrerad förhandsvisning", + "render.preview_help": "Rasterskuggning och blandad transparens. Refraktion, HDRI och slutrendering är inte tillgängliga ännu.", +- "render.preview_image_settings_help": "Liveförhandsvisningen behåller fast studiobelysning. Exponering och bildbelysning tillämpas på bildjobbet när du väljer Kontrollera eller Starta.", +- "render.preview_lighting_help": "Liveförhandsvisningen visar endast direkt ljus och inga skuggor.", ++ "render.preview_image_settings_help": "Modellförhandsvisningen använder en approximation av direkt belysning. När interaktiv rendering på CPU är aktiverad uppdateras en preliminär bild med de bildinställningar som stöds, inklusive exponering. Slutlig rendering är separat.", ++ "render.preview_lighting_help": "Modellförhandsvisningen använder direkt belysning utan skuggor. Interaktiv rendering på CPU använder de bildinställningar som stöds för sin preliminära bild.", + "render.preview_retry": "Försök igen med liveförhandsvisning", + "render.preview_unavailable_help": "Liveförhandsvisningen är inte tillgänglig. Sparade uppsättningar och bildjobbens kontroller förblir åtkomliga. Ändra scenen eller försök uttryckligen igen; en avvisad scen byggs inte om vid varje bildruta.", + "render.preview_upload": "Vertexdata för liveförhandsvisning", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "Använd den här budgeten", + "render.stage_panels.use_maps": "Använd GPU-kartor", + "render.stage_panels.use_uniform": "Använd enhetlig", +- "render.stage_preview_note": "Integrerad förhandsvisning · direkt belysning", ++ "render.stage_preview_note": "Renderingsförhandsvisning", + "render.state_completed": "Färdig bild", + "render.state_in_progress": "Bild under rendering", + "render.state_model": "Modellförhandsvisning", +diff --git a/assets/locales/tr.json b/assets/locales/tr.json +index 3611b1ae..4ea2729e 100644 +--- a/assets/locales/tr.json ++++ b/assets/locales/tr.json +@@ -2163,7 +2163,7 @@ + "render.cpu_point_help": "Seçili yönlü aydınlatmaya eklenen en fazla sekiz nokta ışık. Mesafeler mm cinsindendir; en az mesafe referans mesafeyi aşmamalıdır.", + "render.cpu_primary_samples": "Piksel başına kenar örneği", + "render.cpu_progressive": "CPU artımlı", +- "render.cpu_progressive_help": "Mevcut CPU tümleştiricisini tek birincil örnekli geçişlerde biriktirin. Seçili yansımalar tek örnek gerektirir; alan ışıkları, dielektrikler ve anizotropi Tek görüntü gerektirir.", ++ "render.cpu_progressive_help": "Mevcut CPU tümleştiricisini tek birincil örnekli geçişlerde biriktirin. Seçili yansımalar tek örnek gerektirir; dielektrikler ve anizotropi Tek görüntü gerektirir.", + "render.cpu_progressive_limits": "En fazla 1.048.576 piksel ve 16.777.216 piksel × örnek değerlendirmesi. Örnekleri değiştirmek görüntüyü asla otomatik yeniden boyutlandırmaz.", + "render.cpu_progressive_seed": "CPU örnekleme tohumu", + "render.cpu_progressive_spp": "piksel başına örnek", +@@ -2681,8 +2681,8 @@ + "render.post_vignette": "Vinyet", + "render.preview": "Yerleşik önizleme", + "render.preview_help": "Harmanlanmış saydamlıkla raster görüntü. Kırılma, HDRI ve son render henüz kullanılamıyor.", +- "render.preview_image_settings_help": "Canlı Önizleme, sabit stüdyo aydınlatmasını korur. Pozlama ve görüntü aydınlatması, Kontrol veya Başlat sırasında görüntü işine uygulanır.", +- "render.preview_lighting_help": "Canlı önizleme yalnızca doğrudan ışığı gösterir, gölge göstermez.", ++ "render.preview_image_settings_help": "Model önizlemesi yaklaşık doğrudan aydınlatma kullanır. Etkinleştirildiğinde CPU üzerinde etkileşimli işleme, pozlama dahil desteklenen görüntü ayarlarıyla geçici bir görüntüyü günceller. Son işleme ayrıdır.", ++ "render.preview_lighting_help": "Model önizlemesi gölgesiz doğrudan aydınlatma kullanır. CPU üzerinde etkileşimli işleme, geçici görüntüsü için desteklenen görüntü ayarlarını kullanır.", + "render.preview_retry": "Canlı önizlemeyi yeniden dene", + "render.preview_unavailable_help": "Canlı önizleme kullanılamıyor. Kaydedilmiş kurulumlar ve görüntü işi kontrolleri erişilebilir kalır. Sahneyi değiştirin veya açıkça yeniden deneyin; reddedilen sahne her karede yeniden kurulmaz.", + "render.preview_upload": "Canlı önizleme tepe noktası yükü", +@@ -2910,7 +2910,7 @@ + "render.stage_panels.use_budget": "Bu bütçeyi kullan", + "render.stage_panels.use_maps": "GPU haritalarını kullan", + "render.stage_panels.use_uniform": "Tekdüzeyi kullan", +- "render.stage_preview_note": "Entegre önizleme · doğrudan ışık", ++ "render.stage_preview_note": "İşleme önizlemesi", + "render.state_completed": "Tamamlanan görüntü", + "render.state_in_progress": "Görüntü hazırlanıyor", + "render.state_model": "Model Önizlemesi", +diff --git a/assets/locales/uk.json b/assets/locales/uk.json +index d1d384fa..1fda5f2a 100644 +--- a/assets/locales/uk.json ++++ b/assets/locales/uk.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "До восьми точкових джерел світла, що додаються до вибраного напрямленого освітлення. Відстані — у мм; мінімум не має перевищувати опорну відстань.", + "render.cpu_primary_samples": "Вибірок краю на піксель", + "render.cpu_progressive": "Прогресивний CPU", +- "render.cpu_progressive_help": "Накопичувати наявний інтегратор CPU проходами по одній первинній вибірці. Вибрані відбиття потребують однієї вибірки; площинні джерела світла, діелектрики та анізотропія потребують режиму «Одне зображення».", ++ "render.cpu_progressive_help": "Накопичувати наявний інтегратор CPU проходами по одній первинній вибірці. Вибрані відбиття потребують однієї вибірки; діелектрики та анізотропія потребують режиму «Одне зображення».", + "render.cpu_progressive_limits": "Не більше 1,048,576 пікселів і 16,777,216 обчислень «піксель × вибірка». Зміна кількості вибірок ніколи не змінює розмір зображення автоматично.", + "render.cpu_progressive_seed": "Початкове значення вибірки CPU", + "render.cpu_progressive_spp": "вибірок на піксель", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "Віньєтування", + "render.preview": "Вбудований попередній перегляд", + "render.preview_help": "Растрове затінення та змішана прозорість. Заломлення, HDRI та фінальний рендеринг поки недоступні.", +- "render.preview_image_settings_help": "Живий перегляд зберігає фіксоване студійне освітлення. Експозиція та освітлення зображення застосовуються до завдання зображення під час перевірки або запуску.", +- "render.preview_lighting_help": "Живий попередній перегляд показує лише пряме світло й без тіней.", ++ "render.preview_image_settings_help": "Попередній перегляд моделі використовує наближене пряме освітлення. Коли ввімкнено інтерактивний рендеринг на CPU, тимчасове зображення оновлюється з підтримуваними налаштуваннями зображення, зокрема експозицією. Фінальний рендеринг виконується окремо.", ++ "render.preview_lighting_help": "Попередній перегляд моделі використовує пряме освітлення без тіней. Інтерактивний рендеринг на CPU використовує підтримувані налаштування зображення для тимчасового зображення.", + "render.preview_retry": "Повторити живий перегляд", + "render.preview_unavailable_help": "Живий перегляд недоступний. Збережені налаштування та керування завданням зображення залишаються доступними. Змініть сцену або явно повторіть спробу; відхилена сцена не перебудовується в кожному кадрі.", + "render.preview_upload": "Дані вершин живого перегляду", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "Використати цей бюджет", + "render.stage_panels.use_maps": "Використати карти GPU", + "render.stage_panels.use_uniform": "Використати однорідний", +- "render.stage_preview_note": "Інтегрований попередній перегляд · пряме світло", ++ "render.stage_preview_note": "Попередній перегляд рендерингу", + "render.state_completed": "Готове зображення", + "render.state_in_progress": "Зображення створюється", + "render.state_model": "Попередній перегляд моделі", +diff --git a/assets/locales/vi.json b/assets/locales/vi.json +index f86b515e..f80fe391 100644 +--- a/assets/locales/vi.json ++++ b/assets/locales/vi.json +@@ -2296,7 +2296,7 @@ + "render.cpu_point_help": "Tối đa tám nguồn sáng điểm, được bổ sung vào ánh sáng định hướng đã chọn. Khoảng cách tính bằng mm; khoảng cách tối thiểu không được vượt quá khoảng cách tham chiếu.", + "render.cpu_primary_samples": "Số mẫu cạnh trên mỗi pixel", + "render.cpu_progressive": "Kết xuất lũy tiến trên CPU", +- "render.cpu_progressive_help": "Tích lũy bộ tích phân CPU hiện có theo từng lượt một mẫu chính. Các phản xạ đã chọn yêu cầu một mẫu; nguồn sáng vùng, chất điện môi và bất đẳng hướng yêu cầu chế độ 'Hình ảnh đơn'.", ++ "render.cpu_progressive_help": "Tích lũy bộ tích phân CPU hiện có theo từng lượt một mẫu chính. Các phản xạ đã chọn yêu cầu một mẫu; chất điện môi và bất đẳng hướng yêu cầu chế độ 'Hình ảnh đơn'.", + "render.cpu_progressive_limits": "Tối đa 1.048.576 pixel và tổng số tính toán (pixel × mẫu) không quá 16.777.216. Thay đổi số mẫu không bao giờ tự động đổi kích thước ảnh.", + "render.cpu_progressive_seed": "Hạt giống lấy mẫu CPU", + "render.cpu_progressive_spp": "Mẫu trên mỗi pixel", +@@ -2925,8 +2925,8 @@ + "render.post_vignette": "Hiệu ứng tối góc (Vignette)", + "render.preview": "Xem trước tích hợp", + "render.preview_help": "Đổ bóng raster và trộn độ trong suốt. Khúc xạ, HDRI và kết xuất cuối cùng hiện chưa khả dụng.", +- "render.preview_image_settings_help": "Xem trước trực tiếp giữ nguyên ánh sáng studio cố định. Độ phơi sáng và ánh sáng hình ảnh sẽ áp dụng cho tác vụ khi bạn Kiểm tra hoặc Bắt đầu.", +- "render.preview_lighting_help": "Bản xem trước trực tiếp chỉ hiện ánh sáng trực tiếp và không có bóng đổ.", ++ "render.preview_image_settings_help": "Bản xem trước mô hình dùng ánh sáng trực tiếp gần đúng. Khi được bật, kết xuất tương tác trên CPU cập nhật ảnh tạm bằng các thiết lập ảnh được hỗ trợ, gồm độ phơi sáng. Kết xuất cuối cùng được thực hiện riêng.", ++ "render.preview_lighting_help": "Bản xem trước mô hình dùng ánh sáng trực tiếp không có bóng. Kết xuất tương tác trên CPU dùng các thiết lập ảnh được hỗ trợ cho ảnh tạm.", + "render.preview_retry": "Thử lại xem trước trực tiếp", + "render.preview_unavailable_help": "Bản xem trước trực tiếp không khả dụng. Các thiết lập đã lưu và điều khiển tác vụ ảnh vẫn có thể truy cập. Hãy thay đổi cảnh hoặc thử lại; cảnh bị từ chối sẽ không được dựng lại trên mỗi khung hình.", + "render.preview_upload": "Dung lượng đỉnh xem trước trực tiếp", +@@ -3190,7 +3190,7 @@ + "render.stage_panels.use_budget": "Sử dụng ngân sách này", + "render.stage_panels.use_maps": "Sử dụng bản đồ GPU", + "render.stage_panels.use_uniform": "Sử dụng diện mạo đồng nhất", +- "render.stage_preview_note": "Xem trước tích hợp · ánh sáng trực tiếp", ++ "render.stage_preview_note": "Xem trước kết xuất", + "render.state_completed": "Ảnh đã hoàn tất", + "render.state_in_progress": "Ảnh đang tạo", + "render.state_model": "Xem trước mô hình", +diff --git a/assets/locales/zh-TW.json b/assets/locales/zh-TW.json +index 5022e714..1eb67f7e 100644 +--- a/assets/locales/zh-TW.json ++++ b/assets/locales/zh-TW.json +@@ -2144,7 +2144,7 @@ + "render.cpu_point_help": "最多八個點光源,疊加於所選的方向光照明之上。距離單位為 mm;最小距離不得超過參考距離。", + "render.cpu_primary_samples": "每像素邊緣取樣數", + "render.cpu_progressive": "CPU 漸進式", +- "render.cpu_progressive_help": "以每輪一個主取樣為單位,累積現有的 CPU 積分器。所選反射需使用一個取樣;面光源、介電質和各向異性需使用「單張影像」。", ++ "render.cpu_progressive_help": "以每輪一個主取樣為單位,累積現有的 CPU 積分器。所選反射需使用一個取樣;介電質和各向異性需使用「單張影像」。", + "render.cpu_progressive_limits": "最多 1,048,576 像素和 16,777,216 次像素 × 取樣評估。變更取樣數不會自動調整影像大小。", + "render.cpu_progressive_seed": "CPU 取樣種子", + "render.cpu_progressive_spp": "取樣/像素", +@@ -2662,8 +2662,8 @@ + "render.post_vignette": "暈影", + "render.preview": "整合預覽", + "render.preview_help": "光柵著色和混合透明度。暫不支援折射、HDRI 和最終彩現。", +- "render.preview_image_settings_help": "即時預覽維持固定的攝影棚照明。曝光與影像照明會在您按下「檢查」或「開始」時套用於影像工作。", +- "render.preview_lighting_help": "即時預覽僅顯示直接光,不含陰影。", ++ "render.preview_image_settings_help": "模型預覽使用近似的直接照明。啟用 CPU 互動式渲染後,會使用曝光等受支援的影像設定更新暫時影像。最終渲染另行執行。", ++ "render.preview_lighting_help": "模型預覽使用無陰影的直接照明。CPU 互動式渲染會將受支援的影像設定用於暫時影像。", + "render.preview_retry": "重試即時預覽", + "render.preview_unavailable_help": "無法使用即時預覽。已儲存的設定與影像工作控制項仍可使用。請變更場景或明確重試;遭拒絕的場景不會在每個影格重新建構。", + "render.preview_upload": "即時預覽頂點資料", +@@ -2891,7 +2891,7 @@ + "render.stage_panels.use_budget": "使用此預算", + "render.stage_panels.use_maps": "使用 GPU 貼圖", + "render.stage_panels.use_uniform": "使用均勻外觀", +- "render.stage_preview_note": "整合式預覽 · 直接光", ++ "render.stage_preview_note": "渲染預覽", + "render.state_completed": "已完成影像", + "render.state_in_progress": "影像進行中", + "render.state_model": "模型預覽", +diff --git a/assets/locales/zh.json b/assets/locales/zh.json +index 1322050e..9174d881 100644 +--- a/assets/locales/zh.json ++++ b/assets/locales/zh.json +@@ -2296,7 +2296,7 @@ + "render.cpu_point_help": "最多可在所选平行光照明基础上添加8个点光源。距离单位为mm,最小距离不得大于参考距离。", + "render.cpu_primary_samples": "每像素边缘采样", + "render.cpu_progressive": "CPU渐进渲染", +- "render.cpu_progressive_help": "使用现有CPU积分器,每轮累积一个主采样。所选反射需要单采样;面光源、电介质和各向异性需要固定图像模式。", ++ "render.cpu_progressive_help": "使用现有CPU积分器,每轮累积一个主采样。所选反射需要单采样;电介质和各向异性需要固定图像模式。", + "render.cpu_progressive_limits": "最多1,048,576像素,像素×采样总数不超过16,777,216。更改采样数不会自动调整图像尺寸。", + "render.cpu_progressive_seed": "CPU采样种子", + "render.cpu_progressive_spp": "每像素采样数", +@@ -2925,8 +2925,8 @@ + "render.post_vignette": "暗角", + "render.preview": "集成预览", + "render.preview_help": "光栅着色和混合透明度。暂不支持折射、HDRI 和最终渲染。", +- "render.preview_image_settings_help": "实时预览使用固定工作室照明。曝光和图像照明在检查或开始时应用于图像任务。", +- "render.preview_lighting_help": "实时预览仅显示直接光照,不显示阴影。", ++ "render.preview_image_settings_help": "模型预览使用近似的直接照明。启用 CPU 交互式渲染后,会使用曝光等受支持的图像设置更新临时图像。最终渲染单独执行。", ++ "render.preview_lighting_help": "模型预览使用无阴影的直接照明。CPU 交互式渲染会将受支持的图像设置用于临时图像。", + "render.preview_retry": "重试实时预览", + "render.preview_unavailable_help": "实时预览不可用,但已保存设置和图像任务控件仍可访问。请修改场景或明确重试;被拒绝的场景不会每帧重建。", + "render.preview_upload": "实时预览顶点数据量", +@@ -3190,7 +3190,7 @@ + "render.stage_panels.use_budget": "使用此预算", + "render.stage_panels.use_maps": "使用 GPU 贴图", + "render.stage_panels.use_uniform": "使用均匀外观", +- "render.stage_preview_note": "集成预览 · 直接光照", ++ "render.stage_preview_note": "渲染预览", + "render.state_completed": "已完成图像", + "render.state_in_progress": "图像生成中", + "render.state_model": "模型预览", +diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs +index 894ddc76..5175b2f0 100644 +--- a/crates/engine/src/cmd/mod.rs ++++ b/crates/engine/src/cmd/mod.rs +@@ -398,3 +398,7 @@ pub(super) fn reversed_param(p: &Value, key: &str, cmd: &str) -> Result { + serde_json::from_value(value.clone()).map_err(|_| crate::params::bad(cmd, format!("`{key}` must be true or false"))) + }) + } ++ ++pub(crate) fn prepare_interactive(s: &crate::Session, params: &serde_json::Value) -> crate::Result { ++ render::prepare_interactive(s, params) ++} +diff --git a/crates/engine/src/cmd/render.rs b/crates/engine/src/cmd/render.rs +index 71b66993..41075532 100644 +--- a/crates/engine/src/cmd/render.rs ++++ b/crates/engine/src/cmd/render.rs +@@ -124,7 +124,7 @@ CommandSpec::new("render.hdr.inspect", "Inspect HDR Source", resources::inspect) + CommandSpec::new("render.settings.capture_hdr", "Save Render Settings with HDR", resources::capture_settings).icon("settings").doc_only() + .params("name, set: typed CPU/GPU setup patch with hdr/environment unset; path: scoped HDR; expected_sha256?: digest returned by render.hdr.inspect (changed sources refuse); rotation_rad?:0, intensity?:1; samples?:1/4/16/64 for CPU only (default16); assume_linear_srgb?:false for GPU only. Captures immutable bytes and saves resource plus setup atomically in one undo, without a host; returns name/setup/resource metadata, never source bytes"), + CommandSpec::new("render.preflight", "Check Render Request", jobs::preflight).icon("inspect").noundo().doc_only() +- .params("setup?: saved name OR settings?: full RenderSetup. A typed job selects raster/cpu_raytrace/gpu_path and its numerical options plus embedded HDR before dispatch; only replace and transient studio_weights may accompany it. Without job, the legacy runtime controls below remain available. See docs/render-settings.md. studio_weights?: three finite 0..1 visibility weights for raster or implicit GPU studio sources only; never saved. integrator?: raster (default) or raytrace; progressive?: false (registered GPU path, CPU integrator/LED options are mutually exclusive); samples?: 1..4096; max_depth?: 1..16; seed?: u32 for progressive; raytrace?: bounded runtime progressive/primary_samples/lights/punctual_lights/area_lights/area_samples/seed/exposure_ev/shadows/reflections/anisotropic_faces/emissions/surface_effects/dielectrics/environment options, only with raytrace. CPU raytrace.budget?: compact (legacy default), studio or workstation; see docs/render-cpu-resource-profiles.md for explicit image/geometry/memory/work limits. CPU raytrace.progressive?: {samples_per_pixel:1..profile limit, seed:u32}; requires primary_samples:1 and selected reflections.samples:1; no area/LED, anisotropy or dielectrics in this initial mode. See docs/render-cpu-progressive.md; environment?: {path: scoped HDR, expected_sha256?: inspected digest, rotation_radians: 0, intensity: 1, samples: 16} OR {resource: saved HDR digest, rotation_radians, intensity, samples}; embedded resources cannot combine with path/hash; explicit sRGB/D65 HDR primaries required. Opaque CPU preview with selected mirror/rough-specular reflections and certified planar anisotropy. HDR with rough reflections or anisotropy requires fully metallic selected bodies and all effective faces; unsupported combinations refuse. No MIS or GI. CPU runtime dielectrics support only certified thin_sheet/closed_box boundaries with explicit IOR and Beer absorption; see docs/render-raytrace-dielectrics.md. CPU emissions are visible radiance only; surface_effects change roughness/shading normals without geometry changes. led_strip?: continuous world-mm LED rectangle recipe; led_samples?: 1/4/16/64 for the whole strip, default16. At most8directional+8punctual+4rectangle/LED sources; shared area N. See docs/render-light-union.md. transparent_background?: false; replace?: false. With progressive:true, raytrace instead accepts GPU dielectrics/clear_coats/textures; environment instead accepts tagged hdr/embedded_hdr/sky with rotation_rad/intensity; file hdr supports expected_sha256, embedded_hdr uses a document resource digest. See docs/render-hdr-resources.md. GPU lens, studio lighting, tone_map, denoise, bounded finishing/backdrop and linear_exr retention are also available. GPU adaptive?: {pilot_samples:16..256,min_samples:16..samples,relative_error:0..1,absolute_error:0.000001..1000000,coverage_error:0.001..0.25} allocates independent production budgets; pilots are discarded, not a certified error guarantee. transmission_samples?:1|2|4 stratifies the first Fresnel branch with extra path cost. volume?:{min_mm:[x,y,z],max_mm:[x,y,z],extinction_per_mm:0..1000,scattering_albedo:[r,g,b],anisotropy:-0.95..0.95} is one finite homogeneous world-mm medium; active media require explicit lighting/environment and refuse glass, denoise and multiple transmission strata. These fields also persist in GPU job.options. See docs/render-materials/TRANSPORT-MASTER-BATCH-2026-10-23.md; see docs/render-transmission.md, render-environment.md, render-runtime-textures.md, render-thin-lens.md, render-studio-lighting.md and render-denoise.md. Optional CPU raytracing requires a raytrace-cpu build and native host, checked before scene capture. Stale geometry is rejected. See docs/render-jobs.md"), ++ .params("setup?: saved name OR settings?: full RenderSetup. A typed job selects raster/cpu_raytrace/gpu_path and its numerical options plus embedded HDR before dispatch; only replace and transient studio_weights may accompany it. Without job, the legacy runtime controls below remain available. See docs/render-settings.md. studio_weights?: three finite 0..1 visibility weights for raster or implicit GPU studio sources only; never saved. integrator?: raster (default) or raytrace; progressive?: false (registered GPU path, CPU integrator/LED options are mutually exclusive); samples?: 1..4096; max_depth?: 1..16; seed?: u32 for progressive; raytrace?: bounded runtime progressive/primary_samples/lights/punctual_lights/area_lights/area_samples/seed/exposure_ev/shadows/reflections/anisotropic_faces/emissions/surface_effects/dielectrics/environment options, only with raytrace. CPU raytrace.budget?: compact (legacy default), studio or workstation; see docs/render-cpu-resource-profiles.md for explicit image/geometry/memory/work limits. CPU raytrace.progressive?: {samples_per_pixel:1..profile limit, seed:u32}; requires primary_samples:1 and selected reflections.samples:1; bounded area/LED direct lights retain their existing source and emitter-sample limits; anisotropy and dielectrics require fixed sampling. See docs/render-cpu-progressive.md; environment?: {path: scoped HDR, expected_sha256?: inspected digest, rotation_radians: 0, intensity: 1, samples: 16} OR {resource: saved HDR digest, rotation_radians, intensity, samples}; embedded resources cannot combine with path/hash; explicit sRGB/D65 HDR primaries required. Opaque CPU preview with selected mirror/rough-specular reflections and certified planar anisotropy. HDR with rough reflections or anisotropy requires fully metallic selected bodies and all effective faces; unsupported combinations refuse. No MIS or GI. CPU runtime dielectrics support only certified thin_sheet/closed_box boundaries with explicit IOR and Beer absorption; see docs/render-raytrace-dielectrics.md. CPU emissions are visible radiance only; surface_effects change roughness/shading normals without geometry changes. led_strip?: continuous world-mm LED rectangle recipe; led_samples?: 1/4/16/64 for the whole strip, default16. At most8directional+8punctual+4rectangle/LED sources; shared area N. See docs/render-light-union.md. transparent_background?: false; replace?: false. With progressive:true, raytrace instead accepts GPU dielectrics/clear_coats/textures; environment instead accepts tagged hdr/embedded_hdr/sky with rotation_rad/intensity; file hdr supports expected_sha256, embedded_hdr uses a document resource digest. See docs/render-hdr-resources.md. GPU lens, studio lighting, tone_map, denoise, bounded finishing/backdrop and linear_exr retention are also available. GPU adaptive?: {pilot_samples:16..256,min_samples:16..samples,relative_error:0..1,absolute_error:0.000001..1000000,coverage_error:0.001..0.25} allocates independent production budgets; pilots are discarded, not a certified error guarantee. transmission_samples?:1|2|4 stratifies the first Fresnel branch with extra path cost. volume?:{min_mm:[x,y,z],max_mm:[x,y,z],extinction_per_mm:0..1000,scattering_albedo:[r,g,b],anisotropy:-0.95..0.95} is one finite homogeneous world-mm medium; active media require explicit lighting/environment and refuse glass, denoise and multiple transmission strata. These fields also persist in GPU job.options. See docs/render-materials/TRANSPORT-MASTER-BATCH-2026-10-23.md; see docs/render-transmission.md, render-environment.md, render-runtime-textures.md, render-thin-lens.md, render-studio-lighting.md and render-denoise.md. Optional CPU raytracing requires a raytrace-cpu build and native host, checked before scene capture. Stale geometry is rejected. See docs/render-jobs.md"), + CommandSpec::new("render.start", "Render Image", jobs::start).key("R").noundo().doc_only().at("RENDER", "IMAGE").icon("render_image") + .params("Same request as render.preflight. Captures an immutable product scene and queues a bounded image job. Returns its session-scoped job identity, captured scene_generation and progress. Does not change the design. See docs/render-jobs.md"), + CommandSpec::new("render.status", "Render Progress", jobs::status).icon("list").noundo().doc_only() +@@ -418,3 +418,7 @@ mod settings_tests; + + #[cfg(test)] + mod job_tests; ++ ++pub(super) fn prepare_interactive(s: &crate::Session, params: &serde_json::Value) -> crate::Result { ++ jobs::interactive(s, params) ++} +diff --git a/crates/engine/src/cmd/render/jobs.rs b/crates/engine/src/cmd/render/jobs.rs +index b0b0b29d..efb547e5 100644 +--- a/crates/engine/src/cmd/render/jobs.rs ++++ b/crates/engine/src/cmd/render/jobs.rs +@@ -99,6 +99,91 @@ fn lower_led(input: &mut Start, command: &str) -> Result<()> { + Ok(()) + } + ++/// Pure preview lowering. Parse the existing CPU wire before changing its sampling; ++/// unsupported effects remain errors rather than disappearing from the request. ++fn interactive_params(params: &Value) -> Result { ++ let command = "render.interactive"; ++ let mut input: Start = serde_json::from_value(params.clone()).map_err(|e| bad(command, e.to_string()))?; ++ let object = params.as_object().ok_or_else(|| bad(command, "Interactive requires an explicit CPU request object"))?; ++ if object.contains_key("setup") || object.contains_key("replace") { ++ return Err(bad(command, "Interactive requires an explicit settings snapshot without setup or replace")); ++ } ++ if input.integrator != Integrator::Raytrace || input.progressive || input.transparent_background { ++ return Err(bad(command, "Interactive requires opaque CPU ray tracing, not GPU progressive or raster rendering")); ++ } ++ if input.studio_weights.is_some() || input.denoise || input.samples.is_some() || input.max_depth.is_some() || input.seed.is_some() { ++ return Err(bad(command, "Interactive cannot accept GPU studio, denoise or sampling controls")); ++ } ++ let mut settings = input.settings.take().ok_or_else(|| bad(command, "Interactive requires explicit settings"))?; ++ if settings.job.is_some() { ++ return Err(bad(command, "Interactive requires a lowered CPU runtime request with settings.job: null")); ++ } ++ if settings.mode != solidcraft_render::RenderMode::Preview || settings.format != solidcraft_render::RenderFormat::Png { ++ return Err(bad(command, "Interactive CPU requires the existing Preview/Image/PNG profile")); ++ } ++ // Keep the existing CPU runtime exposure authority; never silently neutralize ++ // saved/common controls in order to make a request acceptable. ++ if settings.exposure_ev != 0.0 || settings.environment_rotation != 0.0 || settings.environment_intensity != 1.0 { ++ return Err(bad(command, "Interactive CPU exposure belongs to raytrace.exposure_ev; environment controls belong to the captured input")); ++ } ++ lower_led(&mut input, command)?; ++ if let Some(environment) = &input.environment { ++ // Same numerical controls as EnvironmentInput::new, checked before a path ++ // can be read. Resource bytes and primaries remain prepare's responsibility. ++ if !environment.rotation_radians.is_finite() ++ || !environment.intensity.is_finite() ++ || !(0.0..=64.0).contains(&environment.intensity) ++ || !matches!(environment.samples, 1 | 4 | 16 | 64) ++ { ++ return Err(bad(command, "invalid Interactive environment controls")); ++ } ++ if input.raytrace.as_ref().is_some_and(|options| options.environment.is_some()) { ++ return Err(bad(command, "choose either captured HDR or constant CPU environment")); ++ } ++ } ++ let final_request = ImageRequest { ++ camera: settings.camera, ++ width: settings.width, ++ height: settings.height, ++ background: settings.background, ++ transparent_background: input.transparent_background, ++ integrator: input.integrator, ++ raytrace: input.raytrace, ++ studio_weights: input.studio_weights, ++ environment: None, ++ textures: None, ++ }; ++ let preview = solidcraft_render::job::interactive::cpu_request(&final_request).map_err(job_error)?; ++ settings.width = preview.width; ++ settings.height = preview.height; ++ let budget = preview.raytrace.as_ref().map_or(solidcraft_render::job::CpuBudget::Compact, |options| options.budget); ++ settings.validate_for_cpu(budget).map_err(|e| bad(command, e.to_string()))?; ++ // Preserve every original field after strict deserialization. Only the LED ++ // recipe has been consumed into real area lights; do not lower it twice. ++ let mut lowered = object.clone(); ++ lowered.remove("led_strip"); ++ lowered.remove("led_samples"); ++ lowered.insert("settings".into(), serde_json::to_value(settings).map_err(|e| bad(command, e.to_string()))?); ++ lowered.insert("raytrace".into(), serde_json::to_value(preview.raytrace).map_err(|e| bad(command, e.to_string()))?); ++ Ok(Value::Object(lowered)) ++} ++ ++/// Capture/admit only. The engine's Interactive owner submits outside the final ++/// registry; this helper never starts, replaces, cancels or exports a job. ++pub(super) fn interactive(s: &Session, params: &Value) -> Result { ++ let params = interactive_params(params)?; ++ let prepared = prepare(s, ¶ms, "render.interactive")?; ++ if prepared.executor.as_str() != "cpu-raytrace" { ++ return Err(bad("render.interactive", "Interactive requires the installed cpu-raytrace executor")); ++ } ++ Ok(crate::render_interactive::Prepared { ++ scene: prepared.scene, ++ request: prepared.request, ++ options: prepared.options, ++ environment: prepared.environment, ++ }) ++} ++ + #[cfg(test)] + mod union_lowering_tests { + use super::*; +@@ -123,6 +208,179 @@ mod union_lowering_tests { + assert!(input.led_strip.is_none() && input.led_samples.is_none()); + assert_eq!(wire["environment"]["path"], json!("unopened.hdr")); + } ++ fn interactive_final_wire() -> Value { ++ let camera = solidcraft_render::Camera { fov: 0.8, ..Default::default() }; ++ json!({"integrator":"raytrace","settings":{ ++ "width":3840,"height":2160,"camera":camera,"background":[20,40,60],"job":null, ++ "stage":[{"id":"floor","center_mm":[0.0,0.0,-5.0],"half_u_mm":[40.0,0.0,0.0], ++ "half_v_mm":[0.0,40.0,0.0],"reflectance_linear":[0.1,0.2,0.3]}]}, ++ "raytrace":{"primary_samples":4,"shadows":false,"exposure_ev":1.25,"lights":[], ++ "reflections":{"bodies":[{"body":"receiver","mode":"mirror"}],"samples":16,"max_bounces":3}, ++ "punctual_lights":[{"position_mm":[0.0,0.0,20.0],"color":[1.0,0.5,0.25],"intensity":2.0, ++ "reference_distance_mm":20.0,"minimum_distance_mm":0.01}], ++ "emissions":[{"body_index":0,"body":"receiver","color":[0.2,0.4,0.8],"strength":3.0}], ++ "surface_effects":[{"body":"receiver","repeat_mm":[2.0,3.0,4.0],"roughness_amplitude":0.1,"bump_amplitude_mm":0.01}]}, ++ "environment":{"path":"unopened-original.hdr","expected_sha256":"a".repeat(64), ++ "rotation_radians":0.75,"intensity":2.0,"samples":16}}) ++ } ++ ++ #[test] ++ fn interactive_fits_4k_before_admission_and_preserves_final_wire_and_transport() { ++ let wire = interactive_final_wire(); ++ let original = wire.clone(); ++ let lowered = interactive_params(&wire).unwrap(); ++ let before: Start = serde_json::from_value(wire.clone()).unwrap(); ++ let after: Start = serde_json::from_value(lowered.clone()).unwrap(); ++ let final_settings = before.settings.unwrap(); ++ let preview_settings = after.settings.unwrap(); ++ assert_eq!((final_settings.width, final_settings.height), (3840, 2160)); ++ assert_eq!((preview_settings.width, preview_settings.height), (1024, 576)); ++ assert!(before.raytrace.as_ref().unwrap().budget.validate_image(3840, 2160, None).is_err(), "Compact final exceeds pixel cap"); ++ let mut expected_settings = final_settings; ++ expected_settings.width = 1024; ++ expected_settings.height = 576; ++ assert_eq!(preview_settings, expected_settings, "camera, stage, background and other settings remain exact"); ++ let mut expected_options = before.raytrace.unwrap(); ++ expected_options.primary_samples = 1; ++ expected_options.progressive = Some(Default::default()); ++ expected_options.reflections.as_mut().unwrap().samples = 1; ++ assert_eq!(after.raytrace.unwrap(), expected_options, "no lighting, emission, shading effect or EV is discarded"); ++ assert_eq!(lowered["environment"], wire["environment"], "unopened HDR path and expected digest stay pinned"); ++ assert_eq!(lowered["raytrace"]["progressive"], json!({"samples_per_pixel":16,"seed":0})); ++ assert_eq!(wire, original); ++ } ++ ++ #[test] ++ fn interactive_small_and_extreme_aspects_fit_without_enlarging_or_zero_dimensions() { ++ for (width, height, expected) in [(320, 200, (320, 200)), (4096, 1, (1024, 1)), (1, 4096, (1, 1024))] { ++ let wire = json!({"integrator":"raytrace","settings":{"width":width,"height":height}}); ++ let output = interactive_params(&wire).unwrap(); ++ assert_eq!((output["settings"]["width"].as_u64().unwrap(), output["settings"]["height"].as_u64().unwrap()), (expected.0, expected.1)); ++ } ++ } ++ ++ #[test] ++ fn interactive_refuses_alternate_authorities_and_unknown_fields_without_io() { ++ let s = Session::default(); ++ let base = interactive_final_wire(); ++ for (key, value) in [ ++ ("setup", json!(null)), ++ ("setup", json!("Saved")), ++ ("replace", json!(false)), ++ ("replace", json!(true)), ++ ("integrator", json!("raster")), ++ ("progressive", json!(true)), ++ ("transparent_background", json!(true)), ++ ("denoise", json!(true)), ++ ("samples", json!(1)), ++ ("max_depth", json!(2)), ++ ("seed", json!(0)), ++ ("studio_weights", json!([1, 1, 1])), ++ ("unknown", json!(true)), ++ ("lens", json!(null)), ++ ] { ++ let mut wire = base.clone(); ++ wire[key] = value; ++ let error = match interactive(&s, &wire) { ++ Err(error) => error.to_string(), ++ Ok(_) => panic!("Interactive accepted conflicting input {key}"), ++ }; ++ assert!(!error.contains("could not read") && !error.contains("no image host"), "refuse before host/IO: {key}: {error}"); ++ } ++ for settings in [ ++ json!(null), ++ json!({"job":{"method":"cpu_raytrace"}}), ++ json!({"job":{"method":"gpu_path"}}), ++ json!({"exposure_ev":1.0}), ++ json!({"environment_rotation":1.0}), ++ json!({"width":0}), ++ json!({"mode":"final"}), ++ json!({"format":"exr"}), ++ ] { ++ let mut wire = base.clone(); ++ wire["settings"] = settings; ++ assert!(interactive_params(&wire).is_err()); ++ } ++ let mut missing = base.clone(); ++ missing.as_object_mut().unwrap().remove("settings"); ++ assert!(interactive_params(&missing).is_err()); ++ for wire in [json!(null), json!([]), json!(false)] { ++ assert!(interactive_params(&wire).is_err()); ++ } ++ assert!(s.render_job_host().is_none()); ++ } ++ ++ #[test] ++ fn interactive_refuses_invalid_or_unsupported_effects_before_unopened_hdr() { ++ let base = interactive_final_wire(); ++ for (key, value) in [ ++ ("primary_samples", json!(0)), ++ ("exposure_ev", json!(33.0)), ++ ( ++ "dielectrics", ++ json!([{"body_index":0,"body_name":"receiver","ior":1.5,"absorption_per_mm":[0,0,0], ++ "boundary":"closed_box","thickness_mm":0}]), ++ ), ++ ( ++ "anisotropic_faces", ++ json!([{"body_index":0,"body_name":"receiver","face":0,"tangent":[1,0,0], ++ "orientation":"zero","roughness_x":0.2,"roughness_y":0.4},null]), ++ ), ++ ("textures", json!([])), ++ ] { ++ let mut wire = base.clone(); ++ wire["raytrace"][key] = value; ++ assert!(interactive_params(&wire).is_err(), "unsupported {key} must not disappear"); ++ } ++ for (key, value) in [("intensity", json!(-1.0)), ("samples", json!(3))] { ++ let mut wire = base.clone(); ++ wire["environment"][key] = value; ++ assert!(interactive_params(&wire).is_err()); ++ } ++ let mut ambiguous = base.clone(); ++ ambiguous["raytrace"]["environment"] = json!({"color":[1.0,1.0,1.0],"intensity":1.0}); ++ assert!(interactive_params(&ambiguous).is_err()); ++ let mut orphaned_led_samples = base; ++ orphaned_led_samples["led_samples"] = json!(16); ++ assert!(interactive_params(&orphaned_led_samples).is_err()); ++ } ++ ++ #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))] ++ #[test] ++ fn interactive_capture_reuses_cpu_scene_stage_and_admission_without_starting_a_job() { ++ let mut s = Session::default(); ++ s.execute("solid.box", &json!({"length":10,"width":8,"height":4,"body_name":"receiver"})).unwrap(); ++ s.execute( ++ "appearance.assign", ++ &json!({"bodies":["receiver"],"color":"#4080c0", ++ "pbr":{"metallic":1.0,"roughness":0.25,"dielectric_ior":1.5}}), ++ ) ++ .unwrap(); ++ s.execute("render.scene", &json!({})).unwrap(); ++ let subject = crate::product_scene::extract(&s).unwrap(); ++ let host = solidcraft_render::job::CpuHost::for_platform().unwrap(); ++ s.set_render_job_host(Some(host.clone())).unwrap(); ++ let mut wire = interactive_final_wire(); ++ wire.as_object_mut().unwrap().remove("environment"); ++ let document = s.doc.clone(); ++ let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty()); ++ let captured = interactive(&s, &wire).unwrap(); ++ assert_eq!((captured.request.width, captured.request.height), (1024, 576)); ++ assert_eq!(captured.request.integrator, Integrator::Raytrace); ++ assert_eq!(captured.request.raytrace.as_ref().unwrap().exposure_ev, 1.25); ++ let body = captured.scene.meshes.iter().find(|mesh| mesh.name == "receiver").unwrap(); ++ assert_eq!(body.surface, subject.meshes[0].surface); ++ assert_eq!(body.faces, subject.meshes[0].faces); ++ assert!(std::sync::Arc::ptr_eq(&body.mesh, &subject.meshes[0].mesh)); ++ assert_eq!(captured.scene.meshes.len(), 2, "subject and render-only floor are both captured"); ++ assert!(captured.scene.meshes.iter().any(|mesh| mesh.name == "__render_stage__/floor")); ++ assert_eq!(captured.options, solidcraft_render::job::JobOptions::default()); ++ assert!(captured.environment.is_none()); ++ assert_eq!(host.admitted_bytes(), 0, "capture validates but does not submit/reserve a job"); ++ assert!(std::sync::Arc::ptr_eq(&document, &s.doc)); ++ assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty())); ++ assert_eq!(wire["settings"]["width"], 3840); ++ } + } + + /// Resolve portable intent before choosing an executor. Legacy requests are left intact; +diff --git a/crates/engine/src/cmd/render_ui.rs b/crates/engine/src/cmd/render_ui.rs +index d6f4f28d..be7ca6e3 100644 +--- a/crates/engine/src/cmd/render_ui.rs ++++ b/crates/engine/src/cmd/render_ui.rs +@@ -1,7 +1,10 @@ + //! Planned Render interactions, with explicit non-mutating refusals. + use super::CommandSpec; + use crate::schema::render_lights::{MuteParams, SoloParams}; +-use crate::schema::{TypedContract, output_schema_for, render_ui::CheckReport}; ++use crate::schema::{ ++ TypedContract, output_schema_for, ++ render_ui::{CheckReport, InteractiveParams}, ++}; + use crate::{Result, Session, params::bad}; + use serde::Deserialize; + use serde_json::{Value, json}; +@@ -48,8 +51,16 @@ macro_rules! waiting { + } + + const CHECK_REPORT: TypedContract = TypedContract::new(); ++const INTERACTIVE: TypedContract = TypedContract::new(); + + pub static COMMANDS: &[CommandSpec] = &[ ++ CommandSpec::new("render.interactive", "Interactive Render", crate::checked!("render.interactive", interactive)) ++ .icon("render_image") ++ .contract(&INTERACTIVE) ++ .output(output_schema_for::) ++ .noundo() ++ .doc_only() ++ .params("action: on|off|pause|resume. Validates and echoes an explicit CPU Interactive preview request for the UI adapter. Headless calls never start, pause or cancel a render job, open UI, or change the design, final render settings or exportable images."), + CommandSpec::new("render.preflight.copy", "Copy Render Check Report", crate::checked!("render.preflight.copy", copy_check)) + .icon("copy") + .contract(&CHECK_REPORT) +@@ -210,3 +221,118 @@ fn output_sections_copy_report_validates_without_design_history_or_job_changes() + assert!(std::sync::Arc::ptr_eq(&doc, &s.doc)); + assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations, s.is_dirty())); + } ++ ++/// The UI adapter owns provisional preview actions; headless execution only echoes. ++fn interactive(_: &mut Session, params: &Value) -> Result { ++ let command = "render.interactive"; ++ if !params.is_object() { ++ return Err(bad(command, "expected an object")); ++ } ++ let request: InteractiveParams = serde_json::from_value(params.clone()).map_err(|error| bad(command, error.to_string()))?; ++ serde_json::to_value(request).map_err(|error| bad(command, error.to_string())) ++} ++ ++#[cfg(test)] ++#[test] ++fn interactive_contract_describes_exact_actions_and_a_nonmutating_echo() { ++ use crate::schema::{input_schema_for, render_ui::Action}; ++ let command = super::find_command("render.interactive").unwrap(); ++ assert!(!command.undoable); ++ assert!(!command.reads_model); ++ assert!(command.planned.is_none()); ++ assert_eq!(command.icon, "render_image"); ++ let contract = command.contract.unwrap(); ++ assert_eq!(contract.allowed_keys().iter().map(String::as_str).collect::>(), ["action"]); ++ assert!(command.output.is_some()); ++ let action_schema = serde_json::to_value(input_schema_for::()).unwrap(); ++ assert_eq!(action_schema["enum"], json!(["on", "off", "pause", "resume"])); ++ let request_schema = serde_json::to_value(input_schema_for::()).unwrap(); ++ assert_eq!(request_schema["additionalProperties"], false); ++ assert_eq!(request_schema["required"], json!(["action"])); ++ let reply_schema = serde_json::to_value(output_schema_for::()).unwrap(); ++ assert_eq!(reply_schema["required"], json!(["action"])); ++ assert_eq!(reply_schema["properties"].as_object().unwrap().keys().map(String::as_str).collect::>(), ["action"]); ++} ++ ++#[cfg(test)] ++#[test] ++fn interactive_valid_and_hostile_requests_preserve_headless_document_history_and_host() { ++ use crate::schema::ParamCheck; ++ let mut session = Session::default(); ++ session.execute("render.settings.set", &json!({"name":"Original","set":{"width":800}})).unwrap(); ++ session.execute("render.settings.set", &json!({"name":"Original","set":{"width":900}})).unwrap(); ++ session.execute("edit.undo", &json!({})).unwrap(); ++ let document = session.doc.clone(); ++ let before = (session.revision, session.undo.len(), session.redo.len(), session.evaluations, session.is_dirty()); ++ assert!(session.render_job_host().is_none()); ++ for level in [ParamCheck::Off, ParamCheck::Warn, ParamCheck::Strict] { ++ session.param_check = level; ++ for action in ["on", "off", "pause", "resume"] { ++ let params = json!({"action":action}); ++ assert_eq!(session.execute("render.interactive", ¶ms).unwrap(), params); ++ } ++ for hostile in [ ++ json!(null), ++ json!(true), ++ json!(0), ++ json!("on"), ++ json!([]), ++ json!(["on"]), ++ json!({}), ++ json!({"action":null}), ++ json!({"action":true}), ++ json!({"action":1e300}), ++ json!({"action":["on"]}), ++ json!({"action":{"on":true}}), ++ json!({"action":"start"}), ++ json!({"action":"On"}), ++ json!({"action":" on"}), ++ json!({"action":"on\n"}), ++ json!({"action":"x".repeat(65536)}), ++ json!({"action":"on","slot":0}), ++ json!({"action":"off","job":{"session":1,"serial":1,"generation":1}}), ++ json!({"action":"pause","replace":true}), ++ json!({"action":"resume","settings":{}}), ++ json!({"action":"on","path":"must-not-be-read.hdr"}), ++ ] { ++ assert!(session.execute("render.interactive", &hostile).is_err(), "{level:?}: {hostile}"); ++ } ++ assert!(std::sync::Arc::ptr_eq(&document, &session.doc)); ++ assert_eq!(before, (session.revision, session.undo.len(), session.redo.len(), session.evaluations, session.is_dirty())); ++ assert!(session.render_job_host().is_none()); ++ } ++} ++ ++#[cfg(test)] ++#[test] ++fn interactive_echo_preserves_a_queued_final_job_and_its_resource_lease() { ++ use solidcraft_render::job::{CpuHost, JobId}; ++ let host = CpuHost::cooperative(); ++ let mut session = Session::default(); ++ session.set_render_job_host(Some(host.clone())).unwrap(); ++ // Queue a tiny raster job without pumping the cooperative host or opening a device. ++ let started = session.execute("render.start", &json!({"settings":{"width":16,"height":16}})).unwrap(); ++ let first_id: JobId = serde_json::from_value(started["job"].clone()).unwrap(); ++ let first = session.render_job_handle(first_id).unwrap(); ++ let status = serde_json::to_value(first.status().unwrap()).unwrap(); ++ let admitted = host.admitted_bytes(); ++ assert!(admitted > 0); ++ let document = session.doc.clone(); ++ let before = (session.revision, session.undo.len(), session.redo.len(), session.evaluations, session.is_dirty()); ++ for action in ["on", "pause", "resume", "off"] { ++ let params = json!({"action":action}); ++ assert_eq!(session.execute("render.interactive", ¶ms).unwrap(), params); ++ assert_eq!(serde_json::to_value(first.status().unwrap()).unwrap(), status); ++ assert_eq!(host.admitted_bytes(), admitted); ++ assert!(session.render_job_host().unwrap().same_host(&host)); ++ assert!(std::sync::Arc::ptr_eq(&document, &session.doc)); ++ assert_eq!(before, (session.revision, session.undo.len(), session.redo.len(), session.evaluations, session.is_dirty())); ++ } ++ assert!(session.execute("render.interactive", &json!({"action":"off","job":first_id})).is_err()); ++ assert_eq!(serde_json::to_value(first.status().unwrap()).unwrap(), status); ++ assert_eq!(host.admitted_bytes(), admitted); ++ let next = session.execute("render.start", &json!({"settings":{"width":16,"height":16}})).unwrap(); ++ let next_id: JobId = serde_json::from_value(next["job"].clone()).unwrap(); ++ assert_eq!(next_id.session, first_id.session); ++ assert_eq!(next_id.serial, first_id.serial + 1, "echo actions must not allocate or replace final job identities"); ++} +diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs +index 296bd363..12be5f40 100644 +--- a/crates/engine/src/lib.rs ++++ b/crates/engine/src/lib.rs +@@ -24,6 +24,7 @@ pub mod occurrences; + pub mod params; + pub mod product_scene; + pub mod recovery; ++pub mod render_interactive; + pub mod render_jobs; + pub mod render_lights; + pub mod sample; +diff --git a/crates/engine/src/render_jobs.rs b/crates/engine/src/render_jobs.rs +index 7ea41531..bf5d65ec 100644 +--- a/crates/engine/src/render_jobs.rs ++++ b/crates/engine/src/render_jobs.rs +@@ -1,13 +1,14 @@ + //! Per-document, transient render ownership. Captured scenes remain immutable when CAD edits + //! continue; callers get the captured revision and must never present it as a newer scene. + ++use crate::render_interactive::{Controller, InteractiveRender, with_controller}; + use solidcraft_render::{ + ExecutorDescriptor, + job::{CpuHost, ErrorCode, HostKind, Integrator, JobError, JobHandle, JobId, JobStatus, Phase, RenderFrame}, + }; + use std::collections::VecDeque; + use std::sync::{ +- Arc, ++ Arc, Weak, + atomic::{AtomicU64, Ordering}, + }; + +@@ -51,6 +52,8 @@ pub(crate) struct Jobs { + /// One explicitly displayed completed result, independent of a newer completion. + /// The existing frame Arc keeps its original host reservation accounted for. + pinned: Option, ++ /// Preview lifetime only; it never joins final live/history/export ownership. ++ interactive: Weak, + } + + impl Default for Jobs { +@@ -66,12 +69,14 @@ impl Default for Jobs { + history: VecDeque::new(), + last_good: None, + pinned: None, ++ interactive: Weak::new(), + } + } + } + + impl Drop for Jobs { + fn drop(&mut self) { ++ let _ = self.revoke_interactive(); + for job in &self.live { + let _ = job.cancel(); + } +@@ -79,6 +84,56 @@ impl Drop for Jobs { + } + + impl Jobs { ++ pub(crate) fn is_interactive_current(&self, controller: &Weak) -> bool { ++ Weak::ptr_eq(&self.interactive, controller) ++ } ++ ++ fn revoke_interactive(&mut self) -> Result<(), JobError> { ++ let previous = std::mem::take(&mut self.interactive); ++ match previous.upgrade() { ++ Some(controller) => with_controller(&controller, |state| state.disable()), ++ None => Ok(()), ++ } ++ } ++ ++ fn suspend_interactive(&self) -> Result<(), JobError> { ++ match self.interactive.upgrade() { ++ Some(controller) => with_controller(&controller, |state| state.set_final_active(true, std::time::Duration::ZERO)), ++ None => Ok(()), ++ } ++ } ++ ++ fn final_active(&self) -> Result { ++ for job in &self.live { ++ if !job.status()?.progress.phase.terminal() { ++ return Ok(true); ++ } ++ } ++ Ok(false) ++ } ++ ++ fn create_interactive(&mut self, document_uid: u64) -> Result { ++ let host = self.host.as_ref().ok_or_else(|| JobError::new(ErrorCode::HostUnavailable, "no CPU image host is installed"))?; ++ if !host.is_available() || host.kind() != HostKind::NativeWorker { ++ return Err(JobError::new(ErrorCode::HostUnavailable, "Interactive CPU requires an available native CPU host")); ++ } ++ host.validate_integrator(Integrator::Raytrace)?; ++ let final_active = self.final_active()?; ++ if document_uid == 0 || self.owner == 0 { ++ return Err(JobError::new(ErrorCode::LimitExceeded, "render session identity exhausted")); ++ } ++ // Use the same allocator as final owners; never reuse the document uid or ++ // scratch owner as a preview namespace. Zero reports allocator exhaustion. ++ let preview_session = owner(); ++ if preview_session == 0 { ++ return Err(JobError::new(ErrorCode::LimitExceeded, "Interactive owner identity exhausted")); ++ } ++ let next = InteractiveRender::new(document_uid, preview_session, final_active)?; ++ self.revoke_interactive()?; ++ self.interactive = next.weak(); ++ Ok(next) ++ } ++ + pub(crate) fn host_for(&self, executor: &solidcraft_render::ExecutorId) -> Option<&CpuHost> { + if executor.as_str() == "cpu-raytrace" { + return self +@@ -154,6 +209,7 @@ impl Jobs { + } + let serial = self.serial.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "render job identity exhausted"))?; + let generation = self.generation.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "render generation exhausted"))?; ++ self.suspend_interactive()?; + let handle = host.submit_with_environment_and_options( + JobId { session: self.owner, serial, generation }, + revision, +@@ -174,6 +230,7 @@ impl Jobs { + source_id: JobId, + presentation: solidcraft_render::job::presentation::Presentation, + ) -> Result { ++ presentation.validate()?; + self.collect()?; + let source = self.handle(source_id)?; + let frame = source.frame()?.ok_or_else(|| JobError::new(ErrorCode::NotCompleted, "regrade requires a completed frame"))?; +@@ -190,6 +247,10 @@ impl Jobs { + } + let serial = self.serial.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "render job identity exhausted"))?; + let generation = self.generation.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "render generation exhausted"))?; ++ if self.owner == 0 { ++ return Err(JobError::new(ErrorCode::LimitExceeded, "render session identity exhausted")); ++ } ++ self.suspend_interactive()?; + let handle = host.submit_regrade(JobId { session: self.owner, serial, generation }, &source, presentation)?; + let status = handle.status()?; + self.serial = serial; +@@ -244,6 +305,18 @@ impl Jobs { + } + + impl crate::Session { ++ /// Explicit activation support. The caller owns one app-wide capture worker. ++ /// This registers a lifetime only; it never captures or starts an image. ++ pub fn interactive_render(&mut self) -> crate::Result { ++ self.render_jobs.create_interactive(self.uid).map_err(job_error) ++ } ++ ++ /// Bounded final-job metadata for current/background document scheduling. ++ /// Retained completed images do not block Interactive; unknown status fails. ++ pub fn render_final_active(&self) -> crate::Result { ++ self.render_jobs.final_active().map_err(job_error) ++ } ++ + /// A host is installed by the application, never by document data or a command. + pub fn set_render_job_host(&mut self, host: Option) -> crate::Result<()> { + if self.render_jobs.host.as_ref().zip(host.as_ref()).is_some_and(|(a, b)| a.same_host(b)) { +@@ -378,3 +451,240 @@ mod displayed_result_tests { + assert!(s.execute("render.result.pin", &json!({"job":reply["job"]})).is_err(), "a pending result is never exportable"); + } + } ++ ++// Original context ownership and real capture integration cases. ++#[cfg(all(test, feature = "raytrace-cpu", not(target_arch = "wasm32")))] ++mod interactive_context_tests { ++ use super::*; ++ use crate::render_interactive::{InteractiveRender, Snapshot, adopt_created}; ++ use serde_json::{Value, json}; ++ use solidcraft_render::job::interactive::{State, VisualRevision}; ++ use std::time::Duration; ++ ++ fn native() -> crate::Result<(crate::Session, CpuHost)> { ++ let host = CpuHost::for_platform().map_err(job_error)?; ++ let mut session = crate::Session::default(); ++ session.set_render_job_host(Some(host.clone()))?; ++ Ok((session, host)) ++ } ++ ++ fn wire(background: [u8; 3]) -> Value { ++ json!({"integrator":"raytrace","settings":{"width":16,"height":16,"background":background},"raytrace":{"lights":[],"shadows":false}}) ++ } ++ ++ fn capture(context: &InteractiveRender, session: &crate::Session, request: &Value) -> crate::Result { ++ context.enable(VisualRevision { scene_generation: session.revision, visual_revision: 1 }, Duration::ZERO)?; ++ let ticket = context ++ .capture(Duration::from_millis(200))? ++ .ok_or_else(|| crate::EngineError::Other("interactive fixture did not produce a capture ticket".into()))?; ++ context.snapshot(session, ticket, request) ++ } ++ ++ fn terminal(job: &JobHandle) -> crate::Result { ++ // Completion watchdog follows existing native job tests; no speed assertion. ++ Ok(job.wait_timeout(Duration::from_secs(60)).map_err(job_error)?.progress.phase) ++ } ++ ++ fn created(session: &crate::Session, ticket: solidcraft_render::job::interactive::CaptureTicket, request: &Value) -> crate::Result { ++ let p = crate::cmd::prepare_interactive(session, request)?; ++ session ++ .render_job_host() ++ .ok_or_else(|| crate::EngineError::Other("interactive fixture has no render job host".into()))? ++ .submit_with_environment_and_options(ticket.job_id(), ticket.revision().scene_generation, p.scene, p.request, p.options, p.environment) ++ .map_err(job_error) ++ } ++ ++ #[test] ++ fn registration_is_explicit_and_preview_frames_never_join_final_registry() { ++ let (mut session, _) = native().unwrap(); ++ let document = session.doc.clone(); ++ let history = (session.revision, session.undo.len(), session.redo.len()); ++ let context = session.interactive_render().unwrap(); ++ assert_eq!(context.state().unwrap(), State::Off); ++ assert!(context.is_current(&session)); ++ assert!(context.capture(Duration::from_secs(1)).unwrap().is_none()); ++ let snapshot = capture(&context, &session, &wire([31, 67, 101])).unwrap(); ++ let ticket = snapshot.ticket(); ++ assert_ne!(ticket.job_id().session, session.render_jobs.owner); ++ assert_eq!(snapshot.document_uid(), session.uid); ++ assert!(snapshot.run().unwrap()); ++ let preview = context.current().unwrap().unwrap(); ++ assert_eq!(terminal(&preview).unwrap(), Phase::Completed); ++ assert!(preview.frame().unwrap().is_some()); ++ assert!(session.render_job_handle(preview.id()).is_err()); ++ assert!(session.execute("render.status", &json!({"job":preview.id()})).is_err()); ++ assert!(session.render_jobs.live.is_empty()); ++ assert!(session.render_jobs.last_good.is_none()); ++ assert!(session.render_jobs.pinned.is_none()); ++ assert_eq!(history, (session.revision, session.undo.len(), session.redo.len())); ++ assert!(Arc::ptr_eq(&document, &session.doc)); ++ } ++ ++ #[test] ++ fn direct_final_start_preempts_only_interactive_and_finishes() { ++ let (mut session, _) = native().unwrap(); ++ let context = session.interactive_render().unwrap(); ++ assert!(capture(&context, &session, &wire([11, 29, 47])).unwrap().run().unwrap()); ++ let old = context.current().unwrap().unwrap(); ++ let reply = session.execute("render.start", &wire([83, 107, 139])).unwrap(); ++ let final_id: JobId = serde_json::from_value(reply["job"].clone()).unwrap(); ++ let final_job = session.render_job_handle(final_id).unwrap(); ++ assert_ne!(final_id.session, old.id().session); ++ assert_eq!(context.state().unwrap(), State::Paused); ++ assert!(context.current().unwrap().is_none()); ++ assert!(context.capture(Duration::from_secs(100)).unwrap().is_none()); ++ assert_eq!(terminal(&final_job).unwrap(), Phase::Completed); ++ assert!(matches!(terminal(&old).unwrap(), Phase::Cancelled | Phase::Completed)); ++ assert!(!session.render_final_active().unwrap()); ++ let digest = final_job.frame().unwrap().unwrap().info.png_sha256.clone(); ++ context.disable().unwrap(); ++ drop(context); ++ assert_eq!(session.render_job_handle(final_id).unwrap().frame().unwrap().unwrap().info.png_sha256, digest); ++ } ++ ++ #[test] ++ fn replacement_context_revokes_old_capture_without_meshing() { ++ let (mut session, host) = native().unwrap(); ++ session.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Source"})).unwrap(); ++ let world = session.world_state(); ++ assert!(world.body("Source").unwrap().cached_mesh().is_none()); ++ let old = session.interactive_render().unwrap(); ++ let snapshot = capture(&old, &session, &wire([1, 2, 3])).unwrap(); ++ let old_owner = snapshot.ticket().job_id().session; ++ let fresh = session.interactive_render().unwrap(); ++ assert!(!old.is_current(&session)); ++ assert_eq!(old.state().unwrap(), State::Off); ++ assert_eq!(fresh.state().unwrap(), State::Off); ++ assert!(!snapshot.run().unwrap()); ++ assert!(world.body("Source").unwrap().cached_mesh().is_none()); ++ assert_eq!(host.admitted_bytes(), 0); ++ let next = capture(&fresh, &session, &wire([4, 5, 6])).unwrap(); ++ assert_ne!(next.ticket().job_id().session, old_owner); ++ } ++ ++ #[test] ++ fn host_a_b_a_cannot_revive_old_registration_in_the_same_document() { ++ let (mut session, host_a) = native().unwrap(); ++ let uid = session.uid; ++ let old = session.interactive_render().unwrap(); ++ let snapshot = capture(&old, &session, &wire([1, 2, 3])).unwrap(); ++ let host_b = CpuHost::for_platform().unwrap(); ++ session.set_render_job_host(Some(host_b)).unwrap(); ++ assert_eq!(session.uid, uid); ++ assert!(!old.is_current(&session)); ++ assert_eq!(old.state().unwrap(), State::Off); ++ assert!(!snapshot.run().unwrap()); ++ session.set_render_job_host(Some(host_a.clone())).unwrap(); ++ assert!(!old.is_current(&session)); ++ old.enable(VisualRevision { scene_generation: session.revision, visual_revision: 2 }, Duration::ZERO).unwrap(); ++ let stale = old.capture(Duration::from_millis(200)).unwrap().unwrap(); ++ assert!(old.snapshot(&session, stale, &wire([7, 8, 9])).is_err()); ++ assert_eq!(host_a.admitted_bytes(), 0); ++ assert!(session.interactive_render().unwrap().is_current(&session)); ++ } ++ ++ #[test] ++ fn new_design_and_equal_revision_foreign_session_refuse_old_tickets() { ++ let (mut session, host) = native().unwrap(); ++ let context = session.interactive_render().unwrap(); ++ let snapshot = capture(&context, &session, &wire([1, 2, 3])).unwrap(); ++ let ticket = snapshot.ticket(); ++ let uid = session.uid; ++ let mut foreign = crate::Session::new((*session.doc).clone()); ++ foreign.revision = session.revision; ++ foreign.set_render_job_host(Some(host.clone())).unwrap(); ++ assert_ne!(foreign.uid, uid); ++ assert!(!context.is_current(&foreign)); ++ assert!(context.snapshot(&foreign, ticket, &wire([4, 5, 6])).is_err()); ++ session.execute("file.new", &json!({})).unwrap(); ++ assert_ne!(session.uid, uid); ++ assert!(!context.is_current(&session)); ++ assert_eq!(context.state().unwrap(), State::Off); ++ assert!(!snapshot.run().unwrap()); ++ assert_eq!(host.admitted_bytes(), 0); ++ } ++ ++ #[test] ++ fn scratch_drop_does_not_revoke_source_and_exhaustion_is_local() { ++ let (mut session, _) = native().unwrap(); ++ let context = session.interactive_render().unwrap(); ++ drop(session.scratch()); ++ assert!(context.is_current(&session)); ++ assert_eq!(context.state().unwrap(), State::Off); ++ assert!(InteractiveRender::new(session.uid, 0, false).is_err()); ++ let original_owner = session.render_jobs.owner; ++ session.render_jobs.owner = 0; ++ assert!(session.interactive_render().is_err()); ++ assert!(context.is_current(&session)); ++ session.render_jobs.owner = original_owner; ++ } ++ ++ #[test] ++ fn failed_adoption_with_poisoned_controller_cancels_unpumped_cooperative_record() { ++ let (mut session, _) = native().unwrap(); ++ let context = session.interactive_render().unwrap(); ++ let snapshot = capture(&context, &session, &wire([1, 2, 3])).unwrap(); ++ let ticket = snapshot.ticket(); ++ let p = crate::cmd::prepare_interactive(&session, &wire([1, 2, 3])).unwrap(); ++ let mut request = p.request; ++ request.integrator = Integrator::Raster; ++ request.raytrace = None; ++ // A real cooperative queue cannot complete without an explicit pump. ++ // Adoption checks owner, then the poisoned lifecycle before integrator. ++ let cooperative = CpuHost::cooperative(); ++ let job = cooperative.submit(ticket.job_id(), ticket.revision().scene_generation, p.scene, request).unwrap(); ++ assert_eq!(job.status().unwrap().progress.phase, Phase::Queued); ++ let controller = session.render_jobs.interactive.upgrade().unwrap(); ++ let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { ++ let _guard = controller.lock().unwrap(); ++ panic!("original poison fixture"); ++ })); ++ assert!(adopt_created(&controller, ticket, job.clone()).is_err()); ++ assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled); ++ assert!(context.current().is_err(), "a poisoned lifecycle is not resumed"); ++ // No pump, sleeps, synthetic executor or large scene is needed. Removing ++ // Unadopted::drop cancellation leaves Queued and fails this assertion. ++ // Only controller poison is tested; record.data poison is best-effort. ++ } ++ ++ #[test] ++ fn rejected_fresh_equal_id_record_preserves_retained_completed_frame() { ++ let (mut session, _) = native().unwrap(); ++ let context = session.interactive_render().unwrap(); ++ let snapshot = capture(&context, &session, &wire([17, 31, 59])).unwrap(); ++ let ticket = snapshot.ticket(); ++ assert!(snapshot.run().unwrap()); ++ let accepted = context.current().unwrap().unwrap(); ++ assert_eq!(terminal(&accepted).unwrap(), Phase::Completed); ++ let frame = accepted.frame().unwrap().unwrap(); ++ let digest = frame.info.png_sha256.clone(); ++ let duplicate = created(&session, ticket, &wire([83, 107, 139])).unwrap(); ++ assert_eq!(duplicate.id(), accepted.id()); ++ let controller = session.render_jobs.interactive.upgrade().unwrap(); ++ assert!(!adopt_created(&controller, ticket, duplicate.clone()).unwrap()); ++ let phase = duplicate.status().unwrap().progress.phase; ++ assert!(phase.terminal() || phase == Phase::Cancelling); ++ assert!(matches!(terminal(&duplicate).unwrap(), Phase::Cancelled | Phase::Completed)); ++ let retained = context.current().unwrap().unwrap().frame().unwrap().unwrap(); ++ assert!(Arc::ptr_eq(&retained, &frame)); ++ assert_eq!(retained.info.png_sha256, digest); ++ // This native fixture proves accepted-record retention only. Completed ++ // duplicate work does not prove a cancellation request; core queued ++ // distinct-record acceptance covers that separate invariant. ++ assert_eq!(accepted.status().unwrap().request.background, [17, 31, 59]); ++ } ++ ++ #[test] ++ fn dropping_context_before_worker_start_keeps_the_source_mesh_cold() { ++ let (mut session, host) = native().unwrap(); ++ session.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Source"})).unwrap(); ++ let world = session.world_state(); ++ assert!(world.body("Source").unwrap().cached_mesh().is_none()); ++ let context = session.interactive_render().unwrap(); ++ let snapshot = capture(&context, &session, &wire([1, 2, 3])).unwrap(); ++ drop(context); ++ assert!(!snapshot.run().unwrap()); ++ assert!(world.body("Source").unwrap().cached_mesh().is_none()); ++ assert_eq!(host.admitted_bytes(), 0); ++ } ++} +diff --git a/crates/engine/src/schema/render_ui.rs b/crates/engine/src/schema/render_ui.rs +index eef51c95..2cc4998a 100644 +--- a/crates/engine/src/schema/render_ui.rs ++++ b/crates/engine/src/schema/render_ui.rs +@@ -1,4 +1,4 @@ +-//! Clipboard requests for the Render workspace; headless calls only echo validated text. ++//! Typed Render workspace UI requests; headless calls only echo validated inputs. + use schemars::JsonSchema; + use serde::{Deserialize, Serialize}; + +@@ -9,3 +9,20 @@ pub struct CheckReport { + #[schemars(length(min = 1, max = 65536))] + pub text: String, + } ++ ++/// Explicit provisional-preview action; no implicit toggle or default activation. ++#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize, JsonSchema)] ++#[serde(rename_all = "snake_case")] ++pub enum Action { ++ On, ++ Off, ++ Pause, ++ Resume, ++} ++ ++/// A validated UI action echoed unchanged by the headless command handler. ++#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize, JsonSchema)] ++#[serde(deny_unknown_fields)] ++pub struct InteractiveParams { ++ pub action: Action, ++} +diff --git a/crates/gpu/src/path/mod.rs b/crates/gpu/src/path/mod.rs +index 3b08b462..788f5bef 100644 +--- a/crates/gpu/src/path/mod.rs ++++ b/crates/gpu/src/path/mod.rs +@@ -100,7 +100,10 @@ pub fn host_on_adapter(adapter: &wgpu::Adapter) -> Result { + let policy = crate::select::Policy::from_env().map_err(gpu)?; + let info = adapter.get_info(); + if !viewport_path_backends(info.backend, cfg!(target_os = "windows")).intersects(crate::select::path_backends()) { +- return Err(gpu(format!("{VULKAN_ONLY}; the viewport uses {:?}", info.backend))); ++ return Err(gpu(format!( ++ "GPU path tracing is unavailable in this {:?} viewport session; Vulkan has not been tested; select a CPU image method", ++ info.backend ++ ))); + } + if !policy.admits(crate::select::tier_of(info.device_type)) { + return Err(gpu(format!("viewport adapter does not satisfy SOLIDCRAFT_GPU={}", policy.name()))); +diff --git a/crates/render/src/job/host.rs b/crates/render/src/job/host.rs +index 8c06a153..2a39848f 100644 +--- a/crates/render/src/job/host.rs ++++ b/crates/render/src/job/host.rs +@@ -396,6 +396,11 @@ impl Record { + pub struct JobHandle(Arc); + + impl JobHandle { ++ /// Internal admitted-work identity. Equal public IDs need not be one record. ++ pub(super) fn same_record(&self, other: &Self) -> bool { ++ Arc::ptr_eq(&self.0, &other.0) ++ } ++ + pub fn id(&self) -> JobId { + self.0.id + } +diff --git a/crates/render/src/job/host_tests.rs b/crates/render/src/job/host_tests.rs +index cff1b519..5c86d141 100644 +--- a/crates/render/src/job/host_tests.rs ++++ b/crates/render/src/job/host_tests.rs +@@ -46,13 +46,17 @@ mod interactive { + #[test] + fn preview_refuses_incompatible_transport_and_invalid_input_without_erasing_it() { + let mut source = cpu(); +- source.raytrace.as_mut().unwrap().area_lights = Some(vec![crate::job::RectangleLightOptions { +- center_mm: [0.0, 0.0, 10.0], +- edge_u_mm: [2.0, 0.0, 0.0], +- edge_v_mm: [0.0, 2.0, 0.0], +- color: [1.0; 3], +- intensity: 2.0, +- }]); ++ // A valid fixed thin sheet remains deliberately unsupported by progressive. ++ // Area/LED now has its positive preservation case below. ++ source.raytrace.as_mut().unwrap().dielectrics = vec![crate::job::DielectricOptions { ++ body_index: 0, ++ body_name: "Original sheet".into(), ++ boundary: crate::job::DielectricBoundary::ThinSheet, ++ ior: 1.5, ++ absorption_per_mm: [0.0; 3], ++ thickness_mm: 1.0, ++ }]; ++ source.raytrace.as_ref().unwrap().validate().unwrap(); + let before = serde_json::to_value(&source).unwrap(); + assert!(cpu_request(&source).is_err()); + assert_eq!(serde_json::to_value(&source).unwrap(), before); +@@ -66,6 +70,86 @@ mod interactive { + } + } + ++ #[test] ++ fn preview_preserves_rectangle_and_led_sources_and_all_nonsampling_options() { ++ use crate::job::{ ++ CpuProgressiveOptions, DirectionalLightOptions, PunctualLightOptions, RaytraceEnvironmentOptions, RectangleLightOptions, ReflectionBody, ++ ReflectionMode, ReflectionOptions, led_strip::LedStripOptions, ++ }; ++ let rectangle = RectangleLightOptions { ++ center_mm: [0.0, 0.0, 10.0], ++ edge_u_mm: [2.0, 0.0, 0.0], ++ edge_v_mm: [0.0, -2.0, 0.0], ++ color: [1.0, 0.5, 0.25], ++ intensity: 2.0, ++ }; ++ let led = LedStripOptions { ++ center_mm: [5.0, 0.0, 10.0], ++ length_mm: 8.0, ++ width_mm: 0.5, ++ length_axis: [1.0, 0.0, 0.0], ++ width_axis: [0.0, -1.0, 0.0], ++ color: [0.25, 0.5, 1.0], ++ intensity: 3.0, ++ }; ++ for area_samples in [1, 4, 16, 64] { ++ let mut source = cpu(); ++ source.width = 3840; ++ source.height = 2160; ++ source.camera.roll = 0.37; ++ source.background = [19, 31, 97]; ++ let mut options = RaytraceOptions { ++ primary_samples: 16, ++ exposure_ev: 1.25, ++ shadows: false, ++ lights: Some(vec![DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 }]), ++ punctual_lights: Some(vec![PunctualLightOptions { ++ position_mm: [0.0, 0.0, 20.0], ++ color: [1.0; 3], ++ intensity: 2.0, ++ reference_distance_mm: 10.0, ++ minimum_distance_mm: 0.01, ++ cone: None, ++ }]), ++ area_lights: Some(vec![rectangle.clone()]), ++ area_samples: Some(area_samples), ++ seed: Some(73), ++ environment: Some(RaytraceEnvironmentOptions { color: [0.2, 0.3, 0.4], intensity: 2.0 }), ++ reflections: Some(ReflectionOptions { ++ bodies: vec![ReflectionBody { body: "Subject".into(), mode: ReflectionMode::RoughSpecular }], ++ samples: 16, ++ max_bounces: 3, ++ }), ++ ..Default::default() ++ }; ++ led.append_to(&mut options, area_samples).unwrap(); ++ options.validate().unwrap(); ++ source.raytrace = Some(options); ++ let before = serde_json::to_value(&source).unwrap(); ++ let mut expected = source.clone(); ++ expected.width = 1024; ++ expected.height = 576; ++ let expected_options = expected.raytrace.as_mut().unwrap(); ++ expected_options.primary_samples = 1; ++ expected_options.progressive = Some(CpuProgressiveOptions { samples_per_pixel: 16, seed: 0 }); ++ expected_options.reflections.as_mut().unwrap().samples = 1; ++ ++ let preview = cpu_request(&source).unwrap(); ++ assert_eq!( ++ serde_json::to_value(&preview).unwrap(), ++ serde_json::to_value(&expected).unwrap(), ++ "all request fields must survive except the explicitly chosen preview envelope" ++ ); ++ assert_eq!(preview.raytrace, expected.raytrace); ++ assert!(preview.environment.is_none() && preview.textures.is_none()); ++ let preview_options = preview.raytrace.as_ref().unwrap(); ++ assert_eq!(preview_options.area_lights.as_ref().unwrap().as_slice(), &[rectangle.clone(), led.rectangle().unwrap()]); ++ assert_eq!(preview_options.area_samples, Some(area_samples)); ++ assert_eq!(preview_options.seed, Some(73), "camera seed zero must not replace the area-pattern seed"); ++ assert_eq!(serde_json::to_value(&source).unwrap(), before, "the final request remains immutable"); ++ } ++ } ++ + #[test] + fn explicit_enable_settles_edits_and_keeps_only_one_capture_even_without_cad_revision_changes() { + let mut interactive = Interactive::new(9001); +@@ -78,13 +162,16 @@ mod interactive { + assert!(interactive.capture(ms(1398)).unwrap().is_none()); + let b = interactive.capture(ms(1399)).unwrap().unwrap(); + assert_eq!(b.revision(), revision(2)); ++ assert!(interactive.accepts_capture(b)); + assert!(interactive.capture(ms(9999)).unwrap().is_none()); + interactive.edit(revision(3), ms(1400)).unwrap(); ++ assert!(!interactive.accepts_capture(b)); + // Delayed failure of B cannot poison C. + interactive.capture_failed(b, JobError::new(ErrorCode::InvalidScene, "old capture")); + assert_eq!(interactive.state().unwrap(), State::Updating); + let c = interactive.capture(ms(1600)).unwrap().unwrap(); + interactive.capture_failed(c, JobError::new(ErrorCode::InvalidScene, "current capture")); ++ assert!(!interactive.accepts_capture(c)); + assert_eq!(interactive.state().unwrap(), State::Error); + assert_eq!(interactive.error().unwrap().message, "current capture"); + assert!(interactive.capture(ms(9999)).unwrap().is_none(), "no automatic failure retry loop"); +@@ -138,7 +225,10 @@ mod interactive { + assert_eq!(first.status().unwrap().progress.phase, Phase::Cancelled); + assert!(interactive.current().is_none()); + let b = interactive.capture(ms(401)).unwrap().unwrap(); +- let late = host.submit(id(9003, 2), 19, empty(), cpu_request(&cpu()).unwrap()).unwrap(); ++ // A delayed A admission must carry A's identity, not the pending B's. ++ let late = host.submit(a.job_id(), 19, empty(), cpu_request(&cpu()).unwrap()).unwrap(); ++ assert_eq!(late.id(), a.job_id()); ++ assert_ne!(late.id(), b.job_id()); + assert!(!interactive.attach(a, late.clone()).unwrap()); + assert_eq!(late.status().unwrap().progress.phase, Phase::Cancelled); + // Drain cancelled queue entries before admitting another real job. +@@ -251,6 +341,89 @@ mod interactive { + drop(interactive); + assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled); + } ++ ++ #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))] ++ #[test] ++ fn stale_ticket_cannot_cancel_current_job_before_acknowledgement() { ++ let host = host(); ++ let mut interactive = Interactive::new(9008); ++ interactive.enable(revision(1), ms(0)).unwrap(); ++ let old = interactive.capture(ms(200)).unwrap().unwrap(); ++ interactive.edit(revision(2), ms(201)).unwrap(); ++ let current = interactive.capture(ms(401)).unwrap().unwrap(); ++ let job = host.submit(current.job_id(), 19, empty(), cpu_request(&cpu()).unwrap()).unwrap(); ++ // B is admitted but not yet acknowledged. A delayed A callback has no ++ // authority to cancel B, including before current() can return a handle. ++ assert!(interactive.current().is_none()); ++ assert!(interactive.accepts_capture(current)); ++ assert!(!interactive.accepts_capture(old)); ++ assert!(!interactive.attach(old, job.clone()).unwrap()); ++ assert_eq!(job.status().unwrap().progress.phase, Phase::Queued); ++ assert!(interactive.current().is_none()); ++ assert_eq!(interactive.state().unwrap(), State::Updating); ++ assert!(interactive.attach(current, job.clone()).unwrap()); ++ assert!(!interactive.accepts_capture(current)); ++ let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap(); ++ let mut running = Running::begin(work).unwrap(); ++ for _ in 0..100_000 { ++ if !running.advance(16).unwrap() { ++ break; ++ } ++ } ++ assert_eq!(job.status().unwrap().progress.phase, Phase::Completed); ++ assert!(job.frame().unwrap().is_some()); ++ assert_eq!(interactive.state().unwrap(), State::TargetReached); ++ drop(running); ++ drop(interactive); ++ drop(job); ++ assert_eq!(host.admitted_bytes(), 0); ++ } ++ ++ #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))] ++ #[test] ++ fn distinct_same_id_records_are_cancelled_but_current_handle_clones_finish() { ++ let host = host(); ++ let mut interactive = Interactive::new(9009); ++ interactive.enable(revision(1), ms(0)).unwrap(); ++ let old = interactive.capture(ms(200)).unwrap().unwrap(); ++ interactive.edit(revision(2), ms(201)).unwrap(); ++ let current = interactive.capture(ms(401)).unwrap().unwrap(); ++ let accepted = host.submit(current.job_id(), 19, empty(), cpu_request(&cpu()).unwrap()).unwrap(); ++ assert!(interactive.attach(current, accepted.clone()).unwrap()); ++ for callback in [old, current] { ++ // The host accepts an explicit JobId; submitting twice creates two ++ // records. Metadata equality is not actual admitted-work identity. ++ let duplicate = host.submit(current.job_id(), 19, empty(), cpu_request(&cpu()).unwrap()).unwrap(); ++ assert_eq!(accepted.id(), duplicate.id()); ++ assert!(!Arc::ptr_eq(&accepted.0, &duplicate.0)); ++ assert!(!interactive.attach(callback, duplicate.clone()).unwrap()); ++ assert_eq!(duplicate.status().unwrap().progress.phase, Phase::Cancelled); ++ assert_eq!(accepted.status().unwrap().progress.phase, Phase::Queued); ++ assert!(Arc::ptr_eq(&interactive.current().unwrap().0, &accepted.0)); ++ // A second callback for the original Arc is harmless for both an ++ // obsolete ticket and the already acknowledged current ticket. ++ assert!(!interactive.attach(callback, accepted.clone()).unwrap()); ++ assert_eq!(accepted.status().unwrap().progress.phase, Phase::Queued); ++ } ++ let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap(); ++ let mut running = Running::begin(work).unwrap(); ++ for _ in 0..100_000 { ++ if !running.advance(16).unwrap() { ++ break; ++ } ++ } ++ assert_eq!(accepted.status().unwrap().progress.phase, Phase::Completed); ++ assert!(accepted.frame().unwrap().is_some()); ++ assert_eq!(interactive.state().unwrap(), State::TargetReached); ++ while let Some(work) = host.0.shared.queue.lock().unwrap().pop_front() { ++ assert_eq!(work.handle.status().unwrap().progress.phase, Phase::Cancelled); ++ drop(work); ++ } ++ drop(running); ++ drop(interactive); ++ drop(accepted); ++ assert_eq!(host.admitted_bytes(), 0); ++ } + } + + #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))] +diff --git a/crates/render/src/job/interactive.rs b/crates/render/src/job/interactive.rs +index e9711445..0742e581 100644 +--- a/crates/render/src/job/interactive.rs ++++ b/crates/render/src/job/interactive.rs +@@ -192,6 +192,12 @@ impl Interactive { + Ok(Some(ticket)) + } + ++ /// Recheck before expensive capture/admission, including after a worker delay. ++ /// A ticket is not permission to prepare an obsolete or already adopted job. ++ pub fn accepts_capture(&self, ticket: CaptureTicket) -> bool { ++ self.enabled && !self.paused && !self.final_active && self.error.is_none() && self.ticket == Some(ticket) && self.active.is_none() ++ } ++ + /// Attach an admitted preview-only job after immutable capture. Delayed jobs + /// are cancelled, including a previous ticket for the same visual revision. + /// Use a separate engine job session/registry from final-image export. +@@ -203,7 +209,13 @@ impl Interactive { + return Ok(false); + } + if self.ticket != Some(ticket) || ticket.session != self.session { +- if self.active.as_ref().is_none_or(|active| active.id() != job.id()) { ++ // Protect an admitted current capture even before acknowledgement. ++ // Once accepted, only the same record (not merely its JobId) is ours. ++ let current = match &self.active { ++ Some(active) => active.same_record(&job), ++ None => self.ticket.is_some_and(|ticket| ticket.job_id() == job.id()), ++ }; ++ if !current { + job.cancel()?; + } + return Ok(false); +@@ -222,7 +234,7 @@ impl Interactive { + // A ticket is acknowledged exactly once, even if the same capture is + // delivered twice while an earlier attached job is still running. + if self.active.is_some() { +- if self.active.as_ref().is_none_or(|active| active.id() != job.id()) { ++ if self.active.as_ref().is_none_or(|active| !active.same_record(&job)) { + job.cancel()?; + } + return Ok(false); +diff --git a/crates/render/src/job/mod.rs b/crates/render/src/job/mod.rs +index 8ccee2a8..7d851f58 100644 +--- a/crates/render/src/job/mod.rs ++++ b/crates/render/src/job/mod.rs +@@ -892,13 +892,10 @@ impl RaytraceOptions { + "CPU progressive requires primary_samples: 1 and one reflection attempt per camera sample", + )); + } +- if !self.dielectrics.is_empty() +- || self.anisotropic_faces.iter().any(Option::is_some) +- || self.area_lights.as_ref().is_some_and(|lights| !lights.is_empty()) +- { ++ if !self.dielectrics.is_empty() || self.anisotropic_faces.iter().any(Option::is_some) { + return Err(JobError::new( + ErrorCode::InvalidRequest, +- "CPU progressive currently supports isotropic opaque surfaces and directional/point/spot lights; use fixed sampling for dielectric, anisotropic or area/LED inputs", ++ "CPU progressive currently supports isotropic opaque surfaces; use fixed sampling for dielectric or anisotropic inputs", + )); + } + } +@@ -1187,7 +1184,7 @@ mod runtime_request_roundtrip_tests { + color: [1.0; 3], + intensity: 1.0, + }; +- assert!(RaytraceOptions { progressive, area_lights: Some(vec![area]), ..Default::default() }.validate().is_err()); ++ RaytraceOptions { progressive, area_lights: Some(vec![area]), ..Default::default() }.validate().unwrap(); + let dielectric = DielectricOptions { + body_index: 0, + body_name: "Body".into(), +@@ -1209,4 +1206,79 @@ mod runtime_request_roundtrip_tests { + assert!(RaytraceOptions { progressive, anisotropic_faces: [Some(face), None], ..Default::default() }.validate().is_err()); + RaytraceOptions { progressive, area_lights: Some(Vec::new()), ..Default::default() }.validate().unwrap(); + } ++ ++ #[test] ++ fn progressive_rectangle_and_led_admission_preserves_source_limits_and_atomic_rejection() { ++ let strip = led_strip::LedStripOptions { ++ center_mm: [0.0, 0.0, 10.0], ++ length_mm: 2.0, ++ width_mm: 2.0, ++ length_axis: [1.0, 0.0, 0.0], ++ width_axis: [0.0, -1.0, 0.0], ++ color: [1.0, 0.5, 0.25], ++ intensity: 2.0, ++ }; ++ for samples in [1, 4, 16, 64] { ++ let mut options = RaytraceOptions { ++ progressive: Some(CpuProgressiveOptions { samples_per_pixel: 3, seed: 97 }), ++ lights: Some(Vec::new()), ++ ..Default::default() ++ }; ++ for count in 1..=4 { ++ strip.append_to(&mut options, samples).unwrap(); ++ options.validate().unwrap(); ++ assert_eq!(options.area_lights.as_ref().unwrap().len(), count); ++ assert_eq!( ++ options.retained_bytes().unwrap(), ++ (options.area_lights.as_ref().unwrap().capacity() * std::mem::size_of::()) as u64 ++ ); ++ } ++ let before = options.clone(); ++ let capacity = options.area_lights.as_ref().unwrap().capacity(); ++ assert!(strip.append_to(&mut options, samples).is_err()); ++ assert_eq!(options, before); ++ assert_eq!(options.area_lights.as_ref().unwrap().capacity(), capacity); ++ options.area_lights.as_mut().unwrap().pop(); ++ let before = options.clone(); ++ let conflicting = if samples == 1 { 4 } else { 1 }; ++ assert!(strip.append_to(&mut options, conflicting).is_err()); ++ assert_eq!(options, before); ++ for invalid in [0, 2, 65, u32::MAX] { ++ let mut hostile = options.clone(); ++ hostile.area_samples = Some(invalid); ++ assert!(hostile.validate().is_err()); ++ } ++ let mut hostile = options.clone(); ++ hostile.area_lights.as_mut().unwrap()[0].intensity = f64::NAN; ++ assert!(hostile.validate().is_err()); ++ } ++ let mut maximum = RaytraceOptions { ++ progressive: Some(CpuProgressiveOptions::default()), ++ lights: Some(vec![DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 }; 8]), ++ punctual_lights: Some(vec![ ++ PunctualLightOptions { ++ position_mm: [0.0, 0.0, 10.0], ++ color: [1.0; 3], ++ intensity: 1.0, ++ reference_distance_mm: 10.0, ++ minimum_distance_mm: 0.001, ++ cone: None, ++ }; ++ 8 ++ ]), ++ ..Default::default() ++ }; ++ for _ in 0..4 { ++ strip.append_to(&mut maximum, 16).unwrap(); ++ } ++ maximum.validate().unwrap(); ++ maximum.area_lights.as_mut().unwrap().push(strip.rectangle().unwrap()); ++ assert!(maximum.validate().is_err()); ++ for options in [ ++ RaytraceOptions { progressive: Some(CpuProgressiveOptions::default()), area_samples: Some(16), ..Default::default() }, ++ RaytraceOptions { progressive: Some(CpuProgressiveOptions::default()), seed: Some(7), ..Default::default() }, ++ ] { ++ assert!(options.validate().is_err()); ++ } ++ } + } +diff --git a/crates/render/src/raytrace/primary_aa_tests.rs b/crates/render/src/raytrace/primary_aa_tests.rs +index 3af7007a..f0ddbd99 100644 +--- a/crates/render/src/raytrace/primary_aa_tests.rs ++++ b/crates/render/src/raytrace/primary_aa_tests.rs +@@ -489,3 +489,230 @@ fn area_light_points_include_spatial_and_film_sample_identity() { + assert!(area_sample_key(41, 4, 4, 0).is_err()); + assert!(area_sample_key(u64::MAX, 0, 4, 0).is_err()); + } ++ ++// Original receiver and rectangular source; no borrowed model or recorded image. ++fn progressive_area_fixture(area_samples: u32, samples: u32, seed: u32, shadows: bool) -> ImageTask { ++ let original = fixture(1, 1, Some(true)); ++ let mut scene = original.scene.clone(); ++ scene.meshes[0].mesh = Arc::new(Mesh { ++ positions: vec![Vec3::new(-100.0, -100.0, 0.0), Vec3::new(100.0, -100.0, 0.0), Vec3::new(100.0, 100.0, 0.0), Vec3::new(-100.0, 100.0, 0.0)], ++ normals: vec![Vec3::Z; 4], ++ triangles: vec![[0, 1, 2], [0, 2, 3]], ++ tri_face: vec![0; 2], ++ ..Default::default() ++ }); ++ scene.meshes[0].surface = Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 0.0, 1.0, 1.0).unwrap()); ++ scene.bounds = scene.meshes[0].mesh.bounds(); ++ let options = RaytraceOptions { ++ progressive: Some(job::CpuProgressiveOptions { samples_per_pixel: samples, seed: 97 }), ++ lights: Some(Vec::new()), ++ area_lights: Some(vec![job::RectangleLightOptions { ++ center_mm: [0.0, 0.0, 10.0], ++ edge_u_mm: [2.0, 0.0, 0.0], ++ edge_v_mm: [0.0, -2.0, 0.0], ++ color: [1.0, 0.5, 0.25], ++ intensity: 2.0, ++ }]), ++ area_samples: Some(area_samples), ++ seed: Some(seed), ++ shadows, ++ ..Default::default() ++ }; ++ let request = ImageRequest { raytrace: Some(options.clone()), ..original.request.clone() }; ++ ImageTask::new(scene, request, CancelToken::default(), options).unwrap() ++} ++ ++fn progressive_area_rebuild(source: &ImageTask, options: RaytraceOptions) -> ImageTask { ++ let request = ImageRequest { raytrace: Some(options.clone()), ..source.request.clone() }; ++ ImageTask::new(source.scene.clone(), request, CancelToken::default(), options).unwrap() ++} ++ ++#[test] ++fn progressive_area_transport_uses_absolute_film_ordinal_and_seed_for_all_sample_counts() { ++ use super::super::area::RectangleLight; ++ for count in [1, 4, 16, 64] { ++ for seed in [7, 91] { ++ let mut task = progressive_area_fixture(count, 2, seed, false); ++ let light = RectangleLight::new(Vec3::Z * 10.0, Vec3::X * 2.0, -Vec3::Y * 2.0, Vec3::new(1.0, 0.5, 0.25), 2.0).unwrap(); ++ let mut inspected = 0; ++ let mut first_positions = Vec::new(); ++ let mut complete = false; ++ for _ in 0..200_000 { ++ let ordinal = task.progressive.as_ref().unwrap().film.samples(); ++ let before = ++ task.pending.as_ref().filter(|p| p.hit.is_some() && p.area_light == 0 && p.area_index < count).map(|p| (p.area_index, p.ray)); ++ let poll = task.step_with_previews(1).unwrap(); ++ if let Some((index, ray)) = before ++ && let Some(pending) = task.pending.as_ref() ++ && pending.area_light == 0 ++ && pending.area_index == index + 1 ++ { ++ let point = ray.origin() + ray.direction() * (-ray.origin().z / ray.direction().z); ++ let key = area_sample_key(0, 0, 1, ordinal).unwrap(); ++ let sampled = light.sample(point, key, 0, index, count, seed).unwrap().unwrap(); ++ // Index-matched nonmetallic white receiver is exactly Lambertian. ++ // Check the actual consumer, independently of its BRDF and area weight. ++ let delta = sampled.position() - point; ++ let distance_squared = delta.dot(delta); ++ let factor = 4.0 * delta.z * delta.z / (distance_squared * distance_squared * f64::from(count) * std::f64::consts::PI); ++ let expected = Vec3::new(2.0, 1.0, 0.5) * factor; ++ assert!((pending.area_value - expected).len() < 1e-12, "N={count}, seed={seed}, film={ordinal}, index={index}"); ++ if index == 0 { ++ first_positions.push(sampled.position()); ++ } ++ inspected += 1; ++ } ++ if matches!(poll, ImagePoll::Complete(_)) { ++ complete = true; ++ break; ++ } ++ } ++ assert!(complete); ++ assert_eq!(inspected, 2 * count); ++ assert_eq!(first_positions.len(), 2); ++ if count == 1 { ++ assert_eq!(first_positions[0], first_positions[1], "one sample intentionally stays at the emitter centre"); ++ } else { ++ assert_ne!(first_positions[0], first_positions[1], "later film passes must not reuse the first emitter point"); ++ } ++ } ++ } ++} ++ ++#[test] ++fn progressive_area_center_sample_resolves_the_analytic_linear_mean_once() { ++ let task = progressive_area_fixture(1, 3, 7, false); ++ let camera = task.request.camera; ++ let mut sum = Vec3::ZERO; ++ for ordinal in 0..3 { ++ let [u, v] = progressive::variates(97, 0, ordinal, 0); ++ let (origin, direction) = camera.ray(u, v, 1.0, 1.0); ++ let point = origin + direction * (-origin.z / direction.z); ++ let delta = Vec3::Z * 10.0 - point; ++ let r2 = delta.dot(delta); ++ sum += Vec3::new(2.0, 1.0, 0.5) * (4.0 * delta.z * delta.z / (r2 * r2 * std::f64::consts::PI)); ++ } ++ let mean = sum / 3.0; ++ let expected = [mean.x, mean.y, mean.z].map(|value| encode8(value / (1.0 + value))); ++ let (_, png, _) = progressive_complete(task, 1); ++ assert_eq!(::image::load_from_memory(&png).unwrap().to_rgba8().get_pixel(0, 0).0, [expected[0], expected[1], expected[2], 255]); ++} ++ ++#[test] ++fn progressive_area_checkpoints_and_work_are_independent_of_target_and_quantum() { ++ for count in [1, 4, 16, 64] { ++ let small = progressive_complete(progressive_area_fixture(count, 5, 23, true), 1); ++ let large = progressive_complete(progressive_area_fixture(count, 5, 23, true), 16_384); ++ assert_eq!(small, large, "area continuation must share the same cumulative work across quanta"); ++ assert_eq!(small.0.iter().map(|(samples, _)| *samples).collect::>(), [1, 2, 4]); ++ for (samples, checkpoint) in &small.0 { ++ let (_, final_png, _) = progressive_complete(progressive_area_fixture(count, *samples, 23, true), 3); ++ assert_eq!(&final_png, checkpoint); ++ } ++ } ++} ++ ++#[test] ++fn progressive_led_lowering_keeps_rectangle_power_sampling_and_final_bytes() { ++ let strip = job::led_strip::LedStripOptions { ++ center_mm: [0.0, 0.0, 10.0], ++ length_mm: 2.0, ++ width_mm: 2.0, ++ length_axis: [1.0, 0.0, 0.0], ++ width_axis: [0.0, -1.0, 0.0], ++ color: [1.0, 0.5, 0.25], ++ intensity: 2.0, ++ }; ++ for count in [1, 4, 16, 64] { ++ let direct = progressive_area_fixture(count, 3, 7, true); ++ let mut options = direct.options.clone(); ++ options.area_lights = None; ++ options.area_samples = None; ++ options.seed = None; ++ strip.append_to(&mut options, count).unwrap(); ++ options.seed = direct.options.seed; ++ assert_eq!(options, direct.options); ++ let lowered = progressive_area_rebuild(&direct, options); ++ assert_eq!(progressive_complete(direct, 1), progressive_complete(lowered, 7)); ++ } ++} ++ ++#[test] ++fn progressive_area_admission_bills_source_capacity_and_reuses_bounded_scratch() { ++ let source = progressive_area_fixture(1, 3, 7, true); ++ let mut empty = source.options.clone(); ++ empty.area_lights = None; ++ empty.area_samples = None; ++ empty.seed = None; ++ let baseline = progressive_area_rebuild(&source, empty); ++ let slots = source.options.area_lights.as_ref().unwrap().capacity(); ++ let bytes = (slots * std::mem::size_of::()) as u64; ++ assert_eq!(source.options.retained_bytes().unwrap(), bytes); ++ assert_eq!(source.admission.estimated_total_bytes - baseline.admission.estimated_total_bytes, bytes); ++ assert_eq!(source.admission.preparation_bytes - baseline.admission.preparation_bytes, bytes); ++ for count in [4, 16, 64] { ++ let more = progressive_area_fixture(count, 3, 7, true); ++ assert_eq!( ++ more.admission.estimated_total_bytes, source.admission.estimated_total_bytes, ++ "area samples reuse the same continuation, not an N-sized buffer" ++ ); ++ } ++ let mut over = source.request.clone(); ++ over.width = 1025; ++ over.height = 1024; ++ assert_eq!(admit(&source.scene, &over, &source.options).err().unwrap().code, ErrorCode::LimitExceeded); ++} ++ ++#[test] ++fn progressive_area_shadow_cancellation_and_checkpoint_do_not_reset_work() { ++ let mut task = progressive_area_fixture(16, 3, 7, true); ++ let mut pending_shadow = false; ++ for _ in 0..200_000 { ++ if task.pending.as_ref().is_some_and(|p| p.area_shadow) { ++ pending_shadow = true; ++ break; ++ } ++ assert!(matches!(task.step_with_previews(1).unwrap(), ImagePoll::Pending(_))); ++ } ++ assert!(pending_shadow); ++ let used = task.work.used(); ++ task.cancel.cancel(); ++ assert_eq!(task.step_with_previews(1).err().unwrap().code, ErrorCode::Cancelled); ++ assert_eq!(task.work.used(), used); ++ assert_eq!(task.progressive.as_ref().unwrap().film.samples(), 0); ++ assert!(!task.done); ++ ++ let mut reference = progressive_area_fixture(16, 3, 7, true); ++ let mut checkpoint_work = None; ++ for _ in 0..200_000 { ++ if let ImagePoll::Preview { samples_per_pixel, .. } = reference.step_with_previews(1).unwrap() { ++ assert_eq!(samples_per_pixel, 1); ++ checkpoint_work = Some(reference.work.used()); ++ break; ++ } ++ } ++ let limit = checkpoint_work.unwrap(); ++ let mut bounded = progressive_area_fixture(16, 3, 7, true); ++ bounded.work = WorkBudget::new(limit).unwrap(); ++ let mut observed_checkpoint = false; ++ for _ in 0..200_000 { ++ match bounded.step_with_previews(1) { ++ Ok(ImagePoll::Pending(_)) => {} ++ Ok(ImagePoll::Preview { samples_per_pixel, .. }) => { ++ assert!(!observed_checkpoint); ++ assert_eq!(samples_per_pixel, 1); ++ observed_checkpoint = true; ++ assert_eq!(bounded.work.used(), limit); ++ } ++ Ok(ImagePoll::Complete(_)) => panic!("work exhausted after the checkpoint must not publish a final"), ++ Err(error) => { ++ assert_eq!(error.code, ErrorCode::LimitExceeded); ++ assert!(observed_checkpoint); ++ assert_eq!(bounded.work.used(), limit); ++ assert!(!bounded.done); ++ return; ++ } ++ } ++ } ++ panic!("area work ceiling was reset or the fixture did not finish"); ++} +diff --git a/crates/ui-egui/src/command_help.rs b/crates/ui-egui/src/command_help.rs +index ec1d5fd0..e4cbc2ce 100644 +--- a/crates/ui-egui/src/command_help.rs ++++ b/crates/ui-egui/src/command_help.rs +@@ -15,6 +15,7 @@ pub const DOCUMENTED: &[&str] = &[ + "occurrence.move", + "parameters.change", + "pointcloud.insert", ++ "render.interactive", + "solid.align", + "solid.chamfer", + "solid.combine", +diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs +index 1c7d3003..76e51dad 100644 +--- a/crates/ui-egui/src/i18n.rs ++++ b/crates/ui-egui/src/i18n.rs +@@ -671,8 +671,23 @@ mod tests { + ); + } + ++ #[test] ++ fn render_preview_explanations_are_translated_in_every_required_catalog() { ++ let source_locale = Locale::for_language("en"); ++ for id in ["render.preview_image_settings_help", "render.preview_lighting_help", "render.stage_preview_note"] { ++ let source = source_locale.text(id); ++ assert_ne!(source, id, "{id}: missing English source"); ++ for language in ["ar", "de", "he", "ja", "ko", "vi", "zh"] { ++ let locale = Locale::for_language(language); ++ assert!(locale.0.messages().contains_key(id), "{language}: missing {id}"); ++ assert_ne!(locale.text(id), source, "{language}: {id} must not fall back to English"); ++ } ++ } ++ } ++ + #[test] + fn render_shell_labels_and_planned_reasons_translate_in_required_catalogs() { ++ let source_locale = Locale::for_language("en"); + for language in ["ja", "zh", "de", "ko"] { + let locale = Locale::for_language(language); + for label in [ +@@ -691,7 +706,7 @@ mod tests { + "Shots Strip", + "Pick", + "Component", +- "The live preview shows direct light only and no shadows.", ++ source_locale.text("render.preview_lighting_help"), + ] { + assert_ne!(locale.label(label), label, "{language}: {label}"); + } +diff --git a/crates/ui-egui/src/render_ui/mod.rs b/crates/ui-egui/src/render_ui/mod.rs +index 3634f924..ba23443a 100644 +--- a/crates/ui-egui/src/render_ui/mod.rs ++++ b/crates/ui-egui/src/render_ui/mod.rs +@@ -185,6 +185,8 @@ pub(crate) fn overlays(app: &mut SolveApp, ui: &mut egui::Ui) { + if !free.is_positive() { + return; + } ++ crate::render_workspace::assign::selection_bar(app, ui, free); ++ crate::shell::register_panel(app, "render:interactive-card", None, None); + if crate::render_workspace::job_busy(app) { + let pill = Container::navigation_card(ui.ctx(), egui::Id::new("sc_render_progress"), free.center_top(), egui::Align2::CENTER_TOP, |ui| { + crate::render_workspace::progress_pill(app, ui); +@@ -193,9 +195,9 @@ pub(crate) fn overlays(app: &mut SolveApp, ui: &mut egui::Ui) { + crate::scenario::publish_rect("render:progress-pill", pill.response.rect); + } else { + crate::shell::register_panel(app, "render:progress-pill", None, None); ++ crate::render_workspace::interactive::overlay(app, ui, free); + } + crate::render_workspace::environment_overlay(app, ui, viewport); +- crate::render_workspace::assign::selection_bar(app, ui, free); + crate::render_workspace::assign::replacement_dialog(app, ui.ctx()); + crate::navigation_bar_view::show(app, ui, viewport); + if !focused(app) { +diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs +index 511d15be..20da1689 100644 +--- a/crates/ui-egui/src/render_workspace.rs ++++ b/crates/ui-egui/src/render_workspace.rs +@@ -38,6 +38,9 @@ mod environment; + #[path = "render_workspace_inspector.rs"] + mod inspector; + ++#[path = "render_workspace_interactive.rs"] ++pub(crate) mod interactive; ++ + #[path = "render_workspace_library.rs"] + mod library; + +@@ -132,6 +135,7 @@ pub struct State { + pub upload_error: crate::gpu::UploadError, + pub image_host: Option, + pub view: ViewState, ++ interactive: interactive::State, + revision: u64, + design_camera: Option<(Camera, bool)>, + slot: SceneSlot, +@@ -461,6 +465,7 @@ impl Default for State { + upload_error: Arc::new(Mutex::new(None)), + image_host: None, + view: Default::default(), ++ interactive: Default::default(), + revision: u64::MAX, + design_camera: None, + slot: Arc::new(Mutex::new(None)), +@@ -480,8 +485,9 @@ impl Default for State { + + impl State { + /// Retain the selected viewport adapter, but do not open another device or +- /// compile shaders until Render is used. A later viewport installation (for +- /// example safe-mode fallback) replaces only a not-yet-started factory. ++ /// compile shaders until GPU path tracing is selected in Render. Raster and ++ /// CPU image methods retain this factory without starting it. A later viewport ++ /// installation (for example safe-mode fallback) replaces only an unstarted factory. + #[cfg(not(target_arch = "wasm32"))] + pub(crate) fn defer_path_host(&mut self, key: String, create: impl FnOnce() -> Result + Send + 'static) { + if matches!(self.path_host, PathHost::NotStarted) { +@@ -492,7 +498,8 @@ impl State { + + #[cfg(not(target_arch = "wasm32"))] + fn start_deferred_path_host(&mut self) { +- if matches!(self.path_host, PathHost::NotStarted) ++ if self.view.method == ImageMethod::GpuRaytrace ++ && matches!(self.path_host, PathHost::NotStarted) + && let Some(create) = self.pending_setup.take() + { + self.path_host.start(create); +@@ -525,6 +532,7 @@ pub(crate) fn inspect_state(app: &SolveApp) -> serde_json::Value { + json!({ + "active": active(app), "stage": view.stage.key(), "setup": view.name, "draft_dirty": view.dirty, + "method": method, "job": view.job, "completed": view.completed, ++ "interactive": interactive::inspect(app), + "showing_result": view.result, "export_format": if view.studio.export_exr {"exr"} else {"png"}, + }) + } +@@ -588,6 +596,7 @@ pub fn sync_backend(app: &mut SolveApp) { + /// Cooperative work belongs to the frame loop, never to a status/control request. Keep + /// scheduling frames even after leaving Render so a browser job can finish in Design. + pub fn tick(app: &mut SolveApp, ctx: &egui::Context) { ++ interactive::tick(app, ctx); + if let Some(text) = app.render_workspace.clipboard_text.take() { + ctx.copy_text(text); + } +@@ -620,7 +629,10 @@ pub fn reset_document(app: &mut SolveApp) { + let setup_seconds = std::mem::take(&mut app.render_workspace.setup_seconds); + let setup_key = app.render_workspace.setup_key.take(); + let pending_setup = app.render_workspace.pending_setup.take(); +- app.render_workspace = State { host, image_host, path_host, setup_seconds, setup_key, pending_setup, geometry_budget, ..Default::default() }; ++ let mut interactive = std::mem::take(&mut app.render_workspace.interactive); ++ interactive.reset_document(); ++ app.render_workspace = ++ State { host, image_host, path_host, setup_seconds, setup_key, pending_setup, geometry_budget, interactive, ..Default::default() }; + if active(app) { + app.ui.tab = "MODEL".into(); + } +@@ -671,6 +683,7 @@ pub fn enter(app: &mut SolveApp, render: bool) -> Result<(), String> { + #[cfg(not(target_arch = "wasm32"))] + app.render_workspace.start_deferred_path_host(); + } else { ++ app.render_workspace.interactive.reset_document(); + assign::stop(app); + if let Some((camera, perspective)) = app.render_workspace.design_camera.take() { + app.cam = camera; +@@ -820,8 +833,10 @@ pub(crate) fn appearances_card(app: &mut SolveApp, ui: &mut egui::Ui, bounds: eg + + fn image_host(app: &SolveApp, method: ImageMethod) -> Result<&ImageHost, String> { + if method == ImageMethod::GpuRaytrace { +- let PathHost::Ready(host) = &app.render_workspace.path_host else { +- return Err(app.tr("render.gpu_unavailable").to_string()); ++ let host = match &app.render_workspace.path_host { ++ PathHost::Ready(host) => host, ++ PathHost::Failed(error) => return Err(error.clone()), ++ _ => return Err(app.tr("render.gpu_unavailable").to_string()), + }; + let descriptor = host.descriptor().map_err(|error| error.to_string())?; + if !host.is_available() +@@ -858,6 +873,20 @@ fn raw_image_request(app: &SolveApp) -> Result { + if !setups::has_runtime_inputs(app) { + return Ok(json!({"settings":setups::snapshot(app)?})); + } ++ runtime_image_request(app, false) ++} ++ ++/// CPU Interactive skips final-dimension admission and the portable snapshot path. ++/// The engine fits/admit/captures this complete runtime intent off the window. ++fn interactive_request(app: &SolveApp) -> Result { ++ if app.render_workspace.view.method != ImageMethod::CpuRaytrace { ++ return Err(app.tr("render.interactive_requires_cpu").into()); ++ } ++ light::filter_request(app, runtime_image_request(app, true)?) ++} ++ ++/// The existing runtime branch, shared without changing Final Check/Start policy. ++fn runtime_image_request(app: &SolveApp, interactive_cpu: bool) -> Result { + let view = &app.render_workspace.view; + // Temporary bindings and unsaved HDR captures use the runtime API. Embedded HDRs + // still resolve by their document resource ID when a temporary binding is present. +@@ -872,7 +901,11 @@ fn raw_image_request(app: &SolveApp) -> Result { + if view.transparent { + return Err(app.tr("render.cpu_opaque_required").to_string()); + } +- cpu::params(app, &mut params)?; ++ if interactive_cpu { ++ cpu::params_interactive(app, &mut params)?; ++ } else { ++ cpu::params(app, &mut params)?; ++ } + } + ImageMethod::GpuRaytrace => { + params["progressive"] = json!(true); +@@ -1917,6 +1950,7 @@ pub fn preview_size(executor: Option<&ExecutorDescriptor>, full: (u64, u64)) -> + + pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { + if app.render_workspace.view.result { ++ interactive::before_paint(app, ui.ctx()); + app.render_workspace.view.environment_ring = environment::RingView::default(); + assign::stop(app); + show_result(app, ui); +@@ -1930,6 +1964,10 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { + let response = ui.interact(rect, ui.id().with("render_preview"), Sense::click_and_drag()); + if !environment::ring_input(app, ui, rect, &response) { + let input = crate::navigation::handle(app, ui, rect, &response, crate::navigation::NavCaps::RENDER); ++ // Navigation can invalidate the displayed image in this frame. Observe before ++ // any geometry interaction, and observe again below after visible UI actions. ++ interactive::before_paint(app, ui.ctx()); ++ let waiting = interactive::awaiting_current_frame(app); + let navigating = input.scroll != 0.0 + || input.pinch != 1.0 + || input.pan != egui::Vec2::ZERO +@@ -1942,23 +1980,25 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { + || app.cam_anim.is_some(); + let hits = input + .hover +- .filter(|_| input.inside && !navigating) ++ .filter(|_| input.inside && !navigating && !waiting) + .map(|p| crate::viewport::pick_cached(app, &crate::viewport::projection(app, rect), p)) + .unwrap_or_default(); + let candidate = assign::candidate(app, &hits, input.mods); + app.viewport.hover = candidate.as_ref().map(|(hit, _)| hit.clone()); +- let assigning = assign::input(app, ui, &response, candidate.as_ref(), input.inside && !navigating); +- if !assigning && input.inside && !navigating { ++ // No target or inside flag while blank; still drain drag release / Escape. ++ let assigning = assign::input(app, ui, &response, candidate.as_ref(), input.inside && !navigating && !waiting); ++ if !waiting && !assigning && input.inside && !navigating { + assign::hover_tooltip(app, &response, candidate.as_ref()); + } +- if !assigning && response.clicked_by(egui::PointerButton::Primary) && input.inside && !navigating { ++ if !waiting && !assigning && response.clicked_by(egui::PointerButton::Primary) && input.inside && !navigating { + let (add, toggle) = crate::tool_modifiers::selection_click( + crate::tool_modifiers::Held::from_modifiers(input.mods), + app.preferences.selection_shift_add_only, + ); + crate::viewport::select(app, candidate.as_ref().map(|(_, sel)| sel.clone()), add, toggle); + } +- if response.secondary_clicked() ++ if !waiting ++ && response.secondary_clicked() + && let Some((crate::viewport::Hit::Face { body, .. }, _)) = &candidate + { + if let Some(candidate) = &candidate { +@@ -1971,6 +2011,14 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { + } + let bg = app.render_workspace.view.draft.background; + ui.painter().rect_filled(viewport, 0.0, Color32::from_rgb(bg[0], bg[1], bg[2])); ++ // Reobserve after the existing shared navigation path, before any pixel paint. ++ interactive::before_paint(app, ui.ctx()); ++ if interactive::paint(app, ui, rect) || interactive::awaiting_current_frame(app) { ++ shot::overlay(app, ui, viewport); ++ crate::viewport::axis_view(app, ui, viewport); ++ crate::navigation_bar_view::show(app, ui, viewport); ++ return; ++ } + let result = (|| -> Result<(), String> { + if app.viewport.gpu.is_none() { + return Err(crate::i18n::tr("render.error_gpu_preview").into()); +@@ -2088,6 +2136,11 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) { + /// Apply validated UI requests after the same registry call used by automation. + pub(crate) fn apply_command(app: &mut SolveApp, id: &str, reply: &serde_json::Value) -> Result<(), String> { + match id { ++ "render.interactive" => { ++ let input: solidcraft_engine::schema::render_ui::InteractiveParams = ++ serde_json::from_value(reply.clone()).map_err(|error| error.to_string())?; ++ interactive::apply_command(app, input.action)?; ++ } + "render.preflight.copy" => { + app.render_workspace.clipboard_text = Some(reply["text"].as_str().ok_or("invalid check report")?.to_string()); + } +diff --git a/crates/ui-egui/src/render_workspace_cpu.rs b/crates/ui-egui/src/render_workspace_cpu.rs +index 694467ea..99638782 100644 +--- a/crates/ui-egui/src/render_workspace_cpu.rs ++++ b/crates/ui-egui/src/render_workspace_cpu.rs +@@ -160,6 +160,11 @@ struct Binding { + target: Target, + revision: u64, + document: std::sync::Weak, ++ // Interactive may follow appearance/render-only edits only while this exact ++ // evaluated world survives in the same open document. Weak ownership avoids ++ // retaining old geometry and prevents pointer reuse after the world drops. ++ session_uid: u64, ++ world: std::sync::Weak, + } + + #[derive(Clone, Debug)] +@@ -218,6 +223,25 @@ fn binding_current(app: &SolveApp, name: &str) -> bool { + }) + } + ++// Unlike final Check/Start, Interactive may refresh harmless appearance/render ++// edits. The engine retains the exact world Arc for those edits (refresh_render). ++// No geometry extraction, cold meshing, name-only rebinding or revision stamping. ++fn binding_interactive_world_current(app: &SolveApp, name: &str) -> bool { ++ app.render_workspace.view.cpu.bindings.get(name).is_some_and(|binding| { ++ binding.session_uid == app.session.uid ++ && !app.session.model.is_stale() ++ && app ++ .session ++ .interactive_cached_world_state() ++ .is_some_and(|world| std::sync::Weak::ptr_eq(&binding.world, &std::sync::Arc::downgrade(&world))) ++ }) ++} ++ ++fn binding_interactive_current(app: &SolveApp, name: &str) -> bool { ++ binding_interactive_world_current(app, name) ++ && app.render_workspace.view.cpu.bindings.get(name).is_some_and(|binding| target(app, name).as_ref() == Some(&binding.target)) ++} ++ + pub(super) fn revalidate(app: &mut SolveApp, name: &str) -> Result<(), String> { + let current = target(app, name).ok_or_else(|| app.tr("render.cpu_body_missing").to_string())?; + if app.render_workspace.view.cpu.bindings.get(name).is_none_or(|binding| binding.target != current) { +@@ -225,9 +249,13 @@ pub(super) fn revalidate(app: &mut SolveApp, name: &str) -> Result<(), String> { + } + let revision = app.session.revision; + let document = std::sync::Arc::downgrade(&app.session.doc); ++ let world = std::sync::Arc::downgrade(&app.session.world_state()); ++ let session_uid = app.session.uid; + if let Some(binding) = app.render_workspace.view.cpu.bindings.get_mut(name) { + binding.revision = revision; + binding.document = document; ++ binding.session_uid = session_uid; ++ binding.world = world; + } + Ok(()) + } +@@ -268,11 +296,16 @@ pub(super) fn set_reflection(app: &mut SolveApp, name: &str, mode: Option Result<(), String> { ++ params_with_binding_policy(app, params, binding_current) ++} ++ ++/// Interactive-only wire lowering. This does not requalify final Check/Start, ++/// change a stored binding or read an HDR file; the engine still captures and admits it. ++pub(super) fn params_interactive(app: &SolveApp, params: &mut Value) -> Result<(), String> { ++ // Refuse unproved bound worlds before shared lowering checks visibility via ++ // target()/world_state(). Empty reflections never require a warm world. ++ if app ++ .render_workspace ++ .view ++ .raytrace ++ .reflections ++ .as_ref() ++ .is_some_and(|r| r.bodies.iter().any(|entry| !binding_interactive_world_current(app, &entry.body))) ++ { ++ return Err(app.tr("render.cpu_binding_stale").to_string()); ++ } ++ params_with_binding_policy(app, params, binding_interactive_current) ++} ++ ++fn params_with_binding_policy(app: &SolveApp, params: &mut Value, current: fn(&SolveApp, &str) -> bool) -> Result<(), String> { + let base = &app.render_workspace.view.raytrace; + if base.anisotropic_faces.iter().any(Option::is_some) + || !base.dielectrics.is_empty() +@@ -293,7 +348,7 @@ pub(super) fn params(app: &SolveApp, params: &mut Value) -> Result<(), String> { + if base.reflections.as_ref().is_some_and(|r| r.bodies.iter().any(|entry| !unique_visible_body(app, &entry.body))) { + return Err(app.tr("render.cpu_body_missing").to_string()); + } +- if base.reflections.as_ref().is_some_and(|r| r.bodies.iter().any(|entry| !binding_current(app, &entry.body))) { ++ if base.reflections.as_ref().is_some_and(|r| r.bodies.iter().any(|entry| !current(app, &entry.body))) { + return Err(app.tr("render.cpu_binding_stale").to_string()); + } + let view = &app.render_workspace.view.cpu; +diff --git a/crates/ui-egui/src/render_workspace_ribbon.rs b/crates/ui-egui/src/render_workspace_ribbon.rs +index ce8ec02f..925ee9f7 100644 +--- a/crates/ui-egui/src/render_workspace_ribbon.rs ++++ b/crates/ui-egui/src/render_workspace_ribbon.rs +@@ -13,7 +13,8 @@ fn handled(id: &str) -> bool { + is_job_action(id) + || matches!( + id, +- "render.aging.describe" ++ "render.interactive" ++ | "render.aging.describe" + | "render.effects.describe" + | "render.environment.set" + | "render.preset.resolve" +@@ -66,6 +67,7 @@ pub(super) fn action_ready(app: &SolveApp, id: &str) -> Result<(), String> { + return Err(app.tr("render.ribbon_finish_dialog").into()); + } + match id { ++ "render.interactive" => super::interactive::command_ready(app), + "render.preflight" | "render.start" => { + if id == "render.start" && busy(app) { + return Err(app.tr("render.ribbon_job_active").into()); +@@ -209,6 +211,10 @@ fn focus(app: &mut SolveApp, page: inspector::Page, category: Option<&str>) { + /// Parameterless command activation opens the already implemented editor. The + /// engine's explicit resolve/apply methods still require their original params. + pub(super) fn start(app: &mut SolveApp, id: &str) -> bool { ++ if id == "render.interactive" { ++ super::interactive::activate(app); ++ return true; ++ } + if !handled(id) { + return false; + } +diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs +index ea8a43c7..9a6ce942 100644 +--- a/crates/ui-egui/src/render_workspace_tests.rs ++++ b/crates/ui-egui/src/render_workspace_tests.rs +@@ -826,6 +826,106 @@ fn render_lights_list_inspects_unsaved_ui_draft_without_applying_or_opening_anyt + + #[cfg(not(target_arch = "wasm32"))] + mod async_path_host { ++ ++ #[test] ++ fn cpu_and_raster_render_entries_keep_gpu_setup_unstarted_across_document_reset() { ++ use std::sync::atomic::{AtomicUsize, Ordering}; ++ for method in [ImageMethod::Raster, ImageMethod::CpuRaytrace] { ++ let mut h = Harness::new(); ++ let calls = Arc::new(AtomicUsize::new(0)); ++ let observed = calls.clone(); ++ h.app.render_workspace.defer_path_host("not requested".into(), move || { ++ observed.fetch_add(1, Ordering::SeqCst); ++ Err("a CPU/Raster method must not call this GPU factory".into()) ++ }); ++ select_image_method(&mut h.app, method); ++ sync_backend(&mut h.app); ++ enter(&mut h.app, true).unwrap(); ++ for _ in 0..3 { ++ sync_backend(&mut h.app); ++ } ++ // The synchronous state and retained factory prove that no worker was ++ // launched, even if a wrongly launched thread had not been scheduled yet. ++ assert!(matches!(h.app.render_workspace.path_host, PathHost::NotStarted)); ++ assert!(h.app.render_workspace.pending_setup.is_some()); ++ assert_eq!(calls.load(Ordering::SeqCst), 0); ++ ++ crate::documents::adopt(&mut h.app, Session::default()); ++ select_image_method(&mut h.app, method); ++ enter(&mut h.app, true).unwrap(); ++ sync_backend(&mut h.app); ++ assert!(matches!(h.app.render_workspace.path_host, PathHost::NotStarted)); ++ assert!(h.app.render_workspace.pending_setup.is_some()); ++ assert_eq!(h.app.render_workspace.setup_key.as_deref(), Some("not requested")); ++ assert_eq!(calls.load(Ordering::SeqCst), 0); ++ } ++ } ++ ++ #[test] ++ fn explicit_gpu_selection_starts_once_and_keeps_its_receiver_across_document_changes() { ++ use std::sync::atomic::{AtomicUsize, Ordering}; ++ let mut h = Harness::new(); ++ let calls = Arc::new(AtomicUsize::new(0)); ++ let observed = calls.clone(); ++ let (started, seen) = mpsc::channel(); ++ let (release, wait) = mpsc::channel(); ++ h.app.render_workspace.defer_path_host("explicit request".into(), move || { ++ observed.fetch_add(1, Ordering::SeqCst); ++ started.send(()).unwrap(); ++ wait.recv_timeout(Duration::from_secs(10)).unwrap(); ++ Err("deliberate device-free refusal".into()) ++ }); ++ select_image_method(&mut h.app, ImageMethod::CpuRaytrace); ++ enter(&mut h.app, true).unwrap(); ++ assert!(matches!(h.app.render_workspace.path_host, PathHost::NotStarted)); ++ assert!(h.app.render_workspace.pending_setup.is_some()); ++ ++ select_image_method(&mut h.app, ImageMethod::GpuRaytrace); ++ sync_backend(&mut h.app); ++ seen.recv_timeout(Duration::from_secs(10)).unwrap(); ++ assert!(matches!(h.app.render_workspace.path_host, PathHost::Preparing(..))); ++ assert!(h.app.render_workspace.pending_setup.is_none()); ++ assert_eq!(calls.load(Ordering::SeqCst), 1); ++ ++ // A real in-progress factory is not abandoned or duplicated when a new ++ // document defaults back to Raster, or the user changes methods meanwhile. ++ crate::documents::adopt(&mut h.app, Session::default()); ++ enter(&mut h.app, true).unwrap(); ++ assert!(matches!(h.app.render_workspace.path_host, PathHost::Preparing(..))); ++ let duplicate_calls = calls.clone(); ++ h.app.render_workspace.defer_path_host("must not duplicate".into(), move || { ++ duplicate_calls.fetch_add(1, Ordering::SeqCst); ++ Err("unexpected duplicate preparation".into()) ++ }); ++ for method in [ImageMethod::Raster, ImageMethod::CpuRaytrace, ImageMethod::GpuRaytrace] { ++ select_image_method(&mut h.app, method); ++ sync_backend(&mut h.app); ++ } ++ assert_eq!(calls.load(Ordering::SeqCst), 1); ++ release.send(()).unwrap(); ++ finish_setup(&mut h); ++ let PathHost::Failed(error) = &h.app.render_workspace.path_host else { panic!("expected deliberate refusal") }; ++ assert_eq!(error, "deliberate device-free refusal"); ++ ++ // A method change or new document does not become an automatic retry. ++ crate::documents::adopt(&mut h.app, Session::default()); ++ let PathHost::Failed(error) = &h.app.render_workspace.path_host else { panic!("document reset lost the original failure") }; ++ assert_eq!(error, "deliberate device-free refusal"); ++ select_image_method(&mut h.app, ImageMethod::GpuRaytrace); ++ enter(&mut h.app, true).unwrap(); ++ let PathHost::Failed(error) = &h.app.render_workspace.path_host else { panic!("GPU selection lost the original failure") }; ++ assert_eq!(error, "deliberate device-free refusal"); ++ let retry_calls = calls.clone(); ++ h.app.render_workspace.defer_path_host("must not retry".into(), move || { ++ retry_calls.fetch_add(1, Ordering::SeqCst); ++ Err("unexpected replacement after terminal failure".into()) ++ }); ++ sync_backend(&mut h.app); ++ let PathHost::Failed(error) = &h.app.render_workspace.path_host else { panic!("terminal failure was replaced") }; ++ assert_eq!(error, "deliberate device-free refusal"); ++ assert!(h.app.render_workspace.pending_setup.is_none()); ++ assert_eq!(calls.load(Ordering::SeqCst), 1); ++ } + use super::*; + use solidcraft_engine::render::job; + use std::sync::mpsc; +@@ -884,6 +984,11 @@ mod async_path_host { + assert!(matches!(h.app.render_workspace.path_host, PathHost::NotStarted)); + assert!(h.app.render_workspace.pending_setup.is_some()); + enter(&mut h.app, true).unwrap(); ++ assert!(matches!(h.app.render_workspace.path_host, PathHost::NotStarted)); ++ assert!(h.app.render_workspace.pending_setup.is_some()); ++ assert_eq!(calls.load(Ordering::SeqCst), 0); ++ select_image_method(&mut h.app, ImageMethod::GpuRaytrace); ++ sync_backend(&mut h.app); + finish_setup(&mut h); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert!(matches!(h.app.render_workspace.path_host, PathHost::Ready(_))); +@@ -899,6 +1004,8 @@ mod async_path_host { + let calls = Arc::new(AtomicUsize::new(0)); + let observed = calls.clone(); + let mut h = panel_fixture(); ++ select_image_method(&mut h.app, ImageMethod::GpuRaytrace); ++ sync_backend(&mut h.app); + assert!(matches!(h.app.render_workspace.path_host, PathHost::NotStarted)); + h.app.render_workspace.defer_path_host("late selected viewport".into(), move || { + observed.fetch_add(1, Ordering::SeqCst); +@@ -922,6 +1029,7 @@ mod async_path_host { + h.app.render_workspace.defer_path_host("selected safe-mode adapter".into(), || Err("selected adapter unavailable".into())); + h.frames(5); + assert_eq!(h.app.render_workspace.setup_key.as_deref(), Some("selected safe-mode adapter")); ++ select_image_method(&mut h.app, ImageMethod::GpuRaytrace); + enter(&mut h.app, true).unwrap(); + finish_setup(&mut h); + let PathHost::Failed(message) = &h.app.render_workspace.path_host else { panic!("expected selected adapter result") }; +@@ -2710,6 +2818,132 @@ fn cpu_reflection_binding_requires_confirmation_and_never_follows_a_reused_name( + assert!(cpu::params(&h.app, &mut json!({})).unwrap_err().contains(h.app.tr("render.cpu_binding_stale"))); + } + ++#[test] ++fn cpu_interactive_reflection_binding_accepts_appearance_and_render_intent_without_qualifying_final() { ++ use solidcraft_engine::render::job::ReflectionMode; ++ let mut h = Harness::new(); ++ h.app.run("solid.box", json!({"length":10,"width":20,"height":5,"body_name":"Reflector"})).unwrap(); ++ h.app.run("render.scene", json!({})).unwrap(); ++ let world = h.app.session.world_state(); ++ let mesh = world.body("Reflector").unwrap().cached_mesh().unwrap(); ++ let document = h.app.session.doc.clone(); ++ cpu::set_reflection(&mut h.app, "Reflector", Some(ReflectionMode::Mirror)).unwrap(); ++ h.app.run("appearance.assign", json!({"bodies":["Reflector"],"color":"#123456"})).unwrap(); ++ assert!(!Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert!(Arc::ptr_eq(&world, &h.app.session.world_state())); ++ assert!(Arc::ptr_eq(&mesh, &h.app.session.world_state().body("Reflector").unwrap().cached_mesh().unwrap())); ++ h.app.run("render.settings.set", json!({"name":"Interactive target proof","set":{"width":800,"height":600}})).unwrap(); ++ assert!(Arc::ptr_eq(&world, &h.app.session.world_state())); ++ h.app.render_workspace.view.draft.exposure_ev = 1.5; ++ h.app.render_workspace.view.cpu.environment = cpu::Environment::Hdr; ++ h.app.render_workspace.view.cpu.hdr = captured_hdr_input("not-opened-by-interactive-ui.hdr"); ++ h.app.render_workspace.view.cpu.rotation_rad = 0.25; ++ h.app.render_workspace.view.cpu.intensity = 2.0; ++ let before = json!(h.app.render_workspace.view.raytrace.reflections); ++ let mut interactive = json!({}); ++ cpu::params_interactive(&h.app, &mut interactive).unwrap(); ++ assert_eq!(interactive["raytrace"]["reflections"]["bodies"], json!([{"body":"Reflector","mode":"mirror"}])); ++ assert_eq!(interactive["raytrace"]["exposure_ev"], 1.5); ++ assert_eq!(interactive["environment"]["rotation_radians"], 0.25); ++ assert_eq!(interactive["environment"]["expected_sha256"], json!(h.app.render_workspace.view.cpu.hdr.resource().unwrap())); ++ assert_eq!(json!(h.app.render_workspace.view.raytrace.reflections), before); ++ assert!( ++ cpu::params(&h.app, &mut json!({})).unwrap_err().contains(h.app.tr("render.cpu_binding_stale")), ++ "Interactive refresh cannot qualify final Check/Start" ++ ); ++ assert!( ++ cpu::set_reflection(&mut h.app, "Reflector", Some(ReflectionMode::RoughSpecular)).is_err(), ++ "mode changes still require explicit confirmation" ++ ); ++} ++ ++#[test] ++fn cpu_interactive_binding_keeps_cold_meshes_cold_and_refuses_another_world_until_confirmation() { ++ use solidcraft_engine::render::job::ReflectionMode; ++ let mut h = Harness::new(); ++ h.app.session.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Reflector"})).unwrap(); ++ let world = h.app.session.world_state(); ++ assert!(world.body("Reflector").unwrap().cached_mesh().is_none()); ++ let retained = Arc::strong_count(&world); ++ cpu::set_reflection(&mut h.app, "Reflector", Some(ReflectionMode::Mirror)).unwrap(); ++ cpu::params_interactive(&h.app, &mut json!({})).unwrap(); ++ assert!(world.body("Reflector").unwrap().cached_mesh().is_none(), "request lowering must not tessellate"); ++ assert_eq!(Arc::strong_count(&world), retained, "the binding must not retain the evaluated world"); ++ h.app.session.execute("appearance.assign", &json!({"bodies":["Reflector"],"color":"#654321"})).unwrap(); ++ cpu::params_interactive(&h.app, &mut json!({})).unwrap(); ++ assert!(world.body("Reflector").unwrap().cached_mesh().is_none()); ++ h.app.session.execute("solid.box", &json!({"length":3,"width":3,"height":3,"corner":[30,0,0],"body_name":"Other","operation":"new"})).unwrap(); ++ assert!(!Arc::ptr_eq(&world, &h.app.session.world_state())); ++ assert!(cpu::params_interactive(&h.app, &mut json!({})).unwrap_err().contains(h.app.tr("render.cpu_binding_stale"))); ++ cpu::revalidate(&mut h.app, "Reflector").unwrap(); ++ cpu::params_interactive(&h.app, &mut json!({})).unwrap(); ++ cpu::params(&h.app, &mut json!({})).unwrap(); ++} ++ ++#[test] ++fn cpu_interactive_binding_refuses_reused_names_and_same_revision_in_a_new_document() { ++ use solidcraft_engine::render::job::ReflectionMode; ++ let mut h = Harness::new(); ++ h.app.run("solid.box", json!({"length":10,"width":20,"height":5,"body_name":"Reflector"})).unwrap(); ++ h.app.run("solid.box", json!({"length":3,"width":3,"height":3,"corner":[30,0,0],"body_name":"Other","operation":"new"})).unwrap(); ++ cpu::set_reflection(&mut h.app, "Reflector", Some(ReflectionMode::Mirror)).unwrap(); ++ h.app.run("body.rename", json!({"body":"Reflector","name":"Original"})).unwrap(); ++ h.app.run("body.rename", json!({"body":"Other","name":"Reflector"})).unwrap(); ++ assert!(cpu::params_interactive(&h.app, &mut json!({})).is_err()); ++ assert!(cpu::revalidate(&mut h.app, "Reflector").is_err()); ++ cpu::set_reflection(&mut h.app, "Reflector", None).unwrap(); ++ cpu::set_reflection(&mut h.app, "Reflector", Some(ReflectionMode::Mirror)).unwrap(); ++ cpu::params_interactive(&h.app, &mut json!({})).unwrap(); ++ let document = h.app.session.doc.clone(); ++ let revision = h.app.session.revision; ++ let uid = h.app.session.uid; ++ h.app.session = Session::new((*document).clone()); ++ h.app.session.revision = revision; ++ assert_ne!(h.app.session.uid, uid); ++ assert!(cpu::params_interactive(&h.app, &mut json!({})).is_err()); ++} ++ ++#[test] ++fn cpu_interactive_binding_refuses_moved_occurrences_and_hidden_targets() { ++ use solidcraft_engine::render::job::ReflectionMode; ++ let mut h = Harness::new(); ++ let component = h.app.run("component.create", json!({"name":"Part","grounded":false})).unwrap(); ++ h.app.run("solid.box", json!({"length":10,"width":20,"height":5,"body_name":"Reflector"})).unwrap(); ++ let world = h.app.session.world_state(); ++ let name = world.bodies[0].name.clone(); ++ let mesh = world.bodies[0].mesh(); ++ cpu::set_reflection(&mut h.app, &name, Some(ReflectionMode::Mirror)).unwrap(); ++ h.app.run("occurrence.move", json!({"occurrence":component["occurrence"],"translate":[20,0,0]})).unwrap(); ++ let moved = h.app.session.world_state(); ++ assert!(!Arc::ptr_eq(&world, &moved)); ++ assert!(!Arc::ptr_eq(&mesh, &moved.bodies[0].mesh())); ++ assert!(cpu::params_interactive(&h.app, &mut json!({})).is_err(), "same creator and name cannot certify a moved instance"); ++ cpu::revalidate(&mut h.app, &name).unwrap(); ++ cpu::params_interactive(&h.app, &mut json!({})).unwrap(); ++ h.app.session.visibility.hidden_bodies.push(name); ++ assert!(cpu::params_interactive(&h.app, &mut json!({})).unwrap_err().contains(h.app.tr("render.cpu_body_missing"))); ++} ++ ++#[test] ++fn cpu_interactive_binding_refuses_deleted_then_recreated_equal_looking_targets() { ++ use solidcraft_engine::render::job::ReflectionMode; ++ let mut h = Harness::new(); ++ h.app.run("solid.box", json!({"length":10,"width":20,"height":5,"body_name":"Reflector"})).unwrap(); ++ let world = h.app.session.world_state(); ++ let feature = world.body("Reflector").unwrap().feature; ++ cpu::set_reflection(&mut h.app, "Reflector", Some(ReflectionMode::Mirror)).unwrap(); ++ h.app.run("timeline.delete", json!({"feature":feature.to_string()})).unwrap(); ++ assert!(cpu::params_interactive(&h.app, &mut json!({})).unwrap_err().contains(h.app.tr("render.cpu_binding_stale"))); ++ h.app.run("solid.box", json!({"length":10,"width":20,"height":5,"body_name":"Reflector"})).unwrap(); ++ assert!(h.app.session.world_state().body("Reflector").is_some(), "the recreated case must actually reuse the selected name"); ++ assert!(!Arc::ptr_eq(&world, &h.app.session.world_state())); ++ assert!(cpu::params_interactive(&h.app, &mut json!({})).is_err(), "identical names/dimensions cannot certify recreated geometry"); ++ assert!(cpu::params(&h.app, &mut json!({})).is_err()); ++ cpu::set_reflection(&mut h.app, "Reflector", None).unwrap(); ++ cpu::set_reflection(&mut h.app, "Reflector", Some(ReflectionMode::Mirror)).unwrap(); ++ cpu::params_interactive(&h.app, &mut json!({})).unwrap(); ++} ++ + #[test] + fn cpu_environment_controls_keep_wire_schemas_separate_without_reading_files() { + let mut h = Harness::new(); +@@ -6380,3 +6614,1796 @@ fn geometry_budget_change_retries_cached_admission_without_document_changes() { + assert_eq!(state.preview_upload_bytes, Some(bytes as usize)); + assert!(state.scene_error.is_none()); + } ++ ++#[test] ++fn cpu_interactive_cold_assembly_binding_refuses_without_preparing_world() { ++ use solidcraft_engine::render::job::ReflectionMode; ++ let mut h = Harness::new(); ++ let component = h.app.session.execute("component.create", &json!({"name":"Part","grounded":false})).unwrap(); ++ h.app.session.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Reflector"})).unwrap(); ++ let initial = h.app.session.world_state(); ++ let name = initial.bodies[0].name.clone(); ++ cpu::set_reflection(&mut h.app, &name, Some(ReflectionMode::Mirror)).unwrap(); ++ // Exact placement metadata changes without running a UI paint or world query. ++ let occurrence: u64 = serde_json::from_value(component["occurrence"].clone()).unwrap(); ++ h.app.session.pending_moves.insert(occurrence, solidcraft_engine::doc::IDENTITY); ++ assert!(h.app.session.interactive_cached_world_state().is_none()); ++ let model = h.app.session.model.state(); ++ assert!(model.bodies.iter().all(|body| body.cached_mesh().is_none())); ++ assert!(cpu::params_interactive(&h.app, &mut json!({})).unwrap_err().contains(h.app.tr("render.cpu_binding_stale"))); ++ assert!(h.app.session.interactive_cached_world_state().is_none(), "binding proof must not prepare cold placements"); ++ assert!(model.bodies.iter().all(|body| body.cached_mesh().is_none())); ++ cpu::set_reflection(&mut h.app, &name, None).unwrap(); ++ cpu::params_interactive(&h.app, &mut json!({})).unwrap(); ++ assert!(h.app.session.interactive_cached_world_state().is_none(), "empty reflections need no prepared world"); ++} ++ ++#[test] ++fn interactive_egui_clock_is_finite_monotonic_and_requires_no_platform_instant() { ++ use std::time::Duration; ++ let mark = Duration::from_secs(2); ++ for time in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, -1.0, 1.0, f64::MAX] { ++ assert_eq!(interactive::monotonic(mark, time), mark); ++ } ++ assert_eq!(interactive::monotonic(mark, 3.5), Duration::from_millis(3500)); ++} ++ ++fn interactive_control_frame(h: &mut Harness, time: f64, events: Vec) { ++ let mut output = h.ctx.run_ui( ++ egui::RawInput { ++ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(420.0, 420.0))), ++ time: Some(time), ++ events, ++ ..Default::default() ++ }, ++ |ui| { ++ ui.set_width(300.0); ++ interactive::before_paint(&mut h.app, ui.ctx()); ++ interactive::controls(&mut h.app, ui); ++ }, ++ ); ++ output.textures_delta.clear(); ++} ++ ++#[test] ++fn interactive_is_opt_in_and_refuses_raster_or_cooperative_hosts_without_fallback() { ++ let mut h = Harness::new(); ++ h.app.ui.tab = "RENDER".into(); ++ h.app.render_workspace.view.method = ImageMethod::Raster; ++ assert_eq!(interactive::inspect(&h.app)["enabled"], false); ++ let document = h.app.session.doc.clone(); ++ let path = matches!(h.app.render_workspace.path_host, PathHost::NotStarted); ++ assert!(h.app.run("render.interactive", json!({"action":"on"})).is_err()); ++ assert_eq!(h.app.render_workspace.view.method, ImageMethod::Raster); ++ h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; ++ h.app.session.set_render_job_host(Some(solidcraft_engine::render::job::CpuHost::cooperative())).unwrap(); ++ assert!(h.app.run("render.interactive", json!({"action":"on"})).is_err()); ++ interactive_control_frame(&mut h, 1.0, vec![]); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Off"); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!(matches!(h.app.render_workspace.path_host, PathHost::NotStarted), path); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_ui_fixture() -> Harness { ++ let mut h = Harness::new(); ++ h.app.run("solid.box", json!({"length":10,"width":8,"height":4,"body_name":"Subject"})).unwrap(); ++ h.app.run("render.scene", json!({})).unwrap(); ++ let host = solidcraft_engine::render::job::CpuHost::for_platform().unwrap(); ++ h.app.session.set_render_job_host(Some(host)).unwrap(); ++ h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; ++ h.app.render_workspace.view.draft.width = 16; ++ h.app.render_workspace.view.draft.height = 16; ++ // Do not enter through a deferred GPU factory in CPU-only adapter tests. ++ h.app.ui.tab = "RENDER".into(); ++ h ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_test_cpu_branch(h: &mut Harness, case: &str) -> bool { ++ let host = h.app.session.render_job_host().unwrap(); ++ let supported = host.kind() == solidcraft_engine::render::job::HostKind::NativeWorker ++ && host.is_available() ++ && host.validate_integrator(Integrator::Raytrace).is_ok(); ++ if supported { ++ eprintln!("INTERACTIVE_BRANCH case={case} cpu_supported=true"); ++ return true; ++ } ++ let document = h.app.session.doc.clone(); ++ let before = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()); ++ assert!(h.app.run("render.interactive", json!({"action":"on"})).is_err()); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Off"); ++ assert_eq!(interactive::inspect(&h.app)["enabled"], false); ++ assert!(h.app.render_workspace.view.job.is_none() && h.app.render_workspace.view.completed.is_none()); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!(before, (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty())); ++ eprintln!("INTERACTIVE_BRANCH case={case} cpu_supported=false unsupported_refusal_asserted=true"); ++ false ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_runtime_builder_preserves_hdr_ev_and_muted_lights_without_final_dimension_admission() { ++ let mut h = interactive_ui_fixture(); ++ let name = h.app.render_workspace.view.name.clone(); ++ h.app.run("render.settings.set", json!({"name":name,"set":{"job":{"method":"cpu_raytrace"}}})).unwrap(); ++ h.app.run("render.library.environment.apply", json!({"id":"HDR-001","name":name,"replace_environment":true})).unwrap(); ++ setups::load(&mut h.app); ++ assert!(h.app.render_workspace.view.cpu.hdr.embedded()); ++ h.app.render_workspace.view.draft.width = 3840; ++ h.app.render_workspace.view.draft.height = 2160; ++ h.app.render_workspace.view.draft.exposure_ev = 1.5; ++ h.app.render_workspace.view.raytrace.shadows = false; ++ h.app.run("render.lights.mute", json!({"id":"directional:0","mute":true})).unwrap(); ++ let before = h.app.session.doc.clone(); ++ let wire = interactive_request(&h.app).unwrap(); ++ assert_eq!(wire["settings"]["width"], 3840, "engine must fit before admission"); ++ assert!(wire["settings"]["job"].is_null()); ++ assert_eq!(wire["settings"]["exposure_ev"], 0.0); ++ assert_eq!(wire["raytrace"]["exposure_ev"], 1.5); ++ assert_eq!(wire["raytrace"]["shadows"], false); ++ assert_eq!(wire["raytrace"]["lights"][0]["intensity"], 0.0); ++ assert_eq!(wire["environment"]["resource"], json!(h.app.render_workspace.view.cpu.hdr.resource().unwrap())); ++ assert!(wire["environment"].get("path").is_none()); ++ assert!(raw_image_request(&h.app).is_err(), "final admission must remain unchanged"); ++ assert!(Arc::ptr_eq(&before, &h.app.session.doc)); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_identity_tracks_camera_transport_and_visibility_before_paint_without_dispatching() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_identity_tracks_camera_transport_and_visibility_before_paint_without_dispatching") { ++ return; ++ } ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_control_frame(&mut h, 0.0, vec![]); ++ let first = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ let revision = h.app.session.revision; ++ h.app.cam.yaw += 0.2; ++ interactive_control_frame(&mut h, 0.5, vec![]); ++ let camera = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ assert!(camera > first); ++ h.app.render_workspace.view.raytrace.shadows = false; ++ interactive_control_frame(&mut h, 1.0, vec![]); ++ let transport = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ assert!(transport > camera); ++ h.app.session.visibility.hidden_bodies.push("Subject".into()); ++ interactive_control_frame(&mut h, 1.5, vec![]); ++ let visibility = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ assert!(visibility > transport); ++ assert_eq!(h.app.session.revision, revision, "all three edits deliberately bypass CAD revision"); ++ assert_eq!(interactive::inspect(&h.app)["pending_capture"], false, "before_paint never dispatches a worker"); ++ assert!(h.app.render_workspace.view.job.is_none() && h.app.render_workspace.view.completed.is_none()); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_real_command_controls_pause_resume_and_leave_without_changing_final_slots() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_real_command_controls_pause_resume_and_leave_without_changing_final_slots") { ++ return; ++ } ++ interactive_control_frame(&mut h, 0.0, vec![]); ++ let mut time = 0.01; ++ for action in ["on", "pause", "resume", "off"] { ++ let rect = crate::scenario::rect_of(&format!("render:interactive:{action}")).unwrap(); ++ let at = rect.center(); ++ interactive_control_frame( ++ &mut h, ++ time, ++ vec![ ++ egui::Event::PointerMoved(at), ++ egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE }, ++ egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE }, ++ ], ++ ); ++ time += 0.01; ++ interactive_control_frame(&mut h, time, vec![]); ++ time += 0.01; ++ assert_eq!(interactive::inspect(&h.app)["enabled"], action != "off"); ++ assert_eq!(interactive::inspect(&h.app)["paused"], action == "pause"); ++ assert!(h.app.render_workspace.view.job.is_none() && h.app.render_workspace.view.completed.is_none()); ++ assert!(!h.app.render_workspace.view.result); ++ } ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ enter(&mut h.app, false).unwrap(); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Off"); ++} ++ ++#[test] ++fn interactive_reset_retains_one_real_receiver_and_discards_its_late_foreign_error() { ++ use solidcraft_engine::render::job::interactive::{Interactive, VisualRevision}; ++ use std::{sync::mpsc, time::Duration}; ++ let mut h = Harness::new(); ++ let mut controller = Interactive::new(7001); ++ controller.enable(VisualRevision { scene_generation: 0, visual_revision: 1 }, Duration::ZERO).unwrap(); ++ let ticket = controller.capture(Duration::from_millis(200)).unwrap().unwrap(); ++ let (sender, receiver) = mpsc::channel(); ++ h.app.render_workspace.interactive.pending = Some(interactive::Pending { uid: h.app.session.uid, ticket, receiver }); ++ reset_document(&mut h.app); ++ assert!(h.app.render_workspace.interactive.pending()); ++ reset_document(&mut h.app); ++ assert!(h.app.render_workspace.interactive.pending(), "a second document reset cannot orphan the pending worker"); ++ sender.send(Err("late old capture".into())).unwrap(); ++ interactive_control_frame(&mut h, 1.0, vec![]); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Off"); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_background_final_metadata_suspends_without_cancelling_queued_final() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_background_final_metadata_suspends_without_cancelling_queued_final") { ++ return; ++ } ++ crate::documents::open_tab(&mut h.app, Session::default()).unwrap(); ++ crate::documents::switch(&mut h.app, 0); ++ h.app.ui.tab = "RENDER".into(); ++ h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let host = solidcraft_engine::render::job::CpuHost::cooperative(); ++ let job = { ++ let background = h.app.docs.background_mut().next().unwrap(); ++ background.session.set_render_job_host(Some(host.clone())).unwrap(); ++ let reply = background.session.execute("render.start", &json!({"settings":{"width":8,"height":8}})).unwrap(); ++ serde_json::from_value::(reply["job"].clone()).unwrap() ++ }; ++ let retained = host.admitted_bytes(); ++ interactive_control_frame(&mut h, 1.0, vec![]); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Paused"); ++ let background = h.app.docs.background().next().unwrap(); ++ assert_eq!(background.render_job_handle(job).unwrap().status().unwrap().progress.phase, solidcraft_engine::render::job::Phase::Queued); ++ assert_eq!(host.admitted_bytes(), retained); ++ assert!(!h.app.render_workspace.interactive.pending()); ++} ++ ++// Native CPU acceptance of the real M3 dispatcher; no native window or GPU. ++#[cfg(not(target_arch = "wasm32"))] ++struct InteractiveHeldCallback { ++ job: solidcraft_engine::render::job::JobHandle, ++ sender: std::sync::mpsc::Sender>, ++ reply: Result, ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_acceptance_frame(h: &mut Harness, time: f64, dispatch: bool, paint: bool) -> (egui::FullOutput, bool) { ++ let mut painted = false; ++ let output = h.ctx.run_ui( ++ egui::RawInput { ++ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(420.0, 420.0))), ++ time: Some(time), ++ ..Default::default() ++ }, ++ |ui| { ++ // tick dispatches through the actual production spawn(Snapshot) path. ++ // Do not run a second refresh here: the callback must be held before UI delivery. ++ if dispatch { ++ interactive::tick(&mut h.app, ui.ctx()); ++ } else { ++ interactive::before_paint(&mut h.app, ui.ctx()); ++ } ++ if paint { ++ painted = interactive::paint(&h.app, ui, ui.max_rect()); ++ } ++ }, ++ ); ++ (output, painted) ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_clear_acceptance_frame(h: &mut Harness, time: f64, dispatch: bool) { ++ let (mut output, painted) = interactive_acceptance_frame(h, time, dispatch, false); ++ assert!(!painted); ++ output.textures_delta.clear(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_hold_real_completed_callback(h: &mut Harness) -> InteractiveHeldCallback { ++ use solidcraft_engine::render::job::Phase; ++ use std::{sync::mpsc, time::Duration}; ++ // The actual capture thread owns and invokes the real engine Snapshot.run. ++ // This test only withholds its actual returned message from the UI consumer. ++ // No tick/paint is called while the receiver is temporarily removed. ++ let mut pending = h.app.render_workspace.interactive.pending.take().expect("production tick must start a capture"); ++ let reply = pending.receiver.recv_timeout(Duration::from_secs(60)).expect("real snapshot worker did not return"); ++ assert!(matches!(&reply, Ok(true)), "real snapshot must be adopted: {reply:?}"); ++ let job = ++ interactive::test_current(&h.app).expect("Interactive controller access must succeed").expect("Snapshot.run must attach the real CPU job"); ++ assert_eq!(job.id(), pending.ticket.job_id()); ++ assert_eq!(pending.uid, h.app.session.uid); ++ let status = job.wait_timeout(Duration::from_secs(60)).expect("real CPU job did not finish"); ++ assert_eq!(status.progress.phase, Phase::Completed); ++ assert!(status.error.is_none()); ++ assert_eq!(status.request.integrator, Integrator::Raytrace); ++ assert_eq!(status.request.raytrace.as_ref().unwrap().progressive.unwrap().samples_per_pixel, 16); ++ assert_eq!((status.request.width, status.request.height), (16, 16)); ++ let frame = job.frame().unwrap().expect("Completed requires real frame bytes"); ++ assert_eq!(frame.info.executor.as_str(), "cpu-raytrace"); ++ assert_eq!(frame.info.job, job.id()); ++ assert_eq!(frame.info.scene_generation, pending.ticket.revision().scene_generation); ++ assert!(!frame.png().is_empty()); ++ assert_eq!(frame.info.png_bytes, frame.png().len() as u64); ++ { ++ use sha2::{Digest, Sha256}; ++ assert_eq!(frame.info.png_sha256, format!("{:x}", Sha256::digest(frame.png()))); ++ } ++ assert!(job.preview().unwrap().is_none(), "terminal image is distinct from the intermediate preview slot"); ++ // The renderer's Completed progress is normalized to 1/1, not an SPP counter. ++ assert_eq!((status.progress.done, status.progress.total), (1, 1)); ++ let (sender, receiver) = mpsc::channel(); ++ pending.receiver = receiver; ++ h.app.render_workspace.interactive.pending = Some(pending); ++ InteractiveHeldCallback { job, sender, reply } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_assert_final_export_isolation(h: &mut Harness, job: &solidcraft_engine::render::job::JobHandle) { ++ assert!(h.app.render_workspace.view.job.is_none()); ++ assert!(h.app.render_workspace.view.completed.is_none()); ++ assert!(!h.app.render_workspace.view.result); ++ assert!(h.app.render_workspace.image.is_none()); ++ assert!(!studio::linear_export_available(&h.app)); ++ let registry_error = h.app.session.render_job_handle(job.id()).err().expect("preview must not enter the final registry"); ++ assert!(registry_error.to_string().contains("WrongOwner"), "{registry_error}"); ++ let path = h.dir.join(format!("interactive-not-exportable-{}-{}.png", job.id().session, job.id().serial)); ++ assert!(!path.exists()); ++ let error = h.app.session.execute("render.export", &json!({"job":job.id(),"path":path,"format":"png"})).unwrap_err(); ++ // Require the actual preview/final ownership guard, rather than accepting a ++ // path/format/refusal error which would not prove final-registry isolation. ++ assert!(error.to_string().contains("WrongOwner"), "{error}"); ++ assert!(!path.exists()); ++ assert!(job.frame().unwrap().is_some(), "export refusal must not consume preview pixels"); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_real_snapshot_worker_cpu16_png_is_cached_painted_reused_and_never_final_exported() { ++ let mut h = interactive_ui_fixture(); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_real_snapshot_worker_cpu16_png_is_cached_painted_reused_and_never_final_exported") { ++ return; ++ } ++ let document = h.app.session.doc.clone(); ++ let before = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.0, true); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ // Explicit egui time relative to the inherited clock crosses the 200 ms group; ++ // this does not wait on wall time or sleep to make a race likely. ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let held = interactive_hold_real_completed_callback(&mut h); ++ assert!(interactive::test_cache(&h.app).is_none(), "worker completion alone must not fabricate a UI cache"); ++ let frame = held.job.frame().unwrap().unwrap(); ++ held.sender.send(held.reply).unwrap(); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.3, false, true); ++ assert!(painted); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ let (cached, samples, complete, texture) = interactive::test_cache(&h.app).unwrap(); ++ assert_eq!(cached.job, held.job.id()); ++ assert_eq!(cached.png_sha256, frame.info.png_sha256); ++ assert_eq!(samples, 16); ++ assert!(complete, "completed16 must use the completed key, still only in the provisional UI cache"); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "TargetReached"); ++ assert_eq!(interactive::inspect(&h.app)["provisional"], true); ++ assert_eq!(interactive::inspect(&h.app)["stale"], false); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ let uploaded = &output.textures_delta.set.get(&texture).expect("first real PNG publication must upload a texture").first().unwrap().image; ++ let egui::ImageData::Color(pixels) = uploaded; ++ let png = image::load_from_memory_with_format(frame.png(), image::ImageFormat::Png).unwrap().to_rgba8(); ++ assert_eq!(pixels.size, [png.width() as usize, png.height() as usize]); ++ assert_eq!(pixels.pixels.len(), png.pixels().len()); ++ assert!( ++ pixels.pixels.iter().zip(png.pixels()).all(|(actual, rgba)| *actual == Color32::from_rgba_unmultiplied(rgba[0], rgba[1], rgba[2], rgba[3])) ++ ); ++ output.textures_delta.clear(); ++ assert!( ++ h.ctx ++ .tessellate(output.shapes, output.pixels_per_point) ++ .iter() ++ .any(|shape| matches!(&shape.primitive, egui::epaint::Primitive::Mesh(mesh) if mesh.texture_id == texture && !mesh.indices.is_empty())) ++ ); ++ let (mut repaint, painted) = interactive_acceptance_frame(&mut h, epoch + 0.4, false, true); ++ assert!(painted); ++ assert_eq!(interactive::test_cache(&h.app).unwrap().3, texture); ++ assert!(!repaint.textures_delta.set.contains_key(&texture), "unchanged JobId/sequence/revision must reuse its texture"); ++ repaint.textures_delta.clear(); ++ interactive_assert_final_export_isolation(&mut h, &held.job); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!(before, (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty())); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_real_completed_callback_after_off_and_reenable_cannot_fill_new_cache_or_spawn_twice() { ++ let mut h = interactive_ui_fixture(); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_real_completed_callback_after_off_and_reenable_cannot_fill_new_cache_or_spawn_twice") { ++ return; ++ } ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.0, true); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let held = interactive_hold_real_completed_callback(&mut h); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ assert!(h.app.render_workspace.interactive.pending(), "Off retains the single undrained receiver"); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 1.0, true); ++ let pending = h.app.render_workspace.interactive.pending.as_ref().unwrap(); ++ assert_eq!(pending.ticket.job_id(), held.job.id(), "reactivation cannot replace an undrained capture"); ++ assert!(interactive::test_current(&h.app).expect("Interactive controller access must succeed").is_none()); ++ held.sender.send(held.reply).unwrap(); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 1.1, false, true); ++ assert!(!painted); ++ output.textures_delta.clear(); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(interactive::test_current(&h.app).expect("Interactive controller access must succeed").is_none()); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Updating"); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ interactive_assert_final_export_isolation(&mut h, &held.job); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_real_completed_callback_after_pause_cannot_publish_unseen_old_pixels() { ++ let mut h = interactive_ui_fixture(); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_real_completed_callback_after_pause_cannot_publish_unseen_old_pixels") { ++ return; ++ } ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.0, true); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let held = interactive_hold_real_completed_callback(&mut h); ++ h.app.run("render.interactive", json!({"action":"pause"})).unwrap(); ++ assert!(h.app.render_workspace.interactive.pending()); ++ held.sender.send(held.reply).unwrap(); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.3, false, true); ++ assert!(!painted, "Pause may retain already displayed pixels, but cannot adopt this unseen callback"); ++ output.textures_delta.clear(); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Paused"); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ interactive_assert_final_export_isolation(&mut h, &held.job); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_real_completed_callback_after_camera_edit_is_discarded_then_new_capture_can_publish() { ++ let mut h = interactive_ui_fixture(); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_real_completed_callback_after_camera_edit_is_discarded_then_new_capture_can_publish") { ++ return; ++ } ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.0, true); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let held = interactive_hold_real_completed_callback(&mut h); ++ let old = held.job.id(); ++ let visual = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ let revision = h.app.session.revision; ++ h.app.cam.yaw += 0.2; ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.3, false); ++ assert!(interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap() > visual); ++ assert_eq!(h.app.session.revision, revision); ++ assert!(interactive::test_current(&h.app).expect("Interactive controller access must succeed").is_none()); ++ held.sender.send(held.reply).unwrap(); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.4, false, true); ++ assert!(!painted); ++ output.textures_delta.clear(); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ interactive_assert_final_export_isolation(&mut h, &held.job); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.501, true); ++ let newer = interactive_hold_real_completed_callback(&mut h); ++ assert_ne!(newer.job.id(), old); ++ newer.sender.send(newer.reply).unwrap(); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.6, false, true); ++ assert!(painted); ++ output.textures_delta.clear(); ++ assert_eq!(interactive::test_cache(&h.app).unwrap().0.job, newer.job.id()); ++ assert_eq!(interactive::inspect(&h.app)["samples"], 16); ++ assert_eq!(interactive::inspect(&h.app)["provisional"], true); ++ interactive_assert_final_export_isolation(&mut h, &newer.job); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++struct InteractiveRecoveryReply { ++ id: solidcraft_engine::render::job::JobId, ++ sender: std::sync::mpsc::Sender>, ++ reply: Result, ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_recovery_hold_reply(h: &mut Harness) -> InteractiveRecoveryReply { ++ use std::{sync::mpsc, time::Duration}; ++ let mut pending = h.app.render_workspace.interactive.pending.take().expect("actual tick must dispatch a Snapshot"); ++ let reply = pending.receiver.recv_timeout(Duration::from_secs(60)).expect("actual capture worker did not return"); ++ let id = pending.ticket.job_id(); ++ let (sender, receiver) = mpsc::channel(); ++ pending.receiver = receiver; ++ h.app.render_workspace.interactive.pending = Some(pending); ++ InteractiveRecoveryReply { id, sender, reply } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_recovery_missing_hdr(h: &mut Harness) -> (std::path::PathBuf, Vec) { ++ let path = h.dir.join("interactive-recovery-original.hdr"); ++ let bytes = original_hdr_bytes(128, true); ++ std::fs::write(&path, &bytes).unwrap(); ++ h.app.render_workspace.view.cpu.environment = cpu::Environment::Hdr; ++ hdr::inspect(&mut h.app, hdr::Target::Cpu, path.to_string_lossy().into_owned()).unwrap(); ++ assert!(interactive_request(&h.app).is_ok(), "valid inspected metadata must reach actual worker preparation"); ++ std::fs::remove_file(&path).unwrap(); ++ (path, bytes) ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_recovery_require_error(h: &mut Harness, time: f64) -> serde_json::Value { ++ interactive_clear_acceptance_frame(h, time, true); ++ let status = interactive::inspect(&h.app); ++ assert_eq!(status["phase"], "Error"); ++ assert!(status["error"].as_str().is_some_and(|error| !error.is_empty())); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(interactive::test_current(&h.app).expect("Interactive controller access must succeed").is_none()); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(h.app.render_workspace.view.job.is_none() && h.app.render_workspace.view.completed.is_none()); ++ status["error"].clone() ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_recovery_require_success(h: &mut Harness, dispatch_time: f64, paint_time: f64) -> solidcraft_engine::render::job::JobId { ++ interactive_clear_acceptance_frame(h, dispatch_time, true); ++ let held = interactive_hold_real_completed_callback(h); ++ let id = held.job.id(); ++ held.sender.send(held.reply).unwrap(); ++ let (mut output, painted) = interactive_acceptance_frame(h, paint_time, false, true); ++ assert!(painted); ++ output.textures_delta.clear(); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "TargetReached"); ++ assert_eq!(interactive::inspect(&h.app)["samples"], 16); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ assert_eq!(interactive::test_cache(&h.app).unwrap().0.job, id); ++ interactive_assert_final_export_isolation(h, &held.job); ++ id ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_invalid_hdr_selection_never_dispatches_and_input_edit_can_recover() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_invalid_hdr_selection_never_dispatches_and_input_edit_can_recover") { ++ return; ++ } ++ h.app.render_workspace.view.cpu.environment = cpu::Environment::Hdr; ++ h.app.render_workspace.view.cpu.hdr = hdr::Input::FilePending { path: h.dir.join("not-inspected.hdr").to_string_lossy().into_owned() }; ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let error = interactive_recovery_require_error(&mut h, epoch + 0.3); ++ assert!(h.app.run("render.interactive", json!({"action":"resume"})).is_err()); ++ assert_eq!(interactive_recovery_require_error(&mut h, epoch + 2.0), error); ++ h.app.render_workspace.view.cpu.environment = cpu::Environment::Constant; ++ interactive_clear_acceptance_frame(&mut h, epoch + 2.1, false); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ interactive_recovery_require_success(&mut h, epoch + 2.301, epoch + 2.4); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_real_hdr_file_error_latches_until_same_intent_resume_or_actual_input_edit() { ++ for recovery in ["resume", "edit"] { ++ let mut h = interactive_ui_fixture(); ++ let case = format!("interactive_real_hdr_file_error_latches_until_same_intent_resume_or_actual_input_edit:{recovery}"); ++ if !interactive_test_cpu_branch(&mut h, &case) { ++ continue; ++ } ++ let (path, bytes) = interactive_recovery_missing_hdr(&mut h); ++ let request = interactive_request(&h.app).unwrap(); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch, true); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let failed = interactive_recovery_hold_reply(&mut h); ++ assert!(failed.reply.as_ref().is_err_and(|error| !error.is_empty()), "missing HDR must fail actual preparation: {:?}", failed.reply); ++ assert!( ++ interactive::test_current(&h.app).expect("Interactive controller access must succeed").is_none(), ++ "preparation failure is not an admitted job-status failure" ++ ); ++ let failed_id = failed.id; ++ failed.sender.send(failed.reply).unwrap(); ++ let error = interactive_recovery_require_error(&mut h, epoch + 0.3); ++ for offset in [0.6, 1.0] { ++ assert_eq!(interactive_recovery_require_error(&mut h, epoch + offset), error, "unchanged input must not retry"); ++ } ++ if recovery == "resume" { ++ std::fs::write(&path, bytes).unwrap(); ++ assert_eq!(interactive_request(&h.app).unwrap(), request, "repairing external bytes is not a UI intent edit"); ++ assert_eq!(interactive_recovery_require_error(&mut h, epoch + 1.1), error, "file repair alone cannot silently resume"); ++ h.app.run("render.interactive", json!({"action":"resume"})).unwrap(); ++ } else { ++ h.app.render_workspace.view.cpu.environment = cpu::Environment::Constant; ++ interactive_clear_acceptance_frame(&mut h, epoch + 1.1, false); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ } ++ let new_id = interactive_recovery_require_success(&mut h, epoch + 1.301, epoch + 1.4); ++ assert_ne!(new_id, failed_id); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_user_pause_survives_error_fixing_edit_until_explicit_resume() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_user_pause_survives_error_fixing_edit_until_explicit_resume") { ++ return; ++ } ++ let _ = interactive_recovery_missing_hdr(&mut h); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let failed = interactive_recovery_hold_reply(&mut h); ++ assert!(failed.reply.is_err()); ++ failed.sender.send(failed.reply).unwrap(); ++ interactive_recovery_require_error(&mut h, epoch + 0.3); ++ h.app.run("render.interactive", json!({"action":"pause"})).unwrap(); ++ h.app.render_workspace.view.cpu.environment = cpu::Environment::Constant; ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.4, false); ++ interactive_clear_acceptance_frame(&mut h, epoch + 2.0, true); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Paused"); ++ assert_eq!(interactive::inspect(&h.app)["paused"], true); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ h.app.run("render.interactive", json!({"action":"resume"})).unwrap(); ++ interactive_recovery_require_success(&mut h, epoch + 2.201, epoch + 2.3); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_disconnected_real_callback_transport_latches_and_resume_creates_fresh_capture() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_disconnected_real_callback_transport_latches_and_resume_creates_fresh_capture") { ++ return; ++ } ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let held = interactive_hold_real_completed_callback(&mut h); ++ assert!(held.reply.unwrap(), "native Snapshot/CPU work really finished before transport failure"); ++ // Deliberately close the actual std channel instead of fabricating an Err. ++ // This covers consumer Disconnected, not a claim that the native worker crashed. ++ drop(held.sender); ++ let error = interactive_recovery_require_error(&mut h, epoch + 0.3); ++ assert_eq!(error, h.app.tr("render.interactive_error")); ++ assert_eq!(interactive_recovery_require_error(&mut h, epoch + 1.0), error); ++ interactive_assert_final_export_isolation(&mut h, &held.job); ++ h.app.run("render.interactive", json!({"action":"resume"})).unwrap(); ++ let newer = interactive_recovery_require_success(&mut h, epoch + 1.201, epoch + 1.3); ++ assert_ne!(newer, held.job.id()); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_late_real_preparation_error_cannot_overwrite_edited_or_resumed_intent() { ++ for recovery in ["edit", "resume"] { ++ let mut h = interactive_ui_fixture(); ++ let case = format!("interactive_late_real_preparation_error_cannot_overwrite_edited_or_resumed_intent:{recovery}"); ++ if !interactive_test_cpu_branch(&mut h, &case) { ++ continue; ++ } ++ let (path, bytes) = interactive_recovery_missing_hdr(&mut h); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let failed = interactive_recovery_hold_reply(&mut h); ++ assert!(failed.reply.is_err()); ++ if recovery == "edit" { ++ h.app.render_workspace.view.cpu.environment = cpu::Environment::Constant; ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.3, false); ++ } else { ++ std::fs::write(path, bytes).unwrap(); ++ // First consume clock input without consuming the still-held reply. ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.3, false); ++ h.app.run("render.interactive", json!({"action":"resume"})).unwrap(); ++ } ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.501, true); ++ assert_eq!( ++ h.app.render_workspace.interactive.pending.as_ref().unwrap().ticket.job_id(), ++ failed.id, ++ "one old receiver still blocks new dispatch" ++ ); ++ failed.sender.send(failed.reply).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.6, false); ++ assert!(interactive::inspect(&h.app)["error"].is_null(), "actual old failure must be discarded"); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ let new_id = interactive_recovery_require_success(&mut h, epoch + 0.7, epoch + 0.8); ++ assert_ne!(new_id, failed.id); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_final_priority_never_clears_a_latched_error_or_retries_without_resume() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_final_priority_never_clears_a_latched_error_or_retries_without_resume") { ++ return; ++ } ++ crate::documents::open_tab(&mut h.app, Session::default()).unwrap(); ++ crate::documents::switch(&mut h.app, 0); ++ h.app.ui.tab = "RENDER".into(); ++ h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; ++ h.app.render_workspace.view.draft.width = 16; ++ h.app.render_workspace.view.draft.height = 16; ++ let (path, bytes) = interactive_recovery_missing_hdr(&mut h); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let failed = interactive_recovery_hold_reply(&mut h); ++ assert!(failed.reply.is_err()); ++ failed.sender.send(failed.reply).unwrap(); ++ let error = interactive_recovery_require_error(&mut h, epoch + 0.3); ++ let final_job = { ++ let background = h.app.docs.background_mut().next().unwrap(); ++ background.session.set_render_job_host(Some(solidcraft_engine::render::job::CpuHost::cooperative())).unwrap(); ++ let reply = background.session.execute("render.start", &json!({"settings":{"width":8,"height":8}})).unwrap(); ++ let id = serde_json::from_value(reply["job"].clone()).unwrap(); ++ background.session.render_job_handle(id).unwrap() ++ }; ++ assert_eq!(interactive_recovery_require_error(&mut h, epoch + 0.4), error); ++ assert_eq!(final_job.status().unwrap().progress.phase, solidcraft_engine::render::job::Phase::Queued); ++ assert!(h.app.run("render.interactive", json!({"action":"resume"})).unwrap_err().contains(h.app.tr("render.interactive_final_active"))); ++ assert_eq!(final_job.status().unwrap().progress.phase, solidcraft_engine::render::job::Phase::Queued); ++ // Only the test's explicit owner cancellation ends its queued final. ++ final_job.cancel().unwrap(); ++ assert_eq!(interactive_recovery_require_error(&mut h, epoch + 0.5), error); ++ std::fs::write(path, bytes).unwrap(); ++ h.app.run("render.interactive", json!({"action":"resume"})).unwrap(); ++ interactive_recovery_require_success(&mut h, epoch + 0.701, epoch + 0.8); ++ assert_eq!(final_job.status().unwrap().progress.phase, solidcraft_engine::render::job::Phase::Cancelled); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_actual_png_display_cap_error_latches_until_explicit_resume() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_actual_png_display_cap_error_latches_until_explicit_resume") { ++ return; ++ } ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let held = interactive_hold_real_completed_callback(&mut h); ++ held.sender.send(held.reply).unwrap(); ++ let mut output = h.ctx.run_ui( ++ egui::RawInput { ++ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(420.0, 420.0))), ++ time: Some(epoch + 0.3), ++ ..Default::default() ++ }, ++ |ui| { ++ // Real decoder admission against an invalid display capability; retain ++ // the real CPU PNG and restore input before fonts/end-frame processing. ++ let previous = ui.ctx().input(|input| input.max_texture_side); ++ ui.ctx().input_mut(|input| input.max_texture_side = 0); ++ interactive::before_paint(&mut h.app, ui.ctx()); ++ ui.ctx().input_mut(|input| input.max_texture_side = previous); ++ assert!(!interactive::paint(&h.app, ui, ui.max_rect())); ++ }, ++ ); ++ output.textures_delta.clear(); ++ let error = interactive_recovery_require_error(&mut h, epoch + 0.4); ++ assert_eq!(error, h.app.tr("render.error_display_dimensions")); ++ assert_eq!(interactive_recovery_require_error(&mut h, epoch + 1.0), error, "restoring display cap alone cannot rearm capture"); ++ interactive_assert_final_export_isolation(&mut h, &held.job); ++ h.app.run("render.interactive", json!({"action":"resume"})).unwrap(); ++ let newer = interactive_recovery_require_success(&mut h, epoch + 1.201, epoch + 1.3); ++ assert_ne!(newer, held.job.id()); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_card_dimensions_use_real_paused_preview_not_changed_final_draft() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_card_dimensions_use_real_paused_preview_not_changed_final_draft") { ++ return; ++ } ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_recovery_require_success(&mut h, epoch + 0.201, epoch + 0.3); ++ h.app.run("render.interactive", json!({"action":"pause"})).unwrap(); ++ h.app.render_workspace.view.draft.width = 3840; ++ h.app.render_workspace.view.draft.height = 2160; ++ let mut output = h.ctx.run_ui( ++ egui::RawInput { ++ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(420.0, 420.0))), ++ time: Some(epoch + 0.4), ++ ..Default::default() ++ }, ++ |ui| { ++ interactive::before_paint(&mut h.app, ui.ctx()); ++ interactive::controls(&mut h.app, ui); ++ }, ++ ); ++ let text = crate::test_support::text_shapes(&output).map(|shape| shape.galley.job.text.clone()).collect::>().join("\n"); ++ assert!(text.contains("16 × 16 px"), "actual cached dimensions must be visible: {text}"); ++ assert!(!text.contains("3840 × 2160 px"), "final draft cannot relabel the captured preview"); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Paused"); ++ assert_eq!(interactive::inspect(&h.app)["stale"], true); ++ let (info, samples, complete, _) = interactive::test_cache(&h.app).unwrap(); ++ assert_eq!((info.width, info.height, samples, complete), (16, 16, 16, true)); ++ output.textures_delta.clear(); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[test] ++fn interactive_card_bounds_avoid_current_selection_docks_and_navigation_at_wide_and_narrow_sizes() { ++ for (width, height) in [(1600.0, 1000.0), (760.0, 700.0)] { ++ let mut h = Harness::new(); ++ h.app.ui.tab = "RENDER".into(); ++ h.app.shell.workspace_panels.clear(); ++ let viewport = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, height)); ++ let content = egui::Rect::from_min_max(egui::pos2(0.0, 132.0), egui::pos2(width, height - 56.0)); ++ let left = egui::Rect::from_min_max(egui::pos2(8.0, 140.0), egui::pos2(274.0, height - 64.0)); ++ let right = egui::Rect::from_min_max(egui::pos2(width - 313.0, 140.0), egui::pos2(width - 8.0, height - 64.0)); ++ crate::shell::register_panel(&mut h.app, "render:browser", Some(left), Some(crate::ui_kit::Edge::Left)); ++ crate::shell::register_panel(&mut h.app, "render:inspector", Some(right), Some(crate::ui_kit::Edge::Right)); ++ let centre = (left.right() + right.left()) / 2.0; ++ let navigation = egui::Rect::from_center_size(egui::pos2(centre, content.bottom() - 28.0), egui::vec2(120.0, 40.0)); ++ let axis = egui::Rect::from_min_size(egui::pos2(right.left() - 110.0, content.top()), egui::vec2(110.0, 110.0)); ++ h.app.viewport.layout = ++ Some(crate::viewport_layout::Layout { viewport, drawable: content, content, axis_view: axis, navigation, confirm: egui::Rect::NOTHING }); ++ // A new measured selection replaces the old one in this very frame. ++ // Both positions cut across the old top-centre status/action region. ++ for y in [content.top() + 90.0, content.top() + 180.0] { ++ let selection = egui::Rect::from_center_size(egui::pos2(centre, y), egui::vec2(180.0, 34.0)); ++ crate::shell::register_panel(&mut h.app, "render:selection", Some(selection), None); ++ let available = interactive::overlay_bounds(&h.app, content); ++ assert!(available.is_positive(), "{width}: no space for the Interactive card"); ++ assert!(content.contains_rect(available), "{width}: {available:?} outside {content:?}"); ++ for occupied in [selection, left, right, navigation, axis] { ++ assert!(!available.intersect(occupied).is_positive(), "{width}: {available:?} overlaps {occupied:?}"); ++ } ++ assert!(available.width() >= Tokens::get().control_height + Tokens::get().space_8); ++ } ++ assert!(!interactive::overlay_bounds(&h.app, egui::Rect::NOTHING).is_positive()); ++ assert_eq!(h.app.shell.workspace_panels["render:browser"].0, left); ++ assert_eq!(h.app.shell.workspace_panels["render:inspector"].0, right); ++ } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_overlay_keeps_real_selection_actions_and_pause_off_targets_accessible_without_dispatch() { ++ fn overlay_frame(h: &mut Harness, size: egui::Vec2, events: Vec) { ++ let mut output = h.ctx.run_ui( ++ egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), events, ..Default::default() }, ++ |ui| { ++ // The shell clears Render reservations at the start of a real frame. ++ // Keep the already measured docks but never leave a previous selection ++ // rectangle that could make the moved-call regression pass by accident. ++ h.app.shell.workspace_panels.remove("render:selection"); ++ crate::render_ui::overlays(&mut h.app, ui); ++ }, ++ ); ++ output.textures_delta.clear(); ++ } ++ for size in [egui::vec2(1600.0, 1000.0), egui::vec2(760.0, 700.0)] { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_overlay_selection_controls") { ++ return; ++ } ++ h.call("ui.resize", json!({"width":size.x as u32,"height":size.y as u32})); ++ h.app.run("appearance.assign", json!({"bodies":["Subject"],"appearance":"ABS - Blue"})).unwrap(); ++ h.app.run("select.filter", json!({"mode":"body"})).unwrap(); ++ h.app.run("select.set", json!({"items":[solidcraft_engine::Sel::Body {name:"Subject".into()}]})).unwrap(); ++ h.frames(4); ++ for _ in 0..3 { ++ overlay_frame(&mut h, size, vec![]); ++ } ++ let selection_before = crate::scenario::rect_of("render:selection").unwrap(); ++ let actions_before: Vec<_> = (0..4).map(|index| crate::scenario::rect_of(&format!("selection:action:{index}")).unwrap()).collect(); ++ let document = h.app.session.doc.clone(); ++ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()); ++ let camera = h.app.cam; ++ let docks = h.app.shell.workspace_panels.clone(); ++ h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ // Paint the production overlays, but never tick or run a Snapshot worker. ++ for _ in 0..3 { ++ overlay_frame(&mut h, size, vec![]); ++ } ++ let card = crate::scenario::rect_of("render:interactive-card").unwrap(); ++ let selection = crate::scenario::rect_of("render:selection").unwrap(); ++ assert_eq!(selection, selection_before, "our card must not move the author's toolbar"); ++ assert!(!card.intersect(selection).is_positive()); ++ let content = crate::render_ui::canvas(&h.app, h.app.viewport.rect.unwrap()); ++ assert!(content.contains_rect(card), "{size:?}: {card:?} outside {content:?}"); ++ for (index, before) in actions_before.iter().enumerate() { ++ let action = crate::scenario::rect_of(&format!("selection:action:{index}")).unwrap(); ++ assert_eq!(&action, before); ++ assert!(selection.contains_rect(action)); ++ assert!(!card.intersect(action).is_positive(), "author action {index} is occluded"); ++ } ++ for action in ["pause", "off"] { ++ let target = crate::scenario::rect_of(&format!("render:interactive:{action}")).unwrap(); ++ assert!(card.contains_rect(target), "{size:?}: {action} clipped outside {card:?}: {target:?}"); ++ assert!(!selection.intersect(target).is_positive()); ++ } ++ for action in ["pause", "off"] { ++ let at = crate::scenario::rect_of(&format!("render:interactive:{action}")).unwrap().center(); ++ for pressed in [true, false] { ++ overlay_frame( ++ &mut h, ++ size, ++ vec![ ++ egui::Event::PointerMoved(at), ++ egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE }, ++ ], ++ ); ++ } ++ overlay_frame(&mut h, size, vec![]); ++ assert_eq!(interactive::inspect(&h.app)["paused"], action == "pause"); ++ assert_eq!(interactive::inspect(&h.app)["enabled"], action != "off"); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ } ++ assert_eq!(h.app.cam, camera); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), history); ++ assert!(h.app.render_workspace.view.job.is_none() && h.app.render_workspace.view.completed.is_none()); ++ for id in ["render:browser", "render:inspector", "render:appearances", "render:shots_strip"] { ++ let current = h.app.shell.workspace_panels.get(id).map(|(rect, edge)| (*rect, edge.as_ref().map(std::mem::discriminant))); ++ let before = docks.get(id).map(|(rect, edge)| (*rect, edge.as_ref().map(std::mem::discriminant))); ++ assert_eq!(current, before, "{id}"); ++ } ++ // With Interactive Off, the author's real hit target still dispatches. ++ let favorite_count = h.app.preferences.render_library_favorites.len(); ++ h.step(&json!({"click":{"handle":"selection:action:2"}})).unwrap(); ++ assert_eq!(h.app.preferences.render_library_favorites.len(), favorite_count + 1); ++ assert_eq!(crate::scenario::rect_of("render:selection").unwrap(), selection_before); ++ } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_waiting_show_text(h: &mut Harness, time: f64) -> String { ++ let mut output = h.ctx.run_ui( ++ egui::RawInput { ++ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 900.0))), ++ time: Some(time), ++ ..Default::default() ++ }, ++ |ui| show(&mut h.app, ui), ++ ); ++ let text = crate::test_support::text_shapes(&output).map(|shape| shape.galley.job.text.clone()).collect::>().join("\n"); ++ output.textures_delta.clear(); ++ text ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_waiting_canvas_uses_real_show_and_keeps_off_pause_error_and_result_routes() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_waiting_canvas_uses_real_show_and_keeps_off_pause_error_and_result_routes") { ++ return; ++ } ++ assert!(h.app.viewport.gpu.is_none(), "the fallback refusal is the real no-GPU positive control"); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ let fallback = h.app.tr("render.error_gpu_preview").to_string(); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ assert!(interactive_waiting_show_text(&mut h, epoch + 0.01).contains(&fallback)); ++ ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let waiting = interactive_waiting_show_text(&mut h, epoch + 0.02); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Updating"); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(!waiting.contains(&fallback), "real show must not enter the model-preview refusal while waiting"); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(!h.app.render_workspace.interactive.pending(), "show/before_paint must not dispatch"); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.025, false, true); ++ assert!(!painted, "reserving the canvas does not claim an image was painted"); ++ output.textures_delta.clear(); ++ ++ h.app.render_workspace.view.result = true; ++ assert!(!interactive::awaiting_current_frame(&h.app), "the result view keeps priority"); ++ h.app.render_workspace.view.result = false; ++ h.app.render_workspace.view.method = ImageMethod::Raster; ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; ++ h.app.ui.tab = "MODEL".into(); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ h.app.ui.tab = "RENDER".into(); ++ ++ h.app.run("render.interactive", json!({"action":"pause"})).unwrap(); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ assert!(interactive_waiting_show_text(&mut h, epoch + 0.03).contains(&fallback), "pause before any image keeps its existing fallback"); ++ h.app.run("render.interactive", json!({"action":"resume"})).unwrap(); ++ assert!(!interactive_waiting_show_text(&mut h, epoch + 0.04).contains(&fallback)); ++ h.app.render_workspace.view.cpu.environment = cpu::Environment::Hdr; ++ h.app.render_workspace.view.cpu.hdr = hdr::Input::FilePending { path: h.dir.join("not-inspected.hdr").to_string_lossy().into_owned() }; ++ let error = interactive_waiting_show_text(&mut h, epoch + 0.05); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Error"); ++ assert!(!interactive::inspect(&h.app)["error"].is_null()); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ assert!(error.contains(&fallback), "an input error keeps the existing model-preview route"); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ assert!(interactive_waiting_show_text(&mut h, epoch + 0.06).contains(&fallback)); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_waiting_canvas_after_supported_edit_drops_old_pixels_and_new_capture_still_publishes() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_waiting_canvas_after_supported_edit_drops_old_pixels_and_new_capture_still_publishes") { ++ return; ++ } ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.render_workspace.view.raytrace.shadows = true; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let old = interactive_recovery_require_success(&mut h, epoch + 0.201, epoch + 0.3); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ let visual = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ let document = h.app.session.doc.clone(); ++ ++ h.app.render_workspace.view.raytrace.shadows = false; ++ let text = interactive_waiting_show_text(&mut h, epoch + 0.4); ++ assert!(interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap() > visual); ++ assert!(interactive::test_cache(&h.app).is_none(), "the previously accepted image must be dropped"); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(!text.contains(h.app.tr("render.error_gpu_preview"))); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.41, false, true); ++ assert!(!painted, "old pixels cannot become current while the new request waits"); ++ output.textures_delta.clear(); ++ ++ let new = interactive_recovery_require_success(&mut h, epoch + 0.901, epoch + 1.0); ++ assert_ne!(new, old); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ let job = interactive::test_current(&h.app).unwrap().unwrap(); ++ assert_eq!(job.id(), new); ++ assert!(!job.status().unwrap().request.raytrace.as_ref().unwrap().shadows); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc), "presentation and runtime settings do not author CAD state"); ++ interactive_assert_final_export_isolation(&mut h, &job); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_waiting_canvas_preserves_paused_out_of_date_pixels_and_resume_waits_without_fallback() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_waiting_canvas_preserves_paused_out_of_date_pixels_and_resume_waits_without_fallback") { ++ return; ++ } ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.render_workspace.view.raytrace.shadows = true; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_recovery_require_success(&mut h, epoch + 0.201, epoch + 0.3); ++ let (before, samples, complete, texture) = interactive::test_cache(&h.app).unwrap(); ++ h.app.run("render.interactive", json!({"action":"pause"})).unwrap(); ++ h.app.render_workspace.view.raytrace.shadows = false; ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.4, false, true); ++ assert!(painted, "explicit pause still permits the already displayed image"); ++ output.textures_delta.clear(); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Paused"); ++ assert_eq!(interactive::inspect(&h.app)["stale"], true); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ let (after, after_samples, after_complete, after_texture) = interactive::test_cache(&h.app).unwrap(); ++ assert_eq!((after.job, after.png_sha256), (before.job, before.png_sha256)); ++ assert_eq!((after_samples, after_complete, after_texture), (samples, complete, texture)); ++ ++ h.app.run("render.interactive", json!({"action":"resume"})).unwrap(); ++ let text = interactive_waiting_show_text(&mut h, epoch + 0.5); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Updating"); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(!text.contains(h.app.tr("render.error_gpu_preview"))); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.51, false, true); ++ assert!(!painted); ++ output.textures_delta.clear(); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_waiting_canvas_camera_late_callback_and_document_switch_never_adopt_old_pixels() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_waiting_canvas_camera_late_callback_and_document_switch_never_adopt_old_pixels") { ++ return; ++ } ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch, true); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let held = interactive_hold_real_completed_callback(&mut h); ++ let visual = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ h.app.cam.yaw += 0.2; ++ let text = interactive_waiting_show_text(&mut h, epoch + 0.3); ++ assert!(interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap() > visual); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(!text.contains(h.app.tr("render.error_gpu_preview"))); ++ held.sender.send(held.reply).unwrap(); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.4, false, true); ++ assert!(!painted); ++ output.textures_delta.clear(); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(interactive::test_current(&h.app).unwrap().is_none()); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ interactive_assert_final_export_isolation(&mut h, &held.job); ++ ++ let old_uid = h.app.session.uid; ++ crate::documents::open_tab(&mut h.app, Session::default()).unwrap(); ++ assert_ne!(h.app.session.uid, old_uid); ++ assert!(!interactive::awaiting_current_frame(&h.app), "a foreign context cannot reserve the canvas even before refresh"); ++ h.app.ui.tab = "RENDER".into(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.5, false); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.6, false, true); ++ assert!(!painted, "neither the old image nor its waiting presentation belongs to another document"); ++ output.textures_delta.clear(); ++ assert_eq!(interactive::inspect(&h.app)["enabled"], false); ++ assert!(h.app.render_workspace.view.job.is_none() && h.app.render_workspace.view.completed.is_none()); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_waiting_canvas_rejects_live_foreign_session_without_resetting_context() { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_waiting_canvas_rejects_live_foreign_session_without_resetting_context") { ++ return; ++ } ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ let before = interactive::inspect(&h.app); ++ assert_eq!(before["enabled"], true); ++ assert_eq!(before["phase"], "Updating"); ++ assert_eq!(before["paused"], false); ++ assert!(before["error"].is_null()); ++ assert!(!h.app.render_workspace.view.result); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ ++ let uid = h.app.session.uid; ++ let document = h.app.session.doc.clone(); ++ let mut foreign = Session::new((*document).clone()); ++ assert_ne!(foreign.uid, uid); ++ // Use real engine Sessions and the same ownership swap as documents::swap_in. ++ // Deliberately omit the UI reset: it would otherwise mask is_current's guard. ++ // Retain the original Session so its registry/controller lifetime stays live. ++ std::mem::swap(&mut h.app.session, &mut foreign); ++ assert_ne!(h.app.session.uid, uid); ++ assert_eq!(h.app.session.doc, document, "equal design contents do not confer session ownership"); ++ assert_eq!(interactive::inspect(&h.app), before, "the context is still enabled, not reset or refreshed"); ++ assert!(active(&h.app)); ++ assert_eq!(h.app.render_workspace.view.method, ImageMethod::CpuRaytrace); ++ assert!(!h.app.render_workspace.view.result); ++ assert!(!interactive::awaiting_current_frame(&h.app), "a live context owned by another Session cannot reserve the canvas"); ++ assert_eq!(interactive::inspect(&h.app), before, "the predicate must remain read-only"); ++ ++ std::mem::swap(&mut h.app.session, &mut foreign); ++ assert_eq!(h.app.session.uid, uid); ++ assert_eq!(interactive::inspect(&h.app), before); ++ assert!(interactive::awaiting_current_frame(&h.app), "restoring the real owner proves the same context remained live"); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ assert!(!h.app.render_workspace.interactive.pending()); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_canvas_input_frame(h: &mut Harness, time: &mut f64, events: Vec) { ++ *time += 1.0 / 60.0; ++ let mut output = h.ctx.run_ui( ++ egui::RawInput { ++ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 900.0))), ++ time: Some(*time), ++ focused: true, ++ events, ++ ..Default::default() ++ }, ++ |ui| show(&mut h.app, ui), ++ ); ++ output.textures_delta.clear(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_canvas_input_fixture(case: &str) -> Option<(Harness, f64, egui::Pos2)> { ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, case) { ++ return None; ++ } ++ h.app.run("select.filter", json!({"mode":"body"})).unwrap(); ++ h.app.run("select.clear", json!({})).unwrap(); ++ let scene = solidcraft_engine::product_scene::extract(&h.app.session).unwrap(); ++ h.app.cam.fit(&scene.bounds); ++ h.app.preferences.nav = "fusion".into(); ++ h.app.preferences.zoom_to_cursor = false; ++ h.app.preferences.smooth_wheel_zoom = false; ++ let mut time = interactive::test_clock(&h.app).as_secs_f64(); ++ for _ in 0..3 { ++ interactive_canvas_input_frame(&mut h, &mut time, vec![]); ++ } ++ let rect = h.app.viewport.rect.unwrap(); ++ let projection = crate::viewport::projection(&h.app, rect); ++ let at = projection.to_screen(h.app.cam.target).unwrap(); ++ assert!(!crate::shell::covered(&h.app, at)); ++ assert!( ++ crate::viewport::pick(&h.app, &projection, at).iter().any(|hit| matches!(hit, crate::viewport::Hit::Face { body, .. } if body == "Subject")) ++ ); ++ interactive_canvas_input_frame(&mut h, &mut time, vec![egui::Event::PointerMoved(at)]); ++ Some((h, time, at)) ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn interactive_canvas_input_click(h: &mut Harness, time: &mut f64, at: egui::Pos2, button: egui::PointerButton, mods: egui::Modifiers) { ++ interactive_canvas_input_frame(h, time, vec![egui::Event::ModifiersChanged(mods), egui::Event::PointerMoved(at)]); ++ for pressed in [true, false] { ++ interactive_canvas_input_frame(h, time, vec![egui::Event::PointerButton { pos: at, button, pressed, modifiers: mods }]); ++ } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_blank_canvas_blocks_hover_selection_and_context_but_off_keeps_real_targets() { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("interactive_blank_canvas_blocks_hover_selection_and_context_but_off_keeps_real_targets") ++ else { ++ return; ++ }; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let document = h.app.session.doc.clone(); ++ let undo = h.app.session.undo.len(); ++ for mods in [egui::Modifiers::NONE, egui::Modifiers::SHIFT, egui::Modifiers::CTRL] { ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Primary, mods); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(h.app.viewport.hover.is_none(), "hidden geometry cannot advertise a hover target"); ++ assert!(h.app.session.selection.is_empty(), "plain/add/toggle clicks cannot select invisible geometry"); ++ } ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Secondary, egui::Modifiers::NONE); ++ assert!(h.app.viewport.context_menu.is_none(), "a right click cannot open a menu for hidden geometry"); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!(h.app.session.undo.len(), undo); ++ assert!(!h.app.render_workspace.interactive.pending(), "show never dispatches a capture"); ++ ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ assert!(h.app.viewport.hover.is_some(), "the same real hit remains available with Interactive Off"); ++ assert!(h.app.session.selection.contains(&solidcraft_engine::Sel::Body { name: "Subject".into() })); ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Secondary, egui::Modifiers::NONE); ++ assert!(h.app.viewport.context_menu.is_some(), "the same native canvas click still opens the normal body menu"); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_blank_canvas_neither_paints_nor_samples_and_escape_and_off_still_work() { ++ for sampling in [false, true] { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("interactive_blank_canvas_neither_paints_nor_samples_and_escape_and_off_still_work") ++ else { ++ return; ++ }; ++ if sampling { ++ h.app.start("appearance.pick_up"); ++ } else { ++ assign::arm(&mut h.app, json!({"appearance":"ABS - Blue"})).unwrap(); ++ } ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let document = h.app.session.doc.clone(); ++ let undo = h.app.session.undo.len(); ++ let look = h.app.render_workspace.view.assign.look.clone(); ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!(h.app.session.undo.len(), undo); ++ assert_eq!(h.app.render_workspace.view.assign.look, look, "no hidden face is sampled"); ++ assert_eq!(h.app.render_workspace.view.assign.sampling, sampling); ++ assert_eq!(h.app.render_workspace.view.assign.painting, !sampling); ++ ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }], ++ ); ++ assert!(!h.app.render_workspace.view.assign.painting && !h.app.render_workspace.view.assign.sampling); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: false, repeat: false, modifiers: egui::Modifiers::NONE }], ++ ); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ if sampling { ++ h.app.start("appearance.pick_up"); ++ } else { ++ assign::arm(&mut h.app, json!({"appearance":"ABS - Blue"})).unwrap(); ++ } ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ if sampling { ++ assert!(!h.app.render_workspace.view.assign.sampling); ++ assert!(h.app.render_workspace.view.assign.painting, "Off permits real sampling to arm paint"); ++ } else { ++ assert_eq!(h.app.session.undo.len(), undo + 1); ++ assert_eq!(h.app.session.doc.appearances.bodies.get("Subject").unwrap().name, "ABS - Blue"); ++ } ++ } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_blank_canvas_clears_real_drag_preview_and_release_cannot_apply_hidden_target() { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("interactive_blank_canvas_clears_real_drag_preview_and_release_cannot_apply_hidden_target") ++ else { ++ return; ++ }; ++ let document = h.app.session.doc.clone(); ++ let undo = h.app.session.undo.len(); ++ assign::tile(&mut h.app, json!({"appearance":"ABS - Blue"}), true).unwrap(); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE }], ++ ); ++ assert!(assign::preview(&h.app).is_some(), "positive control: real Off drag reached geometry"); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_canvas_input_frame(&mut h, &mut time, vec![egui::Event::PointerMoved(at)]); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(assign::preview(&h.app).is_none()); ++ assert!(assign::hover(&h.app).is_none()); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE }], ++ ); ++ assert!(assign::preview(&h.app).is_none()); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!(h.app.session.undo.len(), undo); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_current_and_paused_images_keep_canvas_paint_and_final_observation() { ++ for paused in [false, true] { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("interactive_current_and_paused_images_keep_canvas_paint_and_final_observation") ++ else { ++ return; ++ }; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let job = interactive_recovery_require_success(&mut h, time + 0.3, time + 0.4); ++ time += 0.4; ++ if paused { ++ h.app.run("render.interactive", json!({"action":"pause"})).unwrap(); ++ } ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ assert!(h.app.session.selection.contains(&solidcraft_engine::Sel::Body { name: "Subject".into() })); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ assert_eq!(interactive::test_cache(&h.app).unwrap().0.job, job); ++ let undo = h.app.session.undo.len(); ++ assign::arm(&mut h.app, json!({"appearance":"ABS - Blue"})).unwrap(); ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ assert_eq!(h.app.session.undo.len(), undo + 1); ++ assert_eq!(h.app.session.doc.appearances.bodies.get("Subject").unwrap().name, "ABS - Blue"); ++ if paused { ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Paused"); ++ assert_eq!(interactive::inspect(&h.app)["stale"], true); ++ assert_eq!(interactive::test_cache(&h.app).unwrap().0.job, job); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ } else { ++ assert!(interactive::test_cache(&h.app).is_none(), "the final observation sees the appearance edit made by this canvas click"); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ } ++ assert!(!h.app.render_workspace.interactive.pending()); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_canvas_reobserves_pending_edit_before_release_and_navigation_still_updates_camera() { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("interactive_canvas_reobserves_pending_edit_before_release_and_navigation_still_updates_camera") ++ else { ++ return; ++ }; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_recovery_require_success(&mut h, time + 0.3, time + 0.4); ++ time += 0.4; ++ interactive_canvas_input_frame(&mut h, &mut time, vec![egui::Event::PointerMoved(at)]); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE }], ++ ); ++ let visual = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ h.app.render_workspace.view.raytrace.shadows = !h.app.render_workspace.view.raytrace.shadows; ++ assert!(interactive::test_cache(&h.app).is_some(), "before show, old UI state has not yet observed the visible setting edit"); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE }], ++ ); ++ assert!(interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap() > visual); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(h.app.session.selection.is_empty(), "the release cannot pick using the previous frame's cache/phase"); ++ assert!(h.app.viewport.hover.is_none()); ++ ++ let camera = h.app.cam; ++ let document = h.app.session.doc.clone(); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::MouseWheel { ++ unit: egui::MouseWheelUnit::Line, ++ delta: egui::vec2(0.0, 3.0), ++ modifiers: egui::Modifiers::NONE, ++ phase: egui::TouchPhase::Move, ++ }], ++ ); ++ assert_ne!(h.app.cam, camera, "the waiting guard must not swallow real shared camera navigation"); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(h.app.viewport.hover.is_none()); ++ assert!(!h.app.render_workspace.interactive.pending(), "neither observation dispatches Snapshot"); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_accepted_image_drag_setting_edit_and_immediate_release_never_applies_hidden_target() { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("interactive_accepted_image_drag_setting_edit_and_immediate_release_never_applies_hidden_target") ++ else { ++ return; ++ }; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let job = interactive_recovery_require_success(&mut h, time + 0.3, time + 0.4); ++ time += 0.4; ++ interactive_canvas_input_frame(&mut h, &mut time, vec![egui::Event::PointerMoved(at)]); ++ let (accepted, samples, complete, texture) = interactive::test_cache(&h.app).unwrap(); ++ assert_eq!(accepted.job, job); ++ assert_eq!((samples, complete), (16, true)); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ ++ let document = h.app.session.doc.clone(); ++ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()); ++ let selection = h.app.session.selection.clone(); ++ assign::tile(&mut h.app, json!({"appearance":"ABS - Blue"}), true).unwrap(); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE }], ++ ); ++ assert!(assign::preview(&h.app).is_some(), "the real drag must start over the accepted CPU image"); ++ assert!(assign::hover(&h.app).is_some()); ++ let (pressed, pressed_samples, pressed_complete, pressed_texture) = interactive::test_cache(&h.app).unwrap(); ++ assert_eq!((pressed.job, &pressed.png_sha256), (job, &accepted.png_sha256)); ++ assert_eq!((pressed_samples, pressed_complete, pressed_texture), (samples, complete, texture)); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ ++ let visual = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ h.app.render_workspace.view.raytrace.shadows = !h.app.render_workspace.view.raytrace.shadows; ++ // No tick, show, refresh, move or other UI frame between this edit and release. ++ // The old image/drag are still present, so only same-frame observation can reject the drop. ++ let (before_release, _, _, before_release_texture) = interactive::test_cache(&h.app).unwrap(); ++ assert_eq!((before_release.job, &before_release.png_sha256, before_release_texture), (job, &accepted.png_sha256, texture)); ++ assert!(assign::preview(&h.app).is_some()); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE }], ++ ); ++ assert!(interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap() > visual); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(assign::preview(&h.app).is_none()); ++ assert!(assign::hover(&h.app).is_none()); ++ assert!(h.app.viewport.hover.is_none()); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()), history); ++ assert_eq!(h.app.session.selection, selection); ++ assert!(!h.app.render_workspace.interactive.pending(), "show must not dispatch Snapshot to consume this release"); ++ assert!(interactive::test_current(&h.app).unwrap().is_none(), "show must not attach a replacement CPU job"); ++ assert!(active(&h.app)); ++ assert!(!h.app.render_workspace.view.assign.painting && !h.app.render_workspace.view.assign.sampling); ++ assert!(!assign::cancel(&mut h.app), "the release must consume the drag; nothing may remain for Escape to cancel"); ++ ++ interactive_canvas_input_frame(&mut h, &mut time, vec![]); ++ assert!(assign::preview(&h.app).is_none() && assign::hover(&h.app).is_none()); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()), history); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(interactive::test_current(&h.app).unwrap().is_none()); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_blank_canvas_clicks_preserve_selection_created_on_the_accepted_image() { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("interactive_blank_canvas_clicks_preserve_selection_created_on_the_accepted_image") ++ else { ++ return; ++ }; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_recovery_require_success(&mut h, time + 0.3, time + 0.4); ++ time += 0.4; ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ assert!(h.app.session.selection.contains(&solidcraft_engine::Sel::Body { name: "Subject".into() })); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ let selection = h.app.session.selection.clone(); ++ let document = h.app.session.doc.clone(); ++ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()); ++ ++ h.app.render_workspace.view.raytrace.shadows = !h.app.render_workspace.view.raytrace.shadows; ++ interactive_canvas_input_frame(&mut h, &mut time, vec![]); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ for mods in [egui::Modifiers::NONE, egui::Modifiers::SHIFT, egui::Modifiers::CTRL] { ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Primary, mods); ++ assert_eq!(h.app.session.selection, selection, "blank-canvas clicks cannot clear, add to or toggle the existing selection"); ++ assert!(h.app.viewport.hover.is_none()); ++ assert!(interactive::awaiting_current_frame(&h.app)); ++ } ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()), history); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[test] ++fn gpu_failed_host_keeps_specific_reason_in_image_params_and_disabled_commands() { ++ let mut h = Harness::new(); ++ enter(&mut h.app, true).unwrap(); ++ h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; ++ let document = h.app.session.doc.clone(); ++ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()); ++ for reason in ["This Direct3D 12 session has not tested Vulkan.", "Vulkan device creation failed: deliberate independent diagnostic 47."] { ++ h.app.render_workspace.path_host = PathHost::Failed(reason.into()); ++ assert_ne!(reason, h.app.tr("render.gpu_unavailable")); ++ assert_eq!(image_params(&h.app).unwrap_err(), reason); ++ for id in ["render.preflight", "render.start"] { ++ let command = solidcraft_engine::find_command(id).unwrap(); ++ assert!(command.info(&h.app.session).enabled, "the engine must not hide the UI readiness check"); ++ let info = interactive_command_info(&h.app, command); ++ assert!(!info.enabled, "{id}"); ++ assert_eq!(info.disabled_reason.as_deref(), Some(reason), "{id}"); ++ } ++ assert!(matches!(&h.app.render_workspace.path_host, PathHost::Failed(stored) if stored == reason)); ++ assert_eq!(h.app.render_workspace.view.method, ImageMethod::GpuRaytrace); ++ } ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), history); ++ assert!(h.app.render_workspace.view.job.is_none()); ++} ++ ++#[test] ++fn gpu_pending_hosts_keep_generic_disabled_reason_without_starting_setup() { ++ let mut h = Harness::new(); ++ enter(&mut h.app, true).unwrap(); ++ h.app.render_workspace.view.method = ImageMethod::GpuRaytrace; ++ let generic = h.app.tr("render.gpu_unavailable").to_string(); ++ // This channel represents a still-pending answer; no worker or GPU factory is created. ++ let (_sender, receiver) = std::sync::mpsc::channel(); ++ for host in [PathHost::NotStarted, PathHost::Preparing(receiver, std::time::Instant::now())] { ++ let preparing = matches!(&host, PathHost::Preparing(..)); ++ h.app.render_workspace.path_host = host; ++ assert_eq!(image_params(&h.app).unwrap_err(), generic); ++ for id in ["render.preflight", "render.start"] { ++ let info = interactive_command_info(&h.app, solidcraft_engine::find_command(id).unwrap()); ++ assert!(!info.enabled, "{id}"); ++ assert_eq!(info.disabled_reason.as_deref(), Some(generic.as_str()), "{id}"); ++ } ++ assert_eq!(matches!(&h.app.render_workspace.path_host, PathHost::Preparing(..)), preparing); ++ assert!(matches!(&h.app.render_workspace.path_host, PathHost::NotStarted | PathHost::Preparing(..))); ++ assert!(h.app.render_workspace.view.job.is_none()); ++ } ++} ++ ++#[test] ++fn gpu_failed_host_preserves_raster_readiness_and_cooperative_cpu_refusal() { ++ let mut h = Harness::new(); ++ h.app.run("solid.box", json!({"length":10,"width":12,"height":3})).unwrap(); ++ enter(&mut h.app, true).unwrap(); ++ h.app.render_workspace.image_host = Some(solidcraft_engine::render::job::CpuHost::cooperative()); ++ sync_backend(&mut h.app); ++ h.app.render_workspace.view.draft.width = 16; ++ h.app.render_workspace.view.draft.height = 16; ++ for method in [ImageMethod::Raster, ImageMethod::CpuRaytrace] { ++ h.app.render_workspace.view.method = method; ++ h.app.render_workspace.path_host = PathHost::NotStarted; ++ let baseline = image_params(&h.app); ++ if method == ImageMethod::Raster { ++ assert!(baseline.is_ok(), "cooperative Raster must be available: {baseline:?}"); ++ } else { ++ assert_eq!(method, ImageMethod::CpuRaytrace); ++ let error = baseline.as_ref().unwrap_err(); ++ assert!(error.contains("CPU raytracing"), "cooperative CPU must retain its own host refusal: {error}"); ++ assert_ne!(error, h.app.tr("render.gpu_unavailable")); ++ } ++ let baseline_commands = ["render.preflight", "render.start"].map(|id| { ++ let info = interactive_command_info(&h.app, solidcraft_engine::find_command(id).unwrap()); ++ assert_eq!(info.enabled, method == ImageMethod::Raster, "{method:?}: {id}"); ++ assert_eq!(info.disabled_reason.as_deref(), baseline.as_ref().err().map(String::as_str), "{method:?}: {id}"); ++ (id, info.enabled, info.disabled_reason) ++ }); ++ let document = h.app.session.doc.clone(); ++ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()); ++ let reason = "Deliberate GPU-only refusal must not replace another method's readiness."; ++ h.app.render_workspace.path_host = PathHost::Failed(reason.into()); ++ assert_eq!(image_params(&h.app), baseline, "{method:?}: preserve the exact success or rejection"); ++ for (id, enabled, disabled_reason) in baseline_commands { ++ let info = interactive_command_info(&h.app, solidcraft_engine::find_command(id).unwrap()); ++ assert_eq!(info.enabled, enabled, "{method:?}: {id}"); ++ assert_eq!(info.disabled_reason, disabled_reason, "{method:?}: {id}"); ++ } ++ assert!(matches!(&h.app.render_workspace.path_host, PathHost::Failed(stored) if stored == reason)); ++ assert_eq!(h.app.render_workspace.view.method, method); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len()), history); ++ assert!(h.app.render_workspace.view.job.is_none()); ++ } ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_area_and_led_real_snapshot_pixels_reach_receiver_cache_without_final_export() { ++ use solidcraft_engine::render::job::{RectangleLightOptions, led_strip::LedStripOptions}; ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_area_and_led_real_snapshot_pixels_reach_receiver_cache_without_final_export") { ++ return; ++ } ++ h.app.render_workspace.view.raytrace.area_lights = Some(vec![RectangleLightOptions { ++ center_mm: [5.0, 4.0, 20.0], ++ edge_u_mm: [4.0, 0.0, 0.0], ++ edge_v_mm: [0.0, -4.0, 0.0], ++ color: [1.0, 0.5, 0.25], ++ intensity: 2.0, ++ }]); ++ h.app.render_workspace.view.raytrace.area_samples = Some(4); ++ h.app.render_workspace.view.raytrace.seed = Some(73); ++ LedStripOptions { ++ center_mm: [5.0, 4.0, 12.0], ++ length_mm: 8.0, ++ width_mm: 1.0, ++ length_axis: [1.0, 0.0, 0.0], ++ width_axis: [0.0, -1.0, 0.0], ++ color: [0.25, 0.5, 1.0], ++ intensity: 3.0, ++ } ++ .append_to(&mut h.app.render_workspace.view.raytrace, 4) ++ .unwrap(); ++ h.app.render_workspace.view.draft.exposure_ev = 0.75; ++ let expected = h.app.render_workspace.view.raytrace.area_lights.clone().unwrap(); ++ assert_eq!(expected.len(), 2); ++ let document = h.app.session.doc.clone(); ++ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ // Existing helper dispatches the real Snapshot, receives its real reply, ++ // validates real native PNG bytes/hash, drains the reply and paints the cache. ++ let id = interactive_recovery_require_success(&mut h, epoch + 0.201, epoch + 0.3); ++ let job = interactive::test_current(&h.app).unwrap().unwrap(); ++ assert_eq!(job.id(), id); ++ let status = job.status().unwrap(); ++ let options = status.request.raytrace.as_ref().unwrap(); ++ assert_eq!(options.area_lights.as_ref(), Some(&expected)); ++ assert_eq!(options.area_samples, Some(4)); ++ assert_eq!(options.seed, Some(73)); ++ assert_eq!(options.exposure_ev, 0.75); ++ assert_eq!(options.progressive.unwrap().samples_per_pixel, 16); ++ let (cached, samples, complete, _) = interactive::test_cache(&h.app).unwrap(); ++ let frame = job.frame().unwrap().unwrap(); ++ assert_eq!((cached.job, cached.png_sha256), (id, frame.info.png_sha256.clone())); ++ assert_eq!((cached.width, cached.height, samples, complete), (16, 16, 16, true)); ++ assert_eq!(interactive::inspect(&h.app)["provisional"], true); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()), history); ++ interactive_assert_final_export_isolation(&mut h, &job); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn interactive_led_light_edit_and_final_preemption_discard_real_late_replies_without_erasing_final() { ++ use solidcraft_engine::render::job::{CpuHost, JobId, Phase, led_strip::LedStripOptions}; ++ let mut h = interactive_ui_fixture(); ++ if !interactive_test_cpu_branch(&mut h, "interactive_led_light_edit_and_final_preemption_discard_real_late_replies_without_erasing_final") { ++ return; ++ } ++ crate::documents::open_tab(&mut h.app, Session::default()).unwrap(); ++ crate::documents::switch(&mut h.app, 0); ++ h.app.ui.tab = "RENDER".into(); ++ h.app.render_workspace.view.method = ImageMethod::CpuRaytrace; ++ h.app.render_workspace.view.draft.width = 16; ++ h.app.render_workspace.view.draft.height = 16; ++ LedStripOptions { ++ center_mm: [5.0, 4.0, 12.0], ++ length_mm: 8.0, ++ width_mm: 1.0, ++ length_axis: [1.0, 0.0, 0.0], ++ width_axis: [0.0, -1.0, 0.0], ++ color: [1.0, 0.5, 0.25], ++ intensity: 2.0, ++ } ++ .append_to(&mut h.app.render_workspace.view.raytrace, 4) ++ .unwrap(); ++ h.app.render_workspace.view.raytrace.seed = Some(91); ++ let document = h.app.session.doc.clone(); ++ let history = (h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()); ++ let epoch = interactive::test_clock(&h.app).as_secs_f64(); ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.201, true); ++ let first = interactive_hold_real_completed_callback(&mut h); ++ let old = first.job.id(); ++ let old_options = first.job.status().unwrap().request.raytrace.unwrap(); ++ assert_eq!(old_options.area_lights.as_ref().unwrap().first().unwrap().intensity, 2.0); ++ assert_eq!((old_options.area_samples, old_options.seed), (Some(4), Some(91))); ++ let visual = interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap(); ++ h.app.render_workspace.view.raytrace.area_lights.as_mut().unwrap().first_mut().unwrap().intensity = 1.5; ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.3, false); ++ assert!(interactive::inspect(&h.app)["visual_revision"].as_u64().unwrap() > visual); ++ assert!(interactive::test_current(&h.app).unwrap().is_none(), "light edit must detach the old owned job"); ++ first.sender.send(first.reply).unwrap(); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.4, false, true); ++ assert!(!painted); ++ output.textures_delta.clear(); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ interactive_assert_final_export_isolation(&mut h, &first.job); ++ ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.601, true); ++ let second = interactive_hold_real_completed_callback(&mut h); ++ assert_ne!(second.job.id(), old); ++ let new_options = second.job.status().unwrap().request.raytrace.unwrap(); ++ assert_eq!(new_options.area_lights.as_ref().unwrap().first().unwrap().intensity, 1.5); ++ assert_eq!((new_options.area_samples, new_options.seed), (Some(4), Some(91))); ++ let final_host = CpuHost::cooperative(); ++ let final_job = { ++ let background = h.app.docs.background_mut().next().unwrap(); ++ background.session.set_render_job_host(Some(final_host.clone())).unwrap(); ++ let reply = background.session.execute("render.start", &json!({"settings":{"width":8,"height":8}})).unwrap(); ++ let id: JobId = serde_json::from_value(reply["job"].clone()).unwrap(); ++ background.session.render_job_handle(id).unwrap() ++ }; ++ let retained = final_host.admitted_bytes(); ++ interactive_clear_acceptance_frame(&mut h, epoch + 0.7, false); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Paused"); ++ second.sender.send(second.reply).unwrap(); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, epoch + 0.8, false, true); ++ assert!(!painted, "a final-suspended late LED reply cannot fill the preview cache"); ++ output.textures_delta.clear(); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(interactive::test_current(&h.app).unwrap().is_none()); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ assert!(interactive::inspect(&h.app)["error"].is_null()); ++ interactive_assert_final_export_isolation(&mut h, &second.job); ++ assert_eq!(final_job.status().unwrap().progress.phase, Phase::Queued); ++ assert_eq!(final_host.admitted_bytes(), retained); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!((h.app.session.revision, h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.is_dirty()), history); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ assert_eq!(final_job.status().unwrap().progress.phase, Phase::Queued, "Off cannot cancel the unrelated final"); ++ final_job.cancel().unwrap(); ++} +diff --git a/docs/render-cpu-progressive.md b/docs/render-cpu-progressive.md +index a31b70ea..789f2e3a 100644 +--- a/docs/render-cpu-progressive.md ++++ b/docs/render-cpu-progressive.md +@@ -73,15 +73,23 @@ render host is installed. + | Directional / point / spot sources | Existing CPU light contracts and limits | + | Constant / captured HDR environment | Existing CPU contracts; HDR plus rough reflections still requires certified fully metallic selected bodies and effective faces | + | Surface emission / isotropic surface effects | Existing CPU appearance contracts; emission is visible radiance | +-| Area / LED sources | Explicitly rejected in this initial progressive mode | ++| Area / LED sources | Existing bounded rectangle direct-light transport; continuous LED recipes lower to the same sources | + | Dielectric / anisotropic face overrides | Explicitly rejected in this initial progressive mode | + | Output | Opaque PNG with the existing display background | + + An incompatible request fails; it does not remove settings or switch methods. + The fixed CPU route retains its existing area, dielectric and anisotropy support. ++Progressive area/LED uses at most four shared rectangle slots, with ++`area_samples` of 1/4/16/64 (default 16) and the existing combined light caps. ++Each film pass uses the existing area-power normalization and cumulative work ++budget; increasing emitter samples does not multiply emitted power. The area ++pattern uses `raytrace.seed`, separately from the camera-jitter seed ++`raytrace.progressive.seed`. One emitter sample still uses its centre. This is ++direct lighting, with no MIS or diffuse GI; general glass and anisotropic ++progressive transport remain unsupported. Host-pool and profile limits are unchanged. + At 1024 × 1024 the camera-sample cap allows at most 16 samples per pixel; at +-512 × 512 it allows 64. Requests are also subject to the existing geometry, +-384 MiB CPU job and 512 MiB shared host-pool admission limits. Traversal, ++512 × 512 it allows 64. Requests are also subject to the selected CPU resource profile's geometry, ++job-memory and shared-host pool limits; see [CPU resource profiles](render-cpu-resource-profiles.md). Traversal, + shading, film updates, resolve, PNG encoding and hashing share one cumulative + 1,000,000,000-unit work ceiling. The count is not reset at a pass boundary. + The camera-sample limit is a cold upper bound, not a promise that every scene +diff --git a/docs/render-interactive.md b/docs/render-interactive.md +index bea2e2ca..08b04ac8 100644 +--- a/docs/render-interactive.md ++++ b/docs/render-interactive.md +@@ -14,6 +14,9 @@ final request stays untouched. Integer aspect rounding is at most half a pixel + (or one pixel for an extreme aspect). Transparent output, another integrator or + unsupported progressive transport returns an error instead of dropping effects. + The existing profile and host still enforce geometry, traversal and memory limits. ++Rectangle/LED direct-light inputs, their emitter-sample count and area-pattern ++seed survive preview lowering unchanged. Only camera/reflection sampling uses ++the preview envelope; dielectric and anisotropic overrides still fail explicitly. + + ## Adapter contract + +@@ -29,6 +32,9 @@ The existing profile and host still enforce geometry, traversal and memory limit + - Explicit activation calls `enable`; edits call `edit`. Supply monotonic elapsed + `Duration` values. `capture` issues one ticket after 200 ms without a newer edit. + Do not evaluate geometry or read files every frame just to compare identity. ++- Recheck `accepts_capture(ticket)` before expensive capture/admission and after ++ worker preparation. This avoids preparing an already obsolete request; it does ++ not replace the mandatory identity checks in `attach` after admission. + - Capture through the existing authoritative engine boundary, prepare the CPU + request, then admit/submit through the installed CPU host using + `CaptureTicket::job_id()`. Pass the resulting handle to `attach` +diff --git a/docs/render-settings.md b/docs/render-settings.md +index e3f99d8e..fe7f3a3f 100644 +--- a/docs/render-settings.md ++++ b/docs/render-settings.md +@@ -162,9 +162,10 @@ using the existing CPU transport. An absent/null value preserves fixed AA; an + empty object defaults to 16 samples and seed 0. Samples are 1..64 and the seed is + u32. `primary_samples` must be 1, output is at most 1,048,576 pixels, and + `width × height × samples_per_pixel` is at most 16,777,216. Saving checks these +-limits without a render host. Area/LED lights, dielectric and anisotropic-face +-overrides are refused in this mode; the fixed CPU route retains them. Embedded +-HDR and one setup exposure remain compatible. See ++limits without a render host. Area/LED direct lights retain the existing four ++shared rectangle slots, emitter-sample counts and power normalization. Dielectric ++and anisotropic-face overrides remain refused; the fixed CPU route retains them. ++Embedded HDR and one setup exposure remain compatible. See + [CPU progressive sampling](render-cpu-progressive.md) for reflection limits, + work admission and provisional/final publication. The top-level runtime + `progressive: true` continues to select GPU. +diff --git a/assets/locales/pending/render-interactive.json b/assets/locales/pending/render-interactive.json +new file mode 100644 +--- /dev/null ++++ b/assets/locales/pending/render-interactive.json +@@ -0,0 +1,164 @@ ++{ ++ "en": { ++ "cmd.render.interactive": "Interactive Render", ++ "help.render.interactive": "Explicitly enable a provisional CPU preview while editing. Final render settings and exportable images stay unchanged.", ++ "render.interactive_error": "Interactive preview error", ++ "render.interactive_final_active": "Final render active", ++ "render.interactive_off": "Off", ++ "render.interactive_on": "On", ++ "render.interactive_pause": "Pause", ++ "render.interactive_paused": "Paused", ++ "render.interactive_provisional": "Provisional preview", ++ "render.interactive_refining": "Refining preview", ++ "render.interactive_requires_cpu": "Interactive preview requires CPU ray tracing.", ++ "render.interactive_resume": "Resume", ++ "render.interactive_samples": "{done}/{total} SPP", ++ "render.interactive_stale": "Out of date", ++ "render.interactive_target": "Sample target reached", ++ "render.interactive_updating": "Updating" ++ }, ++ "ar": { ++ "cmd.render.interactive": "تصيير تفاعلي", ++ "help.render.interactive": "فعّل معاينة مؤقتة باستخدام المعالج CPU أثناء التحرير. تبقى إعدادات التصيير النهائي والصور القابلة للتصدير دون تغيير.", ++ "render.interactive_error": "خطأ في المعاينة التفاعلية", ++ "render.interactive_final_active": "التصيير النهائي قيد التنفيذ", ++ "render.interactive_off": "إيقاف", ++ "render.interactive_on": "تفعيل", ++ "render.interactive_pause": "إيقاف مؤقت", ++ "render.interactive_paused": "متوقف مؤقتًا", ++ "render.interactive_provisional": "معاينة مؤقتة", ++ "render.interactive_refining": "جارٍ تحسين المعاينة", ++ "render.interactive_requires_cpu": "تتطلب المعاينة التفاعلية تتبّع الأشعة على المعالج CPU.", ++ "render.interactive_resume": "استئناف", ++ "render.interactive_samples": "{done}/{total} SPP", ++ "render.interactive_stale": "غير محدثة", ++ "render.interactive_target": "تم بلوغ عدد العينات المطلوب", ++ "render.interactive_updating": "جارٍ التحديث" ++ }, ++ "de": { ++ "cmd.render.interactive": "Interaktives Rendering", ++ "help.render.interactive": "Aktivieren Sie die vorläufige CPU-Vorschau zum Bearbeiten manuell. Einstellungen für das finale Rendering und exportierbare Bilder bleiben unverändert.", ++ "render.interactive_error": "Fehler in der interaktiven Vorschau", ++ "render.interactive_final_active": "Finales Rendering aktiv", ++ "render.interactive_off": "Aus", ++ "render.interactive_on": "Ein", ++ "render.interactive_pause": "Pausieren", ++ "render.interactive_paused": "Pausiert", ++ "render.interactive_provisional": "Vorläufige Vorschau", ++ "render.interactive_refining": "Vorschau wird verfeinert", ++ "render.interactive_requires_cpu": "Die interaktive Vorschau erfordert CPU-Raytracing.", ++ "render.interactive_resume": "Fortsetzen", ++ "render.interactive_samples": "{done}/{total} SPP", ++ "render.interactive_stale": "Nicht aktuell", ++ "render.interactive_target": "Zielanzahl an Samples erreicht", ++ "render.interactive_updating": "Wird aktualisiert" ++ }, ++ "es": { ++ "cmd.render.interactive": "Render interactivo", ++ "help.render.interactive": "Activa explícitamente una vista previa provisional por CPU mientras editas. Los ajustes del render final y las imágenes exportables se mantienen intactos.", ++ "render.interactive_error": "Error en la vista previa interactiva", ++ "render.interactive_final_active": "Render final activo", ++ "render.interactive_off": "Desactivar", ++ "render.interactive_on": "Activar", ++ "render.interactive_pause": "Pausar", ++ "render.interactive_paused": "En pausa", ++ "render.interactive_provisional": "Vista previa provisional", ++ "render.interactive_refining": "Refinando vista previa", ++ "render.interactive_requires_cpu": "La vista previa interactiva requiere trazado de rayos por CPU.", ++ "render.interactive_resume": "Reanudar", ++ "render.interactive_samples": "{done}/{total} SPP", ++ "render.interactive_stale": "Desactualizada", ++ "render.interactive_target": "Número objetivo de muestras alcanzado", ++ "render.interactive_updating": "Actualizando" ++ }, ++ "he": { ++ "cmd.render.interactive": "רינדור אינטראקטיבי", ++ "help.render.interactive": "יש להפעיל במפורש תצוגה מקדימה זמנית במעבד CPU בזמן העריכה. הגדרות הרינדור הסופי והתמונות הזמינות לייצוא נשארות ללא שינוי.", ++ "render.interactive_error": "שגיאה בתצוגה המקדימה האינטראקטיבית", ++ "render.interactive_final_active": "הרינדור הסופי פעיל", ++ "render.interactive_off": "כיבוי", ++ "render.interactive_on": "הפעלה", ++ "render.interactive_pause": "השהיה", ++ "render.interactive_paused": "מושהה", ++ "render.interactive_provisional": "תצוגה מקדימה זמנית", ++ "render.interactive_refining": "משפר את התצוגה המקדימה", ++ "render.interactive_requires_cpu": "תצוגה מקדימה אינטראקטיבית דורשת עקיבת קרניים במעבד CPU.", ++ "render.interactive_resume": "המשך", ++ "render.interactive_samples": "{done}/{total} SPP", ++ "render.interactive_stale": "לא עדכני", ++ "render.interactive_target": "הושג מספר הדגימות המבוקש", ++ "render.interactive_updating": "מעדכן" ++ }, ++ "ja": { ++ "cmd.render.interactive": "インタラクティブレンダリング", ++ "help.render.interactive": "編集中にCPUによる暫定プレビューを明示的に有効にします。最終レンダリングの設定とエクスポート可能な画像は変更しません。", ++ "render.interactive_error": "インタラクティブプレビューのエラー", ++ "render.interactive_final_active": "最終レンダリング中", ++ "render.interactive_off": "無効にする", ++ "render.interactive_on": "有効にする", ++ "render.interactive_pause": "一時停止", ++ "render.interactive_paused": "一時停止中", ++ "render.interactive_provisional": "暫定プレビュー", ++ "render.interactive_refining": "プレビューを改善中", ++ "render.interactive_requires_cpu": "インタラクティブプレビューにはCPUレイトレーシングが必要です。", ++ "render.interactive_resume": "再開", ++ "render.interactive_samples": "{done}/{total} SPP", ++ "render.interactive_stale": "最新ではありません", ++ "render.interactive_target": "目標サンプル数に到達", ++ "render.interactive_updating": "更新中" ++ }, ++ "ko": { ++ "cmd.render.interactive": "대화형 렌더링", ++ "help.render.interactive": "편집하는 동안 임시 CPU 미리 보기를 직접 켭니다. 최종 렌더링 설정과 내보낼 수 있는 이미지는 변경하지 않습니다.", ++ "render.interactive_error": "대화형 미리 보기 오류", ++ "render.interactive_final_active": "최종 렌더링 진행 중", ++ "render.interactive_off": "끄기", ++ "render.interactive_on": "켜기", ++ "render.interactive_pause": "일시 중지", ++ "render.interactive_paused": "일시 중지됨", ++ "render.interactive_provisional": "임시 미리 보기", ++ "render.interactive_refining": "미리 보기 개선 중", ++ "render.interactive_requires_cpu": "대화형 미리 보기에는 CPU 레이 트레이싱이 필요합니다.", ++ "render.interactive_resume": "계속", ++ "render.interactive_samples": "{done}/{total} SPP", ++ "render.interactive_stale": "최신 상태가 아님", ++ "render.interactive_target": "목표 샘플 수 도달", ++ "render.interactive_updating": "업데이트 중" ++ }, ++ "vi": { ++ "cmd.render.interactive": "Kết xuất tương tác", ++ "help.render.interactive": "Chủ động bật bản xem trước tạm thời bằng CPU khi chỉnh sửa. Thiết lập kết xuất cuối và các ảnh có thể xuất vẫn được giữ nguyên.", ++ "render.interactive_error": "Lỗi xem trước tương tác", ++ "render.interactive_final_active": "Đang kết xuất ảnh cuối", ++ "render.interactive_off": "Tắt", ++ "render.interactive_on": "Bật", ++ "render.interactive_pause": "Tạm dừng", ++ "render.interactive_paused": "Đã tạm dừng", ++ "render.interactive_provisional": "Bản xem trước tạm thời", ++ "render.interactive_refining": "Đang cải thiện bản xem trước", ++ "render.interactive_requires_cpu": "Xem trước tương tác yêu cầu dò tia bằng CPU.", ++ "render.interactive_resume": "Tiếp tục", ++ "render.interactive_samples": "{done}/{total} SPP", ++ "render.interactive_stale": "Chưa cập nhật", ++ "render.interactive_target": "Đã đạt số mẫu mục tiêu", ++ "render.interactive_updating": "Đang cập nhật" ++ }, ++ "zh": { ++ "cmd.render.interactive": "交互式渲染", ++ "help.render.interactive": "编辑时手动启用临时 CPU 预览。最终渲染设置和可导出的图像保持不变。", ++ "render.interactive_error": "交互式预览错误", ++ "render.interactive_final_active": "最终渲染进行中", ++ "render.interactive_off": "关闭", ++ "render.interactive_on": "启用", ++ "render.interactive_pause": "暂停", ++ "render.interactive_paused": "已暂停", ++ "render.interactive_provisional": "临时预览", ++ "render.interactive_refining": "正在细化预览", ++ "render.interactive_requires_cpu": "交互式预览需要 CPU 光线追踪。", ++ "render.interactive_resume": "继续", ++ "render.interactive_samples": "{done}/{total} SPP", ++ "render.interactive_stale": "不是最新状态", ++ "render.interactive_target": "已达到目标采样数", ++ "render.interactive_updating": "正在更新" ++ } ++} +diff --git a/crates/engine/src/render_interactive.rs b/crates/engine/src/render_interactive.rs +new file mode 100644 +--- /dev/null ++++ b/crates/engine/src/render_interactive.rs +@@ -0,0 +1,400 @@ ++//! Transient CPU Interactive capture, separate from final render ownership/export. ++use std::sync::{Arc, Mutex, Weak}; ++use std::time::Duration; ++ ++use serde_json::Value; ++use solidcraft_render::job::{ ++ self, ErrorCode, JobError, JobHandle, ++ interactive::{CaptureTicket, Interactive, State, VisualRevision}, ++}; ++ ++use crate::{Result, Session, render_jobs::job_error}; ++ ++pub(crate) type Controller = Mutex; ++ ++/// A poisoned lifecycle is never resumed. Cleanup only its owned work, then fail. ++pub(crate) fn with_controller(controller: &Controller, f: impl FnOnce(&mut Interactive) -> job::Result) -> job::Result { ++ match controller.lock() { ++ Ok(mut state) => f(&mut state), ++ Err(poisoned) => { ++ let _ = poisoned.into_inner().disable(); ++ Err(JobError::new(ErrorCode::Internal, "Interactive lifecycle lock poisoned")) ++ } ++ } ++} ++ ++/// One transient controller for the current document/service registration. ++/// Only Session::interactive_render allocates its dedicated preview namespace. ++pub struct InteractiveRender { ++ document_uid: u64, ++ preview_session: u64, ++ controller: Arc, ++} ++ ++impl InteractiveRender { ++ pub(crate) fn new(document_uid: u64, preview_session: u64, final_active: bool) -> job::Result { ++ if document_uid == 0 || preview_session == 0 { ++ return Err(JobError::new(ErrorCode::LimitExceeded, "Interactive identity exhausted")); ++ } ++ let mut state = Interactive::new(preview_session); ++ state.set_final_active(final_active, Duration::ZERO)?; ++ Ok(Self { document_uid, preview_session, controller: Arc::new(Mutex::new(state)) }) ++ } ++ ++ pub(crate) fn weak(&self) -> Weak { ++ Arc::downgrade(&self.controller) ++ } ++ ++ fn with(&self, f: impl FnOnce(&mut Interactive) -> job::Result) -> Result { ++ with_controller(&self.controller, f).map_err(job_error) ++ } ++ ++ /// Cheap ownership metadata only: no geometry, files, host discovery or work. ++ pub fn is_current(&self, session: &Session) -> bool { ++ self.document_uid == session.uid && session.render_jobs.is_interactive_current(&self.weak()) ++ } ++ ++ pub fn document_uid(&self) -> u64 { ++ self.document_uid ++ } ++ ++ pub fn enable(&self, revision: VisualRevision, now: Duration) -> Result<()> { ++ self.with(|state| state.enable(revision, now)) ++ } ++ ++ pub fn edit(&self, revision: VisualRevision, now: Duration) -> Result<()> { ++ self.with(|state| state.edit(revision, now)) ++ } ++ ++ pub fn disable(&self) -> Result<()> { ++ self.with(Interactive::disable) ++ } ++ ++ pub fn pause(&self) -> Result<()> { ++ self.with(Interactive::pause) ++ } ++ ++ pub fn resume(&self, now: Duration) -> Result<()> { ++ self.with(|state| state.resume(now)) ++ } ++ ++ pub fn set_final_active(&self, active: bool, now: Duration) -> Result<()> { ++ self.with(|state| state.set_final_active(active, now)) ++ } ++ ++ pub fn capture(&self, now: Duration) -> Result> { ++ self.with(|state| state.capture(now)) ++ } ++ ++ pub fn state(&self) -> Result { ++ self.with(|state| state.state()) ++ } ++ ++ pub fn current(&self) -> Result> { ++ self.with(|state| Ok(state.current().cloned())) ++ } ++ ++ /// Capture failures live in the controller; worker failures live in its job. ++ pub fn error(&self) -> Result> { ++ self.with(|state| { ++ if let Some(error) = state.error() { ++ return Ok(Some(error.to_string())); ++ } ++ let status = state.current().map(JobHandle::status).transpose()?; ++ Ok(status.and_then(|status| status.error).map(|error| error.to_string())) ++ }) ++ } ++ ++ pub fn capture_failed(&self, ticket: CaptureTicket, message: String) -> Result<()> { ++ self.with(|state| { ++ state.capture_failed(ticket, JobError::new(ErrorCode::InvalidScene, message)); ++ Ok(()) ++ }) ++ } ++ ++ fn reject_snapshot(&self, ticket: CaptureTicket, error: JobError) -> Result { ++ self.with(|state| { ++ state.capture_failed(ticket, error.clone()); ++ Ok(()) ++ })?; ++ Err(job_error(error)) ++ } ++ ++ /// Freeze one complete UI intent and document. The caller supplies the same ++ /// immutable numerical intent that produced this visual revision/ticket. ++ /// A name, CAD revision or reused Value alone is not visual provenance. ++ pub fn snapshot(&self, session: &Session, ticket: CaptureTicket, params: &Value) -> Result { ++ if !self.is_current(session) || ticket.job_id().session != self.preview_session || ticket.revision().scene_generation != session.revision { ++ return self.reject_snapshot( ++ ticket, ++ JobError::new(ErrorCode::WrongOwner, "Interactive capture belongs to another document or service revision"), ++ ); ++ } ++ if session.model.is_stale() { ++ return self.reject_snapshot(ticket, JobError::new(ErrorCode::InvalidScene, "finish the modelling gesture before Interactive capture")); ++ } ++ if !self.with(|state| Ok(state.accepts_capture(ticket)))? { ++ return self.reject_snapshot(ticket, JobError::new(ErrorCode::WrongOwner, "Interactive capture ticket is no longer current")); ++ } ++ Ok(Snapshot { ++ session: session.scratch(), ++ params: params.clone(), ++ ticket, ++ controller: self.weak(), ++ scope: solidcraft_io::vfs::current_scope(), ++ }) ++ } ++} ++ ++impl Drop for InteractiveRender { ++ fn drop(&mut self) { ++ let _ = self.disable(); ++ } ++} ++ ++/// Immutable capture envelope; no engine worker or queue is created here. ++/// The caller maintains one app-wide capture worker, including across tab swaps. ++pub struct Snapshot { ++ session: Session, ++ params: Value, ++ ticket: CaptureTicket, ++ controller: Weak, ++ scope: Option, ++} ++ ++/// Internal output of the ordinary authoritative CPU preparation boundary. ++pub(crate) struct Prepared { ++ pub(crate) scene: solidcraft_render::ProductScene, ++ pub(crate) request: job::ImageRequest, ++ pub(crate) options: job::JobOptions, ++ pub(crate) environment: Option, ++} ++ ++/// This guard only receives a record just created by this capture, never a ++/// caller's retained/manual/foreign handle. Dropping a JobHandle alone is not a ++/// cancellation request: native queue/running work keeps its own clone. ++struct Unadopted { ++ job: JobHandle, ++ adopted: bool, ++} ++ ++impl Drop for Unadopted { ++ fn drop(&mut self) { ++ if !self.adopted { ++ let _ = self.job.cancel(); ++ } ++ } ++} ++ ++/// Adopt a newly submitted local record. Even an equal-ID duplicate is cancelled ++/// when rejected: it is a different new record, not a copy of the accepted job. ++pub(crate) fn adopt_created(controller: &Controller, ticket: CaptureTicket, job: JobHandle) -> job::Result { ++ if job.id().session != ticket.job_id().session { ++ return Err(JobError::new(ErrorCode::WrongOwner, "created Interactive record has another identity")); ++ } ++ let mut pending = Unadopted { job, adopted: false }; ++ let accepted = with_controller(controller, |state| state.attach(ticket, pending.job.clone()))?; ++ pending.adopted = accepted; ++ Ok(accepted) ++} ++ ++impl Snapshot { ++ /// Correlate the caller's receiver and discard old errors after tab changes. ++ pub fn ticket(&self) -> CaptureTicket { ++ self.ticket ++ } ++ ++ pub fn document_uid(&self) -> u64 { ++ self.session.uid ++ } ++ ++ /// Invoke beside the window, never while holding a lifecycle lock. Both ++ /// preparation and admission may be long; edits/finals can invalidate either. ++ pub fn run(mut self) -> Result { ++ let Some(controller) = self.controller.upgrade() else { return Ok(false) }; ++ if !with_controller(&controller, |state| Ok(state.accepts_capture(self.ticket))).map_err(job_error)? { ++ return Ok(false); ++ } ++ let result = (|| { ++ let prepared = solidcraft_io::vfs::scoped(self.scope.take(), || crate::cmd::prepare_interactive(&self.session, &self.params))?; ++ if !with_controller(&controller, |state| Ok(state.accepts_capture(self.ticket))).map_err(job_error)? { ++ return Ok(false); ++ } ++ let host = self ++ .session ++ .render_job_host() ++ .ok_or_else(|| job_error(JobError::new(ErrorCode::HostUnavailable, "CPU image host is unavailable")))?; ++ let job = host ++ .submit_with_environment_and_options( ++ self.ticket.job_id(), ++ self.ticket.revision().scene_generation, ++ prepared.scene, ++ prepared.request, ++ prepared.options, ++ prepared.environment, ++ ) ++ .map_err(job_error)?; ++ adopt_created(&controller, self.ticket, job).map_err(job_error) ++ })(); ++ if let Err(error) = &result { ++ let _ = with_controller(&controller, |state| { ++ state.capture_failed(self.ticket, JobError::new(ErrorCode::InvalidScene, error.to_string())); ++ Ok(()) ++ }); ++ } ++ result ++ } ++} ++ ++/// Opaque visual-source stamp: no placed world, mesh, strong document or B-rep ++/// ownership. Construct only after the previous stamp stops matching; retain it ++/// and call is_current on each frame instead of cloning session metadata again. ++pub struct SceneIdentity { ++ uid: u64, ++ revision: u64, ++ document: Weak, ++ model: Weak, ++ pending_moves: std::collections::BTreeMap, ++ active_sketch: Option, ++ active_component: u64, ++ active_occurrence_path: Option>, ++ visibility: solidcraft_doc::Visibility, ++} ++ ++impl SceneIdentity { ++ /// Exact metadata comparison. model.state only clones the existing evaluated ++ /// Arc; it neither evaluates nor places bodies nor obtains a display mesh. ++ /// Weak allocation identities cannot alias a later allocation while retained. ++ pub fn is_current(&self, session: &Session) -> bool { ++ self.uid == session.uid ++ && self.revision == session.revision ++ && Weak::ptr_eq(&self.document, &Arc::downgrade(&session.doc)) ++ && Weak::ptr_eq(&self.model, &Arc::downgrade(&session.model.state())) ++ && self.pending_moves == session.pending_moves ++ && self.active_sketch == session.active_sketch ++ && self.active_component == session.active_component ++ && self.active_occurrence_path == session.active_occurrence_path ++ && self.visibility == session.visibility ++ } ++} ++ ++impl Session { ++ /// Source identity without computing cold assembly placements or meshes. ++ /// Stale modelling gestures must still be rejected separately before capture. ++ /// View camera/draft/output edits belong to the caller's visual intent stamp. ++ pub fn interactive_scene_identity(&self) -> SceneIdentity { ++ SceneIdentity { ++ uid: self.uid, ++ revision: self.revision, ++ document: Arc::downgrade(&self.doc), ++ model: Arc::downgrade(&self.model.state()), ++ pending_moves: self.pending_moves.clone(), ++ active_sketch: self.active_sketch, ++ active_component: self.active_component, ++ active_occurrence_path: self.active_occurrence_path.clone(), ++ visibility: self.visibility.clone(), ++ } ++ } ++} ++ ++impl Session { ++ /// Existing prepared world only, for Interactive reflection-binding proof. ++ /// None is not a capture-availability decision: SceneIdentity remains valid ++ /// for cold assemblies and the capture worker prepares their real world. ++ pub fn interactive_cached_world_state(&self) -> Option> { ++ self.cached_world_state() ++ } ++} ++ ++// Exact identity checks must not prepare cold geometry on the window thread. ++#[cfg(test)] ++#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] ++mod scene_identity_tests { ++ use super::*; ++ use serde_json::json; ++ ++ #[test] ++ fn cold_assembly_stamp_neither_places_nor_meshes() { ++ let mut session = Session::default(); ++ session.execute("solid.box", &json!({"length":10,"width":20,"height":5,"body_name":"Source"})).unwrap(); ++ // A root body plus an empty placed component is a valid cold assembly. ++ let doc = session.doc_mut(); ++ doc.components.push(solidcraft_doc::Component { id: 100, name: "Empty component".into(), ..Default::default() }); ++ doc.occurrences.push(solidcraft_doc::Occurrence { ++ id: 101, ++ component: 100, ++ parent: 0, ++ name: "Empty placement".into(), ++ transform: solidcraft_doc::IDENTITY, ++ grounded: false, ++ }); ++ assert!(session.world_cache.lock().unwrap().is_none()); ++ let state = session.model.state(); ++ assert!(state.body("Source").unwrap().cached_mesh().is_none()); ++ let stamp = session.interactive_scene_identity(); ++ for _ in 0..10 { ++ assert!(stamp.is_current(&session)); ++ } ++ assert!(session.world_cache.lock().unwrap().is_none()); ++ assert!(state.body("Source").unwrap().cached_mesh().is_none()); ++ } ++ ++ #[test] ++ fn exact_context_and_visibility_changes_invalidate_without_revision() { ++ let mut session = Session::default(); ++ let revision = session.revision; ++ let stamp = session.interactive_scene_identity(); ++ session.pending_moves.insert(7, solidcraft_doc::IDENTITY); ++ assert!(!stamp.is_current(&session)); ++ session.pending_moves.clear(); ++ assert!(stamp.is_current(&session)); ++ session.active_component = 7; ++ assert!(!stamp.is_current(&session)); ++ session.active_component = 0; ++ session.active_occurrence_path = Some(vec![7, 8]); ++ assert!(!stamp.is_current(&session)); ++ session.active_occurrence_path = None; ++ session.active_sketch = Some(9); ++ assert!(!stamp.is_current(&session)); ++ session.active_sketch = None; ++ session.visibility.hidden_occurrences.push(vec![7, 8]); ++ assert!(!stamp.is_current(&session)); ++ session.visibility.hidden_occurrences.clear(); ++ session.visibility.hidden_folders.push("c0/bodies".into()); ++ assert!(!stamp.is_current(&session)); ++ assert_eq!(session.revision, revision); ++ } ++ ++ #[test] ++ fn stamp_has_no_strong_document_or_model_retention() { ++ let session = Session::default(); ++ let model = session.model.state(); ++ let doc_count = Arc::strong_count(&session.doc); ++ let model_count = Arc::strong_count(&model); ++ let doc = Arc::downgrade(&session.doc); ++ let weak_model = Arc::downgrade(&model); ++ let stamp = session.interactive_scene_identity(); ++ assert_eq!(Arc::strong_count(&session.doc), doc_count); ++ assert_eq!(Arc::strong_count(&model), model_count); ++ assert!(stamp.is_current(&session)); ++ drop(model); ++ drop(session); ++ assert!(doc.upgrade().is_none()); ++ assert!(weak_model.upgrade().is_none()); ++ // Retained Weak allocation identities cannot be recycled for a new object. ++ let replacement = Session { uid: stamp.uid, revision: stamp.revision, ..Default::default() }; ++ assert!(!stamp.is_current(&replacement)); ++ } ++ ++ #[test] ++ fn same_document_and_revision_do_not_hide_a_replaced_evaluated_model() { ++ let mut session = Session::default(); ++ let stamp = session.interactive_scene_identity(); ++ session.model = Session::default().model; ++ assert!(!stamp.is_current(&session)); ++ let refreshed = session.interactive_scene_identity(); ++ assert!(refreshed.is_current(&session)); ++ session.revision += 1; ++ assert!(!refreshed.is_current(&session)); ++ } ++} +diff --git a/crates/ui-egui/src/render_workspace_interactive.rs b/crates/ui-egui/src/render_workspace_interactive.rs +new file mode 100644 +--- /dev/null ++++ b/crates/ui-egui/src/render_workspace_interactive.rs +@@ -0,0 +1,649 @@ ++//! Opt-in CPU checkpoints. This cache and its capture receiver are app-wide, ++//! never part of saved setups, final results or export ownership. ++use super::ImageMethod; ++use crate::{SolveApp, theme::Tokens, ui_kit}; ++use serde_json::{Value, json}; ++#[cfg(not(target_arch = "wasm32"))] ++use solidcraft_engine::render_interactive::Snapshot; ++use solidcraft_engine::{ ++ render::job::{ ++ FrameInfo, HostKind, Integrator, JobId, ++ interactive::{CaptureTicket, State as Phase, VisualRevision}, ++ }, ++ render_interactive::{InteractiveRender, SceneIdentity}, ++ schema::render_ui::Action, ++}; ++use std::{sync::mpsc, time::Duration}; ++ ++struct Intent { ++ scene: SceneIdentity, ++ uid: u64, ++ revision: u64, ++ camera: solidcraft_engine::render::Camera, ++ stale: bool, ++ request: Result, ++} ++ ++pub(super) struct Pending { ++ pub(super) uid: u64, ++ pub(super) ticket: CaptureTicket, ++ pub(super) receiver: mpsc::Receiver>, ++} ++#[derive(Clone, Copy, PartialEq, Eq)] ++struct PixelKey { ++ job: JobId, ++ sequence: u32, ++ complete: bool, ++} ++struct Cached { ++ key: PixelKey, ++ revision: VisualRevision, ++ info: FrameInfo, ++ samples: u32, ++ stale: bool, ++ texture: Result, ++} ++ ++pub(super) struct State { ++ context: Option, ++ pub(super) pending: Option, ++ issued: Option, ++ observed: Option, ++ visual: u64, ++ clock: Duration, ++ phase: Phase, ++ user_paused: bool, ++ final_active: bool, ++ error: Option, ++ frame: Option, ++} ++impl Default for State { ++ fn default() -> Self { ++ Self { ++ context: None, ++ pending: None, ++ issued: None, ++ observed: None, ++ visual: 0, ++ clock: Duration::ZERO, ++ phase: Phase::Off, ++ user_paused: false, ++ final_active: false, ++ error: None, ++ frame: None, ++ } ++ } ++} ++impl State { ++ /// Never drop a live receiver to make room for a second capture thread. ++ pub(super) fn reset_document(&mut self) { ++ if let Some(context) = self.context.take() { ++ let _ = context.disable(); ++ } ++ self.issued = None; ++ self.observed = None; ++ self.phase = Phase::Off; ++ self.user_paused = false; ++ self.final_active = false; ++ self.error = None; ++ self.frame = None; ++ } ++ #[cfg(test)] ++ pub(super) fn pending(&self) -> bool { ++ self.pending.is_some() ++ } ++ fn revision(&self) -> Option { ++ self.observed.as_ref().map(|intent| VisualRevision { scene_generation: intent.revision, visual_revision: self.visual }) ++ } ++ fn drain(&mut self, app: &SolveApp) { ++ let Some(pending) = self.pending.take() else { return }; ++ let reply = match pending.receiver.try_recv() { ++ Ok(reply) => reply, ++ Err(mpsc::TryRecvError::Empty) => { ++ self.pending = Some(pending); ++ return; ++ } ++ Err(mpsc::TryRecvError::Disconnected) => Err(app.tr("render.interactive_error").into()), ++ }; ++ if pending.uid != app.session.uid ++ || self.issued != Some(pending.ticket) ++ || self.revision() != Some(pending.ticket.revision()) ++ || self.context.as_ref().is_none_or(|context| !context.is_current(&app.session)) ++ { ++ return; ++ } ++ // Final preemption or a user pause invalidates the outstanding ticket; ++ // an expected rejected capture is not a fresh preparation failure. ++ if self.user_paused ++ || self.final_active ++ || self.context.as_ref().is_some_and(|context| matches!(context.state(), Ok(Phase::Paused | Phase::Off))) ++ { ++ return; ++ } ++ match reply { ++ Err(error) => { ++ if let Some(context) = &self.context { ++ let _ = context.capture_failed(pending.ticket, error.clone()); ++ } ++ self.error = Some(error); ++ self.phase = Phase::Error; ++ } ++ Ok(false) => { ++ self.error = Some(app.tr("render.interactive_error").into()); ++ self.phase = Phase::Error; ++ } ++ Ok(true) => {} ++ } ++ } ++ fn observe(&mut self, app: &SolveApp) -> Result<(), String> { ++ // The exact-input stamp never computes world placements/meshes. ++ // Preserve a current stamp across request-only edits; its weak identities ++ // prevent pointer reuse without retaining CAD data or changing COW behavior. ++ let stale = app.session.model.is_stale(); ++ let request = if stale { Err(app.tr("render.error_finish_gesture").into()) } else { super::interactive_request(app) }; ++ let current_scene = self.observed.as_ref().is_some_and(|old| old.scene.is_current(&app.session)); ++ if current_scene ++ && self.observed.as_ref().is_some_and(|old| { ++ old.uid == app.session.uid ++ && old.revision == app.session.revision ++ && old.camera == app.cam ++ && old.stale == stale ++ && old.request == request ++ }) ++ { ++ return Ok(()); ++ } ++ let scene = match self.observed.take() { ++ Some(old) if current_scene => old.scene, ++ _ => app.session.interactive_scene_identity(), ++ }; ++ let intent = Intent { scene, uid: app.session.uid, revision: app.session.revision, camera: app.cam, stale, request }; ++ let recovering = self.error.is_some() || self.phase == Phase::Error; ++ self.visual = self.visual.checked_add(1).ok_or_else(|| app.tr("render.interactive_error").to_string())?; ++ self.observed = Some(intent); ++ self.issued = None; ++ self.error = None; ++ if self.user_paused { ++ if let Some(frame) = &mut self.frame { ++ frame.stale = true; ++ } ++ } else { ++ self.frame = None; ++ } ++ if let (Some(context), Some(revision)) = (&self.context, self.revision()) { ++ context.edit(revision, self.clock).map_err(|error| error.to_string())?; ++ if recovering && !self.user_paused { ++ context.resume(self.clock).map_err(|error| error.to_string())?; ++ } ++ } ++ if !stale && let Some(Err(error)) = self.observed.as_ref().map(|intent| &intent.request) { ++ self.error = Some(error.clone()); ++ } ++ Ok(()) ++ } ++ fn update(&mut self, app: &mut SolveApp, ctx: &egui::Context, dispatch: bool) -> Result<(), String> { ++ self.clock = monotonic(self.clock, ctx.input(|input| input.time)); ++ self.drain(app); ++ if self.context.is_none() { ++ return Ok(()); ++ } ++ if !super::active(app) ++ || app.render_workspace.view.method != ImageMethod::CpuRaytrace ++ || self.context.as_ref().is_some_and(|context| !context.is_current(&app.session)) ++ { ++ self.reset_document(); ++ return Ok(()); ++ } ++ self.observe(app)?; ++ let final_active = finals_active(app); ++ let suspend = final_active.as_ref().copied().unwrap_or(true) || app.render_workspace.view.result; ++ self.final_active = suspend; ++ let waiting_for_model = self.observed.as_ref().is_some_and(|intent| intent.stale); ++ let context = self.context.as_ref().ok_or_else(|| app.tr("render.interactive_error").to_string())?; ++ context.set_final_active(suspend || waiting_for_model, self.clock).map_err(|error| error.to_string())?; ++ if suspend || waiting_for_model { ++ self.issued = None; ++ } ++ if suspend && !self.user_paused { ++ self.frame = None; ++ } ++ if let Err(error) = final_active { ++ self.error = Some(error); ++ } ++ if waiting_for_model { ++ self.phase = if self.user_paused || suspend { Phase::Paused } else { Phase::Updating }; ++ if let Some(frame) = &mut self.frame { ++ frame.stale = true; ++ } ++ return Ok(()); ++ } ++ if self.error.is_some() { ++ // Request errors must cancel an already attached old capture, too. ++ context.pause().map_err(|error| error.to_string())?; ++ self.phase = Phase::Error; ++ return Ok(()); ++ } ++ self.phase = context.state().map_err(|error| error.to_string())?; ++ if self.phase == Phase::Error { ++ self.error = context.error().map_err(|error| error.to_string())?.or_else(|| Some(app.tr("render.interactive_error").into())); ++ self.frame = None; ++ return Ok(()); ++ } ++ self.cache(ctx)?; ++ if !dispatch || self.pending.is_some() || suspend || self.user_paused { ++ return Ok(()); ++ } ++ #[cfg(not(target_arch = "wasm32"))] ++ if let Some(ticket) = self ++ .context ++ .as_ref() ++ .ok_or_else(|| app.tr("render.interactive_error").to_string())? ++ .capture(self.clock) ++ .map_err(|error| error.to_string())? ++ { ++ let request = self ++ .observed ++ .as_ref() ++ .and_then(|intent| intent.request.as_ref().ok()) ++ .ok_or_else(|| app.tr("render.interactive_error").to_string())?; ++ let snapshot = self ++ .context ++ .as_ref() ++ .ok_or_else(|| app.tr("render.interactive_error").to_string())? ++ .snapshot(&app.session, ticket, request) ++ .map_err(|error| error.to_string())?; ++ self.issued = Some(ticket); ++ self.pending = Some(spawn(snapshot)?); ++ self.phase = Phase::Updating; ++ } ++ Ok(()) ++ } ++ fn cache(&mut self, ctx: &egui::Context) -> Result<(), String> { ++ if self.user_paused || self.final_active { ++ return Ok(()); ++ } ++ let Some(context) = &self.context else { return Ok(()) }; ++ let Some(job) = context.current().map_err(|error| error.to_string())? else { return Ok(()) }; ++ let Some(ticket) = self.issued else { return Ok(()) }; ++ if job.id() != ticket.job_id() || self.revision() != Some(ticket.revision()) { ++ return Ok(()); ++ } ++ let status = job.status().map_err(|error| error.to_string())?; ++ if status.request.integrator != Integrator::Raytrace || status.scene_generation != ticket.revision().scene_generation { ++ return Err(crate::i18n::tr("render.interactive_error").into()); ++ } ++ // Prefer an immutable checkpoint. A completed 16-SPP preview is also ++ // provisional and is never inserted into view.job/completed/result slots. ++ let preview = job.preview().map_err(|error| error.to_string())?; ++ if let Some(preview) = preview { ++ let key = PixelKey { job: job.id(), sequence: preview.info.frame_sequence, complete: false }; ++ self.cache_png(ctx, key, ticket.revision(), &preview.info.frame, preview.info.samples_per_pixel, (preview.png(), &status.request))?; ++ } else if let Some(frame) = job.frame().map_err(|error| error.to_string())? { ++ let key = PixelKey { job: job.id(), sequence: 0, complete: true }; ++ let samples = status.request.raytrace.as_ref().and_then(|options| options.progressive).map_or(0, |options| options.samples_per_pixel); ++ self.cache_png(ctx, key, ticket.revision(), &frame.info, samples, (frame.png(), &status.request))?; ++ } ++ Ok(()) ++ } ++ fn cache_png( ++ &mut self, ++ ctx: &egui::Context, ++ key: PixelKey, ++ revision: VisualRevision, ++ info: &FrameInfo, ++ samples: u32, ++ payload: (&[u8], &solidcraft_engine::render::job::ImageRequest), ++ ) -> Result<(), String> { ++ let (png, request) = payload; ++ if self.frame.as_ref().is_some_and(|frame| frame.key == key && frame.revision == revision) { ++ return Ok(()); ++ } ++ if info.job != key.job ++ || info.scene_generation != revision.scene_generation ++ || !(1..=16).contains(&samples) ++ || (info.width, info.height) != (request.width, request.height) ++ || info.width > 1024 ++ || info.height > 1024 ++ { ++ return Err(crate::i18n::tr("render.error_provisional_identity").into()); ++ } ++ let texture = super::decode_render_image( ++ png, ++ info.width, ++ info.height, ++ super::captured_image_limits(request), ++ ctx.input(|input| input.max_texture_side), ++ ) ++ .map(|image| ctx.load_texture("sc_render_interactive", image, egui::TextureOptions::LINEAR)); ++ let error = texture.as_ref().err().cloned(); ++ self.frame = Some(Cached { key, revision, info: info.clone(), samples, stale: false, texture }); ++ if let Some(error) = error { ++ return Err(error); ++ } ++ Ok(()) ++ } ++} ++ ++pub(super) fn monotonic(previous: Duration, seconds: f64) -> Duration { ++ if !seconds.is_finite() || seconds < 0.0 { ++ return previous; ++ } ++ match Duration::try_from_secs_f64(seconds) { ++ Ok(now) => previous.max(now), ++ Err(_) => previous, ++ } ++} ++fn finals_active(app: &SolveApp) -> Result { ++ let mut active = false; ++ for session in std::iter::once(&app.session).chain(app.docs.background()) { ++ active |= session.render_final_active().map_err(|error| error.to_string())?; ++ } ++ Ok(active) ++} ++ ++pub(super) fn ready(app: &SolveApp) -> Result<(), String> { ++ if cfg!(target_arch = "wasm32") || !super::active(app) || app.render_workspace.view.method != ImageMethod::CpuRaytrace { ++ return Err(app.tr("render.interactive_requires_cpu").into()); ++ } ++ let host = app.session.render_job_host().ok_or_else(|| app.tr("render.interactive_requires_cpu").to_string())?; ++ if host.kind() != HostKind::NativeWorker || !host.is_available() || host.validate_integrator(Integrator::Raytrace).is_err() { ++ return Err(app.tr("render.interactive_requires_cpu").into()); ++ } ++ if finals_active(app)? || app.render_workspace.view.result { ++ return Err(app.tr("render.interactive_final_active").into()); ++ } ++ Ok(()) ++} ++ ++pub(super) fn apply_command(app: &mut SolveApp, action: Action) -> Result<(), String> { ++ if matches!(action, Action::On | Action::Resume) { ++ ready(app)?; ++ } ++ let mut state = std::mem::take(&mut app.render_workspace.interactive); ++ let result = (|| { ++ match action { ++ Action::Off => state.reset_document(), ++ Action::On => { ++ state.reset_document(); ++ state.context = Some(app.session.interactive_render().map_err(|error| error.to_string())?); ++ state.observe(app)?; ++ let revision = state.revision().ok_or_else(|| app.tr("render.interactive_error").to_string())?; ++ state ++ .context ++ .as_ref() ++ .ok_or_else(|| app.tr("render.interactive_error").to_string())? ++ .enable(revision, state.clock) ++ .map_err(|error| error.to_string())?; ++ state.phase = Phase::Updating; ++ } ++ Action::Pause => { ++ let context = state.context.as_ref().ok_or_else(|| app.tr("render.interactive_requires_cpu").to_string())?; ++ context.pause().map_err(|error| error.to_string())?; ++ state.user_paused = true; ++ state.issued = None; ++ state.phase = Phase::Paused; ++ } ++ Action::Resume => { ++ state.observe(app)?; ++ if let Some(Err(error)) = state.observed.as_ref().map(|intent| &intent.request) { ++ return Err(error.clone()); ++ } ++ let context = state.context.as_ref().ok_or_else(|| app.tr("render.interactive_requires_cpu").to_string())?; ++ context.resume(state.clock).map_err(|error| error.to_string())?; ++ state.user_paused = false; ++ state.issued = None; ++ state.error = None; ++ state.frame = None; ++ state.phase = Phase::Updating; ++ } ++ } ++ Ok(()) ++ })(); ++ app.render_workspace.interactive = state; ++ result ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++fn spawn(snapshot: Snapshot) -> Result { ++ let uid = snapshot.document_uid(); ++ let ticket = snapshot.ticket(); ++ let (sender, receiver) = mpsc::channel(); ++ let _worker = std::thread::Builder::new() ++ .name("solidcraft-interactive-capture".into()) ++ .spawn(move || { ++ let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| snapshot.run())) ++ .map_err(|_| crate::i18n::tr("render.interactive_error").to_string()) ++ .and_then(|result| result.map_err(|error| error.to_string())); ++ let _ = sender.send(result); ++ }) ++ .map_err(|error| error.to_string())?; ++ Ok(Pending { uid, ticket, receiver }) ++} ++ ++fn refresh(app: &mut SolveApp, ctx: &egui::Context, dispatch: bool) { ++ let mut state = std::mem::take(&mut app.render_workspace.interactive); ++ if let Err(error) = state.update(app, ctx, dispatch) { ++ if let Some(context) = &state.context { ++ let _ = context.pause(); ++ } ++ state.error = Some(error); ++ state.phase = Phase::Error; ++ state.frame = None; ++ } ++ let poll = state.pending.is_some() || matches!(state.phase, Phase::Updating | Phase::Refining); ++ app.render_workspace.interactive = state; ++ if poll { ++ ctx.request_repaint_after(Duration::from_millis(100)); ++ } ++} ++pub(super) fn tick(app: &mut SolveApp, ctx: &egui::Context) { ++ refresh(app, ctx, true); ++} ++pub(super) fn before_paint(app: &mut SolveApp, ctx: &egui::Context) { ++ refresh(app, ctx, false); ++} ++ ++/// Reserve the canvas while an active CPU preview awaits its current pixels. ++/// This never turns a waiting state into a painted image or retains old pixels. ++pub(super) fn awaiting_current_frame(app: &SolveApp) -> bool { ++ let state = &app.render_workspace.interactive; ++ super::active(app) ++ && app.render_workspace.view.method == ImageMethod::CpuRaytrace ++ && !app.render_workspace.view.result ++ && state.context.as_ref().is_some_and(|context| context.is_current(&app.session)) ++ && !state.user_paused ++ && !state.final_active ++ && state.error.is_none() ++ && matches!(state.phase, Phase::Updating | Phase::Refining) ++ && state.frame.is_none() ++} ++ ++pub(super) fn paint(app: &SolveApp, ui: &egui::Ui, rect: egui::Rect) -> bool { ++ let state = &app.render_workspace.interactive; ++ if state.context.is_none() || state.final_active || state.error.is_some() { ++ return false; ++ } ++ let Some(frame) = &state.frame else { return false }; ++ if !state.user_paused && (frame.stale || state.revision() != Some(frame.revision)) { ++ return false; ++ } ++ let Ok(texture) = &frame.texture else { return false }; ++ let scale = (rect.width() / frame.info.width as f32).min(rect.height() / frame.info.height as f32); ++ let target = egui::Rect::from_center_size(rect.center(), egui::vec2(frame.info.width as f32, frame.info.height as f32) * scale); ++ ui.painter().with_clip_rect(rect).image( ++ texture.id(), ++ target, ++ egui::Rect::from_min_max(egui::Pos2::ZERO, egui::pos2(1.0, 1.0)), ++ Tokens::get().file_image_tint, ++ ); ++ true ++} ++ ++/// Place only our card in current-frame space; never move another workspace surface. ++pub(super) fn overlay_bounds(app: &SolveApp, free: egui::Rect) -> egui::Rect { ++ if !free.is_finite() || !free.is_positive() { ++ return egui::Rect::NOTHING; ++ } ++ let gap = Tokens::get().space_8; ++ let available = crate::shell::workspace_content(app, free).shrink(gap); ++ let mut obstacles = Vec::new(); ++ for (id, (rect, edge)) in &app.shell.workspace_panels { ++ if *id != "render:interactive-card" && edge.is_none() { ++ obstacles.push(rect.expand(gap)); ++ } ++ } ++ if let Some(layout) = &app.viewport.layout { ++ obstacles.extend([layout.axis_view, layout.navigation, layout.confirm].map(|rect| rect.expand(gap))); ++ } ++ crate::viewport_layout::free_rect(available, &obstacles) ++} ++ ++pub(crate) fn overlay(app: &mut SolveApp, ui: &egui::Ui, free: egui::Rect) { ++ let bounds = overlay_bounds(app, free); ++ let t = Tokens::get(); ++ // Match navigation_card's real chrome, including theme-dependent borders. ++ let chrome = ui_kit::Container::new(ui.ctx(), ui_kit::Surface::Navigation) ++ .frame(ui.ctx(), t.overlay, crate::frame::Side::Left) ++ .inner_margin(t.space_4) ++ .total_margin() ++ .sum(); ++ let width = (bounds.width() - chrome.x).min(t.form_card_width); ++ let height = bounds.height() - chrome.y; ++ if !bounds.is_finite() || width < t.control_height || height < t.control_height { ++ return; ++ } ++ let card = ui_kit::Container::navigation_card( ++ ui.ctx(), ++ egui::Id::new("sc_render_interactive_controls"), ++ bounds.left_top(), ++ egui::Align2::LEFT_TOP, ++ |ui| { ++ ui.set_width(width); ++ ui.set_max_width(width); ++ ui.set_clip_rect(ui.clip_rect().intersect(bounds)); ++ egui::ScrollArea::vertical() ++ .id_salt("sc_render_interactive_controls_scroll") ++ .min_scrolled_height(0.0) ++ .max_height(height) ++ .auto_shrink([false, true]) ++ .show(ui, |ui| controls(app, ui)); ++ }, ++ ); ++ crate::shell::register_panel(app, "render:interactive-card", Some(card.response.rect.intersect(bounds)), None); ++ crate::scenario::publish_rect("render:interactive-card", card.response.rect.intersect(bounds)); ++} ++pub(super) fn controls(app: &mut SolveApp, ui: &mut egui::Ui) { ++ let state = &app.render_workspace.interactive; ++ let phase = state.phase; ++ let running = state.context.is_some(); ++ let paused = state.user_paused; ++ let key = match phase { ++ Phase::Off => "render.interactive_off", ++ Phase::Updating => "render.interactive_updating", ++ Phase::Refining => "render.interactive_refining", ++ Phase::Paused => "render.interactive_paused", ++ Phase::TargetReached => "render.interactive_target", ++ Phase::Error => "render.interactive_error", ++ }; ++ let label = app.tr(key).to_string(); ++ let error = state.error.clone(); ++ let samples = state.frame.as_ref().map(|frame| frame.samples); ++ let dimensions = state.frame.as_ref().map(|frame| (frame.info.width, frame.info.height)); ++ let stale = state.frame.as_ref().is_some_and(|frame| frame.stale); ++ let final_active = state.final_active; ++ ui_kit::text(ui, &label, ui_kit::Text::Inline); ++ if running { ++ ui_kit::text(ui, app.tr("render.interactive_provisional"), ui_kit::Text::Note("render.interactive_provisional")); ++ } ++ if let Some(samples) = samples { ++ let label = crate::i18n::format("render.interactive_samples", &[("done", &samples.to_string()), ("total", "16")]); ++ ui_kit::text(ui, &label, ui_kit::Text::Inline); ++ } ++ if let Some((width, height)) = dimensions { ++ ui_kit::text(ui, &format!("{width} × {height} px"), ui_kit::Text::Inline); ++ } ++ if stale { ++ ui_kit::text(ui, app.tr("render.interactive_stale"), ui_kit::Text::Note("render.interactive_stale")); ++ } ++ if final_active { ++ ui_kit::text(ui, app.tr("render.interactive_final_active"), ui_kit::Text::Note("render.interactive_final_active")); ++ } ++ if let Some(error) = error { ++ ui_kit::text(ui, &error, ui_kit::Text::Error("render.interactive_error")); ++ } ++ let reason = ready(app).err(); ++ if let Some(reason) = &reason { ++ ui_kit::text(ui, reason, ui_kit::Text::Note("render.interactive_requires_cpu")); ++ } ++ let mut action = None; ++ ui.horizontal_wrapped(|ui| { ++ for (action_value, name, key, enabled) in if !running { ++ vec![(Action::On, "on", "render.interactive_on", reason.is_none())] ++ } else { ++ vec![ ++ ( ++ if paused || phase == Phase::Error { Action::Resume } else { Action::Pause }, ++ if paused || phase == Phase::Error { "resume" } else { "pause" }, ++ if paused || phase == Phase::Error { "render.interactive_resume" } else { "render.interactive_pause" }, ++ !final_active && (reason.is_none() || !(paused || phase == Phase::Error)), ++ ), ++ (Action::Off, "off", "render.interactive_off", true), ++ ] ++ } { ++ let label = app.tr(key).to_string(); ++ let response = ui_kit::button(ui, label, ui_kit::Button::Enabled(enabled)); ++ crate::scenario::publish_target(&format!("render:interactive:{name}"), response.rect); ++ if response.clicked() { ++ action = Some(action_value); ++ } ++ } ++ }); ++ if let Some(action) = action { ++ if let Err(error) = app.run("render.interactive", json!({"action":action})) { ++ app.set_status(error, true); ++ } ++ ui.ctx().request_repaint(); ++ } ++} ++pub(super) fn command_ready(app: &SolveApp) -> Result<(), String> { ++ if app.render_workspace.interactive.context.is_some() { Ok(()) } else { ready(app) } ++} ++pub(super) fn activate(app: &mut SolveApp) { ++ let state = &app.render_workspace.interactive; ++ let action = if state.context.is_none() { ++ Action::On ++ } else if state.user_paused || state.phase == Phase::Error { ++ Action::Resume ++ } else { ++ Action::Pause ++ }; ++ if let Err(error) = app.run("render.interactive", json!({"action":action})) { ++ app.set_status(error, true); ++ } ++} ++pub(super) fn inspect(app: &SolveApp) -> Value { ++ let state = &app.render_workspace.interactive; ++ json!({"enabled":state.context.is_some(),"phase":format!("{:?}",state.phase),"visual_revision":state.visual, ++ "pending_capture":state.pending.is_some(),"paused":state.user_paused,"error":state.error, ++ "samples":state.frame.as_ref().map(|frame| frame.samples),"stale":state.frame.as_ref().is_some_and(|frame|frame.stale), ++ "job":state.frame.as_ref().map(|frame|frame.info.job),"provisional":true}) ++} ++ ++// Read-only private observations for original UI acceptance tests. No production ++// command/API, host factory, renderer injection, worker gate or timing hook. ++#[cfg(all(test, not(target_arch = "wasm32")))] ++pub(super) fn test_current(app: &SolveApp) -> solidcraft_engine::Result> { ++ let Some(context) = app.render_workspace.interactive.context.as_ref() else { return Ok(None) }; ++ context.current() ++} ++#[cfg(all(test, not(target_arch = "wasm32")))] ++pub(super) fn test_cache(app: &SolveApp) -> Option<(FrameInfo, u32, bool, egui::TextureId)> { ++ let frame = app.render_workspace.interactive.frame.as_ref()?; ++ Some((frame.info.clone(), frame.samples, frame.key.complete, frame.texture.as_ref().ok()?.id())) ++} ++ ++// Harness frames advance this clock even while Interactive is Off. ++#[cfg(all(test, not(target_arch = "wasm32")))] ++pub(super) fn test_clock(app: &SolveApp) -> Duration { ++ app.render_workspace.interactive.clock ++} diff --git a/proposals/render/2026-10-30/c12-complete-source/manifest.json b/proposals/render/2026-10-30/c12-complete-source/manifest.json new file mode 100644 index 000000000..ecf726cf0 --- /dev/null +++ b/proposals/render/2026-10-30/c12-complete-source/manifest.json @@ -0,0 +1,119 @@ +{ + "status": "SOURCE_CHECKPOINT_C12_LIVE_NOT_A_TEST_RESULT", + "base_commit": "a077906234972dbbf11e80c54893f85ece97c8b7", + "sealed_manifest_sha256": "47f0f0e66d3a8c1f524dec3122622602ae5c1197eaa4f9e28f38d2f59fbbc989", + "source_paths": [ + "assets/locales/ar.json", + "assets/locales/bs.json", + "assets/locales/cs.json", + "assets/locales/de.json", + "assets/locales/en.json", + "assets/locales/es.json", + "assets/locales/fr.json", + "assets/locales/gl.json", + "assets/locales/he.json", + "assets/locales/hr.json", + "assets/locales/hu.json", + "assets/locales/id.json", + "assets/locales/it.json", + "assets/locales/ja.json", + "assets/locales/ko.json", + "assets/locales/ms.json", + "assets/locales/nb.json", + "assets/locales/nl.json", + "assets/locales/pending/render-interactive.json", + "assets/locales/ro.json", + "assets/locales/ru.json", + "assets/locales/sr.json", + "assets/locales/sv.json", + "assets/locales/tr.json", + "assets/locales/uk.json", + "assets/locales/vi.json", + "assets/locales/zh-TW.json", + "assets/locales/zh.json", + "crates/engine/src/cmd/mod.rs", + "crates/engine/src/cmd/render.rs", + "crates/engine/src/cmd/render/jobs.rs", + "crates/engine/src/cmd/render_ui.rs", + "crates/engine/src/lib.rs", + "crates/engine/src/render_interactive.rs", + "crates/engine/src/render_jobs.rs", + "crates/engine/src/schema/render_ui.rs", + "crates/gpu/src/path/mod.rs", + "crates/render/src/job/host.rs", + "crates/render/src/job/host_tests.rs", + "crates/render/src/job/interactive.rs", + "crates/render/src/job/mod.rs", + "crates/render/src/raytrace/primary_aa_tests.rs", + "crates/ui-egui/src/command_help.rs", + "crates/ui-egui/src/i18n.rs", + "crates/ui-egui/src/render_ui/mod.rs", + "crates/ui-egui/src/render_workspace.rs", + "crates/ui-egui/src/render_workspace_cpu.rs", + "crates/ui-egui/src/render_workspace_interactive.rs", + "crates/ui-egui/src/render_workspace_ribbon.rs", + "crates/ui-egui/src/render_workspace_tests.rs", + "docs/render-cpu-progressive.md", + "docs/render-interactive.md", + "docs/render-settings.md" + ], + "raw_sha256": { + "assets/locales/ar.json": "c9550c904e826c15d0166c03e1074e0d2a9ee530aa1e1e4ba94349cf68276dfd", + "assets/locales/bs.json": "73e5dbe7663db0b237a279ccbeae3c36b0b0ad7ec2c92dd1b58508532c19947c", + "assets/locales/cs.json": "a65d8c8e08fc20e2b79215bc120171fd8b432475d50cd0efc20f002a83fdbcee", + "assets/locales/de.json": "d4fc46818fc98cf705c5dca29d733dde5683fad8904b5edb008f45161103f2ba", + "assets/locales/en.json": "65a3f17a323a5230201e2466f8dbebed40e600d43ff247ec45aab37972ed2004", + "assets/locales/es.json": "67ec9a1ac8648b528aac00e7663d79869b837e4c880b2b4562b265497e511c72", + "assets/locales/fr.json": "f4cdf8a71df33533cf22bf32a0efad5e1f7300e4d3e6fc41a8d18ba0e087e0c3", + "assets/locales/gl.json": "5a70c152291171719e731de794c3dda9c59d01c8ce5c203504220443fa59bb80", + "assets/locales/he.json": "c26fa65f9339b2d8c7242ead3238fa4263753db62e76cdd14da37dbe842b5d3a", + "assets/locales/hr.json": "6639a12b83a0f40aca3f3703f5da02aac299d0b141aff3293cde412052a105dc", + "assets/locales/hu.json": "817d8b2d94cc6e51fdd4fcf5ede8cdcfb54b950efe7e81553486025c112651da", + "assets/locales/id.json": "7879d92fd882349e59e041a523f4c1fff91d8658b55ee8af22d158d498dbfac0", + "assets/locales/it.json": "df6df32fdc8c8c5fc36bfd7d5917749be56f3d52321eea2a59b59b6c1aeae5c2", + "assets/locales/ja.json": "69328222757966f0f23129630e31f34fcdb3e281ec7beecfe3bf1438e028ad13", + "assets/locales/ko.json": "4074ac6c38c9c1df45dc5c82479af9cdf9cd496162b576b5691a7746e0210815", + "assets/locales/ms.json": "60cc04a79c914571f8940d5ba7633cddb0c788ccb1444c2707e715bc534388cd", + "assets/locales/nb.json": "ddc114aa7ea0ae9c9bbfa001e96e0ec4baf09bf1f6a39e5f20cfedf34c7a1909", + "assets/locales/nl.json": "f9ff26d3451d8db96c7b6b587e21ed0f97c2c60ef1155f01959091f0e77edb1c", + "assets/locales/pending/render-interactive.json": "4502966fe59189042d2420defa75091036599c0cb14d573027eb76fca1511a63", + "assets/locales/ro.json": "ed570d60378b5f09f922c7351d536c65124679396f0ed85f209c57c6cf9a23d5", + "assets/locales/ru.json": "f84e64e5bd48f64e186087d40225fe3196d3d17ddccde666432ec25f6918b37f", + "assets/locales/sr.json": "e07a4c02f20731ce701767f6dc792a5004ba69eb24e46a6b9257c9020649fd68", + "assets/locales/sv.json": "cba544a487b218cf76b05e14e5edcd095f36e3553cdee3ca94d28b55f0db66b6", + "assets/locales/tr.json": "4e7d97b67847a8fe6ef9242165d092308f73d4776257f07a10f7fc601007d745", + "assets/locales/uk.json": "45449f7373f565f517e50fb67faa826b9885c6b154cd814e5caeadd6e96afc48", + "assets/locales/vi.json": "44a7746524e1427d004aedab346ba4459015e82589f447152608d174a5b87294", + "assets/locales/zh-TW.json": "b533860b90a8026a50af1696374a10786107b20947d4c39c9df2e22b2811d9d1", + "assets/locales/zh.json": "a7863f8717e6fdf6ebc7129d49a7366018cb9c19ea34610c465beeafe7d627e5", + "crates/engine/src/cmd/mod.rs": "ee2a6307c9bc27436ab1d381e1994f44feb1336055d8f9c0bda9dcaa23cb4ebb", + "crates/engine/src/cmd/render.rs": "63478b87010e4232d524c478ee27517a71b3c5d6059f5facb49cba428ef0aa6b", + "crates/engine/src/cmd/render/jobs.rs": "1cb96c6189fbbf9b904579d6c230aff004004249fcd89a86c3a82d87dc41bd68", + "crates/engine/src/cmd/render_ui.rs": "45d0f233b6788de8f28037cc9ea4447aed19405334f6648dc60943c24672d020", + "crates/engine/src/lib.rs": "3e1109f30b89552f7114276b5ca0fd5d335f845132bca798a091ce7d1a917701", + "crates/engine/src/render_interactive.rs": "2b404d5ec53cf3a4e953c842cc3238c90604dc2dc8b3e7582006d5f6e779ad36", + "crates/engine/src/render_jobs.rs": "b11fd62f42692c5701a08f391c2876de060fde766bf3b3639b3b3eabb2558bd2", + "crates/engine/src/schema/render_ui.rs": "80793c893f50e4dc2f785ff5dd7652c1ef984a4f307e9225a6196203812b4653", + "crates/gpu/src/path/mod.rs": "56eb1fe9e358d08377e37ec28628463497faaae4365a3890d289ba94a66b1777", + "crates/render/src/job/host.rs": "7d2e248f8c7d6586f18d8b9840da9074514ed4672bc8a8845170a805b1bf9315", + "crates/render/src/job/host_tests.rs": "3ed03799be1af84527642893847666a81d79976a3b58cc9551e4c0675676ccd4", + "crates/render/src/job/interactive.rs": "ccc8aaa5fc76038b39e8829f87b0888ccd92816567ea8b3d83778201364a4cce", + "crates/render/src/job/mod.rs": "03b8cb130fd848a64d30048ecdbfea785e9144827336eb8859473293076bc7ee", + "crates/render/src/raytrace/primary_aa_tests.rs": "0b5002bbe5b53d7059d7d1602af559b119d44549f0a19e0fa880c71ce5b9db18", + "crates/ui-egui/src/command_help.rs": "861f005ae58c4d685ef8e2d30e372454607755a3eea3854b37f33147758930ba", + "crates/ui-egui/src/i18n.rs": "39cea02cfac3a21f8727f0a2b3b1ffafb27f7715ce80e60599ec395807b4cf9a", + "crates/ui-egui/src/render_ui/mod.rs": "028173a06e671099b0f01f093110e58270b015d3afb6379abdfaf3db0b4ad53f", + "crates/ui-egui/src/render_workspace.rs": "46970f79648100ffd2676609ff5d9093a317b421aa39f28163c8883dd802d151", + "crates/ui-egui/src/render_workspace_cpu.rs": "a1534b73a972fffbfad50b831a00e3166c3d668ae7fb978b1286a3f390f4ade8", + "crates/ui-egui/src/render_workspace_interactive.rs": "2b385ccba4e94aaff6318f70a3669cd8205d786edad502e01e3c1e03f2e43579", + "crates/ui-egui/src/render_workspace_ribbon.rs": "27fc255da6da75976edb4b37928b78ea034c6c579f258b3155f15d43e3237ffb", + "crates/ui-egui/src/render_workspace_tests.rs": "9d88967c9177b90fcf44174f89d7faa003a5a7c8eade73448cd09384e005a22d", + "docs/render-cpu-progressive.md": "0a2bc05d4751234afbab9002de42827807c48bbb71a254823ac31e38cd8fc373", + "docs/render-interactive.md": "14cf4b47d453c6de0f0c835eac63a98b6f8445fdeb7b5c65d3de538b091577a2", + "docs/render-settings.md": "714958b1b3643d7919b6ea5cf0439923948f05aa3991736f42ea0d5902843e72" + }, + "patch_sha256": "5cee44aeee7e400e154dde6f46850f2ea32b48f492d5df72b5e7462047c8bd1f", + "line_endings": "Git/unified patch text uses canonical LF. Raw SHA pins document actual Windows input bytes; they are not a promise that checkout line endings are identical after apply.", + "test_results_claimed": false, + "excluded": "Private active validation lock and all controller/lease/log/design data." +}