One definition, both sides

You write a contract once. BridgeKit gives you a typed proxy on the JS side, a typed interface to implement on the native side — a Kotlin interface on Android, a Swift protocol on iOS — reactive streams, observable state, and the code generator keeps them in lockstep through a contract hash.

// app-host.contract.ts — provided by NATIVE, consumed by RN
import { defineContract, t } from '@malopezr7/bridgekit/contract';

export const AppHost = defineContract('app.host', {
  methods: {
    showLogin: t.fire(),                                  // fire-and-forget
    isLoggedIn: t.query(t.boolean()),                     // async request/response
    saveFile: t.query(
      t.object({ url: t.string(), name: t.string() }),
      t.literals('success', 'already-exists', 'cancelled', 'error'),
      { timeoutMs: null },                                // interactive: never times out
    ),
  },
  streams: {
    notifications: t.stream(t.string()),                       // lossless buffered by default
  },
  state: {
    connectivity: t.state(t.object({ online: t.boolean() }), { online: false }),
  },
});

Bidirectional & typed

RN → native and native → RN. The same four markers — async, fire, stream, state — work in both directions over one transport.

Contract-first codegen

bridgekit generate reads your .contract.ts and emits committed, readable Kotlin and Swift from the same source. Nitrogen never runs for feature code.

Reactive streams

Lossless-by-default flows replace event emitters and polling. Backpressure, sharing and cancellation are handled for you.

Observable state

Provider-owned, single-writer, synchronously readable. Initial values make every read total — the render-gating dance dies here.

Local-first resolution

A JS-provided contract resolves inside the runtime with zero native crossing — web target, standalone mode and tests work without Kotlin.

Testable & observable

In-memory loopback transport for plain Jest. Every op carries a correlation id; BridgeKit.dump() prints bindings, streams, state and epoch.

Start reading

What is BridgeKit The problem it solves and the shape of the solution.

Core concepts Contract, provider, consumer, scope, binding, state, stream, epoch.

Quick start From an empty contract to a live round trip in five steps.

Status

BridgeKit is production-validated on Android (Kotlin) and iOS (Swift). Typed bidirectional contracts — async, fire, streams and state — are proven on-device on both platforms at parity, and the host app runs on BridgeKit over pure SPM. The remaining deferred target is the web transport; see Limitations.