asecli 0.6.2__py3-none-any.whl

asecli/bridge/resources/editor_create.part04.cs.txt

@@ -0,0 +1,114 @@
+
+    string moveError = UnityEditor.AssetDatabase.MoveAsset(temporaryAssetPath, assetPath);
+    if (!string.IsNullOrEmpty(moveError)) throw new System.Exception("asset commit failed: " + moveError);
+    committed = true;
+    var targetShader = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Shader>(assetPath);
+    if (targetShader == null || targetShader.name != shaderName)
+        throw new System.Exception("shader identity changed after asset commit");
+
+    var result = new Newtonsoft.Json.Linq.JObject();
+    result["protocol"] = "ASECLI_EDITOR_CREATE_V1";
+    result["ase_version"] = aseVersion;
+    result["asset_path"] = assetPath;
+    result["template_guid"] = reloadedMaster.CurrentTemplate.GUID;
+    result["shader_name"] = targetShader.name;
+    result["saved"] = saved;
+    result["reloaded"] = reloaded;
+    result["committed"] = committed;
+    var manifest = new Newtonsoft.Json.Linq.JObject();
+    var manifestTemplate = new Newtonsoft.Json.Linq.JObject();
+    manifestTemplate["guid"] = reloadedMaster.CurrentTemplate.GUID;
+    manifestTemplate["shader_name"] = targetShader.name;
+    manifest["template"] = manifestTemplate;
+    manifest["nodes"] = manifestNodes;
+    manifest["connections"] = manifestConnections;
+    result["manifest"] = manifest;
+
+    UnityEditor.Selection.activeObject = previousSelection;
+    AmplifyShaderEditor.UIUtils.CurrentWindow = previousWindow;
+    stateRestored = true;
+    if (win != null && win != previousWindow)
+    {
+        var createdWindow = win;
+        createdWindow.Close();
+        UnityEngine.Object.DestroyImmediate(createdWindow);
+        win = null;
+    }
+    success = true;
+    return "ASECLI_EDITOR_CREATE_V1:" + result.ToString(Newtonsoft.Json.Formatting.None);
+}
+catch (System.Exception ex)
+{
+    failure = ex;
+    throw;
+}
+finally
+{
+    var cleanupErrors = new System.Collections.Generic.List<string>();
+    if (win == null && AmplifyShaderEditor.UIUtils.CurrentWindow != previousWindow)
+        win = AmplifyShaderEditor.UIUtils.CurrentWindow as AmplifyShaderEditor.AmplifyShaderEditorWindow;
+    if (!success)
+    {
+        try
+        {
+            if (committed && !UnityEditor.AssetDatabase.DeleteAsset(assetPath) &&
+                System.IO.File.Exists(System.IO.Path.GetFullPath(assetPath)))
+                cleanupErrors.Add("failed to roll back committed target asset");
+        }
+        catch (System.Exception cleanupEx)
+        {
+            cleanupErrors.Add("target rollback threw: " + cleanupEx.Message);
+        }
+        try
+        {
+            if (!UnityEditor.AssetDatabase.DeleteAsset(temporaryAssetPath) &&
+                System.IO.File.Exists(System.IO.Path.GetFullPath(temporaryAssetPath)))
+                cleanupErrors.Add("failed to delete temporary asset");
+        }
+        catch (System.Exception cleanupEx)
+        {
+            cleanupErrors.Add("temporary cleanup threw: " + cleanupEx.Message);
+        }
+        try { UnityEditor.AssetDatabase.Refresh(); }
+        catch (System.Exception cleanupEx) { cleanupErrors.Add("AssetDatabase.Refresh threw: " + cleanupEx.Message); }
+    }
+    if (!stateRestored)
+    {
+        try
+        {
+            UnityEditor.Selection.activeObject = previousSelection;
+            AmplifyShaderEditor.UIUtils.CurrentWindow = previousWindow;
+            stateRestored = true;
+        }
+        catch (System.Exception cleanupEx)
+        {
+            cleanupErrors.Add("Editor state restore threw: " + cleanupEx.Message);
+        }
+    }
+    if (win != null && win != previousWindow)
+    {
+        try
+        {
+            win.Close();
+            UnityEngine.Object.DestroyImmediate(win);
+            win = null;
+        }
+        catch (System.Exception cleanupEx)
+        {
+            cleanupErrors.Add("window cleanup threw: " + cleanupEx.Message);
+        }
+    }
+    if (cleanupErrors.Count > 0)
+    {
+        string cleanupMessage = string.Join(" | ", cleanupErrors.ToArray());
+        if (failure != null)
+        {
+            failure.Data["ASECLI cleanup failures"] = cleanupMessage;
+            UnityEngine.Debug.LogError("ASECLI Editor create cleanup failures: " + cleanupMessage);
+        }
+        else
+        {
+            throw new System.Exception("ASECLI Editor create cleanup failed: " + cleanupMessage);
+        }
+    }
+}

