feat(addon): wire local bake into Render + enable LOCAL strategy (3b.4)

Completes the "On this computer" path end to end:
- Render launch: when LOCAL + an unbaked sim, it runs the local bake first
  (OUTWIT_OT_bridge_bake_local with chain_to_render=True), which on completion
  re-invokes the launch. A path+mtime "already baked this .blend" guard
  (_local_bake_is_current) breaks the re-bake loop — needed because Geometry-Nodes
  sims always read as unbaked from the scan.
- Post-upload gate now routes by plan: should_delegate → BakeAndRender* (farm
  bakes); should_local → PLAIN Render* with the collected fluid caches (already
  baked here), skipping preflight (it can false-flag an already-baked GN zone).
- Pack-copy strips non-DOMAIN fluid modifiers ONLY when a domain is already baked
  (local path) — an unbaked scene (delegated path) keeps them for the farm bake;
  runs on the upload copy so the artist's live scene is untouched.
- Flip LOCAL_BAKE_AVAILABLE = True; panel notes "Render will bake on this
  computer first (saves the .blend)". Bump addon 0.13.1 -> 0.14.0.

Tests: operator/panel "LOCAL unavailable→block" cases converted to the now-shipped
LOCAL-available behavior (unavailable-gate logic stays covered by the bridge_status
+ planner tests, which set the flag explicitly); operator harness loads
bridge_simulation with the dataclass-slots shim. 170 addon tests green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dmitrat

OutWit.Render.BlenderAddon/Tests/bridge_operator_policy_tests.py

@@ -136,6 +136,29 @@ class SceneEngineRoutingError(Exception):
     sys.modules[f"{PACKAGE_NAME}.bridge_dependency_policy"] = dependency_policy_module
     dependency_policy_spec.loader.exec_module(dependency_policy_module)
 
+    # bridge_simulation uses dataclass(slots=True) (Blender's 3.11+ Python); shim the slots kwarg away on
+    # an older test interpreter. The launch flow reaches it via _scan_scene_simulations.
+    simulation_spec = importlib.util.spec_from_file_location(
+        f"{PACKAGE_NAME}.bridge_simulation", ADDON_DIR / "bridge_simulation.py")
+    simulation_module = importlib.util.module_from_spec(simulation_spec)
+    sys.modules[f"{PACKAGE_NAME}.bridge_simulation"] = simulation_module
+    if sys.version_info >= (3, 10):
+        simulation_spec.loader.exec_module(simulation_module)
+    else:
+        import dataclasses as _dataclasses
+
+        _real_dataclass = _dataclasses.dataclass
+
+        def _dataclass_without_slots(*args, **kwargs):
+            kwargs.pop("slots", None)
+            return _real_dataclass(*args, **kwargs)
+
+        _dataclasses.dataclass = _dataclass_without_slots
+        try:
+            simulation_spec.loader.exec_module(simulation_module)
+        finally:
+            _dataclasses.dataclass = _real_dataclass
+
     bridge_scene_packaging_module = types.ModuleType(f"{PACKAGE_NAME}.bridge_scene_packaging")
 
     class ScenePackagingError(Exception):
@@ -997,7 +1020,8 @@ def test_validate_operator_reports_delegated_bake_for_simulation(self) -> None:
         self.assertIn("baked on the render farm", state.status_message)
         self.assertIn(({"INFO"}, state.status_message), operator.report_calls)
 
-    def test_validate_operator_blocks_simulation_when_local_bake_unavailable(self) -> None:
+    def test_validate_operator_reports_local_bake_for_simulation(self) -> None:
+        # LOCAL strategy + unbaked sim → not an error; it will be baked on this computer before rendering.
         state = _create_state()
         state.bake_strategy = "LOCAL"
         context = _create_context(state)
@@ -1012,8 +1036,8 @@ def test_validate_operator_blocks_simulation_when_local_bake_unavailable(self) -
         result = operator.execute(context)
 
         self.assertEqual({"FINISHED"}, result)
