No black boxes. This is the actual technical pipeline — serial handshake, WASM parsing, HMAC authentication, AES-encrypted licensing — explained in plain language.
Every line of real code, explained plainly. From the first byte off the wire to the POST that reaches your HIS.
RS-232 serial or TCP/IP — auto-detection in seconds
Plug your instrument into the lab computer via RS-232 serial cable, or configure it to send data over your LAN via TCP/IP. LISBridge opens the port, reads the first bytes of data off the wire, and automatically identifies the instrument model — without you selecting anything. It then applies the correct message-framing rules for that exact machine before a single result is processed.
Per-machine completeness rules — not a generic timeout
Before parsing anything, LISBridge reads enough bytes to identify the exact machine model. Each instrument has a different definition of 'message complete' — a generic timeout approach loses data. LISBridge applies machine-specific rules: COBAS C311/E411 waits for an L|1|N terminator followed by a 2-character hex checksum. Rayto CBC (HL7 format) waits until it sees MSH + OBR + at least 20 OBX segments. Abacus 380 waits for an ETX byte, or for the buffer to contain WBC/RBC/PLT graph data.
Rust-compiled WASM running inside wasmtime — authenticated per call
Once a complete message is buffered, LISBridge passes it to the WASM parser. The parser runs as a compiled Rust binary inside a native wasmtime runtime — not in a browser, not in Node.js. Every single parse call is authenticated: LISBridge generates an HMAC-SHA256 signature from your machine's hardware ID and the current Unix timestamp, passes it into the WASM sandbox, and the parser verifies it before touching any data. An invalid or expired signature returns AUTH_FAILED immediately.
Raw data → findings → HIS endpoint, everything logged permanently
The parsed result is stored in three layers: the original raw bytes go into raw_data, the structured result goes into parsed_data, and each individual test value (WBC, RBC, HGB, etc.) goes into findings. Images — WBC/RBC/PLT histograms and scatter plots extracted as base64 — are stored in the images table. Only then does LISBridge forward the clean, structured result to your HIS endpoint via HTTP POST. If the network is down, results queue and deliver the moment connectivity restores.
Each instrument sends data differently — different protocols, different framing, different quirks. LISBridge has a dedicated, instrument-specific parser for every model below. Generic fallback parsers exist for unknown ASTM and HL7 devices too.
Don't see your instrument? Contact us — new parsers ship as silent WASM updates, no app reinstall needed.
Every architectural decision in LISBridge exists for a specific reason rooted in lab environment constraints.
The parser is compiled from Rust to WebAssembly and runs inside a native wasmtime runtime embedded in the Tauri app. Zero Node.js, zero Electron overhead. The WASM sandbox provides memory isolation — a parser bug cannot affect the host process.
Every parse call is signed: LISBridge computes HMAC-SHA256(machine_id:timestamp) using a shared secret baked in at compile time. The WASM verifies this before parsing. Tokens are bound to a specific machine and expire with the timestamp — replay attacks are blocked by design.
LISBridge polls cdn.trodad.com/lisbridge/parser-wasm/latest.txt every 15 minutes. If a new version is available, it downloads the manifest, fetches the WASM binary, compiles and validates it, then hot-swaps the running module in memory. Instruments keep parsing throughout — zero downtime, zero restart.
Your license key is encrypted with AES-256-GCM before being written to local storage. The decrypted payload is validated against an Ed25519 public key fetched from lisbridge.com/api/license/public-key. An in-memory cache (RwLock) prevents repeated DB hits — license validation costs a single memory read on every parse.
You can restrict which IP addresses are permitted to send TCP data to LISBridge. Any connection from an address not on the allowlist is rejected at the socket layer before any data is read. Useful in multi-subnet lab environments.
The entire class of memory-safety bugs — buffer overflows, use-after-free, null pointer dereferences — is architecturally eliminated by the Rust compiler at build time. LISBridge cannot crash from the failure modes that bring down C-based and Java-based middleware stacks.
LISBridge fetches pending test orders from your HIS or HMS by polling an HTTP endpoint you configure, authenticated with a global pull token. Because the connection originates from inside the network, no inbound firewall rule, DMZ placement, or static IP is required — the objection that stalls most hospital integrations does not apply. Each pulled payload is stored and indexed, and a node whose endpoint stops responding enters a reachability cooldown rather than retrying in a tight loop.
TCP client connections re-establish themselves with exponential backoff plus jitter after a drop. Local storage runs SQLite in write-ahead logging mode with connection pooling, so results already received survive an unclean shutdown. A single-instance lock — with stale-lock detection after a crash — prevents two copies of LISBridge from competing for the same instruments.
Download LISBridge, plug in your analyzer, and the full pipeline above — handshake, WASM parse, HMAC auth, HIS delivery — runs automatically. No developer. No config files. No waiting.
Full feature access · No credit card · Cancel anytime · Works on Windows, macOS, Linux