@push.rocks/smartrust 1.3.0 → 1.3.2

package/changelog.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 2026-03-14 - 1.3.2 - fix(rustbinarylocator)
+support resolving platform-suffixed local Rust binaries
+
+- Checks local Rust build paths for binaries with platform suffixes such as _linux_amd64 in addition to unsuffixed names
+- Adds platform and architecture suffix mapping for linux, darwin, windows, x64, and arm64
+
+## 2026-02-26 - 1.3.1 - fix(readme)
+document socket transport and clarify stdio/socket differences in README
+
+- Add 'Two Transport Modes' section documenting stdio (spawn) and socket (connect) modes
+- Add examples for connect(), socket usage, and auto-reconnect with exponential backoff
+- Clarify protocol is transport-agnostic and update ready/stream/event descriptions
+- Update event docs: mark stderr as stdio-only and add 'reconnected' event for socket transports
+- Clarify kill() behavior for both stdio and socket transports
+- Add API reference entries for SocketTransport, StdioTransport, ISocketConnectOptions, IRustTransport, and LineScanner
+- Add platform notes, architecture diagram, and minimal Rust/socket usage guidance
+
 ## 2026-02-26 - 1.3.0 - feat(transport)
 introduce transport abstraction and socket-mode support for RustBridge
 

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartrust',
-    version: '1.3.0',
+    version: '1.3.2',
     description: 'a bridge between JS engines and rust'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHNDQUFzQztDQUNwRCxDQUFBIn0=

package/dist_ts/classes.rustbinarylocator.d.ts

@@ -24,5 +24,6 @@ export declare class RustBinaryLocator {
     private searchBinary;
     private findPlatformPackageBinary;
     private isExecutable;
+    private getPlatformSuffix;
     private findInPath;
 }

package/dist_ts/classes.rustbinarylocator.js

@@ -70,11 +70,18 @@ export class RustBinaryLocator {
             plugins.path.resolve(process.cwd(), `rust/target/release/${binaryName}`),
             plugins.path.resolve(process.cwd(), `rust/target/debug/${binaryName}`),
         ];
+        const platformSuffix = this.getPlatformSuffix();
         for (const localPath of localPaths) {
             if (await this.isExecutable(localPath)) {
                 this.logger.log('info', `Binary found at local path: ${localPath}`);
                 return localPath;
             }
+            // Also try with platform suffix (tsrust convention: binaryName_linux_amd64)
+            const suffixedPath = `${localPath}_${platformSuffix}`;
+            if (await this.isExecutable(suffixedPath)) {
+                this.logger.log('info', `Binary found at local path (platform-suffixed): ${suffixedPath}`);
+                return suffixedPath;
+            }
         }
         // 5. System PATH
         if (this.options.searchSystemPath !== false) {
@@ -123,6 +130,13 @@ export class RustBinaryLocator {
             }
         }
     }
