asecli 0.6.2__py3-none-any.whl

asecli/bridge/graph_geometry_parser.py

@@ -0,0 +1,57 @@
+"""Parser for backward-compatible ASECLI graph geometry payloads."""
+
+from __future__ import annotations
+
+import base64
+
+from .mcp_client import McpError
+
+
+def parse_geometry_payload(payload: str, geometry_type):
+    version = payload.splitlines()[0]
+    nodes: dict[str, dict] = {}
+    ports: list[tuple[str, str, str, float, float, str]] = []
+    for row in payload.splitlines()[1:]:
+        parts = row.split("|")
+        if parts[0] == "N" and len(parts) in {7, 8}:
+            try:
+                values = [float(value) for value in parts[2:7]]
+            except ValueError as exc:
+                raise McpError("MCP graph-geometry result contains non-numeric node geometry") from exc
+            if parts[1] in nodes or min(values[2:]) <= 0:
+                raise McpError(f"MCP graph-geometry result contains invalid node geometry for {parts[1]}")
+            node_title = ""
+            if len(parts) == 8 and version == "ASECLI_GEOMETRY_V3":
+                try:
+                    node_title = base64.b64decode(parts[7]).decode("utf-8")
+                except Exception as exc:
+                    raise McpError("MCP graph-geometry result contains malformed node title") from exc
+            nodes[parts[1]] = dict(
+                x=values[0], y=values[1], width=values[2], height=values[3],
+                title_height=values[4], input_ports={}, output_ports={},
+                node_title=node_title, input_port_labels={}, output_port_labels={},
+            )
+        elif parts[0] in {"I", "O"} and len(parts) in {5, 6}:
+            try:
+                label = ""
+                if len(parts) == 6 and version == "ASECLI_GEOMETRY_V3":
+                    label = base64.b64decode(parts[5]).decode("utf-8")
+                ports.append((parts[0], parts[1], parts[2], float(parts[3]), float(parts[4]), label))
+            except ValueError as exc:
+                raise McpError("MCP graph-geometry result contains non-numeric port geometry") from exc
+            except Exception as exc:
+                raise McpError("MCP graph-geometry result contains malformed port label") from exc
+        elif row:
+            raise McpError("MCP graph-geometry result contains a malformed row")
+    for direction, node_id, port_id, x, y, label in ports:
+        if node_id not in nodes:
+            raise McpError(f"MCP graph-geometry port references missing node {node_id}")
+        key = "input_ports" if direction == "I" else "output_ports"
+        if port_id in nodes[node_id][key]:
+            raise McpError(f"MCP graph-geometry result contains duplicate port {node_id}:{port_id}")
+        nodes[node_id][key][port_id] = (x - nodes[node_id]["x"], y - nodes[node_id]["y"])
+        label_key = "input_port_labels" if direction == "I" else "output_port_labels"
+        nodes[node_id][label_key][port_id] = label
+    if not nodes:
+        raise McpError("MCP graph-geometry result is empty")
+    return {node_id: geometry_type(**values) for node_id, values in nodes.items()}

asecli/bridge/graph_inspect.py

