@motionharness/bridge-davinci 0.0.22 → 0.0.25

package/dist/resolve_rpc.py

@@ -2,8 +2,8 @@
 """One JSON request over stdin. Only documented Resolve scripting APIs are used.
 
 Only explicit targets and owned render IDs can be modified. Resolve's database
-is never edited directly. Unsupported effects exposed by public readback block
-automated replacement; Edit-page OFX omitted from OTIO cannot be fully enumerated.
+is never edited directly. Updating a bound media-pool item leaves its timeline
+instances and effects under Resolve ownership.
 """
 import hashlib
 import importlib
@@ -29,8 +29,6 @@ import instance_runtime as instances
 import legacy_conversion as legacy
 from runtime_io import atomic_json, file_digest
 
-# Frame boundaries were read back on this exact build; do not extrapolate to unknown builds.
-VALIDATED_BUILD = "21.1.0.14"
 SUPPORTED_INSPECTOR_EFFECTS = {
     "Transform", "Source Transform", "Immersive Transform", "Cropping", "Source Cropping",
     "Source Looks", "Dynamic Zoom", "Composite", "Lens Correction", "Retime and Scaling",
@@ -39,10 +37,6 @@ SUPPORTED_INSPECTOR_EFFECTS = {
 ORIGINAL_PLAYBACK = {"perfProxyMediaMode": "0", "perfOptimisedMediaOn": "0", "perfRenderCacheMode": "none"}
 
 
-def validated_host(resolve):
-    return resolve.GetVersionString() == VALIDATED_BUILD and sys.platform == "darwin" and platform.machine() == "arm64"
-
-
 class BridgeFailure(Exception):
     def __init__(self, code, message, **details):
         super().__init__(message)
@@ -88,8 +82,7 @@ def project_for(resolve, requested=None, render_proof=None):
     # GetCurrentDatabase returns None throughout some renders on 21.1.0.14.
     # Monitoring/cancelling an already-started job may use its previously
     # verified project + complete queue fingerprint; starting still requires DB.
-    if (render_proof and requested and not manager.GetCurrentDatabase()
-            and validated_host(resolve) and project.IsRenderingInProgress()):
+    if render_proof and requested and not manager.GetCurrentDatabase() and project.IsRenderingInProgress():
         require(project.GetUniqueId() == requested["projectId"], "VERSION_CONFLICT", "运行中的任务已不属于原工程。")
         job = render_job(project, render_proof["jobId"])
         require(render_proof.get("expectedJobFingerprint") and fingerprint(job) == render_proof["expectedJobFingerprint"],
@@ -127,91 +120,36 @@ def media_for(project, media_id):
 
 
 def ofx_source_target(resolve, params):
-    """Prove an OFX host source maps to one media item, without UI selection.
+    """Match the actual input file to its registered media-pool identity.
 
-    Two complete pool reads detect changes visible during discovery. This is a
-    read-only observation, not a lock; callers must revalidate before mutation.
-    File-less timeline/compound entries are excluded only when GetTimeline()
-    returns an identifiable timeline. Other unclassifiable entries fail closed.
+    Read file paths once to reject ambiguous imports. Only the target's bridge
+    metadata matters; unrelated subtitles, generators and metadata are ignored.
     """
-    def identifier(value):
-        return isinstance(value, str) and bool(value.strip()) and "\0" not in value
-
-    def canonical_path(value, code):
-        require(identifier(value) and os.path.isabs(value), code, "侧栏源路径必须是非空绝对路径。")
-        return os.path.realpath(value)
-
     requested = params.get("scope")
+    media_id, raw_path = params.get("mediaPoolItemId"), params.get("path")
+    valid = lambda value: isinstance(value, str) and bool(value.strip()) and "\0" not in value
     require(isinstance(requested, dict) and set(requested) == {"databaseId", "projectId"}
-            and all(identifier(value) for value in requested.values()),
-            "INVALID_ARGUMENT", "侧栏入口需要明确的数据库和工程作用域。")
-    media_id = params.get("mediaPoolItemId")
-    require(identifier(media_id), "INVALID_ARGUMENT", "侧栏入口需要明确的素材池对象 ID。")
-    path = canonical_path(params.get("path"), "INVALID_ARGUMENT")
-
-    def read_media(media):
-        identity = media.GetUniqueId()
-        require(identifier(identity), "CAPABILITY_UNAVAILABLE", "素材池对象缺少可验证的 ID。")
-        properties = media.GetClipProperty()
-        require(isinstance(properties, dict) and "File Path" in properties,
-                "CAPABILITY_UNAVAILABLE", "无法完整读取素材池文件路径，不能证明侧栏源唯一。")
-        raw_path = properties["File Path"]
-        if raw_path == "":
-            timeline = media.GetTimeline()
-            timeline_id = timeline.GetUniqueId() if timeline else None
-            require(identifier(timeline_id), "CAPABILITY_UNAVAILABLE",
-                    "素材池包含无法识别来源的无文件素材，不能证明侧栏源唯一。")
-            return identity, {"timelineId": timeline_id}
-        source_path = canonical_path(raw_path, "CAPABILITY_UNAVAILABLE")
-        metadata = media.GetThirdPartyMetadata()
-        require(isinstance(metadata, dict) and all(isinstance(key, str) and isinstance(value, str)
-                for key, value in metadata.items()), "CAPABILITY_UNAVAILABLE", "无法完整读取素材关联元数据。")
-        # Copy values so a host response or test double cannot mutate our proof.
-        return identity, {"path": source_path, "metadata": dict(metadata)}
-
-    def scan(project):
-        pool = project.GetMediaPool()
-        root = pool.GetRootFolder() if pool else None
-        require(root is not None, "CAPABILITY_UNAVAILABLE", "无法读取素材池根目录。")
-        folders, media_states, objects = {}, {}, {}
-        pending = [root]
-        while pending:
-            folder = pending.pop()
-            folder_id = folder.GetUniqueId()
-            require(identifier(folder_id) and folder_id not in folders,
-                    "CAPABILITY_UNAVAILABLE", "素材池目录 ID 缺失、重复或存在循环。")
-            clips, children = folder.GetClipList(), folder.GetSubFolderList()
-            require(isinstance(clips, list) and isinstance(children, list),
-                    "CAPABILITY_UNAVAILABLE", "素材池目录读取不完整，不能证明侧栏源唯一。")
-            folders[folder_id] = []
-            for media in clips:
-                identity, state = read_media(media)
-                require(identity not in media_states, "CAPABILITY_UNAVAILABLE", "素材池对象 ID 重复，不能证明侧栏源唯一。")
-                media_states[identity], objects[identity] = state, media
-                folders[folder_id].append(identity)
-            folders[folder_id].sort()
-            pending.extend(children)
-        matches = [identity for identity, state in media_states.items() if state.get("path") == path]
-        require(len(matches) == 1 and matches[0] == media_id, "VERSION_CONFLICT",
-                "侧栏源路径没有对应唯一且匹配的素材池对象；请从固定菜单管理片段。")
-        return {"folders": folders, "media": media_states}, objects[media_id]
-
-    try:
-        project, scope = project_for(resolve, requested)
-        first, _ = scan(project)
-        project_for(resolve, requested)
-        second, target = scan(project)
-        require(first == second, "VERSION_CONFLICT", "素材池在侧栏身份核对期间发生变化。")
-        identity, final_state = read_media(target)
-        require(identity == media_id and final_state == second["media"][media_id],
-                "VERSION_CONFLICT", "素材路径或关联元数据在侧栏身份核对期间发生变化。")
-        project_for(resolve, requested)
-        return {"scope": scope, "mediaPoolItemId": media_id, "path": path,
-                "metadata": final_state["metadata"], "unique": True}
-    except BridgeFailure:
-        raise
-    except Exception as error:
-        raise BridgeFailure("CAPABILITY_UNAVAILABLE", "无法完整核对侧栏素材身份。", diagnostic=str(error))
+            and all(valid(value) for value in requested.values()) and valid(media_id),
+            "INVALID_ARGUMENT", "侧栏入口需要明确的数据库、工程和素材池对象 ID。")
+    require(valid(raw_path) and os.path.isabs(raw_path), "INVALID_ARGUMENT", "侧栏源路径必须是非空绝对路径。")
+    path = os.path.realpath(raw_path)
+    project, scope = project_for(resolve, requested)
+    matches = []
+    for media in all_media(project.GetMediaPool().GetRootFolder()):
+        try:
+            properties = media.GetClipProperty() or {}
+            source_path = properties.get("File Path")
+        except Exception:
+            require(media.GetUniqueId() != media_id, "CAPABILITY_UNAVAILABLE", "无法读取目标素材的文件路径。")
+            continue
+        if valid(source_path) and os.path.isabs(source_path) and os.path.realpath(source_path) == path:
+            matches.append(media)
+    require(len(matches) == 1 and matches[0].GetUniqueId() == media_id,
+            "VERSION_CONFLICT", "侧栏源路径没有对应唯一且匹配的素材池对象；请从固定菜单管理片段。")
+    result = media_identity(project, scope, matches[0])
+    require(os.path.realpath(result["path"]) == path, "VERSION_CONFLICT", "目标素材已被重新链接。")
+    project_for(resolve, requested)
+    return {**result, "path": path, "unique": True}
 
 
 def fps_value(value):
@@ -234,13 +172,13 @@ def sample_end_time(start, timeline_frames, source_fps, timeline_fps, source_fra
     return min(source_frames / source_rate, start / source_rate + (timeline_frames - 1) / timeline_rate + 1 / source_rate)
 
 
-def item_snapshot(item, timeline_id, track, validated=False, media_index=None, timeline_fps=None):
+def item_snapshot(item, timeline_id, track, media_index=None, timeline_fps=None):
     media = item.GetMediaPoolItem()
-    intrinsic_entry = intrinsic.read_entry(item, media_index or {}) if validated and not media else None
+    intrinsic_entry = intrinsic.read_entry(item, media_index or {}) if not media else None
     if intrinsic_entry:
         media = media_index[intrinsic_entry['identity']['mediaPoolItemId']]
-    unsupported = [] if validated else ["host-build-and-frame-conventions-unverified"]
-    kind = item.GetType() if validated else "unknown"
+    unsupported = []
+    kind = item.GetType()
     if not media and kind != "transition":
         unsupported.append("no-plain-media-source")
     fusion_count = item.GetFusionCompCount() if media else 0
@@ -254,7 +192,7 @@ def item_snapshot(item, timeline_id, track, validated=False, media_index=None, t
         unsupported.append("take-selector-or-multicam")
     props = media.GetClipProperty() if media else {}
     speed, properties, fades = None, None, None
-    if validated and media:
+    if media:
         if media.GetTimeline():
             unsupported.append("nested-or-compound-timeline")
         if kind != "video":
@@ -313,12 +251,12 @@ def item_snapshot(item, timeline_id, track, validated=False, media_index=None, t
         "sourceIn": source_in, "sourceOut": source_out,
         "mediaPoolItemId": media.GetUniqueId() if media else None, "unsupported": unsupported,
         "kind": kind, "speed": speed, "properties": properties, "fades": fades,
-        "enabled": item.GetClipEnabled() if validated and media else None,
-        "sourceStartTime": item.GetSourceStartTime() if validated and media else None,
-        "sourceEndTime": item.GetSourceEndTime() if validated and media else None,
-        "leftOffset": item.GetLeftOffset() if validated and media else None,
-        "rightOffset": item.GetRightOffset() if validated and media else None,
-        "markers": item.GetMarkers() if validated and media else None,
+        "enabled": item.GetClipEnabled() if media else None,
+        "sourceStartTime": item.GetSourceStartTime() if media else None,
+        "sourceEndTime": item.GetSourceEndTime() if media else None,
+        "leftOffset": item.GetLeftOffset() if media else None,
+        "rightOffset": item.GetRightOffset() if media else None,
+        "markers": item.GetMarkers() if media else None,
         **({"inspectorEntry": entry} if entry else {}),
         **({"intrinsicEntry": intrinsic_entry} if intrinsic_entry else {}),
     }
@@ -575,9 +513,6 @@ def grade_evidence(resolve, timeline, native_items, intrinsic_ids=None):
 
 @contextmanager
 def timeline_context(resolve, timeline):
-    if resolve is None or not validated_host(resolve):
-        yield
-        return
     project = resolve.GetProjectManager().GetCurrentProject()
     previous = project.GetCurrentTimeline()
     try:
@@ -593,42 +528,41 @@ def timeline_context(resolve, timeline):
             await_timeline(project, previous, resolve=resolve)
 
 
-def scan_timeline(timeline, resolve=None, grade_media_id=None):
+def scan_timeline(timeline, resolve, grade_media_id=None):
     with timeline_context(resolve, timeline):
         return scan_current_timeline(timeline, resolve, grade_media_id)
 
 
-def scan_current_timeline(timeline, resolve=None, grade_media_id=None):
-    validated = resolve is not None and validated_host(resolve)
+def scan_current_timeline(timeline, resolve, grade_media_id=None):
     items, native_items, paths = [], [], {}
     media_index = None
     for track in range(1, timeline.GetTrackCount("video") + 1):
         native = timeline.GetItemListInTrack("video", track) or []
         native_items.extend(native)
         for item in native:
-            if validated and not item.GetMediaPoolItem() and item.GetFusionCompCount() > 0 and media_index is None:
+            if not item.GetMediaPoolItem() and item.GetFusionCompCount() > 0 and media_index is None:
                 project = resolve.GetProjectManager().GetCurrentProject()
                 media_index = {m.GetUniqueId(): m for m in all_media(project.GetMediaPool().GetRootFolder())}
-            snapshot = item_snapshot(item, timeline.GetUniqueId(), track, validated, media_index, fps_value(timeline.GetSetting("timelineFrameRate")) if validated else None)
-            snapshot.update(trackEnabled=timeline.GetIsTrackEnabled("video", track) if validated else None,
-                            trackLocked=timeline.GetIsTrackLocked("video", track) if validated else None)
+            snapshot = item_snapshot(item, timeline.GetUniqueId(), track, media_index, fps_value(timeline.GetSetting("timelineFrameRate")))
+            snapshot.update(trackEnabled=timeline.GetIsTrackEnabled("video", track),
+                            trackLocked=timeline.GetIsTrackLocked("video", track))
             items.append(snapshot)
-            if validated and item.GetMediaPoolItem():
+            if item.GetMediaPoolItem():
                 paths[snapshot["id"]] = item.GetMediaPoolItem().GetClipProperty("File Path") or ""
             elif snapshot.get('intrinsicEntry'):
                 paths[snapshot['id']] = media_index[snapshot['mediaPoolItemId']].GetClipProperty('File Path') or ''
-    evidence = otio_evidence(resolve, timeline) if validated and items else {"complete": not items, "reasons": [], "hash": None}
-    if validated and items and evidence.get("clipCount") != sum(1 for item in items if item["kind"] == "video" and item["mediaPoolItemId"]):
+    evidence = otio_evidence(resolve, timeline) if items else {"complete": True, "reasons": [], "hash": None}
+    if items and evidence.get("clipCount") != sum(1 for item in items if item["kind"] == "video" and item["mediaPoolItemId"]):
         evidence["reasons"] = sorted(set(evidence["reasons"] + ["otio-item-coverage-mismatch"]))
         evidence["globalReasons"] = sorted(set(evidence.get("globalReasons", evidence["reasons"]) + ["otio-item-coverage-mismatch"]))
-    scoped_reasons = otio_item_reasons(evidence, items, paths, timeline.GetStartFrame(), fps_value(timeline.GetSetting("timelineFrameRate"))) if validated and items else {}
+    scoped_reasons = otio_item_reasons(evidence, items, paths, timeline.GetStartFrame(), fps_value(timeline.GetSetting("timelineFrameRate"))) if items else {}
     # A media readback retains grades only for that media's uses. Keep every
     # native item and OTIO check for indirect references, but avoid exporting
     # unrelated LUTs. Whole-timeline snapshots still inspect all grades.
     grade_items = [native for native, item in zip(native_items, items)
                    if grade_media_id is None or item["mediaPoolItemId"] == grade_media_id]
-    grades = grade_evidence(resolve, timeline, grade_items, {i['id'] for i in items if i.get('intrinsicEntry')}) if validated and grade_items and any(i["kind"] == "video" for i in items) else {}
-    entry_scope = scope_for(resolve.GetProjectManager(), resolve.GetProjectManager().GetCurrentProject()) if validated and any(i.get("inspectorEntry") or i.get('intrinsicEntry') for i in items) else None
+    grades = grade_evidence(resolve, timeline, grade_items, {i['id'] for i in items if i.get('intrinsicEntry')}) if grade_items and any(i["kind"] == "video" for i in items) else {}
+    entry_scope = scope_for(resolve.GetProjectManager(), resolve.GetProjectManager().GetCurrentProject()) if any(i.get("inspectorEntry") or i.get('intrinsicEntry') for i in items) else None
     for item in items:
         item["otioHash"] = evidence["hash"]
         item["unsupported"] = sorted(set(item["unsupported"] + scoped_reasons.get(item["id"], evidence["reasons"])))
@@ -640,10 +574,9 @@ def scan_current_timeline(timeline, resolve=None, grade_media_id=None):
             owner = entry["identity"]
             if any(owner[key] != value for key, value in entry_scope.items()):
                 item["unsupported"] = sorted(set(item["unsupported"] + ["inspector-identity-conflict"]))
-    if validated:
-        graph = timeline.GetNodeGraph()
-        if graph and any(graph.GetToolsInNode(index) for index in range(1, graph.GetNumNodes() + 1)):
-            for item in items: item["unsupported"] = sorted(set(item["unsupported"] + ["timeline-grade-unverified"]))
+    graph = timeline.GetNodeGraph()
+    if graph and any(graph.GetToolsInNode(index) for index in range(1, graph.GetNumNodes() + 1)):
+        for item in items: item["unsupported"] = sorted(set(item["unsupported"] + ["timeline-grade-unverified"]))
     return items
 
 
@@ -685,8 +618,28 @@ def publish_playback(path, publication, before_path):
             os.unlink(pending)
 
 
-def media_snapshot(project, scope, media, resolve=None):
-    properties = media.GetClipProperty() or {}
+def media_identity(project, scope, media):
+    """The original media owns the binding, independently of its timeline uses."""
+    try:
+        properties = media.GetClipProperty() or {}
+        metadata = media.GetThirdPartyMetadata() or {}
+    except Exception as error:
+        raise BridgeFailure("CAPABILITY_UNAVAILABLE", "无法读取目标原素材的身份或关联。", diagnostic=str(error))
+    require(isinstance(properties, dict) and isinstance(metadata, dict)
+            and all(isinstance(key, str) and isinstance(value, str) for key, value in metadata.items()),
+            "CAPABILITY_UNAVAILABLE", "无法读取目标素材的身份或关联。")
+    data = {"scope": scope, "projectName": project.GetName(), "mediaPoolItemId": media.GetUniqueId(),
+            "path": properties.get("File Path", ""), "metadata": metadata,
+            "uses": [], "usageScanComplete": False,
+            "clipProperties": {key: properties.get(key) for key in ("FPS", "Frames", "Resolution", "Audio Ch", "Proxy Media Path", "Input Color Space", "Input Gamma", "Data Level", "Alpha mode", "PAR", "Field Dominance", "Clip Name")}}
+    data["fingerprint"] = fingerprint({"scope": scope, "mediaPoolItemId": data["mediaPoolItemId"], "path": data["path"],
+        "bridgeMetadata": metadata.get("motionharness.bridge"),
+        "properties": {key: value for key, value in data["clipProperties"].items() if key != "Clip Name"}})
+    return data
+
+
+def media_snapshot(project, scope, media, resolve):
+    data = media_identity(project, scope, media)
     media_id = media.GetUniqueId()
     uses = []
     complete = True
@@ -697,23 +650,20 @@ def media_snapshot(project, scope, media, resolve=None):
         items = scan_timeline(timeline, resolve, grade_media_id=media_id)
         uses.extend(i for i in items if i["mediaPoolItemId"] == media_id)
         # A nested timeline could reference this media indirectly.
-        if any(any(reason in i["unsupported"] for reason in ("nested-or-compound-timeline", "no-plain-media-source", "nested-or-unknown-otio-item", "nested-media-reference", "otio-inspection-unavailable", "otio-item-coverage-mismatch", "host-build-and-frame-conventions-unverified")) for i in items):
+        if any(any(reason in i["unsupported"] for reason in ("nested-or-compound-timeline", "no-plain-media-source", "nested-or-unknown-otio-item", "nested-media-reference", "otio-inspection-unavailable", "otio-item-coverage-mismatch")) for i in items):
             complete = False
-    settings = project.GetSettings() if resolve and validated_host(resolve) else {}
-    data = {"scope": scope, "projectName": project.GetName(), "mediaPoolItemId": media_id, "path": properties.get("File Path", ""),
-            "metadata": media.GetThirdPartyMetadata() or {}, "uses": uses, "usageScanComplete": complete,
-            "clipProperties": {key: properties.get(key) for key in ("FPS", "Frames", "Resolution", "Audio Ch", "Proxy Media Path", "Input Color Space", "Input Gamma", "Data Level", "Alpha mode", "PAR", "Field Dominance", "Clip Name")},
-            "playbackPolicy": {key: settings.get(key) for key in ("perfProxyMediaMode", "perfOptimisedMediaOn", "perfRenderCacheMode")}}
-    data["fingerprint"] = fingerprint({"properties": properties, **data})
+    settings = project.GetSettings()
+    data.update({"uses": uses, "usageScanComplete": complete,
+                 "playbackPolicy": {key: settings.get(key) for key in ("perfProxyMediaMode", "perfOptimisedMediaOn", "perfRenderCacheMode")}})
     return data
 
 
-def timeline_snapshot(project, scope, timeline, resolve=None):
+def timeline_snapshot(project, scope, timeline, resolve):
     with timeline_context(resolve, timeline):
         return current_timeline_snapshot(project, scope, timeline, resolve)
 
 
-def current_timeline_snapshot(project, scope, timeline, resolve=None):
+def current_timeline_snapshot(project, scope, timeline, resolve):
     items = scan_timeline(timeline, resolve)
     sources = []
     # Rebuild once per snapshot, not once per source. Do not cache across calls:
@@ -729,8 +679,8 @@ def current_timeline_snapshot(project, scope, timeline, resolve=None):
         props = media.GetClipProperty() or {}
         sources.append({"mediaPoolItemId": media_id, "properties": {key: props.get(key) for key in ("File Path", "FPS", "Frames", "Resolution", "Input Color Space", "Input Gamma", "Data Level", "Proxy Media Path")},
                         "bridgeMetadata": (media.GetThirdPartyMetadata() or {}).get("motionharness.bridge")})
-    settings = project.GetSettings() if resolve and validated_host(resolve) else {}
-    data = {"scope": scope, "timelineId": timeline.GetUniqueId(), "name": timeline.GetName(), "validatedHost": bool(resolve and validated_host(resolve)),
+    settings = project.GetSettings()
+    data = {"scope": scope, "timelineId": timeline.GetUniqueId(), "name": timeline.GetName(),
             "fps": fps_value(timeline.GetSetting("timelineFrameRate")), "startFrame": timeline.GetStartFrame(),
             "resolution": {"width": int(timeline.GetSetting("timelineResolutionWidth")), "height": int(timeline.GetSetting("timelineResolutionHeight"))},
             "endFrame": timeline.GetEndFrame(), "items": items, "sources": sources,
@@ -828,7 +778,6 @@ def seek_timecode(project, timeline, requested, timeout=3.0, resolve=None):
 
 
 def preview_frame(resolve, project, scope, params, before=None):
-    require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该平台与构建的画面捕获尚未验证。")
     require_active_project(resolve, project)
     require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "Resolve 正在导出。")
     timeline = timeline_for(project, params["timelineId"])
@@ -885,7 +834,7 @@ def playback_policy(project):
 
 
 def render_preset_evidence(resolve, project):
-    name = "Hotion Harness Bridge delivery check " + str(uuid.uuid4())
+    name = "MotionHarness Bridge delivery check " + str(uuid.uuid4())
     require(project.SaveAsNewRenderPreset(name), "CAPABILITY_UNAVAILABLE", "无法核对导出预设的缓存策略。")
     try:
         with tempfile.TemporaryDirectory(prefix="mh-bridge-preset-") as directory:
@@ -899,7 +848,6 @@ def render_preset_evidence(resolve, project):
 
 
 def create_render(resolve, project, scope, params):
-    require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该构建尚未验证指定任务导出。")
     require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "Resolve 已有输出任务在运行。")
     timeline = timeline_for(project, params["timelineId"])
     expected = params["expectedTimelineFingerprint"]
@@ -910,7 +858,7 @@ def create_render(resolve, project, scope, params):
     previous = project.GetCurrentTimeline()
     before_jobs = project.GetRenderJobList() or []
     require(not any(os.path.realpath(job.get("TargetDir", "")) == os.path.realpath(os.path.dirname(path)) and job.get("OutputFilename") == os.path.basename(path) for job in before_jobs), "TARGET_OCCUPIED", "输出位置已被其他队列项占用。")
-    backup = "Hotion Harness Bridge restore " + str(uuid.uuid4())
+    backup = "MotionHarness Bridge restore " + str(uuid.uuid4())
     require(project.SaveAsNewRenderPreset(backup), "CAPABILITY_UNAVAILABLE", "无法保存原有导出配置，未修改设置。")
     job_id = None
     try:
@@ -958,7 +906,6 @@ def create_render(resolve, project, scope, params):
 
 
 def start_render(resolve, project, scope, params):
-    require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该构建尚未验证指定任务导出。")
     require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "Resolve 正在执行其他渲染；未启动队列。")
     job = render_job(project, params["jobId"])
     require(params.get("expectedJobFingerprint") and fingerprint(job) == params["expectedJobFingerprint"], "VERSION_CONFLICT", "队列任务的输出设置已改变或没有核对记录，未启动。")
@@ -985,7 +932,6 @@ def start_render(resolve, project, scope, params):
 
 
 def finish_render(resolve, project, params):
-    require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该构建尚未验证输出恢复。")
     render_job(project, params["jobId"])
     require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "仍有渲染运行，保留原始画面模式直至可核对的终态。")
     expected, actual = params["playbackPolicy"], playback_policy(project)
@@ -997,7 +943,7 @@ def finish_render(resolve, project, params):
 
 
 def export_references(resolve, project, scope, params):
-    require(validated_host(resolve) and not project.IsRenderingInProgress(), "RESOLVE_BUSY", "输出后画面核对需要已完成渲染的目标工程。")
+    require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "输出后画面核对需要已完成渲染的目标工程。")
     timeline = timeline_for(project, params["timelineId"])
     before = timeline_snapshot(project, scope, timeline, resolve)
     require(before["fingerprint"] == params["expectedTimelineFingerprint"], "VERSION_CONFLICT", "输出后的时间线已改变，不能生成原回执的参考画面。")
@@ -1024,7 +970,6 @@ def export_references(resolve, project, scope, params):
 
 
 def preview_original(resolve, project, scope, params):
-    require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该构建尚未验证原始媒体合成检查。")
     require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "不能在导出期间改变合成画面检查策略。")
     timeline = timeline_for(project, params["timelineId"])
     before = timeline_snapshot(project, scope, timeline, resolve)
@@ -1046,8 +991,6 @@ def preview_original(resolve, project, scope, params):
 
 
 def selection_snapshot(resolve, plain_media_only=False):
-    require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该构建尚未验证时间线选择读取。")
-
     def plain_item(item):
         media = item.GetMediaPoolItem()
         require(media is not None and media is not False, "CAPABILITY_UNAVAILABLE", "请选择有直接视频源的普通片段；生成器入口暂不支持此操作。")
@@ -1131,8 +1074,7 @@ def entry_target(resolve, project, scope, params):
         source = ofx_source_target(resolve, {"scope": scope, "mediaPoolItemId": selection.get("mediaPoolItemId"), "path": selection["path"]})
     if not selection.get("timelineId") and not selection.get("itemId"):
         require(source is not None, "INVALID_REQUEST", "素材级入口需要源视频路径。")
-        media = media_for(project, selection.get("mediaPoolItemId"))
-        return {**source, "projectName": project.GetName(), "name": media.GetName()}
+        return {**source, "name": source["clipProperties"].get("Clip Name") or ""}
     timeline = timeline_for(project, selection.get("timelineId"))
     found = [item for track in range(1, timeline.GetTrackCount("video") + 1)
              for item in timeline.GetItemListInTrack("video", track) or []
@@ -1162,7 +1104,7 @@ def inspector_operation(resolve, params):
     # A composition imported through the API is not an Edit-page Fusion effect.
     # Keep the graph experiment separate from the product's Inspector entry.
     require(params.get("remove") or params.get("compositionOnly") is True, "CAPABILITY_UNAVAILABLE",
-            "ImportFusionComp 不能创建 Edit 检查器效果，请通过原生特效库应用 Hotion Harness Bridge 模板。")
+            "ImportFusionComp 不能创建 Edit 检查器效果，请通过原生特效库应用 MotionHarness Bridge 模板。")
     identity = params["identity"]
     require(identity.get("schemaVersion") == 1, "INVALID_REQUEST", "检查器入口身份版本无效。")
     selected = selection_snapshot(resolve)
@@ -1197,7 +1139,7 @@ def inspector_operation(resolve, params):
     before = timeline_snapshot(project, scope, timeline, resolve)
     targets = [value for value in before["items"] if value["id"] == item.GetUniqueId()]
     require(len(targets) == 1 and not targets[0]["unsupported"] and not targets[0].get("trackLocked"),
-            "UNSUPPORTED_TIMELINE_ITEM", "实验入口只接受完整读回通过、未锁定的普通 Hotion Harness 片段。")
+            "UNSUPPORTED_TIMELINE_ITEM", "实验入口只接受完整读回通过、未锁定的普通 MotionHarness 片段。")
     with open(params["compositionPath"], "rb") as stream:
         data = stream.read()
     require(hashlib.sha256(data).hexdigest() == params["compositionSha256"] and data.startswith(b"-- MH Resolve Bridge inspector v1\n"),
@@ -1238,6 +1180,8 @@ def inspector_operation(resolve, params):
 
 
 def dispatch(resolve, operation, params):
+    # Resolve version and process architecture are diagnostic information only.
+    # Operations use the host APIs directly and report actual failures.
     if operation == "ofx_source_target":
         return ofx_source_target(resolve, params)
     if operation == "selection":
@@ -1272,22 +1216,19 @@ def dispatch(resolve, operation, params):
                 "scope": scope_for(manager, project) if project else None,
                 "timelines": [{"id": t.GetUniqueId(), "name": t.GetName()} for t in timelines(project)] if project else [],
                 "adapter": "documented-python-scripting", "officialMcp": "not-tested-by-scripting",
-                "replacement": "stable-playback-file-with-native-speed-and-otio-check" if validated_host(resolve) else "host-build-unverified",
-                "frameConvention": "half-open" if validated_host(resolve) else "unverified",
-                "profile": {"platform": sys.platform, "architecture": platform.machine(), "basicBridgeValidated": validated_host(resolve)},
+                "replacement": "stable-playback-file-with-media-identity",
+                "frameConvention": "half-open",
+                "profile": {"platform": sys.platform, "architecture": platform.machine()},
                 "timelineReadback": "top-level-video; native speed/properties/fades and conservative OTIO structure check"}
     proof = params if operation in ("render_status", "cancel_render") else None
     project, scope = project_for(resolve, params.get("scope"), proof)
     if operation == "entry_target":
-        require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该 Resolve 平台与构建尚未验证所选片段管理。")
         return entry_target(resolve, project, scope, params)
     if operation in ("legacy_preview", "legacy_convert", "legacy_check"):
-        require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该 Resolve 平台与构建尚未验证旧生成器结构转换。")
         require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "Resolve 正在导出。")
         action = {"legacy_preview": legacy.preview, "legacy_convert": legacy.convert, "legacy_check": legacy.check}[operation]
         return action(resolve, project, scope, params, globals())
     if operation == "duplicate_instance":
-        require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该 Resolve 平台与构建尚未验证单实例独立副本。")
         require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "Resolve 正在导出。")
         return instances.duplicate_instance(resolve, project, scope, params, globals())
     if operation == "timeline":
@@ -1332,8 +1273,6 @@ def dispatch(resolve, operation, params):
         require(len(found) <= 1, "RECOVERY_CONFLICT", "多个媒体对象拥有同一绑定身份，未自动选择。")
         return media_snapshot(project, scope, found[0], resolve) if found else None
     if operation in ("render_status", "cancel_render"):
-        if operation == "cancel_render":
-            require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该构建尚未验证指定任务取消。")
         render_job(project, params["jobId"])
         status = project.GetRenderJobStatus(params["jobId"])
         if operation == "cancel_render" and status.get("JobStatus") == "Rendering":
@@ -1344,25 +1283,18 @@ def dispatch(resolve, operation, params):
         return status
     if operation == "media_identity":
         media = media_for(project, params["mediaPoolItemId"])
-        properties = media.GetClipProperty() or {}
-        result = {"scope": scope, "projectName": project.GetName(), "mediaPoolItemId": media.GetUniqueId(),
-                  "path": properties.get("File Path", ""), "metadata": media.GetThirdPartyMetadata() or {},
-                  "clipProperties": {key: properties.get(key) for key in ("Proxy Media Path", "Clip Name")},
-                  "validatedHost": validated_host(resolve)}
+        result = media_identity(project, scope, media)
         require_active_project(resolve, project)
         return result
     if operation in ("media", "bind", "replace"):
         media = media_for(project, params["mediaPoolItemId"])
-        before = media_snapshot(project, scope, media, resolve)
         if operation == "media":
-            return before
+            return media_snapshot(project, scope, media, resolve)
+        before = media_identity(project, scope, media)
         require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "Resolve 正在导出，桥接没有修改媒体。")
-        require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该 Resolve 平台与构建尚未验证自动修改的帧边界。")
-        require(before["fingerprint"] == params["expectedFingerprint"], "VERSION_CONFLICT", "Resolve 媒体或使用位置已变化。")
+        require(before["fingerprint"] == params["expectedFingerprint"], "VERSION_CONFLICT", "Resolve 原素材的身份、关联或媒体规格已变化。")
         if operation == "replace":
             repair = params.get("offlineRepair")
-            allowed = {"offline-media-reference"} if repair else set()
-            require(before["usageScanComplete"] and not any(set(i["unsupported"]) - allowed for i in before["uses"]), "UNSUPPORTED_TIMELINE_ITEM", "已剪片段包含不能完整核对的处理，未重连新版本。")
             path = os.path.realpath(params["filePath"])
             publication = params.get("publication")
             require(publication or os.path.isfile(path), "ARTIFACT_MISSING", "新产物不存在。")
@@ -1372,22 +1304,21 @@ def dispatch(resolve, operation, params):
                         "RECOVERY_CONFLICT", "离线搬迁修复只允许原绑定、原产物身份和已记录的旧路径。")
                 require(file_digest(publication["sourcePath"] if publication else path) == repair["sha256"],
                         "ARTIFACT_CHANGED", "搬迁媒体与记录摘要不同。")
-            policy = before["playbackPolicy"]
-            require(str(policy.get("perfProxyMediaMode")) in ("0", "1", "2") and str(policy.get("perfOptimisedMediaOn")) in ("0", "1")
-                    and policy.get("perfRenderCacheMode") in ("none", "smart", "user"),
-                    "PLAYBACK_POLICY_UNVERIFIED", "原生代理、优化媒体或缓存设置无法完整读回，未修改工程设置。", policy=policy)
             require(not before["clipProperties"].get("Proxy Media Path"), "PROXY_UNSUPPORTED", "当前替换路径尚未验证已关联代理。")
             require(os.path.basename(path) == os.path.basename(before["path"]), "BASENAME_CONFLICT", "安全重连要求版本目录中的文件名保持一致；未修改现有素材。")
             if publication:
                 require_active_project(resolve, project)
+                require(media_identity(project, scope, media)["fingerprint"] == before["fingerprint"],
+                        "VERSION_CONFLICT", "发布前原素材的身份或关联已改变。")
                 # Require the still-current metadata; no selection or effect-stored ID is consulted.
                 old_link = json.loads(before["metadata"].get("motionharness.bridge") or "{}")
                 new_link = json.loads(params["metadata"].get("motionharness.bridge") or "{}")
                 require(not old_link or all(old_link.get(k) == new_link.get(k) for k in ("schemaVersion", "bindingId", "sourceId")),
                         "BINDING_CONFLICT", "素材的关联身份已经改变。")
-                if old_link and os.path.realpath(before["path"]) == path:
-                    ofx_source_target(resolve, {"scope": scope, "mediaPoolItemId": media.GetUniqueId(), "path": path})
                 publish_playback(path, publication, before["path"])
+            require_active_project(resolve, project)
+            require(media_identity(project, scope, media)["fingerprint"] == before["fingerprint"],
+                    "APPLY_OUTCOME_UNKNOWN" if publication else "VERSION_CONFLICT", "重连前原素材的身份或关联已改变。")
             require(project.GetMediaPool().RelinkClips([media], os.path.dirname(path)), "APPLY_OUTCOME_UNKNOWN", "Resolve 未确认重连版本目录，需读回核对后处理。")
             # Clip interpretation belongs to the existing cut. Relinking may
             # re-read container defaults; preserve the user's native settings.
@@ -1400,27 +1331,15 @@ def dispatch(resolve, operation, params):
             require(all(readback.get(key) == before["clipProperties"].get(key) for key in ("Alpha mode", "Input Color Space", "Input Gamma", "Data Level", "PAR", "Field Dominance", "Clip Name") if key in before["clipProperties"]),
                     "APPLY_OUTCOME_UNKNOWN", "媒体解释读回与替换前不同，需核对原生状态。")
         set_metadata(media, {**before["metadata"], **params["metadata"]})
-        if operation == 'replace':
-            for use in before['uses']:
-                if not use.get('intrinsicEntry'):
-                    continue
-                target = timeline_for(project, use['timelineId'])
-                with timeline_context(resolve, target):
-                    matches = [i for i in target.GetItemListInTrack('video', use['track']) or [] if i.GetUniqueId() == use['id']]
-                    require(len(matches) == 1 and intrinsic.read_entry(matches[0], {media.GetUniqueId(): media}),
-                            'APPLY_OUTCOME_UNKNOWN', '素材已替换，但原生入口或画面引用在更新期间发生变化。')
-                    intrinsic.refresh_media(matches[0], media)
-        after = media_snapshot(project, scope, media, resolve)
+        after = media_identity(project, scope, media)
+        require_active_project(resolve, project)
         if operation == "replace":
-            def edits(uses):
-                return [{**item, "unsupported": [reason for reason in item["unsupported"] if not repair or reason != "offline-media-reference"]} for item in uses]
-            require(os.path.realpath(after["path"]) == path and edits(before["uses"]) == edits(after["uses"]), "APPLY_OUTCOME_UNKNOWN", "替换后的路径或剪辑使用位置读回不一致。")
+            require(os.path.realpath(after["path"]) == path, "APPLY_OUTCOME_UNKNOWN", "替换后的原素材路径读回不一致。")
             for key in ("FPS", "Frames", "Resolution", "Audio Ch", "Input Color Space", "Input Gamma", "Data Level"):
                 require(before["clipProperties"].get(key) == after["clipProperties"].get(key), "APPLY_OUTCOME_UNKNOWN", "替换后媒体规格或颜色解释改变。", property=key)
         return after
     if operation == "insert":
         require(not project.IsRenderingInProgress(), "RESOLVE_BUSY", "Resolve 正在导出。")
-        require(validated_host(resolve), "CAPABILITY_UNAVAILABLE", "该 Resolve 平台与构建尚未验证插入的帧边界。")
         timeline = timeline_for(project, params["timelineId"])
         before = timeline_snapshot(project, scope, timeline, resolve)
         require(before["fingerprint"] == params["expectedTimelineFingerprint"], "VERSION_CONFLICT", "时间线在插入前发生变化。")
@@ -1476,7 +1395,7 @@ def dispatch(resolve, operation, params):
                                                         "mediaType": 1, "trackIndex": track, "recordFrame": record}]) or []
         require(len(created) == 1, "APPLY_OUTCOME_UNKNOWN", "Resolve 未返回唯一插入对象，需核对后恢复。")
         save_insert_progress(params, before, "appended", media, created[0])
-        item = item_snapshot(created[0], timeline.GetUniqueId(), track, True, {media.GetUniqueId(): media}, before["fps"])
+        item = item_snapshot(created[0], timeline.GetUniqueId(), track, {media.GetUniqueId(): media}, before["fps"])
         sampling_matches = item["sourceIn"] == start and item["sourceOut"] == end
         if spec["fps"] != before["fps"]:
             expected_start = start * spec["fps"]["den"] / spec["fps"]["num"]