asecli/bridge/resources/wire_route.transaction.cs.txt

@@ -0,0 +1,140 @@
+var payloadJson = System.Text.Encoding.UTF8.GetString(System.Convert.FromBase64String("{payload_base64}"));
+var payload = Newtonsoft.Json.Linq.JObject.Parse(payloadJson);
+string assetPath = (string)payload["asset_path"];
+var routes = (Newtonsoft.Json.Linq.JArray)payload["routes"];
+var previousWindow = AmplifyShaderEditor.UIUtils.CurrentWindow;
+var previousSelection = UnityEditor.Selection.activeObject;
+AmplifyShaderEditor.AmplifyShaderEditorWindow win = null;
+byte[] diskSnapshot = null;
+bool saved = false;
+try
+{
+    if ((int)payload["version"] != 1)
+        throw new System.Exception("unsupported WireNode route version");
+    if (string.IsNullOrEmpty(assetPath) || !assetPath.StartsWith("Assets/") ||
+        !assetPath.EndsWith(".shader") || assetPath.Contains("..") || assetPath.Contains("\\"))
+        throw new System.Exception("unsafe target asset path");
+    string diskPath = System.IO.Path.GetFullPath(assetPath);
+    diskSnapshot = System.IO.File.ReadAllBytes(diskPath);
+    var shader = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Shader>(assetPath);
+    if (shader == null) throw new System.Exception("shader not found: " + assetPath);
+
+    var publicInstance = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance;
+    var windowCreate = typeof(AmplifyShaderEditor.AmplifyShaderEditorWindow).GetMethod(
+        "CreateNode", publicInstance, null,
+        new System.Type[] { typeof(System.Type), typeof(UnityEngine.Vector2), typeof(AmplifyShaderFunction), typeof(bool) }, null);
+    var graphCreateConnection = typeof(AmplifyShaderEditor.ParentGraph).GetMethod(
+        "CreateConnection", publicInstance, null,
+        new System.Type[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(bool) }, null);
+    var graphDeleteConnection = typeof(AmplifyShaderEditor.ParentGraph).GetMethod(
+        "DeleteConnection", publicInstance, null,
+        new System.Type[] { typeof(bool), typeof(int), typeof(int), typeof(bool), typeof(bool), typeof(bool) }, null);
+    var saveMethod = typeof(AmplifyShaderEditor.AmplifyShaderEditorWindow).GetMethod(
+        "SaveToDisk", publicInstance, null, new System.Type[] { typeof(bool) }, null);
+    if (windowCreate == null || graphCreateConnection == null || graphDeleteConnection == null || saveMethod == null)
+        throw new System.Exception("required WireNode routing API is unavailable in this ASE version");
+
+    win = UnityEditor.EditorWindow.CreateInstance<AmplifyShaderEditor.AmplifyShaderEditorWindow>();
+    AmplifyShaderEditor.UIUtils.CurrentWindow = win;
+    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);
+    var graph = win.CurrentGraph;
+    if (graph == null || graph.CurrentMasterNode == null)
+        throw new System.Exception("ASE graph did not load in GUI event");
+
+    var createdIds = new Newtonsoft.Json.Linq.JArray();
+    foreach (Newtonsoft.Json.Linq.JObject route in routes)
+    {
+        string action = (string)route["action"];
+        var logical = (Newtonsoft.Json.Linq.JObject)route["logical_wire"];
+        int sourceNodeId = (int)logical["from_node"];
+        int sourcePortId = (int)logical["from_port"];
+        int targetNodeId = (int)logical["to_node"];
+        int targetPortId = (int)logical["to_port"];
+        var sourceNode = graph.GetNode(sourceNodeId);
+        var targetNode = graph.GetNode(targetNodeId);
+        if (sourceNode == null || targetNode == null ||
+            sourceNode.GetOutputPortByUniqueId(sourcePortId) == null ||
+            targetNode.GetInputPortByUniqueId(targetPortId) == null)
+            throw new System.Exception("WireNode route endpoint not found");
+
+        var anchors = (Newtonsoft.Json.Linq.JArray)route["anchors"];
+        if (action == "move")
+        {
+            foreach (Newtonsoft.Json.Linq.JObject anchor in anchors)
+            {
+                int wireNodeId = (int)anchor["wire_node_id"];
+                var node = graph.GetNode(wireNodeId);
+                if (node == null || node.GetType() != typeof(AmplifyShaderEditor.WireNode))
+                    throw new System.Exception("existing WireNode route anchor not found");
+                var point = (Newtonsoft.Json.Linq.JArray)anchor["to"];
+                node.Vec2Position = new UnityEngine.Vector2((float)point[0], (float)point[1]);
+            }
+        }
+        else if (action == "add")
+        {
+            var targetPort = targetNode.GetInputPortByUniqueId(targetPortId);
+            if (!targetPort.IsConnectedTo(sourceNodeId, sourcePortId))
+                throw new System.Exception("logical wire is no longer a direct connection");
+            graphDeleteConnection.Invoke(
+                graph, new object[] { true, targetNodeId, targetPortId, false, true, false });
+            int previousNodeId = sourceNodeId;
+            int previousPortId = sourcePortId;
+            foreach (Newtonsoft.Json.Linq.JArray point in anchors)
+            {
+                var created = (AmplifyShaderEditor.ParentNode)windowCreate.Invoke(
+                    win, new object[] {
+                        typeof(AmplifyShaderEditor.WireNode),
+                        new UnityEngine.Vector2((float)point[0], (float)point[1]), null, false
+                    });
+                if (created == null || created.GetType() != typeof(AmplifyShaderEditor.WireNode))
+                    throw new System.Exception("ASE failed to create WireNode");
+                graphCreateConnection.Invoke(
+                    graph, new object[] {
+                        created.UniqueId, created.InputPorts[0].PortId,
+                        previousNodeId, previousPortId, false
+                    });
+                if (!created.InputPorts[0].IsConnectedTo(previousNodeId, previousPortId))
+                    throw new System.Exception("ASE rejected source-to-WireNode connection");
+                previousNodeId = created.UniqueId;
+                previousPortId = created.OutputPorts[0].PortId;
+                createdIds.Add(created.UniqueId);
+            }
+            graphCreateConnection.Invoke(
+                graph, new object[] { targetNodeId, targetPortId, previousNodeId, previousPortId, false });
+            if (!targetPort.IsConnectedTo(previousNodeId, previousPortId))
+                throw new System.Exception("ASE rejected WireNode-to-target connection");
+        }
+        else throw new System.Exception("unknown WireNode route action");
+    }
+    saved = (bool)saveMethod.Invoke(win, new object[] { false });
+    if (!saved) throw new System.Exception("ASE SaveToDisk returned false");
+    var response = new Newtonsoft.Json.Linq.JObject();
+    response["protocol"] = "ASECLI_WIRE_ROUTE_V1";
+    response["asset_path"] = assetPath;
+    response["ase_version"] = AmplifyShaderEditor.VersionInfo.StaticToString();
+    response["saved"] = true;
+    response["applied_routes"] = routes.Count;
+    response["created_node_ids"] = createdIds;
+    return "ASECLI_WIRE_ROUTE_V1:" + response.ToString(Newtonsoft.Json.Formatting.None);
+}
+catch
+{
+    if (diskSnapshot != null)
+    {
+        System.IO.File.WriteAllBytes(System.IO.Path.GetFullPath(assetPath), diskSnapshot);
+        UnityEditor.AssetDatabase.ImportAsset(assetPath, UnityEditor.ImportAssetOptions.ForceUpdate);
+    }
+    throw;
+}
+finally
+{
+    UnityEditor.Selection.activeObject = previousSelection;
+    AmplifyShaderEditor.UIUtils.CurrentWindow = previousWindow;
+    if (win != null) { win.Close(); UnityEngine.Object.DestroyImmediate(win); }
+}

