@aethervtt/shard-net 0.0.0-stage → 0.3.0

package/dist/client.js

@@ -0,0 +1,527 @@
+import {
+  ByteReader,
+  ByteWriter,
+  createRowCodec,
+  onRemove,
+  ShardError
+} from "@aethervtt/shard-core";
+import { FixedTime } from "@aethervtt/shard-runtime";
+import { Connected, Disconnected, NetClock, NetId, NetRole } from "./components.js";
+import {
+  badMessage,
+  describeManifest,
+  Fragmenter,
+  header,
+  Msg,
+  PROTOCOL_VERSION,
+  Section
+} from "./wire.js";
+class PendingCommand {
+  def;
+  seq;
+  status = "pending";
+  error;
+  constructor(def, seq) {
+    this.def = def;
+    this.seq = seq;
+  }
+}
+class InterpBuffer {
+  static SIZE = 8;
+  ticks = new Float64Array(InterpBuffer.SIZE);
+  values;
+  count = 0;
+  head = 0;
+  constructor(width) {
+    this.values = new Float64Array(InterpBuffer.SIZE * width);
+  }
+}
+const SAMPLE_WINDOW = 16;
+const PING_MS = 500;
+class NetClient {
+  world;
+  config;
+  byNetId = /* @__PURE__ */ new Map();
+  connection;
+  /** Why the server refused or dropped this client, if it did. */
+  lastError;
+  pending = /* @__PURE__ */ new Map();
+  fragmenter = new Fragmenter();
+  inbox = [];
+  applied = /* @__PURE__ */ new Map();
+  interp = /* @__PURE__ */ new Map();
+  codecs;
+  commandCodecs;
+  eventCodecs;
+  floatFields;
+  widths;
+  commandIndex = /* @__PURE__ */ new Map();
+  reader = new ByteReader();
+  out = new ByteWriter(1024);
+  latestSeq = 0;
+  seqBits = 0;
+  ackDirty = false;
+  lastPing = Number.NEGATIVE_INFINITY;
+  lastNetTick = -1;
+  nextCommand = 1;
+  rtts = [];
+  offsets = [];
+  sortScratch = [];
+  closedReason;
+  unsubscribe;
+  constructor(world, config) {
+    this.world = world;
+    this.config = config;
+    const mapping = {
+      toWire: (e) => this.toWire(e),
+      fromWire: (id) => id === 0 ? null : this.byNetId.get(id)
+    };
+    const m = config.manifest;
+    this.codecs = m.components.map(
+      (c) => createRowCodec(c.def, { quantize: c.quantize, entities: mapping })
+    );
+    this.commandCodecs = m.commands.map((c) => createRowCodec(c.schema, { entities: mapping }));
+    this.eventCodecs = m.events.map((e) => createRowCodec(e.schema, { entities: mapping }));
+    m.commands.forEach((c, i) => {
+      this.commandIndex.set(c.name, i);
+    });
+    this.floatFields = [];
+    this.widths = [];
+    for (const entry of m.components) {
+      const fields = [];
+      let offset = 0;
+      if (entry.mode === "interpolate") {
+        entry.def.layout.forEach((c, column) => {
+          if (c.storage !== "f32" && c.storage !== "f64") return;
+          fields.push({ column, stride: c.stride, quat: c.field.kind === "quat", offset });
+          offset += c.stride;
+        });
+      }
+      this.floatFields.push(fields);
+      this.widths.push(offset);
+    }
+    world.insertResource(NetClock, { serverTick: 0, offsetTicks: 0, rtt: 0, jitter: 0 });
+    this.unsubscribe = world.observe(onRemove(NetId), (event) => {
+      const table = world.entityTable(event.entity);
+      const id = table.column(NetId, "id")[world.entityRow(event.entity)];
+      if (this.byNetId.get(id) === event.entity) this.forget(id);
+    });
+  }
+  attach(connection) {
+    this.connection = connection;
+    connection.onMessage((channel, bytes) => this.inbox.push({ channel, bytes }));
+    connection.onClose((reason) => {
+      this.closedReason = reason?.message ?? "disconnected";
+      if (reason && !this.lastError) this.lastError = reason;
+    });
+    header(this.out, Msg.hello, this.world.resource(FixedTime).tick);
+    this.out.u16(PROTOCOL_VERSION);
+    this.out.u32(this.config.manifest.hash);
+    this.out.string(this.config.token);
+    this.out.string(JSON.stringify(describeManifest(this.config.manifest)));
+    this.fragmenter.send(connection, "reliable", this.out.finish(), this.config.maxMessage);
+  }
+  dispose() {
+    this.unsubscribe?.();
+    const connection = this.connection;
+    if (!connection) return;
+    header(this.out, Msg.disconnect, this.world.resource(FixedTime).tick);
+    this.out.string("left");
+    connection.send("reliable", this.out.finish());
+    connection.close("left");
+  }
+  toWire(entity) {
+    const world = this.world;
+    if (!world.isAlive(entity) || !world.has(entity, NetId)) return 0;
+    return world.entityTable(entity).column(NetId, "id")[world.entityRow(entity)];
+  }
+  forget(id) {
+    this.byNetId.delete(id);
+    this.applied.delete(id);
+    this.interp.delete(id);
+  }
+  // --- receiving -----------------------------------------------------------
+  receive() {
+    const connection = this.connection;
+    const world = this.world;
+    const fixed = world.resource(FixedTime);
+    const clock = world.resource(NetClock);
+    if (connection) {
+      connection.pump?.();
+      const inbox = this.inbox;
+      for (let i = 0; i < inbox.length; i++) {
+        try {
+          this.handle(inbox[i].bytes);
+        } catch (err) {
+          this.lastError = err instanceof ShardError ? err : badMessage(String(err));
+          connection.close(this.lastError.message);
+          this.closedReason = this.lastError.message;
+          break;
+        }
+      }
+      inbox.length = 0;
+    }
+    if (this.closedReason !== void 0) {
+      const role = world.resource(NetRole);
+      const error = this.lastError;
+      world.send(Disconnected, {
+        code: error?.code ?? "net/transport-closed",
+        message: error?.message ?? this.closedReason
+      });
+      role.connected = false;
+      this.connection = void 0;
+      this.closedReason = void 0;
+    }
+    clock.serverTick = fixed.tick + fixed.alpha + clock.offsetTicks;
+  }
+  handle(bytes) {
+    const r = this.reader;
+    r.reset(bytes);
+    const kind = r.u8();
+    const tick = r.u32();
+    switch (kind) {
+      case Msg.fragment: {
+        const whole = this.fragmenter.receive(r);
+        if (whole) this.handle(whole);
+        return;
+      }
+      case Msg.welcome:
+        this.welcome(r, tick);
+        return;
+      case Msg.refused: {
+        const code = r.string();
+        const message = r.string();
+        const hint = r.string();
+        this.lastError = new ShardError(code, message, hint ? { hint } : {});
+        this.closedReason = message;
+        return;
+      }
+      case Msg.disconnect:
+        this.lastError = new ShardError("net/disconnected", r.string());
+        this.closedReason = this.lastError.message;
+        return;
+      case Msg.pong:
+        this.pong(r, tick);
+        return;
+      case Msg.reliable:
+        this.reliable(r, tick);
+        return;
+      case Msg.state:
+        this.state(r, tick);
+        return;
+      default:
+        throw badMessage(`unknown kind ${kind}`);
+    }
+  }
+  welcome(r, serverTick) {
+    const world = this.world;
+    const peer = r.varuint();
+    r.u16();
+    const role = world.resource(NetRole);
+    role.peer = peer;
+    role.connected = true;
+    const clock = world.resource(NetClock);
+    clock.offsetTicks = serverTick - world.resource(FixedTime).tick;
+    world.send(Connected, { peer });
+  }
+  pong(r, serverTick) {
+    const sentAt = r.f64();
+    const fixed = this.world.resource(FixedTime);
+    const clock = this.world.resource(NetClock);
+    const rtt = Math.max(0, this.config.now() - sentAt);
+    pushSample(this.rtts, rtt);
+    const stepMs = fixed.step * 1e3;
+    pushSample(this.offsets, serverTick + rtt / 2 / stepMs - (fixed.tick + fixed.alpha));
+    clock.rtt = median(this.rtts, this.sortScratch);
+    clock.offsetTicks = median(this.offsets, this.sortScratch);
+    let spread = 0;
+    for (const v of this.rtts) spread += Math.abs(v - clock.rtt);
+    clock.jitter = spread / this.rtts.length;
+  }
+  stale(netId, comp, tick) {
+    let ticks = this.applied.get(netId);
+    if (!ticks) {
+      ticks = new Float64Array(this.codecs.length).fill(-1);
+      this.applied.set(netId, ticks);
+    }
+    if (tick < ticks[comp]) return true;
+    ticks[comp] = tick;
+    return false;
+  }
+  /** Decodes one component update into its entity. False if it named an unknown entity. */
+  apply(r, netId, comp, tick) {
+    const codec = this.codecs[comp];
+    if (!codec) throw badMessage(`component #${comp}`);
+    const entity = this.byNetId.get(netId);
+    if (entity === void 0 || !this.world.isAlive(entity)) {
+      codec.decode(r);
+      return false;
+    }
+    if (this.stale(netId, comp, tick)) {
+      codec.decode(r);
+      return true;
+    }
+    const world = this.world;
+    if (!world.has(entity, codec.def)) world.add(entity, codec.def);
+    const ok = codec.decodeRow(r, world.entityTable(entity), world.entityRow(entity));
+    if (this.widths[comp] > 0) this.sample(netId, comp, entity, tick);
+    return ok;
+  }
+  reliable(r, tick) {
+    const world = this.world;
+    for (; ; ) {
+      const section = r.u8();
+      if (section === Section.end) return;
+      const count = r.varuint();
+      for (let i = 0; i < count; i++) {
+        switch (section) {
+          case Section.spawn: {
+            const netId = r.varuint();
+            const prefab = r.string();
+            const old = this.byNetId.get(netId);
+            if (old !== void 0 && world.isAlive(old)) world.despawn(old);
+            const spawn = this.config.spawnPrefab;
+            const entity = prefab && spawn ? spawn(world, prefab) : world.spawn();
+            world.add(entity, NetId, { id: netId });
+            this.byNetId.set(netId, entity);
+            break;
+          }
+          case Section.set:
+            this.apply(r, r.varuint(), r.varuint(), tick);
+            break;
+          case Section.remove: {
+            const entity = this.byNetId.get(r.varuint());
+            const def = this.codecs[r.varuint()]?.def;
+            if (entity !== void 0 && def && world.isAlive(entity)) world.remove(entity, def);
+            break;
+          }
+          case Section.despawn: {
+            const netId = r.varuint();
+            const entity = this.byNetId.get(netId);
+            this.forget(netId);
+            if (entity !== void 0 && world.isAlive(entity)) world.despawn(entity);
+            break;
+          }
+          case Section.answer: {
+            const seq = r.varuint();
+            const code = r.string();
+            const message = r.string();
+            const hint = r.string();
+            const pending = this.pending.get(seq);
+            if (!pending) break;
+            this.pending.delete(seq);
+            if (code) {
+              pending.status = "rejected";
+              pending.error = new ShardError(code, message, hint ? { hint } : {});
+            } else pending.status = "accepted";
+            break;
+          }
+          case Section.event: {
+            const index = r.varuint();
+            const def = this.config.manifest.events[index];
+            const codec = this.eventCodecs[index];
+            if (!def || !codec) throw badMessage(`event #${index}`);
+            const data = codec.decode(r);
+            if (data) world.send(def.event, { data, tick });
+            break;
+          }
+          default:
+            throw badMessage(`section ${section}`);
+        }
+      }
+    }
+  }
+  state(r, tick) {
+    const seq = r.u32();
+    const count = r.u32();
+    let complete = true;
+    for (let i = 0; i < count; i++) {
+      if (!this.apply(r, r.varuint(), r.varuint(), tick)) complete = false;
+    }
+    if (complete) this.received(seq);
+  }
+  received(seq) {
+    if (seq > this.latestSeq) {
+      const shift = seq - this.latestSeq;
+      this.seqBits = shift > 32 ? 0 : shift === 32 ? 1 << 31 : (this.seqBits << shift | 1 << shift - 1) >>> 0;
+      if (this.latestSeq === 0) this.seqBits = 0;
+      this.latestSeq = seq;
+    } else if (seq < this.latestSeq) {
+      const diff = this.latestSeq - seq;
+      if (diff <= 32) this.seqBits = (this.seqBits | 1 << diff - 1) >>> 0;
+    }
+    this.ackDirty = true;
+  }
+  // --- interpolation -------------------------------------------------------
+  sample(netId, comp, entity, tick) {
+    let buffers = this.interp.get(netId);
+    if (!buffers) {
+      buffers = new Array(this.codecs.length);
+      this.interp.set(netId, buffers);
+    }
+    let buffer = buffers[comp];
+    if (!buffer) {
+      buffer = new InterpBuffer(this.widths[comp]);
+      buffers[comp] = buffer;
+    }
+    const width = this.widths[comp];
+    const newest = buffer.count > 0 ? buffer.ticks[(buffer.head + SIZE - 1) % SIZE] : -1;
+    if (tick <= newest) return;
+    const slot = buffer.head;
+    buffer.ticks[slot] = tick;
+    const world = this.world;
+    const storage = world.entityTable(entity).storage(this.codecs[comp].def);
+    const row = world.entityRow(entity);
+    for (const f of this.floatFields[comp]) {
+      const column = storage.columns[f.column];
+      for (let i = 0; i < f.stride; i++) {
+        buffer.values[slot * width + f.offset + i] = column[row * f.stride + i];
+      }
+    }
+    buffer.head = (slot + 1) % SIZE;
+    if (buffer.count < SIZE) buffer.count++;
+  }
+  /** Writes interpolated values for every remote entity (PreUpdate). */
+  interpolate() {
+    if (this.interp.size === 0) return;
+    const world = this.world;
+    const fixed = world.resource(FixedTime);
+    const clock = world.resource(NetClock);
+    const step = fixed.step;
+    const delay = Math.max(2 * this.config.ticksPerNet, 2 * clock.jitter / 1e3 / step);
+    this.renderTick = clock.serverTick - clock.rtt / 2 / 1e3 / step - delay;
+    this.interp.forEach(this.interpolateEntity);
+  }
+  renderTick = 0;
+  interpolateEntity = (buffers, netId) => {
+    const world = this.world;
+    const entity = this.byNetId.get(netId);
+    if (entity === void 0 || !world.isAlive(entity)) return;
+    for (let c = 0; c < buffers.length; c++) {
+      const buffer = buffers[c];
+      if (!buffer || buffer.count === 0) continue;
+      if (!world.has(entity, this.codecs[c].def)) continue;
+      this.write(buffer, c, entity, this.renderTick);
+    }
+  };
+  write(buffer, comp, entity, renderTick) {
+    const width = this.widths[comp];
+    const oldest = (buffer.head + SIZE - buffer.count) % SIZE;
+    const newestSlot = (buffer.head + SIZE - 1) % SIZE;
+    let a = oldest;
+    let b = oldest;
+    let t = 0;
+    if (renderTick <= buffer.ticks[oldest]) {
+      a = b = oldest;
+    } else if (renderTick >= buffer.ticks[newestSlot]) {
+      a = b = newestSlot;
+    } else {
+      for (let k = 0; k < buffer.count - 1; k++) {
+        const i = (oldest + k) % SIZE;
+        const j = (i + 1) % SIZE;
+        if (renderTick >= buffer.ticks[i] && renderTick <= buffer.ticks[j]) {
+          a = i;
+          b = j;
+          const span = buffer.ticks[j] - buffer.ticks[i];
+          t = span > 0 ? (renderTick - buffer.ticks[i]) / span : 0;
+          break;
+        }
+      }
+    }
+    const world = this.world;
+    const table = world.entityTable(entity);
+    const storage = table.storage(this.codecs[comp].def);
+    const row = world.entityRow(entity);
+    const va = buffer.values;
+    for (const f of this.floatFields[comp]) {
+      const column = storage.columns[f.column];
+      const base = row * f.stride;
+      const oa = a * width + f.offset;
+      const ob = b * width + f.offset;
+      if (f.quat) {
+        const dot = va[oa] * va[ob] + va[oa + 1] * va[ob + 1] + va[oa + 2] * va[ob + 2] + va[oa + 3] * va[ob + 3];
+        const sign = dot < 0 ? -1 : 1;
+        const u = Math.min(t, 1);
+        let len = 0;
+        for (let i = 0; i < 4; i++) {
+          const v = va[oa + i] * (1 - u) + va[ob + i] * sign * u;
+          column[base + i] = v;
+          len += v * v;
+        }
+        len = Math.sqrt(len) || 1;
+        for (let i = 0; i < 4; i++) column[base + i] = column[base + i] / len;
+        continue;
+      }
+      for (let i = 0; i < f.stride; i++) {
+        column[base + i] = va[oa + i] + (va[ob + i] - va[oa + i]) * t;
+      }
+    }
+    table.markChanged(this.codecs[comp].def, row);
+  }
+  // --- sending -------------------------------------------------------------
+  /** Runs in Last: acks and pings on network ticks. */
+  send() {
+    const connection = this.connection;
+    const world = this.world;
+    if (!connection || !world.resource(NetRole).connected) return;
+    const fixed = world.resource(FixedTime);
+    const netTick = Math.floor(fixed.tick / this.config.ticksPerNet);
+    if (netTick === this.lastNetTick) return;
+    this.lastNetTick = netTick;
+    world.resource(NetRole).tick = Math.floor(world.resource(NetClock).serverTick);
+    if (this.ackDirty) {
+      header(this.out, Msg.ack, fixed.tick);
+      this.out.varuint(this.latestSeq);
+      this.out.u32(this.seqBits);
+      this.out.f64(world.resource(NetClock).rtt);
+      connection.send("unreliable", this.out.finish());
+      this.ackDirty = false;
+    }
+    const now = this.config.now();
+    if (now - this.lastPing >= PING_MS) {
+      this.lastPing = now;
+      header(this.out, Msg.ping, fixed.tick);
+      this.out.f64(now);
+      connection.send("unreliable", this.out.finish());
+    }
+  }
+  sendCommand(def, data) {
+    const index = this.commandIndex.get(def.name);
+    if (index === void 0) {
+      throw new ShardError("net/unknown-command", `${def.name} isn't in netPlugin({ commands })`, {
+        hint: "List every net command in the plugin options on both sides."
+      });
+    }
+    const pending = new PendingCommand(def, this.nextCommand++);
+    const connection = this.connection;
+    if (!connection || !this.world.resource(NetRole).connected) {
+      pending.status = "rejected";
+      pending.error = new ShardError("net/not-connected", `Can't send ${def.name}: not connected`);
+      return pending;
+    }
+    this.pending.set(pending.seq, pending);
+    header(this.out, Msg.command, this.world.resource(FixedTime).tick);
+    this.out.varuint(pending.seq);
+    this.out.varuint(index);
+    this.commandCodecs[index].encode(data, this.out);
+    this.fragmenter.send(connection, "reliable", this.out.finish(), this.config.maxMessage);
+    return pending;
+  }
+}
+const SIZE = InterpBuffer.SIZE;
+function pushSample(list, v) {
+  list.push(v);
+  if (list.length > SAMPLE_WINDOW) list.shift();
+}
+function median(list, scratch) {
+  scratch.length = 0;
+  for (const v of list) scratch.push(v);
+  scratch.sort((a, b) => a - b);
+  const n = scratch.length;
+  if (n === 0) return 0;
+  return n % 2 === 1 ? scratch[(n - 1) / 2] : (scratch[n / 2 - 1] + scratch[n / 2]) / 2;
+}
+export {
+  NetClient,
+  PendingCommand
+};

