@hybridlabor-api/bdb-antigravity-skills 1.2.1 → 1.2.3

package/mcps/davinci-resolve-mcp-free/src/CursorBridge.py

@@ -0,0 +1,2910 @@
+#!/usr/bin/env python3
+"""
+CursorBridge - HTTP bridge between DaVinci Resolve and Cursor MCP.
+
+Launch from: Workspace > Scripts > CursorBridge
+Exposes a JSON API on localhost:9876 that an external MCP server can query.
+Works with DaVinci Resolve Free (no external scripting required).
+
+GET  endpoints = read-only queries
+POST endpoints = write / mutation operations
+"""
+
+import json
+import sys
+import traceback
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
+
+HOST = "127.0.0.1"
+PORT = 9876
+BRIDGE_VERSION = "2.0.0"
+
+# ---------------------------------------------------------------------------
+# Resolve bootstrap — grab the object while Fusion globals are in scope
+# ---------------------------------------------------------------------------
+resolve_obj = None
+
+
+def _init_resolve():
+    global resolve_obj
+    for attempt in (
+        lambda: fu.GetResolve(),        # noqa: F821
+        lambda: fusion.GetResolve(),     # noqa: F821
+        lambda: bmd.scriptapp("Resolve"),  # noqa: F821
+    ):
+        try:
+            resolve_obj = attempt()
+            if resolve_obj:
+                return
+        except Exception:
+            pass
+    try:
+        import DaVinciResolveScript as dvr
+        resolve_obj = dvr.scriptapp("Resolve")
+    except Exception:
+        pass
+
+
+_init_resolve()
+
+if resolve_obj:
+    print("[CursorBridge] Connected to Resolve: %s %s" % (
+        resolve_obj.GetProductName(), resolve_obj.GetVersionString()))
+else:
+    print("[CursorBridge] WARNING: Could not obtain Resolve object.")
+
+
+# ---------------------------------------------------------------------------
+# Shared helpers
+# ---------------------------------------------------------------------------
+
+def safe(fn):
+    try:
+        return fn()
+    except Exception:
+        return None
+
+
+def _resolve():
+    r = resolve_obj
+    if not r:
+        return None, {"error": "Not connected to Resolve"}
+    return r, None
+
+
+def _project():
+    r, err = _resolve()
+    if err:
+        return None, None, err
+    pm = r.GetProjectManager()
+    if not pm:
+        return None, None, {"error": "No project manager"}
+    proj = pm.GetCurrentProject()
+    if not proj:
+        return None, None, {"error": "No project open"}
+    return r, proj, None
+
+
+def _timeline():
+    r, proj, err = _project()
+    if err:
+        return None, None, None, err
+    tl = proj.GetCurrentTimeline()
+    if not tl:
+        return None, None, None, {"error": "No timeline open"}
+    return r, proj, tl, None
+
+
+def _clip_at(body):
+    """Locate a TimelineItem by trackType / trackIndex / clipIndex."""
+    _, _, tl, err = _timeline()
+    if err:
+        return None, err
+    tt = body.get("trackType", "video")
+    ti = int(body.get("trackIndex", 1))
+    ci = int(body.get("clipIndex", 0))
+    items = safe(lambda: tl.GetItemListInTrack(tt, ti))
+    if not items:
+        return None, {"error": "No clips on %s track %d" % (tt, ti)}
+    if ci < 0 or ci >= len(items):
+        return None, {"error": "clipIndex %d out of range (0-%d)" % (ci, len(items) - 1)}
+    return items[ci], None
+
+
+def _find_pool_item(pool, name):
+    """Recursively search media pool for an item by name."""
+    def search(folder):
+        clips = folder.GetClipList() or []
+        for c in clips:
+            if safe(lambda: c.GetName()) == name:
+                return c
+        for sf in (folder.GetSubFolderList() or []):
+            hit = search(sf)
+            if hit:
+                return hit
+        return None
+    root = pool.GetRootFolder()
+    return search(root) if root else None
+
+
+def _find_folder_by_path(pool, path):
+    """Find a media pool folder by slash-separated path (e.g. 'Footage/Day1')."""
+    root = pool.GetRootFolder()
+    if not root:
+        return None
+    if not path or path.lower() in ("root", "/", ""):
+        return root
+    parts = [p for p in path.split("/") if p and p.lower() not in ("root", "master")]
+    current = root
+    for part in parts:
+        subfolders = current.GetSubFolderList() or []
+        found = None
+        for sf in subfolders:
+            if safe(lambda sf=sf: sf.GetName()) == part:
+                found = sf
+                break
+        if not found:
+            return None
+        current = found
+    return current
+
+
+def _resolve_clip_refs(tl, clip_refs):
+    """Resolve a list of {trackType, trackIndex, clipIndex} dicts to TimelineItem objects."""
+    items = []
+    for ref in clip_refs:
+        tt = ref.get("trackType", "video")
+        ti = int(ref.get("trackIndex", 1))
+        ci = int(ref.get("clipIndex", 0))
+        track_items = safe(lambda tt=tt, ti=ti: tl.GetItemListInTrack(tt, ti))
+        if track_items and 0 <= ci < len(track_items):
+            items.append(track_items[ci])
+    return items
+
+
+def _get_album(gallery, body):
+    """Get a gallery album from body params (albumIndex + albumType), or current album."""
+    album_index = int(body.get("albumIndex", 0))
+    album_type = body.get("albumType", "still")
+    if album_index > 0:
+        if album_type == "powergrade":
+            albums = safe(lambda: gallery.GetGalleryPowerGradeAlbums()) or []
+        else:
+            albums = safe(lambda: gallery.GetGalleryStillAlbums()) or []
+        if album_index < 1 or album_index > len(albums):
+            return None, {"error": "Album index %d out of range (1-%d)" % (album_index, len(albums))}
+        return albums[album_index - 1], None
+    album = safe(lambda: gallery.GetCurrentStillAlbum())
+    if not album:
+        return None, {"error": "No album selected"}
+    return album, None
+
+
+# ---------------------------------------------------------------------------
+# GET handlers  (read-only)
+# ---------------------------------------------------------------------------
+
+def gather_status():
+    r, err = _resolve()
+    if err:
+        return {"connected": False, "bridgeVersion": BRIDGE_VERSION, **err}
+    return {
+        "connected": True,
+        "bridgeVersion": BRIDGE_VERSION,
+        "product": safe(lambda: r.GetProductName()),
+        "version": safe(lambda: r.GetVersionString()),
+    }
+
+
+def gather_project():
+    _, proj, err = _project()
+    if err:
+        return err
+    keys = [
+        "timelineResolutionWidth", "timelineResolutionHeight",
+        "timelineFrameRate", "timelinePlaybackFrameRate",
+        "colorScienceMode", "audioCaptureNumChannels", "superScale",
+    ]
+    settings = {}
+    for k in keys:
+        v = safe(lambda k=k: proj.GetSetting(k))
+        if v not in (None, ""):
+            settings[k] = v
+    return {
+        "name": safe(lambda: proj.GetName()),
+        "timelineCount": safe(lambda: proj.GetTimelineCount()),
+        "currentRenderFormatAndCodec": safe(lambda: proj.GetCurrentRenderFormatAndCodec()),
+        "settings": settings,
+    }
+
+
+def gather_page():
+    r, err = _resolve()
+    if err:
+        return err
+    return {"page": safe(lambda: r.GetCurrentPage())}
+
+
+def gather_timeline():
+    _, proj, tl, err = _timeline()
+    if err:
+        return err
+    vt = safe(lambda: tl.GetTrackCount("video")) or 0
+    at = safe(lambda: tl.GetTrackCount("audio")) or 0
+    st = safe(lambda: tl.GetTrackCount("subtitle")) or 0
+    names = {}
+    for i in range(1, vt + 1):
+        n = safe(lambda i=i: tl.GetTrackName("video", i))
+        if n:
+            names["video_%d" % i] = n
+    for i in range(1, at + 1):
+        n = safe(lambda i=i: tl.GetTrackName("audio", i))
+        if n:
+            names["audio_%d" % i] = n
+    tl_keys = [
+        "timelineResolutionWidth", "timelineResolutionHeight",
+        "timelineFrameRate", "timelineOutputResolutionWidth",
+        "timelineOutputResolutionHeight",
+    ]
+    settings = {}
+    for k in tl_keys:
+        v = safe(lambda k=k: tl.GetSetting(k))
+        if v not in (None, ""):
+            settings[k] = v
+    return {
+        "name": safe(lambda: tl.GetName()),
+        "startFrame": safe(lambda: tl.GetStartFrame()),
+        "endFrame": safe(lambda: tl.GetEndFrame()),
+        "startTimecode": safe(lambda: tl.GetStartTimecode()),
+        "currentTimecode": safe(lambda: tl.GetCurrentTimecode()),
+        "trackCount": {"video": vt, "audio": at, "subtitle": st},
+        "trackNames": names,
+        "markInOut": safe(lambda: tl.GetMarkInOut()),
+        "settings": settings,
+    }
+
+
+def gather_clips(track_type, track_index):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    mx = safe(lambda: tl.GetTrackCount(track_type)) or 0
+    if track_index < 1 or track_index > mx:
+        return {"error": "Track index %d out of range (1-%d) for %s" % (track_index, mx, track_type)}
+    items = safe(lambda: tl.GetItemListInTrack(track_type, track_index))
+    if not items:
+        return {"trackType": track_type, "trackIndex": track_index, "clips": []}
+    clips = []
+    for item in items:
+        cd = {
+            "name": safe(lambda: item.GetName()),
+            "duration": safe(lambda: item.GetDuration()),
+            "start": safe(lambda: item.GetStart()),
+            "end": safe(lambda: item.GetEnd()),
+            "enabled": safe(lambda: item.GetClipEnabled()),
+            "color": safe(lambda: item.GetClipColor()),
+        }
+        mp = safe(lambda: item.GetMediaPoolItem())
+        if mp:
+            props = safe(lambda: mp.GetClipProperty()) or {}
+            for key in ("File Path", "Clip Name", "Resolution", "FPS", "Frames", "Duration", "Audio Ch"):
+                if key in props:
+                    cd[key] = props[key]
+        clips.append(cd)
+    return {"trackType": track_type, "trackIndex": track_index, "clips": clips}
+
+
+def gather_markers():
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    raw = safe(lambda: tl.GetMarkers()) or {}
+    return {"markers": [{"frameId": fid, **info} for fid, info in raw.items()]}
+
+
+def gather_render():
+    _, proj, err = _project()
+    if err:
+        return err
+    return {
+        "formatAndCodec": safe(lambda: proj.GetCurrentRenderFormatAndCodec()),
+        "renderMode": safe(lambda: proj.GetCurrentRenderMode()),
+        "renderJobList": safe(lambda: proj.GetRenderJobList()),
+        "isRendering": safe(lambda: proj.IsRenderingInProgress()),
+    }
+
+
+def gather_media_pool():
+    """List clips in current media pool folder."""
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    folder = pool.GetCurrentFolder()
+    if not folder:
+        return {"error": "No current folder"}
+    clips = folder.GetClipList() or []
+    result = []
+    for c in clips:
+        result.append({
+            "name": safe(lambda: c.GetName()),
+            "clipColor": safe(lambda: c.GetClipColor()),
+            "mediaId": safe(lambda: c.GetMediaId()),
+        })
+    subfolders = [safe(lambda sf=sf: sf.GetName()) for sf in (folder.GetSubFolderList() or [])]
+    return {
+        "folderName": safe(lambda: folder.GetName()),
+        "clips": result,
+        "subfolders": subfolders,
+    }
+
+
+def gather_media_pool_structure(qs):
+    """Get the media pool folder tree structure."""
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    include_clips = qs.get("include_clips", ["false"])[0].lower() == "true"
+    max_depth = int(qs.get("max_depth", ["10"])[0])
+
+    def build_tree(folder, depth=0):
+        if depth > max_depth:
+            return {"name": safe(lambda: folder.GetName()), "truncated": True}
+        clips = folder.GetClipList() or []
+        subfolders = folder.GetSubFolderList() or []
+        node = {
+            "name": safe(lambda: folder.GetName()),
+            "clipCount": len(clips),
+            "subfolderCount": len(subfolders),
+        }
+        if include_clips:
+            node["clips"] = [{"name": safe(lambda c=c: c.GetName()),
+                              "mediaId": safe(lambda c=c: c.GetMediaId())} for c in clips]
+        node["subfolders"] = [build_tree(sf, depth + 1) for sf in subfolders]
+        return node
+
+    root = pool.GetRootFolder()
+    if not root:
+        return {"error": "No root folder"}
+    current = pool.GetCurrentFolder()
+    return {
+        "tree": build_tree(root),
+        "currentFolder": safe(lambda: current.GetName()) if current else None,
+    }
+
+
+def gather_clip_metadata(qs):
+    """Get metadata for a media pool clip by name."""
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_name = qs.get("clip_name", [""])[0]
+    if not clip_name:
+        return {"error": "clip_name parameter is required"}
+    item = _find_pool_item(pool, clip_name)
+    if not item:
+        return {"error": "Clip '%s' not found in media pool" % clip_name}
+    metadata = safe(lambda: item.GetMetadata()) or {}
+    third_party = safe(lambda: item.GetThirdPartyMetadata()) or {}
+    return {
+        "name": safe(lambda: item.GetName()),
+        "mediaId": safe(lambda: item.GetMediaId()),
+        "metadata": metadata,
+        "thirdPartyMetadata": third_party,
+    }
+
+
+def gather_clip_info(qs):
+    """Get detailed clip properties for a media pool clip."""
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_name = qs.get("clip_name", [""])[0]
+    if not clip_name:
+        return {"error": "clip_name parameter is required"}
+    item = _find_pool_item(pool, clip_name)
+    if not item:
+        return {"error": "Clip '%s' not found in media pool" % clip_name}
+    props = safe(lambda: item.GetClipProperty()) or {}
+    flags = safe(lambda: item.GetFlagList()) or []
+    markers = safe(lambda: item.GetMarkers()) or {}
+    mark_in_out = safe(lambda: item.GetMarkInOut()) or {}
+    return {
+        "name": safe(lambda: item.GetName()),
+        "mediaId": safe(lambda: item.GetMediaId()),
+        "clipColor": safe(lambda: item.GetClipColor()) or "",
+        "flags": flags,
+        "markers": {str(k): v for k, v in markers.items()},
+        "markInOut": mark_in_out,
+        "properties": props,
+    }
+
+
+def gather_clip_markers(qs):
+    """Get markers on a specific timeline item."""
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    tt = qs.get("track_type", ["video"])[0]
+    ti = int(qs.get("track_index", ["1"])[0])
+    ci = int(qs.get("clip_index", ["0"])[0])
+    items = safe(lambda: tl.GetItemListInTrack(tt, ti))
+    if not items:
+        return {"error": "No clips on %s track %d" % (tt, ti)}
+    if ci < 0 or ci >= len(items):
+        return {"error": "clipIndex %d out of range (0-%d)" % (ci, len(items) - 1)}
+    item = items[ci]
+    markers = safe(lambda: item.GetMarkers()) or {}
+    return {
+        "clipName": safe(lambda: item.GetName()),
+        "markers": [{"frameId": fid, **info} for fid, info in markers.items()],
+    }
+
+
+def gather_clip_flags(qs):
+    """Get flags on a specific timeline item."""
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    tt = qs.get("track_type", ["video"])[0]
+    ti = int(qs.get("track_index", ["1"])[0])
+    ci = int(qs.get("clip_index", ["0"])[0])
+    items = safe(lambda: tl.GetItemListInTrack(tt, ti))
+    if not items:
+        return {"error": "No clips on %s track %d" % (tt, ti)}
+    if ci < 0 or ci >= len(items):
+        return {"error": "clipIndex %d out of range (0-%d)" % (ci, len(items) - 1)}
+    item = items[ci]
+    flags = safe(lambda: item.GetFlagList()) or []
+    return {"clipName": safe(lambda: item.GetName()), "flags": flags}
+
+
+def gather_current_video_item(qs):
+    """Get the current video item at the playhead."""
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    item = safe(lambda: tl.GetCurrentVideoItem())
+    if not item:
+        return {"error": "No current video item at playhead"}
+    mp = safe(lambda: item.GetMediaPoolItem())
+    props = {}
+    if mp:
+        props = safe(lambda: mp.GetClipProperty()) or {}
+    track_info = safe(lambda: item.GetTrackTypeAndIndex()) or []
+    return {
+        "name": safe(lambda: item.GetName()),
+        "duration": safe(lambda: item.GetDuration()),
+        "start": safe(lambda: item.GetStart()),
+        "end": safe(lambda: item.GetEnd()),
+        "enabled": safe(lambda: item.GetClipEnabled()),
+        "color": safe(lambda: item.GetClipColor()),
+        "trackType": track_info[0] if len(track_info) > 0 else None,
+        "trackIndex": track_info[1] if len(track_info) > 1 else None,
+        "properties": {k: props[k] for k in ("File Path", "Clip Name", "Resolution", "FPS", "Frames", "Duration") if k in props},
+    }
+
+
+def gather_clip_thumbnail(qs):
+    """Get thumbnail for current clip (Color page only)."""
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    data = safe(lambda: tl.GetCurrentClipThumbnailImage())
+    if not data:
+        return {"error": "Failed to get thumbnail. Make sure you are on the Color page."}
+    return data
+
+
+def gather_gallery_albums(qs):
+    """List gallery still albums and PowerGrade albums."""
+    _, proj, err = _project()
+    if err:
+        return err
+    gallery = safe(lambda: proj.GetGallery())
+    if not gallery:
+        return {"error": "Cannot access gallery"}
+    still_albums = safe(lambda: gallery.GetGalleryStillAlbums()) or []
+    pg_albums = safe(lambda: gallery.GetGalleryPowerGradeAlbums()) or []
+    current = safe(lambda: gallery.GetCurrentStillAlbum())
+    current_name = safe(lambda: gallery.GetAlbumName(current)) if current else None
+    result = {"currentAlbum": current_name, "stillAlbums": [], "powerGradeAlbums": []}
+    for i, album in enumerate(still_albums):
+        name = safe(lambda a=album: gallery.GetAlbumName(a))
+        stills = safe(lambda a=album: a.GetStills()) or []
+        result["stillAlbums"].append({"index": i + 1, "name": name, "stillCount": len(stills)})
+    for i, album in enumerate(pg_albums):
+        name = safe(lambda a=album: gallery.GetAlbumName(a))
+        stills = safe(lambda a=album: a.GetStills()) or []
+        result["powerGradeAlbums"].append({"index": i + 1, "name": name, "stillCount": len(stills)})
+    return result
+
+
+def gather_album_stills(qs):
+    """List stills in a gallery album."""
+    _, proj, err = _project()
+    if err:
+        return err
+    gallery = safe(lambda: proj.GetGallery())
+    if not gallery:
+        return {"error": "Cannot access gallery"}
+    album_index = int(qs.get("album_index", ["0"])[0])
+    album_type = qs.get("album_type", ["still"])[0]
+    if album_index > 0:
+        if album_type == "powergrade":
+            albums = safe(lambda: gallery.GetGalleryPowerGradeAlbums()) or []
+        else:
+            albums = safe(lambda: gallery.GetGalleryStillAlbums()) or []
+        if album_index < 1 or album_index > len(albums):
+            return {"error": "Album index %d out of range (1-%d)" % (album_index, len(albums))}
+        album = albums[album_index - 1]
+    else:
+        album = safe(lambda: gallery.GetCurrentStillAlbum())
+    if not album:
+        return {"error": "No album selected"}
+    album_name = safe(lambda: gallery.GetAlbumName(album))
+    stills = safe(lambda: album.GetStills()) or []
+    result = []
+    for i, still in enumerate(stills):
+        label = safe(lambda s=still: album.GetLabel(s))
+        result.append({"index": i + 1, "label": label or ""})
+    return {"albumName": album_name, "stills": result}
+
+
+# ---------------------------------------------------------------------------
+# POST handlers  (write / mutate)
+# ---------------------------------------------------------------------------
+
+VALID_PAGES = ("media", "cut", "edit", "fusion", "color", "fairlight", "deliver")
+
+
+def action_open_page(body):
+    r, err = _resolve()
+    if err:
+        return err
+    page = body.get("page", "")
+    if page not in VALID_PAGES:
+        return {"error": "Invalid page. Must be one of: %s" % ", ".join(VALID_PAGES)}
+    return {"success": bool(r.OpenPage(page)), "page": page}
+
+
+def action_set_timecode(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    tc = body.get("timecode", "")
+    if not tc:
+        return {"error": "timecode is required (e.g. '01:00:05:00')"}
+    return {"success": bool(tl.SetCurrentTimecode(tc)), "timecode": tc}
+
+
+# -- Markers ---------------------------------------------------------------
+
+def action_add_marker(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    frame_id = body.get("frameId")
+    if frame_id is None:
+        return {"error": "frameId is required"}
+    color = body.get("color", "Blue")
+    name = body.get("name", "")
+    note = body.get("note", "")
+    duration = body.get("duration", 1)
+    custom = body.get("customData", "")
+    ok = tl.AddMarker(int(frame_id), color, name, note, int(duration), custom)
+    return {"success": bool(ok), "frameId": frame_id, "color": color}
+
+
+def action_delete_marker(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    frame = body.get("frameId")
+    color = body.get("color")
+    if frame is not None:
+        return {"success": bool(tl.DeleteMarkerAtFrame(int(frame))), "frameId": frame}
+    if color:
+        return {"success": bool(tl.DeleteMarkersByColor(color)), "color": color}
+    return {"error": "Provide frameId or color (use 'All' to delete all)"}
+
+
+# -- Timeline management ---------------------------------------------------
+
+def action_switch_timeline(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    idx = body.get("index")
+    if idx is None:
+        return {"error": "index is required (1-based)"}
+    idx = int(idx)
+    total = proj.GetTimelineCount() or 0
+    if idx < 1 or idx > total:
+        return {"error": "index %d out of range (1-%d)" % (idx, total)}
+    tl = proj.GetTimelineByIndex(idx)
+    if not tl:
+        return {"error": "Could not get timeline at index %d" % idx}
+    ok = proj.SetCurrentTimeline(tl)
+    return {"success": bool(ok), "timeline": safe(lambda: tl.GetName())}
+
+
+def action_create_timeline(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    name = body.get("name", "")
+    if not name:
+        return {"error": "name is required"}
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    tl = pool.CreateEmptyTimeline(name)
+    if not tl:
+        return {"error": "Failed to create timeline '%s'" % name}
+    return {"success": True, "timeline": name}
+
+
+def action_rename_timeline(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    name = body.get("name", "")
+    if not name:
+        return {"error": "name is required"}
+    return {"success": bool(tl.SetName(name)), "name": name}
+
+
+def action_duplicate_timeline(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    name = body.get("name", "")
+    new_tl = tl.DuplicateTimeline(name) if name else tl.DuplicateTimeline()
+    if not new_tl:
+        return {"error": "Failed to duplicate timeline"}
+    return {"success": True, "timeline": safe(lambda: new_tl.GetName())}
+
+
+# -- Track management ------------------------------------------------------
+
+def action_add_track(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    tt = body.get("trackType", "video")
+    sub = body.get("subTrackType", "")
+    if sub:
+        ok = tl.AddTrack(tt, sub)
+    else:
+        ok = tl.AddTrack(tt)
+    return {"success": bool(ok), "trackType": tt}
+
+
+def action_delete_track(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    tt = body.get("trackType", "video")
+    ti = int(body.get("trackIndex", 0))
+    if ti < 1:
+        return {"error": "trackIndex must be >= 1"}
+    return {"success": bool(tl.DeleteTrack(tt, ti)), "trackType": tt, "trackIndex": ti}
+
+
+def action_set_track_enable(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    tt = body.get("trackType", "video")
+    ti = int(body.get("trackIndex", 1))
+    en = bool(body.get("enabled", True))
+    return {"success": bool(tl.SetTrackEnable(tt, ti, en)), "enabled": en}
+
+
+def action_set_track_lock(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    tt = body.get("trackType", "video")
+    ti = int(body.get("trackIndex", 1))
+    locked = bool(body.get("locked", True))
+    return {"success": bool(tl.SetTrackLock(tt, ti, locked)), "locked": locked}
+
+
+def action_set_track_name(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    tt = body.get("trackType", "video")
+    ti = int(body.get("trackIndex", 1))
+    name = body.get("name", "")
+    if not name:
+        return {"error": "name is required"}
+    return {"success": bool(tl.SetTrackName(tt, ti, name)), "name": name}
+
+
+# -- Media management ------------------------------------------------------
+
+def action_import_media(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    paths = body.get("filePaths", [])
+    if not paths:
+        return {"error": "filePaths array is required"}
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    items = pool.ImportMedia(paths)
+    if not items:
+        return {"error": "Import failed — check file paths are valid Windows paths accessible from Resolve"}
+    return {
+        "success": True,
+        "imported": [safe(lambda i=i: i.GetName()) for i in items],
+    }
+
+
+def action_import_media_from_storage(body):
+    r, proj, err = _project()
+    if err:
+        return err
+    paths = body.get("filePaths", [])
+    if not paths:
+        return {"error": "filePaths array is required"}
+    ms = r.GetMediaStorage()
+    if not ms:
+        return {"error": "No media storage"}
+    items = ms.AddItemListToMediaPool(paths)
+    if not items:
+        return {"error": "Import from storage failed"}
+    return {
+        "success": True,
+        "imported": [safe(lambda i=i: i.GetName()) for i in items],
+    }
+
+
+def action_append_to_timeline(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_name = body.get("clipName", "")
+    if not clip_name:
+        return {"error": "clipName is required"}
+    item = _find_pool_item(pool, clip_name)
+    if not item:
+        return {"error": "Clip '%s' not found in media pool" % clip_name}
+    tl_items = pool.AppendToTimeline([item])
+    if not tl_items:
+        return {"error": "Failed to append clip to timeline"}
+    return {"success": True, "appended": clip_name}
+
+
+# -- Clip operations -------------------------------------------------------
+
+def action_set_clip_color(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    color = body.get("color", "")
+    if not color:
+        ok = item.ClearClipColor()
+        return {"success": bool(ok), "action": "cleared"}
+    return {"success": bool(item.SetClipColor(color)), "color": color}
+
+
+def action_set_clip_enabled(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    en = bool(body.get("enabled", True))
+    return {"success": bool(item.SetClipEnabled(en)), "enabled": en}
+
+
+def action_set_clip_properties(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    props = body.get("properties", {})
+    if not props:
+        return {"error": "properties dict is required (e.g. {\"Pan\": 0, \"Opacity\": 80})"}
+    results = {}
+    for k, v in props.items():
+        results[k] = bool(item.SetProperty(k, v))
+    return {"success": all(results.values()), "results": results}
+
+
+def action_add_clip_marker(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    fid = body.get("frameId")
+    if fid is None:
+        return {"error": "frameId is required"}
+    ok = item.AddMarker(
+        int(fid),
+        body.get("color", "Blue"),
+        body.get("name", ""),
+        body.get("note", ""),
+        int(body.get("duration", 1)),
+        body.get("customData", ""),
+    )
+    return {"success": bool(ok)}
+
+
+# -- Titles / Generators ---------------------------------------------------
+
+def action_insert_title(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    name = body.get("titleName", "")
+    if not name:
+        return {"error": "titleName is required (e.g. 'Text+', 'Scroll')"}
+    fusion_title = body.get("fusionTitle", False)
+    if fusion_title:
+        item = tl.InsertFusionTitleIntoTimeline(name)
+    else:
+        item = tl.InsertTitleIntoTimeline(name)
+    if not item:
+        return {"error": "Failed to insert title '%s'" % name}
+    return {"success": True, "title": name, "clipName": safe(lambda: item.GetName())}
+
+
+def action_insert_generator(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    name = body.get("generatorName", "")
+    if not name:
+        return {"error": "generatorName is required (e.g. 'Solid Color', '10 Step')"}
+    fusion_gen = body.get("fusionGenerator", False)
+    if fusion_gen:
+        item = tl.InsertFusionGeneratorIntoTimeline(name)
+    else:
+        item = tl.InsertGeneratorIntoTimeline(name)
+    if not item:
+        return {"error": "Failed to insert generator '%s'" % name}
+    return {"success": True, "generator": name, "clipName": safe(lambda: item.GetName())}
+
+
+def action_insert_fusion_comp(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    item = tl.InsertFusionCompositionIntoTimeline()
+    if not item:
+        return {"error": "Failed to insert Fusion composition"}
+    return {"success": True, "clipName": safe(lambda: item.GetName())}
+
+
+# -- Render -----------------------------------------------------------------
+
+def action_set_render_settings(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    settings = body.get("settings", {})
+    if not settings:
+        return {"error": "settings dict is required"}
+    return {"success": bool(proj.SetRenderSettings(settings))}
+
+
+def action_set_render_format(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    fmt = body.get("format", "")
+    codec = body.get("codec", "")
+    if not fmt or not codec:
+        return {"error": "format and codec are required"}
+    return {"success": bool(proj.SetCurrentRenderFormatAndCodec(fmt, codec))}
+
+
+def action_add_render_job(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    job_id = proj.AddRenderJob()
+    if not job_id:
+        return {"error": "Failed to add render job — check render settings are complete"}
+    return {"success": True, "jobId": job_id}
+
+
+def action_start_rendering(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    job_ids = body.get("jobIds", [])
+    if job_ids:
+        ok = proj.StartRendering(job_ids)
+    else:
+        ok = proj.StartRendering()
+    return {"success": bool(ok)}
+
+
+def action_stop_rendering(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    proj.StopRendering()
+    return {"success": True}
+
+
+def action_delete_render_job(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    job_id = body.get("jobId", "")
+    if job_id:
+        return {"success": bool(proj.DeleteRenderJob(job_id))}
+    if body.get("all", False):
+        return {"success": bool(proj.DeleteAllRenderJobs())}
+    return {"error": "Provide jobId or set all=true"}
+
+
+def action_get_render_formats(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    formats = safe(lambda: proj.GetRenderFormats()) or {}
+    fmt = body.get("format", "")
+    if fmt:
+        codecs = safe(lambda: proj.GetRenderCodecs(fmt)) or {}
+        return {"format": fmt, "codecs": codecs}
+    return {"formats": formats}
+
+
+# -- Project ----------------------------------------------------------------
+
+def action_save_project(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    return {"success": bool(proj.GetName() and resolve_obj.GetProjectManager().SaveProject())}
+
+
+def action_set_project_setting(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    key = body.get("key", "")
+    value = body.get("value", "")
+    if not key:
+        return {"error": "key is required"}
+    return {"success": bool(proj.SetSetting(key, str(value))), "key": key, "value": value}
+
+
+def action_set_timeline_setting(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    key = body.get("key", "")
+    value = body.get("value", "")
+    if not key:
+        return {"error": "key is required"}
+    return {"success": bool(tl.SetSetting(key, str(value))), "key": key, "value": value}
+
+
+def action_export_frame(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    path = body.get("filePath", "")
+    if not path:
+        return {"error": "filePath is required (e.g. 'C:\\\\output\\\\frame.png')"}
+    return {"success": bool(proj.ExportCurrentFrameAsStill(path)), "filePath": path}
+
+
+def action_create_subtitles(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    ok = tl.CreateSubtitlesFromAudio(body.get("settings", {}))
+    return {"success": bool(ok)}
+
+
+def action_detect_scene_cuts(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    return {"success": bool(tl.DetectSceneCuts())}
+
+
+# -- Media Pool Deep Access -------------------------------------------------
+
+def action_navigate_media_pool(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    path = body.get("path", "")
+    if not path or path.lower() in ("root", "/"):
+        folder = pool.GetRootFolder()
+    else:
+        folder = _find_folder_by_path(pool, path)
+    if not folder:
+        return {"error": "Folder not found: '%s'" % path}
+    ok = pool.SetCurrentFolder(folder)
+    return {"success": bool(ok), "folder": safe(lambda: folder.GetName())}
+
+
+def action_create_media_pool_folder(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    name = body.get("name", "")
+    if not name:
+        return {"error": "name is required"}
+    parent_path = body.get("parentPath", "")
+    if parent_path:
+        parent = _find_folder_by_path(pool, parent_path)
+        if not parent:
+            return {"error": "Parent folder not found: '%s'" % parent_path}
+    else:
+        parent = pool.GetCurrentFolder()
+    if not parent:
+        return {"error": "No parent folder"}
+    new_folder = pool.AddSubFolder(parent, name)
+    if not new_folder:
+        return {"error": "Failed to create folder '%s'" % name}
+    return {"success": True, "folder": name}
+
+
+def action_set_clip_metadata(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_name = body.get("clipName", "")
+    if not clip_name:
+        return {"error": "clipName is required"}
+    item = _find_pool_item(pool, clip_name)
+    if not item:
+        return {"error": "Clip '%s' not found in media pool" % clip_name}
+    metadata = body.get("metadata", {})
+    if not metadata:
+        return {"error": "metadata dict is required"}
+    ok = item.SetMetadata(metadata)
+    return {"success": bool(ok)}
+
+
+def action_set_pool_clip_property(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_name = body.get("clipName", "")
+    if not clip_name:
+        return {"error": "clipName is required"}
+    item = _find_pool_item(pool, clip_name)
+    if not item:
+        return {"error": "Clip '%s' not found in media pool" % clip_name}
+    prop_name = body.get("propertyName", "")
+    prop_value = body.get("propertyValue", "")
+    if not prop_name:
+        return {"error": "propertyName is required"}
+    ok = item.SetClipProperty(prop_name, prop_value)
+    return {"success": bool(ok), "property": prop_name}
+
+
+def action_delete_media_pool_clips(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_names = body.get("clipNames", [])
+    if not clip_names:
+        return {"error": "clipNames array is required"}
+    items, not_found = [], []
+    for name in clip_names:
+        item = _find_pool_item(pool, name)
+        if item:
+            items.append(item)
+        else:
+            not_found.append(name)
+    if not items:
+        return {"error": "No matching clips found", "notFound": not_found}
+    ok = pool.DeleteClips(items)
+    return {"success": bool(ok), "deleted": len(items), "notFound": not_found}
+
+
+def action_move_media_pool_clips(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_names = body.get("clipNames", [])
+    target_path = body.get("targetFolder", "")
+    if not clip_names:
+        return {"error": "clipNames array is required"}
+    if not target_path:
+        return {"error": "targetFolder path is required"}
+    target = _find_folder_by_path(pool, target_path)
+    if not target:
+        return {"error": "Target folder not found: '%s'" % target_path}
+    items = [i for name in clip_names for i in [_find_pool_item(pool, name)] if i]
+    if not items:
+        return {"error": "No matching clips found"}
+    ok = pool.MoveClips(items, target)
+    return {"success": bool(ok), "moved": len(items)}
+
+
+def action_relink_media_pool_clips(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_names = body.get("clipNames", [])
+    folder_path = body.get("folderPath", "")
+    if not clip_names:
+        return {"error": "clipNames array is required"}
+    if not folder_path:
+        return {"error": "folderPath is required (filesystem path)"}
+    items = [i for name in clip_names for i in [_find_pool_item(pool, name)] if i]
+    if not items:
+        return {"error": "No matching clips found"}
+    ok = pool.RelinkClips(items, folder_path)
+    return {"success": bool(ok), "relinked": len(items)}
+
+
+def action_unlink_media_pool_clips(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_names = body.get("clipNames", [])
+    if not clip_names:
+        return {"error": "clipNames array is required"}
+    items = [i for name in clip_names for i in [_find_pool_item(pool, name)] if i]
+    if not items:
+        return {"error": "No matching clips found"}
+    ok = pool.UnlinkClips(items)
+    return {"success": bool(ok), "unlinked": len(items)}
+
+
+def action_auto_sync_audio(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_names = body.get("clipNames", [])
+    if len(clip_names) < 2:
+        return {"error": "At least 2 clipNames required (video + audio)"}
+    items = [i for name in clip_names for i in [_find_pool_item(pool, name)] if i]
+    if len(items) < 2:
+        return {"error": "Need at least 2 matching clips"}
+    settings = body.get("settings", {})
+    ok = pool.AutoSyncAudio(items, settings)
+    return {"success": bool(ok)}
+
+
+def action_import_timeline_from_file(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    file_path = body.get("filePath", "")
+    if not file_path:
+        return {"error": "filePath is required"}
+    options = body.get("importOptions", {})
+    tl = pool.ImportTimelineFromFile(file_path, options) if options else pool.ImportTimelineFromFile(file_path)
+    if not tl:
+        return {"error": "Failed to import timeline from '%s'" % file_path}
+    return {"success": True, "timeline": safe(lambda: tl.GetName())}
+
+
+def action_export_metadata(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    file_name = body.get("fileName", "")
+    if not file_name:
+        return {"error": "fileName is required (CSV path)"}
+    clip_names = body.get("clipNames", [])
+    items = [i for name in clip_names for i in [_find_pool_item(pool, name)] if i] if clip_names else []
+    ok = pool.ExportMetadata(file_name, items) if items else pool.ExportMetadata(file_name)
+    return {"success": bool(ok), "fileName": file_name}
+
+
+def action_insert_to_timeline(body):
+    """Insert a media pool clip at a specific track and record frame position."""
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_name = body.get("clipName", "")
+    if not clip_name:
+        return {"error": "clipName is required"}
+    item = _find_pool_item(pool, clip_name)
+    if not item:
+        return {"error": "Clip '%s' not found in media pool" % clip_name}
+    clip_info = {"mediaPoolItem": item}
+    for key, body_key in [("trackIndex", "trackIndex"), ("recordFrame", "recordFrame"),
+                          ("startFrame", "startFrame"), ("endFrame", "endFrame"),
+                          ("mediaType", "mediaType")]:
+        val = body.get(body_key)
+        if val is not None:
+            clip_info[key] = int(val)
+    tl_items = pool.AppendToTimeline([clip_info])
+    if not tl_items:
+        return {"error": "Failed to insert clip to timeline"}
+    return {"success": True, "inserted": clip_name, "count": len(tl_items)}
+
+
+# -- Per-Clip Markers & Flags ----------------------------------------------
+
+def action_delete_clip_marker(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    frame = body.get("frameId")
+    color = body.get("color")
+    custom_data = body.get("customData")
+    if frame is not None:
+        return {"success": bool(item.DeleteMarkerAtFrame(int(frame)))}
+    if color:
+        return {"success": bool(item.DeleteMarkersByColor(color))}
+    if custom_data:
+        return {"success": bool(item.DeleteMarkerByCustomData(custom_data))}
+    return {"error": "Provide frameId, color (use 'All' for all), or customData"}
+
+
+def action_add_clip_flag(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    color = body.get("color", "")
+    if not color:
+        return {"error": "color is required"}
+    return {"success": bool(item.AddFlag(color)), "color": color}
+
+
+def action_clear_clip_flags(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    color = body.get("color", "All")
+    return {"success": bool(item.ClearFlags(color)), "color": color}
+
+
+# -- Timeline Clip Manipulation ---------------------------------------------
+
+def action_delete_timeline_clips(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    clip_refs = body.get("clips", [])
+    ripple = body.get("ripple", False)
+    if not clip_refs:
+        return {"error": "clips array is required (each: {trackType, trackIndex, clipIndex})"}
+    items = _resolve_clip_refs(tl, clip_refs)
+    if not items:
+        return {"error": "No matching clips found"}
+    ok = tl.DeleteClips(items, ripple)
+    return {"success": bool(ok), "deleted": len(items), "ripple": ripple}
+
+
+def action_link_timeline_clips(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    clip_refs = body.get("clips", [])
+    linked = body.get("linked", True)
+    if len(clip_refs) < 2:
+        return {"error": "At least 2 clip references required"}
+    items = _resolve_clip_refs(tl, clip_refs)
+    if len(items) < 2:
+        return {"error": "Need at least 2 matching clips"}
+    ok = tl.SetClipsLinked(items, linked)
+    return {"success": bool(ok), "linked": linked, "count": len(items)}
+
+
+def action_create_compound_clip(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    clip_refs = body.get("clips", [])
+    if not clip_refs:
+        return {"error": "clips array is required"}
+    items = _resolve_clip_refs(tl, clip_refs)
+    if not items:
+        return {"error": "No matching clips found"}
+    clip_info = {}
+    if body.get("name"):
+        clip_info["name"] = body["name"]
+    if body.get("startTimecode"):
+        clip_info["startTimecode"] = body["startTimecode"]
+    result = tl.CreateCompoundClip(items, clip_info) if clip_info else tl.CreateCompoundClip(items)
+    if not result:
+        return {"error": "Failed to create compound clip"}
+    return {"success": True, "name": safe(lambda: result.GetName())}
+
+
+def action_create_fusion_clip(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    clip_refs = body.get("clips", [])
+    if not clip_refs:
+        return {"error": "clips array is required"}
+    items = _resolve_clip_refs(tl, clip_refs)
+    if not items:
+        return {"error": "No matching clips found"}
+    result = tl.CreateFusionClip(items)
+    if not result:
+        return {"error": "Failed to create Fusion clip"}
+    return {"success": True, "name": safe(lambda: result.GetName())}
+
+
+def action_export_timeline(body):
+    """Export timeline to AAF/EDL/FCPXML/OTIO etc."""
+    r, _, tl, err = _timeline()
+    if err:
+        return err
+    file_name = body.get("fileName", "")
+    export_type = body.get("exportType", "")
+    export_subtype = body.get("exportSubtype", "EXPORT_NONE")
+    if not file_name:
+        return {"error": "fileName is required"}
+    if not export_type:
+        return {"error": "exportType is required"}
+    type_map = {
+        "AAF": "EXPORT_AAF", "DRT": "EXPORT_DRT", "EDL": "EXPORT_EDL",
+        "FCP_7_XML": "EXPORT_FCP_7_XML",
+        "FCPXML_1_8": "EXPORT_FCPXML_1_8", "FCPXML_1_9": "EXPORT_FCPXML_1_9",
+        "FCPXML_1_10": "EXPORT_FCPXML_1_10",
+        "HDR_10_PROFILE_A": "EXPORT_HDR_10_PROFILE_A",
+        "HDR_10_PROFILE_B": "EXPORT_HDR_10_PROFILE_B",
+        "TEXT_CSV": "EXPORT_TEXT_CSV", "TEXT_TAB": "EXPORT_TEXT_TAB",
+        "DOLBY_VISION_VER_2_9": "EXPORT_DOLBY_VISION_VER_2_9",
+        "DOLBY_VISION_VER_4_0": "EXPORT_DOLBY_VISION_VER_4_0",
+        "DOLBY_VISION_VER_5_1": "EXPORT_DOLBY_VISION_VER_5_1",
+        "OTIO": "EXPORT_OTIO", "ALE": "EXPORT_ALE", "ALE_CDL": "EXPORT_ALE_CDL",
+    }
+    subtype_map = {
+        "EXPORT_NONE": "EXPORT_NONE", "EXPORT_AAF_NEW": "EXPORT_AAF_NEW",
+        "EXPORT_AAF_EXISTING": "EXPORT_AAF_EXISTING",
+        "EXPORT_CDL": "EXPORT_CDL", "EXPORT_SDL": "EXPORT_SDL",
+        "EXPORT_MISSING_CLIPS": "EXPORT_MISSING_CLIPS",
+    }
+    et_attr = type_map.get(export_type)
+    if not et_attr:
+        return {"error": "Unknown exportType '%s'. Valid: %s" % (export_type, ", ".join(type_map.keys()))}
+    es_attr = subtype_map.get(export_subtype, "EXPORT_NONE")
+    et = safe(lambda: getattr(r, et_attr))
+    es = safe(lambda: getattr(r, es_attr))
+    if et is None:
+        return {"error": "Resolve does not support export constant '%s'" % et_attr}
+    ok = tl.Export(file_name, et, es)
+    return {"success": bool(ok), "fileName": file_name, "exportType": export_type}
+
+
+# -- Gallery / Stills -------------------------------------------------------
+
+def action_set_current_album(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    gallery = safe(lambda: proj.GetGallery())
+    if not gallery:
+        return {"error": "Cannot access gallery"}
+    album, aerr = _get_album(gallery, body)
+    if aerr:
+        return aerr
+    ok = gallery.SetCurrentStillAlbum(album)
+    name = safe(lambda: gallery.GetAlbumName(album))
+    return {"success": bool(ok), "albumName": name}
+
+
+def action_create_gallery_album(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    gallery = safe(lambda: proj.GetGallery())
+    if not gallery:
+        return {"error": "Cannot access gallery"}
+    album_type = body.get("albumType", "still")
+    if album_type == "powergrade":
+        album = gallery.CreateGalleryPowerGradeAlbum()
+    else:
+        album = gallery.CreateGalleryStillAlbum()
+    if not album:
+        return {"error": "Failed to create %s album" % album_type}
+    name = body.get("name", "")
+    if name:
+        gallery.SetAlbumName(album, name)
+    final_name = safe(lambda: gallery.GetAlbumName(album))
+    return {"success": True, "albumName": final_name, "albumType": album_type}
+
+
+def action_grab_still(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    still = tl.GrabStill()
+    if not still:
+        return {"error": "Failed to grab still. Make sure you are on the Color page."}
+    return {"success": True}
+
+
+def action_grab_all_stills(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    source = int(body.get("stillFrameSource", 2))
+    stills = tl.GrabAllStills(source)
+    if not stills:
+        return {"error": "Failed to grab stills"}
+    return {"success": True, "count": len(stills)}
+
+
+def action_export_stills(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    gallery = safe(lambda: proj.GetGallery())
+    if not gallery:
+        return {"error": "Cannot access gallery"}
+    album, aerr = _get_album(gallery, body)
+    if aerr:
+        return aerr
+    folder_path = body.get("folderPath", "")
+    file_prefix = body.get("filePrefix", "still")
+    fmt = body.get("format", "png")
+    if not folder_path:
+        return {"error": "folderPath is required"}
+    stills = safe(lambda: album.GetStills()) or []
+    still_indices = body.get("stillIndices", [])
+    if still_indices:
+        selected = [stills[i - 1] for i in still_indices if 1 <= i <= len(stills)]
+    else:
+        selected = stills
+    if not selected:
+        return {"error": "No stills to export"}
+    ok = album.ExportStills(selected, folder_path, file_prefix, fmt)
+    return {"success": bool(ok), "exported": len(selected), "folderPath": folder_path}
+
+
+def action_import_stills(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    gallery = safe(lambda: proj.GetGallery())
+    if not gallery:
+        return {"error": "Cannot access gallery"}
+    album = safe(lambda: gallery.GetCurrentStillAlbum())
+    if not album:
+        return {"error": "No album selected"}
+    file_paths = body.get("filePaths", [])
+    if not file_paths:
+        return {"error": "filePaths array is required"}
+    ok = album.ImportStills(file_paths)
+    return {"success": bool(ok)}
+
+
+def action_delete_stills(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    gallery = safe(lambda: proj.GetGallery())
+    if not gallery:
+        return {"error": "Cannot access gallery"}
+    album, aerr = _get_album(gallery, body)
+    if aerr:
+        return aerr
+    stills = safe(lambda: album.GetStills()) or []
+    still_indices = body.get("stillIndices", [])
+    if not still_indices:
+        return {"error": "stillIndices array is required"}
+    selected = [stills[i - 1] for i in still_indices if 1 <= i <= len(stills)]
+    if not selected:
+        return {"error": "No stills found at given indices"}
+    ok = album.DeleteStills(selected)
+    return {"success": bool(ok), "deleted": len(selected)}
+
+
+def action_set_still_label(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    gallery = safe(lambda: proj.GetGallery())
+    if not gallery:
+        return {"error": "Cannot access gallery"}
+    album = safe(lambda: gallery.GetCurrentStillAlbum())
+    if not album:
+        return {"error": "No album selected"}
+    still_index = int(body.get("stillIndex", 0))
+    label = body.get("label", "")
+    stills = safe(lambda: album.GetStills()) or []
+    if still_index < 1 or still_index > len(stills):
+        return {"error": "stillIndex %d out of range (1-%d)" % (still_index, len(stills))}
+    ok = album.SetLabel(stills[still_index - 1], label)
+    return {"success": bool(ok), "label": label}
+
+
+# -- Color Grading / Node Graph / LUT / CDL --------------------------------
+
+def gather_node_graph(qs):
+    """Get the color node graph for a timeline item or the timeline itself."""
+    scope = qs.get("scope", ["clip"])[0]
+    if scope == "timeline":
+        _, _, tl, err = _timeline()
+        if err:
+            return err
+        graph = safe(lambda: tl.GetNodeGraph())
+        if not graph:
+            return {"error": "Cannot get timeline node graph"}
+    else:
+        item, err = _clip_at({
+            "trackType": qs.get("track_type", ["video"])[0],
+            "trackIndex": int(qs.get("track_index", ["1"])[0]),
+            "clipIndex": int(qs.get("clip_index", ["0"])[0]),
+        })
+        if err:
+            return err
+        layer = int(qs.get("layer_index", ["1"])[0])
+        graph = safe(lambda: item.GetNodeGraph(layer))
+        if not graph:
+            return {"error": "Cannot get clip node graph"}
+    num = safe(lambda: graph.GetNumNodes()) or 0
+    nodes = []
+    for i in range(1, num + 1):
+        nodes.append({
+            "index": i,
+            "label": safe(lambda i=i: graph.GetNodeLabel(i)) or "",
+            "lut": safe(lambda i=i: graph.GetLUT(i)) or "",
+            "tools": safe(lambda i=i: graph.GetToolsInNode(i)) or [],
+            "cacheMode": safe(lambda i=i: graph.GetNodeCacheMode(i)),
+        })
+    return {"nodeCount": num, "nodes": nodes}
+
+
+def action_set_lut(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    layer = int(body.get("layerIndex", 1))
+    graph = safe(lambda: item.GetNodeGraph(layer))
+    if not graph:
+        return {"error": "Cannot get node graph"}
+    node_index = int(body.get("nodeIndex", 1))
+    lut_path = body.get("lutPath", "")
+    if not lut_path:
+        return {"error": "lutPath is required"}
+    ok = graph.SetLUT(node_index, lut_path)
+    return {"success": bool(ok), "nodeIndex": node_index, "lutPath": lut_path}
+
+
+def action_get_lut(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    layer = int(body.get("layerIndex", 1))
+    graph = safe(lambda: item.GetNodeGraph(layer))
+    if not graph:
+        return {"error": "Cannot get node graph"}
+    node_index = int(body.get("nodeIndex", 1))
+    lut = safe(lambda: graph.GetLUT(node_index))
+    return {"nodeIndex": node_index, "lutPath": lut or ""}
+
+
+def action_set_node_enabled(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    layer = int(body.get("layerIndex", 1))
+    graph = safe(lambda: item.GetNodeGraph(layer))
+    if not graph:
+        return {"error": "Cannot get node graph"}
+    node_index = int(body.get("nodeIndex", 1))
+    enabled = bool(body.get("enabled", True))
+    ok = graph.SetNodeEnabled(node_index, enabled)
+    return {"success": bool(ok), "nodeIndex": node_index, "enabled": enabled}
+
+
+def action_apply_grade_from_drx(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    layer = int(body.get("layerIndex", 1))
+    graph = safe(lambda: item.GetNodeGraph(layer))
+    if not graph:
+        return {"error": "Cannot get node graph"}
+    path = body.get("drxPath", "")
+    grade_mode = int(body.get("gradeMode", 0))
+    if not path:
+        return {"error": "drxPath is required"}
+    ok = graph.ApplyGradeFromDRX(path, grade_mode)
+    return {"success": bool(ok), "drxPath": path, "gradeMode": grade_mode}
+
+
+def action_reset_all_grades(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    layer = int(body.get("layerIndex", 1))
+    graph = safe(lambda: item.GetNodeGraph(layer))
+    if not graph:
+        return {"error": "Cannot get node graph"}
+    ok = graph.ResetAllGrades()
+    return {"success": bool(ok)}
+
+
+def action_apply_arri_cdl_lut(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    layer = int(body.get("layerIndex", 1))
+    graph = safe(lambda: item.GetNodeGraph(layer))
+    if not graph:
+        return {"error": "Cannot get node graph"}
+    ok = graph.ApplyArriCdlLut()
+    return {"success": bool(ok)}
+
+
+def action_set_cdl(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    cdl_map = body.get("cdl", {})
+    if not cdl_map:
+        return {"error": "cdl dict is required with keys: NodeIndex, Slope, Offset, Power, Saturation"}
+    ok = item.SetCDL(cdl_map)
+    return {"success": bool(ok)}
+
+
+def action_export_lut(body):
+    r, _ = _resolve()
+    item, err = _clip_at(body)
+    if err:
+        return err
+    export_type_str = body.get("exportType", "33PTCUBE")
+    path = body.get("path", "")
+    if not path:
+        return {"error": "path is required"}
+    type_map = {
+        "17PTCUBE": "EXPORT_LUT_17PTCUBE",
+        "33PTCUBE": "EXPORT_LUT_33PTCUBE",
+        "65PTCUBE": "EXPORT_LUT_65PTCUBE",
+        "PANASONICVLUT": "EXPORT_LUT_PANASONICVLUT",
+    }
+    attr = type_map.get(export_type_str)
+    if not attr:
+        return {"error": "Unknown exportType. Valid: %s" % ", ".join(type_map.keys())}
+    et = safe(lambda: getattr(r, attr))
+    if et is None:
+        return {"error": "Resolve does not support %s" % attr}
+    ok = item.ExportLUT(et, path)
+    return {"success": bool(ok), "path": path}
+
+
+def action_copy_grades(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    source_ref = body.get("source", {})
+    target_refs = body.get("targets", [])
+    if not source_ref or not target_refs:
+        return {"error": "source and targets are required"}
+    source_item, serr = _clip_at(source_ref)
+    if serr:
+        return serr
+    target_items = _resolve_clip_refs(tl, target_refs)
+    if not target_items:
+        return {"error": "No matching target clips found"}
+    ok = source_item.CopyGrades(target_items)
+    return {"success": bool(ok), "copiedTo": len(target_items)}
+
+
+def action_reset_node_colors(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    ok = item.ResetAllNodeColors()
+    return {"success": bool(ok)}
+
+
+# -- Color Versions ---------------------------------------------------------
+
+def gather_color_versions(qs):
+    item, err = _clip_at({
+        "trackType": qs.get("track_type", ["video"])[0],
+        "trackIndex": int(qs.get("track_index", ["1"])[0]),
+        "clipIndex": int(qs.get("clip_index", ["0"])[0]),
+    })
+    if err:
+        return err
+    current = safe(lambda: item.GetCurrentVersion()) or {}
+    local_versions = safe(lambda: item.GetVersionNameList(0)) or []
+    remote_versions = safe(lambda: item.GetVersionNameList(1)) or []
+    return {
+        "clipName": safe(lambda: item.GetName()),
+        "currentVersion": current,
+        "localVersions": local_versions,
+        "remoteVersions": remote_versions,
+    }
+
+
+def action_add_color_version(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    name = body.get("versionName", "")
+    vtype = int(body.get("versionType", 0))
+    if not name:
+        return {"error": "versionName is required"}
+    ok = item.AddVersion(name, vtype)
+    return {"success": bool(ok), "versionName": name, "versionType": vtype}
+
+
+def action_load_color_version(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    name = body.get("versionName", "")
+    vtype = int(body.get("versionType", 0))
+    if not name:
+        return {"error": "versionName is required"}
+    ok = item.LoadVersionByName(name, vtype)
+    return {"success": bool(ok), "versionName": name}
+
+
+def action_delete_color_version(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    name = body.get("versionName", "")
+    vtype = int(body.get("versionType", 0))
+    if not name:
+        return {"error": "versionName is required"}
+    ok = item.DeleteVersionByName(name, vtype)
+    return {"success": bool(ok), "versionName": name}
+
+
+def action_rename_color_version(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    old_name = body.get("oldName", "")
+    new_name = body.get("newName", "")
+    vtype = int(body.get("versionType", 0))
+    if not old_name or not new_name:
+        return {"error": "oldName and newName are required"}
+    ok = item.RenameVersionByName(old_name, new_name, vtype)
+    return {"success": bool(ok)}
+
+
+# -- Color Groups -----------------------------------------------------------
+
+def gather_color_groups(qs):
+    _, proj, err = _project()
+    if err:
+        return err
+    groups = safe(lambda: proj.GetColorGroupsList()) or []
+    result = []
+    for i, g in enumerate(groups):
+        name = safe(lambda g=g: g.GetName())
+        result.append({"index": i + 1, "name": name})
+    return {"colorGroups": result}
+
+
+def action_add_color_group(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    name = body.get("groupName", "")
+    if not name:
+        return {"error": "groupName is required"}
+    group = proj.AddColorGroup(name)
+    if not group:
+        return {"error": "Failed to create color group '%s'" % name}
+    return {"success": True, "groupName": name}
+
+
+def action_delete_color_group(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    name = body.get("groupName", "")
+    if not name:
+        return {"error": "groupName is required"}
+    groups = safe(lambda: proj.GetColorGroupsList()) or []
+    target = None
+    for g in groups:
+        if safe(lambda g=g: g.GetName()) == name:
+            target = g
+            break
+    if not target:
+        return {"error": "Color group '%s' not found" % name}
+    ok = proj.DeleteColorGroup(target)
+    return {"success": bool(ok)}
+
+
+def action_assign_to_color_group(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    item, ierr = _clip_at(body)
+    if ierr:
+        return ierr
+    group_name = body.get("groupName", "")
+    if not group_name:
+        return {"error": "groupName is required"}
+    groups = safe(lambda: proj.GetColorGroupsList()) or []
+    target = None
+    for g in groups:
+        if safe(lambda g=g: g.GetName()) == group_name:
+            target = g
+            break
+    if not target:
+        return {"error": "Color group '%s' not found" % group_name}
+    ok = item.AssignToColorGroup(target)
+    return {"success": bool(ok), "groupName": group_name}
+
+
+def action_remove_from_color_group(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    ok = item.RemoveFromColorGroup()
+    return {"success": bool(ok)}
+
+
+# -- Fusion Composition Management ------------------------------------------
+
+def gather_fusion_comps(qs):
+    item, err = _clip_at({
+        "trackType": qs.get("track_type", ["video"])[0],
+        "trackIndex": int(qs.get("track_index", ["1"])[0]),
+        "clipIndex": int(qs.get("clip_index", ["0"])[0]),
+    })
+    if err:
+        return err
+    count = safe(lambda: item.GetFusionCompCount()) or 0
+    names = safe(lambda: item.GetFusionCompNameList()) or []
+    return {"clipName": safe(lambda: item.GetName()), "fusionCompCount": count, "fusionCompNames": names}
+
+
+def action_add_fusion_comp(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    comp = item.AddFusionComp()
+    if not comp:
+        return {"error": "Failed to add Fusion composition"}
+    return {"success": True}
+
+
+def action_import_fusion_comp(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    path = body.get("path", "")
+    if not path:
+        return {"error": "path is required (.comp file)"}
+    comp = item.ImportFusionComp(path)
+    if not comp:
+        return {"error": "Failed to import Fusion composition from '%s'" % path}
+    return {"success": True, "path": path}
+
+
+def action_export_fusion_comp(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    path = body.get("path", "")
+    comp_index = int(body.get("compIndex", 1))
+    if not path:
+        return {"error": "path is required"}
+    ok = item.ExportFusionComp(path, comp_index)
+    return {"success": bool(ok), "path": path, "compIndex": comp_index}
+
+
+def action_delete_fusion_comp(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    comp_name = body.get("compName", "")
+    if not comp_name:
+        return {"error": "compName is required"}
+    ok = item.DeleteFusionCompByName(comp_name)
+    return {"success": bool(ok), "compName": comp_name}
+
+
+def action_load_fusion_comp(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    comp_name = body.get("compName", "")
+    if not comp_name:
+        return {"error": "compName is required"}
+    comp = item.LoadFusionCompByName(comp_name)
+    if not comp:
+        return {"error": "Failed to load Fusion composition '%s'" % comp_name}
+    return {"success": True, "compName": comp_name}
+
+
+def action_rename_fusion_comp(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    old_name = body.get("oldName", "")
+    new_name = body.get("newName", "")
+    if not old_name or not new_name:
+        return {"error": "oldName and newName are required"}
+    ok = item.RenameFusionCompByName(old_name, new_name)
+    return {"success": bool(ok)}
+
+
+# -- Smart Features (Studio) ------------------------------------------------
+
+def action_create_magic_mask(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    mode = body.get("mode", "F")
+    ok = item.CreateMagicMask(mode)
+    return {"success": bool(ok), "mode": mode}
+
+
+def action_regenerate_magic_mask(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    ok = item.RegenerateMagicMask()
+    return {"success": bool(ok)}
+
+
+def action_stabilize(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    ok = item.Stabilize()
+    return {"success": bool(ok)}
+
+
+def action_smart_reframe(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    ok = item.SmartReframe()
+    return {"success": bool(ok)}
+
+
+# -- Audio / Fairlight -------------------------------------------------------
+
+def gather_fairlight_presets(qs):
+    r, err = _resolve()
+    if err:
+        return err
+    presets = safe(lambda: r.GetFairlightPresets()) or []
+    return {"presets": presets}
+
+
+def action_apply_fairlight_preset(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    name = body.get("presetName", "")
+    if not name:
+        return {"error": "presetName is required"}
+    ok = proj.ApplyFairlightPresetToCurrentTimeline(name)
+    return {"success": bool(ok), "presetName": name}
+
+
+def action_insert_audio_at_playhead(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    media_path = body.get("mediaPath", "")
+    start_offset = int(body.get("startOffsetInSamples", 0))
+    duration = int(body.get("durationInSamples", 0))
+    if not media_path:
+        return {"error": "mediaPath is required"}
+    ok = proj.InsertAudioToCurrentTrackAtPlayhead(media_path, start_offset, duration)
+    return {"success": bool(ok)}
+
+
+def gather_voice_isolation_state(qs):
+    scope = qs.get("scope", ["clip"])[0]
+    if scope == "track":
+        _, _, tl, err = _timeline()
+        if err:
+            return err
+        ti = int(qs.get("track_index", ["1"])[0])
+        state = safe(lambda: tl.GetVoiceIsolationState(ti))
+        return {"scope": "track", "trackIndex": ti, "state": state or {}}
+    else:
+        item, err = _clip_at({
+            "trackType": qs.get("track_type", ["video"])[0],
+            "trackIndex": int(qs.get("track_index", ["1"])[0]),
+            "clipIndex": int(qs.get("clip_index", ["0"])[0]),
+        })
+        if err:
+            return err
+        state = safe(lambda: item.GetVoiceIsolationState())
+        return {"scope": "clip", "clipName": safe(lambda: item.GetName()), "state": state or {}}
+
+
+def action_set_voice_isolation_state(body):
+    scope = body.get("scope", "clip")
+    state = body.get("state", {})
+    if not state:
+        return {"error": "state dict required: {isEnabled: bool, amount: int (0-100)}"}
+    if scope == "track":
+        _, _, tl, err = _timeline()
+        if err:
+            return err
+        ti = int(body.get("trackIndex", 1))
+        ok = tl.SetVoiceIsolationState(ti, state)
+        return {"success": bool(ok), "scope": "track", "trackIndex": ti}
+    else:
+        item, err = _clip_at(body)
+        if err:
+            return err
+        ok = item.SetVoiceIsolationState(state)
+        return {"success": bool(ok), "scope": "clip"}
+
+
+# -- Take Selector -----------------------------------------------------------
+
+def gather_takes(qs):
+    item, err = _clip_at({
+        "trackType": qs.get("track_type", ["video"])[0],
+        "trackIndex": int(qs.get("track_index", ["1"])[0]),
+        "clipIndex": int(qs.get("clip_index", ["0"])[0]),
+    })
+    if err:
+        return err
+    count = safe(lambda: item.GetTakesCount()) or 0
+    selected = safe(lambda: item.GetSelectedTakeIndex()) or 0
+    takes = []
+    for i in range(1, count + 1):
+        info = safe(lambda i=i: item.GetTakeByIndex(i)) or {}
+        takes.append({"index": i, "startFrame": info.get("startFrame"), "endFrame": info.get("endFrame")})
+    return {"clipName": safe(lambda: item.GetName()), "takesCount": count, "selectedTakeIndex": selected, "takes": takes}
+
+
+def action_add_take(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    item, ierr = _clip_at(body)
+    if ierr:
+        return ierr
+    mp_clip_name = body.get("mediaPoolClipName", "")
+    if not mp_clip_name:
+        return {"error": "mediaPoolClipName is required"}
+    mp_item = _find_pool_item(pool, mp_clip_name)
+    if not mp_item:
+        return {"error": "Clip '%s' not found in media pool" % mp_clip_name}
+    start = body.get("startFrame")
+    end = body.get("endFrame")
+    if start is not None and end is not None:
+        ok = item.AddTake(mp_item, int(start), int(end))
+    else:
+        ok = item.AddTake(mp_item)
+    return {"success": bool(ok)}
+
+
+def action_select_take(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    idx = int(body.get("takeIndex", 1))
+    ok = item.SelectTakeByIndex(idx)
+    return {"success": bool(ok), "takeIndex": idx}
+
+
+def action_delete_take(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    idx = int(body.get("takeIndex", 1))
+    ok = item.DeleteTakeByIndex(idx)
+    return {"success": bool(ok), "takeIndex": idx}
+
+
+def action_finalize_take(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    ok = item.FinalizeTake()
+    return {"success": bool(ok)}
+
+
+# -- Proxy / Cache / Misc Clip Ops ------------------------------------------
+
+def action_link_proxy_media(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_name = body.get("clipName", "")
+    proxy_path = body.get("proxyMediaFilePath", "")
+    if not clip_name or not proxy_path:
+        return {"error": "clipName and proxyMediaFilePath are required"}
+    item = _find_pool_item(pool, clip_name)
+    if not item:
+        return {"error": "Clip '%s' not found" % clip_name}
+    ok = item.LinkProxyMedia(proxy_path)
+    return {"success": bool(ok)}
+
+
+def action_unlink_proxy_media(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_name = body.get("clipName", "")
+    if not clip_name:
+        return {"error": "clipName is required"}
+    item = _find_pool_item(pool, clip_name)
+    if not item:
+        return {"error": "Clip '%s' not found" % clip_name}
+    ok = item.UnlinkProxyMedia()
+    return {"success": bool(ok)}
+
+
+def action_replace_clip(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    pool = proj.GetMediaPool()
+    if not pool:
+        return {"error": "No media pool"}
+    clip_name = body.get("clipName", "")
+    file_path = body.get("filePath", "")
+    if not clip_name or not file_path:
+        return {"error": "clipName and filePath are required"}
+    item = _find_pool_item(pool, clip_name)
+    if not item:
+        return {"error": "Clip '%s' not found" % clip_name}
+    ok = item.ReplaceClip(file_path)
+    return {"success": bool(ok)}
+
+
+def action_set_clip_cache(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    cache_type = body.get("cacheType", "color")
+    cache_value = int(body.get("cacheValue", 1))
+    if cache_type == "fusion":
+        ok = item.SetFusionOutputCache(cache_value)
+    else:
+        ok = item.SetColorOutputCache(cache_value)
+    return {"success": bool(ok), "cacheType": cache_type, "cacheValue": cache_value}
+
+
+def action_update_sidecar(body):
+    item, err = _clip_at(body)
+    if err:
+        return err
+    ok = item.UpdateSidecar()
+    return {"success": bool(ok)}
+
+
+def gather_linked_items(qs):
+    item, err = _clip_at({
+        "trackType": qs.get("track_type", ["video"])[0],
+        "trackIndex": int(qs.get("track_index", ["1"])[0]),
+        "clipIndex": int(qs.get("clip_index", ["0"])[0]),
+    })
+    if err:
+        return err
+    linked = safe(lambda: item.GetLinkedItems()) or []
+    result = []
+    for li in linked:
+        ti = safe(lambda li=li: li.GetTrackTypeAndIndex()) or []
+        result.append({
+            "name": safe(lambda li=li: li.GetName()),
+            "trackType": ti[0] if len(ti) > 0 else None,
+            "trackIndex": ti[1] if len(ti) > 1 else None,
+        })
+    return {"clipName": safe(lambda: item.GetName()), "linkedItems": result}
+
+
+def action_set_timeline_mark_in_out(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    mark_in = body.get("markIn")
+    mark_out = body.get("markOut")
+    mark_type = body.get("type", "all")
+    if mark_in is not None and mark_out is not None:
+        ok = tl.SetMarkInOut(int(mark_in), int(mark_out), mark_type)
+        return {"success": bool(ok)}
+    return {"error": "markIn and markOut are required"}
+
+
+def action_clear_timeline_mark_in_out(body):
+    _, _, tl, err = _timeline()
+    if err:
+        return err
+    mark_type = body.get("type", "all")
+    ok = tl.ClearMarkInOut(mark_type)
+    return {"success": bool(ok)}
+
+
+# -- Project Manager ---------------------------------------------------------
+
+def gather_project_list(qs):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    if not pm:
+        return {"error": "No project manager"}
+    projects = safe(lambda: pm.GetProjectListInCurrentFolder()) or []
+    folders = safe(lambda: pm.GetFolderListInCurrentFolder()) or []
+    current_folder = safe(lambda: pm.GetCurrentFolder()) or ""
+    current_db = safe(lambda: pm.GetCurrentDatabase()) or {}
+    return {
+        "currentFolder": current_folder,
+        "currentDatabase": current_db,
+        "projects": projects,
+        "folders": folders,
+    }
+
+
+def gather_database_list(qs):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    if not pm:
+        return {"error": "No project manager"}
+    dbs = safe(lambda: pm.GetDatabaseList()) or []
+    current = safe(lambda: pm.GetCurrentDatabase()) or {}
+    return {"currentDatabase": current, "databases": dbs}
+
+
+def action_load_project(body):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    if not pm:
+        return {"error": "No project manager"}
+    name = body.get("projectName", "")
+    if not name:
+        return {"error": "projectName is required"}
+    proj = pm.LoadProject(name)
+    if not proj:
+        return {"error": "Failed to load project '%s'" % name}
+    return {"success": True, "projectName": safe(lambda: proj.GetName())}
+
+
+def action_create_project(body):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    if not pm:
+        return {"error": "No project manager"}
+    name = body.get("projectName", "")
+    if not name:
+        return {"error": "projectName is required"}
+    proj = pm.CreateProject(name)
+    if not proj:
+        return {"error": "Failed to create project '%s' (name may already exist)" % name}
+    return {"success": True, "projectName": safe(lambda: proj.GetName())}
+
+
+def action_delete_project(body):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    name = body.get("projectName", "")
+    if not name:
+        return {"error": "projectName is required"}
+    ok = pm.DeleteProject(name)
+    return {"success": bool(ok)}
+
+
+def action_archive_project(body):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    name = body.get("projectName", "")
+    file_path = body.get("filePath", "")
+    if not name or not file_path:
+        return {"error": "projectName and filePath are required"}
+    src_media = body.get("archiveSrcMedia", True)
+    render_cache = body.get("archiveRenderCache", True)
+    proxy_media = body.get("archiveProxyMedia", False)
+    ok = pm.ArchiveProject(name, file_path, src_media, render_cache, proxy_media)
+    return {"success": bool(ok)}
+
+
+def action_export_project(body):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    name = body.get("projectName", "")
+    file_path = body.get("filePath", "")
+    if not name or not file_path:
+        return {"error": "projectName and filePath are required"}
+    with_stills = body.get("withStillsAndLUTs", True)
+    ok = pm.ExportProject(name, file_path, with_stills)
+    return {"success": bool(ok)}
+
+
+def action_import_project(body):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    file_path = body.get("filePath", "")
+    if not file_path:
+        return {"error": "filePath is required"}
+    project_name = body.get("projectName")
+    ok = pm.ImportProject(file_path, project_name) if project_name else pm.ImportProject(file_path)
+    return {"success": bool(ok)}
+
+
+def action_navigate_project_folder(body):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    action = body.get("action", "")
+    folder_name = body.get("folderName", "")
+    if action == "root":
+        ok = pm.GotoRootFolder()
+    elif action == "parent":
+        ok = pm.GotoParentFolder()
+    elif action == "open" and folder_name:
+        ok = pm.OpenFolder(folder_name)
+    elif action == "create" and folder_name:
+        ok = pm.CreateFolder(folder_name)
+    elif action == "delete" and folder_name:
+        ok = pm.DeleteFolder(folder_name)
+    else:
+        return {"error": "action required: 'root', 'parent', 'open', 'create', or 'delete'"}
+    return {"success": bool(ok), "action": action}
+
+
+def action_set_database(body):
+    r, err = _resolve()
+    if err:
+        return err
+    pm = r.GetProjectManager()
+    db_info = body.get("dbInfo", {})
+    if not db_info:
+        return {"error": "dbInfo dict required with keys DbType, DbName, optional IpAddress"}
+    ok = pm.SetCurrentDatabase(db_info)
+    return {"success": bool(ok)}
+
+
+# -- Resolve-level / Presets / MediaStorage ----------------------------------
+
+def action_layout_preset(body):
+    r, err = _resolve()
+    if err:
+        return err
+    action = body.get("action", "")
+    name = body.get("presetName", "")
+    path = body.get("presetFilePath", "")
+    if action == "load" and name:
+        return {"success": bool(r.LoadLayoutPreset(name))}
+    elif action == "save" and name:
+        return {"success": bool(r.SaveLayoutPreset(name))}
+    elif action == "update" and name:
+        return {"success": bool(r.UpdateLayoutPreset(name))}
+    elif action == "delete" and name:
+        return {"success": bool(r.DeleteLayoutPreset(name))}
+    elif action == "export" and name and path:
+        return {"success": bool(r.ExportLayoutPreset(name, path))}
+    elif action == "import" and path:
+        return {"success": bool(r.ImportLayoutPreset(path, name))}
+    return {"error": "action required: 'load', 'save', 'update', 'delete', 'export', 'import'"}
+
+
+def action_render_preset(body):
+    r, err = _resolve()
+    if err:
+        return err
+    _, proj, perr = _project()
+    if perr:
+        return perr
+    action = body.get("action", "")
+    name = body.get("presetName", "")
+    path = body.get("presetPath", "")
+    if action == "import" and path:
+        return {"success": bool(r.ImportRenderPreset(path))}
+    elif action == "export" and name and path:
+        return {"success": bool(r.ExportRenderPreset(name, path))}
+    elif action == "load" and name:
+        return {"success": bool(proj.LoadRenderPreset(name))}
+    elif action == "saveAs" and name:
+        return {"success": bool(proj.SaveAsNewRenderPreset(name))}
+    elif action == "delete" and name:
+        return {"success": bool(proj.DeleteRenderPreset(name))}
+    elif action == "list":
+        return {"presets": safe(lambda: proj.GetRenderPresetList()) or []}
+    return {"error": "action required: 'load', 'saveAs', 'delete', 'list', 'import', 'export'"}
+
+
+def action_burnin_preset(body):
+    r, err = _resolve()
+    if err:
+        return err
+    action = body.get("action", "")
+    name = body.get("presetName", "")
+    path = body.get("presetPath", "")
+    if action == "import" and path:
+        return {"success": bool(r.ImportBurnInPreset(path))}
+    elif action == "export" and name and path:
+        return {"success": bool(r.ExportBurnInPreset(name, path))}
+    elif action == "load" and name:
+        _, proj, perr = _project()
+        if perr:
+            return perr
+        return {"success": bool(proj.LoadBurnInPreset(name))}
+    return {"error": "action required: 'load', 'import', 'export'"}
+
+
+def action_set_keyframe_mode(body):
+    r, err = _resolve()
+    if err:
+        return err
+    mode = int(body.get("mode", 0))
+    ok = r.SetKeyframeMode(mode)
+    return {"success": bool(ok), "mode": mode}
+
+
+def gather_keyframe_mode(qs):
+    r, err = _resolve()
+    if err:
+        return err
+    mode = safe(lambda: r.GetKeyframeMode())
+    labels = {0: "All", 1: "Color", 2: "Sizing"}
+    return {"keyframeMode": mode, "label": labels.get(mode, "Unknown")}
+
+
+def action_quick_export(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    preset_name = body.get("presetName", "")
+    if not preset_name:
+        presets = safe(lambda: proj.GetQuickExportRenderPresets()) or []
+        return {"error": "presetName is required", "availablePresets": presets}
+    params = body.get("params", {})
+    result = proj.RenderWithQuickExport(preset_name, params)
+    return {"result": result}
+
+
+def gather_quick_export_presets(qs):
+    _, proj, err = _project()
+    if err:
+        return err
+    presets = safe(lambda: proj.GetQuickExportRenderPresets()) or []
+    return {"presets": presets}
+
+
+def action_set_render_mode(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    mode = int(body.get("renderMode", 0))
+    ok = proj.SetCurrentRenderMode(mode)
+    return {"success": bool(ok), "renderMode": mode}
+
+
+def action_get_render_job_status(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    job_id = body.get("jobId", "")
+    if not job_id:
+        return {"error": "jobId is required"}
+    status = safe(lambda: proj.GetRenderJobStatus(job_id))
+    return {"jobId": job_id, "status": status or {}}
+
+
+def action_refresh_lut_list(body):
+    _, proj, err = _project()
+    if err:
+        return err
+    ok = proj.RefreshLUTList()
+    return {"success": bool(ok)}
+
+
+def gather_render_resolutions(qs):
+    _, proj, err = _project()
+    if err:
+        return err
+    fmt = qs.get("format", [""])[0]
+    codec = qs.get("codec", [""])[0]
+    if fmt and codec:
+        res = safe(lambda: proj.GetRenderResolutions(fmt, codec)) or []
+    else:
+        res = safe(lambda: proj.GetRenderResolutions()) or []
+    return {"resolutions": res}
+
+
+def gather_media_storage(qs):
+    r, err = _resolve()
+    if err:
+        return err
+    ms = r.GetMediaStorage()
+    if not ms:
+        return {"error": "No media storage"}
+    volumes = safe(lambda: ms.GetMountedVolumeList()) or []
+    folder_path = qs.get("folder_path", [""])[0]
+    result = {"volumes": volumes}
+    if folder_path:
+        subfolders = safe(lambda: ms.GetSubFolderList(folder_path)) or []
+        files = safe(lambda: ms.GetFileList(folder_path)) or []
+        result["subfolders"] = subfolders
+        result["files"] = files
+    return result
+
+
+def action_reveal_in_storage(body):
+    r, err = _resolve()
+    if err:
+        return err
+    ms = r.GetMediaStorage()
+    if not ms:
+        return {"error": "No media storage"}
+    path = body.get("path", "")
+    if not path:
+        return {"error": "path is required"}
+    ok = ms.RevealInStorage(path)
+    return {"success": bool(ok)}
+
+
+# ---------------------------------------------------------------------------
+# Route tables
+# ---------------------------------------------------------------------------
+
+GET_ROUTES = {
+    "/status":                  lambda qs: gather_status(),
+    "/project":                 lambda qs: gather_project(),
+    "/page":                    lambda qs: gather_page(),
+    "/timeline":                lambda qs: gather_timeline(),
+    "/timeline/clips":          lambda qs: gather_clips(
+                                    qs.get("track_type", ["video"])[0],
+                                    int(qs.get("track_index", ["1"])[0])),
+    "/timeline/markers":        lambda qs: gather_markers(),
+    "/timeline/current-item":   lambda qs: gather_current_video_item(qs),
+    "/timeline/thumbnail":      lambda qs: gather_clip_thumbnail(qs),
+    "/render":                  lambda qs: gather_render(),
+    "/render/resolutions":      gather_render_resolutions,
+    "/render/quick-export-presets": gather_quick_export_presets,
+    "/mediapool":               lambda qs: gather_media_pool(),
+    "/mediapool/structure":     gather_media_pool_structure,
+    "/mediapool/clip/metadata": gather_clip_metadata,
+    "/mediapool/clip/info":     gather_clip_info,
+    "/clip/markers":            gather_clip_markers,
+    "/clip/flags":              gather_clip_flags,
+    "/clip/node-graph":         gather_node_graph,
+    "/clip/color-versions":     gather_color_versions,
+    "/clip/fusion-comps":       gather_fusion_comps,
+    "/clip/takes":              gather_takes,
+    "/clip/linked-items":       gather_linked_items,
+    "/color/groups":            gather_color_groups,
+    "/audio/voice-isolation":   gather_voice_isolation_state,
+    "/fairlight/presets":       gather_fairlight_presets,
+    "/gallery/albums":          gather_gallery_albums,
+    "/gallery/stills":          gather_album_stills,
+    "/keyframe-mode":           gather_keyframe_mode,
+    "/projects":                gather_project_list,
+    "/databases":               gather_database_list,
+    "/media-storage":           gather_media_storage,
+}
+
+def action_shutdown(body):
+    """Gracefully stop the HTTP server (used for hot-reload)."""
+    import threading
+    threading.Thread(target=lambda: server.shutdown(), daemon=True).start()
+    return {"success": True, "message": "Shutting down"}
+
+
+POST_ROUTES = {
+    "/bridge/shutdown":             action_shutdown,
+    "/page":                        action_open_page,
+    "/playhead":                    action_set_timecode,
+    # markers
+    "/marker/add":                  action_add_marker,
+    "/marker/delete":               action_delete_marker,
+    # timeline
+    "/timeline/switch":             action_switch_timeline,
+    "/timeline/create":             action_create_timeline,
+    "/timeline/rename":             action_rename_timeline,
+    "/timeline/duplicate":          action_duplicate_timeline,
+    "/timeline/export":             action_export_timeline,
+    "/timeline/mark-in-out":        action_set_timeline_mark_in_out,
+    "/timeline/clear-mark-in-out":  action_clear_timeline_mark_in_out,
+    # timeline clip manipulation
+    "/timeline/clips/delete":       action_delete_timeline_clips,
+    "/timeline/clips/link":         action_link_timeline_clips,
+    "/timeline/compound-clip":      action_create_compound_clip,
+    "/timeline/fusion-clip":        action_create_fusion_clip,
+    # tracks
+    "/track/add":                   action_add_track,
+    "/track/delete":                action_delete_track,
+    "/track/enable":                action_set_track_enable,
+    "/track/lock":                  action_set_track_lock,
+    "/track/rename":                action_set_track_name,
+    # media
+    "/media/import":                action_import_media,
+    "/media/import-storage":        action_import_media_from_storage,
+    "/media/append":                action_append_to_timeline,
+    "/media/insert":                action_insert_to_timeline,
+    # media pool deep access
+    "/mediapool/navigate":          action_navigate_media_pool,
+    "/mediapool/folder/create":     action_create_media_pool_folder,
+    "/mediapool/clip/metadata":     action_set_clip_metadata,
+    "/mediapool/clip/property":     action_set_pool_clip_property,
+    "/mediapool/clips/delete":      action_delete_media_pool_clips,
+    "/mediapool/clips/move":        action_move_media_pool_clips,
+    "/mediapool/clips/relink":      action_relink_media_pool_clips,
+    "/mediapool/clips/unlink":      action_unlink_media_pool_clips,
+    "/mediapool/audio-sync":        action_auto_sync_audio,
+    "/mediapool/timeline/import":   action_import_timeline_from_file,
+    "/mediapool/metadata/export":   action_export_metadata,
+    # clip operations
+    "/clip/color":                  action_set_clip_color,
+    "/clip/enabled":                action_set_clip_enabled,
+    "/clip/properties":             action_set_clip_properties,
+    "/clip/marker/add":             action_add_clip_marker,
+    "/clip/marker/delete":          action_delete_clip_marker,
+    "/clip/flag/add":               action_add_clip_flag,
+    "/clip/flag/clear":             action_clear_clip_flags,
+    "/clip/cache":                  action_set_clip_cache,
+    "/clip/sidecar":                action_update_sidecar,
+    # color grading / LUT / CDL
+    "/color/set-lut":               action_set_lut,
+    "/color/get-lut":               action_get_lut,
+    "/color/set-node-enabled":      action_set_node_enabled,
+    "/color/apply-drx":             action_apply_grade_from_drx,
+    "/color/reset-grades":          action_reset_all_grades,
+    "/color/apply-arri-cdl":        action_apply_arri_cdl_lut,
+    "/color/set-cdl":               action_set_cdl,
+    "/color/export-lut":            action_export_lut,
+    "/color/copy-grades":           action_copy_grades,
+    "/color/reset-node-colors":     action_reset_node_colors,
+    # color versions
+    "/color/version/add":           action_add_color_version,
+    "/color/version/load":          action_load_color_version,
+    "/color/version/delete":        action_delete_color_version,
+    "/color/version/rename":        action_rename_color_version,
+    # color groups
+    "/color/group/add":             action_add_color_group,
+    "/color/group/delete":          action_delete_color_group,
+    "/color/group/assign":          action_assign_to_color_group,
+    "/color/group/remove":          action_remove_from_color_group,
+    # fusion comps per-clip
+    "/clip/fusion/add":             action_add_fusion_comp,
+    "/clip/fusion/import":          action_import_fusion_comp,
+    "/clip/fusion/export":          action_export_fusion_comp,
+    "/clip/fusion/delete":          action_delete_fusion_comp,
+    "/clip/fusion/load":            action_load_fusion_comp,
+    "/clip/fusion/rename":          action_rename_fusion_comp,
+    # smart features
+    "/clip/magic-mask":             action_create_magic_mask,
+    "/clip/magic-mask/regenerate":  action_regenerate_magic_mask,
+    "/clip/stabilize":              action_stabilize,
+    "/clip/smart-reframe":          action_smart_reframe,
+    # audio / fairlight
+    "/audio/fairlight-preset":      action_apply_fairlight_preset,
+    "/audio/insert-at-playhead":    action_insert_audio_at_playhead,
+    "/audio/voice-isolation":       action_set_voice_isolation_state,
+    # take selector
+    "/clip/take/add":               action_add_take,
+    "/clip/take/select":            action_select_take,
+    "/clip/take/delete":            action_delete_take,
+    "/clip/take/finalize":          action_finalize_take,
+    # proxy
+    "/mediapool/proxy/link":        action_link_proxy_media,
+    "/mediapool/proxy/unlink":      action_unlink_proxy_media,
+    "/mediapool/clip/replace":      action_replace_clip,
+    # titles & generators
+    "/title/insert":                action_insert_title,
+    "/generator/insert":            action_insert_generator,
+    "/fusion/insert":               action_insert_fusion_comp,
+    # render
+    "/render/settings":             action_set_render_settings,
+    "/render/format":               action_set_render_format,
+    "/render/formats":              action_get_render_formats,
+    "/render/job/add":              action_add_render_job,
+    "/render/job/status":           action_get_render_job_status,
+    "/render/start":                action_start_rendering,
+    "/render/stop":                 action_stop_rendering,
+    "/render/job/delete":           action_delete_render_job,
+    "/render/mode":                 action_set_render_mode,
+    "/render/quick-export":         action_quick_export,
+    "/render/refresh-luts":         action_refresh_lut_list,
+    "/render/preset":               action_render_preset,
+    # project
+    "/project/save":                action_save_project,
+    "/project/setting":             action_set_project_setting,
+    "/timeline/setting":            action_set_timeline_setting,
+    "/project/export-frame":        action_export_frame,
+    "/timeline/subtitles":          action_create_subtitles,
+    "/timeline/scene-cuts":         action_detect_scene_cuts,
+    # project manager
+    "/projects/load":               action_load_project,
+    "/projects/create":             action_create_project,
+    "/projects/delete":             action_delete_project,
+    "/projects/archive":            action_archive_project,
+    "/projects/export":             action_export_project,
+    "/projects/import":             action_import_project,
+    "/projects/folder":             action_navigate_project_folder,
+    "/projects/database":           action_set_database,
+    # resolve-level presets
+    "/resolve/layout-preset":       action_layout_preset,
+    "/resolve/burnin-preset":       action_burnin_preset,
+    "/resolve/keyframe-mode":       action_set_keyframe_mode,
+    # media storage
+    "/media-storage/reveal":        action_reveal_in_storage,
+    # gallery / stills
+    "/gallery/album/set":           action_set_current_album,
+    "/gallery/album/create":        action_create_gallery_album,
+    "/gallery/grab":                action_grab_still,
+    "/gallery/grab-all":            action_grab_all_stills,
+    "/gallery/stills/export":       action_export_stills,
+    "/gallery/stills/import":       action_import_stills,
+    "/gallery/stills/delete":       action_delete_stills,
+    "/gallery/stills/label":        action_set_still_label,
+}
+
+
+# ---------------------------------------------------------------------------
+# HTTP handler
+# ---------------------------------------------------------------------------
+
+class BridgeHandler(BaseHTTPRequestHandler):
+    def log_message(self, fmt, *args):
+        pass
+
+    def _respond(self, data):
+        body = json.dumps(data, default=str).encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _error(self, code, msg):
+        body = json.dumps({"error": msg}).encode("utf-8")
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        parsed = urlparse(self.path)
+        path = parsed.path.rstrip("/")
+        qs = parse_qs(parsed.query)
+        handler = GET_ROUTES.get(path)
+        if handler:
+            try:
+                self._respond(handler(qs))
+            except Exception:
+                self._error(500, traceback.format_exc())
+        else:
+            self._error(404, "Unknown GET endpoint: %s" % path)
+
+    def do_POST(self):
+        parsed = urlparse(self.path)
+        path = parsed.path.rstrip("/")
+        content_len = int(self.headers.get("Content-Length", 0))
+        raw = self.rfile.read(content_len) if content_len else b"{}"
+        try:
+            body = json.loads(raw)
+        except Exception:
+            self._error(400, "Invalid JSON body")
+            return
+        handler = POST_ROUTES.get(path)
+        if handler:
+            try:
+                self._respond(handler(body))
+            except Exception:
+                self._error(500, traceback.format_exc())
+        else:
+            self._error(404, "Unknown POST endpoint: %s" % path)
+
+    def do_OPTIONS(self):
+        self.send_response(204)
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.end_headers()
+
+
+# ---------------------------------------------------------------------------
+# Start server (with hot-reload: shut down any previous instance first)
+# ---------------------------------------------------------------------------
+import time
+try:
+    import urllib.request
+    req = urllib.request.Request(
+        "http://%s:%d/bridge/shutdown" % (HOST, PORT),
+        data=b"{}",
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    urllib.request.urlopen(req, timeout=2)
+    print("[CursorBridge] Sent shutdown to previous instance, waiting...")
+    time.sleep(1.5)
+except Exception:
+    pass
+
+print("[CursorBridge] Starting HTTP server on http://%s:%d ..." % (HOST, PORT))
+server = None
+try:
+    server = HTTPServer((HOST, PORT), BridgeHandler)
+    print("[CursorBridge] Bridge is running (read + write).  %d GET routes, %d POST routes." % (
+        len(GET_ROUTES), len(POST_ROUTES)))
+    print("[CursorBridge] To stop: close DaVinci Resolve or re-run this script.")
+    server.serve_forever()
+except OSError as e:
+    if "Address already in use" in str(e) or "Only one usage" in str(e) or getattr(e, "errno", 0) == 10048:
+        print("[CursorBridge] Port %d already in use — could not replace old bridge." % PORT)
+        print("[CursorBridge] Restart DaVinci Resolve and try again.")
+    else:
+        print("[CursorBridge] ERROR: %s" % e)
+except KeyboardInterrupt:
+    print("[CursorBridge] Shutting down.")
+except Exception as e:
+    print("[CursorBridge] ERROR: %s" % e)