diff --git a/src/client/spark_websocket/Core/WebsocketConnectNotification.cs b/src/client/spark_websocket/Core/WebsocketConnectNotification.cs
new file mode 100644
index 000000000..d73c4c448
--- /dev/null
+++ b/src/client/spark_websocket/Core/WebsocketConnectNotification.cs
@@ -0,0 +1,14 @@
+namespace Bts.Websocket;
+
+using bts.websocket_core;
+
+public class WebsocketConnectNotification {
+ public WebsocketConnectNotification(
+ WebsocketClientID id, WebsocketIncomingMessage? message = null) {
+ Id = id;
+ Message = message;
+ }
+
+ public WebsocketClientID Id { get; }
+ public WebsocketIncomingMessage? Message { get; }
+}
diff --git a/src/client/spark_websocket/Core/WebsocketConnectionUpdate.cs b/src/client/spark_websocket/Core/WebsocketConnectionUpdate.cs
new file mode 100644
index 000000000..6951a6eda
--- /dev/null
+++ b/src/client/spark_websocket/Core/WebsocketConnectionUpdate.cs
@@ -0,0 +1,73 @@
+namespace Bts.Websocket;
+
+using bts.websocket_core;
+
+public class WebsocketConnectionUpdate {
+ readonly WebsocketClientID? connection;
+ readonly WebsocketIncomingMessage? incomingMessage;
+ readonly WebsocketOutgoingMessage? outgoingMessage;
+ readonly WebsocketConnectNotification? connect;
+ readonly WebsocketDisconnectNotification? disconnect;
+
+ WebsocketConnectionUpdate(
+ WebsocketClientID connection,
+ WebsocketIncomingMessage? incomingMessage = null,
+ WebsocketOutgoingMessage? outgoingMessage = null,
+ WebsocketConnectNotification? connect = null,
+ WebsocketDisconnectNotification? disconnect = null) {
+ this.connection = connection;
+ this.incomingMessage = incomingMessage;
+ this.outgoingMessage = outgoingMessage;
+ this.connect = connect;
+ this.disconnect = disconnect;
+ }
+
+ public static WebsocketConnectionUpdate Create(
+ WebsocketClientID connection, WebsocketConnectNotification connect) =>
+ new(connection, connect: connect);
+
+ public static WebsocketConnectionUpdate Create(
+ WebsocketClientID connection, WebsocketDisconnectNotification disconnect) =>
+ new(connection, disconnect: disconnect);
+
+ public static WebsocketConnectionUpdate Create(
+ WebsocketClientID connection, WebsocketIncomingMessage incomingMessage) =>
+ new(connection, incomingMessage: incomingMessage);
+
+ public static WebsocketConnectionUpdate Create(
+ WebsocketClientID connection, WebsocketOutgoingMessage outgoingMessage) =>
+ new(connection, outgoingMessage: outgoingMessage);
+
+ public WebsocketClientID Connection =>
+ connection ?? throw new InvalidOperationException();
+
+ public WebsocketConnectionUpdateType Type {
+ get {
+ if (incomingMessage is not null) {
+ return WebsocketConnectionUpdateType.IncomingMessage;
+ }
+ if (outgoingMessage is not null) {
+ return WebsocketConnectionUpdateType.OutgoingMessage;
+ }
+ if (connect is not null) {
+ return WebsocketConnectionUpdateType.Connect;
+ }
+ if (disconnect is not null) {
+ return WebsocketConnectionUpdateType.Disconnect;
+ }
+ return WebsocketConnectionUpdateType.Unspecified;
+ }
+ }
+
+ public WebsocketIncomingMessage IncomingMessage =>
+ incomingMessage ?? throw new InvalidOperationException();
+
+ public WebsocketOutgoingMessage OutgoingMessage =>
+ outgoingMessage ?? throw new InvalidOperationException();
+
+ public WebsocketConnectNotification Connect =>
+ connect ?? throw new InvalidOperationException();
+
+ public WebsocketDisconnectNotification Disconnect =>
+ disconnect ?? throw new InvalidOperationException();
+}
diff --git a/src/client/spark_websocket/Core/WebsocketConnectionUpdateType.cs b/src/client/spark_websocket/Core/WebsocketConnectionUpdateType.cs
new file mode 100644
index 000000000..6de37b1b7
--- /dev/null
+++ b/src/client/spark_websocket/Core/WebsocketConnectionUpdateType.cs
@@ -0,0 +1,9 @@
+namespace Bts.Websocket;
+
+public enum WebsocketConnectionUpdateType {
+ Unspecified,
+ Connect,
+ IncomingMessage,
+ OutgoingMessage,
+ Disconnect
+};
diff --git a/src/client/spark_websocket/Core/WebsocketDisconnectNotification.cs b/src/client/spark_websocket/Core/WebsocketDisconnectNotification.cs
new file mode 100644
index 000000000..a6b93ae24
--- /dev/null
+++ b/src/client/spark_websocket/Core/WebsocketDisconnectNotification.cs
@@ -0,0 +1,10 @@
+namespace Bts.Websocket;
+
+using bts.websocket_core;
+
+public class WebsocketDisconnectNotification {
+ public WebsocketDisconnectNotification(WebsocketClientID id) =>
+ Id = id;
+
+ public WebsocketClientID Id { get; }
+}
diff --git a/src/client/spark_websocket/Core/WebsocketGatewayObservable.cs b/src/client/spark_websocket/Core/WebsocketGatewayObservable.cs
new file mode 100644
index 000000000..464acd87a
--- /dev/null
+++ b/src/client/spark_websocket/Core/WebsocketGatewayObservable.cs
@@ -0,0 +1,108 @@
+namespace Bts.Websocket;
+
+using bts;
+using bts.websocket_core;
+
+using mbts;
+
+using System;
+using System.Reactive.Subjects;
+
+///
+/// Represents an I/O model that provides websocket requests from clients as output, and accepts
+/// data/notifications to send back to the clients as input. This class doesn't interpret clients'
+/// requests; it doesn't subscribe to data on their behalf. It emits those requests as output so
+/// someone else can.
+///
+public class WebsocketGatewayObservable : IConnectableObservable, ISubject, WebsocketConnectionUpdate>, IDisposable {
+ readonly WebsocketServerConfig config;
+ readonly object lockObj = new();
+ IWebsocketConnectionGateway? gatewayBacking;
+
+ public WebsocketGatewayObservable(WebsocketServerConfig config)
+ : this(new WebsocketConnectionGateway(), config) { }
+
+ public WebsocketGatewayObservable(
+ IWebsocketConnectionGateway gateway, WebsocketServerConfig config) {
+ gatewayBacking = gateway;
+ this.config = config;
+ }
+
+ IWebsocketConnectionGateway gateway =>
+ /// The gateway is (only) set to null in
+ gatewayBacking ?? throw new ObjectDisposedException($"{GetType()}");
+
+ public IDisposable Connect() {
+ IWebsocketConnectionGateway? gw;
+ lock (lockObj) {
+ gw = gateway;
+ ConnectAsync().ignore();
+ return this;
+ }
+ }
+
+ public async Task ConnectAsync() {
+ var gw = gateway;
+ try {
+ await gw.start_listening(config);
+ } catch (Exception ex) {
+ Log.Api.error($"Error running {typeof(IWebsocketConnectionGateway)}: {ex}");
+ throw;
+ }
+ }
+
+ public void OnCompleted() =>
+ Log.Api.warn($"{GetType()} outgoing message stream completed.");
+
+ public void OnError(Exception error) =>
+ Log.Api.error($"{GetType()} detected error in outgoing message stream: {error}");
+
+ public void OnNext(IEnumerable outMessages) =>
+ gateway.send_to_clients(outMessages);
+
+ public IDisposable Subscribe(IObserver observer) {
+ lock (lockObj) {
+ return new Subscription(observer, gateway);
+ }
+ }
+
+ public void Dispose() {
+ lock (lockObj) {
+ (gatewayBacking as IDisposable)?.Dispose();
+ gatewayBacking = null;
+ }
+ }
+
+ class Subscription : IDisposable {
+ readonly IObserver observer;
+ readonly IWebsocketConnectionGateway gateway;
+
+ public Subscription(
+ IObserver observer, IWebsocketConnectionGateway gateway) {
+ this.observer = observer;
+ this.gateway = gateway;
+ gateway.Connected += onConnected;
+ gateway.Disconnected += onDisconnected;
+ gateway.MessageReceived += onMessageReceived;
+ }
+
+ public void Dispose() {
+ gateway.Connected -= onConnected;
+ gateway.Disconnected -= onDisconnected;
+ gateway.MessageReceived -= onMessageReceived;
+ }
+
+ void onConnected(WebsocketClientID id, WebsocketIncomingMessage? message) {
+ observer.OnNext(WebsocketConnectionUpdate.Create(
+ id, new WebsocketConnectNotification(id, message)));
+ }
+
+ void onDisconnected(WebsocketClientID id) =>
+ observer.OnNext(WebsocketConnectionUpdate.Create(
+ id, new WebsocketDisconnectNotification(id)));
+
+ void onMessageReceived(WebsocketIncomingMessage message) =>
+ observer.OnNext(WebsocketConnectionUpdate.Create(
+ message.sender_client_id, message));
+ }
+}