-        self.assertIn("render farm", state.status_message)
-        self.assertIn(({"ERROR"}, state.status_message), operator.report_calls)
+        self.assertIn("this computer", state.status_message)
+        self.assertIn(({"INFO"}, state.status_message), operator.report_calls)
 
     def test_preflight_operator_skips_when_simulation_is_delegated_bake(self) -> None:
         # A simulation covered by a delegated bake is not preflighted on the unbaked scene; the
@@ -1036,7 +1060,9 @@ def test_preflight_operator_skips_when_simulation_is_delegated_bake(self) -> Non
         self.assertFalse(state.preflight_still_ready)
         self.assertIn(({"INFO"}, state.status_message), operator.report_calls)
 
-    def test_preflight_operator_blocks_simulation_when_local_bake_unavailable(self) -> None:
+    def test_preflight_operator_skips_when_simulation_is_local_bake(self) -> None:
+        # A simulation covered by a local bake is not preflighted on the unbaked scene; the operator
+        # reports informationally ("on this computer") and leaves the per-mode verdicts unset.
         state = _create_state()
         state.bake_strategy = "LOCAL"
         context = _create_context(state)
@@ -1051,10 +1077,10 @@ def test_preflight_operator_blocks_simulation_when_local_bake_unavailable(self)
         operator = bridge_operators.OUTWIT_OT_bridge_run_preflight()
         result = operator.execute(context)
 
-        self.assertEqual({"CANCELLED"}, result)
-        self.assertFalse(state.preflight_can_render_all)
-        self.assertIn("render farm", state.preflight_issue_summary)
-        self.assertIn(({"ERROR"}, state.preflight_issue_summary), operator.report_calls)
+        self.assertEqual({"FINISHED"}, result)
+        self.assertIn("this computer", state.status_message)
+        self.assertFalse(state.preflight_still_ready)
+        self.assertIn(({"INFO"}, state.status_message), operator.report_calls)
 
     def test_launch_operator_routes_unbaked_simulation_to_delegated_bake(self) -> None:
         # The crux: an unbaked simulation with DELEGATED must NOT block and must NOT reach a plain
@@ -1089,26 +1115,36 @@ def run_selected_launch(_context, *, bake=False):
         self.assertTrue(captured.get("bake"), "launch must route to the BakeAndRender* path")
         self.assertIn(({"INFO"}, "BakeAndRenderStill launched successfully."), operator.report_calls)
 
-    def test_launch_operator_blocks_simulation_when_local_bake_unavailable(self) -> None:
-        # LOCAL baking is not available yet, so the launch must refuse rather than silently delegate
-        # or render unbaked — the gate the user required ("no render without a bake plan").
+    def test_launch_operator_local_bake_renders_plain_not_delegated(self) -> None:
+        # LOCAL strategy: the scene is baked locally before upload, so the launch must take the PLAIN
+        # Render* path (bake=False) — never BakeAndRender* (which would re-bake on the farm). (The
+        # stub scene has no live sim objects, so the pre-upload bake step is skipped here; this exercises
+        # the post-upload routing for a LOCAL-baked scene the validator still flags.)
         state = _create_state()
         state.bake_strategy = "LOCAL"
         context = _create_context(state)
         response = _create_simulation_issue_validate_response()
+        launch_response = SimpleNamespace(job_id="job-7", status="Pending", message="RenderStill launched successfully.")
+        captured = {}
 
         bridge_operators._ensure_current_scene_uploaded = lambda _context: None
         bridge_operators._get_current_blend_path = lambda: "C:/Workspace/test.blend"
         bridge_operators._scene_requires_upload = lambda *_args: False
         bridge_operators._run_validate_blend = lambda _context: (bridge_operators._apply_validate_response(state, response) or response)
-        bridge_operators._run_selected_launch = lambda _context, *, bake=False: (_ for _ in ()).throw(AssertionError("must not submit when blocked"))
+
+        def run_selected_launch(_context, *, bake=False):
+            captured["bake"] = bake
+            return launch_response
+
+        bridge_operators._run_selected_launch = run_selected_launch
+        bridge_operators._sticky_render_settings_after_submit = lambda _context: None
 
         operator = bridge_operators.OUTWIT_OT_bridge_launch_render()
         result = _run_launch_operator(operator, context)
 
