Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -260,7 +260,7 @@ all_block_definitions = {
         "inputs": {"CONDITION": [2, None], "SUBSTACK": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
     },
     "control_if_else": {
-        "block_name": "if <> then else", "block_type": "Control", "block_shape": "C-Block", "op_code": "control_if_else",
+        "block_name": "if <> then go else", "block_type": "Control", "block_shape": "C-Block", "op_code": "control_if_else",
         "functionality": "Executes one set of blocks if the specified boolean condition is true, and a different set of blocks if the condition is false. [NOTE: it takes boolean blocks as input]",
         "inputs": {"CONDITION": [2, None], "SUBSTACK": [2, None], "SUBSTACK2": [2, None]}, "fields": {}, "shadow": False, "topLevel": True
     },
@@ -1863,11 +1863,13 @@ def classify(line):
 
     # Control Blocks
     # if re.match(r"wait (.+?) seconds", l): return "control_wait", "stack"
-    if re.match(r"wait\s+(\(?\[?.+?\]?\)?)\s*(sec(?:ond)?s?)?$", l): return "control_wait", "stack"
-    if l.startswith("wait until <"): return "control_wait_until", "stack"
+    # if re.match(r"wait\s+(\(?\[?.+?\]?\)?)\s*(sec(?:ond)?s?)?$", l): return "control_wait", "stack"
+    # if l.startswith("wait until <"): return "control_wait_until", "stack"
+    if re.match(r"wait\s+(?!until)(\(?\[?.+?\]?\)?)\s*(sec(?:ond)?s?)?$", l, re.IGNORECASE): return "control_wait", "stack"
+    if re.match(r"wait\s+until\s*<", l, re.IGNORECASE): return "control_wait_until", "stack"
     if l.startswith("repeat ("): return "control_repeat", "c_block"
     if l == "forever": return "control_forever", "c_block"
-    if l.startswith("if <") and " then else" in l: return "control_if_else", "c_block"
+    if l.startswith("if <") and " then go" in l: return "control_if_else", "c_block"
     if l.startswith("if <"): return "control_if", "c_block"
     if l.startswith("repeat until <"): return "control_repeat_until", "c_block"
     # Updated regex for stop block to handle different options
@@ -1924,38 +1926,26 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
     """
     Build a nested “plan” tree from:
       • generated_input: dict of block_key -> block_data (pre-generated block definitions)
-      • opcode_keys:    dict of opcode -> list of block_keys (in order)
-      • pseudo_code:    a multiline string, indented with two‑space levels
+      • opcode_keys:     dict of opcode -> list of block_keys (in order)
+      • pseudo_code:     a multiline string, indented with two-space levels
 
     Returns:
         { "flow": [ ... list of block dictionaries ... ] }
     """
-    # helper: pick next unused block_key for an opcode
     ptrs = defaultdict(int)
     def pick_key(opcode):
         lst = opcode_keys.get(opcode, [])
         idx = ptrs[opcode]
         if idx >= len(lst):
-            # Fallback: if no more pre-generated keys, create a new one.
-            # This should ideally not happen if initial_opcode_counts is comprehensive
             ptrs[opcode] += 1
             return f"{opcode}_{idx + 1}"
         ptrs[opcode] += 1
         return lst[idx]
 
-    all_generated_blocks = {} # This will store the final, structured blocks
-
-    # Populate all_generated_blocks with initial blocks, ensuring they have IDs
-    for key, block_data in generated_input.items():
-        all_generated_blocks[key] = copy.deepcopy(block_data)
-        all_generated_blocks[key]["id"] = key # Ensure ID is set
-
-    # Stack stores (indent, owner_block_id, last_block_in_current_linear_chain_id)
-    # owner_block_id: The ID of the C-block or Hat block that owns the current substack.
-    # last_block_in_current_linear_chain_id: The ID of the last block added to the *current linear sequence* within this substack.
-    stack = [(-2, None, None)] # Sentinel: (indent, owner_block_id, last_block_in_current_linear_chain_id)
-                               # Using -2 for initial indent to be less than any valid indent (0 or more)
+    # Change: Start with an empty dictionary. Blocks will be added only as they are parsed.
+    all_generated_blocks = {}
 
+    stack = [(-2, None, None)]
     top_level_script_keys = []
 
     lines = pseudo_code.splitlines()
@@ -1963,150 +1953,114 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
     while i < len(lines):
         raw_line = lines[i]
         stripped_line = raw_line.strip()
-        print("Stripped line here -----1---->", stripped_line)
-        # Skip empty lines and comments
+        
         if not stripped_line or stripped_line.startswith("//"):
             i += 1
             continue
 
         current_indent = (len(raw_line) - len(raw_line.lstrip())) // 2
 
-        # Handle 'else' and 'end' first, as they control scope
         if stripped_line.lower() == "else":
             # Pop the 'then' substack's scope
             popped_indent, popped_owner_key, popped_last_block_in_chain = stack.pop()
             if popped_last_block_in_chain:
                 all_generated_blocks[popped_last_block_in_chain]["next"] = None
 
-            # The 'if-else' block (popped_owner_key) is the owner.
-            # This 'else' must belong to the current owner on top of the stack (which should be the if-else block)
-            # Ensure the current_owner_block_id is indeed an if-else block
-            if popped_owner_key and all_generated_blocks[popped_owner_key]["op_code"] == "control_if_else":
+            # Check if the popped scope's owner is an IF block.
+            # This check now looks for any C-Block, which is correct for this context.
+            if popped_owner_key and all_generated_blocks[popped_owner_key]["block_shape"] == "C-Block":
+                
+                # This is the crucial step that fixes the issue.
+                # We explicitly upgrade the block from a 'control_if' to a 'control_if_else'.
+                owner_block = all_generated_blocks[popped_owner_key]
+                owner_block["op_code"] = "control_if_else"
+                
                 # Push a new scope for the 'else' substack, with the same owner.
-                stack.append((current_indent, popped_owner_key, None)) # New scope for 'else' part, no last block yet
+                stack.append((current_indent, popped_owner_key, None))
             else:
-                # Error: 'else' found without a preceding 'if' or incorrect nesting
+                # This is the error you were getting.
+                # It happens because the 'if' block was never correctly upgraded.
                 print(f"Error: 'else' found without a corresponding 'if-else' block at line {i+1}")
-                # Attempt to recover by treating it as a regular block or skipping
-                stack.append((popped_indent, popped_owner_key, popped_last_block_in_chain)) # Put back what was popped
+                stack.append((popped_indent, popped_owner_key, popped_last_block_in_chain))
             i += 1
             continue
 
         if stripped_line.lower() == "end":
-            # Pop the current substack's scope
             popped_indent, popped_owner_key, popped_last_block_in_chain = stack.pop()
             if popped_last_block_in_chain:
-                print("popped_last_block_in_chain is executed here")
                 all_generated_blocks[popped_last_block_in_chain]["next"] = None
             
-            # If the popped scope had an owner (C-block or procedure definition),
-            # and its substack input isn't already filled, set it to None (empty substack).
             if popped_owner_key:
                 owner_block = all_generated_blocks[popped_owner_key]
                 if owner_block["block_shape"] == "C-Block" or owner_block["op_code"] == "procedures_definition":
-                    # Determine which substack this 'end' is closing
-                    # This logic needs to be smarter for if-else
                     if owner_block["op_code"] == "control_if_else":
-                        # If we just popped the 'then' branch (SUBSTACK)
-                        # and SUBSTACK2 is not yet set, then this 'end' closes SUBSTACK.
-                        # If SUBSTACK2 was already set, this 'end' closes SUBSTACK2.
-                        # If neither is filled, it's an empty 'then' branch.
-                        if owner_block["inputs"].get("SUBSTACK") and owner_block["inputs"]["SUBSTACK"][1] is not None and \
-                           (not owner_block["inputs"].get("SUBSTACK2") or owner_block["inputs"]["SUBSTACK2"][1] is None):
-                            # This 'end' closes the first substack (then branch)
-                            pass # Already handled by the stack logic
-                        elif owner_block["inputs"].get("SUBSTACK2") and owner_block["inputs"]["SUBSTACK2"][1] is not None:
-                            # This 'end' closes the second substack (else branch)
-                            pass # Already handled by the stack logic
-                        else: # Neither substack was filled, meaning an empty 'then' branch
-                            # For now, ensure it's not set to a block ID if it was empty.
-                            if "SUBSTACK" in owner_block["inputs"] and owner_block["inputs"]["SUBSTACK"][1] is None:
-                                pass # Already None
-                            if "SUBSTACK2" in owner_block["inputs"] and owner_block["inputs"]["SUBSTACK2"][1] is None:
-                                pass # Already None
-                    elif owner_block["inputs"].get("SUBSTACK") and owner_block["inputs"]["SUBSTACK"][1] is None: # Only set if not already set by a block
-                        owner_block["inputs"]["SUBSTACK"] = [2, None] # No blocks in substack
+                        if owner_block["inputs"].get("SUBSTACK2") and owner_block["inputs"]["SUBSTACK2"][1] is not None:
+                            pass
+                        else:
+                            pass
+                    elif owner_block["inputs"].get("SUBSTACK") and owner_block["inputs"]["SUBSTACK"][1] is None:
+                        owner_block["inputs"]["SUBSTACK"] = [2, None]
             i += 1
             continue
 
-        # Adjust stack based on indentation for regular blocks
-        # Pop scopes whose indentation is greater than or equal to the current line's indentation
         while len(stack) > 1 and stack[-1][0] >= current_indent:
             popped_indent, popped_owner_key, popped_last_block_in_chain = stack.pop()
             if popped_last_block_in_chain:
-                all_generated_blocks[popped_last_block_in_chain]["next"] = None # Terminate the chain
+                all_generated_blocks[popped_last_block_in_chain]["next"] = None
 
-        # Get the current active scope from the stack
         current_scope_indent, current_owner_block_id, last_block_in_current_chain = stack[-1]
 
-        # Classify the statement and create the block
-        #stmt_for_parse = stripped_line.rstrip("then").strip()
-        stmt_for_parse = re.sub(r"\bthen\s*$", "", stripped_line, flags=re.IGNORECASE).strip()
-        print("befor the classify hit here: ",stmt_for_parse)
-        opcode, ntype = classify(stmt_for_parse)
-        print("the opcode classify: ",opcode)
-        if opcode is None: # Should not happen if classify is robust
+        opcode, ntype = classify(stripped_line)
+        stmt_for_parse = re.sub(r"\bthen(\s+go)?\s*$", "", stripped_line, flags=re.IGNORECASE).strip()
+        print("The opcode here is",opcode)
+        print("The ntype here is",ntype)
+        if opcode is None:
             i += 1
             continue
 
-        # Create the new block (and register it in all_generated_blocks)
-        # _register_block now only sets parent for shadow/input blocks; main block parent/next/topLevel set here.
         key = pick_key(opcode)
-        # Ensure the block exists in all_generated_blocks before trying to access it
+        
+        # Change: The code now relies on this check to create a block only if it's new.
         if key not in all_generated_blocks:
-            # If not pre-generated, create a basic entry. This is a fallback.
-            all_generated_blocks[key] = copy.deepcopy(all_block_definitions.get(opcode, {}))
+            all_generated_blocks[key] = copy.deepcopy(generated_input.get(key, all_block_definitions.get(opcode, {})))
             all_generated_blocks[key]["id"] = key
             all_generated_blocks[key]["inputs"] = all_generated_blocks[key].get("inputs", {})
             all_generated_blocks[key]["fields"] = all_generated_blocks[key].get("fields", {})
-            # Removed sub_stacks from here
 
         info = all_generated_blocks[key]
-
-        # Set parent, next, and topLevel for the main script blocks
+        
         if ntype == "hat":
             info["parent"] = None
             info["topLevel"] = True
             top_level_script_keys.append(key)
-            # Push a new scope for the children of this hat block.
-            stack.append((current_indent, key, None)) # New scope: owner is this hat, no last block yet
-        else: # Stack block or C-block (that is part of a linear sequence)
+            stack.append((current_indent, key, None))
+        else:
             if last_block_in_current_chain:
-                # This block's parent is the previous block in the chain
                 info["parent"] = last_block_in_current_chain
                 all_generated_blocks[last_block_in_current_chain]["next"] = key
             else:
-                # This is the first block in a new linear chain (e.g., first block inside a forever loop)
-                # Its parent is the owner of the current scope (the C-block or Hat block)
                 info["parent"] = current_owner_block_id
                 
-                # If the owner is a C-block or procedure definition, link its SUBSTACK input
                 if current_owner_block_id and (all_generated_blocks[current_owner_block_id]["block_shape"] == "C-Block" or all_generated_blocks[current_owner_block_id]["op_code"] == "procedures_definition"):
                     owner_block = all_generated_blocks[current_owner_block_id]
                     if owner_block["op_code"] == "control_if_else":
-                        # If SUBSTACK is already set, this means we are starting SUBSTACK2 (else part)
                         if owner_block["inputs"].get("SUBSTACK") and owner_block["inputs"]["SUBSTACK"][1] is not None and \
                            (not owner_block["inputs"].get("SUBSTACK2") or owner_block["inputs"]["SUBSTACK2"][1] is None):
                             owner_block["inputs"]["SUBSTACK2"] = [2, key]
-                        else: # This should be the first substack (then part)
+                        else:
                             owner_block["inputs"]["SUBSTACK"] = [2, key]
-                    elif not owner_block["inputs"].get("SUBSTACK") or owner_block["inputs"]["SUBSTACK"][1] is None: # Only set if not already set by a block
+                    elif not owner_block["inputs"].get("SUBSTACK") or owner_block["inputs"]["SUBSTACK"][1] is None:
                         owner_block["inputs"]["SUBSTACK"] = [2, key]
                 elif current_owner_block_id and all_generated_blocks[current_owner_block_id]["block_shape"] == "Hat Block":
-                    # If the owner is a Hat block, this is its first child
                     all_generated_blocks[current_owner_block_id]["next"] = key
             
             info["topLevel"] = False
-            info["next"] = None # Default, will be overwritten if there's a next block
+            info["next"] = None
 
-            # If it's a C-block or define block, it also starts a new inner scope
             if ntype == "c_block" or opcode == "procedures_definition":
-                # Update the current scope's last_block_in_current_chain to this C-block
                 stack[-1] = (current_scope_indent, current_owner_block_id, key)
-                # Push a new scope for the C-block's substack
-                stack.append((current_indent, key, None)) # New scope: owner is this C-block, no last block yet
+                stack.append((current_indent, key, None))
             else:
-                # For regular stack blocks, just update the last_block_in_current_chain for the current scope
                 stack[-1] = (current_scope_indent, current_owner_block_id, key)
 
         # Parse inputs and fields (this part remains largely the same, but ensure parse_reporter_or_value/parse_condition
@@ -2554,8 +2508,8 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
 
     # Initialize dictionaries to store and reuse generated unique IDs
     # This prevents creating multiple unique IDs for the same variable/broadcast across different blocks
-    variable_id_map = defaultdict(lambda: generate_secure_token())
-    broadcast_id_map = defaultdict(lambda: generate_secure_token())
+    variable_id_map = defaultdict(lambda: generate_secure_token(20))
+    broadcast_id_map = defaultdict(lambda: generate_secure_token(20))
 
     # Define the mapping for input field names to their required integer types for shadows
     input_type_mapping = {
@@ -2580,6 +2534,31 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
         "VALUE_STRING": 10 # Used internally for VALUE when it should be type 10
     }
 
+    # Explicit mapping of opcodes -> expected menu inputs that MUST be simple menu/shadow links ([1, block_id])
+    explicit_menu_links = {
+        "motion_goto": [("TO", "motion_goto_menu")],
+        "motion_glideto": [("TO", "motion_glideto_menu")],
+        "motion_pointtowards": [("TOWARDS", "motion_pointtowards_menu")],
+        "sensing_keypressed": [("KEY_OPTION", "sensing_keyoptions")],
+        "sensing_of": [("OBJECT", "sensing_of_object_menu")],
+        "sensing_touchingobject": [("TOUCHINGOBJECTMENU", "sensing_touchingobjectmenu")],
+        "control_create_clone_of": [("CLONE_OPTION", "control_create_clone_of_menu")],
+        "sound_play": [("SOUND_MENU", "sound_sounds_menu")],
+        "sound_playuntildone": [("SOUND_MENU", "sound_sounds_menu")],
+        "looks_switchcostumeto": [("COSTUME", "looks_costume")],
+        "looks_switchbackdropto": [("BACKDROP", "looks_backdrops")],
+    }
+
+    # helper to check if this opcode+input_name is an explicit menu link
+    def is_explicit_menu_opcode_input(opcode, input_name):
+        if not opcode:
+            return False
+        pairs = explicit_menu_links.get(opcode, [])
+        for inp, _menu in pairs:
+            if inp == input_name:
+                return True
+        return False
+
     for block_id, gen_block_data in generated_output_json.items():
         processed_block = {}
         all_gen_block_data = all_generated_blocks.get(block_id, {})
@@ -2595,13 +2574,14 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
         if "mutation" in all_gen_block_data:
             processed_block["mutation"] = all_gen_block_data["mutation"]
 
+        opcode = processed_block["opcode"]  # convenience
+
         # Process inputs
         if "inputs" in all_gen_block_data:
             for input_name, input_data in all_gen_block_data["inputs"].items():
+                # --- BROADCAST INPUT special handling (type 11) ---
                 if input_name == "BROADCAST_INPUT":
-                    # Special handling for BROADCAST_INPUT (type 11)
                     if isinstance(input_data, dict) and input_data.get("kind") == "value":
-                        # This is the new logic to handle a direct value for broadcast
                         menu_option = input_data.get("value", "message1")
                         broadcast_id = broadcast_id_map[menu_option]
                         processed_block["inputs"][input_name] = [
@@ -2613,23 +2593,26 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                             ]
                         ]
                     elif isinstance(input_data, list) and len(input_data) == 2 and isinstance(input_data[1], list) and len(input_data[1]) == 3 and input_data[1][0] == 11:
