plusui-native-core 0.1.56 → 0.1.57

package/Core/Features/App/app.cpp

@@ -7,31 +7,8 @@
 #include <plusui/tray.hpp>
 #include <plusui/window.hpp>
 
-#include <bridge.hpp> // Generated generated bridge
-
 namespace plusui {
 
-// --- Bridge Implementation (Demo) ---
-class DemoBridge : public bridge::GeneratedBridge {
-public:
-  nlohmann::json handle_greet(const nlohmann::json &args) override {
-    std::string name = args.value("name", "Guest");
-    return {{"message", "Hello from C++, " + name + "!"}};
-  }
-
-  void handle_log(const nlohmann::json &args) override {
-    std::string msg = args.value("msg", "");
-    std::cout << "[Client Log] " << msg << std::endl;
-  }
-
-  void handle_minimize(const nlohmann::json &args) override {
-    // We need access to the window to minimize it.
-    // For now, we'll just log. In a real app, Bridge might hold a reference to
-    // WindowController.
-    std::cout << "[Client] Requested minimize" << std::endl;
-  }
-};
-
 struct App::Impl {
   bool running = false;
 };
@@ -151,39 +128,6 @@ Window App::Builder::build() {
     }
   }
 
-  // --- Initialize Bridge ---
-  // Create the bridge instance
-  auto bridge = std::make_shared<DemoBridge>();
-
-  // Hook 1: Window -> Bridge (Inbound)
-  webviewWin.onMessage(
-      [bridge](const std::string &msg) { bridge->dispatch(msg); });
-
-  // Hook 2: Bridge -> Window (Outbound)
-  // We capture webviewWin by value (it's a lightweight handle)
-  bridge->setOutboundHandler([webviewWin](const std::string &msg) mutable {
-    webviewWin.postMessage(msg);
-  });
-
-  // Keep bridge alive?
-  // Since webviewWin.onMessage captures 'bridge', the bridge is kept alive by
-  // the Window. And 'bridge' outbound handler captures 'webviewWin', keeping
-  // Window alive. Cycle exists, but ensures lifetime match.
-
-  // Optional: Emit an initial event
-  bridge->emit_onResize(config.width, config.height);
-
-  // Hook 3: File Drop
-  webviewWin.onFileDrop([bridge](const std::string &jsonStr) {
-    if (jsonStr.empty())
-      return;
-    try {
-      auto j = nlohmann::json::parse(jsonStr);
-      bridge->emit_onFileDrop(j);
-    } catch (...) {
-    }
-  });
-
   return webviewWin;
 }
 