package/dist/components.d.ts

@@ -0,0 +1,72 @@
+import type { PeerId } from './transport.js';
+export declare const NetId: import("@aethervtt/shard-core").ComponentDef<{
+    readonly id: import("@aethervtt/shard-core").FieldType<number, "u32">;
+}>;
+export declare const Replicated: import("@aethervtt/shard-core").ComponentDef<{
+    readonly prefab: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly owner: import("@aethervtt/shard-core").FieldType<number, "u32">;
+}>;
+export declare const Relevance: import("@aethervtt/shard-core").ComponentDef<{
+    readonly always: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly priority: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export declare const Focus: import("@aethervtt/shard-core").ComponentDef<{
+    readonly peer: import("@aethervtt/shard-core").FieldType<number, "u32">;
+}>;
+export type NetRoleName = 'server' | 'client';
+export interface NetRoleData {
+    role: NetRoleName;
+    /** This app's peer id: 0 on the server, assigned by the server on a client. */
+    peer: PeerId;
+    /** Client: handshake done. Server: listening (or running locally with no transport). */
+    connected: boolean;
+    /** The last network tick sent (server) or received (client). */
+    tick: number;
+}
+export declare const NetRole: import("@aethervtt/shard-core").ResourceDef<NetRoleData>;
+export interface NetClockData {
+    /** The server tick now, estimated (fractional). Equals FixedTime.tick on the server. */
+    serverTick: number;
+    /** serverTick minus this app's FixedTime.tick, smoothed. */
+    offsetTicks: number;
+    /** Round trip in ms. */
+    rtt: number;
+    /** Spread of recent round trips in ms. */
+    jitter: number;
+}
+export declare const NetClock: import("@aethervtt/shard-core").ResourceDef<NetClockData>;
+export interface PeerInfo {
+    readonly id: PeerId;
+    /** `joining`: accept or the player load is still running (0090). */
+    state: 'handshake' | 'joining' | 'connected';
+    rtt: number;
+    /** The token the client sent with hello. */
+    token: string;
+    /** What `accept` returned as `user`: the peer's account (0090). */
+    user: unknown;
+    joinedTick: number;
+}
+export declare const Peers: import("@aethervtt/shard-core").ResourceDef<Map<number, PeerInfo>>;
+export declare const PeerJoined: import("@aethervtt/shard-core").EventDef<{
+    peer: PeerId;
+    user: unknown;
+}>;
+export declare const PeerLeft: import("@aethervtt/shard-core").EventDef<{
+    peer: PeerId;
+    reason: string;
+    user: unknown;
+}>;
+/** Server: a player's `store` failed (0090). The server keeps running. */
+export declare const PlayerSaveFailed: import("@aethervtt/shard-core").EventDef<{
+    peer: PeerId;
+    user: unknown;
+    code: string;
+    message: string;
+}>;
+export declare const Connected: import("@aethervtt/shard-core").EventDef<{
+    peer: PeerId;
+}>;
+export declare const Disconnected: import("@aethervtt/shard-core").EventDef<{
+    code: string;
+    message: string;
+}>;

package/dist/components.js

@@ -0,0 +1,71 @@
+import { defineComponent, defineEvent, defineResource, t } from "@aethervtt/shard-core";
+const NetId = defineComponent(
+  "net/NetId",
+  {
+    id: t.u32({
+      readonly: true,
+      description: "Session-wide id the server assigned. Never reused."
+    })
+  },
+  {
+    description: "The id an entity has on every machine in a session (0087).",
+    serialize: false
+  }
+);
+const Replicated = defineComponent(
+  "net/Replicated",
+  {
+    prefab: t.string({
+      description: "Prefab clients spawn this entity from (path or guid); empty for a bare entity."
+    }),
+    owner: t.u32({ description: "Peer that owns it; 0 for the server." })
+  },
+  {
+    description: "Marks a server entity for replication (0087). Add it on the server; clients never author it.",
+    serialize: false
+  }
+);
+const Relevance = defineComponent(
+  "net/Relevance",
+  {
+    always: t.bool({ description: "Every client receives it, whatever the interest policy says." }),
+    priority: t.f32({ default: 1, min: 0, description: "Weight when bandwidth is short." })
+  },
+  { description: "Pins or raises an entity in interest management (0087).", serialize: false }
+);
+const Focus = defineComponent(
+  "net/Focus",
+  { peer: t.u32({ description: "Peer whose interest centres here (a spectator camera)." }) },
+  {
+    description: "An extra point of interest for a peer, besides the entities it owns (0087).",
+    serialize: false
+  }
+);
+const NetRole = defineResource("net/NetRole", {
+  description: "Which side of a session this app is, and whether it is connected (0086)."
+});
+const NetClock = defineResource("net/NetClock", {
+  description: "Clock estimate against the server: tick offset, RTT and jitter (0086)."
+});
+const Peers = defineResource("net/Peers", {
+  description: "Server: connected peers by id (0086)."
+});
+const PeerJoined = defineEvent("net/PeerJoined");
+const PeerLeft = defineEvent("net/PeerLeft");
+const PlayerSaveFailed = defineEvent("net/PlayerSaveFailed");
+const Connected = defineEvent("net/Connected");
+const Disconnected = defineEvent("net/Disconnected");
+export {
+  Connected,
+  Disconnected,
+  Focus,
+  NetClock,
+  NetId,
+  NetRole,
+  PeerJoined,
+  PeerLeft,
+  Peers,
+  PlayerSaveFailed,
+  Relevance,
+  Replicated
+};

package/dist/conditions.d.ts

@@ -0,0 +1,29 @@
+import type { NetTransport } from './transport.js';
+export interface NetConditions {
+    /** One-way delay in seconds, each direction. RTT is twice this. */
+    latency: number;
+    /** Up to this many extra seconds per message, uniformly. */
+    jitter: number;
+    /** Probability an unreliable message is dropped, each direction. */
+    loss: number;
+    /** Probability an unreliable message arrives twice. */
+    duplicate: number;
+    /** Unreliable messages may overtake each other under jitter. Reliable ones never do. */
+    reorder: boolean;
+}
+export interface ConditionsOptions extends Partial<NetConditions> {
+    seed?: number;
+    /** The clock in ms. Tests pass the fake clock every app shares. */
+    now?: () => number;
+}
+/** A transport whose conditions can change at runtime (`net.conditions`). */
+export interface ConditionedTransport extends NetTransport {
+    readonly conditions: NetConditions;
+    setConditions(conditions: Partial<NetConditions>): void;
+}
+export declare function isConditioned(transport: NetTransport): transport is ConditionedTransport;
+/**
+ * Wraps any transport with seeded latency, jitter, loss and duplication (0086). Connections it
+ * makes or accepts deliver both directions through the delay, so one wrapped side is enough.
+ */
+export declare function simulateConditions(transport: NetTransport, options?: ConditionsOptions): ConditionedTransport;