--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/foosdk/sdk/pfc/weakRef.h	Mon Jan 05 02:15:46 2026 -0500
@@ -0,0 +1,71 @@
+#pragma once
+
+// PFC weakRef class
+// Create weak references to objects that automatically become invalidated upon destruction of the object
+// Note that this is NOT thread safe and meant for single thread usage. If you require thread safety, provide your own means, such as mutexlocking of weakRef::get() and the destruction of your objects.
+
+#include <memory> // std::shared_ptr
+
+namespace pfc {
+	typedef std::shared_ptr<const bool> weakRefKillSwitch_t;
+
+	template<typename target_t>
+	class weakRef {
+		typedef weakRef<target_t> self_t;
+	public:
+		static self_t _make(target_t * target, weakRefKillSwitch_t ks) {
+			self_t ret;
+			ret.m_target = target;
+			ret.m_ks = ks;
+			return ret;
+		}
+
+
+		bool isValid() const {
+			return m_ks && !*m_ks;
+		}
+
+		target_t * get() const {
+			if (!isValid()) return nullptr;
+			return m_target;
+		}
+		target_t * operator() () const {
+			return get();
+		}
+	private:
+		target_t * m_target = nullptr;
+		weakRefKillSwitch_t m_ks;
+	};
+
+	template<typename class_t>
+	class weakRefTarget {
+	public:
+		weakRefTarget() {}
+
+		typedef weakRef<class_t> weakRef_t;
+
+		weakRef<class_t> weakRef() {
+			PFC_ASSERT(!*m_ks);
+			class_t * ptr = static_cast<class_t*>(this);
+			return weakRef_t::_make(ptr, m_ks);
+		}
+
+		// Optional: explicitly invalidates all weak references to this object. Called implicitly by the destructor, but you can do it yourself earlier.
+		void weakRefShutdown() {
+			*m_ks = true;
+		}
+		~weakRefTarget() {
+			weakRefShutdown();
+		}
+
+		// Optional: obtain a reference to the killswitch if you wish to use it directly
+		weakRefKillSwitch_t weakRefKS() const {
+			return m_ks;
+		}
+	private:
+		std::shared_ptr<bool> m_ks = std::make_shared<bool>(false);
+
+		weakRefTarget(const weakRefTarget &) = delete;
+		void operator=(const weakRefTarget &) = delete;
+	};
+}