@kyneta/bridge-transport 1.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Duane Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# @kyneta/bridge-transport
+
+In-process transport for testing — alias-aware delivery.
+
+`BridgeTransport` is a real transport that runs the production alias transformer
+and `WireMessage` pipeline end-to-end and applies the docId/schemaHash alias
+transformer at the channel send/receive boundary — exactly like every other binary
+transport. Async delivery is preserved via `queueMicrotask()` to keep test behavior
+representative of real network adapters.
+
+## Usage
+
+```typescript
+import { Bridge, createBridgeTransport } from "@kyneta/bridge-transport"
+import { Exchange } from "@kyneta/exchange"
+
+const bridge = new Bridge()
+
+const exchangeA = new Exchange({
+  transports: [createBridgeTransport({ transportId: "peer-a", bridge })],
+})
+
+const exchangeB = new Exchange({
+  transports: [createBridgeTransport({ transportId: "peer-b", bridge })],
+})
+```
+
+## Peer Dependencies
+
+```json
+{
+  "peerDependencies": {
+    "@kyneta/transport": "^1.4.0",
+    "@kyneta/wire": "^1.4.0"
+  }
+}
+```
+
+`BridgeTransport` extends the `Transport<G>` base class from
+`@kyneta/transport` and uses the alias transformer + `WireMessage` pipeline from
+`@kyneta/wire` to exercise the production wire path in tests.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+import { GeneratedChannel, Transport, TransportFactory } from "@kyneta/transport";
+
+//#region src/bridge.d.ts
+/**
+ * In-process byte router connecting multiple `BridgeTransport`s,
+ * keyed by each transport's unique `transportId`.
+ *
+ * Channel-level sends produce alias-aware encoded bytes via the wire-layer
+ * transformer and call `routeBytes`.
+ */
+declare class Bridge {
+  readonly transports: Map<string, BridgeTransport>;
+  addTransport(transport: BridgeTransport): void;
+  removeTransport(transportId: string): void;
+  /**
+   * Route already-encoded bytes from one transport to another. The
+   * receiving transport's `deliverBytes` is responsible for decoding
+   * and applying the inbound alias transformer.
+   *
+   * Used by `BridgeTransport`'s channel send path.
+   */
+  routeBytes(fromTransportId: string, toTransportId: string, bytes: Uint8Array): void;
+  get transportIds(): Set<string>;
+}
+type BridgeTransportContext = {
+  targetTransportId: string;
+};
+type BridgeTransportParams = {
+  /** Unique identifier for this transport instance (e.g. "peer-a", "server"). */transportId: string;
+  /**
+   * Transport type category. Defaults to "bridge".
+   * Stored in ChannelMeta for informational purposes.
+   */
+  transportType?: string;
+  bridge: Bridge;
+};
+/**
+ * In-memory transport that runs the alias-aware pipeline end-to-end.
+ * Tests that use this transport exercise the same wire path as
+ * production transports.
+ *
+ * @example
+ * ```typescript
+ * const bridge = new Bridge()
+ * const exchangeA = new Exchange({
+ *   transports: [createBridgeTransport({ transportId: "peer-a", bridge })],
+ * })
+ * ```
+ */
+declare class BridgeTransport extends Transport<BridgeTransportContext> {
+  readonly bridge: Bridge;
+  private channelToAdapter;
+  private adapterToChannel;
+  private aliasStateByChannel;
+  constructor({
+    transportId,
+    transportType,
+    bridge
+  }: BridgeTransportParams);
+  generate(context: BridgeTransportContext): GeneratedChannel;
+  onStart(): Promise<void>;
+  onStop(): Promise<void>;
+  createChannelTo(targetTransportId: string): void;
+  removeChannelTo(targetTransportId: string): void;
+  /**
+   * Deliver encoded bytes to the appropriate channel.
+   *
+   * Decodes via `decodeWireMessage`, applies the inbound alias
+   * transformer, and delivers each resolved message asynchronously
+   * via `queueMicrotask()`.
+   */
+  deliverBytes(fromTransportId: string, bytes: Uint8Array): void;
+}
+/**
+ * Create a BridgeTransport factory for in-process testing.
+ *
+ * @example
+ * ```typescript
+ * const bridge = new Bridge()
+ * const exchangeA = new Exchange({
+ *   transports: [createBridgeTransport({ transportId: "peer-a", bridge })],
+ * })
+ * ```
+ */
+declare function createBridgeTransport(params: BridgeTransportParams): TransportFactory;
+//#endregion
+export { Bridge, BridgeTransport, type BridgeTransportParams, createBridgeTransport };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/bridge.ts"],"mappings":";;;;AAwCA;;;;;;cAAa,MAAA;EAAA,SACF,UAAA,EAAU,GAAA,SAAA,eAAA;EAEnB,YAAA,CAAa,SAAA,EAAW,eAAA;EAOxB,eAAA,CAAgB,WAAA;EATP;;;;;;;EAoBT,UAAA,CACE,eAAA,UACA,aAAA,UACA,KAAA,EAAO,UAAA;EAAA,IAOL,YAAA,CAAA,GAAgB,GAAA;AAAA;AAAA,KASjB,sBAAA;EACH,iBAAA;AAAA;AAAA,KAGU,qBAAA;EAbU,+EAepB,WAAA;EAfuB;AAGxB;;;EAiBC,aAAA;EACA,MAAA,EAAQ,MAAA;AAAA;;;;;;;;;;AAgBV;;;;cAAa,eAAA,SAAwB,SAAA,CAAU,sBAAA;EAAA,SACpC,MAAA,EAAQ,MAAA;EAAA,QAGT,gBAAA;EAAA,QACA,gBAAA;EAAA,QAIA,mBAAA;;IAEM,WAAA;IAAa,aAAA;IAAe;EAAA,GAAU,qBAAA;EAKpD,QAAA,CAAS,OAAA,EAAS,sBAAA,GAAyB,gBAAA;EAyBrC,OAAA,CAAA,GAAW,OAAA;EAqBX,MAAA,CAAA,GAAU,OAAA;EAgBhB,eAAA,CAAgB,iBAAA;EAQhB,eAAA,CAAgB,iBAAA;EAtF4B;;;;;;;EAuG5C,YAAA,CAAa,eAAA,UAAyB,KAAA,EAAO,UAAA;AAAA;;;;;;;;;;;;iBAsC/B,qBAAA,CACd,MAAA,EAAQ,qBAAA,GACP,gBAAA"}