@@ -0,0 +1,136 @@
+"""Read editor-accurate ASE node bounds through MCP for visual layout checks."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .mcp_client import McpClient, McpError, tool_text
+from .recompile import _detect_project_root
+
+
+BOUNDS_SNIPPET = r'''
+string assetPath = {asset_path};
+var shader = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Shader>(assetPath);
+if (shader == null) throw new System.Exception("shader not found: " + assetPath);
+var previousWindow = AmplifyShaderEditor.UIUtils.CurrentWindow;
+var previousSelection = UnityEditor.Selection.activeObject;
+AmplifyShaderEditor.AmplifyShaderEditorWindow win = null;
+try
+{{
+    win = UnityEditor.EditorWindow.CreateInstance<AmplifyShaderEditor.AmplifyShaderEditorWindow>();
+    AmplifyShaderEditor.UIUtils.CurrentWindow = win;
+    var uiTextInfo = typeof(AmplifyShaderEditor.UIUtils).GetField(
+        "m_textInfo",
+        System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
+    if (uiTextInfo != null && uiTextInfo.GetValue(null) == null)
+        uiTextInfo.SetValue(null, new System.Globalization.CultureInfo("en-US", false).TextInfo);
+
+    var delayedLoad = typeof(AmplifyShaderEditor.AmplifyShaderEditorWindow).GetField(
+        "m_delayedLoadObject",
+        System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
+    if (delayedLoad == null)
+        throw new System.Exception("ASE delayed-load field not found");
+    delayedLoad.SetValue(win, shader);
+    win.Show();
+
+    var layoutEvent = new UnityEngine.Event();
+    layoutEvent.type = UnityEngine.EventType.Layout;
+    win.SendEvent(layoutEvent);
+    var repaintEvent = new UnityEngine.Event();
+    repaintEvent.type = UnityEngine.EventType.Repaint;
+    win.SendEvent(repaintEvent);
+
+    if (win.CurrentGraph == null || win.CurrentGraph.CurrentMasterNode == null)
+        throw new System.Exception("ASE graph did not load in GUI event");
+    var sb = new System.Text.StringBuilder("ASECLI_BOUNDS_V1\n");
+    foreach (var node in win.CurrentGraph.AllNodes)
+    {{
+        var rect = node.TruePosition;
+        sb.Append(node.UniqueId).Append('|')
+          .Append(rect.x.ToString("R", System.Globalization.CultureInfo.InvariantCulture)).Append('|')
+          .Append(rect.y.ToString("R", System.Globalization.CultureInfo.InvariantCulture)).Append('|')
+          .Append(rect.width.ToString("R", System.Globalization.CultureInfo.InvariantCulture)).Append('|')
+          .Append(rect.height.ToString("R", System.Globalization.CultureInfo.InvariantCulture)).Append('\n');
+    }}
+    return sb.ToString();
+}}
+finally
+{{
+    UnityEditor.Selection.activeObject = previousSelection;
+    AmplifyShaderEditor.UIUtils.CurrentWindow = previousWindow;
+    if (win != null)
+    {{
+        win.Close();
+        UnityEngine.Object.DestroyImmediate(win);
+    }}
+}}
+'''
+
+
+def measure_node_bounds_via_mcp(
+    shader_path: str,
+    *,
+    mcp_url: str = "http://127.0.0.1:8080/mcp",
+    instance_token: str | None = None,
+    unity_instance: str | None = None,
+    allow_remote_mcp: bool = False,
+) -> dict[str, tuple[float, float, float, float]]:
+    """Load a fresh hidden ASE window and return each node's runtime TruePosition."""
+    path = Path(shader_path).resolve()
+    if not path.exists():
+        raise FileNotFoundError(shader_path)
+    project_root = _detect_project_root(path)
+    asset_path = path.as_posix().removeprefix(project_root.as_posix() + "/")
+    client = McpClient(
+        mcp_url,
+        instance_token=instance_token,
+        allow_remote=allow_remote_mcp,
+    )
+    client.connect()
+    arguments = {
+        "action": "execute",
+        "code": BOUNDS_SNIPPET.format(asset_path=json.dumps(asset_path)),
+    }
+    if unity_instance is not None:
+        arguments["unity_instance"] = unity_instance
+    result = client.call_tool("execute_code", arguments)
+    envelope_text = tool_text(result, instance_token)
+    try:
+        envelope = json.loads(envelope_text)
+    except json.JSONDecodeError as exc:
+        raise McpError("MCP node-bounds result has an unexpected envelope") from exc
+    if not isinstance(envelope, dict):
+        raise McpError("MCP node-bounds result has an unexpected envelope")
+    if envelope.get("success") is False:
+        data = envelope.get("data") if isinstance(envelope.get("data"), dict) else {}
+        detail = envelope.get("message") or data.get("reason") or "Unity execution failed"
+        available = data.get("available_instances")
+        if isinstance(available, list) and available:
+            detail = f"{detail}; available instances: {', '.join(str(item) for item in available)}"
+        raise McpError(str(detail))
+    try:
+        payload = envelope["data"]["result"]
+    except (KeyError, TypeError) as exc:
+        raise McpError("MCP node-bounds result has an unexpected envelope") from exc
+    if not isinstance(payload, str) or not payload.startswith("ASECLI_BOUNDS_V1\n"):
+        raise McpError("MCP node-bounds result has an unexpected payload")
+
+    bounds: dict[str, tuple[float, float, float, float]] = {}
+    for line in payload.splitlines()[1:]:
+        if not line:
+            continue
+        parts = line.split("|")
+        if len(parts) != 5:
+            raise McpError("MCP node-bounds result contains a malformed row")
+        node_id = parts[0]
+        try:
+            rect = tuple(float(value) for value in parts[1:])
+        except ValueError as exc:
+            raise McpError("MCP node-bounds result contains a non-numeric rectangle") from exc
+        if node_id in bounds:
+            raise McpError(f"MCP node-bounds result contains duplicate node id {node_id}")
+        bounds[node_id] = rect  # type: ignore[assignment]
+    if not bounds:
+        raise McpError("MCP node-bounds result is empty")
+    return bounds

