diff --git a/Cargo.lock b/Cargo.lock
index 84815db15f..05eccc901e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2105,6 +2105,7 @@ dependencies = [
  "tracing-subscriber",
  "ts-rs",
  "wasm-bindgen",
+ "wasm-bindgen-derive",
  "wasm-bindgen-futures",
  "wasm-bindgen-test",
  "web-sys",
@@ -2198,6 +2199,7 @@ dependencies = [
  "tracing-subscriber",
  "ts-rs",
  "wasm-bindgen",
+ "wasm-bindgen-derive",
  "wasm-bindgen-futures",
  "wasm-bindgen-test",
  "web-sys",
@@ -3759,6 +3761,28 @@ dependencies = [
  "wasm-bindgen-wasm-interpreter",
 ]
 
+[[package]]
+name = "wasm-bindgen-derive"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ab8fdb87408dab27d43267c311c89135b35d13f8b3081e88451ddeff742c93a"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-derive-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-derive-macro"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2fbc080f15cb38f447d52bbae64630c2d4925a9ecb5d140d56c0910b69b4cc7"
+dependencies = [
+ "proc-macro2 1.0.94",
+ "quote 1.0.39",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "wasm-bindgen-externref-xform"
 version = "0.2.100"
diff --git a/cpp/perspective/src/cpp/server.cpp b/cpp/perspective/src/cpp/server.cpp
index eef950c80e..5bea64dcee 100644
--- a/cpp/perspective/src/cpp/server.cpp
+++ b/cpp/perspective/src/cpp/server.cpp
@@ -608,6 +608,11 @@ ServerResources::remove_view_on_delete_sub(
     }
 }
 
+void
+ServerResources::drop_view_on_delete_sub(const t_id& view_id) {
+    m_view_on_delete_subs.erase(view_id);
+}
+
 void
 ServerResources::create_view_on_update_sub(
     const t_id& view_id, Subscription sub
@@ -636,6 +641,53 @@ ServerResources::drop_view_on_update_sub(const t_id& view_id) {
     m_view_on_update_subs.erase(view_id);
 }
 
+void
+ServerResources::remove_view_on_update_sub(
+    const t_id& view_id, std::uint32_t sub_id, std::uint32_t client_id
+) {
+    if (m_view_on_update_subs.find(view_id) != m_view_on_update_subs.end()) {
+        auto& subs = m_view_on_update_subs[view_id];
+        subs.erase(
+            std::remove_if(
+                subs.begin(),
+                subs.end(),
+                [sub_id, client_id](const Subscription& sub) {
+                    return sub.id == sub_id && sub.client_id == client_id;
+                }
+            ),
+            subs.end()
+        );
+    }
+}
+
+void
+ServerResources::create_on_hosted_tables_update_sub(Subscription sub) {
+    PSP_WRITE_LOCK(m_write_lock);
+    m_on_hosted_tables_update_subs.push_back(sub);
+}
+
+std::vector<Subscription>
+ServerResources::get_on_hosted_tables_update_sub() {
+    PSP_READ_LOCK(m_write_lock);
+    return m_on_hosted_tables_update_subs;
+}
+
+void
+ServerResources::remove_on_hosted_tables_update_sub(
+    std::uint32_t sub_id, std::uint32_t client_id
+) {
+    m_on_hosted_tables_update_subs.erase(
+        std::remove_if(
+            m_on_hosted_tables_update_subs.begin(),
+            m_on_hosted_tables_update_subs.end(),
+            [sub_id, client_id](const Subscription& sub) {
+                return sub.id == sub_id && sub.client_id == client_id;
+            }
+        ),
+        m_on_hosted_tables_update_subs.end()
+    );
+}
+
 std::vector<std::pair<std::shared_ptr<Table>, const ServerResources::t_id>>
 ServerResources::get_dirty_tables() {
     PSP_READ_LOCK(m_write_lock);
@@ -662,6 +714,18 @@ ServerResources::drop_client(const std::uint32_t client_id) {
             delete_view(client_id, view_id);
         }
     }
+
+    std::vector<Subscription> subs;
+    std::remove_copy_if(
+        m_on_hosted_tables_update_subs.begin(),
+        m_on_hosted_tables_update_subs.end(),
+        std::back_inserter(subs),
+        [&client_id](const Subscription& item) {
+            return item.client_id == client_id;
+        }
+    );
+
+    m_on_hosted_tables_update_subs = subs;
 }
 
 std::uint32_t
@@ -876,6 +940,7 @@ needs_poll(const proto::Request::ClientReqCase proto_case) {
         case ReqCase::kTableUpdateReq:
         case ReqCase::kTableRemoveDeleteReq:
         case ReqCase::kGetHostedTablesReq:
+        case ReqCase::kRemoveHostedTablesUpdateReq:
         case ReqCase::kTableReplaceReq:
         case ReqCase::kTableDeleteReq:
         case ReqCase::kViewGetConfigReq:
@@ -932,6 +997,7 @@ entity_type_is_table(const proto::Request::ClientReqCase proto_case) {
         case ReqCase::kViewDeleteReq:
         case ReqCase::kViewExpressionSchemaReq:
         case ReqCase::kViewRemoveOnUpdateReq:
+        case ReqCase::kRemoveHostedTablesUpdateReq:
             return false;
         case proto::Request::CLIENT_REQ_NOT_SET:
             throw std::runtime_error("Unhandled request type 2");
@@ -1228,24 +1294,41 @@ ProtoServer::_handle_request(std::uint32_t client_id, Request&& req) {
             break;
         }
         case proto::Request::kGetHostedTablesReq: {
-            proto::Response resp;
-            const auto& tables = resp.mutable_get_hosted_tables_resp();
-            const auto& infos = tables->mutable_table_infos();
-            for (const auto& name : m_resources.get_table_ids()) {
-                const auto& v = infos->Add();
+            const auto& r = req.get_hosted_tables_req();
+            if (!r.subscribe()) {
+                proto::Response resp;
+                const auto& tables = resp.mutable_get_hosted_tables_resp();
+                const auto& infos = tables->mutable_table_infos();
+                for (const auto& name : m_resources.get_table_ids()) {
+                    const auto& v = infos->Add();
 
-                v->set_entity_id(name);
-                const auto tbl = m_resources.get_table(name);
+                    v->set_entity_id(name);
+                    const auto tbl = m_resources.get_table(name);
 
-                if (!tbl->get_index().empty()) {
-                    v->set_index(tbl->get_index());
-                }
+                    if (!tbl->get_index().empty()) {
+                        v->set_index(tbl->get_index());
+                    }
 
-                if (tbl->get_limit() != std::numeric_limits<int>::max()) {
-                    v->set_limit(tbl->get_limit());
+                    if (tbl->get_limit() != std::numeric_limits<int>::max()) {
+                        v->set_limit(tbl->get_limit());
+                    }
                 }
+
+                push_resp(std::move(resp));
+            } else {
+                Subscription sub_info;
+                sub_info.id = req.msg_id();
+                sub_info.client_id = client_id;
+                m_resources.create_on_hosted_tables_update_sub(sub_info);
             }
 
+            break;
+        }
+        case proto::Request::kRemoveHostedTablesUpdateReq: {
+            auto sub_id = req.remove_hosted_tables_update_req().id();
+            m_resources.remove_on_hosted_tables_update_sub(sub_id, client_id);
+            proto::Response resp;
+            resp.mutable_remove_hosted_tables_update_resp();
             push_resp(std::move(resp));
             break;
         }
@@ -1348,6 +1431,18 @@ ProtoServer::_handle_request(std::uint32_t client_id, Request&& req) {
             proto::Response resp;
             resp.mutable_make_table_resp();
             push_resp(std::move(resp));
+
+            // Notify `on_thsoted_tables_update` listeners
+            auto subscriptions = m_resources.get_on_hosted_tables_update_sub();
+            for (auto& subscription : subscriptions) {
+                Response out;
+                out.set_msg_id(subscription.id);
+                ProtoServerResp<ProtoServer::Response> resp2;
+                resp2.data = std::move(out);
+                resp2.client_id = subscription.client_id;
+                proto_resp.emplace_back(std::move(resp2));
+            }
+
             break;
         }
         case proto::Request::kTableSizeReq: {
@@ -2272,6 +2367,18 @@ ProtoServer::_handle_request(std::uint32_t client_id, Request&& req) {
             proto::Response resp;
             resp.mutable_table_delete_resp();
             push_resp(std::move(resp));
+
+            // notify `on_hosted_tables_update` listeners
+            auto subscriptions = m_resources.get_on_hosted_tables_update_sub();
+            for (auto& subscription : subscriptions) {
+                Response out;
+                out.set_msg_id(subscription.id);
+                ProtoServerResp<ProtoServer::Response> resp2;
+                resp2.data = std::move(out);
+                resp2.client_id = subscription.client_id;
+                proto_resp.emplace_back(std::move(resp2));
+            }
+
             break;
         }
         case proto::Request::kViewDeleteReq: {
@@ -2509,30 +2616,6 @@ ProtoServer::_process_table(
     m_resources.mark_table_clean(table_id);
 }
 
-void
-ServerResources::remove_view_on_update_sub(
-    const t_id& view_id, std::uint32_t sub_id, std::uint32_t client_id
-) {
-    if (m_view_on_update_subs.find(view_id) != m_view_on_update_subs.end()) {
-        auto& subs = m_view_on_update_subs[view_id];
-        subs.erase(
-            std::remove_if(
-                subs.begin(),
-                subs.end(),
-                [sub_id, client_id](const Subscription& sub) {
-                    return sub.id == sub_id && sub.client_id == client_id;
-                }
-            ),
-            subs.end()
-        );
-    }
-}
-
-void
-ServerResources::drop_view_on_delete_sub(const t_id& view_id) {
-    m_view_on_delete_subs.erase(view_id);
-}
-
 } // namespace perspective::server
 
 const char*
diff --git a/cpp/perspective/src/include/perspective/server.h b/cpp/perspective/src/include/perspective/server.h
index 9f2efb18ac..8d36ddc15a 100644
--- a/cpp/perspective/src/include/perspective/server.h
+++ b/cpp/perspective/src/include/perspective/server.h
@@ -569,6 +569,13 @@ namespace server {
         );
         void drop_view_on_delete_sub(const t_id& view_id);
 
+        // `on_hosted_tables_update()`
+        void create_on_hosted_tables_update_sub(Subscription sub);
+        std::vector<Subscription> get_on_hosted_tables_update_sub();
+        void remove_on_hosted_tables_update_sub(
+            std::uint32_t sub_id, std::uint32_t client_id
+        );
+
         void mark_table_dirty(const t_id& id);
         void mark_table_clean(const t_id& id);
         void mark_all_tables_clean();
@@ -594,6 +601,8 @@ namespace server {
         tsl::hopscotch_map<t_id, std::vector<Subscription>>
             m_table_on_delete_subs;
 
+        std::vector<Subscription> m_on_hosted_tables_update_subs;
+
         tsl::hopscotch_set<t_id> m_dirty_tables;
 
 #ifdef PSP_PARALLEL_FOR
diff --git a/cpp/protos/perspective.proto b/cpp/protos/perspective.proto
index b13098ce07..5c0d63aa3f 100644
--- a/cpp/protos/perspective.proto
+++ b/cpp/protos/perspective.proto
@@ -118,6 +118,7 @@ message Request {
         // Minimum Virtual API (theoretical).
         GetFeaturesReq get_features_req = 3;
         GetHostedTablesReq get_hosted_tables_req = 4;
+        RemoveHostedTablesUpdateReq remove_hosted_tables_update_req = 37;
         TableMakePortReq table_make_port_req = 5;
         TableMakeViewReq table_make_view_req = 6;
         TableSchemaReq table_schema_req = 7;
@@ -164,6 +165,7 @@ message Response {
     oneof client_resp {
         GetFeaturesResp get_features_resp = 3;
         GetHostedTablesResp get_hosted_tables_resp = 4;
+        RemoveHostedTablesUpdateResp remove_hosted_tables_update_resp = 37;
         TableMakePortResp table_make_port_resp = 5;
         TableMakeViewResp table_make_view_resp = 6;
         TableSchemaResp table_schema_resp = 7;
@@ -219,7 +221,10 @@ message GetFeaturesResp {
 }
 
 // `Client::get_hosted_tables`
-message GetHostedTablesReq {}
+message GetHostedTablesReq {
+    bool subscribe = 1;
+}
+
 message GetHostedTablesResp {
     repeated HostedTable table_infos = 1;
 }
@@ -230,6 +235,11 @@ message HostedTable {
     optional uint32 limit = 3;
 }
 
+message RemoveHostedTablesUpdateReq {
+    uint32 id = 1;
+}
+message RemoveHostedTablesUpdateResp {}
+
 // `Table::size`
 message TableSizeReq {}
 message TableSizeResp {
diff --git a/examples/blocks/src/editable/README.md b/examples/blocks/src/editable/README.md
index b5c308502f..67ac27cc0b 100644
--- a/examples/blocks/src/editable/README.md
+++ b/examples/blocks/src/editable/README.md
@@ -1,7 +1,4 @@
-A simple example of [Perspective](https://github.com/finos/perspective) with
-superstore data, and editability enabled (not default but easy to toggle at
-runtime).
-
-An explcit `SharedWorker` is used to create the Perspective engine, allowing
-edits to be shared live when this example is opened across multiple browser
-tabs.
+A simple example of [Perspective](https://github.com/finos/perspective) with superstore
+data, and editability enabled (not default but easy to toggle at runtime). This
+example has no server component, and the edits occur only within the browser session;
+refreshing the page will forget any edits and revert to the original dataset.
diff --git a/examples/blocks/src/editable/index.html b/examples/blocks/src/editable/index.html
index 6fad615870..91af59f54d 100644
--- a/examples/blocks/src/editable/index.html
+++ b/examples/blocks/src/editable/index.html
@@ -13,23 +13,13 @@
 
             import perspective from "/node_modules/@finos/perspective/dist/cdn/perspective.js";
 
+            const worker = await perspective.worker();
+            const resp = await fetch("/node_modules/superstore-arrow/superstore.lz4.arrow");
+            const arrow = await resp.arrayBuffer();
             const viewer = document.getElementsByTagName("perspective-viewer")[0];
-
-            const worker = new SharedWorker("/node_modules/@finos/perspective/dist/cdn/perspective-server.worker.js");
-            const client = await perspective.worker(worker);
-            const tables = await client.get_hosted_table_names();
-
-            if (tables.length > 0) {
-                const table = client.open_table(tables[0]);
-                viewer.load(table);
-            } else {
-                const resp = await fetch("/node_modules/superstore-arrow/superstore.lz4.arrow");
-                const arrow = await resp.arrayBuffer();
-                const table = client.table(arrow);
-                viewer.load(table);
-            }
-
-            viewer.restore({ plugin_config: { edit_mode: "EDIT" }, settings: true });
+            const table = worker.table(arrow);
+            viewer.load(table);
+            viewer.restore({ settings: true, plugin_config: { edit_mode: "EDIT" } });
         </script>
         <style>
             perspective-viewer {
diff --git a/packages/perspective-workspace/src/ts/workspace/commands.ts b/packages/perspective-workspace/src/ts/workspace/commands.ts
index 95192f349a..c5b79d6826 100644
--- a/packages/perspective-workspace/src/ts/workspace/commands.ts
+++ b/packages/perspective-workspace/src/ts/workspace/commands.ts
@@ -39,7 +39,7 @@ export const createCommands = (
                 args.widget_name as string
             )!;
 
-            menu.unsafe_set_model(await widget.viewer.unsafe_get_model());
+            menu.set_model(widget.viewer.get_model());
             menu.open(indicator);
             workspace.get_context_menu()?.init_overlay?.();
             menu.addEventListener("blur", () => {
@@ -80,7 +80,7 @@ export const createCommands = (
             const widget = workspace.getWidgetByName(
                 args.widget_name as string
             )!;
-            menu.unsafe_set_model(await widget.viewer.unsafe_get_model());
+            menu.set_model(widget.viewer.get_model());
 
             menu.open(indicator);
             workspace.get_context_menu()?.init_overlay?.();
diff --git a/rust/perspective-client/docs/client/on_hosted_tables_update.md b/rust/perspective-client/docs/client/on_hosted_tables_update.md
new file mode 100644
index 0000000000..02811432e2
--- /dev/null
+++ b/rust/perspective-client/docs/client/on_hosted_tables_update.md
@@ -0,0 +1,29 @@
+Register a callback which is invoked whenever `Client::table` (on this `Client`)
+or `Table::delete` (on a `Table` belinging to this `Client`) are called.
+
+<div class="javascript">
+
+# JavaScript Examples
+
+```javascript
+const sub = await client.on_hosted_tables_update(() => {
+    console.log("Tables have updated!", await client.get_hosted_table_names());
+});
+
+// This invokes the handler
+const table = await client.table("x\n1", {name: "test"});
+
+// So does this
+await table.delete();
+
+// cleanup
+await client.remove_hosted_tables_update(sub);
+```
+
+</div>
+<div class="python">
+
+</div>
+<div class="python">
+
+</div>
diff --git a/rust/perspective-client/docs/client/remove_hosted_tables_update.md b/rust/perspective-client/docs/client/remove_hosted_tables_update.md
new file mode 100644
index 0000000000..e942a1457a
--- /dev/null
+++ b/rust/perspective-client/docs/client/remove_hosted_tables_update.md
@@ -0,0 +1 @@
+Remove a callback previously registered via `Client::on_hosted_tables_update`.
diff --git a/rust/perspective-client/docs/table/get_name.md b/rust/perspective-client/docs/table/get_name.md
new file mode 100644
index 0000000000..5c0fe1996c
--- /dev/null
+++ b/rust/perspective-client/docs/table/get_name.md
@@ -0,0 +1,2 @@
+Returns the user-specified name for this table, or the auto-generated name if a
+name was not specified when the table was created.
diff --git a/rust/perspective-client/src/rust/client.rs b/rust/perspective-client/src/rust/client.rs
index 9a40e8a963..aa96fbaeda 100644
--- a/rust/perspective-client/src/rust/client.rs
+++ b/rust/perspective-client/src/rust/client.rs
@@ -12,12 +12,12 @@
 
 use std::collections::HashMap;
 use std::error::Error;
-use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
+use std::sync::atomic::AtomicU32;
 
 use async_lock::{Mutex, RwLock};
-use futures::future::{join_all, BoxFuture, LocalBoxFuture};
-use futures::Future;
+use futures::future::{BoxFuture, LocalBoxFuture, join_all};
+use futures::{Future, FutureExt};
 use nanoid::*;
 use prost::Message;
 use serde::{Deserialize, Serialize};
@@ -26,7 +26,7 @@ use crate::proto::request::ClientReq;
 use crate::proto::response::ClientResp;
 use crate::proto::{
     self, ColumnType, GetFeaturesReq, GetFeaturesResp, GetHostedTablesReq, GetHostedTablesResp,
-    HostedTable, MakeTableReq, Request, Response, ServerSystemInfoReq,
+    HostedTable, MakeTableReq, RemoveHostedTablesUpdateReq, Request, Response, ServerSystemInfoReq,
 };
 use crate::table::{Table, TableInitOptions, TableOptions};
 use crate::table_data::{TableData, UpdateData};
@@ -76,9 +76,9 @@ type SendCallback = Arc<
 >;
 
 pub trait ClientHandler: Clone + Send + Sync + 'static {
-    fn send_request<'a>(
-        &'a self,
-        msg: &'a [u8],
+    fn send_request(
+        &self,
+        msg: Vec<u8>,
     ) -> impl Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send;
 }
 
@@ -115,7 +115,7 @@ impl Client {
     /// dispatch. See [`Client::new`] for details.
     pub fn new_with_callback<T>(send_request: T) -> Self
     where
-        T: for<'a> Fn(&'a [u8]) -> BoxFuture<'a, Result<(), Box<dyn Error + Send + Sync>>>
+        T: for<'a> Fn(Vec<u8>) -> BoxFuture<'static, Result<(), Box<dyn Error + Send + Sync>>>
             + 'static
             + Sync
             + Send,
@@ -125,7 +125,7 @@ impl Client {
             let mut bytes: Vec<u8> = Vec::new();
             req.encode(&mut bytes).unwrap();
             let send_request = send_request.clone();
-            Box::pin(async move { send_request(&bytes).await })
+            Box::pin(async move { send_request(bytes).await })
         });
 
         Client {
@@ -359,7 +359,9 @@ impl Client {
         let msg = Request {
             msg_id: self.gen_id(),
             entity_id: "".to_owned(),
-            client_req: Some(ClientReq::GetHostedTablesReq(GetHostedTablesReq {})),
+            client_req: Some(ClientReq::GetHostedTablesReq(GetHostedTablesReq {
+                subscribe: false,
+            })),
         };
 
         match self.oneshot(&msg).await? {
@@ -391,7 +393,9 @@ impl Client {
         let msg = Request {
             msg_id: self.gen_id(),
             entity_id: "".to_owned(),
-            client_req: Some(ClientReq::GetHostedTablesReq(GetHostedTablesReq {})),
+            client_req: Some(ClientReq::GetHostedTablesReq(GetHostedTablesReq {
+                subscribe: false,
+            })),
         };
 
         match self.oneshot(&msg).await? {
@@ -402,6 +406,56 @@ impl Client {
         }
     }
 
+    #[doc = include_str!("../../docs/client/on_hosted_tables_update.md")]
+    pub async fn on_hosted_tables_update<T, U>(&self, on_update: T) -> ClientResult<u32>
+    where
+        T: Fn() -> U + Send + Sync + 'static,
+        U: Future<Output = ()> + Send + 'static,
+    {
+        let on_update = Arc::new(on_update);
+        let callback = move |resp: Response| {
+            let on_update = on_update.clone();
+            async move {
+                match resp.client_resp {
+                    Some(ClientResp::GetHostedTablesResp(_)) | None => {
+                        on_update().await;
+                        Ok(())
+                    },
+                    resp => Err(ClientError::OptionResponseFailed(resp.into())),
+                }
+            }
+            .boxed()
+        };
+
+        let msg = Request {
+            msg_id: self.gen_id(),
+            entity_id: "".to_owned(),
+            client_req: Some(ClientReq::GetHostedTablesReq(GetHostedTablesReq {
+                subscribe: true,
+            })),
+        };
+
+        self.subscribe(&msg, Box::new(callback)).await?;
+        Ok(msg.msg_id)
+    }
+
+    #[doc = include_str!("../../docs/client/remove_hosted_tables_update.md")]
+    pub async fn remove_hosted_tables_update(&self, update_id: u32) -> ClientResult<()> {
+        let msg = Request {
+            msg_id: self.gen_id(),
+            entity_id: "".to_owned(),
+            client_req: Some(ClientReq::RemoveHostedTablesUpdateReq(
+                RemoveHostedTablesUpdateReq { id: update_id },
+            )),
+        };
+
+        self.unsubscribe(update_id).await?;
+        match self.oneshot(&msg).await? {
+            ClientResp::RemoveHostedTablesUpdateResp(_) => Ok(()),
+            resp => Err(resp.into()),
+        }
+    }
+
     #[doc = include_str!("../../docs/client/system_info.md")]
     pub async fn system_info(&self) -> ClientResult<SystemInfo> {
         let msg = Request {
diff --git a/rust/perspective-js/Cargo.toml b/rust/perspective-js/Cargo.toml
index 8919b932a8..15d430aeb9 100644
--- a/rust/perspective-js/Cargo.toml
+++ b/rust/perspective-js/Cargo.toml
@@ -75,6 +75,7 @@ tracing = { version = ">=0.1.36" }
 tracing-subscriber = "0.3.15"
 console_error_panic_hook = "0.1.6"
 wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+wasm-bindgen-derive = "0.3.0"
 wasm-bindgen-futures = "0.4.41"
 
 [dependencies.web-sys]
diff --git a/rust/perspective-js/src/rust/client.rs b/rust/perspective-js/src/rust/client.rs
index 5120d18a98..1ec32e6d43 100644
--- a/rust/perspective-js/src/rust/client.rs
+++ b/rust/perspective-js/src/rust/client.rs
@@ -23,10 +23,10 @@ use macro_rules_attribute::apply;
 use perspective_client::SystemInfo;
 use perspective_client::{ReconnectCallback, Session, TableData, TableInitOptions};
 use wasm_bindgen::prelude::*;
-use wasm_bindgen_futures::{future_to_promise, JsFuture};
+use wasm_bindgen_futures::{JsFuture, future_to_promise};
 
 pub use crate::table::*;
-use crate::utils::{inherit_docs, ApiError, ApiResult, JsValueSerdeExt, LocalPollLoop};
+use crate::utils::{ApiError, ApiResult, JsValueSerdeExt, LocalPollLoop, inherit_docs};
 
 #[wasm_bindgen]
 extern "C" {
@@ -146,8 +146,7 @@ impl Client {
         });
 
         let client = perspective_client::Client::new_with_callback(move |msg| {
-            let vec = msg.to_vec();
-            Box::pin(send_request.run_all(vec))
+            Box::pin(send_request.run_all(msg))
         });
 
         Client { close, client }
@@ -303,6 +302,24 @@ impl Client {
         )?)
     }
 
+    #[apply(inherit_docs)]
+    #[inherit_doc = "client/on_hosted_tables_update.md"]
+    #[wasm_bindgen]
+    pub async fn on_hosted_tables_update(&self, on_update_js: Function) -> ApiResult<u32> {
+        let poll_loop = LocalPollLoop::new(move |_| on_update_js.call0(&JsValue::UNDEFINED));
+        let on_update = Box::new(move || poll_loop.poll(()));
+        let id = self.client.on_hosted_tables_update(on_update).await?;
+        Ok(id)
+    }
+
+    #[apply(inherit_docs)]
+    #[inherit_doc = "client/remove_hosted_tables_update.md"]
+    #[wasm_bindgen]
+    pub async fn remove_hosted_tables_update(&self, update_id: u32) -> ApiResult<()> {
+        self.client.remove_hosted_tables_update(update_id).await?;
+        Ok(())
+    }
+
     #[apply(inherit_docs)]
     #[inherit_doc = "client/system_info.md"]
     #[wasm_bindgen]
diff --git a/rust/perspective-js/src/rust/lib.rs b/rust/perspective-js/src/rust/lib.rs
index 945d1cd9f1..e69d4c5246 100644
--- a/rust/perspective-js/src/rust/lib.rs
+++ b/rust/perspective-js/src/rust/lib.rs
@@ -18,6 +18,8 @@
 )]
 #![allow(non_snake_case)]
 
+extern crate alloc;
+
 mod client;
 mod table;
 pub mod utils;
diff --git a/rust/perspective-js/src/rust/table.rs b/rust/perspective-js/src/rust/table.rs
index f462783a35..bc82438e9f 100644
--- a/rust/perspective-js/src/rust/table.rs
+++ b/rust/perspective-js/src/rust/table.rs
@@ -11,19 +11,20 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 use extend::ext;
-use js_sys::{Array, ArrayBuffer, Function, Object, Reflect, Uint8Array, JSON};
+use js_sys::{Array, ArrayBuffer, Function, JSON, Object, Reflect, Uint8Array};
 use macro_rules_attribute::apply;
 use perspective_client::config::*;
 use perspective_client::{
-    assert_table_api, ColumnType, TableData, TableReadFormat, UpdateData, UpdateOptions,
+    ColumnType, TableData, TableReadFormat, UpdateData, UpdateOptions, assert_table_api,
 };
 use wasm_bindgen::convert::TryFromJsValue;
 use wasm_bindgen::prelude::*;
+use wasm_bindgen_derive::TryFromJsValue;
 use wasm_bindgen_futures::spawn_local;
 
 use crate::client::Client;
 use crate::utils::{
-    inherit_docs, ApiError, ApiFuture, ApiResult, JsValueSerdeExt, LocalPollLoop, ToApiError,
+    ApiError, ApiFuture, ApiResult, JsValueSerdeExt, LocalPollLoop, ToApiError, inherit_docs,
 };
 pub use crate::view::*;
 
@@ -166,7 +167,7 @@ pub(crate) impl UpdateData {
     }
 }
 
-#[derive(Clone)]
+#[derive(TryFromJsValue, Clone)]
 #[wasm_bindgen]
 pub struct Table(pub(crate) perspective_client::Table);
 
@@ -217,6 +218,13 @@ impl Table {
         }
     }
 
+    #[apply(inherit_docs)]
+    #[inherit_doc = "table/get_name.md"]
+    #[wasm_bindgen]
+    pub async fn get_name(&self) -> String {
+        self.0.get_name().to_owned()
+    }
+
     #[apply(inherit_docs)]
     #[inherit_doc = "table/get_limit.md"]
     #[wasm_bindgen]
@@ -360,10 +368,4 @@ impl Table {
         let columns = self.0.validate_expressions(exprs).await?;
         Ok(JsValue::from_serde_ext(&columns)?)
     }
-
-    #[allow(clippy::use_self)]
-    #[doc(hidden)]
-    pub fn unsafe_get_model(&self) -> *const Table {
-        std::ptr::addr_of!(*self)
-    }
 }
diff --git a/rust/perspective-js/src/ts/perspective.browser.ts b/rust/perspective-js/src/ts/perspective.browser.ts
index 6d8e55a40c..d58f3d62ad 100644
--- a/rust/perspective-js/src/ts/perspective.browser.ts
+++ b/rust/perspective-js/src/ts/perspective.browser.ts
@@ -60,7 +60,7 @@ async function compilerize(
     disable_stage_0: boolean = false
 ) {
     const wasm_buff = disable_stage_0 ? wasm : await load_wasm_stage_0(wasm);
-    await wasm_module.default(wasm_buff);
+    await wasm_module.default({ module_or_path: wasm_buff });
     await wasm_module.init();
     return wasm_module;
 }
diff --git a/rust/perspective-js/src/ts/perspective.node.ts b/rust/perspective-js/src/ts/perspective.node.ts
index 12d5f8a2f1..4df0e9f0df 100644
--- a/rust/perspective-js/src/ts/perspective.node.ts
+++ b/rust/perspective-js/src/ts/perspective.node.ts
@@ -39,7 +39,7 @@ const uncompressed_client_wasm = await fs
     .readFile(path.join(__dirname, "../../dist/wasm/perspective-js.wasm"))
     .then((buffer) => load_wasm_stage_0(buffer.buffer as ArrayBuffer));
 
-await perspective_client.default(uncompressed_client_wasm);
+await perspective_client.default({ module_or_path: uncompressed_client_wasm });
 perspective_client.init();
 
 const SYNC_MODULE = await fs
@@ -245,6 +245,14 @@ export function get_hosted_table_names() {
     return SYNC_CLIENT.get_hosted_table_names();
 }
 
+export function on_hosted_tables_update(cb: () => void) {
+    return SYNC_CLIENT.on_hosted_tables_update(cb);
+}
+
+export function remove_hosted_tables_update(id: number) {
+    return SYNC_CLIENT.remove_hosted_tables_update(id);
+}
+
 export function system_info() {
     return SYNC_CLIENT.system_info();
 }
@@ -287,6 +295,8 @@ export default {
     table,
     websocket,
     get_hosted_table_names,
+    on_hosted_tables_update,
+    remove_hosted_tables_update,
     system_info,
     WebSocketServer,
 };
diff --git a/rust/perspective-js/test/js/hosted_tables.spec.js b/rust/perspective-js/test/js/hosted_tables.spec.js
index 034bfcb1b0..904021802c 100644
--- a/rust/perspective-js/test/js/hosted_tables.spec.js
+++ b/rust/perspective-js/test/js/hosted_tables.spec.js
@@ -16,15 +16,44 @@ import { test_arrow } from "./test_arrows";
 
 test("Can get hosted table name from worker", async () => {
     const testTableName1 = Math.random().toString();
-    const _table = perspective.table(test_arrow, { name: testTableName1 });
+    const _table = await perspective.table(test_arrow, {
+        name: testTableName1,
+    });
     const names = await perspective.get_hosted_table_names();
 
     expect(names).toContain(testTableName1);
 
     const testTableName2 = Math.random().toString();
-    const _table2 = perspective.table(test_arrow, { name: testTableName2 });
+    const _table2 = await perspective.table(test_arrow, {
+        name: testTableName2,
+    });
     const names2 = await perspective.get_hosted_table_names();
 
     expect(names2).toContain(testTableName1);
     expect(names2).toContain(testTableName2);
+    await _table.delete();
+    await _table2.delete();
+});
+
+test("Can subscribe to hosted table changes from worker", async () => {
+    let count = 0;
+    const id = perspective.on_hosted_tables_update(() => {
+        count += 1;
+    });
+
+    const testTableName1 = Math.random().toString();
+    const _table = await perspective.table(test_arrow, {
+        name: testTableName1,
+    });
+    expect(count).toEqual(1);
+
+    const testTableName2 = Math.random().toString();
+    const _table2 = await perspective.table(test_arrow, {
+        name: testTableName2,
+    });
+    expect(count).toEqual(2);
+    await _table.delete();
+    expect(count).toEqual(3);
+    await _table2.delete();
+    expect(count).toEqual(4);
 });
diff --git a/rust/perspective-python/src/client/client_async.rs b/rust/perspective-python/src/client/client_async.rs
index 491e5c7aa6..1b9ae529d8 100644
--- a/rust/perspective-python/src/client/client_async.rs
+++ b/rust/perspective-python/src/client/client_async.rs
@@ -62,7 +62,7 @@ impl AsyncClient {
                 let handle_request = handle_request.clone();
                 Box::pin(async move {
                     if let Some(fut) = Python::with_gil(move |py| -> PyResult<_> {
-                        let ret = handle_request.call1(py, (PyBytes::new(py, msg),))?;
+                        let ret = handle_request.call1(py, (PyBytes::new(py, &msg),))?;
                         if isawaitable(ret.bind(py)).unwrap_or(false) {
                             Ok(Some(py_async::py_into_future(ret.into_bound(py))?))
                         } else {
@@ -159,6 +159,48 @@ impl AsyncClient {
         self.client.get_hosted_table_names().await.into_pyerr()
     }
 
+    pub async fn on_hosted_tables_update(&self, callback_py: Py<PyAny>) -> PyResult<u32> {
+        let locked_val = self.loop_cb.read().await.clone();
+        let loop_cb = Python::with_gil(|py| (*locked_val).as_ref().map(|v| Py::clone_ref(v, py)));
+        let callback = Box::new(move || {
+            let loop_cb = Python::with_gil(|py| loop_cb.as_ref().map(|v| Py::clone_ref(v, py)));
+            let callback = Python::with_gil(|py| Py::clone_ref(&callback_py, py));
+            async move {
+                let aggregate_errors: PyResult<()> = {
+                    let callback = Python::with_gil(|py| Py::clone_ref(&callback, py));
+                    Python::with_gil(|py| {
+                        match &loop_cb {
+                            None => callback.call0(py)?,
+                            Some(loop_cb) => loop_cb.call1(py, (&callback,))?,
+                        };
+
+                        Ok(())
+                    })
+                };
+
+                // TODO These are unrecoverable errors - we should mark them as such
+                if let Err(err) = aggregate_errors {
+                    tracing::warn!("Error in on_hosted_tables_update callback: {:?}", err);
+                }
+            }
+            .boxed()
+        });
+
+        let callback_id = self
+            .client
+            .on_hosted_tables_update(callback)
+            .await
+            .into_pyerr()?;
+        Ok(callback_id)
+    }
+
+    pub async fn remove_hosted_tables_update(&self, id: u32) -> PyResult<()> {
+        self.client
+            .remove_hosted_tables_update(id)
+            .await
+            .into_pyerr()
+    }
+
     pub async fn set_loop_callback(&self, loop_cb: Py<PyAny>) -> PyResult<()> {
         *self.loop_cb.write().await = Some(loop_cb).into();
         Ok(())
diff --git a/rust/perspective-python/src/client/client_sync.rs b/rust/perspective-python/src/client/client_sync.rs
index 46779d0717..7a415c93ce 100644
--- a/rust/perspective-python/src/client/client_sync.rs
+++ b/rust/perspective-python/src/client/client_sync.rs
@@ -14,9 +14,9 @@ use std::collections::HashMap;
 use std::future::Future;
 
 use macro_rules_attribute::apply;
-use perspective_client::{assert_table_api, assert_view_api, Session};
 #[cfg(doc)]
-use perspective_client::{config::ViewConfigUpdate, Schema, TableInitOptions, UpdateOptions};
+use perspective_client::{Schema, TableInitOptions, UpdateOptions, config::ViewConfigUpdate};
+use perspective_client::{Session, assert_table_api, assert_view_api};
 use pyo3::exceptions::PyTypeError;
 use pyo3::marker::Ungil;
 use pyo3::prelude::*;
@@ -142,6 +142,20 @@ impl Client {
         self.0.get_hosted_table_names().py_block_on(py)
     }
 
+    #[apply(inherit_doc)]
+    #[inherit_doc = "client/on_hosted_tables_update.md"]
+    pub fn on_hosted_tables_update(&self, py: Python<'_>, callback: Py<PyAny>) -> PyResult<u32> {
+        self.0.on_hosted_tables_update(callback).py_block_on(py)
+    }
+
+    #[apply(inherit_doc)]
+    #[inherit_doc = "client/remove_hosted_tables_update.md"]
+    pub fn remove_hosted_tables_update(&self, py: Python<'_>, callback_id: u32) -> PyResult<()> {
+        self.0
+            .remove_hosted_tables_update(callback_id)
+            .py_block_on(py)
+    }
+
     #[apply(inherit_doc)]
     #[inherit_doc = "client/set_loop_callback.md"]
     pub fn set_loop_callback(&self, py: Python<'_>, loop_cb: Py<PyAny>) -> PyResult<()> {
diff --git a/rust/perspective-server/src/local_client.rs b/rust/perspective-server/src/local_client.rs
index 9a433b8e4e..a4b0367165 100644
--- a/rust/perspective-server/src/local_client.rs
+++ b/rust/perspective-server/src/local_client.rs
@@ -34,13 +34,13 @@ impl SessionHandler for LocalClientState {
 }
 
 impl ClientHandler for LocalClientState {
-    async fn send_request<'a>(
-        &'a self,
-        msg: &'a [u8],
+    async fn send_request(
+        &self,
+        msg: Vec<u8>,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         let session_lock = self.get_session().await;
         let session = session_lock.as_ref().unwrap();
-        session.handle_request(msg).await?;
+        session.handle_request(&msg).await?;
         session.poll().await?;
         Ok(())
     }
diff --git a/rust/perspective-viewer/Cargo.toml b/rust/perspective-viewer/Cargo.toml
index 0548a5d871..97f953d349 100644
--- a/rust/perspective-viewer/Cargo.toml
+++ b/rust/perspective-viewer/Cargo.toml
@@ -106,10 +106,12 @@ ts-rs = { version = "10.0.0", features = [
 tracing = { version = ">=0.1.36" }
 tracing-subscriber = "0.3.15"
 
-
 # Browser API bindings
 wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 
+# Pass perspective-js arguments to viewer
+wasm-bindgen-derive = "0.3.0"
+
 # Browser `Promise` bindings
 wasm-bindgen-futures = "0.4.41"
 
diff --git a/rust/perspective-viewer/src/less/status-bar.less b/rust/perspective-viewer/src/less/status-bar.less
index 8b5eb22c48..ede0446fef 100644
--- a/rust/perspective-viewer/src/less/status-bar.less
+++ b/rust/perspective-viewer/src/less/status-bar.less
@@ -125,16 +125,15 @@
             flex: 1 1000 auto;
         }
 
-        #rows {
+        span#rows {
             flex: 0 1000 auto;
             overflow: hidden;
             margin: 0px 14px;
             span {
-                white-space: nowrap;
                 margin: 0 !important;
             }
 
-            span span {
+            span {
                 color: var(--inactive--color);
             }
         }
@@ -156,15 +155,17 @@
         }
 
         span {
+            white-space: nowrap;
+
             // font-size: var(--label--font-size, 0.75em);
             margin: 0px 14px;
             user-select: none;
             // height: 100%;
             // line-height: 36px;
 
-            &:before {
-                position: relative;
-            }
+            // &:before {
+            //     position: relative;
+            // }
 
             &:hover {
                 color: inherit;
diff --git a/rust/perspective-viewer/src/rust/custom_elements/copy_dropdown.rs b/rust/perspective-viewer/src/rust/custom_elements/copy_dropdown.rs
index 41a8da6131..7ec625b6b5 100644
--- a/rust/perspective-viewer/src/rust/custom_elements/copy_dropdown.rs
+++ b/rust/perspective-viewer/src/rust/custom_elements/copy_dropdown.rs
@@ -61,10 +61,8 @@ impl CopyDropDownMenuElement {
     /// Internal Only.
     ///
     /// Set this custom element model's raw pointer.
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub fn unsafe_set_model(&self, ptr: *const PerspectiveViewerElement) {
-        let model = unsafe { ptr.as_ref().unwrap() };
-        self.set_model(model);
+    pub fn set_model(&self, parent: &PerspectiveViewerElement) {
+        self.set_config_model(parent)
     }
 
     pub fn connected_callback(&self) {}
@@ -78,11 +76,11 @@ impl CopyDropDownMenuElement {
             .unchecked_into::<HtmlElement>();
 
         let elem = Self::new(dropdown);
-        elem.set_model(model);
+        elem.set_config_model(model);
         elem
     }
 
-    pub fn set_model<A: GetViewerConfigModel>(&self, model: &A) {
+    pub fn set_config_model<A: GetViewerConfigModel>(&self, model: &A) {
         let callback = Callback::from({
             let model = model.cloned();
             let modal_rc = self.modal.clone();
diff --git a/rust/perspective-viewer/src/rust/custom_elements/export_dropdown.rs b/rust/perspective-viewer/src/rust/custom_elements/export_dropdown.rs
index 35cca8ecb0..d96e140806 100644
--- a/rust/perspective-viewer/src/rust/custom_elements/export_dropdown.rs
+++ b/rust/perspective-viewer/src/rust/custom_elements/export_dropdown.rs
@@ -61,10 +61,8 @@ impl ExportDropDownMenuElement {
     /// Internal Only.
     ///
     /// Set this custom element model's raw pointer.
-    #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub fn unsafe_set_model(&self, ptr: *const PerspectiveViewerElement) {
-        let model = unsafe { ptr.as_ref().unwrap() };
-        self.set_model(model);
+    pub fn set_model(&self, parent: &PerspectiveViewerElement) {
+        self.set_config_model(parent)
     }
 
     pub fn connected_callback(&self) {}
@@ -78,11 +76,11 @@ impl ExportDropDownMenuElement {
             .unchecked_into::<HtmlElement>();
 
         let elem = Self::new(dropdown);
-        elem.set_model(model);
+        elem.set_config_model(model);
         elem
     }
 
-    pub fn set_model<A: GetViewerConfigModel>(&self, model: &A) {
+    fn set_config_model<A: GetViewerConfigModel>(&self, model: &A) {
         let callback = Callback::from({
             let model = model.cloned();
             let modal_rc = self.modal.clone();
diff --git a/rust/perspective-viewer/src/rust/custom_elements/viewer.rs b/rust/perspective-viewer/src/rust/custom_elements/viewer.rs
index 79064d87d2..da81160301 100644
--- a/rust/perspective-viewer/src/rust/custom_elements/viewer.rs
+++ b/rust/perspective-viewer/src/rust/custom_elements/viewer.rs
@@ -174,27 +174,21 @@ impl PerspectiveViewerElement {
         ApiFuture::new(async move {
             let task = async {
                 update_task?;
-                #[wasm_bindgen]
-                extern "C" {
-                    pub type Model;
-
-                    #[wasm_bindgen(method)]
-                    pub fn unsafe_get_model(this: &Model) -> *const Table;
-                }
-
-                let jstable = JsFuture::from(promise).await?.unchecked_into::<Model>();
-                pub fn unsafe_set_model(ptr: *const Table) -> Table {
-                    (unsafe { ptr.as_ref().unwrap() }).clone()
+                let jstable = JsFuture::from(promise).await?;
+
+                if let Some(table) =
+                    wasm_bindgen_derive::try_from_js_option::<perspective_js::Table>(jstable)?
+                {
+                    tracing::debug!(
+                        "Successfully loaded {:.0} rows from Table",
+                        table.size().await?
+                    );
+
+                    session.set_table(table.get_table().clone()).await?;
+                    session.validate().await?.create_view().await
+                } else {
+                    Err(ApiError::new("Invalid Table"))
                 }
-
-                let table = unsafe_set_model(jstable.unsafe_get_model());
-                tracing::debug!(
-                    "Successfully loaded {:.0} rows from Table",
-                    table.size().await?
-                );
-
-                session.set_table(table.get_table().clone()).await?;
-                session.validate().await?.create_view().await
             };
 
             renderer.set_throttle(None);
@@ -771,11 +765,12 @@ impl PerspectiveViewerElement {
         }
     }
 
+    /// Create a new JavaScript Heap reference for this model instance.
     #[doc(hidden)]
     #[allow(clippy::use_self)]
     #[wasm_bindgen]
-    pub fn unsafe_get_model(&self) -> *const PerspectiveViewerElement {
-        std::ptr::addr_of!(*self)
+    pub fn get_model(&self) -> PerspectiveViewerElement {
+        self.clone()
     }
 
     /// Asynchronously opens the column settings for a specific column.
diff --git a/rust/perspective-viewer/src/ts/bootstrap.ts b/rust/perspective-viewer/src/ts/bootstrap.ts
index 1ebf52f721..c8d07d56b5 100644
--- a/rust/perspective-viewer/src/ts/bootstrap.ts
+++ b/rust/perspective-viewer/src/ts/bootstrap.ts
@@ -32,7 +32,7 @@ export async function init_client(
         wasm_binary = wasm_binary.buffer as ArrayBuffer;
     }
 
-    const module = await load_wasm_stage_0(wasm_binary);
-    await wasm_module.default(module);
+    const module_or_path = await load_wasm_stage_0(wasm_binary);
+    await wasm_module.default({ module_or_path });
     await wasm_module.init();
 }