fix(bridge): validate/preflight carry the render's target scope - v1.0.10

The 1.0.9 group-launch fix was necessary but not sufficient: the
launch pipeline is upload -> VALIDATE -> PREFLIGHT -> render submit,
and while the render submit is scoped to the selected group/project,
validate and preflight went through Scripts.RunAsync - an UNSCOPED
all-clients submit. The engine (rightly) rejects that for accounts
without the global grant, so a non-admin died at validation with
"not authorized to launch on all clients" before the correctly-scoped
render was ever reached. Admin accounts sailed through, which is why
the bug only shows on the self-serve flow.

- BridgeRenderLaunchService: validate + preflight (and the runtime
  diagnostics probe) submit via SubmitAsync with the same optional
  group/project the render uses.
- Channel: RunRenderValidateBlendScopedAsync /
  RunRenderPreflightScopedAsync - scope ids travel as strings
  ("" = none) so ONE method covers group/project/none in the
  name+count REST binder; unscoped callers keep the legacy methods.
- Addon: _run_validate_blend/_run_preflight pass the resolved target
  from _get_selected_target.

Error UX (operator report): the raw HTTP-500 JSON envelope used to
land in a screen-wide popup. bridge_client now extracts ErrorMessage
from the envelope, and the launch operator reports a one-sentence
popup (innermost engine clause, 160-char cap) while the full text
stays in the panel's error field with the Copy button.

Suites: py 88+127, C# 33+7 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: dmitrat

OutWit.Render.BlenderAddon/Tests/bridge_operator_policy_tests.py

@@ -503,6 +503,32 @@ def test_no_targets_at_all_resolves_to_unscoped(self):
         self.assertEqual(bridge_operators._get_selected_target(state), ("", ""))
 
 
+class ShortErrorMessageTests(unittest.TestCase):
+    """The popup gets one readable sentence; the full text stays in the panel's Copy field."""
+
+    def test_extracts_the_innermost_parenthesised_engine_clause(self):
+        raw = ("Failed to process request: One or more errors occurred. "
+               "(Script submission failed: User 'abc' is not authorized to launch on all clients.)")
+        self.assertEqual(
+            bridge_operators._short_error_message(Exception(raw)),
+            "Script submission failed: User 'abc' is not authorized to launch on all clients.")
+
+    def test_plain_message_passes_through(self):
+        self.assertEqual(
+            bridge_operators._short_error_message(Exception("Scene not saved.")),
+            "Scene not saved.")
+
+    def test_overlong_message_is_truncated_with_ellipsis(self):
+        message = bridge_operators._short_error_message(Exception("x" * 500))
+        self.assertLessEqual(len(message), bridge_operators._ERROR_POPUP_LIMIT)
+        self.assertTrue(message.endswith("…"))
+
+    def test_empty_message_falls_back_to_a_generic_line(self):
+        self.assertEqual(
+            bridge_operators._short_error_message(Exception("")),
+            "Render launch failed.")
+
+
 class BridgeOperatorPolicyTests(unittest.TestCase):
     def test_scene_requires_upload_reuploads_after_a_saved_edit(self) -> None:
         # Regression: adding a camera (or any edit) + saving must re-upload even when the path and the

OutWit.Render.BlenderAddon/outwit_render_bridge/__init__.py