asecli/bridge/gui_handoff.py

@@ -0,0 +1,100 @@
+"""Recoverable fallback-to-native MZGUI provider handoff."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+from ._gui_handoff_store import (
+    disable_known_fallback,
+    handoff_backup_path,
+    remove_known_resource,
+    restore_known_fallback,
+)
+from ._gui_project import unity_project
+from ._gui_resource_store import install_gui_resource
+from .gui_support import (
+    GUI_AUTHORING_SHA256,
+    GUI_AUTHORING_SOURCE,
+    GUI_SUPPORT_ASSET_PATH,
+    GUI_SUPPORT_KNOWN_PREVIOUS,
+    GUI_SUPPORT_SHA256,
+    inspect_gui_support,
+)
+
+
+def handoff_gui_support(
+    project_root: str | Path,
+    *,
+    write: bool = False,
+    runtime_probe: dict | None = None,
+) -> dict:
+    """Install the authoring-only bridge, then verify native takeover or roll back."""
+    project = unity_project(project_root, GUI_SUPPORT_ASSET_PATH)
+    state = inspect_gui_support(project_root, runtime_probe=runtime_probe)
+    target_digest = state["asecli_material_gui"]["actual_sha256"]
+    known = {GUI_SUPPORT_SHA256, *GUI_SUPPORT_KNOWN_PREVIOUS.keys()}
+
+    pending = sorted(project.target.parent.glob(project.target.name + ".asecli-handoff-*.disabled"))
+    if pending:
+        return _finish_pending(
+            project, state, pending, known, runtime_probe=runtime_probe, write=write
+        )
+
+    runtime = state["native_mzgui"]["runtime_providers"]
+    native = [item for item in runtime if item["shader_gui"] and not item["fallback"]]
+    fallback = [item for item in runtime if item["fallback"]]
+    if (
+        state["provider"] != "multiple"
+        or target_digest not in known
+        or runtime_probe is None
+        or not runtime_probe.get("native_authoring_capable")
+        or len(runtime) != 2
+        or len(native) != 1
+        or len(fallback) != 1
+    ):
+        raise RuntimeError("native handoff requires exactly a native provider plus one known fallback")
+    backup = handoff_backup_path(project.target, target_digest)
+    result = {**state, "action": "prepare_native_handoff", "handoff_backup": str(backup)}
+    if not write:
+        return result
+    disable_known_fallback(project, target_digest, known)
+    try:
+        install_gui_resource(project, GUI_AUTHORING_SOURCE.encode("utf-8"))
+    except BaseException:
+        restore_known_fallback(project, backup, target_digest, known)
+        raise
+    return {
+        **result,
+        "action": "native_handoff_pending_verification",
+        "written": True,
+        "requires_editor_recompile": True,
+    }
+
+
+def _finish_pending(project, state, pending, known, *, runtime_probe, write):
+    if len(pending) != 1 or project.target.is_symlink() or not project.target.is_file():
+        raise RuntimeError("GUI handoff state is ambiguous; refusing automatic recovery")
+    if hashlib.sha256(project.target.read_bytes()).hexdigest() != GUI_AUTHORING_SHA256:
+        raise RuntimeError("GUI handoff authoring bridge changed; refusing automatic recovery")
+    backup = pending[0]
+    if backup.is_symlink() or not backup.is_file():
+        raise RuntimeError("GUI handoff backup is not a regular file; refusing automatic recovery")
+    digest = hashlib.sha256(backup.read_bytes()).hexdigest()
+    if digest not in known or backup != handoff_backup_path(project.target, digest):
+        raise RuntimeError("GUI handoff backup is unknown; refusing automatic recovery")
+    runtime = state["native_mzgui"]["runtime_providers"]
+    if (
+        runtime_probe is not None
+        and state["provider"] == "native_mzgui"
+        and len(runtime) == 1
+        and runtime[0]["shader_gui"]
+        and not runtime[0]["fallback"]
+    ):
+        return {**state, "action": "native_handoff_verified", "handoff_backup": str(backup)}
+    result = {**state, "action": "rollback_native_handoff", "handoff_backup": str(backup)}
+    if write:
+        remove_known_resource(project, project.target, GUI_AUTHORING_SHA256)
+        restore_known_fallback(project, backup, digest, known)
+        result.update(action="native_handoff_rolled_back", written=True)
+    return result

asecli/bridge/gui_presentation.py

@@ -0,0 +1,70 @@
+"""Executable presentation contracts for the built-in material GUI."""
+
+from __future__ import annotations
+
+
+INLINE_HELP_PRESENTATION_CONTRACT = {
+    "contract": "asecli.inline-help.v1",
+    "icon": "none",
+    "border": "none",
+    "background_rgba": [0.0, 0.0, 0.0, 0.1],
+    "accent": {"edge": "left", "width": 3.0, "rgba": [1.0, 1.0, 1.0, 0.3]},
+    "typography": {
+        "base": "EditorStyles.miniLabel",
+        "font_style": "italic",
+        "dark_skin_alpha": 0.4,
+        "light_skin_alpha": 0.55,
+    },
+    "layout": {"text_inset": [16.0, 4.0], "word_wrap": True},
+}
+
+_REQUIRED_SOURCE_MARKERS = {
+    "inline_renderer": "DrawInlineHelp(metadata.Help)",
+    "mini_typography": "new GUIStyle(EditorStyles.miniLabel)",
+    "italic_typography": "style.fontStyle = FontStyle.Italic",
+    "word_wrap": "style.wordWrap = true",
+    "subtle_background": (
+        "EditorGUI.DrawRect(backgroundRect, new Color(0f, 0f, 0f, 0.1f))"
+    ),
+    "left_accent_color": (
+        "EditorGUI.DrawRect(accentRect, new Color(1f, 1f, 1f, 0.3f))"
+    ),
+    "left_accent_geometry": "backgroundRect.x + 6f,\n                backgroundRect.y + 6f,\n                3f,",
+    "text_inset": "row.x + 16f,\n                row.y + 4f,",
+    "dark_skin_text": "new Color(1f, 1f, 1f, 0.4f)",
+    "light_skin_text": "new Color(0f, 0f, 0f, 0.55f)",
+}
+_FORBIDDEN_SOURCE_MARKERS = {
+    "native_layout_help_box": "EditorGUILayout.HelpBox(",
+    "native_gui_help_box": "EditorGUI.HelpBox(",
+}
+
+
+def inspect_inline_help_presentation(source: str) -> dict:
+    """Report whether the packaged C# source satisfies the public style contract."""
+    violations = [
+        f"missing:{name}"
+        for name, marker in _REQUIRED_SOURCE_MARKERS.items()
+        if marker not in source
+    ]
+    violations.extend(
+        f"forbidden:{name}"
+        for name, marker in _FORBIDDEN_SOURCE_MARKERS.items()
+        if marker in source
+    )
+    return {
+        **INLINE_HELP_PRESENTATION_CONTRACT,
+        "valid": not violations,
+        "violations": violations,
+    }
+
+
+def require_inline_help_presentation(source: str) -> None:
+    """Fail closed before installation when the packaged style has regressed."""
+    result = inspect_inline_help_presentation(source)
+    if result["valid"]:
+        return
+    raise RuntimeError(
+        "packaged ASECLI GUI violates inline-help presentation contract: "
+        + ", ".join(result["violations"])
+    )