-                        # Preserve existing well-formed type 11 structure
+                        # Preserve well-formed existing type 11 structure
                         processed_block["inputs"][input_name] = input_data
                     else:
-                        # Fallback for unexpected formats, try to use the original if possible
-                        processed_block["inputs"][input_name] = gen_block_data["inputs"].get(input_name, [1, [11, "message1", generate_secure_token()]])
-
-                elif isinstance(input_data, dict):
-                    if input_data.get("kind") == "value":
+                        # Fallback: try original generated_output_json value if present, else synthesize
+                        fallback = gen_block_data.get("inputs", {}).get(input_name,
+                                                                       [1, [11, "message1", generate_secure_token(20)]])
+                        processed_block["inputs"][input_name] = fallback
+                    continue
+
+                # --- Input described as a dict (value, block, menu) ---
+                if isinstance(input_data, dict):
+                    kind = input_data.get("kind")
+                    if kind == "value":
                         # Determine the correct shadow type based on the input_name and opcode
-                        shadow_type = input_type_mapping.get(input_name, 4) # Default to 4
-                        
-                        # Specific override for "NUM" in "looks_goforwardbackwardlayers"
-                        if input_name == "NUM" and processed_block["opcode"] == "looks_goforwardbackwardlayers":
+                        shadow_type = input_type_mapping.get(input_name, 4)  # default 4
+
+                        # Specific overrides
+                        if input_name == "NUM" and opcode == "looks_goforwardbackwardlayers":
                             shadow_type = 7