-        self.assertEqual({"CANCELLED"}, result)
-        self.assertIn("render farm", state.status_message)
-        self.assertIn(({"ERROR"}, state.status_message), operator.report_calls)
+        self.assertEqual({"FINISHED"}, result)
+        self.assertIn("bake", captured)
+        self.assertFalse(captured["bake"], "local bake → plain Render*, not BakeAndRender*")
 
 
 if __name__ == "__main__":

OutWit.Render.BlenderAddon/Tests/bridge_panel_policy_tests.py

@@ -171,14 +171,16 @@ def test_primary_finding_omits_simulation_when_delegated_bake_covers_it(self) ->
         self.assertNotEqual("Blocked", bridge_panel._primary_finding_policy(state))
         self.assertIn("baked on the render farm", bridge_panel._simulation_bake_plan_message(state))
 
-    def test_primary_finding_surfaces_simulation_block_when_local_bake_unavailable(self) -> None:
+    def test_primary_finding_omits_simulation_when_local_bake_covers_it(self) -> None:
+        # LOCAL strategy (now available): the simulation is baked on this computer → not a block.
         state = _create_state()
         state.bake_strategy = "LOCAL"
         state.validate_warning_summary = ""
         state.validate_issue_summary = "Cloth simulation 'Pillow' is not yet portable to remote rendering in the current v1 flow."
 
-        self.assertIn("render farm", bridge_panel._primary_finding(state))
-        self.assertEqual("Blocked", bridge_panel._primary_finding_policy(state))
+        self.assertEqual("", bridge_panel._primary_finding(state))
+        self.assertNotEqual("Blocked", bridge_panel._primary_finding_policy(state))
+        self.assertIn("this computer", bridge_panel._simulation_bake_plan_message(state))
 
     def test_dependency_plan_block_message_returns_primary_finding_only_when_blocked(self) -> None:
         state = _create_state()
