@korajs/test 0.0.0-canary-20261008174129

package/dist/index.js

@@ -0,0 +1,942 @@
+// src/test-network.ts
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { createServerTransportPair } from "@korajs/server/internal";
+import { ChaosTransport } from "@korajs/sync";
+
+// src/test-device.ts
+import { SimpleEventEmitter } from "@korajs/core/internal";
+import { MergeEngine } from "@korajs/merge";
+import {
+  MemoryBlobStore,
+  Store,
+  createRemoteChunkProvider,
+  prepareBlobForSend,
+  putBlobForTransfer,
+  receiveBlob,
+  resolveBlobManifest,
+  serveBlobChunks
+} from "@korajs/store";
+import { BetterSqlite3Adapter } from "@korajs/store/better-sqlite3";
+import { SyncEncryptor, SyncEngine, validateEncryptedRelations } from "@korajs/sync";
+import {
+  ApplyPipeline,
+  MergeAwareSyncStore,
+  StoreQueueStorage,
+  StoreSyncStatePersistence,
+  createSyncEngineChunkPort,
+  wireAuditPersistence,
+  wireBlobUpload
+} from "korajs/testing";
+var ReconnectingClientTransport = class {
+  constructor(inner, createPair, server) {
+    this.inner = inner;
+    this.createPair = createPair;
+    this.server = server;
+  }
+  inner;
+  createPair;
+  server;
+  messageHandler = null;
+  closeHandler = null;
+  errorHandler = null;
+  connectedOnce = false;
+  async connect(url, options) {
+    if (this.connectedOnce && !this.inner.isConnected()) {
+      const previous = this.inner;
+      previous.onMessage(() => {
+      });
+      previous.onClose(() => {
+      });
+      previous.onError(() => {
+      });
+      const { client, serverTransport } = this.createPair();
+      this.inner = client;
+      this.wire();
+      this.server.handleConnection(serverTransport);
+    }
+    this.connectedOnce = true;
+    await this.inner.connect(url, options);
+  }
+  disconnect() {
+    return this.inner.disconnect();
+  }
+  send(message) {
+    this.inner.send(message);
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+    this.wire();
+  }
+  onClose(handler) {
+    this.closeHandler = handler;
+    this.wire();
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    this.wire();
+  }
+  isConnected() {
+    return this.inner.isConnected();
+  }
+  wire() {
+    this.inner.onMessage((message) => this.messageHandler?.(message));
+    this.inner.onClose((reason) => this.closeHandler?.(reason));
+    this.inner.onError((error) => this.errorHandler?.(error));
+  }
+};
+var TestDevice = class {
+  name;
+  store;
+  emitter;
+  /** Content-addressed blob store for out-of-band blob bytes (chunks + full blobs). */
+  blobStore = new MemoryBlobStore();
+  schema;
+  server;
+  encryption;
+  batchSize;
+  encryptor = null;
+  mergeEngine;
+  createTransportPair;
+  adapter;
+  dbPath;
+  syncSchemaVersion;
+  operationTransforms;
+  scopeExit;
+  principal;
+  reconnectable;
+  applyPipeline = null;
+  syncEngine = null;
+  blobChunkProvider = null;
+  currentTransport = null;
+  unsubscribeSync = null;
+  unsubscribeAudit = null;
+  closing = false;
+  constructor(options) {
+    this.name = options.name;
+    this.schema = options.schema;
+    this.server = options.server;
+    this.createTransportPair = options.createTransportPair;
+    this.dbPath = `${options.tmpDir}/test-device-${options.name}.db`;
+    this.syncSchemaVersion = options.syncSchemaVersion ?? options.schema.version;
+    this.operationTransforms = options.operationTransforms ?? [];
+    this.scopeExit = options.scopeExit;
+    this.principal = options.principal;
+    this.reconnectable = options.reconnectable === true;
+    this.encryption = options.encryption;
+    this.batchSize = options.batchSize;
+    validateEncryptedRelations(options.schema, options.encryption?.config);
+    this.emitter = new SimpleEventEmitter();
+    this.mergeEngine = new MergeEngine();
+    this.adapter = new BetterSqlite3Adapter(this.dbPath);
+    this.store = new Store({
+      schema: options.schema,
+      adapter: this.adapter,
+      emitter: this.emitter,
+      materialization: options.legacyMerge === true ? "legacy" : "fold",
+      ...options.operationTransforms && options.operationTransforms.length > 0 ? { operationTransforms: options.operationTransforms } : {},
+      ...options.maxOperationBytes !== void 0 ? { maxOperationBytes: options.maxOperationBytes } : {},
+      ...options.nodeId !== void 0 ? { nodeId: options.nodeId } : {}
+    });
+  }
+  /**
+   * Open the store (must be called before sync or collection operations).
+   */
+  async open() {
+    await this.store.open();
+    this.applyPipeline = new ApplyPipeline({
+      store: this.store,
+      mergeEngine: this.mergeEngine,
+      emitter: this.emitter
+    });
+    this.store.setLocalMutationHandler(this.applyPipeline);
+    this.unsubscribeAudit = wireAuditPersistence(this.store, this.emitter);
+    const principal = this.principal?.();
+    if (principal) await this.store.bindPrincipal(principal);
+  }
+  /**
+   * The signed-in user changed (RT-42), as an auth binding reports it: like createApp,
+   * end the live session and bind the store to the new user before the next write.
+   */
+  async authChanged() {
+    if (this.syncEngine) {
+      await this.syncEngine.refreshPrincipal();
+      return;
+    }
+    const principal = this.principal?.();
+    if (principal) await this.store.bindPrincipal(principal);
+  }
+  /**
+   * Connect to the test server and perform initial sync.
+   * If already connected, flushes any pending operations.
+   */
+  async sync() {
+    if (this.syncEngine && this.currentTransport?.isConnected()) {
+      await this.waitForPendingOps();
+      await this.waitForSettled();
+      return;
+    }
+    const created = this.createTransportPair();
+    const { serverTransport } = created;
+    const client = this.reconnectable ? new ReconnectingClientTransport(created.client, this.createTransportPair, this.server) : created.client;
+    this.currentTransport = client;
+    if (this.encryption && !this.encryptor) {
+      this.encryptor = await SyncEncryptor.create(
+        this.encryption.config,
+        this.encryption.salt,
+        this.encryption.iterations
+      );
+    }
+    const conflictHandler = {};
+    const syncStore = new MergeAwareSyncStore(this.store, this.mergeEngine, this.emitter, {
+      onMergeConflict: () => conflictHandler.fn?.()
+    });
+    this.syncEngine = new SyncEngine({
+      transport: client,
+      store: syncStore,
+      queueStorage: new StoreQueueStorage(this.adapter),
+      syncState: new StoreSyncStatePersistence(this.store),
+      config: {
+        url: "ws://test-network",
+        schemaVersion: this.syncSchemaVersion,
+        operationTransforms: this.operationTransforms.length > 0 ? this.operationTransforms : void 0,
+        ...this.scopeExit ? { scopeExit: this.scopeExit } : {},
+        ...this.principal ? { principal: async () => this.principal ? this.principal() : null } : {},
+        ...this.encryption ? { encryption: this.encryption.config } : {},
+        ...this.batchSize !== void 0 ? { batchSize: this.batchSize } : {}
+      },
+      emitter: this.emitter,
+      ...this.encryptor ? { encryptor: this.encryptor } : {}
+    });
+    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()) {
+        this.syncEngine.pushOperation(event.operation).catch(() => {
+        });
+      }
+    });
+    this.server.handleConnection(serverTransport);
+    await this.syncEngine.start();
+    await this.waitForSettled();
+  }
+  /**
+   * Disconnect from the test server.
+   */
+  async disconnect() {
+    if (this.unsubscribeSync) {
+      this.unsubscribeSync();
+      this.unsubscribeSync = null;
+    }
+    if (this.syncEngine) {
+      await this.syncEngine.stop();
+      this.syncEngine = null;
+    }
+    this.blobChunkProvider = null;
+    this.currentTransport = null;
+  }
+  /**
+   * Reconnect to the test server after a disconnect.
+   */
+  async reconnect() {
+    await this.sync();
+  }
+  /**
+   * Get a collection accessor for performing CRUD operations.
+   */
+  collection(name) {
+    return this.store.collection(name);
+  }
+  /**
+   * Get all records from a collection (convenience method).
+   */
+  async getState(collectionName) {
+    const accessor = this.store.collection(collectionName);
+    return accessor.where({}).exec();
+  }
+  /**
+   * Get the device's node ID.
+   */
+  getNodeId() {
+    return this.store.getNodeId();
+  }
+  /** Exposes the sync engine for integration tests (e.g. doc channel, chaos). */
+  getSyncEngine() {
+    return this.syncEngine;
+  }
+  /**
+   * Operations the server rejected for this device that have not been reconciled.
+   * Empty when the device has never connected.
+   */
+  async getRejectedOperations() {
+    if (!this.syncEngine) return [];
+    return this.syncEngine.getRejectedOperations();
+  }
+  /**
+   * 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.
+   */
+  getVersionVector() {
+    return this.store.getVersionVector();
+  }
+  /**
+   * Check if the device is currently connected to the server.
+   */
+  isConnected() {
+    return this.currentTransport?.isConnected() ?? false;
+  }
+  /**
+   * Close the device, releasing all resources.
+   */
+  async close() {
+    this.closing = true;
+    if (this.unsubscribeAudit) {
+      this.unsubscribeAudit();
+      this.unsubscribeAudit = null;
+    }
+    await this.disconnect();
+    await this.store.close();
+    this.emitter.clear();
+  }
+  /**
+   * Wait for in-flight sync operations to settle.
+   * In-memory transports are near-synchronous, but apply/relay work is async.
+   */
+  async waitForSettled() {
+    for (let i = 0; i < 15; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+  /**
+   * Wait for all pending outbound operations to be acknowledged.
+   */
+  async waitForPendingOps() {
+    if (!this.syncEngine) return;
+    const maxWait = 2e3;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+      const status = this.syncEngine.getStatus();
+      if (status.pendingOperations === 0) return;
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+};
+
+// src/test-server.ts
+import { MemoryServerStore } from "@korajs/server";
+import { KoraSyncServer } from "@korajs/server";
+import { createMemoryServerBlobStore } from "@korajs/store";
+var TestServer = class {
+  store;
+  /** Resolves once the store has the schema (needed before a SQL store is used). */
+  ready;
+  /** The server's central blob store, present when `blobStorage` was enabled. */
+  blobStore;
+  syncServer;
+  constructor(schema, options) {
+    this.store = options?.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
+      },
+      ...options?.operationTransforms ? { operationTransforms: options.operationTransforms } : {},
+      ...blob ? blob.callbacks : {},
+      ...options?.validateOperation ? { validateOperation: options.validateOperation } : {},
+      ...options?.encryption ? { encryption: options.encryption } : {}
+    });
+    this.ready = this.store.setSchema(
+      schema,
+      options?.operationTransforms ? { operationTransforms: options.operationTransforms } : {}
+    );
+    this.ready.catch(() => {
+    });
+  }
+  /**
+   * Register a client connection transport with the server.
+   * Returns the session ID assigned by the server.
+   */
+  handleConnection(transport) {
+    return this.syncServer.handleConnection(transport);
+  }
+  /**
+   * Get all operations stored on the server.
+   */
+  getAllOperations() {
+    if (!(this.store instanceof MemoryServerStore)) {
+      throw new Error(
+        "TestServer.getAllOperations() reads the memory store synchronously; use store.getOperationsAfterDelivery() with a SQL store"
+      );
+    }
+    return this.store.getAllOperations();
+  }
+  /** The trusted server-side write API (route context): writes authored by the server node. */
+  getKoraContext() {
+    return this.syncServer.getKoraContext();
+  }
+  /** The node ids the server's stores fold with and advertise in the handshake. */
+  get authoritativeNodeIds() {
+    return this.syncServer.authoritativeNodeIds;
+  }
+  /**
+   * Get the number of connected clients.
+   */
+  getConnectionCount() {
+    return this.syncServer.getConnectionCount();
+  }
+  /**
+   * Retransmit relay batches connected clients have not acknowledged. Lets a test
+   * deterministically trigger the redelivery that the server also runs on a timer,
+   * without depending on wall-clock time. `staleMs` of 0 resends every pending relay.
+   */
+  retransmitPendingRelays(staleMs = 0) {
+    this.syncServer.retransmitPendingRelays(staleMs);
+  }
+  /** Every blob reference still reachable from live records on the server. */
+  getLiveBlobRefs() {
+    return this.syncServer.getLiveBlobRefs();
+  }
+  /**
+   * Shut down the server and close all sessions.
+   */
+  async close() {
+    await this.syncServer.stop();
+    await this.store.close();
+  }
+};
+
+// src/test-network.ts
+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, {
+    blobStorage: options?.blobStorage,
+    validateOperation: options?.validateOperation,
+    ...options?.serverStore ? { store: options.serverStore } : {},
+    ...options?.serverEncryption ? { encryption: options.serverEncryption } : {}
+  });
+  await server.ready;
+  const devices = [];
+  for (const name of deviceNames) {
+    const device = new TestDevice({
+      name,
+      schema,
+      server,
+      createTransportPair: () => {
+        const pair = createServerTransportPair();
+        const client = pair.client;
+        const chaos = options?.chaos;
+        const base = {
+          client: chaos ? new ChaosTransport(client, chaos) : client,
+          serverTransport: pair.server
+        };
+        return options?.wrapTransport ? options.wrapTransport(base) : base;
+      },
+      tmpDir,
+      ...options?.legacyMerge ? { legacyMerge: true } : {},
+      ...options?.encryption ? { encryption: options.encryption } : {},
+      ...options?.deviceMaxOperationBytes !== void 0 ? { maxOperationBytes: options.deviceMaxOperationBytes } : {}
+    });
+    await device.open();
+    devices.push(device);
+  }
+  return {
+    server,
+    devices,
+    tmpDir,
+    async close() {
+      for (const device of devices) {
+        await device.close();
+      }
+      await server.close();
+      try {
+        const { rmSync } = await import("fs");
+        rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+async function createMixedTestNetwork(serverSchema, serverOptions, deviceConfigs) {
+  const tmpDir = mkdtempSync(join(tmpdir(), "kora-test-"));
+  const server = new TestServer(serverSchema, serverOptions);
+  const devices = [];
+  for (const config of deviceConfigs) {
+    const device = new TestDevice({
+      name: config.name,
+      schema: config.schema,
+      server,
+      syncSchemaVersion: config.syncSchemaVersion,
+      operationTransforms: config.operationTransforms,
+      createTransportPair: () => {
+        const pair = createServerTransportPair();
+        return {
+          client: pair.client,
+          serverTransport: pair.server
+        };
+      },
+      tmpDir
+    });
+    await device.open();
+    devices.push(device);
+  }
+  return {
+    server,
+    devices,
+    tmpDir,
+    async close() {
+      for (const device of devices) {
+        await device.close();
+      }
+      await server.close();
+      try {
+        const { rmSync } = await import("fs");
+        rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+
+// src/assertions.ts
+async function expectConverged(devices, schema) {
+  if (devices.length < 2) return;
+  const result = await checkConvergence(devices, schema);
+  if (!result.converged) {
+    const details = result.differences.map((d) => {
+      const parts = [
+        `  Collection "${d.collection}" differs between ${d.deviceA} and ${d.deviceB}:`
+      ];
+      if (d.missingInB.length > 0) {
+        parts.push(`    Missing in ${d.deviceB}: ${d.missingInB.join(", ")}`);
+      }
+      if (d.missingInA.length > 0) {
+        parts.push(`    Missing in ${d.deviceA}: ${d.missingInA.join(", ")}`);
+      }
+      for (const fd of d.fieldDifferences) {
+        parts.push(
+          `    Record "${fd.recordId}" field "${fd.field}": ${JSON.stringify(fd.valueInA)} vs ${JSON.stringify(fd.valueInB)}`
+        );
+      }
+      return parts.join("\n");
+    }).join("\n");
+    throw new Error(`Devices have not converged:
+${details}`);
+  }
+}
+async function expectConvergedEventually(devices, schema, options) {
+  if (devices.length < 2) return;
+  const timeoutMs = options?.timeoutMs ?? 5e3;
+  const intervalMs = options?.intervalMs ?? 25;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await checkConvergence(devices, schema);
+    if (result.converged) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  await expectConverged(devices, schema);
+}
+async function checkConvergence(devices, schema) {
+  const differences = [];
+  const collectionNames = Object.keys(schema.collections);
+  for (let i = 0; i < devices.length - 1; i++) {
+    for (let j = i + 1; j < devices.length; j++) {
+      const deviceA = devices[i];
+      const deviceB = devices[j];
+      for (const collection of collectionNames) {
+        const stateA = await deviceA.getState(collection);
+        const stateB = await deviceB.getState(collection);
+        const diff = compareCollectionStates(collection, deviceA.name, deviceB.name, stateA, stateB);
+        if (diff) {
+          differences.push(diff);
+        }
+      }
+    }
+  }
+  return {
+    converged: differences.length === 0,
+    differences
+  };
+}
+function compareCollectionStates(collection, nameA, nameB, stateA, stateB) {
+  const mapA = new Map(stateA.map((r) => [r.id, r]));
+  const mapB = new Map(stateB.map((r) => [r.id, r]));
+  const missingInB = [];
+  const missingInA = [];
+  const fieldDifferences = [];
+  for (const [id, recordA] of mapA) {
+    const recordB = mapB.get(id);
+    if (!recordB) {
+      missingInB.push(id);
+      continue;
+    }
+    const allFields = /* @__PURE__ */ new Set([
+      ...Object.keys(recordA).filter((k) => !k.startsWith("_")),
+      ...Object.keys(recordB).filter((k) => !k.startsWith("_"))
+    ]);
+    for (const field of allFields) {
+      if (field === "id") continue;
+      const valA = recordA[field];
+      const valB = recordB[field];
+      if (!deepEqual(valA, valB)) {
+        fieldDifferences.push({
+          recordId: id,
+          field,
+          valueInA: valA,
+          valueInB: valB
+        });
+      }
+    }
+  }
+  for (const id of mapB.keys()) {
+    if (!mapA.has(id)) {
+      missingInA.push(id);
+    }
+  }
+  if (missingInB.length === 0 && missingInA.length === 0 && fieldDifferences.length === 0) {
+    return null;
+  }
+  return {
+    collection,
+    deviceA: nameA,
+    deviceB: nameB,
+    missingInB,
+    missingInA,
+    fieldDifferences
+  };
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (a === void 0 || b === void 0) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((val, i) => deepEqual(val, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(
+      (key) => deepEqual(a[key], b[key])
+    );
+  }
+  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";
+
+// src/test-auth.ts
+function testJwt(userId, generation) {
+  const encode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
+  return `${encode({ alg: "none", typ: "JWT" })}.${encode({ sub: userId, dev: "test-device", generation })}.test`;
+}
+function createTestAuthBinding(options) {
+  let generation = 0;
+  let state = options?.initialUserId ? {
+    state: "authenticated",
+    userId: options.initialUserId,
+    token: testJwt(options.initialUserId, generation)
+  } : { state: "loading" };
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+  return {
+    get state() {
+      return state;
+    },
+    auth: async () => ({ token: state.state === "authenticated" ? state.token ?? "" : "" }),
+    resolveSyncState: async () => state,
+    resolveUserId: async () => state.state === "authenticated" ? state.userId : void 0,
+    resolveNodeId: async () => state.state === "authenticated" ? "test-device" : void 0,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    setLoading() {
+      state = { state: "loading" };
+      notify();
+    },
+    signIn(userId, token) {
+      generation++;
+      state = { state: "authenticated", userId, token: token ?? testJwt(userId, generation) };
+      notify();
+    },
+    refreshToken(token) {
+      if (state.state !== "authenticated") throw new Error("Cannot refresh while signed out");
+      generation++;
+      state = {
+        ...state,
+        token: token ?? testJwt(state.userId, generation)
+      };
+      notify();
+    },
+    signOut() {
+      state = options?.anonymous ? { state: "anonymous", mayConnectAnonymously: true } : { state: "signed-out", mayConnectAnonymously: false };
+      notify();
+    }
+  };
+}
+
+// src/transport-metrics.ts
+function wireBytes(message) {
+  return new TextEncoder().encode(JSON.stringify(message)).byteLength;
+}
+function createTransportMetrics() {
+  const metrics = {
+    connectionAttempts: 0,
+    disconnections: 0,
+    clientMessages: 0,
+    serverMessages: 0,
+    clientBytes: 0,
+    serverBytes: 0,
+    reset() {
+      this.connectionAttempts = 0;
+      this.disconnections = 0;
+      this.clientMessages = 0;
+      this.serverMessages = 0;
+      this.clientBytes = 0;
+      this.serverBytes = 0;
+    }
+  };
+  return {
+    metrics,
+    wrapTransport(pair) {
+      const client = {
+        ...pair.client,
+        async connect(url, options) {
+          metrics.connectionAttempts++;
+          await pair.client.connect(url, options);
+        },
+        async disconnect() {
+          metrics.disconnections++;
+          await pair.client.disconnect();
+        },
+        send(message) {
+          metrics.clientMessages++;
+          metrics.clientBytes += wireBytes(message);
+          pair.client.send(message);
+        },
+        onMessage: (handler) => pair.client.onMessage(handler),
+        onClose: (handler) => pair.client.onClose(handler),
+        onError: (handler) => pair.client.onError(handler),
+        isConnected: () => pair.client.isConnected()
+      };
+      const serverTransport = {
+        ...pair.serverTransport,
+        send(message) {
+          metrics.serverMessages++;
+          metrics.serverBytes += wireBytes(message);
+          pair.serverTransport.send(message);
+        },
+        onMessage: (handler) => pair.serverTransport.onMessage(handler),
+        onClose: (handler) => pair.serverTransport.onClose(handler),
+        onError: (handler) => pair.serverTransport.onError(handler),
+        isConnected: () => pair.serverTransport.isConnected(),
+        close: (code, reason) => pair.serverTransport.close(code, reason)
+      };
+      return { client, serverTransport };
+    }
+  };
+}
+export {
+  ChaosTransport2 as ChaosTransport,
+  TestDevice,
+  TestServer,
+  checkConvergence,
+  createMixedTestNetwork,
+  createTestAuthBinding,
+  createTestNetwork,
+  createTransportMetrics,
+  expectConverged,
+  expectConvergedEventually,
+  wrapTransportPairWithProtobufWire,
+  wrapTransportPairWithServerClock
+};
+//# sourceMappingURL=index.js.map