-                        
-                        # Specific override for "VALUE" in "data_setvariableto"
-                        if input_name == "VALUE" and processed_block["opcode"] == "data_setvariableto":
+                        if input_name == "VALUE" and opcode == "data_setvariableto":
                             shadow_type = 10
 
                         processed_block["inputs"][input_name] = [
@@ -2639,119 +2622,142 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                                 str(input_data.get("value", ""))
                             ]
                         ]
-                    elif input_data.get("kind") == "block":
-                        # Case 3: Nested block input
+                        continue
+
+                    if kind == "block":
+                        # nested block reference via dict
                         nested_block_id = input_data.get("block", "")
-                        
                         if nested_block_id in all_generated_blocks:
+                            # If this opcode+input_name is explicitly a menu -> force [1, nested_block_id]
+                            if is_explicit_menu_opcode_input(opcode, input_name):
+                                processed_block["inputs"][input_name] = [1, nested_block_id]
+                                continue
+
                             nested_block_opcode = all_generated_blocks[nested_block_id].get("op_code")
-                            
+
                             if input_name in ["SUBSTACK", "CONDITION", "SUBSTACK2"]:
-                                # These are control flow blocks, should always be type 2
                                 processed_block["inputs"][input_name] = [2, nested_block_id]
                             elif nested_block_opcode in ["data_variable", "data_listcontents"]:
-                                # It's a variable/list reporter, should be type 12 inside type 1
+                                # variable/list reporter inside a reporter -> [1, [12, name, id]]
                                 variable_name = all_generated_blocks[nested_block_id].get("fields", {}).get("VARIABLE", ["", ""])[0]
                                 variable_id = all_generated_blocks[nested_block_id].get("fields", {}).get("VARIABLE", ["", ""])[1]
                                 if not variable_id:
                                     variable_id = variable_id_map[variable_name]
                                 processed_block["inputs"][input_name] = [1, [12, variable_name, variable_id]]
                             elif input_name in ["TOUCHINGOBJECTMENU", "TO", "TOWARDS", "CLONE_OPTION", "SOUND_MENU", "KEY_OPTION", "OBJECT"]:
-                                # These are menu/dropdown inputs that refer to another block/menu,
-                                # and should be type 1, referring to a shadow block.
+                                # menu/dropdown inputs that refer to another block/menu -> type 1, refer to block id
                                 processed_block["inputs"][input_name] = [1, nested_block_id]
                             else:
-                                # For other reporter blocks (like motion_xposition, operators),
-                                # they should be type 3 when nested.
-                                shadow_type_for_nested = input_type_mapping.get(input_name, 10) # Default to 10 for nested shadows
-                                processed_block["inputs"][input_name] = [3, nested_block_id, [shadow_type_for_nested, ""]] # Empty shadow value
+                                # other reporter blocks (like motion_xposition, operators) -> nested type 3
+                                shadow_type_for_nested = input_type_mapping.get(input_name, 10)
+                                processed_block["inputs"][input_name] = [3, nested_block_id, [shadow_type_for_nested, ""]]
                         else:
-                            # If the referenced block doesn't exist, treat as a broken reference for now
-                            # or try to use original if available.
-                            processed_block["inputs"][input_name] = gen_block_data["inputs"].get(input_name, [3, nested_block_id, [10, ""]]) # Fallback
-
-                    elif input_data.get("kind") == "menu":
-                        # This handles menu inputs from all_gen_block_data that are not BROADCAST_INPUT
-                        menu_option = input_data.get("option", "")
-                        # These should typically be type 1 referring to a shadow block, or a direct value if no shadow block
-                        # For simplicity, we'll try to get the block ID if it's a menu block.
+                            # referenced block missing: fallback to original input format if available, else a safe fallback
+                            processed_block["inputs"][input_name] = gen_block_data.get("inputs", {}).get(input_name, [3, nested_block_id, [10, ""]])
+                        continue
+
+                    if kind == "menu":
+                        # menu kind: either references a block or a direct value
                         if "block" in input_data:
-                            processed_block["inputs"][input_name] = [1, input_data["block"]]
+                            # If explicit menu, ensure we store as [1, block_id]
+                            if is_explicit_menu_opcode_input(opcode, input_name):
+                                processed_block["inputs"][input_name] = [1, input_data["block"]]
+                            else:
+                                processed_block["inputs"][input_name] = [1, input_data["block"]]
                         else:
-                            # If it's a menu without a block reference, it might be a direct value in a shadow.
-                            # This case is less common for menu 'kind'.
-                            processed_block["inputs"][input_name] = [1, [10, menu_option]] # Default to type 10 for string menu options
-
-
-                elif isinstance(input_data, list):
-                    # This branch handles existing list structures from all_gen_block_data (or generated_output_json if no all_gen_block_data)
-                    # It needs to decide if it's a direct value, a block reference, or a special type (11, 12)
+                            # direct value in menu -> type 1 with a string shadow (type 10)
+                            menu_option = input_data.get("option", "")
+                            processed_block["inputs"][input_name] = [1, [10, menu_option]]
+                        continue
 
+                # --- Input is a list already (various formats) ---
+                if isinstance(input_data, list):
+                    # Common shapes:
+                    # [1, <value shadow>], [1, <block_id>], [3, <block_id>, [shadow_type, value]], etc.
                     if len(input_data) == 2:
                         first_val = input_data[0]
                         second_val = input_data[1]
 
+                        # If the second element is a block id that exists
                         if isinstance(second_val, str) and second_val in all_generated_blocks:
-                            # The second element is a block ID
+                            # If explicit menu mapping -> force [1, block_id]
+                            if is_explicit_menu_opcode_input(opcode, input_name):
+                                processed_block["inputs"][input_name] = [1, second_val]
+                                continue
+
                             nested_block_opcode = all_generated_blocks[second_val].get("op_code")
 
                             if input_name in ["SUBSTACK", "CONDITION", "SUBSTACK2"]:
-                                # These are control flow blocks, should always be type 2
                                 processed_block["inputs"][input_name] = [2, second_val]
                             elif nested_block_opcode in ["data_variable", "data_listcontents"]:
-                                # It's a variable/list reporter, should be type 12 inside type 1
                                 variable_name = all_generated_blocks[second_val].get("fields", {}).get("VARIABLE", ["", ""])[0]
                                 variable_id = all_generated_blocks[second_val].get("fields", {}).get("VARIABLE", ["", ""])[1]
                                 if not variable_id:
                                     variable_id = variable_id_map[variable_name]
                                 processed_block["inputs"][input_name] = [1, [12, variable_name, variable_id]]
                             elif input_name in ["TOUCHINGOBJECTMENU", "TO", "TOWARDS", "CLONE_OPTION", "SOUND_MENU", "KEY_OPTION", "OBJECT"]:
-                                # These are menu/dropdown inputs that refer to another block/menu,
-                                # and should be type 1, referring to a shadow block.
                                 processed_block["inputs"][input_name] = [1, second_val]
                             else:
-                                # For other reporter blocks (like motion_xposition, operators),
-                                # they should be type 3 when nested. Correct the first_val if it's not 3.
                                 shadow_type_for_nested = input_type_mapping.get(input_name, 10)
+                                # Ensure nested reporters use type 3
                                 processed_block["inputs"][input_name] = [3, second_val, [shadow_type_for_nested, ""]]
+                            continue
 
-                        elif isinstance(second_val, str):
-                            # It's a value literal (e.g., "-240") that needs wrapping with a shadow type
-                            shadow_type = input_type_mapping.get(input_name, 4) # Default to 4
-                            if input_name == "NUM" and processed_block["opcode"] == "looks_goforwardbackwardlayers":
+                        # If the second element is a string literal value -> wrap with appropriate shadow type
+                        if isinstance(second_val, str):
+                            shadow_type = input_type_mapping.get(input_name, 4)  # default 4
+                            if input_name == "NUM" and opcode == "looks_goforwardbackwardlayers":
                                 shadow_type = 7
-                            if input_name == "VALUE" and processed_block["opcode"] == "data_setvariableto":
+                            if input_name == "VALUE" and opcode == "data_setvariableto":
                                 shadow_type = 10
                             processed_block["inputs"][input_name] = [1, [shadow_type, str(second_val)]]
-                        else:
-                            # Fallback for other 2-element lists (e.g., [1, [11, ...]]), copy as is
-                            processed_block["inputs"][input_name] = input_data
+                            continue
+
+                        # fallback: preserve the input as-is
+                        processed_block["inputs"][input_name] = input_data
+                        continue
 
                     elif len(input_data) == 3 and isinstance(input_data[1], str) and isinstance(input_data[2], list):
-                        # Case: [3, "block_id", [shadow_type, shadow_value]] - an already well-formed nested block
-                        # or [1, "block_id", [shadow_type, shadow_value]] - an existing shadow for a direct value
-                        # Preserve these if they conform to the rules, otherwise correct shadow type
-                        if input_data[0] == 3 and input_data[1] in all_generated_blocks:
-                            # This is a valid type 3 nested block, keep it as is
-                            processed_block["inputs"][input_name] = input_data
-                        elif input_data[0] == 1 and isinstance(input_data[1], list) and input_data[1][0] in [11, 12]:
-                            # This is a type 11 or 12 structure, preserve it
-                            processed_block["inputs"][input_name] = input_data
-                        elif input_data[0] == 1 and isinstance(input_data[1], list) and len(input_data[1]) == 2:
-                            # This is a type 1 with a shadow, re-evaluate shadow type
-                            shadow_type = input_type_mapping.get(input_name, 4)
-                            if input_name == "NUM" and processed_block["opcode"] == "looks_goforwardbackwardlayers":
-                                shadow_type = 7
-                            if input_name == "VALUE" and processed_block["opcode"] == "data_setvariableto":
-                                shadow_type = 10
-                            processed_block["inputs"][input_name] = [input_data[0], [shadow_type, str(input_data[1][1])]]
-                        else:
-                            # Fallback for other 3-element lists, copy as is
-                            processed_block["inputs"][input_name] = input_data
+                        # case: [3, "block_id", [shadow_type, shadow_value]] or
+                        #       [1, "block_id", [shadow_type, shadow_value]] (rare)
+                        block_ref = input_data[1]
+                        if block_ref in all_generated_blocks:
+                            # If explicit menu mapping -> convert to [1, block_id]
+                            if is_explicit_menu_opcode_input(opcode, input_name):
+                                processed_block["inputs"][input_name] = [1, block_ref]
+                                continue
+
+                            # keep already well-formed nested reporter [3, ...]
+                            if input_data[0] == 3:
+                                processed_block["inputs"][input_name] = input_data
+                                continue
+
+                            # If it's a type 1 with a type shadow like [1, [11,...]] or [1, [12,...]] -> preserve
+                            if input_data[0] == 1 and isinstance(input_data[1], list) and input_data[1][0] in [11, 12]:
+                                processed_block["inputs"][input_name] = input_data
+                                continue
+
+                            # if it's [1, [shadow_type, value]] then re-evaluate shadow type
+                            if input_data[0] == 1 and isinstance(input_data[1], list) and len(input_data[1]) == 2:
+                                shadow_type = input_type_mapping.get(input_name, 4)
+                                if input_name == "NUM" and opcode == "looks_goforwardbackwardlayers":
+                                    shadow_type = 7
+                                if input_name == "VALUE" and opcode == "data_setvariableto":
+                                    shadow_type = 10
+                                processed_block["inputs"][input_name] = [input_data[0], [shadow_type, str(input_data[1][1])]]
+                                continue
+
+                        # fallback: preserve the list as-is
+                        processed_block["inputs"][input_name] = input_data
+                        continue
+
                     else:
-                        # Fallback for any other unexpected list formats, copy as is
+                        # other unexpected list shapes -> preserve for now
                         processed_block["inputs"][input_name] = input_data
+                        continue
 
+                # If input_data didn't match any of the above -> try to fallback to original generated value if available
+                processed_block["inputs"][input_name] = gen_block_data.get("inputs", {}).get(input_name, input_data)
 
         # Process fields
         if "fields" in all_gen_block_data:
@@ -2797,7 +2803,7 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                     
                     # Check if TOUCHINGOBJECTMENU input exists and is a block reference
                     referenced_block_id = None
-                    if "TOUCHINGOBJECTMENU" in all_gen_block_data["inputs"]:
+                    if "TOUCHINGOBJECTMENU" in all_gen_block_data.get("inputs", {}):
                         input_val = all_gen_block_data["inputs"]["TOUCHINGOBJECTMENU"]
                         if isinstance(input_val, list) and len(input_val) > 1 and isinstance(input_val[1], str):
                             referenced_block_id = input_val[1]
@@ -2815,7 +2821,7 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                 else:
                     processed_block["fields"][field_name] = field_value
         
-        # Remove unwanted keys from the processed block
+        # Remove unwanted keys from the processed block (if somehow present)
         keys_to_remove = ["functionality", "block_shape", "id", "block_name", "block_type"]
         for key in keys_to_remove:
             if key in processed_block:
@@ -2883,53 +2889,7 @@ def rename_blocks(block_json: Dict[str, Any], opcode_count: Dict[str, list]) ->
         new_opcode_count[opcode] = [token_map.get(k, k) for k in key_list]
         
     return new_block_json, new_opcode_count
-    """
-    Replace each block key in block_json and each identifier in opcode_count
-    with a newly generated secure token.
-
-    Args:
-        block_json: Mapping of block_key -> block_data.
-        opcode_count: Mapping of opcode -> list of block_keys.
-
-    Returns:
-        A tuple of (new_block_json, new_opcode_count) with updated keys.
-    """
-    # Step 1: Generate a secure token mapping for every existing block key
-    token_map = {}
-    for old_key in block_json.keys():
-        # Ensure uniqueness in the unlikely event of a collision
-        while True:
-            new_key = generate_secure_token()
-            if new_key not in token_map.values():
-                break
-        token_map[old_key] = new_key
-
-    # Step 2: Rebuild block_json with new keys
-    new_block_json = {}
-    for old_key, block in block_json.items():
-        new_key = token_map[old_key]
-        new_block_json[new_key] = block.copy()
-
-        # Update parent and next references
-        if 'parent' in block and block['parent'] in token_map:
-            new_block_json[new_key]['parent'] = token_map[block['parent']]
-        if 'next' in block and block['next'] in token_map:
-            new_block_json[new_key]['next'] = token_map[block['next']]
-
-        # Update inputs if they reference blocks
-        for inp_key, inp_val in block.get('inputs', {}).items():
-            if isinstance(inp_val, list) and len(inp_val) == 2:
-                idx, ref = inp_val
-                if idx in (2, 3) and isinstance(ref, str) and ref in token_map:
-                    new_block_json[new_key]['inputs'][inp_key] = [idx, token_map[ref]]
-
-    # Step 3: Update opcode count map
-    new_opcode_count = {}
-    for opcode, key_list in opcode_count.items():
-        new_opcode_count[opcode] = [token_map.get(k, k) for k in key_list]
-
-    return new_block_json, new_opcode_count
-
+  
 #################################################################################################################################################################
 #--------------------------------------------------[Helper function to add Variables and Broadcasts [USed in main app file for main projectjson]]----------------
 #################################################################################################################################################################