@@ -197,13 +199,14 @@ def test_dependency_plan_block_message_returns_empty_when_scene_is_not_blocked(s
 
         self.assertEqual("", result)
 
-    def test_dependency_plan_block_message_blocks_simulation_when_local_bake_unavailable(self) -> None:
+    def test_dependency_plan_block_message_empty_when_simulation_is_local_bake(self) -> None:
+        # LOCAL strategy (now available) covers the simulation → no diagnostic block.
         state = _create_state()
         state.bake_strategy = "LOCAL"
         state.validate_warning_summary = ""
         state.validate_issue_summary = "Cloth simulation 'Pillow' is not yet portable to remote rendering in the current v1 flow."
 
-        self.assertIn("render farm", bridge_panel._dependency_plan_block_message(state))
+        self.assertEqual("", bridge_panel._dependency_plan_block_message(state))
 
     def test_dependency_plan_block_message_empty_when_simulation_is_delegated_bake(self) -> None:
         state = _create_state()

OutWit.Render.BlenderAddon/outwit_render_bridge/__init__.py

@@ -1,7 +1,7 @@
 bl_info = {
     "name": "OmnibusCloud Render Bridge",
     "author": "OutWit",
-    "version": (0, 13, 1),
+    "version": (0, 14, 0),
     "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 = "0.13.1"
+version = "0.14.0"
 name = "OmnibusCloud Render Bridge"
 tagline = "Thin Blender addon for the local OmnibusCloud render bridge"
 maintainer = "OutWit"

OutWit.Render.BlenderAddon/outwit_render_bridge/bridge_dependency_policy.py

@@ -131,7 +131,7 @@ class BakePlan(NamedTuple):
 # unbaked simulation rather than silently delegating or — worse — rendering it unbaked. Flip to
 # ``True`` once the local driver ships. Lives here (not in bridge_simulation) so the bpy-free gate
 # in operators/status/panel can read it without importing the bpy-adjacent scan module.
-LOCAL_BAKE_AVAILABLE = False
+LOCAL_BAKE_AVAILABLE = True
 
 
 def resolve_bake_plan(

OutWit.Render.BlenderAddon/outwit_render_bridge/bridge_operators.py

@@ -6,7 +6,7 @@
 import sys
 
 import bpy
-from bpy.props import StringProperty
+from bpy.props import BoolProperty, StringProperty
 from bpy.types import Operator
 
 from .bridge_async import AsyncCall, JobMonitor, TERMINAL_STATUSES
@@ -285,18 +285,24 @@ def _get_uploaded_attachment_manifest(state) -> list[dict[str, object]]:
     return value if isinstance(value, list) else []
 
 
+def _local_bake_is_current(state) -> bool:
+    """True when a local bake's result still belongs to the CURRENT .blend (same path + mtime). The bake
+    saves the file and records its path/mtime; this stays true until the file is edited+saved again. Used
+    both to merge the fluid manifest and to avoid re-baking an already-locally-baked scene (Geometry-Nodes
+    sims always read as 'unbaked' from the scan, so presence alone cannot tell us a bake already ran)."""
+    current_path = bpy.data.filepath or ""
+    return (
+        bool(getattr(state, "local_bake_source_path", ""))
+        and getattr(state, "local_bake_source_path", "") == current_path
+        and getattr(state, "local_bake_source_mtime", "") == _blend_file_mtime(current_path)
+    )
+
+
 def _local_bake_fluid_attachments(state) -> list[dict[str, object]]:
-    """Fluid-cache attachments collected by a local bake — but only when they still belong to the current
-    .blend (same path + mtime). After a save/edit they are discarded, so a stale manifest never attaches to
-    a different or modified scene."""
+    """Fluid-cache attachments collected by a local bake — only when they still belong to the current
+    .blend (see _local_bake_is_current), so a stale manifest never attaches to a different/edited scene."""
     raw = getattr(state, "local_bake_fluid_manifest_json", "") or ""
-    if not raw:
-        return []
-
-    current_path = bpy.data.filepath or ""
-    if getattr(state, "local_bake_source_path", "") != current_path:
-        return []
-    if getattr(state, "local_bake_source_mtime", "") != _blend_file_mtime(current_path):
+    if not raw or not _local_bake_is_current(state):
         return []
 
     try:
@@ -314,6 +320,24 @@ def _planned_upload_attachments(state) -> list[dict[str, object]]:
     return list(collect_scene_attachment_metadata()) + _local_bake_fluid_attachments(state)
 
 
+def _should_bake_locally_first(context) -> bool:
+    """True when a Render launch must run a LOCAL bake first: the LOCAL strategy is selected, the local
+    driver is available, the scene has an unbaked simulation, and we have not already locally baked THIS
+    exact .blend (the path+mtime guard that breaks the re-bake loop — Geometry-Nodes sims always read as
+    'unbaked' from the scan, so presence alone can't tell us a bake already ran)."""
+    from .bridge_dependency_policy import LOCAL_BAKE_AVAILABLE
+
+    state = _get_runtime_state(context)
+    if not LOCAL_BAKE_AVAILABLE:
+        return False
+    if (getattr(state, "bake_strategy", "DELEGATED") or "DELEGATED").upper() != "LOCAL":
+        return False
+    if _local_bake_is_current(state):
+        return False
+
+    return bool(_scan_scene_simulations(context.scene).unbaked_kinds)
+
+
 def _apply_dependency_plan(state, attachments: list[dict[str, object]]) -> None:
     summary = summarize_scene_attachment_metadata(attachments)
     state.dependency_plan_total_count = int(summary.get("TotalCount") or 0)
@@ -1690,6 +1714,10 @@ class OUTWIT_OT_bridge_bake_local(Operator):
     bl_description = ("Bake this scene's simulations in Blender and save the .blend, so the baked scene "
                       "renders distributed without a farm bake")
 
+    # Set by the Render launch when it delegates baking to this operator: on completion, continue to the
+    # render. False for a standalone bake (the artist just wanted to bake).
+    chain_to_render: BoolProperty(default=False, options={"SKIP_SAVE", "HIDDEN"})
+
     _timer = None
     _steps: list = []
     _index = 0
@@ -1782,6 +1810,12 @@ def _finish(self, context):
                                 if fluid_attachments else "Local bake complete.")
         self.report({"INFO"}, state.status_message)
         _tag_job_areas_redraw()
+
+        # When the Render launch delegated this bake, continue to the render now that the scene is baked
+        # (it reads as baked → the launch takes the plain Render* path with the collected fluid caches).
+        if self.chain_to_render:
+            bpy.ops.outwit.bridge_launch_render("INVOKE_DEFAULT")
+
         return {"FINISHED"}
 
     def _cancel(self, context, message: str, level: str = "WARNING"):
@@ -2198,6 +2232,13 @@ def execute(self, context):
             self.report({"WARNING"}, "A launch is already in progress.")
             return {"CANCELLED"}
 
+        # LOCAL strategy with an unbaked simulation: bake it in this Blender FIRST, then the bake operator
+        # re-invokes this launch (the scene now reads as baked → plain Render* with the collected fluid
+        # caches). The path+mtime guard in _should_bake_locally_first stops this from looping.
+        if _should_bake_locally_first(context):
+            bpy.ops.outwit.bridge_bake_local("INVOKE_DEFAULT", chain_to_render=True)
+            return {"FINISHED"}
+
         # Main-thread: validate the scene is saved and gather all bpy-derived data up front, so the
         # worker thread only does network/subprocess work (Blender's API is not thread-safe).
         try:
@@ -2327,13 +2368,13 @@ def _finish_launch(self, context):
             if bake_plan.block:
                 raise BridgeClientError(bake_plan.block)
 
-            bake = bake_plan.should_delegate or bake_plan.should_local
+            covered_by_bake = bake_plan.should_delegate or bake_plan.should_local
 
             if not validation_response.is_valid:
-                # The ONLY validation failure a bake may bypass is the simulation-cache block, and only
-                # when a bake plan covers it. Any other hard issue still blocks.
+                # The ONLY validation failure a bake plan may bypass is the simulation-cache block, and
+                # only when a plan covers it. Any other hard issue still blocks.
                 other_issue = get_non_simulation_validation_issue(state.validate_issue_summary)
-                if other_issue or not bake:
+                if other_issue or not covered_by_bake:
                     raise BridgeClientError(
                         other_issue
                         or validation_response.message
@@ -2342,11 +2383,16 @@ def _finish_launch(self, context):
                         or "Blend validation reported blocking issues."
                     )
 
-            if bake:
-                # Bake path: the BakeAndRender* script bakes the simulation on the delegated node, then
-                # validates and renders the BAKED scene. The plain-scene preflight is skipped by design
-                # — it would re-flag the very simulation we are about to bake.
+            if bake_plan.should_delegate:
+                # Delegated bake: the BakeAndRender* script bakes the simulation on the fastest node, then
+                # validates and renders the BAKED scene. The plain-scene preflight is skipped by design —
+                # it would re-flag the very simulation we are about to bake.
                 response = _run_selected_launch(context, bake=True)
+            elif bake_plan.should_local:
+                # Local bake already ran in this Blender before upload — the uploaded scene IS baked, so it
+                # renders through the PLAIN Render* path with the collected fluid caches. Preflight is
+                # skipped: it can false-flag an already-baked Geometry-Nodes zone (no bake-state flag).
+                response = _run_selected_launch(context, bake=False)
             else:
                 _run_preflight(context)
                 if not _selected_mode_is_ready(state):

OutWit.Render.BlenderAddon/outwit_render_bridge/bridge_panel.py

@@ -505,6 +505,12 @@ def _draw_simulation_bake(layout, state) -> None:
     box.label(text="Bake before rendering:")
     box.prop(state, "bake_strategy", expand=True)
 
+    # LOCAL needs the artist to know Render bakes here first (and saves the file). The unbaked check keeps
+    # the note from showing once everything is already baked.
+    if (getattr(state, "bake_strategy", "DELEGATED") or "DELEGATED").upper() == "LOCAL" \
+            and getattr(state, "scene_unbaked_simulation_summary", ""):
+        box.label(text="Render will bake on this computer first (saves the .blend).", icon="INFO")
+
 
 def _draw_render_setup(layout, context, state, view) -> None:
     _draw_target(layout, state)