package/dist/index.js

@@ -0,0 +1,149 @@
+import { Transport } from "@kyneta/transport";
+import { applyInboundAliasing, applyOutboundAliasing, decodeWireMessage, emptyAliasState, encodeWireMessage } from "@kyneta/wire";
+//#region src/bridge.ts
+/**
+* In-process byte router connecting multiple `BridgeTransport`s,
+* keyed by each transport's unique `transportId`.
+*
+* Channel-level sends produce alias-aware encoded bytes via the wire-layer
+* transformer and call `routeBytes`.
+*/
+var Bridge = class {
+	transports = /* @__PURE__ */ new Map();
+	addTransport(transport) {
+		if (!transport.transportId) throw new Error("can't add transport without transport id");
+		this.transports.set(transport.transportId, transport);
+	}
+	removeTransport(transportId) {
+		this.transports.delete(transportId);
+	}
+	/**
+	* Route already-encoded bytes from one transport to another. The
+	* receiving transport's `deliverBytes` is responsible for decoding
+	* and applying the inbound alias transformer.
+	*
+	* Used by `BridgeTransport`'s channel send path.
+	*/
+	routeBytes(fromTransportId, toTransportId, bytes) {
+		const toTransport = this.transports.get(toTransportId);
+		if (!toTransport) return;
+		toTransport.deliverBytes(fromTransportId, bytes);
+	}
+	get transportIds() {
+		return new Set(this.transports.keys());
+	}
+};
+/**
+* In-memory transport that runs the alias-aware pipeline end-to-end.
+* Tests that use this transport exercise the same wire path as
+* production transports.
+*
+* @example
+* ```typescript
+* const bridge = new Bridge()
+* const exchangeA = new Exchange({
+*   transports: [createBridgeTransport({ transportId: "peer-a", bridge })],
+* })
+* ```
+*/
+var BridgeTransport = class extends Transport {
+	bridge;
+	channelToAdapter = /* @__PURE__ */ new Map();
+	adapterToChannel = /* @__PURE__ */ new Map();
+	aliasStateByChannel = /* @__PURE__ */ new Map();
+	constructor({ transportId, transportType, bridge }) {
+		super({
+			transportType: transportType ?? "bridge",
+			transportId
+		});
+		this.bridge = bridge;
+	}
+	generate(context) {
+		return {
+			transportType: this.transportType,
+			send: (msg) => {
+				const channelId = this.adapterToChannel.get(context.targetTransportId);
+				if (channelId === void 0) return;
+				const { state: nextState, wire } = applyOutboundAliasing(this.aliasStateByChannel.get(channelId) ?? emptyAliasState(), msg);
+				this.aliasStateByChannel.set(channelId, nextState);
+				const bytes = encodeWireMessage(wire);
+				this.bridge.routeBytes(this.transportId, context.targetTransportId, bytes);
+			},
+			stop: () => {}
+		};
+	}
+	async onStart() {
+		this.bridge.addTransport(this);
+		for (const [transportId, adapter] of this.bridge.transports) if (transportId !== this.transportId) adapter.createChannelTo(this.transportId);
+		for (const transportId of this.bridge.transports.keys()) if (transportId !== this.transportId) this.createChannelTo(transportId);
+		for (const channelId of this.adapterToChannel.values()) this.establishChannel(channelId);
+	}
+	async onStop() {
+		for (const [transportId, adapter] of this.bridge.transports) if (transportId !== this.transportId) adapter.removeChannelTo(this.transportId);
+		this.bridge.removeTransport(this.transportId);
+		for (const channelId of this.channelToAdapter.keys()) {
+			this.removeChannel(channelId);
+			this.aliasStateByChannel.delete(channelId);
+		}
+		this.channelToAdapter.clear();
+		this.adapterToChannel.clear();
+	}
+	createChannelTo(targetTransportId) {
+		if (this.adapterToChannel.has(targetTransportId)) return;
+		const channel = this.addChannel({ targetTransportId });
+		this.channelToAdapter.set(channel.channelId, targetTransportId);
+		this.adapterToChannel.set(targetTransportId, channel.channelId);
+		this.aliasStateByChannel.set(channel.channelId, emptyAliasState());
+	}
+	removeChannelTo(targetTransportId) {
+		const channelId = this.adapterToChannel.get(targetTransportId);
+		if (channelId !== void 0) {
+			this.removeChannel(channelId);
+			this.channelToAdapter.delete(channelId);
+			this.adapterToChannel.delete(targetTransportId);
+			this.aliasStateByChannel.delete(channelId);
+		}
+	}
+	/**
+	* Deliver encoded bytes to the appropriate channel.
+	*
+	* Decodes via `decodeWireMessage`, applies the inbound alias
+	* transformer, and delivers each resolved message asynchronously
+	* via `queueMicrotask()`.
+	*/
+	deliverBytes(fromTransportId, bytes) {
+		const channelId = this.adapterToChannel.get(fromTransportId);
+		if (channelId === void 0) return;
+		const channel = this.channels.get(channelId);
+		if (!channel) return;
+		const wire = decodeWireMessage(bytes);
+		const result = applyInboundAliasing(this.aliasStateByChannel.get(channelId) ?? emptyAliasState(), wire);
+		this.aliasStateByChannel.set(channelId, result.state);
+		if (result.error || !result.msg) {
+			console.warn("[BridgeTransport] alias resolution failed:", result.error);
+			return;
+		}
+		const msg = result.msg;
+		queueMicrotask(() => {
+			channel.onReceive(msg);
+		});
+	}
+};
+/**
+* Create a BridgeTransport factory for in-process testing.
+*
+* @example
+* ```typescript
+* const bridge = new Bridge()
+* const exchangeA = new Exchange({
+*   transports: [createBridgeTransport({ transportId: "peer-a", bridge })],
+* })
+* ```
+*/
+function createBridgeTransport(params) {
+	return () => new BridgeTransport(params);
+}
+//#endregion
+export { Bridge, BridgeTransport, createBridgeTransport };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/bridge.ts"],"sourcesContent":["// bridge-adapter — in-process transport with alias-aware delivery.\n//\n// BridgeTransport is a real transport that runs the alias-aware pipeline\n// end-to-end and applies the docId/schemaHash alias transformer at the\n// channel send/receive boundary — exactly like every other binary\n// transport. Async delivery is preserved via `queueMicrotask()` to keep\n// test behavior representative of real network adapters.\n//\n// Usage:\n//   const bridge = new Bridge()\n//   const exchangeA = new Exchange({\n//     transports: [createBridgeTransport({ transportId: \"peer-a\", bridge })],\n//   })\n\nimport type {\n  ChannelId,\n  GeneratedChannel,\n  TransportFactory,\n} from \"@kyneta/transport\"\nimport { Transport } from \"@kyneta/transport\"\nimport {\n  type AliasState,\n  applyInboundAliasing,\n  applyOutboundAliasing,\n  decodeWireMessage,\n  emptyAliasState,\n  encodeWireMessage,\n} from \"@kyneta/wire\"\n\n// ---------------------------------------------------------------------------\n// Bridge — message router connecting multiple BridgeTransports in-process\n// ---------------------------------------------------------------------------\n\n/**\n * In-process byte router connecting multiple `BridgeTransport`s,\n * keyed by each transport's unique `transportId`.\n *\n * Channel-level sends produce alias-aware encoded bytes via the wire-layer\n * transformer and call `routeBytes`.\n */\nexport class Bridge {\n  readonly transports = new Map<string, BridgeTransport>()\n\n  addTransport(transport: BridgeTransport): void {\n    if (!transport.transportId) {\n      throw new Error(\"can't add transport without transport id\")\n    }\n    this.transports.set(transport.transportId, transport)\n  }\n\n  removeTransport(transportId: string): void {\n    this.transports.delete(transportId)\n  }\n\n  /**\n   * Route already-encoded bytes from one transport to another. The\n   * receiving transport's `deliverBytes` is responsible for decoding\n   * and applying the inbound alias transformer.\n   *\n   * Used by `BridgeTransport`'s channel send path.\n   */\n  routeBytes(\n    fromTransportId: string,\n    toTransportId: string,\n    bytes: Uint8Array,\n  ): void {\n    const toTransport = this.transports.get(toTransportId)\n    if (!toTransport) return\n    toTransport.deliverBytes(fromTransportId, bytes)\n  }\n\n  get transportIds(): Set<string> {\n    return new Set(this.transports.keys())\n  }\n}\n\n// ---------------------------------------------------------------------------\n// BridgeTransport — in-process network adapter for testing\n// ---------------------------------------------------------------------------\n\ntype BridgeTransportContext = {\n  targetTransportId: string\n}\n\nexport type BridgeTransportParams = {\n  /** Unique identifier for this transport instance (e.g. \"peer-a\", \"server\"). */\n  transportId: string\n  /**\n   * Transport type category. Defaults to \"bridge\".\n   * Stored in ChannelMeta for informational purposes.\n   */\n  transportType?: string\n  bridge: Bridge\n}\n\n/**\n * In-memory transport that runs the alias-aware pipeline end-to-end.\n * Tests that use this transport exercise the same wire path as\n * production transports.\n *\n * @example\n * ```typescript\n * const bridge = new Bridge()\n * const exchangeA = new Exchange({\n *   transports: [createBridgeTransport({ transportId: \"peer-a\", bridge })],\n * })\n * ```\n */\nexport class BridgeTransport extends Transport<BridgeTransportContext> {\n  readonly bridge: Bridge\n\n  // Track which remote transport each channel connects to.\n  private channelToAdapter = new Map<ChannelId, string>()\n  private adapterToChannel = new Map<string, ChannelId>()\n\n  // Per-channel alias state. Created with the channel; lives until removal.\n  // Keyed by channelId.\n  private aliasStateByChannel = new Map<ChannelId, AliasState>()\n\n  constructor({ transportId, transportType, bridge }: BridgeTransportParams) {\n    super({ transportType: transportType ?? \"bridge\", transportId })\n    this.bridge = bridge\n  }\n\n  generate(context: BridgeTransportContext): GeneratedChannel {\n    return {\n      transportType: this.transportType,\n      send: msg => {\n        const channelId = this.adapterToChannel.get(context.targetTransportId)\n        if (channelId === undefined) return\n\n        const state =\n          this.aliasStateByChannel.get(channelId) ?? emptyAliasState()\n        const { state: nextState, wire } = applyOutboundAliasing(state, msg)\n        this.aliasStateByChannel.set(channelId, nextState)\n\n        const bytes = encodeWireMessage(wire)\n        this.bridge.routeBytes(\n          this.transportId,\n          context.targetTransportId,\n          bytes,\n        )\n      },\n      stop: () => {\n        // Cleanup handled by removeChannel.\n      },\n    }\n  }\n\n  async onStart(): Promise<void> {\n    this.bridge.addTransport(this)\n\n    // Phase 1: Create all channels (no establishment yet).\n    for (const [transportId, adapter] of this.bridge.transports) {\n      if (transportId !== this.transportId) {\n        adapter.createChannelTo(this.transportId)\n      }\n    }\n    for (const transportId of this.bridge.transports.keys()) {\n      if (transportId !== this.transportId) {\n        this.createChannelTo(transportId)\n      }\n    }\n\n    // Phase 2: Only the joining transport initiates establishment.\n    for (const channelId of this.adapterToChannel.values()) {\n      this.establishChannel(channelId)\n    }\n  }\n\n  async onStop(): Promise<void> {\n    for (const [transportId, adapter] of this.bridge.transports) {\n      if (transportId !== this.transportId) {\n        adapter.removeChannelTo(this.transportId)\n      }\n    }\n    this.bridge.removeTransport(this.transportId)\n\n    for (const channelId of this.channelToAdapter.keys()) {\n      this.removeChannel(channelId)\n      this.aliasStateByChannel.delete(channelId)\n    }\n    this.channelToAdapter.clear()\n    this.adapterToChannel.clear()\n  }\n\n  createChannelTo(targetTransportId: string): void {\n    if (this.adapterToChannel.has(targetTransportId)) return\n    const channel = this.addChannel({ targetTransportId })\n    this.channelToAdapter.set(channel.channelId, targetTransportId)\n    this.adapterToChannel.set(targetTransportId, channel.channelId)\n    this.aliasStateByChannel.set(channel.channelId, emptyAliasState())\n  }\n\n  removeChannelTo(targetTransportId: string): void {\n    const channelId = this.adapterToChannel.get(targetTransportId)\n    if (channelId !== undefined) {\n      this.removeChannel(channelId)\n      this.channelToAdapter.delete(channelId)\n      this.adapterToChannel.delete(targetTransportId)\n      this.aliasStateByChannel.delete(channelId)\n    }\n  }\n\n  /**\n   * Deliver encoded bytes to the appropriate channel.\n   *\n   * Decodes via `decodeWireMessage`, applies the inbound alias\n   * transformer, and delivers each resolved message asynchronously\n   * via `queueMicrotask()`.\n   */\n  deliverBytes(fromTransportId: string, bytes: Uint8Array): void {\n    const channelId = this.adapterToChannel.get(fromTransportId)\n    if (channelId === undefined) return\n\n    const channel = this.channels.get(channelId)\n    if (!channel) return\n\n    const wire = decodeWireMessage(bytes)\n    const state = this.aliasStateByChannel.get(channelId) ?? emptyAliasState()\n    const result = applyInboundAliasing(state, wire)\n    this.aliasStateByChannel.set(channelId, result.state)\n\n    if (result.error || !result.msg) {\n      console.warn(\"[BridgeTransport] alias resolution failed:\", result.error)\n      return\n    }\n    const msg = result.msg\n    queueMicrotask(() => {\n      channel.onReceive(msg)\n    })\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory function\n// ---------------------------------------------------------------------------\n\n/**\n * Create a BridgeTransport factory for in-process testing.\n *\n * @example\n * ```typescript\n * const bridge = new Bridge()\n * const exchangeA = new Exchange({\n *   transports: [createBridgeTransport({ transportId: \"peer-a\", bridge })],\n * })\n * ```\n */\nexport function createBridgeTransport(\n  params: BridgeTransportParams,\n): TransportFactory {\n  return () => new BridgeTransport(params)\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@kyneta/bridge-transport",
+  "version": "1.5.0",
+  "description": "In-process transport for @kyneta/exchange — codec-faithful + alias-aware delivery for testing multi-peer scenarios in a single process",
+  "author": "Duane Johnson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/halecraft/kyneta",
+    "directory": "packages/exchange/transports/bridge"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./src/*": "./src/*"
+  },
+  "peerDependencies": {
+    "@kyneta/transport": "^1.5.0",
+    "@kyneta/wire": "^1.5.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.21.9",
+    "typescript": "^5.9.2",
+    "vitest": "^4.0.17",
+    "@kyneta/transport": "^1.5.0",
+    "@kyneta/schema": "^1.5.0",
+    "@kyneta/wire": "^1.5.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "verify logic",
+    "verify": "verify"
+  }
+}

package/src/__tests__/bridge.test.ts

@@ -0,0 +1,104 @@
+// BridgeTransport — codec-faithful + alias-aware in-process tests.
+
+import type { TransportContext } from "@kyneta/transport"
+import { describe, expect, it, vi } from "vitest"
+import { Bridge, BridgeTransport } from "../bridge.js"
+
+function createTransportContext(
+  overrides: Partial<TransportContext> = {},
+): TransportContext {
+  return {
+    identity: { peerId: "test-peer", type: "user" },
+    onChannelReceive: vi.fn(),
+    onChannelAdded: vi.fn(),
+    onChannelRemoved: vi.fn(),
+    onChannelEstablish: vi.fn(),
+    ...overrides,
+  }
+}
+
+describe("BridgeTransport", () => {
+  it("two adapters exchange messages through a Bridge", async () => {
+    const bridge = new Bridge()
+
+    const ctxA = createTransportContext({
+      identity: { peerId: "peer-a", type: "user" },
+    })
+    const ctxB = createTransportContext({
+      identity: { peerId: "peer-b", type: "user" },
+    })
+
+    const adapterA = new BridgeTransport({ transportId: "peer-a", bridge })
+    const adapterB = new BridgeTransport({ transportId: "peer-b", bridge })
+
+    adapterA._initialize(ctxA)
+    await adapterA._start()
+    adapterB._initialize(ctxB)
+    await adapterB._start()
+
+    expect(bridge.transports.size).toBe(2)
+  })
+
+  it("stops cleanly and removes from bridge", async () => {
+    const bridge = new Bridge()
+
+    const adapterA = new BridgeTransport({ transportId: "peer-a", bridge })
+    adapterA._initialize(createTransportContext())
+    await adapterA._start()
+
+    expect(bridge.transports.size).toBe(1)
+
+    await adapterA._stop()
+    expect(bridge.transports.size).toBe(0)
+  })
+
+  it("channel lifecycle: connected → established via handshake", async () => {
+    const bridge = new Bridge()
+
+    const establishedChannels: number[] = []
+
+    const adapterA = new BridgeTransport({ transportId: "peer-a", bridge })
+    const adapterB = new BridgeTransport({ transportId: "peer-b", bridge })
+
+    adapterA._initialize(
+      createTransportContext({
+        identity: { peerId: "peer-a", type: "user" },
+        onChannelEstablish: channel =>
+          establishedChannels.push(channel.channelId),
+      }),
+    )
+    await adapterA._start()
+
+    adapterB._initialize(
+      createTransportContext({
+        identity: { peerId: "peer-b", type: "user" },
+        onChannelEstablish: channel =>
+          establishedChannels.push(channel.channelId),
+      }),
+    )
+    await adapterB._start()
+
+    expect(establishedChannels.length).toBeGreaterThan(0)
+  })
+
+  it("codec-faithful: messages round-trip bit-perfectly via the bridge codec", async () => {
+    const bridge = new Bridge()
+
+    const ctxA = createTransportContext({
+      identity: { peerId: "peer-a", type: "user" },
+    })
+    const ctxB = createTransportContext({
+      identity: { peerId: "peer-b", type: "user" },
+    })
+
+    const adapterA = new BridgeTransport({ transportId: "peer-a", bridge })
+    const adapterB = new BridgeTransport({ transportId: "peer-b", bridge })
+
+    adapterA._initialize(ctxA)
+    await adapterA._start()
+    adapterB._initialize(ctxB)
+    await adapterB._start()
+
+    expect(bridge.transports.size).toBe(2)
+  })
+})

package/src/bridge.ts

@@ -0,0 +1,254 @@
+// bridge-adapter — in-process transport with alias-aware delivery.
+//
+// BridgeTransport is a real transport that runs the alias-aware pipeline
+// end-to-end and applies the docId/schemaHash alias transformer at the
+// channel send/receive boundary — exactly like every other binary
+// transport. Async delivery is preserved via `queueMicrotask()` to keep
+// test behavior representative of real network adapters.
+//
+// Usage:
+//   const bridge = new Bridge()
+//   const exchangeA = new Exchange({
+//     transports: [createBridgeTransport({ transportId: "peer-a", bridge })],
+//   })
+
+import type {
+  ChannelId,
+  GeneratedChannel,
+  TransportFactory,
+} from "@kyneta/transport"
+import { Transport } from "@kyneta/transport"
+import {
+  type AliasState,
+  applyInboundAliasing,
+  applyOutboundAliasing,
+  decodeWireMessage,
+  emptyAliasState,
+  encodeWireMessage,
+} from "@kyneta/wire"
+
+// ---------------------------------------------------------------------------
+// Bridge — message router connecting multiple BridgeTransports in-process
+// ---------------------------------------------------------------------------
+
+/**
+ * In-process byte router connecting multiple `BridgeTransport`s,
+ * keyed by each transport's unique `transportId`.
+ *
+ * Channel-level sends produce alias-aware encoded bytes via the wire-layer
+ * transformer and call `routeBytes`.
+ */
+export class Bridge {
+  readonly transports = new Map<string, BridgeTransport>()
+
+  addTransport(transport: BridgeTransport): void {
+    if (!transport.transportId) {
+      throw new Error("can't add transport without transport id")
+    }
+    this.transports.set(transport.transportId, transport)
+  }
+
+  removeTransport(transportId: string): void {
+    this.transports.delete(transportId)
+  }
+
+  /**
+   * Route already-encoded bytes from one transport to another. The
+   * receiving transport's `deliverBytes` is responsible for decoding
+   * and applying the inbound alias transformer.
+   *
+   * Used by `BridgeTransport`'s channel send path.
+   */
+  routeBytes(
+    fromTransportId: string,
+    toTransportId: string,
+    bytes: Uint8Array,
+  ): void {
+    const toTransport = this.transports.get(toTransportId)
+    if (!toTransport) return
+    toTransport.deliverBytes(fromTransportId, bytes)
+  }
+
+  get transportIds(): Set<string> {
+    return new Set(this.transports.keys())
+  }
+}
+
+// ---------------------------------------------------------------------------
+// BridgeTransport — in-process network adapter for testing
+// ---------------------------------------------------------------------------
+
+type BridgeTransportContext = {
+  targetTransportId: string
+}
+
+export type BridgeTransportParams = {
+  /** Unique identifier for this transport instance (e.g. "peer-a", "server"). */
+  transportId: string
+  /**
+   * Transport type category. Defaults to "bridge".
+   * Stored in ChannelMeta for informational purposes.
+   */
+  transportType?: string
+  bridge: Bridge
+}
+
+/**
+ * In-memory transport that runs the alias-aware pipeline end-to-end.
+ * Tests that use this transport exercise the same wire path as
+ * production transports.
+ *
+ * @example
+ * ```typescript
+ * const bridge = new Bridge()
+ * const exchangeA = new Exchange({
+ *   transports: [createBridgeTransport({ transportId: "peer-a", bridge })],
+ * })
+ * ```
+ */
+export class BridgeTransport extends Transport<BridgeTransportContext> {
+  readonly bridge: Bridge
+
+  // Track which remote transport each channel connects to.
+  private channelToAdapter = new Map<ChannelId, string>()
+  private adapterToChannel = new Map<string, ChannelId>()
+
+  // Per-channel alias state. Created with the channel; lives until removal.
+  // Keyed by channelId.
+  private aliasStateByChannel = new Map<ChannelId, AliasState>()
+
+  constructor({ transportId, transportType, bridge }: BridgeTransportParams) {
+    super({ transportType: transportType ?? "bridge", transportId })
+    this.bridge = bridge
+  }
+
+  generate(context: BridgeTransportContext): GeneratedChannel {
+    return {
+      transportType: this.transportType,
+      send: msg => {
+        const channelId = this.adapterToChannel.get(context.targetTransportId)
+        if (channelId === undefined) return
+
+        const state =
+          this.aliasStateByChannel.get(channelId) ?? emptyAliasState()
+        const { state: nextState, wire } = applyOutboundAliasing(state, msg)
+        this.aliasStateByChannel.set(channelId, nextState)
+
+        const bytes = encodeWireMessage(wire)
+        this.bridge.routeBytes(
+          this.transportId,
+          context.targetTransportId,
+          bytes,
+        )
+      },
+      stop: () => {
+        // Cleanup handled by removeChannel.
+      },
+    }
+  }
+
+  async onStart(): Promise<void> {
+    this.bridge.addTransport(this)
+
+    // Phase 1: Create all channels (no establishment yet).
+    for (const [transportId, adapter] of this.bridge.transports) {
+      if (transportId !== this.transportId) {
+        adapter.createChannelTo(this.transportId)
+      }
+    }
+    for (const transportId of this.bridge.transports.keys()) {
+      if (transportId !== this.transportId) {
+        this.createChannelTo(transportId)
+      }
+    }
+
+    // Phase 2: Only the joining transport initiates establishment.
+    for (const channelId of this.adapterToChannel.values()) {
+      this.establishChannel(channelId)
+    }
+  }
+
+  async onStop(): Promise<void> {
+    for (const [transportId, adapter] of this.bridge.transports) {
+      if (transportId !== this.transportId) {
+        adapter.removeChannelTo(this.transportId)
+      }
+    }
+    this.bridge.removeTransport(this.transportId)
+
+    for (const channelId of this.channelToAdapter.keys()) {
+      this.removeChannel(channelId)
+      this.aliasStateByChannel.delete(channelId)
+    }
+    this.channelToAdapter.clear()
+    this.adapterToChannel.clear()
+  }
+
+  createChannelTo(targetTransportId: string): void {
+    if (this.adapterToChannel.has(targetTransportId)) return
+    const channel = this.addChannel({ targetTransportId })
+    this.channelToAdapter.set(channel.channelId, targetTransportId)
+    this.adapterToChannel.set(targetTransportId, channel.channelId)
+    this.aliasStateByChannel.set(channel.channelId, emptyAliasState())
+  }
+
+  removeChannelTo(targetTransportId: string): void {
+    const channelId = this.adapterToChannel.get(targetTransportId)
+    if (channelId !== undefined) {
+      this.removeChannel(channelId)
+      this.channelToAdapter.delete(channelId)
+      this.adapterToChannel.delete(targetTransportId)
+      this.aliasStateByChannel.delete(channelId)
+    }
+  }
+
+  /**
+   * Deliver encoded bytes to the appropriate channel.
+   *
+   * Decodes via `decodeWireMessage`, applies the inbound alias
+   * transformer, and delivers each resolved message asynchronously
+   * via `queueMicrotask()`.
+   */
+  deliverBytes(fromTransportId: string, bytes: Uint8Array): void {
+    const channelId = this.adapterToChannel.get(fromTransportId)
+    if (channelId === undefined) return
+
+    const channel = this.channels.get(channelId)
+    if (!channel) return
+
+    const wire = decodeWireMessage(bytes)
+    const state = this.aliasStateByChannel.get(channelId) ?? emptyAliasState()
+    const result = applyInboundAliasing(state, wire)
+    this.aliasStateByChannel.set(channelId, result.state)
+
+    if (result.error || !result.msg) {
+      console.warn("[BridgeTransport] alias resolution failed:", result.error)
+      return
+    }
+    const msg = result.msg
+    queueMicrotask(() => {
+      channel.onReceive(msg)
+    })
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory function
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a BridgeTransport factory for in-process testing.
+ *
+ * @example
+ * ```typescript
+ * const bridge = new Bridge()
+ * const exchangeA = new Exchange({
+ *   transports: [createBridgeTransport({ transportId: "peer-a", bridge })],
+ * })
+ * ```
+ */
+export function createBridgeTransport(
+  params: BridgeTransportParams,
+): TransportFactory {
+  return () => new BridgeTransport(params)
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+// @kyneta/bridge-transport — in-process transport for testing.
+
+export type { BridgeTransportParams } from "./bridge.js"
+export { Bridge, BridgeTransport, createBridgeTransport } from "./bridge.js"