@@ -1,7 +1,7 @@
 bl_info = {
     "name": "OmnibusCloud Render Bridge",
     "author": "OutWit",
-    "version": (1, 0, 9),
+    "version": (1, 0, 10),
     "blender": (4, 0, 0),
     "location": "View3D > Sidebar > OmnibusCloud",
     "description": "Thin Blender addon for the local OmnibusCloud render bridge",

OutWit.Render.BlenderAddon/outwit_render_bridge/blender_manifest.toml

@@ -1,6 +1,6 @@
 schema_version = "1.0.0"
 id = "omnibuscloud_render_bridge"
-version = "1.0.9"
+version = "1.0.10"
 name = "OmnibusCloud Render Bridge"
 tagline = "Thin Blender addon for the local OmnibusCloud render bridge"
 maintainer = "OutWit"

OutWit.Render.BlenderAddon/outwit_render_bridge/bridge_client.py

@@ -63,6 +63,23 @@ class BridgeClientError(Exception):
     pass
 
 
+def _extract_http_error_message(status_code: int, detail: str) -> str:
+    """The human message from a bridge HTTP error body.
+
+    The bridge answers errors with a JSON envelope ({"Status", "Data", "ErrorMessage",
+    "ErrorDetails"}); showing the raw body gave the artist a screen-wide JSON dump for what is
+    one sentence of ErrorMessage. Unparseable bodies keep the old raw form.
+    """
+    try:
+        envelope = json.loads(detail)
+        message = str(envelope.get("ErrorMessage") or "").strip()
+        if message:
+            return message
+    except (ValueError, TypeError, AttributeError):
+        pass
+    return f"Bridge HTTP error {status_code}: {detail}"
+
+
 class BridgeClient:
     def __init__(self, context_directory: str):
         self._context_directory = context_directory
@@ -135,7 +152,23 @@ def _run_upload(self, start_method: str, file_path: str) -> UploadBlendResponse:
 
         raise BridgeClientError(status.error or f"Upload did not complete (status: {status.status or 'unknown'}).")
 
-    def run_render_validate_blend(self, scene_blob_id: str, attached_files: list[dict[str, Any]] | None = None) -> RenderValidateBlendResponse:
+    def run_render_validate_blend(
+        self,
+        scene_blob_id: str,
+        attached_files: list[dict[str, Any]] | None = None,
+        selected_client_group_id: str = "",
+        selected_project_id: str = "",
+    ) -> RenderValidateBlendResponse:
+        """Validation must carry the SAME scope as the render: an unscoped utility submit is an
+        all-clients submit, which the engine rejects for non-admin accounts — the launch then dies
+        here before the correctly-scoped render is ever reached (live-found on the first non-admin
+        self-serve run). Unscoped stays on the legacy method for older running bridges."""
+        group_id = (selected_client_group_id or "").strip()
+        project_id = (selected_project_id or "").strip()
+        if group_id or project_id:
+            return self._post(
+                "RunRenderValidateBlendScopedAsync", RenderValidateBlendResponse.from_json,
+                scene_blob_id, attached_files or [], group_id, project_id)
         return self._post("RunRenderValidateBlendAsync", RenderValidateBlendResponse.from_json, scene_blob_id, attached_files or [])
 
     def run_render_preflight(
@@ -148,19 +181,17 @@ def run_render_preflight(
         options: dict[str, Any],
         tile_options: dict[str, Any],
         video: dict[str, Any],
+        selected_client_group_id: str = "",
+        selected_project_id: str = "",
     ) -> RenderPreflightResponse:
-        return self._post(
-            "RunRenderPreflightAsync",
-            RenderPreflightResponse.from_json,
-            frame,
-            start_frame,
-            end_frame,
-            tiles_x,
-            tiles_y,
-            options,
-            tile_options,
-            video,
-        )
+        group_id = (selected_client_group_id or "").strip()
+        project_id = (selected_project_id or "").strip()
+        payload = [frame, start_frame, end_frame, tiles_x, tiles_y, options, tile_options, video]
+        if group_id or project_id:
+            return self._post(
+                "RunRenderPreflightScopedAsync", RenderPreflightResponse.from_json,
+                *payload, group_id, project_id)
+        return self._post("RunRenderPreflightAsync", RenderPreflightResponse.from_json, *payload)
 
     def run_render_still(self, scene_blob_id: str, frame: int, options: dict[str, Any], attached_files: list[dict[str, Any]] | None = None, selected_client_group_id: str = "", selected_project_id: str = "") -> RunRenderResponse:
         payload = [scene_blob_id, frame, options, attached_files or []]
@@ -337,7 +368,7 @@ def _send(self, request: urllib.request.Request) -> Any:
                 body = response.read().decode("utf-8")
         except urllib.error.HTTPError as ex:
             detail = ex.read().decode("utf-8", errors="replace")
-            raise BridgeClientError(f"Bridge HTTP error {ex.code}: {detail}") from ex
+            raise BridgeClientError(_extract_http_error_message(ex.code, detail)) from ex
         except urllib.error.URLError as ex:
             raise BridgeClientError(f"Bridge request failed: {ex.reason}") from ex
 

OutWit.Render.BlenderAddon/outwit_render_bridge/bridge_operators.py

@@ -221,6 +221,24 @@ def _get_selected_target_unified_id(state) -> str:
     return ""
 
 
+# Blender renders operator ERROR reports as a popup sized to the TEXT — a multi-clause server
+# message becomes a screen-wide banner. The popup gets one readable sentence; the full text
+# stays in state.last_error, which the panel shows with the Copy button.
+_ERROR_POPUP_LIMIT = 160
+
+
+def _short_error_message(error: BaseException) -> str:
+    message = str(error).strip() or "Render launch failed."
+    # The engine wraps the human sentence in transport prefixes ("Failed to process request:
+    # One or more errors occurred. (...)") — surface the innermost parenthesised clause.
+    match = re.search(r"\(([^()]+)\)\s*$", message)
+    if match:
+        message = match.group(1).strip()
+    if len(message) > _ERROR_POPUP_LIMIT:
+        message = message[:_ERROR_POPUP_LIMIT - 1].rstrip() + "…"
+    return message
+
+
 def _get_runtime_state(context):
     return context.window_manager.outwit_bridge_state
 
@@ -693,10 +711,19 @@ def _merge_unique_summaries(*summaries: str) -> str:
 
 
 def _run_validate_blend(context):
+    # Validate carries the SAME target scope as the render: an unscoped utility submit is an
+    # all-clients submit the engine rejects for non-admin accounts — the whole launch then died
+    # right here with "not authorized to launch on all clients" (live-found, first non-admin run).
     state = _get_runtime_state(context)
     context_directory = _get_context_directory(context)
     client = BridgeClient(context_directory)
-    response = client.run_render_validate_blend(_ensure_uploaded_blob_id(state), _get_uploaded_attachment_manifest(state))
+    group_id, project_id = _get_selected_target(state)
+    response = client.run_render_validate_blend(
+        _ensure_uploaded_blob_id(state),
+        _get_uploaded_attachment_manifest(state),
+        group_id,
+        project_id,
+    )
     _apply_validate_response(state, response)
     return response
 
@@ -705,6 +732,7 @@ def _run_preflight(context):
     state = _get_runtime_state(context)
     scene = context.scene
     client = _get_bridge_client(context)
+    group_id, project_id = _get_selected_target(state)
     response = client.run_render_preflight(
         _get_still_frame(context),
         int(scene.frame_start),
@@ -714,6 +742,8 @@ def _run_preflight(context):
         _collect_render_options(context),
         _collect_tile_options(state),
         _collect_video_options(state),
+        group_id,
+        project_id,
     )
     _apply_preflight_response(state, response)
     return response
@@ -2699,13 +2729,13 @@ def _finish_launch(self, context):
             return {"FINISHED"}
         except BridgeClientError as ex:
             state.last_error = str(ex)
-            state.status_message = str(ex)
-            self.report({"ERROR"}, str(ex))
+            state.status_message = _short_error_message(ex)
+            self.report({"ERROR"}, _short_error_message(ex))
             return {"CANCELLED"}
         except Exception as ex:
             state.last_error = str(ex)
             state.status_message = "Render launch failed."
-            self.report({"ERROR"}, str(ex))
+            self.report({"ERROR"}, _short_error_message(ex))
             return {"CANCELLED"}
         finally:
             _launch_in_progress = False

OutWit.Render.BlenderBridge/Channels/BlenderBridgeChannel.cs

@@ -153,6 +153,51 @@ public Task<RenderPreflightResponse> RunRenderPreflightAsync(
                 video);
         }
 
+        public Task<RenderValidateBlendResponse> RunRenderValidateBlendScopedAsync(
+            Guid sceneBlobId,
+            List<RenderSceneAttachmentRefData> attachedFiles,
+            string selectedClientGroupId,
+            string selectedProjectId)
+        {
+            return RenderLaunchService.RunRenderValidateBlendAsync(
+                sceneBlobId,
+                attachedFiles,
+                ParseScopeId(selectedClientGroupId),
+                ParseScopeId(selectedProjectId));
+        }
+
+        public Task<RenderPreflightResponse> RunRenderPreflightScopedAsync(
+            int frame,
+            int startFrame,
+            int endFrame,
+            int tilesX,
+            int tilesY,
+            RenderOptionsData options,
+            TileOptionsData tileOptions,
+            VideoOptionsData video,
+            string selectedClientGroupId,
+            string selectedProjectId)
+        {
+            return RenderLaunchService.RunRenderPreflightAsync(
+                frame,
+                startFrame,
+                endFrame,
+                tilesX,
+                tilesY,
+                options,
+                tileOptions,
+                video,
+                ParseScopeId(selectedClientGroupId),
+                ParseScopeId(selectedProjectId));
+        }
+
+        // "" / whitespace / unparseable / Guid.Empty all mean "no scope of this kind" — the string
+        // transport exists so one method covers group/project/none (REST binds by name + count).
+        private static Guid? ParseScopeId(string? value)
+        {
+            return Guid.TryParse((value ?? "").Trim(), out var id) && id != Guid.Empty ? id : null;
+        }
+
         public Task<RunRenderStillResponse> RunRenderStillAsync(Guid sceneBlobId, int frame, RenderOptionsData options)
         {
             return RenderLaunchService.RunRenderStillAsync(sceneBlobId, frame, options);

OutWit.Render.BlenderBridge/Channels/Interfaces/IBlenderBridgeChannel.cs

@@ -108,6 +108,34 @@ Task<RenderPreflightResponse> RunRenderPreflightAsync(
             TileOptionsData tileOptions,
             VideoOptionsData video);
 
+        /// <summary>
+        /// Validates the blend scoped to the selected render target — utility submits must carry
+        /// the same scope as the render, or a non-admin account is rejected ("all clients") before
+        /// the render is ever reached. Ids travel as strings ("" = none; both set is an error) so
+        /// ONE method covers group/project/none without a Guid-arity explosion in the REST binder.
+        /// </summary>
+        Task<RenderValidateBlendResponse> RunRenderValidateBlendScopedAsync(
+            Guid sceneBlobId,
+            List<RenderSceneAttachmentRefData> attachedFiles,
+            string selectedClientGroupId,
+            string selectedProjectId);
+
+        /// <summary>
+        /// Runs the render preflight scoped to the selected render target (see
+        /// <see cref="RunRenderValidateBlendScopedAsync"/> for the string-id contract).
+        /// </summary>
+        Task<RenderPreflightResponse> RunRenderPreflightScopedAsync(
+            int frame,
+            int startFrame,
+            int endFrame,
+            int tilesX,
+            int tilesY,
+            RenderOptionsData options,
+            TileOptionsData tileOptions,
+            VideoOptionsData video,
+            string selectedClientGroupId,
+            string selectedProjectId);
+
         /// <summary>
         /// Launches the bundled RenderStill script.
         /// </summary>

OutWit.Render.BlenderBridge/Services/Render/BridgeRenderLaunchService.cs

@@ -77,12 +77,14 @@ public partial class BridgeRenderLaunchService : IBridgeRenderLaunchService
 
         public async Task<RenderValidateBlendResponse> RunRenderValidateBlendAsync(Guid sceneBlobId, CancellationToken cancellationToken = default)
         {
-            return await RunRenderValidateBlendAsync(sceneBlobId, null, cancellationToken);
+            return await RunRenderValidateBlendAsync(sceneBlobId, null, cancellationToken: cancellationToken);
         }
 
         public async Task<RenderValidateBlendResponse> RunRenderValidateBlendAsync(
             Guid sceneBlobId,
             IReadOnlyList<RenderSceneAttachmentRefData>? attachedFiles,
+            Guid? selectedClientGroupId = null,
+            Guid? selectedProjectId = null,
             CancellationToken cancellationToken = default)
         {
             ThrowIfSceneBlobIdMissing(sceneBlobId);
@@ -93,7 +95,13 @@ public async Task<RenderValidateBlendResponse> RunRenderValidateBlendAsync(
             using var timeoutSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
             timeoutSource.CancelAfter(DEFAULT_TIMEOUT);
 
-            var handle = await client.Scripts.RunAsync(RENDER_VALIDATE_BLEND_SCRIPT, scene);
+            // Scoped like the render itself: an unscoped utility submit is an ALL-CLIENTS submit,
+            // which the engine (rightly) rejects for accounts without the global grant — validation
+            // then fails before the correctly-scoped render is ever reached (live-found on the
+            // first non-admin self-serve run). HasScopedTarget also rejects group+project both set.
+            _ = HasScopedTarget(selectedClientGroupId, selectedProjectId);
+            var handle = await client.Scripts.SubmitAsync(
+                RENDER_VALIDATE_BLEND_SCRIPT, new object?[] { scene }, selectedClientGroupId, selectedProjectId, ct: cancellationToken);
             var waited = await handle.WaitAsync<string>("result", pollInterval: POLL_INTERVAL, ct: timeoutSource.Token);
 
             if (waited.Status == ProcessingJobStatus.Completed)
@@ -141,6 +149,8 @@ public async Task<RenderPreflightResponse> RunRenderPreflightAsync(
             RenderOptionsData options,
             TileOptionsData tileOptions,
             VideoOptionsData video,
+            Guid? selectedClientGroupId = null,
+            Guid? selectedProjectId = null,
             CancellationToken cancellationToken = default)
         {
             ArgumentNullException.ThrowIfNull(options);
@@ -149,9 +159,13 @@ public async Task<RenderPreflightResponse> RunRenderPreflightAsync(
 
             var client = await GetRequiredClientAsync(cancellationToken);
 
+            // Scoped like the render itself (see RunRenderValidateBlendAsync) — an unscoped
+            // preflight is an all-clients submit a non-admin account cannot make.
+            _ = HasScopedTarget(selectedClientGroupId, selectedProjectId);
+
             var runtimeDiagnostics = await RunAndGetResultAsync<RenderRuntimeDiagnosticsData>(
                 client,
-                s => s.RunAsync(RENDER_RUNTIME_DIAGNOSTICS_SCRIPT),
+                s => s.SubmitAsync(RENDER_RUNTIME_DIAGNOSTICS_SCRIPT, [], selectedClientGroupId, selectedProjectId),
                 "Bridge runtime diagnostics",
                 cancellationToken);
 
@@ -167,22 +181,22 @@ public async Task<RenderPreflightResponse> RunRenderPreflightAsync(
                 RuntimeDiagnostics = runtimeDiagnostics,
                 Still = await RunAndGetResultAsync<RenderPreflightFramesData>(
                     client,
-                    s => s.RunAsync(RENDER_PREFLIGHT_STILL_SCRIPT, frame, options),
+                    s => s.SubmitAsync(RENDER_PREFLIGHT_STILL_SCRIPT, new object?[] { frame, options }, selectedClientGroupId, selectedProjectId),
                     "Bridge still preflight",
                     cancellationToken),
                 Frames = await RunAndGetResultAsync<RenderPreflightFramesData>(
                     client,
-                    s => s.RunAsync(RENDER_PREFLIGHT_FRAMES_SCRIPT, startFrame, endFrame, options),
+                    s => s.SubmitAsync(RENDER_PREFLIGHT_FRAMES_SCRIPT, new object?[] { startFrame, endFrame, options }, selectedClientGroupId, selectedProjectId),
                     "Bridge frame-range preflight",
                     cancellationToken),
                 StillTiled = await RunAndGetResultAsync<RenderPreflightStillTiledData>(
                     client,
-                    s => s.RunAsync(RENDER_PREFLIGHT_STILL_TILED_SCRIPT, tilesX, tilesY, options, tileOptions),
+                    s => s.SubmitAsync(RENDER_PREFLIGHT_STILL_TILED_SCRIPT, new object?[] { tilesX, tilesY, options, tileOptions }, selectedClientGroupId, selectedProjectId),
                     "Bridge tiled-still preflight",
                     cancellationToken),
                 Video = await RunAndGetResultAsync<RenderPreflightVideoData>(
                     client,
-                    s => s.RunAsync(RENDER_PREFLIGHT_VIDEO_SCRIPT, options, video),
+                    s => s.SubmitAsync(RENDER_PREFLIGHT_VIDEO_SCRIPT, new object?[] { options, video }, selectedClientGroupId, selectedProjectId),
                     "Bridge video preflight",
                     cancellationToken)
             };