packaging: Add .vpe packaging for visual scripting gamelogic.

Implement IPackable on VisualScriptingGamelogicEngine so its
variable/event/display declarations and switch/coil/lamp/wire
definitions round-trip through .vpe packages. Add a separate
VisualScriptingGraphPackager that captures ScriptMachine/StateMachine
components, Variables components, and the transitive closure of
ScriptGraphAsset/StateGraphAsset they reference, remapping object
references to stable ids so cross-graph links survive the round trip.
Runtime-created graph assets are tracked and destroyed with the engine.

Author: freezy

Runtime/Gamelogic/VisualScriptingGamelogicEngine.cs

@@ -27,11 +27,13 @@
 
 namespace VisualPinball.Unity.VisualScripting
 {
+	[PackAs("VisualScriptingGameLogic")]
 	[DisallowMultipleComponent]
 	[AddComponentMenu("Pinball/Gamelogic Engine/Visual Scripting Game Logic")]
-	public class VisualScriptingGamelogicEngine : MonoBehaviour, IGamelogicEngine, ISerializationCallbackReceiver
+	public class VisualScriptingGamelogicEngine : MonoBehaviour, IGamelogicEngine, IGamelogicInputThreading, ISerializationCallbackReceiver, IPackable
 	{
 		public string Name => "Visual Scripting Gamelogic Engine";
+		public GamelogicInputDispatchMode SwitchDispatchMode => GamelogicInputDispatchMode.MainThread;
 
 		[Tooltip("Define here the global variables of the Visual Scripting engine.")]
 		public List<TableVariableDefinition> TableVariableDefinitions;
@@ -251,5 +253,40 @@ public void OnBeforeSerialize()
 		public void OnAfterDeserialize()
 		{
 		}
+
+		#region Packaging
+
+		// Graph assets recreated at runtime when unpacking a .vpe table. They are plain in-memory
+		// ScriptableObjects, so the table owns their lifetime and destroys them on teardown.
+		[NonSerialized] private List<ScriptableObject> _runtimeGraphAssets;
+
+		public byte[] Pack() => VisualScriptingGamelogicEnginePackable.Pack(this);
+
+		public byte[] PackReferences(Transform root, PackagedRefs refs, PackagedFiles files)
+			=> VisualScriptingGraphPackager.Pack(root, refs);
+
+		public void Unpack(byte[] bytes) => VisualScriptingGamelogicEnginePackable.Unpack(bytes, this);
+
+		public void UnpackReferences(byte[] bytes, Transform root, PackagedRefs refs, PackagedFiles files)
+			=> _runtimeGraphAssets = VisualScriptingGraphPackager.Unpack(bytes, root, refs);
+
+		private void OnDestroy()
+		{
+			if (_runtimeGraphAssets == null) {
+				return;
+			}
+			foreach (var asset in _runtimeGraphAssets) {
+				if (asset != null) {
+					if (Application.isPlaying) {
+						Destroy(asset);
+					} else {
+						DestroyImmediate(asset);
+					}
+				}
+			}
+			_runtimeGraphAssets = null;
+		}
+
+		#endregion
 	}
 }

Runtime/Packaging/VisualScriptingGamelogicEnginePackable.cs

@@ -0,0 +1,72 @@
+// Visual Pinball Engine
+// Copyright (C) 2026 freezy and VPE Team
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+// ReSharper disable InconsistentNaming
+
+using System;
+using System.Collections.Generic;
+using VisualPinball.Engine.Game.Engines;
+
+namespace VisualPinball.Unity.VisualScripting
+{
+	/// <summary>
+	/// The serializable configuration of the <see cref="VisualScriptingGamelogicEngine"/>: the
+	/// variable, event and display declarations as well as the switch/coil/lamp/wire definitions
+	/// the visual scripts address by id.
+	///
+	/// This is the <see cref="IPackable.Pack"/> payload. The actual visual scripting graphs (the
+	/// <c>ScriptMachine</c>/<c>StateMachine</c> components and their graph assets) are packaged
+	/// separately as references, see <see cref="VisualScriptingGraphPackager"/>.
+	/// </summary>
+	public struct VisualScriptingGamelogicEnginePackable
+	{
+		public List<TableVariableDefinition> TableVariableDefinitions;
+		public List<PlayerVariableDefinition> PlayerVariableDefinitions;
+		public List<EventDefinition> EventDefinitions;
+		public DisplayDefinition[] Displays;
+		public VisualScriptingSwitch[] Switches;
+		public VisualScriptingCoil[] Coils;
+		public VisualScriptingLamp[] Lamps;
+		public GamelogicEngineWire[] Wires;
+
+		public static byte[] Pack(VisualScriptingGamelogicEngine gle)
+		{
+			return PackageApi.Packer.Pack(new VisualScriptingGamelogicEnginePackable {
+				TableVariableDefinitions = gle.TableVariableDefinitions,
+				PlayerVariableDefinitions = gle.PlayerVariableDefinitions,
+				EventDefinitions = gle.EventDefinitions,
+				Displays = gle.Displays,
+				Switches = gle.Switches,
+				Coils = gle.Coils,
+				Lamps = gle.Lamps,
+				Wires = gle.Wires,
+			});
+		}
+
+		public static void Unpack(byte[] bytes, VisualScriptingGamelogicEngine gle)
+		{
+			var data = PackageApi.Packer.Unpack<VisualScriptingGamelogicEnginePackable>(bytes);
+			gle.TableVariableDefinitions = data.TableVariableDefinitions ?? new List<TableVariableDefinition>();
+			gle.PlayerVariableDefinitions = data.PlayerVariableDefinitions ?? new List<PlayerVariableDefinition>();
+			gle.EventDefinitions = data.EventDefinitions ?? new List<EventDefinition>();
+			gle.Displays = data.Displays ?? Array.Empty<DisplayDefinition>();
+			gle.Switches = data.Switches ?? Array.Empty<VisualScriptingSwitch>();
+			gle.Coils = data.Coils ?? Array.Empty<VisualScriptingCoil>();
+			gle.Lamps = data.Lamps ?? Array.Empty<VisualScriptingLamp>();
+			gle.Wires = data.Wires ?? Array.Empty<GamelogicEngineWire>();
+		}
+	}
+}