package/Core/Features/App/app.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export interface AppConfig {
   title?: string;
   width?: number;
@@ -20,6 +22,7 @@ export interface InvokeOptions {
 }
 
 export class App {
+  public readonly connect = connect.feature('app');
   private initialized = false;
 
   constructor(

package/Core/Features/Browser/browser.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export interface BrowserState {
   url: string;
   title: string;
@@ -62,6 +64,8 @@ if (typeof window !== 'undefined') {
 }
 
 export const browser = {
+  connect: connect.feature('browser'),
+
   async navigate(url: string): Promise<void> {
     await invoke('browser.navigate', [url]);
   },
@@ -160,6 +164,8 @@ export const browser = {
 };
 
 export const router = {
+  connect: connect.feature('router'),
+
   setRoutes(routes: Record<string, string>): void {
     _routes = routes;
   },

package/Core/Features/Clipboard/clipboard.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 /**
  * Clipboard API - Cross-platform clipboard management
  *
@@ -24,6 +26,7 @@ export interface ClipboardAPI {
 }
 
 export class Clipboard implements ClipboardAPI {
+  public readonly connect = connect.feature('clipboard');
   private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>;
   private onFn: (event: string, callback: (data: unknown) => void) => () => void;
 

package/Core/Features/Connection/README.md

@@ -9,7 +9,7 @@ The **Connection Feature** is PlusUI's absurdly simple system for frontend ↔ b
 Just `emit()` and `on()` handle all communication patterns:
 
 | Keyword | Pattern | Direction | Use Cases |
-|---------|---------|-----------|-----------|
+| --------- | --------- | ----------- | ----------- |
 | **EVENT** | Fire & forget | One way → | Notifications, commands, logging |
 | **CALL** | Request/response | Two ways ↔ | Get data, save data, RPC |
 | **STREAM** | Continuous data | One way push → | Real-time updates, monitoring |
@@ -46,29 +46,18 @@ connect.emit('greet', { name: 'World' });
 ```cpp
 #include <plusui/connect.hpp>
 
-class MyConnect : public plusui::Connect {
-protected:
-  void handleMessage(const Envelope& env) override {
-    // Listen for messages from frontend
-    if (env.kind == MessageKind::Fire && env.name == "greet") {
-      std::string name = env.payload["name"];
-      
-      // Respond by emitting back
-      emit("greetResponse", {{"message", "Hello, " + name + "!"}});
-    }
-  }
+plusui::Connect connect;
 
-public:
-  // Emit messages to frontend
-  void emit(const std::string& name, const nlohmann::json& data) {
-    event(name, data);
-  }
+connect.on("greet", [&connect](const nlohmann::json& payload) {
+  std::string user = payload.value("name", "World");
+  connect.emit("greetResponse", {{"message", "Hello, " + user + "!"}});
+});
 
-  // Example: notify frontend of window resize
-  void onWindowResize(int w, int h) {
-    emit("resize", {{"width", w}, {"height", h}});
-  }
-};
+// Wire backend connect ↔ window bridge once
+plusui::bindConnect(mainWindow, connect);
+
+// Example: backend push to frontend
+connect.emit("resize", {{"width", 1280}, {"height", 720}});
 ```
 
 ### Listen on Frontend
@@ -98,17 +87,42 @@ connect.on('messageName', (data) => {
 ### Backend
 
 ```cpp
-// Listen for messages (in handleMessage)
-void handleMessage(const Envelope& env) override {
-  if (env.kind == MessageKind::Fire && env.name == "messageName") {
-    // process env.payload
-  }
-}
+plusui::Connect connect;
+
+// Listen for messages
+connect.on("messageName", [](const nlohmann::json& payload) {
+  // process payload
+});
 
 // Send messages
-void emit(const std::string& name, const nlohmann::json& data) {
-  event(name, data);
-}
+connect.emit("messageName", {{"key", "value"}});
+
+// Bridge window <-> connect runtime
+plusui::bindConnect(mainWindow, connect);
+
+// Optional: call primitive support
+connect.onCall("getUser", [](const nlohmann::json& payload) {
+  return nlohmann::json{{"id", payload.value("id", 0)}, {"name", "Ada"}};
+});
+
+// Optional: stream/query subscription hooks
+connect.onSubscription("cpu", [](bool subscribed, const nlohmann::json&) {
+  if (subscribed) {
+    startCpuStream();
+  } else {
+    stopCpuStream();
+  }
+});
+```
+
+### Feature-Scoped Names
+
+Use `connect` for custom global channels, and `feature.connect` when you want automatic namespacing:
+
+```typescript
+window.connect.emit('resized', { width: 1200, height: 800 });   // -> "window.resized"
+clipboard.connect.emit('changed', { text: 'hello' });           // -> "clipboard.changed"
+connect.emit('custom.appEvent', { ok: true });                  // custom/global channel
 ```
 
 ## 💡 Design Your Own Patterns
@@ -124,13 +138,11 @@ connect.emit('getUser', { id: 123 });
 ```
 
 ```cpp
-// Backend
-void handleMessage(const Envelope& env) override {
-  if (env.name == "getUser") {
-    auto user = database.findUser(env.payload["id"]);
-    emit("getUserResponse", {{"user", user}});
-  }
-}
+plusui::Connect connect;
+connect.onCall("getUser", [](const nlohmann::json& payload) {
+  auto user = database.findUser(payload["id"]);
+  return nlohmann::json{{"user", user}};
+});
 ```
 
 ### Notifications

package/Core/Features/Connection/connect.cpp

@@ -1,57 +1,34 @@
 #include <plusui/connect.hpp>
+#include <plusui/window.hpp>
 
 namespace plusui {
 
-// Connect implementation
-//
-// The Connect class is header-only (see plusui/connect.hpp).
-// This file is reserved for future non-template implementation details.
-//
-// TWO METHODS. FIVE PRIMITIVES. EVERYTHING YOU NEED.
-//
-// To use Connect:
-// 1. Create a class that inherits from plusui::Connect
-// 2. Override handleMessage(name, payload) to receive messages
-// 3. Use emit(name, payload) to send messages to frontend
-//
-// Example - All 5 Primitives:
-//
-//   class MyApp : public plusui::Connect {
-//   protected:
-//     void handleMessage(const std::string& name, const nlohmann::json& data) override {
-//       // EVENT: fire & forget
-//       if (name == "notification") {
-//         showNotification(data["message"].get<std::string>());
-//       }
-//       
-//       // CALL: request/response
-//       if (name == "getUser") {
-//         auto userId = data["id"].get<int>();
-//         emit("userData", {{"name", "John"}, {"id", userId}});
-//       }
-//       
-//       // STREAM: continuous updates (start streaming)
-//       if (name == "subscribeCPU") {
-//         startCPUMonitor(); // Will call emit("cpu", ...) repeatedly
-//       }
-//       
-//       // QUERY: request + stream responses
-//       if (name == "search") {
-//         auto query = data["query"].get<std::string>();
-//         for (auto& result : searchDatabase(query)) {
-//           emit("searchResult", result); // Multiple results
-//         }
-//       }
-//       
-//       // STATE: synced value
-//       if (name == "theme") {
-//         currentTheme = data["mode"].get<std::string>();
-//         emit("theme", data); // Sync back to frontend
-//       }
-//     }
-//   };
-//
-// See Core/Features/Connection/README.md for more details.
+namespace {
+
+std::string makeConnectionDispatchScript(const nlohmann::json &message) {
+	return "(function(){const m=" + message.dump() +
+				 ";if(typeof globalThis.__plusuiConnectionMessage === 'function'){"
+				 "globalThis.__plusuiConnectionMessage(m);}"
+				 "window.dispatchEvent(new CustomEvent('plusui:connection:message',"
+				 "{detail:m}));})();";
+}
+
+} // namespace
+
+void bindConnect(Window &window, Connect &connect) {
+	window.onMessage([&connect](const std::string &message) {
+		connect.dispatchMessage(message);
+	});
+
+	connect.setOutbound([&window](const std::string &message) {
+		try {
+			auto parsed = nlohmann::json::parse(message);
+			window.executeScript(makeConnectionDispatchScript(parsed));
+		} catch (...) {
+			// Ignore malformed outbound payloads
+		}
+	});
+}
 
 }
 

package/Core/Features/Connection/connect.ts

@@ -180,7 +180,93 @@ export const connect = {
   on: <TData = unknown>(name: string, callback: (payload: TData) => void): (() => void) => {
     return connectionClient.on<TData>(name, callback);
   },
+
+  feature: (scope: string): FeatureConnect => {
+    return createFeatureConnect(scope);
+  },
 };
 
 // Export the raw client for advanced use cases (call, fire, stream, channel)
 export const connection = connectionClient;
+
+export type FeatureConnect = {
+  emit: <TIn = Record<string, unknown>>(name: string, payload: TIn) => void;
+  on: <TData = unknown>(name: string, callback: (payload: TData) => void) => (() => void);
+  call: <TOut = unknown, TIn = Record<string, unknown>>(name: string, payload: TIn) => Promise<TOut>;
+  stream: <TData = unknown>(name: string) => {
+    subscribe: (callback: (payload: TData) => void) => (() => void);
+  };
+  channel: <TData = unknown>(name: string) => {
+    subscribe: (callback: (payload: TData) => void) => (() => void);
+    publish: (payload: TData) => void;
+  };
+  scoped: (scope: string) => FeatureConnect;
+};
+
+function scopeName(scope: string, name: string): string {
+  if (name.startsWith(`${scope}.`)) {
+    return name;
+  }
+  return `${scope}.${name}`;
+}
+
+async function invokeScoped(method: string, payload?: unknown): Promise<unknown> {
+  const host = globalThis as any;
+  if (typeof host.__invoke__ !== 'function') {
+    return undefined;
+  }
+
+  const args = payload === undefined ? [] : [payload];
+  return host.__invoke__(method, args);
+}
+
+export function createFeatureConnect(scope: string): FeatureConnect {
+  return {
+    emit: <TIn = Record<string, unknown>>(name: string, payload: TIn) => {
+      const scoped = scopeName(scope, name);
+      void invokeScoped(scoped, payload);
+      connect.emit(scoped, payload);
+
+      if (typeof window !== 'undefined') {
+        window.dispatchEvent(new CustomEvent(`plusui:${scoped}`, { detail: payload }));
+      }
+    },
+    on: <TData = unknown>(name: string, callback: (payload: TData) => void): (() => void) => {
+      const scoped = scopeName(scope, name);
+      const offConnect = connect.on<TData>(scoped, callback);
+
+      if (typeof window === 'undefined') {
+        return offConnect;
+      }
+
+      const domHandler = (event: Event) => {
+        const custom = event as CustomEvent<TData>;
+        callback(custom.detail);
+      };
+
+      window.addEventListener(`plusui:${scoped}`, domHandler as EventListener);
+
+      return () => {
+        offConnect();
+        window.removeEventListener(`plusui:${scoped}`, domHandler as EventListener);
+      };
+    },
+    call: <TOut = unknown, TIn = Record<string, unknown>>(name: string, payload: TIn): Promise<TOut> => {
+      const scoped = scopeName(scope, name);
+      const host = globalThis as any;
+
+      if (typeof host.__invoke__ === 'function') {
+        return invokeScoped(scoped, payload) as Promise<TOut>;
+      }
+
+      return connection.call<TOut, TIn>(scoped, payload);
+    },
+    stream: <TData = unknown>(name: string) => {
+      return connection.stream<TData>(scopeName(scope, name));
+    },
+    channel: <TData = unknown>(name: string) => {
+      return connection.channel<TData>(scopeName(scope, name));
+    },
+    scoped: (childScope: string) => createFeatureConnect(scopeName(scope, childScope)),
+  };
+}

package/Core/Features/Display/display.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export interface DisplayMode {
   width: number;
   height: number;
@@ -32,6 +34,8 @@ export interface Display {
 }
 
 export class DisplayAPI {
+  public readonly connect = connect.feature('display');
+
   constructor(
     private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>
   ) {}

package/Core/Features/FileDrop/filedrop.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 /**
  * FileDrop API - Cross-platform drag & drop file handling
  *
@@ -77,6 +79,7 @@ export interface FileDropAPI {
 }
 
 export class FileDrop implements FileDropAPI {
+  public readonly connect = connect.feature('fileDrop');
   private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>;
   private onFn: (event: string, callback: (data: unknown) => void) => () => void;
 

package/Core/Features/Keyboard/keyboard.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export enum KeyCode {
   Unknown = 0,
   Space = 32,
@@ -53,6 +55,7 @@ export type KeyEventCallback = (event: KeyEvent) => void;
 export type ShortcutCallback = () => void;
 
 export class KeyboardAPI {
+  public readonly connect = connect.feature('keyboard');
   private shortcutHandlers: Map<string, ShortcutCallback> = new Map();
 
   constructor(

package/Core/Features/Menu/menu.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 /**
  * PlusUI Menu API
  *
@@ -68,6 +70,7 @@ export interface ContextInfo {
 // ============================================================================
 
 export class MenuAPI {
+    public readonly connect = connect.feature('menu');
     private clickHandlers: Map<string, (item: MenuItem) => void> = new Map();
     private contextMenuItems: MenuItem[] = [];
     private contextMenuEnabled = false;

package/Core/Features/Tray/tray.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export interface TrayMenuItem {
   id: string;
   label: string;
@@ -16,6 +18,8 @@ export interface TrayIconData {
 }
 
 export class TrayAPI {
+  public readonly connect = connect.feature('tray');
+
   constructor(
     private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>,
     private eventFn: (event: string, callback: (...args: unknown[]) => void) => () => void

package/Core/Features/WebGPU/webgpu.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 /**
  * WebGPU Frontend API Wrapper
  *
@@ -561,6 +563,7 @@ export function createWebGPU(
  * Global WebGPU namespace (like navigator.gpu)
  */
 class WebGPUNamespace {
+  public readonly connect = connect.feature('webgpu');
   private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>;
   private onFn: (event: string, callback: (data: unknown) => void) => () => void;
 

package/Core/Features/Window/window.cpp

@@ -138,6 +138,7 @@ struct Window::Impl {
   ConsoleCallback consoleCallback;
   MessageCallback messageCallback;
   FileDropCallback fileDropCallback;
+  std::map<std::string, JSCallback> bindings;
 
   std::vector<MoveCallback> moveCallbacks;
   std::vector<ResizeCallback> resizeCallbacks;
@@ -1107,17 +1108,14 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                   std::cout << "[PlusUI] Received: " << msg
                                             << std::endl;
 
+                                  bool handledByMessageCallback = false;
+
                                   // New Generic Message Handler
                                   if (pImpl->messageCallback) {
                                     pImpl->messageCallback(msg);
-                                    // If handled by generic handler, do we
-                                    // stop? For now, let's allow legacy to run
-                                    // too for backward compat UNLESS the
-                                    // message is clearly for the new system.
-                                    // The new system uses "kind" field.
                                     if (msg.find("\"kind\"") !=
                                         std::string::npos) {
-                                      return S_OK;
+                                      handledByMessageCallback = true;
                                     }
                                   }
 
@@ -1164,8 +1162,126 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                   id = getId();
                                   method = getMethod();
 
+                                  auto extractFirstParam = [&msg]() {
+                                    size_t paramsPos = msg.find("\"params\"");
+                                    if (paramsPos == std::string::npos)
+                                      return std::string("null");
+                                    size_t colonPos = msg.find(":", paramsPos);
+                                    if (colonPos == std::string::npos)
+                                      return std::string("null");
+                                    size_t arrayStart = msg.find("[", colonPos);
+                                    if (arrayStart == std::string::npos)
+                                      return std::string("null");
+
+                                    size_t i = arrayStart + 1;
+                                    while (i < msg.size() &&
+                                           std::isspace(
+                                               static_cast<unsigned char>(msg[i])))
+                                      ++i;
+                                    if (i >= msg.size() || msg[i] == ']')
+                                      return std::string("null");
+
+                                    size_t start = i;
+                                    if (msg[i] == '"') {
+                                      ++i;
+                                      bool escaped = false;
+                                      while (i < msg.size()) {
+                                        char c = msg[i];
+                                        if (escaped) {
+                                          escaped = false;
+                                        } else if (c == '\\') {
+                                          escaped = true;
+                                        } else if (c == '"') {
+                                          ++i;
+                                          break;
+                                        }
+                                        ++i;
+                                      }
+                                      return msg.substr(start, i - start);
+                                    }
+
+                                    int depth = 0;
+                                    bool inString = false;
+                                    bool escaped = false;
+                                    while (i < msg.size()) {
+                                      char c = msg[i];
+                                      if (inString) {
+                                        if (escaped) {
+                                          escaped = false;
+                                        } else if (c == '\\') {
+                                          escaped = true;
+                                        } else if (c == '"') {
+                                          inString = false;
+                                        }
+                                      } else {
+                                        if (c == '"') {
+                                          inString = true;
+                                        } else if (c == '{' || c == '[') {
+                                          ++depth;
+                                        } else if (c == '}' || c == ']') {
+                                          if (depth == 0) {
+                                            break;
+                                          }
+                                          --depth;
+                                        } else if (c == ',' && depth == 0) {
+                                          break;
+                                        }
+                                      }
+                                      ++i;
+                                    }
+                                    return msg.substr(start, i - start);
+                                  };
+
+                                  auto decodeJsonString =
+                                      [](const std::string &input) {
+                                        if (input.size() < 2 ||
+                                            input.front() != '"' ||
+                                            input.back() != '"') {
+                                          return input;
+                                        }
+
+                                        std::string decoded;
+                                        decoded.reserve(input.size() - 2);
+                                        for (size_t i = 1; i + 1 < input.size();
+                                             ++i) {
+                                          char c = input[i];
+                                          if (c == '\\' && i + 1 < input.size() - 1) {
+                                            char next = input[++i];
+                                            switch (next) {
+                                            case '"':
+                                              decoded.push_back('"');
+                                              break;
+                                            case '\\':
+                                              decoded.push_back('\\');
+                                              break;
+                                            case '/':
+                                              decoded.push_back('/');
+                                              break;
+                                            case 'n':
+                                              decoded.push_back('\n');
+                                              break;
+                                            case 'r':
+                                              decoded.push_back('\r');
+                                              break;
+                                            case 't':
+                                              decoded.push_back('\t');
+                                              break;
+                                            default:
+                                              decoded.push_back(next);
+                                              break;
+                                            }
+                                          } else {
+                                            decoded.push_back(c);
+                                          }
+                                        }
+                                        return decoded;
+                                      };
+
                                   // Route to handlers
-                                  if (method.find("window.") == 0) {
+                                  if (handledByMessageCallback) {
+                                    success = true;
+                                    result = "null";
+                                  } else if (method.find("window.") == 0) {
                                     std::string winMethod = method.substr(7);
                                     if (winMethod == "minimize") {
                                       if (pImpl->window)
@@ -1417,6 +1533,30 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                                "clearCallbacks") {
                                       success = true;
                                     }
+                                  } else if (method.find("webview.") == 0) {
+                                    std::string bindingName = method.substr(8);
+                                    auto bindingIt =
+                                        pImpl->bindings.find(bindingName);
+                                    if (bindingIt != pImpl->bindings.end()) {
+                                      std::string rawParam =
+                                          extractFirstParam();
+                                      std::string callbackArg =
+                                          decodeJsonString(rawParam);
+                                      try {
+                                        result =
+                                            bindingIt->second(callbackArg);
+                                        if (result.empty()) {
+                                          result = "null";
+                                        }
+                                        success = true;
+                                      } catch (const std::exception &e) {
+                                        std::cerr
+                                            << "[PlusUI] webview binding error: "
+                                            << e.what() << std::endl;
+                                        result = "null";
+                                        success = true;
+                                      }
+                                    }
                                   }
 
                                   // Send response back to JS (matches
@@ -1654,6 +1794,35 @@ void Window::onFileDrop(FileDropCallback callback) {
   pImpl->fileDropCallback = callback;
 }
 
+void Window::bind(const std::string &name, JSCallback callback) {
+  pImpl->bindings[name] = callback;
+
+  std::string bridgeScript =
+      "window." + name +
+      R"( = function(...args) {
+  if (window.plusui && typeof window.plusui.invoke === 'function') {
+    const payload = args.length === 0 ? null : (args.length === 1 ? args[0] : args);
+    return window.plusui.invoke('webview.)" +
+      name +
+      R"(', [payload]);
+  }
+  if (window.__invoke__) {
+    const payload = args.length === 0 ? null : (args.length === 1 ? args[0] : args);
+    return window.__invoke__('webview.)" +
+      name +
+      R"(', [payload]);
+  }
+  return Promise.resolve(null);
+};)";
+
+  executeScript(bridgeScript);
+}
+
+void Window::unbind(const std::string &name) {
+  pImpl->bindings.erase(name);
+  executeScript("delete window." + name + ";");
+}
+
 void Window::loadURL(const std::string &url) { navigate(url); }
 
 void Window::loadHTML(const std::string &html) {

package/Core/Features/Window/window.ts

@@ -1,3 +1,5 @@
+import { connect } from '../Connection/connect';
+
 export interface WindowSize {
   width: number;
   height: number;
@@ -42,6 +44,8 @@ async function invoke(method: string, args?: unknown[]): Promise<unknown> {
 }
 
 export const window = {
+  connect: connect.feature('window'),
+
   async minimize(id?: WindowId): Promise<void> {
     await invoke('window.minimize', id ? [id] : []);
   },

package/Core/include/plusui/connect.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <functional>
+#include <map>
 #include <nlohmann/json.hpp>
 #include <string>
+#include <vector>
 
 // ============================================
 // PlusUI Connect Feature
@@ -60,12 +62,61 @@
 
 namespace plusui {
 
+class Window;
+
 class Connect {
+public:
+  using EventHandler = std::function<void(const nlohmann::json &)>;
+  using CallHandler =
+      std::function<nlohmann::json(const nlohmann::json &)>;
+  using SubscriptionHandler =
+      std::function<void(bool subscribed, const nlohmann::json &)>;
+
+private:
   std::function<void(const std::string &)> outboundHandler;
+  std::map<std::string, std::vector<EventHandler>> eventHandlers;
+  std::map<std::string, CallHandler> callHandlers;
+  std::map<std::string, SubscriptionHandler> subscriptionHandlers;
+
+  void emitEnvelope(const std::string &kind, const std::string &name,
+                    const nlohmann::json &payload,
+                    const std::string &id = std::string(),
+                    const std::string &error = std::string()) {
+    if (!outboundHandler) {
+      return;
+    }
+
+    nlohmann::json j;
+    j["kind"] = kind;
+    j["name"] = name;
+    if (!id.empty()) {
+      j["id"] = id;
+    }
+    j["payload"] = payload;
+    if (!error.empty()) {
+      j["error"] = error;
+    }
+
+    outboundHandler(j.dump());
+  }
 
-public:
   virtual ~Connect() = default;
 
+  // Mirror frontend API: register message listener by name
+  void on(const std::string &name, EventHandler handler) {
+    eventHandlers[name].push_back(std::move(handler));
+  }
+
+  // Request/response helper for call primitive
+  void onCall(const std::string &name, CallHandler handler) {
+    callHandlers[name] = std::move(handler);
+  }
+
+  // Subscription helper for stream/query primitives
+  void onSubscription(const std::string &name, SubscriptionHandler handler) {
+    subscriptionHandlers[name] = std::move(handler);
+  }
+
   // Setup the outbound message handler
   void setOutbound(std::function<void(const std::string &)> h) {
     outboundHandler = std::move(h);
@@ -86,28 +137,94 @@ public:
    *   - STATE: emit("theme", {{"mode", "dark"}})
    */
   void emit(const std::string &name, const nlohmann::json &payload) {
-    if (!outboundHandler) {
-      return;
-    }
+    emitEnvelope("event", name, payload);
+  }
 
-    nlohmann::json j;
-    j["kind"] = "event";
-    j["name"] = name;
-    j["payload"] = payload;
+  void emitResult(const std::string &id, const std::string &name,
+                  const nlohmann::json &payload) {
+    emitEnvelope("result", name, payload, id);
+  }
 
-    outboundHandler(j.dump());
+  void emitError(const std::string &id, const std::string &name,
+                 const std::string &message) {
+    emitEnvelope("error", name, nlohmann::json::object(), id, message);
   }
 
   // Parse and dispatch incoming messages from frontend
   void dispatchMessage(const std::string &message) {
     try {
       auto j = nlohmann::json::parse(message);
-      std::string name = j.value("name", "");
-      nlohmann::json payload = j.value("payload", nlohmann::json::object());
+      nlohmann::json envelope = j;
+
+      if (j.is_object() && j.value("method", std::string()) ==
+                               "connection.dispatch") {
+        auto paramsIt = j.find("params");
+        if (paramsIt != j.end() && paramsIt->is_array() &&
+            !paramsIt->empty() && (*paramsIt)[0].is_object()) {
+          envelope = (*paramsIt)[0];
+        }
+      }
+
+      std::string name = envelope.value("name", "");
+      nlohmann::json payload =
+          envelope.value("payload", nlohmann::json::object());
+      std::string kind = envelope.value("kind", "fire");
+      std::string id = envelope.value("id", "");
       
-      if (!name.empty()) {
-        handleMessage(name, payload);
+      if (name.empty()) {
+        return;
       }
+
+      if (kind == "call") {
+        try {
+          nlohmann::json responsePayload = nlohmann::json::object();
+          auto callIt = callHandlers.find(name);
+          if (callIt != callHandlers.end()) {
+            responsePayload = callIt->second(payload);
+          } else {
+            responsePayload = handleCall(name, payload);
+          }
+          if (!id.empty()) {
+            emitResult(id, name, responsePayload);
+          }
+        } catch (const std::exception &e) {
+          if (!id.empty()) {
+            emitError(id, name, e.what());
+          }
+        } catch (...) {
+          if (!id.empty()) {
+            emitError(id, name, "Unknown error");
+          }
+        }
+        return;
+      }
+
+      if (kind == "sub") {
+        auto subIt = subscriptionHandlers.find(name);
+        if (subIt != subscriptionHandlers.end()) {
+          subIt->second(true, payload);
+        }
+        handleSubscription(name, true, payload);
+        return;
+      }
+
+      if (kind == "unsub") {
+        auto subIt = subscriptionHandlers.find(name);
+        if (subIt != subscriptionHandlers.end()) {
+          subIt->second(false, payload);
+        }
+        handleSubscription(name, false, payload);
+        return;
+      }
+
+      auto listenersIt = eventHandlers.find(name);
+      if (listenersIt != eventHandlers.end()) {
+        for (const auto &listener : listenersIt->second) {
+          listener(payload);
+        }
+      }
+
+      handleMessage(name, payload);
     } catch (...) {
       // Silently ignore malformed messages
     }
@@ -116,6 +233,19 @@ public:
   void dispatch(const std::string &message) { dispatchMessage(message); }
 
 protected:
+  virtual nlohmann::json handleCall(const std::string &name,
+                                    const nlohmann::json &payload) {
+    handleMessage(name, payload);
+    return nlohmann::json::object();
+  }
+
+  virtual void handleSubscription(const std::string &name, bool subscribed,
+                                  const nlohmann::json &payload) {
+    (void)name;
+    (void)subscribed;
+    (void)payload;
+  }
+
   /**
    * handleMessage() - Receive messages from the frontend
    * 
@@ -136,9 +266,15 @@ protected:
    *     }
    *   }
    */
-  virtual void handleMessage(const std::string &name, const nlohmann::json &payload) = 0;
+  virtual void handleMessage(const std::string &name,
+                             const nlohmann::json &payload) {
+    (void)name;
+    (void)payload;
+  }
 };
 
+void bindConnect(Window &window, Connect &connect);
+
 // Legacy alias for backwards compatibility
 using Bridge = Connect;
 using Connection = Connect;

package/Core/include/plusui/connection.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+#include <plusui/connect.hpp>

package/Core/include/plusui/plusui.hpp

@@ -26,6 +26,7 @@
 #include <plusui/browser.hpp>
 #include <plusui/clipboard.hpp>
 #include <plusui/connect.hpp>
+#include <plusui/connection.hpp>
 #include <plusui/display.hpp>
 #include <plusui/filedrop.hpp>
 #include <plusui/keyboard.hpp>

package/Core/include/plusui/window.hpp

@@ -161,11 +161,14 @@ public:
   bool canGoForward() const;
 
   // Scripting
+  using JSCallback = std::function<std::string(const std::string &)>;
   void executeScript(const std::string &script);
   void executeScript(const std::string &script, StringCallback callback);
   void eval(const std::string &js) {
     executeScript(js);
   } // Alias for compatibility
+  void bind(const std::string &name, JSCallback callback);
+  void unbind(const std::string &name);
 
   template <typename T> std::future<T> evaluate(const std::string &js) {
     // Implementation in cpp or inline

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plusui-native-core",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "description": "PlusUI Core framework (frontend + backend implementations)",
   "type": "module",
   "files": [