asecli/bridge/wire_route.py

@@ -0,0 +1,127 @@
+"""Apply a fixed WireNode routing plan through the currently installed ASE API."""
+
+from __future__ import annotations
+
+import base64
+import json
+from pathlib import Path
+
+from .mcp_client import McpClient, McpError
+from .editor_create import _execute_code_result_text
+from .recompile import _detect_project_root
+from .resource_text import compose_resource_text
+
+WIRE_ROUTE_SNIPPET = compose_resource_text(
+    "asecli.bridge", "resources", ("wire_route.transaction.cs.txt",),
+)
+_RESULT_MARKER = "ASECLI_WIRE_ROUTE_V1:"
+
+
+def apply_wire_routes_via_mcp(
+    shader_path: str | Path,
+    changes: tuple[dict, ...],
+    *,
+    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:
+    target = Path(shader_path).resolve()
+    if not target.is_file():
+        raise FileNotFoundError(shader_path)
+    root = _detect_project_root(target)
+    asset_path = target.as_posix().removeprefix(root.as_posix() + "/")
+    routes = _validated_routes(changes)
+    payload = {"version": 1, "asset_path": asset_path, "routes": routes}
+    encoded = base64.b64encode(
+        json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")
+    ).decode("ascii")
+    code = WIRE_ROUTE_SNIPPET.replace("{payload_base64}", encoded)
+    client = McpClient(mcp_url, instance_token=instance_token, allow_remote=allow_remote_mcp)
+    client.connect()
+    arguments = {"action": "execute", "code": code}
+    if unity_instance is not None:
+        arguments["unity_instance"] = unity_instance
+    result = client.call_tool("execute_code", arguments)
+    response = _parse_result(_execute_code_result_text(result, instance_token))
+    if response.get("protocol") != "ASECLI_WIRE_ROUTE_V1":
+        raise McpError("WireNode route protocol version is missing or unsupported")
+    if response.get("asset_path") != asset_path:
+        raise McpError("WireNode route returned a different asset path")
+    if response.get("saved") is not True:
+        raise McpError("WireNode route did not confirm saved=True")
+    if response.get("applied_routes") != len(routes):
+        raise McpError("WireNode route applied-count does not match the plan")
+    created = response.get("created_node_ids")
+    expected_created = sum(len(item["anchors"]) for item in routes if item["action"] == "add")
+    if not isinstance(created, list) or len(created) != expected_created:
+        raise McpError("WireNode route returned an invalid created-node manifest")
+    return response
+
+
+def _validated_routes(changes: tuple[dict, ...]) -> list[dict]:
+    routes = []
+    seen = set()
+    for change in changes:
+        action = change.get("action")
+        logical = change.get("logical_wire")
+        if action not in {"move", "add"} or not isinstance(logical, dict):
+            raise ValueError("invalid WireNode route change")
+        normalized = {}
+        for source, target in (
+            ("from_node", "from_node"), ("from_port", "from_port"),
+            ("to_node", "to_node"), ("to_port", "to_port"),
+        ):
+            value = str(logical.get(source, ""))
+            if not value.lstrip("-").isdigit():
+                raise ValueError(f"WireNode route {source} must be numeric")
+            normalized[target] = int(value)
+        key = tuple(normalized.values())
+        if key in seen:
+            raise ValueError("duplicate WireNode logical route")
+        seen.add(key)
+        if action == "add":
+            anchors = change.get("anchors")
+            if not isinstance(anchors, list) or not 1 <= len(anchors) <= 2:
+                raise ValueError("a logical wire may add one or two WireNode anchors")
+            normalized_anchors = [_point(item) for item in anchors]
+        else:
+            anchors = change.get("anchors")
+            if not isinstance(anchors, list) or not anchors:
+                raise ValueError("WireNode move requires at least one existing anchor")
+            normalized_anchors = []
+            ids = set()
+            for item in anchors:
+                node_id = str(item.get("wire_node_id", ""))
+                if not node_id.lstrip("-").isdigit() or node_id in ids:
+                    raise ValueError("WireNode move ids must be unique numeric values")
+                ids.add(node_id)
+                normalized_anchors.append({"wire_node_id": int(node_id), "to": _point(item.get("to"))})
+        routes.append({"action": action, "logical_wire": normalized, "anchors": normalized_anchors})
+    return routes
+
+
+def _point(value) -> list[float]:
+    if not isinstance(value, (list, tuple)) or len(value) != 2:
+        raise ValueError("WireNode anchor must be an x,y pair")
+    try:
+        point = [float(value[0]), float(value[1])]
+    except (TypeError, ValueError) as exc:
+        raise ValueError("WireNode anchor coordinates must be numeric") from exc
+    if not all(abs(item) <= 10_000_000 for item in point):
+        raise ValueError("WireNode anchor coordinate is outside the supported canvas range")
+    return point
+
+
+def _parse_result(text: str) -> dict:
+    marker = text.find(_RESULT_MARKER)
+    if marker < 0:
+        raise McpError("MCP tool result did not contain the WireNode route marker")
+    raw = text[marker + len(_RESULT_MARKER):].lstrip()
+    try:
+        value, _ = json.JSONDecoder().raw_decode(raw)
+    except json.JSONDecodeError as exc:
+        raise McpError("MCP tool returned malformed WireNode route JSON") from exc
+    if not isinstance(value, dict):
+        raise McpError("MCP WireNode route result must be a JSON object")
+    return value

asecli/checks/__init__.py

@@ -0,0 +1,10 @@
+"""Validation & checksum (TASK-0008/0009)."""
+
+from .checksum import ChecksumFormatError, compute_checksum, fix_checksum, verify_checksum
+from .usage import external_references_for_node, live_node_ids, usage_audit
+from .validate import validate_file
+
+__all__ = [
+    "ChecksumFormatError", "compute_checksum", "external_references_for_node", "fix_checksum",
+    "live_node_ids", "usage_audit", "verify_checksum", "validate_file",
+]

asecli/checks/checksum.py

@@ -0,0 +1,53 @@
+"""ASE checksum: SHA1 (uppercase hex) of the full text before ``//CHKSM=``.
+
+Replicates ``IOUtils.CreateChecksum``; verified against real files.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+
+MARKER = "//CHKSM="
+_TRAILER = re.compile(r"(?m)^//CHKSM=([^\r\n]*)(\r?\n)?\Z")
+_LINE_MARKER = re.compile(r"(?m)^//CHKSM=")
+
+
+class ChecksumFormatError(ValueError):
+    """Raised when checksum-like lines are ambiguous or not a trailer."""
+
+
+def compute_checksum(text_before: str) -> str:
+    return hashlib.sha1(text_before.encode("utf-8")).hexdigest().upper()
+
+
+def verify_checksum(text: str) -> tuple[bool, str | None, str | None]:
+    match = _checksum_trailer(text)
+    if match is None:
+        return False, None, None
+    idx = match.start()
+    stored = match.group(1).strip()
+    actual = compute_checksum(text[:idx])
+    return bool(re.fullmatch(r"[0-9A-Fa-f]{40}", stored)) and stored.upper() == actual, stored, actual
+
+
+def fix_checksum(text: str) -> str:
+    match = _checksum_trailer(text)
+    if match is None:
+        sep = "" if text.endswith("\n") else "\n"
+        return text + sep + MARKER + compute_checksum(text)
+    idx = match.start()
+    trailing_eol = match.group(2) or ""
+    return text[:idx] + MARKER + compute_checksum(text[:idx]) + trailing_eol
+
+
+def _checksum_trailer(text: str) -> re.Match[str] | None:
+    markers = list(_LINE_MARKER.finditer(text))
+    match = _TRAILER.search(text)
+    if match is None:
+        if markers:
+            raise ChecksumFormatError("//CHKSM= must be the final standalone line")
+        return None
+    if len(markers) != 1 or markers[0].start() != match.start():
+        raise ChecksumFormatError("multiple //CHKSM= lines are ambiguous")
+    return match

asecli/checks/local_vars.py

@@ -0,0 +1,135 @@
+"""Structural checks for ASE Register/Get Local Var semantics."""
+
+from __future__ import annotations
+
+from ..core import (
+    AseGraph,
+    GET_LOCAL_VAR_TYPE,
+    REGISTER_LOCAL_VAR_TYPE,
+    parse_get_local_var,
+    parse_register_local_var,
+)
+
+
+def append_local_var_issues(graph: AseGraph, issues: list[dict]) -> None:
+    nodes_by_id = {node.node_id: node for node in graph.nodes}
+    semantic_edges: list[tuple[str, str]] = []
+    registers = {}
+    for node in graph.nodes:
+        if node.type_name != REGISTER_LOCAL_VAR_TYPE:
+            continue
+        try:
+            item = parse_register_local_var(node)
+        except ValueError as exc:
+            issues.append(_issue("MALFORMED_LOCAL_VAR", node.node_id, str(exc)))
+            continue
+        registers[node.node_id] = item
+        if not item["name"].strip():
+            issues.append(_issue(
+                "EMPTY_LOCAL_VAR_NAME", node.node_id,
+                f"RegisterLocalVarNode {node.node_id} has an empty name",
+            ))
+        if not item["data_type"].strip():
+            issues.append(_issue(
+                "EMPTY_LOCAL_VAR_TYPE", node.node_id,
+                f"RegisterLocalVarNode {node.node_id} has an empty data type",
+            ))
+
+    for node in graph.nodes:
+        if node.type_name != GET_LOCAL_VAR_TYPE:
+            continue
+        try:
+            item = parse_get_local_var(node)
+        except ValueError as exc:
+            issues.append(_issue("MALFORMED_LOCAL_VAR", node.node_id, str(exc)))
+            continue
+        target = nodes_by_id.get(item["register_id"])
+        if target is None:
+            issues.append(_issue(
+                "DANGLING_LOCAL_VAR", node.node_id,
+                f"GetLocalVarNode {node.node_id} references missing Register node {item['register_id']}",
+            ))
+            continue
+        if target.type_name != REGISTER_LOCAL_VAR_TYPE:
+            issues.append(_issue(
+                "INVALID_LOCAL_VAR_TARGET", node.node_id,
+                f"GetLocalVarNode {node.node_id} references non-Register node {item['register_id']}",
+            ))
+            continue
+        register = registers.get(item["register_id"])
+        if register is None:
+            continue
+        semantic_edges.append((item["register_id"], node.node_id))
+        if item["name"] != register["name"]:
+            issues.append(_issue(
+                "LOCAL_VAR_NAME_MISMATCH", node.node_id,
+                f"GetLocalVarNode {node.node_id} name {item['name']!r} does not match "
+                f"Register {item['register_id']} name {register['name']!r}",
+            ))
+        if item["data_type"] != register["data_type"]:
+            issues.append(_issue(
+                "LOCAL_VAR_TYPE_MISMATCH", node.node_id,
+                f"GetLocalVarNode {node.node_id} type {item['data_type']!r} does not match "
+                f"Register {item['register_id']} type {register['data_type']!r}",
+            ))
+
+    _append_cycle_issues(graph, semantic_edges, issues)
+
+
+def _issue(code: str, node_id: str, message: str) -> dict:
+    return {"code": code, "severity": "error", "node_id": node_id, "message": message}
+
+
+def _append_cycle_issues(graph: AseGraph, semantic_edges: list[tuple[str, str]], issues: list[dict]) -> None:
+    adjacency: dict[str, set[str]] = {node.node_id: set() for node in graph.nodes}
+    for wire in graph.wires:
+        if wire.out_node in adjacency and wire.in_node in adjacency:
+            adjacency[wire.out_node].add(wire.in_node)
+    for source, target in semantic_edges:
+        adjacency[source].add(target)
+
+    index = 0
+    indices: dict[str, int] = {}
+    lowlinks: dict[str, int] = {}
+    stack: list[str] = []
+    on_stack: set[str] = set()
+    components: list[set[str]] = []
+
+    def visit(node_id: str) -> None:
+        nonlocal index
+        indices[node_id] = lowlinks[node_id] = index
+        index += 1
+        stack.append(node_id)
+        on_stack.add(node_id)
+        for target in adjacency[node_id]:
+            if target not in indices:
+                visit(target)
+                lowlinks[node_id] = min(lowlinks[node_id], lowlinks[target])
+            elif target in on_stack:
+                lowlinks[node_id] = min(lowlinks[node_id], indices[target])
+        if lowlinks[node_id] == indices[node_id]:
+            component = set()
+            while True:
+                member = stack.pop()
+                on_stack.remove(member)
+                component.add(member)
+                if member == node_id:
+                    break
+            components.append(component)
+
+    for node_id in adjacency:
+        if node_id not in indices:
+            visit(node_id)
+
+    semantic = set(semantic_edges)
+    for component in components:
+        cyclic = len(component) > 1 or any(node in adjacency[node] for node in component)
+        uses_local_var = any(source in component and target in component for source, target in semantic)
+        if cyclic and uses_local_var:
+            members = sorted(component, key=lambda value: (not value.lstrip("-").isdigit(), value))
+            issue = _issue(
+                "LOCAL_VAR_REFERENCE_CYCLE", members[0],
+                f"Local Var semantic references participate in a cycle: {', '.join(members)}",
+            )
+            issue["members"] = members
+            issues.append(issue)