+    getPlatformSuffix() {
+        const archMap = { x64: 'amd64', arm64: 'arm64' };
+        const platformMap = { linux: 'linux', darwin: 'darwin', win32: 'windows' };
+        const platform = platformMap[process.platform] || process.platform;
+        const arch = archMap[process.arch] || process.arch;
+        return `${platform}_${arch}`;
+    }
     async findInPath(binaryName) {
         const pathDirs = (process.env.PATH || '').split(plugins.path.delimiter);
         for (const dir of pathDirs) {
@@ -134,4 +148,4 @@ export class RustBinaryLocator {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5ydXN0YmluYXJ5bG9jYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NsYXNzZXMucnVzdGJpbmFyeWxvY2F0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFHeEMsTUFBTSxhQUFhLEdBQXNCO0lBQ3ZDLEdBQUcsS0FBSSxDQUFDO0NBQ1QsQ0FBQztBQUVGOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLE9BQU8saUJBQWlCO0lBQ3BCLE9BQU8sQ0FBd0I7SUFDL0IsTUFBTSxDQUFvQjtJQUMxQixVQUFVLEdBQWtCLElBQUksQ0FBQztJQUV6QyxZQUFZLE9BQThCLEVBQUUsTUFBMEI7UUFDcEUsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLElBQUksYUFBYSxDQUFDO0lBQ3hDLENBQUM7SUFFRDs7O09BR0c7SUFDSSxLQUFLLENBQUMsVUFBVTtRQUNyQixJQUFJLElBQUksQ0FBQyxVQUFVLEtBQUssSUFBSSxFQUFFLENBQUM7WUFDN0IsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDO1FBQ3pCLENBQUM7UUFDRCxNQUFNLElBQUksR0FBRyxNQUFNLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUN2QyxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQztRQUN2QixPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRDs7T0FFRztJQUNJLFVBQVU7UUFDZixJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQztJQUN6QixDQUFDO0lBRU8sS0FBSyxDQUFDLFlBQVk7UUFDeEIsTUFBTSxFQUFFLFVBQVUsRUFBRSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUM7UUFFcEMsbUNBQW1DO1FBQ25DLElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUM1QixJQUFJLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQUM7Z0JBQ3JELElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxtQ0FBbUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsQ0FBQyxDQUFDO2dCQUN0RixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDO1lBQ2pDLENBQUM7WUFDRCxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsd0NBQXdDLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQztRQUM3RixDQUFDO1FBRUQsbUNBQW1DO1FBQ25DLElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUM1QixNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDckQsSUFBSSxPQUFPLEVBQUUsQ0FBQztnQkFDWixJQUFJLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO29CQUNyQyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsb0JBQW9CLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSxLQUFLLE9BQU8sRUFBRSxDQUFDLENBQUM7b0JBQ25GLE9BQU8sT0FBTyxDQUFDO2dCQUNqQixDQUFDO2dCQUNELElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSw0QkFBNEIsT0FBTyxFQUFFLENBQUMsQ0FBQztZQUMzRixDQUFDO1FBQ0gsQ0FBQztRQUVELG1DQUFtQztRQUNuQyxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMscUJBQXFCLEVBQUUsQ0FBQztZQUN2QyxNQUFNLGNBQWMsR0FBRyxNQUFNLElBQUksQ0FBQyx5QkFBeUIsRUFBRSxDQUFDO1lBQzlELElBQUksY0FBYyxFQUFFLENBQUM7Z0JBQ25CLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxxQ0FBcUMsY0FBYyxFQUFFLENBQUMsQ0FBQztnQkFDL0UsT0FBTyxjQUFjLENBQUM7WUFDeEIsQ0FBQztRQUNILENBQUM7UUFFRCxtQ0FBbUM7UUFDbkMsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLElBQUk7WUFDNUMsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLHVCQUF1QixVQUFVLEVBQUUsQ0FBQztZQUN4RSxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEVBQUUscUJBQXFCLFVBQVUsRUFBRSxDQUFDO1NBQ3ZFLENBQUM7UUFDRixNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztRQUNoRCxLQUFLLE1BQU0sU0FBUyxJQUFJLFVBQVUsRUFBRSxDQUFDO1lBQ25DLElBQUksTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUM7Z0JBQ3ZDLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSwrQkFBK0IsU0FBUyxFQUFFLENBQUMsQ0FBQztnQkFDcEUsT0FBTyxTQUFTLENBQUM7WUFDbkIsQ0FBQztZQUNELDRFQUE0RTtZQUM1RSxNQUFNLFlBQVksR0FBRyxHQUFHLFNBQVMsSUFBSSxjQUFjLEVBQUUsQ0FBQztZQUN0RCxJQUFJLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxZQUFZLENBQUMsRUFBRSxDQUFDO2dCQUMxQyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsbURBQW1ELFlBQVksRUFBRSxDQUFDLENBQUM7Z0JBQzNGLE9BQU8sWUFBWSxDQUFDO1lBQ3RCLENBQUM7UUFDSCxDQUFDO1FBRUQsaUJBQWlCO1FBQ2pCLElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxnQkFBZ0IsS0FBSyxLQUFLLEVBQUUsQ0FBQztZQUM1QyxNQUFNLFVBQVUsR0FBRyxNQUFNLElBQUksQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDckQsSUFBSSxVQUFVLEVBQUUsQ0FBQztnQkFDZixJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsZ0NBQWdDLFVBQVUsRUFBRSxDQUFDLENBQUM7Z0JBQ3RFLE9BQU8sVUFBVSxDQUFDO1lBQ3BCLENBQUM7UUFDSCxDQUFDO1FBRUQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLGNBQWMsVUFBVSx3R0FBd0csQ0FBQyxDQUFDO1FBQzNKLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVPLEtBQUssQ0FBQyx5QkFBeUI7UUFDckMsTUFBTSxFQUFFLFVBQVUsRUFBRSxxQkFBcUIsRUFBRSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDM0QsTUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQztRQUNsQyxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDO1FBQzFCLE1BQU0sV0FBVyxHQUFHLEdBQUcscUJBQXFCLElBQUksUUFBUSxJQUFJLElBQUksRUFBRSxDQUFDO1FBRW5FLElBQUksQ0FBQztZQUNILE1BQU0sUUFBUSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsV0FBVyxJQUFJLFVBQVUsRUFBRSxDQUFDLENBQUM7WUFDckUsTUFBTSxXQUFXLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLENBQUM7WUFDeEQsSUFBSSxNQUFNLElBQUksQ0FBQyxZQUFZLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQztnQkFDekMsT0FBTyxXQUFXLENBQUM7WUFDckIsQ0FBQztRQUNILENBQUM7UUFBQyxNQUFNLENBQUM7WUFDUCxtREFBbUQ7UUFDckQsQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVPLEtBQUssQ0FBQyxZQUFZLENBQUMsUUFBZ0I7UUFDekMsSUFBSSxDQUFDO1lBQ0gsTUFBTSxPQUFPLENBQUMsRUFBRSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3RFLE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztRQUFDLE1BQU0sQ0FBQztZQUNQLHVFQUF1RTtZQUN2RSw2QkFBNkI7WUFDN0IsSUFBSSxDQUFDO2dCQUNILE1BQU0sT0FBTyxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLFFBQVEsRUFBRSxPQUFPLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDdEUsTUFBTSxPQUFPLENBQUMsRUFBRSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLEtBQUssQ0FBQyxDQUFDO2dCQUNqRCxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsNkNBQTZDLFFBQVEsRUFBRSxDQUFDLENBQUM7Z0JBQ2pGLE9BQU8sSUFBSSxDQUFDO1lBQ2QsQ0FBQztZQUFDLE1BQU0sQ0FBQztnQkFDUCxPQUFPLEtBQUssQ0FBQztZQUNmLENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQztJQUVPLGlCQUFpQjtRQUN2QixNQUFNLE9BQU8sR0FBMkIsRUFBRSxHQUFHLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsQ0FBQztRQUN6RSxNQUFNLFdBQVcsR0FBMkIsRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxDQUFDO1FBQ25HLE1BQU0sUUFBUSxHQUFHLFdBQVcsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQztRQUNuRSxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUM7UUFDbkQsT0FBTyxHQUFHLFFBQVEsSUFBSSxJQUFJLEVBQUUsQ0FBQztJQUMvQixDQUFDO0lBRU8sS0FBSyxDQUFDLFVBQVUsQ0FBQyxVQUFrQjtRQUN6QyxNQUFNLFFBQVEsR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ3hFLEtBQUssTUFBTSxHQUFHLElBQUksUUFBUSxFQUFFLENBQUM7WUFDM0IsTUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1lBQ3BELElBQUksTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7Z0JBQ3RDLE9BQU8sUUFBUSxDQUFDO1lBQ2xCLENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0NBQ0YifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartrust",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "private": false,
   "description": "a bridge between JS engines and rust",
   "main": "dist_ts/index.js",

package/readme.md

@@ -1,6 +1,6 @@
 # @push.rocks/smartrust
 
-A type-safe, production-ready bridge between TypeScript and Rust binaries via JSON-over-stdin/stdout IPC — with support for request/response, streaming, and event patterns.
+A type-safe, production-ready bridge between TypeScript and Rust binaries — with support for **stdio** (child process) and **socket** (Unix socket / Windows named pipe) transports, request/response, streaming, and event patterns.
 
 ## Issue Reporting and Security
 
@@ -16,25 +16,34 @@ pnpm install @push.rocks/smartrust
 
 ## Overview 🔭
 
-`@push.rocks/smartrust` provides a complete bridge for TypeScript applications that need to communicate with Rust binaries. It handles the entire lifecycle — binary discovery, process spawning, request/response correlation, **streaming responses**, event pub/sub, and graceful shutdown — so you can focus on your command definitions instead of IPC plumbing.
+`@push.rocks/smartrust` provides a complete bridge for TypeScript applications that need to communicate with Rust binaries. It handles the entire lifecycle — binary discovery, process spawning **or socket connection**, request/response correlation, **streaming responses**, event pub/sub, and graceful shutdown — so you can focus on your command definitions instead of IPC plumbing.
+
+### Two Transport Modes 🔌
+
+| Mode | Method | Use Case |
+|------|--------|----------|
+| **Stdio** | `bridge.spawn()` | Spawn the Rust binary as a child process. Communicate via stdin/stdout. |
+| **Socket** | `bridge.connect(path)` | Connect to an **already-running** Rust daemon via Unix socket or Windows named pipe. |
+
+The JSON protocol is identical in both modes — only the transport layer changes. Socket mode enables use cases where the Rust binary runs as a **privileged system service** (e.g., a VPN daemon needing root for TUN devices, a network proxy binding to privileged ports) while the TypeScript app connects to it unprivileged.
 
 ### Why? 🤔
 
 If you're integrating Rust into a Node.js project, you'll inevitably need:
 - A way to **find** the compiled Rust binary across different environments (dev, CI, production, platform packages)
-- A way to **spawn** it and establish reliable two-way communication
+- A way to **spawn it** or **connect to it** and establish reliable two-way communication
 - **Type-safe** request/response patterns with proper error handling
 - **Streaming responses** for progressive data processing, log tailing, or chunked transfers
 - **Event streaming** from Rust to TypeScript
-- **Graceful lifecycle management** (ready detection, clean shutdown, force kill)
+- **Graceful lifecycle management** (ready detection, clean shutdown, auto-reconnection)
 
-`smartrust` wraps all of this into three classes: `RustBridge`, `RustBinaryLocator`, and `StreamingResponse`.
+`smartrust` wraps all of this into a clean API: `RustBridge`, `RustBinaryLocator`, `StreamingResponse`, and pluggable transports.
 
 ## Usage 🚀
 
 ### The IPC Protocol
 
-`smartrust` uses a simple, newline-delimited JSON protocol over stdin/stdout:
+`smartrust` uses a simple, newline-delimited JSON protocol:
 
 | Direction | Format | Description |
 |-----------|--------|-------------|
@@ -44,7 +53,7 @@ If you're integrating Rust into a Node.js project, you'll inevitably need:
 | **Rust → TS** (Stream Chunk) | `{"id": "req_1", "stream": true, "data": {...}}` | Intermediate chunk (zero or more) |
 | **Rust → TS** (Event) | `{"event": "ready", "data": {...}}` | Unsolicited event (no ID) |
 
-Your Rust binary reads JSON lines from stdin and writes JSON lines to stdout. That's it. Stderr is free for logging.
+This protocol works identically over stdio and socket transports. Your Rust binary reads JSON lines from one end and writes JSON lines to the other. That's it.
 
 ### Defining Your Commands
 
@@ -62,7 +71,9 @@ type TMyCommands = {
 };
 ```
 
-### Creating and Using the Bridge
+### Stdio Mode — Spawn a Child Process
+
+This is the classic mode. The bridge spawns the Rust binary and communicates via stdin/stdout:
 
 ```typescript
 const bridge = new RustBridge<TMyCommands>({
@@ -90,10 +101,62 @@ bridge.on('management:configChanged', (data) => {
   console.log('Config was changed:', data);
 });
 
-// Clean shutdown
+// Clean shutdown (SIGTERM → SIGKILL after 5s)
+bridge.kill();
+```
+
+### Socket Mode — Connect to a Running Daemon 🔗
+
+When the Rust binary runs as a system service (e.g., via `systemd`, `launchd`, or a Windows Service), use `connect()` to talk to it over a Unix socket or named pipe:
+
+```typescript
+const bridge = new RustBridge<TMyCommands>({
+  binaryName: 'my-daemon',  // used for logging / error messages
+});
+
+// Connect to the daemon's management socket
+const ok = await bridge.connect('/var/run/my-daemon.sock');
+if (!ok) {
+  console.error('Failed to connect to daemon');
+  process.exit(1);
+}
+
+// Same API as stdio mode — completely transparent!
+const { pid } = await bridge.sendCommand('start', { port: 8080, host: '0.0.0.0' });
+const metrics = await bridge.sendCommand('getMetrics', {});
+
+// kill() closes the socket — it does NOT kill the daemon
 bridge.kill();
 ```
 
+#### Auto-Reconnect
+
+For long-running applications, enable automatic reconnection with exponential backoff:
+
+```typescript
+const ok = await bridge.connect('/var/run/my-daemon.sock', {
+  autoReconnect: true,          // reconnect on unexpected disconnect
+  reconnectBaseDelayMs: 100,    // initial retry delay (doubles each attempt)
+  reconnectMaxDelayMs: 30000,   // max retry delay cap
+  maxReconnectAttempts: 10,     // give up after 10 attempts
+});
+
+// Listen for reconnection events
+bridge.on('reconnected', () => {
+  console.log('Reconnected to daemon!');
+});
+```
+
+#### Platform Notes
+
+| Platform | Socket Path Format | Example |
+|----------|-------------------|---------|
+| **Linux** | `/var/run/<name>.sock` or `$XDG_RUNTIME_DIR/<name>.sock` | `/var/run/my-daemon.sock` |
+| **macOS** | `/var/run/<name>.sock` | `/var/run/my-daemon.sock` |
+| **Windows** | `\\.\pipe\<name>` | `\\.\pipe\my-daemon` |
+
+Node.js `net.connect()` handles all formats transparently — no platform-specific code needed.
+
 ### Streaming Commands 🌊
 
 For commands where the Rust binary sends a series of chunks before a final result, use `sendCommandStreaming`. This is perfect for progressive data processing, log tailing, search results, or any scenario where you want incremental output.
@@ -231,6 +294,17 @@ const bridge = new RustBridge<TMyCommands>({
 });
 ```
 
+Socket connection options (passed to `bridge.connect()`):
+
+```typescript
+interface ISocketConnectOptions {
+  autoReconnect?: boolean;         // default: false
+  reconnectBaseDelayMs?: number;   // default: 100
+  reconnectMaxDelayMs?: number;    // default: 30000
+  maxReconnectAttempts?: number;   // default: 10
+}
+```
+
 ### Events 📡
 
 `RustBridge` extends `EventEmitter` and emits the following events:
@@ -238,8 +312,9 @@ const bridge = new RustBridge<TMyCommands>({
 | Event | Payload | Description |
 |-------|---------|-------------|
 | `ready` | — | Bridge connected and binary reported ready |
-| `exit` | `(code, signal)` | Rust process exited |
-| `stderr` | `string` | A line from the binary's stderr |
+| `exit` | `(code, signal)` | Transport closed (process exited or socket disconnected) |
+| `stderr` | `string` | A line from the binary's stderr (stdio mode only) |
+| `reconnected` | — | Socket transport reconnected after unexpected disconnect |
 | `management:<name>` | `any` | Custom event from Rust (e.g. `management:configChanged`) |
 
 ### Custom Logger 📝
@@ -263,7 +338,9 @@ const bridge = new RustBridge<TMyCommands>({
 
 ### Writing the Rust Side 🦀
 
-Your Rust binary needs to implement a simple protocol:
+Your Rust binary needs to implement a simple protocol. The transport (stdio or socket) doesn't change the message format — only how connections are established.
+
+#### Stdio Mode (Child Process)
 
 1. **On startup**, write a ready event to stdout:
    ```
@@ -280,7 +357,14 @@ Your Rust binary needs to implement a simple protocol:
 
 6. **Use stderr** for logging — it won't interfere with the IPC protocol
 
-Here's a minimal Rust skeleton:
+#### Socket Mode (Daemon)
+
+1. **Listen** on a Unix socket (e.g., `/var/run/my-daemon.sock`) or Windows named pipe
+2. **On each new client connection**, send the `{"event":"ready","data":{...}}\n` event
+3. Read/write JSON lines on the socket (same protocol as stdio)
+4. Support multiple concurrent clients — each connection is independent
+
+Here's a minimal Rust skeleton (stdio mode):
 
 ```rust
 use serde::{Deserialize, Serialize};
@@ -368,6 +452,33 @@ fn main() {
 }
 ```
 
+## Architecture 🏗️
+
+```
+┌──────────────────────────────────────────────────────┐
+│                    RustBridge<T>                      │
+│  (protocol layer: handleLine, sendCommand, events)   │
+├──────────────┬───────────────────────────────────────┤
+│ StdioTransport │         SocketTransport             │
+│  spawn() +     │   net.connect() + auto-reconnect    │
+│  stdin/stdout  │   Unix socket / named pipe          │
+├──────────────┴───────────────────────────────────────┤
+│               IRustTransport interface               │
+│         connect() / write() / disconnect()           │
+├──────────────────────────────────────────────────────┤
+│       LineScanner (shared newline scanner)            │
+├──────────────────────────────────────────────────────┤
+│              RustBinaryLocator                        │
+│  (binary search — stdio mode only)                   │
+└──────────────────────────────────────────────────────┘
+```
+
+- **`RustBridge`** — The main class. Protocol-level logic (JSON parsing, request correlation, streaming, events) is transport-agnostic.
+- **`StdioTransport`** — Spawns a child process, manages stdin/stdout/stderr, handles SIGTERM/SIGKILL.
+- **`SocketTransport`** — Connects to an existing Unix socket or named pipe, with optional auto-reconnect and exponential backoff.
+- **`LineScanner`** — Shared buffer-based newline scanner used by both transports for efficient message framing.
+- **`RustBinaryLocator`** — Priority-ordered binary search (used by stdio mode only).
+
 ## API Reference 📖
 
 ### `RustBridge<TCommands>`
@@ -375,11 +486,12 @@ fn main() {
 | Method / Property | Signature | Description |
 |---|---|---|
 | `constructor` | `new RustBridge<T>(options: IRustBridgeOptions)` | Create a new bridge instance |
-| `spawn()` | `Promise<boolean>` | Spawn the binary and wait for ready; returns `false` on failure |
+| `spawn()` | `Promise<boolean>` | **Stdio mode**: Spawn the binary and wait for ready; returns `false` on failure |
+| `connect(socketPath, options?)` | `Promise<boolean>` | **Socket mode**: Connect to a running daemon; returns `false` on failure |
 | `sendCommand(method, params)` | `Promise<TCommands[K]['result']>` | Send a typed command and await the response |
 | `sendCommandStreaming(method, params)` | `StreamingResponse<TChunk, TResult>` | Send a streaming command; returns immediately |
-| `kill()` | `void` | SIGTERM the process, reject pending requests, force SIGKILL after 5s |
-| `running` | `boolean` | Whether the bridge is currently connected |
+| `kill()` | `void` | Stdio: SIGTERM the process, SIGKILL after 5s. Socket: close the connection (daemon stays alive) |
+| `running` | `boolean` | Whether the bridge is currently connected and ready |
 
 ### `StreamingResponse<TChunk, TResult>`
 
@@ -396,13 +508,43 @@ fn main() {
 | `findBinary()` | `Promise<string \| null>` | Find the binary using the priority search; result is cached |
 | `clearCache()` | `void` | Clear the cached path to force a fresh search |
 
+### `StdioTransport`
+
+| Method / Property | Signature | Description |
+|---|---|---|
+| `constructor` | `new StdioTransport(options: IStdioTransportOptions)` | Create a stdio transport |
+| `connect()` | `Promise<void>` | Spawn the child process |
+| `write(data)` | `Promise<void>` | Write to stdin with backpressure handling |
+| `disconnect()` | `void` | Kill the process (SIGTERM → SIGKILL after 5s) |
+| `connected` | `boolean` | Whether the process is running |
+
+### `SocketTransport`
+
+| Method / Property | Signature | Description |
+|---|---|---|
+| `constructor` | `new SocketTransport(options: ISocketTransportOptions)` | Create a socket transport |
+| `connect()` | `Promise<void>` | Connect to the Unix socket / named pipe |
+| `write(data)` | `Promise<void>` | Write to socket with backpressure handling |
+| `disconnect()` | `void` | Close the socket (does not kill the daemon) |
+| `connected` | `boolean` | Whether the socket is connected |
+
+### `LineScanner`
+
+| Method / Property | Signature | Description |
+|---|---|---|
+| `constructor` | `new LineScanner(maxPayloadSize, logger)` | Create a line scanner |
+| `push(chunk, onLine)` | `void` | Feed a `Buffer` chunk; calls `onLine` for each complete line |
+| `clear()` | `void` | Reset the internal buffer |
+
 ### Exported Interfaces & Types
 
 | Interface / Type | Description |
 |---|---|
 | `IRustBridgeOptions` | Full configuration for `RustBridge` |
 | `IBinaryLocatorOptions` | Configuration for `RustBinaryLocator` |
+| `ISocketConnectOptions` | Socket connection options (reconnect settings) |
 | `IRustBridgeLogger` | Logger interface: `{ log(level, message, data?) }` |
+| `IRustTransport` | Transport interface (extends `EventEmitter`) |
 | `IManagementRequest` | IPC request shape: `{ id, method, params }` |
 | `IManagementResponse` | IPC response shape: `{ id, success, result?, error? }` |
 | `IManagementEvent` | IPC event shape: `{ event, data }` |

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartrust',
-  version: '1.3.0',
+  version: '1.3.2',
   description: 'a bridge between JS engines and rust'
 }

package/ts/classes.rustbinarylocator.ts

@@ -81,11 +81,18 @@ export class RustBinaryLocator {
       plugins.path.resolve(process.cwd(), `rust/target/release/${binaryName}`),
       plugins.path.resolve(process.cwd(), `rust/target/debug/${binaryName}`),
     ];
+    const platformSuffix = this.getPlatformSuffix();
     for (const localPath of localPaths) {
       if (await this.isExecutable(localPath)) {
         this.logger.log('info', `Binary found at local path: ${localPath}`);
         return localPath;
       }
+      // Also try with platform suffix (tsrust convention: binaryName_linux_amd64)
+      const suffixedPath = `${localPath}_${platformSuffix}`;
+      if (await this.isExecutable(suffixedPath)) {
+        this.logger.log('info', `Binary found at local path (platform-suffixed): ${suffixedPath}`);
+        return suffixedPath;
+      }
     }
 
     // 5. System PATH
@@ -137,6 +144,14 @@ export class RustBinaryLocator {
     }
   }
 
+  private getPlatformSuffix(): string {
+    const archMap: Record<string, string> = { x64: 'amd64', arm64: 'arm64' };
+    const platformMap: Record<string, string> = { linux: 'linux', darwin: 'darwin', win32: 'windows' };
+    const platform = platformMap[process.platform] || process.platform;
+    const arch = archMap[process.arch] || process.arch;
+    return `${platform}_${arch}`;
+  }
+
   private async findInPath(binaryName: string): Promise<string | null> {
     const pathDirs = (process.env.PATH || '').split(plugins.path.delimiter);
     for (const dir of pathDirs) {