@korajs/test 0.6.1 → 1.0.0-beta.1

package/dist/index.d.cts

@@ -1,9 +1,29 @@
-import { SchemaDefinition, Operation, KoraEventEmitter, OperationTransform, VersionVector } from '@korajs/core';
+import { SchemaDefinition, Operation, BlobRef, KoraEventEmitter, OperationTransform, VersionVector } from '@korajs/core';
 import { SyncTransport, SyncEngine, ChaosConfig } from '@korajs/sync';
 export { ChaosConfig, ChaosTransport } from '@korajs/sync';
 import * as _korajs_server from '@korajs/server';
-import { MemoryServerStore, ServerTransport } from '@korajs/server';
-import { Store, CollectionAccessor } from '@korajs/store';
+import { ServerTransport, MemoryServerStore } from '@korajs/server';
+import { ContentAddressedBlobStore, Store, MemoryBlobStore, CollectionAccessor, BlobManifest, ReceiveBlobResult } from '@korajs/store';
+
+/**
+ * A linked client/server transport pair, as consumed by {@link TestDevice}.
+ */
+interface TransportPair {
+    client: SyncTransport;
+    serverTransport: ServerTransport;
+}
+/**
+ * Wraps a transport pair so that every sync message exchanged between the two
+ * ends is encoded to protobuf bytes and decoded back — a faithful stand-in for
+ * a real network hop that uses the protobuf wire format.
+ *
+ * Both directions are wrapped, so operations, handshakes, batches, and acks all
+ * travel as bytes rather than shared object references.
+ *
+ * @param pair - The underlying (in-memory) transport pair to wrap
+ * @returns A transport pair that routes messages through the protobuf codec
+ */
+declare function wrapTransportPairWithProtobufWire(pair: TransportPair): TransportPair;
 
 /**
  * In-memory test server wrapping KoraSyncServer with MemoryServerStore.
@@ -17,9 +37,13 @@ interface TestServerOptions {
         min: number;
         max: number;
     };
+    /** Enable central blob storage: the server persists and serves uploaded blob bytes. */
+    blobStorage?: boolean;
 }
 declare class TestServer {
     readonly store: MemoryServerStore;
+    /** The server's central blob store, present when `blobStorage` was enabled. */
+    readonly blobStore: ContentAddressedBlobStore | null;
     private readonly syncServer;
     constructor(schema: SchemaDefinition, options?: TestServerOptions);
     /**
@@ -35,6 +59,8 @@ declare class TestServer {
      * Get the number of connected clients.
      */
     getConnectionCount(): number;
+    /** Every blob reference still reachable from live records on the server. */
+    getLiveBlobRefs(): Promise<BlobRef[]>;
     /**
      * Shut down the server and close all sessions.
      */
@@ -74,6 +100,8 @@ declare class TestDevice {
     readonly emitter: KoraEventEmitter & {
         clear(): void;
     };
+    /** Content-addressed blob store for out-of-band blob bytes (chunks + full blobs). */
+    readonly blobStore: MemoryBlobStore;
     private readonly schema;
     private readonly server;
     private readonly mergeEngine;
@@ -84,8 +112,10 @@ declare class TestDevice {
     private readonly operationTransforms;
     private applyPipeline;
     private syncEngine;
+    private blobChunkProvider;
     private currentTransport;
     private unsubscribeSync;
+    private unsubscribeAudit;
     private closing;
     constructor(options: TestDeviceOptions);
     /**
@@ -119,6 +149,42 @@ declare class TestDevice {
     getNodeId(): string;
     /** Exposes the sync engine for integration tests (e.g. doc channel, chaos). */
     getSyncEngine(): SyncEngine | null;
+    /**
+     * Stage a blob's bytes into this device's blob store, splitting them into
+     * content-addressed chunks this device can then serve to peers over the sync
+     * connection. Returns the manifest (blob hash + ordered chunk hashes) needed
+     * to pull the blob elsewhere.
+     */
+    stageBlob(bytes: Uint8Array, options?: {
+        chunkSize?: number;
+    }): Promise<BlobManifest>;
+    /**
+     * Store a blob for transfer the way `app.blobs.put` does: stage chunks, store
+     * the full blob, and store the manifest as its own content-addressed object.
+     * The returned reference carries a `manifestHash`, so a peer can pull the bytes
+     * knowing only the reference.
+     */
+    putBlob(bytes: Uint8Array, options?: {
+        chunkSize?: number;
+        mimeType?: string;
+        filename?: string;
+    }): Promise<{
+        ref: BlobRef;
+        manifest: BlobManifest;
+    }>;
+    /**
+     * Pull a blob's bytes over the live connection knowing only its reference: the
+     * manifest is resolved by `ref.manifestHash` first, then the chunks are fetched.
+     */
+    pullBlobByRef(ref: BlobRef): Promise<ReceiveBlobResult>;
+    /**
+     * Pull a blob's bytes from peers over the live sync connection. Requests only
+     * the chunks this device is missing, reassembles them, and verifies integrity
+     * against the manifest's blob hash before storing the full blob locally.
+     */
+    pullBlob(manifest: BlobManifest): Promise<ReceiveBlobResult>;
+    /** Read fully-assembled blob bytes from this device's store, or null if absent. */
+    getBlobBytes(hash: string): Promise<Uint8Array | null>;
     /**
      * Get the device's version vector.
      */
@@ -152,6 +218,16 @@ interface TestNetworkOptions {
     deviceNames?: string[];
     /** Optional chaos transport settings applied to each device link. */
     chaos?: ChaosConfig;
+    /**
+     * Optional wrapper applied to each device's transport pair after the base
+     * (in-memory, optionally chaos-wrapped) pair is created. Use it to route
+     * messages through the protobuf wire codec
+     * ({@link wrapTransportPairWithProtobufWire}) or to inject a controllable
+     * server clock. Called once per device connection.
+     */
+    wrapTransport?: (pair: TransportPair) => TransportPair;
+    /** Enable central blob storage on the server (persist + serve uploaded blob bytes). */
+    blobStorage?: boolean;
 }
 /**
  * A test network with a server and multiple devices.
@@ -273,4 +349,14 @@ declare function expectConvergedEventually(devices: TestDevice[], schema: Schema
  */
 declare function checkConvergence(devices: TestDevice[], schema: SchemaDefinition): Promise<ConvergenceResult>;
 
-export { type CollectionDifference, type ConvergenceResult, type FieldDifference, type MixedTestDeviceConfig, TestDevice, type TestDeviceOptions, type TestNetwork, type TestNetworkOptions, TestServer, type TestServerOptions, checkConvergence, createMixedTestNetwork, createTestNetwork, expectConverged, expectConvergedEventually };
+/**
+ * Wraps a transport pair so the server side reports `serverNow()` as its
+ * handshake wall-clock time.
+ *
+ * @param pair - The underlying transport pair
+ * @param serverNow - Returns the server's true current time (ms since epoch)
+ * @returns A transport pair whose handshake responses carry the injected time
+ */
+declare function wrapTransportPairWithServerClock(pair: TransportPair, serverNow: () => number): TransportPair;
+
+export { type CollectionDifference, type ConvergenceResult, type FieldDifference, type MixedTestDeviceConfig, TestDevice, type TestDeviceOptions, type TestNetwork, type TestNetworkOptions, TestServer, type TestServerOptions, type TransportPair, checkConvergence, createMixedTestNetwork, createTestNetwork, expectConverged, expectConvergedEventually, wrapTransportPairWithProtobufWire, wrapTransportPairWithServerClock };

package/dist/index.d.ts

@@ -1,9 +1,29 @@
-import { SchemaDefinition, Operation, KoraEventEmitter, OperationTransform, VersionVector } from '@korajs/core';
+import { SchemaDefinition, Operation, BlobRef, KoraEventEmitter, OperationTransform, VersionVector } from '@korajs/core';
 import { SyncTransport, SyncEngine, ChaosConfig } from '@korajs/sync';
 export { ChaosConfig, ChaosTransport } from '@korajs/sync';
 import * as _korajs_server from '@korajs/server';
-import { MemoryServerStore, ServerTransport } from '@korajs/server';
-import { Store, CollectionAccessor } from '@korajs/store';
+import { ServerTransport, MemoryServerStore } from '@korajs/server';
+import { ContentAddressedBlobStore, Store, MemoryBlobStore, CollectionAccessor, BlobManifest, ReceiveBlobResult } from '@korajs/store';
+
+/**
+ * A linked client/server transport pair, as consumed by {@link TestDevice}.
+ */
+interface TransportPair {
+    client: SyncTransport;
+    serverTransport: ServerTransport;
+}
+/**
+ * Wraps a transport pair so that every sync message exchanged between the two
+ * ends is encoded to protobuf bytes and decoded back — a faithful stand-in for
+ * a real network hop that uses the protobuf wire format.
+ *
+ * Both directions are wrapped, so operations, handshakes, batches, and acks all
+ * travel as bytes rather than shared object references.
+ *
+ * @param pair - The underlying (in-memory) transport pair to wrap
+ * @returns A transport pair that routes messages through the protobuf codec
+ */
+declare function wrapTransportPairWithProtobufWire(pair: TransportPair): TransportPair;
 
 /**
  * In-memory test server wrapping KoraSyncServer with MemoryServerStore.
@@ -17,9 +37,13 @@ interface TestServerOptions {
         min: number;
         max: number;
     };
+    /** Enable central blob storage: the server persists and serves uploaded blob bytes. */
+    blobStorage?: boolean;
 }
 declare class TestServer {
     readonly store: MemoryServerStore;
+    /** The server's central blob store, present when `blobStorage` was enabled. */
+    readonly blobStore: ContentAddressedBlobStore | null;
     private readonly syncServer;
     constructor(schema: SchemaDefinition, options?: TestServerOptions);
     /**
@@ -35,6 +59,8 @@ declare class TestServer {
      * Get the number of connected clients.
      */
     getConnectionCount(): number;
+    /** Every blob reference still reachable from live records on the server. */
+    getLiveBlobRefs(): Promise<BlobRef[]>;
     /**
      * Shut down the server and close all sessions.
      */
@@ -74,6 +100,8 @@ declare class TestDevice {
     readonly emitter: KoraEventEmitter & {
         clear(): void;
     };
+    /** Content-addressed blob store for out-of-band blob bytes (chunks + full blobs). */
+    readonly blobStore: MemoryBlobStore;
     private readonly schema;
     private readonly server;
     private readonly mergeEngine;
@@ -84,8 +112,10 @@ declare class TestDevice {
     private readonly operationTransforms;
     private applyPipeline;
     private syncEngine;
+    private blobChunkProvider;
     private currentTransport;
     private unsubscribeSync;
+    private unsubscribeAudit;
     private closing;
     constructor(options: TestDeviceOptions);
     /**
@@ -119,6 +149,42 @@ declare class TestDevice {
     getNodeId(): string;
     /** Exposes the sync engine for integration tests (e.g. doc channel, chaos). */
     getSyncEngine(): SyncEngine | null;
+    /**
+     * Stage a blob's bytes into this device's blob store, splitting them into
+     * content-addressed chunks this device can then serve to peers over the sync
+     * connection. Returns the manifest (blob hash + ordered chunk hashes) needed
+     * to pull the blob elsewhere.
+     */
+    stageBlob(bytes: Uint8Array, options?: {
+        chunkSize?: number;
+    }): Promise<BlobManifest>;
+    /**
+     * Store a blob for transfer the way `app.blobs.put` does: stage chunks, store
+     * the full blob, and store the manifest as its own content-addressed object.
+     * The returned reference carries a `manifestHash`, so a peer can pull the bytes
+     * knowing only the reference.
+     */
+    putBlob(bytes: Uint8Array, options?: {
+        chunkSize?: number;
+        mimeType?: string;
+        filename?: string;
+    }): Promise<{
+        ref: BlobRef;
+        manifest: BlobManifest;
+    }>;
+    /**
+     * Pull a blob's bytes over the live connection knowing only its reference: the
+     * manifest is resolved by `ref.manifestHash` first, then the chunks are fetched.
+     */
+    pullBlobByRef(ref: BlobRef): Promise<ReceiveBlobResult>;
+    /**
+     * Pull a blob's bytes from peers over the live sync connection. Requests only
+     * the chunks this device is missing, reassembles them, and verifies integrity
+     * against the manifest's blob hash before storing the full blob locally.
+     */
+    pullBlob(manifest: BlobManifest): Promise<ReceiveBlobResult>;
+    /** Read fully-assembled blob bytes from this device's store, or null if absent. */
+    getBlobBytes(hash: string): Promise<Uint8Array | null>;
     /**
      * Get the device's version vector.
      */
@@ -152,6 +218,16 @@ interface TestNetworkOptions {
     deviceNames?: string[];
     /** Optional chaos transport settings applied to each device link. */
     chaos?: ChaosConfig;
+    /**
+     * Optional wrapper applied to each device's transport pair after the base
+     * (in-memory, optionally chaos-wrapped) pair is created. Use it to route
+     * messages through the protobuf wire codec
+     * ({@link wrapTransportPairWithProtobufWire}) or to inject a controllable
+     * server clock. Called once per device connection.
+     */
+    wrapTransport?: (pair: TransportPair) => TransportPair;
+    /** Enable central blob storage on the server (persist + serve uploaded blob bytes). */
+    blobStorage?: boolean;
 }
 /**
  * A test network with a server and multiple devices.
@@ -273,4 +349,14 @@ declare function expectConvergedEventually(devices: TestDevice[], schema: Schema
  */
 declare function checkConvergence(devices: TestDevice[], schema: SchemaDefinition): Promise<ConvergenceResult>;
 
-export { type CollectionDifference, type ConvergenceResult, type FieldDifference, type MixedTestDeviceConfig, TestDevice, type TestDeviceOptions, type TestNetwork, type TestNetworkOptions, TestServer, type TestServerOptions, checkConvergence, createMixedTestNetwork, createTestNetwork, expectConverged, expectConvergedEventually };
+/**
+ * Wraps a transport pair so the server side reports `serverNow()` as its
+ * handshake wall-clock time.
+ *
+ * @param pair - The underlying transport pair
+ * @param serverNow - Returns the server's true current time (ms since epoch)
+ * @returns A transport pair whose handshake responses carry the injected time
+ */
+declare function wrapTransportPairWithServerClock(pair: TransportPair, serverNow: () => number): TransportPair;
+
+export { type CollectionDifference, type ConvergenceResult, type FieldDifference, type MixedTestDeviceConfig, TestDevice, type TestDeviceOptions, type TestNetwork, type TestNetworkOptions, TestServer, type TestServerOptions, type TransportPair, checkConvergence, createMixedTestNetwork, createTestNetwork, expectConverged, expectConvergedEventually, wrapTransportPairWithProtobufWire, wrapTransportPairWithServerClock };

package/dist/index.js

@@ -8,19 +8,33 @@ import { ChaosTransport } from "@korajs/sync";
 // src/test-device.ts
 import { SimpleEventEmitter } from "@korajs/core/internal";
 import { MergeEngine } from "@korajs/merge";
-import { Store } from "@korajs/store";
+import {
+  MemoryBlobStore,
+  Store,
+  createRemoteChunkProvider,
+  prepareBlobForSend,
+  putBlobForTransfer,
+  receiveBlob,
+  resolveBlobManifest,
+  serveBlobChunks
+} from "@korajs/store";
 import { BetterSqlite3Adapter } from "@korajs/store/better-sqlite3";
 import { SyncEngine } from "@korajs/sync";
 import {
   ApplyPipeline,
   MergeAwareSyncStore,
   StoreQueueStorage,
-  StoreSyncStatePersistence
+  StoreSyncStatePersistence,
+  createSyncEngineChunkPort,
+  wireAuditPersistence,
+  wireBlobUpload
 } from "korajs/testing";
 var TestDevice = class {
   name;
   store;
   emitter;
+  /** Content-addressed blob store for out-of-band blob bytes (chunks + full blobs). */
+  blobStore = new MemoryBlobStore();
   schema;
   server;
   mergeEngine;
@@ -31,8 +45,10 @@ var TestDevice = class {
   operationTransforms;
   applyPipeline = null;
   syncEngine = null;
+  blobChunkProvider = null;
   currentTransport = null;
   unsubscribeSync = null;
+  unsubscribeAudit = null;
   closing = false;
   constructor(options) {
     this.name = options.name;
@@ -62,6 +78,7 @@ var TestDevice = class {
       emitter: this.emitter
     });
     this.store.setLocalMutationHandler(this.applyPipeline);
+    this.unsubscribeAudit = wireAuditPersistence(this.store, this.emitter);
   }
   /**
    * Connect to the test server and perform initial sync.
@@ -92,6 +109,10 @@ var TestDevice = class {
       emitter: this.emitter
     });
     conflictHandler.fn = () => this.syncEngine?.recordConflict();
+    const chunkPort = createSyncEngineChunkPort(this.syncEngine);
+    serveBlobChunks(chunkPort, this.blobStore);
+    this.blobChunkProvider = createRemoteChunkProvider(chunkPort);
+    wireBlobUpload(this.emitter, this.syncEngine, this.blobStore);
     const engine = this.syncEngine;
     this.unsubscribeSync = this.emitter.on("operation:created", (event) => {
       if (!this.closing && this.syncEngine === engine && this.currentTransport?.isConnected()) {
@@ -115,6 +136,7 @@ var TestDevice = class {
       await this.syncEngine.stop();
       this.syncEngine = null;
     }
+    this.blobChunkProvider = null;
     this.currentTransport = null;
   }
   /**
@@ -146,6 +168,57 @@ var TestDevice = class {
   getSyncEngine() {
     return this.syncEngine;
   }
+  /**
+   * Stage a blob's bytes into this device's blob store, splitting them into
+   * content-addressed chunks this device can then serve to peers over the sync
+   * connection. Returns the manifest (blob hash + ordered chunk hashes) needed
+   * to pull the blob elsewhere.
+   */
+  async stageBlob(bytes, options) {
+    const { manifest } = await prepareBlobForSend(bytes, this.blobStore, options);
+    return manifest;
+  }
+  /**
+   * Store a blob for transfer the way `app.blobs.put` does: stage chunks, store
+   * the full blob, and store the manifest as its own content-addressed object.
+   * The returned reference carries a `manifestHash`, so a peer can pull the bytes
+   * knowing only the reference.
+   */
+  async putBlob(bytes, options) {
+    return putBlobForTransfer(this.blobStore, bytes, options);
+  }
+  /**
+   * Pull a blob's bytes over the live connection knowing only its reference: the
+   * manifest is resolved by `ref.manifestHash` first, then the chunks are fetched.
+   */
+  async pullBlobByRef(ref) {
+    if (!this.blobChunkProvider) {
+      throw new Error("Cannot pull a blob before the device has connected (call sync() first)");
+    }
+    const manifest = await resolveBlobManifest(this.blobChunkProvider, ref);
+    return receiveBlob(manifest, this.blobChunkProvider, {
+      chunkStore: this.blobStore,
+      blobStore: this.blobStore
+    });
+  }
+  /**
+   * Pull a blob's bytes from peers over the live sync connection. Requests only
+   * the chunks this device is missing, reassembles them, and verifies integrity
+   * against the manifest's blob hash before storing the full blob locally.
+   */
+  async pullBlob(manifest) {
+    if (!this.blobChunkProvider) {
+      throw new Error("Cannot pull a blob before the device has connected (call sync() first)");
+    }
+    return receiveBlob(manifest, this.blobChunkProvider, {
+      chunkStore: this.blobStore,
+      blobStore: this.blobStore
+    });
+  }
+  /** Read fully-assembled blob bytes from this device's store, or null if absent. */
+  async getBlobBytes(hash) {
+    return this.blobStore.get(hash);
+  }
   /**
    * Get the device's version vector.
    */
@@ -163,6 +236,10 @@ var TestDevice = class {
    */
   async close() {
     this.closing = true;
+    if (this.unsubscribeAudit) {
+      this.unsubscribeAudit();
+      this.unsubscribeAudit = null;
+    }
     await this.disconnect();
     await this.store.close();
     this.emitter.clear();
@@ -194,19 +271,25 @@ var TestDevice = class {
 // src/test-server.ts
 import { MemoryServerStore } from "@korajs/server";
 import { KoraSyncServer } from "@korajs/server";
+import { createMemoryServerBlobStore } from "@korajs/store";
 var TestServer = class {
   store;
+  /** The server's central blob store, present when `blobStorage` was enabled. */
+  blobStore;
   syncServer;
   constructor(schema, options) {
     this.store = new MemoryServerStore();
     const schemaVersion = options?.schemaVersion ?? schema.version;
+    const blob = options?.blobStorage ? createMemoryServerBlobStore() : null;
+    this.blobStore = blob?.store ?? null;
     this.syncServer = new KoraSyncServer({
       store: this.store,
       schemaVersion,
       supportedSchemaVersions: options?.supportedSchemaVersions ?? {
         min: schemaVersion,
         max: schemaVersion
-      }
+      },
+      ...blob ? blob.callbacks : {}
     });
     void this.store.setSchema(schema);
   }
@@ -229,6 +312,10 @@ var TestServer = class {
   getConnectionCount() {
     return this.syncServer.getConnectionCount();
   }
+  /** Every blob reference still reachable from live records on the server. */
+  getLiveBlobRefs() {
+    return this.syncServer.getLiveBlobRefs();
+  }
   /**
    * Shut down the server and close all sessions.
    */
@@ -243,7 +330,7 @@ async function createTestNetwork(schema, options) {
   const deviceCount = options?.devices ?? 2;
   const deviceNames = options?.deviceNames ?? Array.from({ length: deviceCount }, (_, i) => `device-${i}`);
   const tmpDir = mkdtempSync(join(tmpdir(), "kora-test-"));
-  const server = new TestServer(schema);
+  const server = new TestServer(schema, { blobStorage: options?.blobStorage });
   const devices = [];
   for (const name of deviceNames) {
     const device = new TestDevice({
@@ -254,10 +341,11 @@ async function createTestNetwork(schema, options) {
         const pair = createServerTransportPair();
         const client = pair.client;
         const chaos = options?.chaos;
-        return {
+        const base = {
           client: chaos ? new ChaosTransport(client, chaos) : client,
           serverTransport: pair.server
         };
+        return options?.wrapTransport ? options.wrapTransport(base) : base;
       },
       tmpDir
     });
@@ -451,6 +539,126 @@ function deepEqual(a, b) {
   return false;
 }
 
+// src/protobuf-wire-transport.ts
+import { ProtobufMessageSerializer } from "@korajs/sync";
+var PROTOBUF_WIRE_TYPES = /* @__PURE__ */ new Set([
+  "handshake",
+  "handshake-response",
+  "operation-batch",
+  "acknowledgment",
+  "error"
+]);
+function roundTripThroughProtobuf(message, serializer) {
+  if (!PROTOBUF_WIRE_TYPES.has(message.type)) {
+    return structuredClone(message);
+  }
+  const encoded = serializer.encode(message);
+  if (!(encoded instanceof Uint8Array)) {
+    throw new Error("Expected the protobuf serializer to encode to bytes");
+  }
+  return serializer.decode(encoded);
+}
+var ProtobufWireClientTransport = class {
+  constructor(inner, serializer) {
+    this.inner = inner;
+    this.serializer = serializer;
+  }
+  inner;
+  serializer;
+  connect(url, options) {
+    return this.inner.connect(url, options);
+  }
+  disconnect() {
+    return this.inner.disconnect();
+  }
+  send(message) {
+    this.inner.send(roundTripThroughProtobuf(message, this.serializer));
+  }
+  onMessage(handler) {
+    this.inner.onMessage(handler);
+  }
+  onClose(handler) {
+    this.inner.onClose(handler);
+  }
+  onError(handler) {
+    this.inner.onError(handler);
+  }
+  isConnected() {
+    return this.inner.isConnected();
+  }
+};
+var ProtobufWireServerTransport = class {
+  constructor(inner, serializer) {
+    this.inner = inner;
+    this.serializer = serializer;
+  }
+  inner;
+  serializer;
+  send(message) {
+    this.inner.send(roundTripThroughProtobuf(message, this.serializer));
+  }
+  onMessage(handler) {
+    this.inner.onMessage(handler);
+  }
+  onClose(handler) {
+    this.inner.onClose(handler);
+  }
+  onError(handler) {
+    this.inner.onError(handler);
+  }
+  isConnected() {
+    return this.inner.isConnected();
+  }
+  close(code, reason) {
+    this.inner.close(code, reason);
+  }
+};
+function wrapTransportPairWithProtobufWire(pair) {
+  const serializer = new ProtobufMessageSerializer();
+  return {
+    client: new ProtobufWireClientTransport(pair.client, serializer),
+    serverTransport: new ProtobufWireServerTransport(pair.serverTransport, serializer)
+  };
+}
+
+// src/server-clock-transport.ts
+var ServerClockServerTransport = class {
+  constructor(inner, serverNow) {
+    this.inner = inner;
+    this.serverNow = serverNow;
+  }
+  inner;
+  serverNow;
+  send(message) {
+    if (message.type === "handshake-response") {
+      this.inner.send({ ...message, serverTime: this.serverNow() });
+      return;
+    }
+    this.inner.send(message);
+  }
+  onMessage(handler) {
+    this.inner.onMessage(handler);
+  }
+  onClose(handler) {
+    this.inner.onClose(handler);
+  }
+  onError(handler) {
+    this.inner.onError(handler);
+  }
+  isConnected() {
+    return this.inner.isConnected();
+  }
+  close(code, reason) {
+    this.inner.close(code, reason);
+  }
+};
+function wrapTransportPairWithServerClock(pair, serverNow) {
+  return {
+    client: pair.client,
+    serverTransport: new ServerClockServerTransport(pair.serverTransport, serverNow)
+  };
+}
+
 // src/index.ts
 import { ChaosTransport as ChaosTransport2 } from "@korajs/sync";
 export {
@@ -461,6 +669,8 @@ export {
   createMixedTestNetwork,
   createTestNetwork,
   expectConverged,
-  expectConvergedEventually
+  expectConvergedEventually,
+  wrapTransportPairWithProtobufWire,
+  wrapTransportPairWithServerClock
 };
 //# sourceMappingURL=index.js.map