asecli/bridge/gui_provider_detection.py

@@ -0,0 +1,197 @@
+"""Static and Editor-runtime detection of the native MZGUI material provider."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import re
+
+from .mcp_client import McpClient, McpError, tool_text
+
+
+_NATIVE_NAMESPACE_RE = re.compile(r"\bnamespace\s+MZGUI\b")
+_NATIVE_GUI_BASE_RE = re.compile(r"\bclass\s+MZGUI\s*:\s*([A-Za-z_][A-Za-z0-9_:.]*)")
+_SHADER_GUI_ALIAS_RE = re.compile(
+    r"\busing\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:global::)?UnityEditor\.ShaderGUI\s*;"
+)
+_GUI_PROBE_MARKER = "ASECLI_GUI_SUPPORT_PROBE_V2:"
+GUI_SUPPORT_PROBE_SNIPPET = r'''
+var probe = new Newtonsoft.Json.Linq.JObject();
+probe["protocol"] = "ASECLI_GUI_SUPPORT_PROBE_V2";
+probe["assets_path"] = System.IO.Path.GetFullPath(UnityEngine.Application.dataPath);
+var providers = new Newtonsoft.Json.Linq.JArray();
+foreach (var assembly in System.AppDomain.CurrentDomain.GetAssemblies())
+{
+    var candidate = assembly.GetType("MZGUI.MZGUI", false);
+    if (candidate == null) continue;
+    var item = new Newtonsoft.Json.Linq.JObject();
+    item["full_name"] = candidate.FullName;
+    item["assembly"] = candidate.Assembly.FullName;
+    item["shader_gui"] = typeof(UnityEditor.ShaderGUI).IsAssignableFrom(candidate);
+    item["fallback"] = candidate.GetInterface(
+        "ASECLI.MaterialGUI.IASECLIFallbackProvider") != null;
+    providers.Add(item);
+}
+probe["providers"] = providers;
+probe["type_found"] = providers.Count > 0;
+probe["detected"] = providers.Count == 1 && !(bool)providers[0]["fallback"] &&
+    (bool)providers[0]["shader_gui"];
+probe["fallback"] = providers.Count == 1 && (bool)providers[0]["fallback"];
+probe["assembly"] = providers.Count == 1 ? providers[0]["assembly"] : null;
+System.Type propertyNode = null;
+foreach (var assembly in System.AppDomain.CurrentDomain.GetAssemblies())
+{
+    propertyNode = assembly.GetType("AmplifyShaderEditor.PropertyNode", false);
+    if (propertyNode != null) break;
+}
+var allFields = System.Reflection.BindingFlags.Public |
+    System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;
+probe["native_authoring_capable"] = propertyNode != null &&
+    propertyNode.GetField("m_mzguiAttribs", allFields) != null &&
+    propertyNode.GetField("m_selectedMzguiAttribs", allFields) != null;
+return "ASECLI_GUI_SUPPORT_PROBE_V2:" + probe.ToString(Newtonsoft.Json.Formatting.None);
+'''.strip()
+
+
+def probe_native_mzgui_for_assets(
+    project_assets: Path,
+    *,
+    mcp_url: str,
+    instance_token: str | None,
+    allow_remote_mcp: bool,
+) -> dict:
+    client = McpClient(mcp_url, instance_token=instance_token, allow_remote=allow_remote_mcp)
+    client.connect()
+    result = client.call_tool("execute_code", {"action": "execute", "code": GUI_SUPPORT_PROBE_SNIPPET})
+    text = tool_text(result, instance_token)
+    marker = text.find(_GUI_PROBE_MARKER)
+    if marker < 0:
+        raise McpError("MCP tool result did not contain the GUI support probe marker")
+    raw = text[marker + len(_GUI_PROBE_MARKER) :].lstrip()
+    try:
+        value, _ = json.JSONDecoder().raw_decode(raw)
+    except json.JSONDecodeError as exc:
+        raise McpError("MCP GUI support probe returned malformed JSON") from exc
+    if not isinstance(value, dict):
+        raise McpError("MCP GUI support probe result must be an object")
+    validate_runtime_probe(value, project_assets)
+    return value
+
+
+def validate_runtime_probe(probe: dict, project_assets: Path) -> None:
+    if probe.get("protocol") not in {
+        "ASECLI_GUI_SUPPORT_PROBE_V1",
+        "ASECLI_GUI_SUPPORT_PROBE_V2",
+    }:
+        raise ValueError("GUI support runtime probe protocol is missing or unsupported")
+    if not isinstance(probe.get("detected"), bool) or not isinstance(probe.get("type_found"), bool):
+        raise ValueError("GUI support runtime probe booleans are invalid")
+    if "fallback" in probe and not isinstance(probe.get("fallback"), bool):
+        raise ValueError("GUI support runtime fallback marker is invalid")
+    if probe.get("protocol") == "ASECLI_GUI_SUPPORT_PROBE_V2":
+        providers = probe.get("providers")
+        if not isinstance(providers, list):
+            raise ValueError("GUI support runtime providers are invalid")
+        for provider in providers:
+            if not isinstance(provider, dict):
+                raise ValueError("GUI support runtime provider is invalid")
+            if not isinstance(provider.get("assembly"), str):
+                raise ValueError("GUI support runtime provider assembly is invalid")
+            if not isinstance(provider.get("shader_gui"), bool) or not isinstance(
+                provider.get("fallback"), bool
+            ):
+                raise ValueError("GUI support runtime provider flags are invalid")
+        if not isinstance(probe.get("native_authoring_capable"), bool):
+            raise ValueError("GUI support native authoring capability is invalid")
+    assets_path = probe.get("assets_path")
+    if not isinstance(assets_path, str) or Path(assets_path).resolve() != project_assets.resolve():
+        raise ValueError("connected Editor project does not match the requested project root")
+
+
+def runtime_providers(probe: dict | None) -> list[dict]:
+    """Normalize V1/V2 probe results without turning an ambiguous hit into native."""
+    if probe is None:
+        return []
+    if probe.get("protocol") == "ASECLI_GUI_SUPPORT_PROBE_V2":
+        return [dict(item) for item in probe.get("providers", [])]
+    if not probe.get("type_found"):
+        return []
+    return [
+        {
+            "full_name": "MZGUI.MZGUI",
+            "assembly": probe.get("assembly") or "unknown",
+            "shader_gui": bool(probe.get("detected") or probe.get("fallback")),
+            "fallback": bool(probe.get("fallback")),
+        }
+    ]
+
+
+def scan_native_mzgui(project_root: Path, *, skip_source_name: str) -> tuple[list[str], list[str]]:
+    """Return proven providers and candidates that need an Editor reflection probe."""
+    search_roots = [project_root / "Assets", project_root / "Packages"]
+    package_cache = project_root / "Library" / "PackageCache"
+    if package_cache.is_dir():
+        try:
+            search_roots.extend(entry for entry in package_cache.iterdir() if "mzgui" in entry.name.lower())
+        except OSError:
+            pass
+
+    evidence: list[str] = []
+    candidates: list[str] = []
+    for root in search_roots:
+        if not root.is_dir():
+            continue
+        for source in root.rglob("*.cs"):
+            if source.name == skip_source_name:
+                continue
+            try:
+                if source.stat().st_size > 2_000_000:
+                    continue
+                text = source.read_text(encoding="utf-8-sig", errors="ignore")
+            except OSError:
+                continue
+            relative = _relative_evidence(source, project_root)
+            if _source_defines_native_mzgui(text):
+                evidence.append(relative)
+            elif _NATIVE_NAMESPACE_RE.search(text) and re.search(r"\bclass\s+MZGUI\b", text):
+                candidates.append(relative)
+        for assembly in root.rglob("*.dll"):
+            try:
+                if assembly.stat().st_size > 100_000_000:
+                    continue
+                data = assembly.read_bytes()
+            except OSError:
+                continue
+            if "mzgui" in assembly.name.lower() or (b"MZGUI" in data and b"ShaderGUI" in data):
+                candidates.append(_relative_evidence(assembly, project_root))
+
+    for manifest_name in ("manifest.json", "packages-lock.json"):
+        manifest = project_root / "Packages" / manifest_name
+        if not manifest.is_file():
+            continue
+        try:
+            if "mzgui" in manifest.read_text(encoding="utf-8", errors="ignore").lower():
+                candidates.append(_relative_evidence(manifest, project_root))
+        except OSError:
+            continue
+    return sorted(set(evidence)), sorted(set(candidates) - set(evidence))
+
+
+def _source_defines_native_mzgui(text: str) -> bool:
+    if not _NATIVE_NAMESPACE_RE.search(text):
+        return False
+    match = _NATIVE_GUI_BASE_RE.search(text)
+    if match is None:
+        return False
+    base = match.group(1).replace("global::", "")
+    if base in {"ShaderGUI", "UnityEditor.ShaderGUI"}:
+        return True
+    aliases = {alias.group(1) for alias in _SHADER_GUI_ALIAS_RE.finditer(text)}
+    return base in aliases
+
+
+def _relative_evidence(path: Path, project_root: Path) -> str:
+    try:
+        return path.resolve().relative_to(project_root).as_posix()
+    except ValueError:
+        return str(path.resolve())

asecli/bridge/gui_runtime_probe.py

@@ -0,0 +1,25 @@
+"""Connected-Editor runtime probe for MZGUI providers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ._gui_project import unity_project
+from .gui_provider_detection import probe_native_mzgui_for_assets
+from .gui_support import GUI_SUPPORT_ASSET_PATH
+
+
+def probe_native_mzgui_via_mcp(
+    project_root: str | Path,
+    *,
+    mcp_url: str = "http://127.0.0.1:8080/mcp",
+    instance_token: str | None = None,
+    allow_remote_mcp: bool = False,
+) -> dict:
+    project = unity_project(project_root, GUI_SUPPORT_ASSET_PATH)
+    return probe_native_mzgui_for_assets(
+        project.assets,
+        mcp_url=mcp_url,
+        instance_token=instance_token,
+        allow_remote_mcp=allow_remote_mcp,
+    )