@aethervtt/shard-net 0.0.0-stage → 0.3.0

package/dist/server.js

@@ -0,0 +1,1002 @@
+import {
+  ByteReader,
+  ByteWriter,
+  ChildOf,
+  createRowCodec,
+  onRemove,
+  ShardError
+} from "@aethervtt/shard-core";
+import { FixedTime, LogResource } from "@aethervtt/shard-runtime";
+import {
+  Focus,
+  NetId,
+  NetRole,
+  PeerJoined,
+  PeerLeft,
+  Peers,
+  PlayerSaveFailed,
+  Relevance,
+  Replicated
+} from "./components.js";
+import { RelevanceSet } from "./interest.js";
+import { NumberList } from "./vec.js";
+import {
+  badMessage,
+  describeManifest,
+  Fragmenter,
+  header,
+  Msg,
+  PROTOCOL_VERSION,
+  Section
+} from "./wire.js";
+const PACKET_RING = 64;
+class ServerCommand {
+  def;
+  peer;
+  seq;
+  data;
+  arrivedTick;
+  status = "pending";
+  error;
+  answer;
+  constructor(def, peer, seq, data, arrivedTick, answer) {
+    this.def = def;
+    this.peer = peer;
+    this.seq = seq;
+    this.data = data;
+    this.arrivedTick = arrivedTick;
+    this.answer = answer;
+  }
+  accept() {
+    if (this.status !== "pending") return;
+    this.status = "accepted";
+    this.answer(this);
+  }
+  reject(code, message = code, hint) {
+    if (this.status !== "pending") return;
+    this.status = "rejected";
+    this.error = new ShardError(code, message, hint === void 0 ? {} : { hint });
+    this.answer(this);
+  }
+}
+class PeerState {
+  id;
+  info;
+  connection;
+  fragmenter = new Fragmenter();
+  inbox = [];
+  known = /* @__PURE__ */ new Map();
+  relevant = new RelevanceSet();
+  /** Last tick's relevant set, for hysteresis (`knows`). */
+  previous = new RelevanceSet();
+  focus = [];
+  packets = [];
+  answers = [];
+  nextSeq = 1;
+  closed;
+  /** When the join started (config.now), for the timeout. */
+  joinStarted = 0;
+  /** Command rate limit: tokens refill at commandsPerSecond. */
+  tokens;
+  lastRefill = 0;
+  stats = {
+    bytesSent: 0,
+    bytesByComponent: {},
+    deferred: 0,
+    resends: 0,
+    commands: 0,
+    rejected: 0
+  };
+  constructor(connection, id, tick, tokens) {
+    this.id = id;
+    this.connection = connection;
+    this.tokens = tokens;
+    this.info = {
+      id,
+      state: "handshake",
+      rtt: 0,
+      token: "",
+      user: void 0,
+      joinedTick: tick
+    };
+    for (let i = 0; i < PACKET_RING; i++) {
+      this.packets.push({
+        seq: 0,
+        acked: true,
+        netIds: new NumberList(),
+        comps: new NumberList(),
+        ticks: new NumberList()
+      });
+    }
+  }
+  /** Whether the peer had the entity after the last network tick. */
+  knows(entity) {
+    return this.previous.has(entity);
+  }
+}
+class NetServer {
+  world;
+  config;
+  peers = /* @__PURE__ */ new Map();
+  /** The same peers as an array, so per-frame loops don't allocate iterators. */
+  peerList = [];
+  byNetId = /* @__PURE__ */ new Map();
+  commands = [];
+  /** Recent commands for `net.commands`. */
+  recentCommands = [];
+  recentEvents = [];
+  nextNetId = 1;
+  nextPeer = 1;
+  /** Joins whose async accept/load finished, applied in the next receive. */
+  settled = [];
+  saveFailures = [];
+  stores = /* @__PURE__ */ new Set();
+  incoming = [];
+  events = [];
+  codecs;
+  commandCodecs;
+  eventCodecs;
+  commandIndex = /* @__PURE__ */ new Map();
+  eventIndex = /* @__PURE__ */ new Map();
+  reader = new ByteReader();
+  out = new ByteWriter(4096);
+  state = new ByteWriter(4096);
+  spawns = new ByteWriter(1024);
+  sets = new ByteWriter(4096);
+  removes = new ByteWriter(256);
+  despawns = new ByteWriter(256);
+  tail = new ByteWriter(1024);
+  current;
+  pendingRef = false;
+  despawnCount = 0;
+  lastNetTick = -1;
+  unassigned;
+  replicatedQuery;
+  focusQuery;
+  relevanceQuery;
+  newEntities = [];
+  candidates = new NumberList();
+  scores = new NumberList();
+  order = new Uint32Array(64);
+  despawnKnown;
+  listener;
+  unsubscribe;
+  constructor(world, config) {
+    this.world = world;
+    this.config = config;
+    const mapping = {
+      toWire: (e) => this.toWire(e),
+      fromWire: (id) => this.fromWire(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);
+    });
+    m.events.forEach((e, i) => {
+      this.eventIndex.set(e.name, i);
+    });
+    this.unassigned = world.query({ with: [Replicated], without: [NetId] });
+    this.replicatedQuery = world.query({ with: [Replicated] });
+    this.focusQuery = world.query({ with: [Focus] });
+    this.relevanceQuery = world.query({ with: [Relevance, Replicated] });
+    this.despawnKnown = (known) => {
+      const peer = this.current;
+      if (this.world.isAlive(known.entity) && peer.relevant.has(known.entity)) return;
+      this.despawns.varuint(known.netId);
+      this.despawnCount++;
+      peer.known.delete(known.netId);
+    };
+    this.unsubscribe = world.observe(onRemoveNetId, (event) => {
+      const id = readNetId(world, event.entity);
+      if (id !== void 0) this.byNetId.delete(id);
+    });
+    world.insertResource(Peers, /* @__PURE__ */ new Map());
+  }
+  attach(listener) {
+    this.listener = listener;
+    listener.onConnection((connection) => {
+      const tick = this.world.resource(FixedTime).tick;
+      const peer = new PeerState(connection, this.nextPeer++, tick, this.config.commandsPerSecond);
+      connection.onMessage((channel, bytes) => peer.inbox.push({ channel, bytes }));
+      connection.onClose((reason) => {
+        peer.closed = reason?.message ?? "disconnected";
+      });
+      this.incoming.push(peer);
+    });
+  }
+  /** Saves every connected player (0090), closes their connections, and waits for the stores. */
+  async dispose() {
+    for (const peer of [...this.peerList]) {
+      if (peer.info.state === "connected") {
+        this.sendDisconnect(peer, "server stopped");
+        this.drop(peer, "server stopped");
+      } else peer.connection.close("server stopped");
+    }
+    await this.flush();
+    this.unsubscribe?.();
+    await this.listener?.close();
+  }
+  /** Resolves when every player store in flight has settled. */
+  async flush() {
+    while (this.stores.size > 0) await Promise.allSettled([...this.stores]);
+  }
+  // --- entity ids ----------------------------------------------------------
+  toWire(entity) {
+    const world = this.world;
+    if (!world.isAlive(entity) || !world.has(entity, NetId)) return 0;
+    const id = world.entityTable(entity).column(NetId, "id")[world.entityRow(entity)];
+    const peer = this.current;
+    if (!peer || peer.known.has(id)) return id;
+    if (peer.relevant.has(entity)) {
+      this.pendingRef = true;
+      return id;
+    }
+    return 0;
+  }
+  fromWire(id) {
+    if (id === 0) return null;
+    const peer = this.current;
+    if (peer && !peer.known.has(id)) return void 0;
+    return this.byNetId.get(id);
+  }
+  netIdOf(entity) {
+    return readNetId(this.world, entity);
+  }
+  // --- receiving -----------------------------------------------------------
+  receive() {
+    const world = this.world;
+    const tick = world.resource(FixedTime).tick;
+    for (let i = 0; i < this.incoming.length; i++) {
+      const peer = this.incoming[i];
+      this.peers.set(peer.id, peer);
+      this.peerList.push(peer);
+    }
+    this.incoming.length = 0;
+    this.settleJoins();
+    for (const f of this.saveFailures.splice(0)) {
+      world.send(PlayerSaveFailed, {
+        peer: f.peer,
+        user: f.user,
+        code: f.error.code,
+        message: f.error.message
+      });
+    }
+    const peers = this.peerList;
+    for (let p = 0; p < peers.length; p++) {
+      const peer = peers[p];
+      peer.connection.pump?.();
+      this.current = peer;
+      const inbox = peer.inbox;
+      for (let i = 0; i < inbox.length; i++) {
+        try {
+          this.handle(peer, inbox[i].bytes, tick);
+        } catch (err) {
+          const error = err instanceof ShardError ? err : badMessage(String(err));
+          this.refuse(peer, error);
+        }
+        if (peer.closed) break;
+      }
+      inbox.length = 0;
+      this.current = void 0;
+      if (peer.closed) {
+        this.drop(peer, peer.closed);
+        p--;
+      }
+    }
+  }
+  handle(peer, bytes, tick) {
+    const r = this.reader;
+    r.reset(bytes);
+    const kind = r.u8();
+    const sentTick = r.u32();
+    if (kind === Msg.fragment) {
+      const whole = peer.fragmenter.receive(r);
+      if (whole) this.handle(peer, whole, tick);
+      return;
+    }
+    if (kind === Msg.hello) {
+      this.hello(peer, r, tick);
+      return;
+    }
+    if (peer.info.state !== "connected") throw badMessage("message before handshake");
+    switch (kind) {
+      case Msg.ping: {
+        const clientTime = r.f64();
+        header(this.out, Msg.pong, tick);
+        this.out.f64(clientTime);
+        this.out.u32(sentTick);
+        peer.connection.send("unreliable", this.out.finish());
+        return;
+      }
+      case Msg.ack:
+        this.ack(peer, r);
+        return;
+      case Msg.command:
+        this.command(peer, r, tick);
+        return;
+      case Msg.disconnect:
+        peer.closed = r.remaining > 0 ? r.string() : "left";
+        return;
+      default:
+        throw badMessage(`unknown kind ${kind}`);
+    }
+  }
+  hello(peer, r, tick) {
+    const protocol = r.u16();
+    const hash = r.u32();
+    const token = r.string();
+    const types = JSON.parse(r.string());
+    const m = this.config.manifest;
+    if (protocol !== PROTOCOL_VERSION) {
+      this.refuse(
+        peer,
+        new ShardError(
+          "net/schema-mismatch",
+          `Protocol ${protocol}, server runs ${PROTOCOL_VERSION}`
+        )
+      );
+      return;
+    }
+    if (hash !== m.hash) {
+      const mine = describeManifest(m);
+      const differs = mine.find((line) => !types.includes(line)) ?? types.find((line) => !mine.includes(line));
+      this.refuse(
+        peer,
+        new ShardError(
+          "net/schema-mismatch",
+          `Client and server disagree on ${differs ?? "their replicated types"}`,
+          { hint: "Run the same build of the game on both sides." }
+        )
+      );
+      return;
+    }
+    let taken = 0;
+    for (const p of this.peerList) if (p.info.state !== "handshake") taken++;
+    if (taken >= this.config.maxPeers) {
+      this.refuse(peer, new ShardError("net/full", "The server is full"));
+      return;
+    }
+    peer.info.state = "joining";
+    peer.info.token = token;
+    peer.joinStarted = this.config.now();
+    this.join(peer, token, tick);
+  }
+  // --- joining and leaving (0090) -------------------------------------------
+  join(peer, token, tick) {
+    let result;
+    try {
+      result = this.config.accept?.(peer.id, token, this.world);
+    } catch (err) {
+      this.finishJoin(peer, { peer, error: failure(err, "net/accept-failed") }, tick);
+      return;
+    }
+    if (!isPromise(result) && !this.config.players?.load) {
+      this.finishJoin(peer, outcome(peer, result), tick);
+      return;
+    }
+    void this.joinAsync(peer, token, result);
+  }
+  async joinAsync(peer, token, result) {
+    let accepted;
+    try {
+      accepted = await result;
+    } catch (err) {
+      this.settled.push({ peer, error: failure(err, "net/accept-failed") });
+      return;
+    }
+    const first = outcome(peer, accepted);
+    const load = this.config.players?.load;
+    if (first.error || !load || peer.closed) {
+      this.settled.push(first);
+      return;
+    }
+    try {
+      const data = await load({ peer: peer.id, user: first.user, token });
+      this.settled.push({ peer, user: first.user, data });
+    } catch (err) {
+      this.settled.push({ peer, error: failure(err, "net/load-failed") });
+    }
+  }
+  /** Applies finished joins, and times out the slow ones. */
+  settleJoins() {
+    const tick = this.world.resource(FixedTime).tick;
+    for (const result of this.settled.splice(0)) this.finishJoin(result.peer, result, tick);
+    const now = this.config.now();
+    for (const peer of this.peerList) {
+      if (peer.info.state === "joining" && !peer.closed && now - peer.joinStarted > this.config.joinTimeout) {
+        this.refuse(
+          peer,
+          new ShardError(
+            "net/join-timeout",
+            `Joining took over ${this.config.joinTimeout / 1e3} s`,
+            {
+              hint: "accept and players.load must settle within joinTimeout."
+            }
+          )
+        );
+      }
+    }
+  }
+  finishJoin(peer, result, tick) {
+    if (peer.closed || peer.info.state !== "joining" || !this.peers.has(peer.id)) return;
+    if (result.error) {
+      this.refuse(peer, result.error);
+      return;
+    }
+    const user = result.user;
+    peer.info.user = user;
+    try {
+      this.config.players?.spawn?.(this.world, {
+        peer: peer.id,
+        user,
+        token: peer.info.token,
+        data: result.data
+      });
+    } catch (err) {
+      this.refuse(peer, failure(err, "net/spawn-failed"));
+      return;
+    }
+    peer.info.state = "connected";
+    peer.info.joinedTick = tick;
+    this.world.resource(Peers).set(peer.id, peer.info);
+    header(this.out, Msg.welcome, tick);
+    this.out.varuint(peer.id);
+    this.out.u16(this.config.ticksPerNet);
+    peer.connection.send("reliable", this.out.finish());
+    this.world.send(PeerJoined, { peer: peer.id, user });
+  }
+  ownedBy(peer) {
+    const owned = [];
+    for (const table of this.replicatedQuery.tables) {
+      const owner = table.column(Replicated, "owner");
+      for (let row = 0; row < table.count; row++) {
+        if (owner[row] === peer) owned.push(table.entities[row]);
+      }
+    }
+    return owned;
+  }
+  /** Captures a connected player's data and starts its store. Undefined without hooks. */
+  save(peer) {
+    const state = this.peers.get(peer);
+    if (state?.info.state !== "connected") {
+      throw new ShardError("net/not-connected", `Peer ${peer} isn't connected`);
+    }
+    return this.captureAndStore(state, this.ownedBy(peer));
+  }
+  captureAndStore(peer, owned) {
+    const players = this.config.players;
+    if (!players?.capture && !players?.store) return void 0;
+    const user = peer.info.user;
+    let data;
+    try {
+      data = players.capture?.(this.world, { peer: peer.id, user, owned });
+    } catch (err) {
+      this.saveFailed(peer.id, user, failure(err, "net/save-failed"));
+      return void 0;
+    }
+    if (!players.store) return void 0;
+    let stored;
+    try {
+      stored = Promise.resolve(players.store({ peer: peer.id, user, data }));
+    } catch (err) {
+      stored = Promise.reject(err);
+    }
+    const tracked = stored.then(
+      () => void 0,
+      (err) => this.saveFailed(peer.id, user, failure(err, "net/save-failed"))
+    );
+    this.stores.add(tracked);
+    void tracked.finally(() => this.stores.delete(tracked));
+    return stored;
+  }
+  saveFailed(peer, user, error) {
+    this.saveFailures.push({ peer, user, error });
+    this.world.tryResource(LogResource)?.error(error);
+  }
+  /** A connected peer left: save it, despawn what it owned, tell the game. */
+  leave(peer, reason) {
+    const owned = this.ownedBy(peer.id);
+    this.captureAndStore(peer, owned);
+    if (this.config.players && (this.config.players.despawn ?? true)) {
+      for (const e of owned) if (this.world.isAlive(e)) this.world.despawn(e);
+    }
+    this.world.send(PeerLeft, { peer: peer.id, reason, user: peer.info.user });
+  }
+  refuse(peer, error) {
+    header(this.out, Msg.refused, this.world.resource(FixedTime).tick);
+    this.out.string(error.code);
+    this.out.string(error.message);
+    this.out.string(error.hint ?? "");
+    peer.connection.send("reliable", this.out.finish());
+    peer.connection.close(error.message);
+    peer.closed = error.code;
+  }
+  drop(peer, reason) {
+    this.peers.delete(peer.id);
+    const index = this.peerList.indexOf(peer);
+    if (index !== -1) this.peerList.splice(index, 1);
+    const wasConnected = this.world.resource(Peers).delete(peer.id);
+    for (const cmd of this.commands) if (cmd.peer === peer.id) cmd.reject("net/peer-left");
+    if (wasConnected) this.leave(peer, reason);
+    peer.info.state = "handshake";
+  }
+  sendDisconnect(peer, reason) {
+    header(this.out, Msg.disconnect, this.world.resource(FixedTime).tick);
+    this.out.string(reason);
+    peer.connection.send("reliable", this.out.finish());
+    peer.connection.close(reason);
+  }
+  /** Disconnects a peer (`net.disconnect`). */
+  disconnect(peer, reason = "disconnected by the server") {
+    const state = this.peers.get(peer);
+    if (!state) return false;
+    this.sendDisconnect(state, reason);
+    this.drop(state, reason);
+    return true;
+  }
+  ack(peer, r) {
+    const latest = r.varuint();
+    const bits = r.u32();
+    const rtt = r.f64();
+    if (rtt > 0) peer.info.rtt = rtt;
+    for (let i = 0; i <= 32; i++) {
+      if (i > 0 && (bits & 1 << i - 1) === 0) continue;
+      const seq = latest - i;
+      if (seq <= 0) break;
+      const record = peer.packets[seq % PACKET_RING];
+      if (record.seq !== seq || record.acked) continue;
+      record.acked = true;
+      for (let k = 0; k < record.netIds.length; k++) {
+        const known = peer.known.get(record.netIds.at(k));
+        if (!known) continue;
+        const c = record.comps.at(k);
+        const t = record.ticks.at(k);
+        if (t > known.acked[c]) known.acked[c] = t;
+      }
+    }
+  }
+  command(peer, r, tick) {
+    const seq = r.varuint();
+    const index = r.varuint();
+    const def = this.config.manifest.commands[index];
+    peer.stats.commands++;
+    const answer = (cmd2) => this.answer(cmd2);
+    if (!def) {
+      const cmd2 = new ServerCommand(unknownDef, peer.id, seq, {}, tick, answer);
+      cmd2.reject("net/unknown-command", `Command #${index} isn't in the server's manifest`);
+      return;
+    }
+    const now = this.config.now();
+    const rate = this.config.commandsPerSecond;
+    peer.tokens = Math.min(rate, peer.tokens + (now - peer.lastRefill) / 1e3 * rate);
+    peer.lastRefill = now;
+    const data = this.commandCodecs[index].decode(r);
+    const cmd = new ServerCommand(def, peer.id, seq, data ?? {}, tick, answer);
+    this.remember(cmd);
+    if (peer.tokens < 1) {
+      cmd.reject("net/command-rate", `Over ${rate} commands per second`);
+      return;
+    }
+    peer.tokens--;
+    if (data === void 0) {
+      cmd.reject("net/unknown-net-id", "The command names an entity you do not have");
+      return;
+    }
+    const errors = def.schema.validate(def.schema.serialize(data));
+    if (errors.length > 0) {
+      const e = errors[0];
+      cmd.reject(e.code, e.message, e.hint);
+      return;
+    }
+    this.commands.push(cmd);
+  }
+  remember(cmd) {
+    this.recentCommands.push(cmd);
+    if (this.recentCommands.length > 64) this.recentCommands.shift();
+  }
+  /** Delivers a command from the server's own world (single-player, or a host's local player). */
+  local(def, data, onAnswer) {
+    const tick = this.world.resource(FixedTime).tick;
+    const cmd = new ServerCommand(def, 0, 0, data, tick, onAnswer);
+    const errors = def.schema.validate(def.schema.serialize(data));
+    this.remember(cmd);
+    if (errors.length > 0) cmd.reject(errors[0].code, errors[0].message, errors[0].hint);
+    else this.commands.push(cmd);
+    return cmd;
+  }
+  answer(cmd) {
+    if (cmd.peer === 0) return;
+    const peer = this.peers.get(cmd.peer);
+    if (cmd.status === "rejected") {
+      if (peer) peer.stats.rejected++;
+    }
+    peer?.answers.push({ seq: cmd.seq, error: cmd.error });
+  }
+  /** Commands of one type still waiting for an answer. */
+  pending(def) {
+    const out = [];
+    for (const cmd of this.commands) if (cmd.def === def && cmd.status === "pending") out.push(cmd);
+    return out;
+  }
+  // --- events --------------------------------------------------------------
+  sendEvent(def, data, to) {
+    const index = this.eventIndex.get(def.name);
+    if (index === void 0) {
+      throw new ShardError("net/unknown-event", `${def.name} isn't in netPlugin({ events })`, {
+        hint: "List every net event in the plugin options on both sides."
+      });
+    }
+    this.events.push({ index, data, to });
+    const tick = this.world.resource(FixedTime).tick;
+    this.recentEvents.push({
+      name: def.name,
+      tick,
+      to: typeof to === "function" ? "filter" : String(to)
+    });
+    if (this.recentEvents.length > 64) this.recentEvents.shift();
+    this.world.send(def.event, { data, tick });
+  }
+  commandIndexOf(def) {
+    return this.commandIndex.get(def.name);
+  }
+  // --- sending -------------------------------------------------------------
+  /** Runs in Last: answers unhandled commands, and on network ticks sends state to every peer. */
+  send() {
+    const world = this.world;
+    const fixed = world.resource(FixedTime);
+    for (const cmd of this.commands) {
+      if (cmd.status === "pending" && fixed.tick > cmd.arrivedTick) {
+        cmd.reject("net/unhandled-command", `No system handled ${cmd.def.name}`);
+      }
+    }
+    if (this.commands.length > 0) {
+      let n = 0;
+      for (const cmd of this.commands) if (cmd.status === "pending") this.commands[n++] = cmd;
+      this.commands.length = n;
+    }
+    const netTick = Math.floor(fixed.tick / this.config.ticksPerNet);
+    if (netTick === this.lastNetTick) return;
+    this.lastNetTick = netTick;
+    world.resource(NetRole).tick = fixed.tick;
+    this.assignIds();
+    this.collectFocus();
+    this.config.interest.prepare?.(world);
+    for (let p = 0; p < this.peerList.length; p++) {
+      const peer = this.peerList[p];
+      if (peer.info.state !== "connected" || peer.closed) continue;
+      this.current = peer;
+      this.sendTo(peer, fixed.tick);
+      this.current = void 0;
+    }
+    this.events.length = 0;
+  }
+  assignIds() {
+    const list = this.newEntities;
+    list.length = 0;
+    for (const table of this.unassigned.tables) {
+      for (let row = 0; row < table.count; row++) list.push(table.entities[row]);
+    }
+    for (const e of list) {
+      const id = this.nextNetId++;
+      this.world.add(e, NetId, { id });
+      this.byNetId.set(id, e);
+    }
+  }
+  collectFocus() {
+    for (let p = 0; p < this.peerList.length; p++) this.peerList[p].focus.length = 0;
+    for (const table of this.replicatedQuery.tables) {
+      const owner = table.column(Replicated, "owner");
+      for (let row = 0; row < table.count; row++) {
+        if (owner[row] !== 0) this.peers.get(owner[row])?.focus.push(table.entities[row]);
+      }
+    }
+    for (const table of this.focusQuery.tables) {
+      const peerId = table.column(Focus, "peer");
+      for (let row = 0; row < table.count; row++) {
+        this.peers.get(peerId[row])?.focus.push(table.entities[row]);
+      }
+    }
+  }
+  keepRelevant = (e) => {
+    const world = this.world;
+    if (!world.isAlive(e) || !world.has(e, NetId)) return false;
+    if (!world.has(e, ChildOf)) return true;
+    const parent = world.entityTable(e).column(ChildOf, "parent")[world.entityRow(e)];
+    return parent < 0 || !world.isAlive(parent) || !world.has(parent, Replicated) || this.current.relevant.has(parent);
+  };
+  relevance(peer) {
+    const world = this.world;
+    const set = peer.previous;
+    peer.previous = peer.relevant;
+    peer.relevant = set;
+    set.clear();
+    this.config.interest.update(world, peer, set);
+    for (const table of this.relevanceQuery.tables) {
+      const always = table.column(Relevance, "always");
+      for (let row = 0; row < table.count; row++) {
+        if (always[row] === 1) set.add(table.entities[row]);
+      }
+    }
+    for (let pass = 0; pass < 8; pass++) {
+      const before = set.size;
+      set.retain(this.keepRelevant);
+      if (set.size === before) break;
+    }
+  }
+  sendTo(peer, tick) {
+    const world = this.world;
+    const config = this.config;
+    const comps = config.manifest.components;
+    this.relevance(peer);
+    this.spawns.reset();
+    this.sets.reset();
+    this.removes.reset();
+    this.despawns.reset();
+    let spawnCount = 0;
+    let setCount = 0;
+    let removeCount = 0;
+    this.despawnCount = 0;
+    peer.known.forEach(this.despawnKnown);
+    const despawnCount = this.despawnCount;
+    const resendAfter = Math.max(
+      config.ticksPerNet * 2,
+      Math.ceil(peer.info.rtt / 1e3 * (1 / world.resource(FixedTime).step)) + config.ticksPerNet
+    );
+    const candidates = this.candidates;
+    const scores = this.scores;
+    candidates.clear();
+    scores.clear();
+    const relevant = peer.relevant;
+    for (let i = 0; i < relevant.size; i++) {
+      const e = relevant.at(i);
+      const table = world.entityTable(e);
+      const row = world.entityRow(e);
+      const netId = table.column(NetId, "id")[row];
+      const known = peer.known.get(netId);
+      const priority = table.has(Relevance) ? table.column(Relevance, "priority")[row] : 1;
+      if (!known) {
+        candidates.push(i);
+        scores.push(priority * 1e6);
+        continue;
+      }
+      let due = false;
+      for (let c = 0; c < comps.length; c++) {
+        const entry = comps[c];
+        const has = table.has(entry.def);
+        const visible = has && (!entry.visibleTo || entry.visibleTo(world, peer.id, e));
+        if (!visible) {
+          if (known.present[c]) {
+            this.removes.varuint(netId);
+            this.removes.varuint(c);
+            removeCount++;
+            known.present[c] = 0;
+            known.sent[c] = 0;
+            known.acked[c] = 0;
+          }
+          continue;
+        }
+        const changed = table.changedTicks(entry.def)[row];
+        if (changed <= known.acked[c] && known.present[c]) continue;
+        if (changed > known.sent[c] || !known.present[c] || tick - known.sentAt[c] >= resendAfter) {
+          due = true;
+        }
+      }
+      if (due) {
+        candidates.push(i);
+        scores.push(priority * (tick - known.lastSent + 1));
+      }
+    }
+    const count = candidates.length;
+    if (this.order.length < count) this.order = new Uint32Array(count * 2);
+    const order = this.order;
+    for (let i = 0; i < count; i++) order[i] = i;
+    if (Number.isFinite(config.bytesPerTick)) {
+      const s = scores.data;
+      order.subarray(0, count).sort((a, b) => s[b] - s[a]);
+    }
+    const state = this.state;
+    header(state, Msg.state, tick);
+    const seq = peer.nextSeq;
+    state.u32(seq);
+    const countAt = state.length;
+    state.u32(0);
+    let stateEntries = 0;
+    const record = peer.packets[seq % PACKET_RING];
+    record.netIds.clear();
+    record.comps.clear();
+    record.ticks.clear();
+    const stateLimit = config.maxMessage - 64;
+    let bytes = 0;
+    let deferred = 0;
+    for (let k = 0; k < count; k++) {
+      if (bytes >= config.bytesPerTick || state.length >= stateLimit) {
+        deferred = count - k;
+        break;
+      }
+      const e = relevant.at(candidates.at(order[k]));
+      const table = world.entityTable(e);
+      const row = world.entityRow(e);
+      const netId = table.column(NetId, "id")[row];
+      let known = peer.known.get(netId);
+      const startBytes = this.spawns.length + this.sets.length + state.length;
+      if (!known) {
+        known = makeKnown(netId, e, comps.length);
+        peer.known.set(netId, known);
+        this.spawns.varuint(netId);
+        const prefab = table.column(Replicated, "prefab")[row];
+        this.spawns.string(prefab ?? "");
+        spawnCount++;
+      }
+      for (let c = 0; c < comps.length; c++) {
+        const entry = comps[c];
+        if (!table.has(entry.def)) continue;
+        if (entry.visibleTo && !entry.visibleTo(world, peer.id, e)) continue;
+        const changed = table.changedTicks(entry.def)[row];
+        const present = known.present[c] === 1;
+        if (present && changed <= known.acked[c]) continue;
+        const resend = present && changed <= known.sent[c];
+        if (resend && tick - known.sentAt[c] < resendAfter) continue;
+        let toReliable = !present || entry.channel === "reliable";
+        let w = toReliable ? this.sets : state;
+        let before = w.length;
+        w.varuint(netId);
+        w.varuint(c);
+        this.pendingRef = false;
+        this.codecs[c].encodeRow(table, row, w);
+        if (!toReliable && w.length > config.maxMessage) {
+          state.length = before;
+          toReliable = true;
+          w = this.sets;
+          before = w.length;
+          w.varuint(netId);
+          w.varuint(c);
+          this.pendingRef = false;
+          this.codecs[c].encodeRow(table, row, w);
+        }
+        const size = w.length - before;
+        peer.stats.bytesByComponent[entry.def.name] = (peer.stats.bytesByComponent[entry.def.name] ?? 0) + size;
+        if (resend) peer.stats.resends++;
+        known.present[c] = 1;
+        known.sentAt[c] = tick;
+        if (toReliable) {
+          setCount++;
+          known.sent[c] = changed;
+          known.acked[c] = this.pendingRef ? 0 : changed;
+        } else {
+          stateEntries++;
+          known.sent[c] = changed;
+          if (this.pendingRef) known.acked[c] = 0;
+          record.netIds.push(netId);
+          record.comps.push(c);
+          record.ticks.push(this.pendingRef ? 0 : changed);
+        }
+      }
+      known.lastSent = tick;
+      bytes += this.spawns.length + this.sets.length + state.length - startBytes;
+    }
+    peer.stats.deferred = deferred;
+    const tail = this.tail;
+    tail.reset();
+    let tailSections = 0;
+    if (peer.answers.length > 0) {
+      tail.u8(Section.answer);
+      tail.varuint(peer.answers.length);
+      for (const a of peer.answers) {
+        tail.varuint(a.seq);
+        tail.string(a.error?.code ?? "");
+        tail.string(a.error?.message ?? "");
+        tail.string(a.error?.hint ?? "");
+      }
+      peer.answers.length = 0;
+      tailSections++;
+    }
+    let eventCount = 0;
+    for (const ev of this.events) if (isRecipient(ev.to, peer.id)) eventCount++;
+    if (eventCount > 0) {
+      tail.u8(Section.event);
+      tail.varuint(eventCount);
+      for (const ev of this.events) {
+        if (!isRecipient(ev.to, peer.id)) continue;
+        tail.varuint(ev.index);
+        this.eventCodecs[ev.index].encode(ev.data, tail);
+      }
+      tailSections++;
+    }
+    if (spawnCount + setCount + removeCount + despawnCount + tailSections > 0) {
+      const out = this.out;
+      header(out, Msg.reliable, tick);
+      if (spawnCount > 0) section(out, Section.spawn, spawnCount, this.spawns);
+      if (setCount > 0) section(out, Section.set, setCount, this.sets);
+      if (removeCount > 0) section(out, Section.remove, removeCount, this.removes);
+      if (despawnCount > 0) section(out, Section.despawn, despawnCount, this.despawns);
+      out.bytes(tail.finish());
+      out.u8(Section.end);
+      peer.stats.bytesSent += out.length;
+      peer.fragmenter.send(peer.connection, "reliable", out.finish(), config.maxMessage);
+    }
+    if (stateEntries > 0) {
+      state.patchU32(countAt, stateEntries);
+      record.seq = seq;
+      record.acked = false;
+      peer.nextSeq++;
+      peer.stats.bytesSent += state.length;
+      peer.connection.send("unreliable", state.finish());
+    }
+  }
+  /** Describes one entity for `net.inspect`. */
+  inspect(entity) {
+    const world = this.world;
+    const replicated = world.tryGet(entity, Replicated);
+    const netId = readNetId(world, entity);
+    const peers = {};
+    for (const peer of this.peers.values()) {
+      const known = netId === void 0 ? void 0 : peer.known.get(netId);
+      const redacted = [];
+      for (const entry of this.config.manifest.components) {
+        if (world.has(entity, entry.def) && entry.visibleTo && !entry.visibleTo(world, peer.id, entity)) {
+          redacted.push(entry.def.name);
+        }
+      }
+      peers[String(peer.id)] = {
+        relevant: peer.relevant.has(entity),
+        known: known !== void 0,
+        redacted,
+        lastSentTick: known?.lastSent ?? null
+      };
+    }
+    return {
+      netId: netId ?? null,
+      owner: replicated?.owner ?? null,
+      prefab: replicated?.prefab ?? null,
+      peers
+    };
+  }
+}
+const unknownDef = { kind: "net-command", name: "net/Unknown" };
+function outcome(peer, result) {
+  if (result instanceof ShardError) return { peer, error: result };
+  return { peer, user: result?.user };
+}
+function isPromise(value) {
+  return typeof value?.then === "function";
+}
+function failure(err, code) {
+  if (err instanceof ShardError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new ShardError(code, message, { cause: err });
+}
+const onRemoveNetId = onRemove(NetId);
+function readNetId(world, entity) {
+  if (!world.isAlive(entity) || !world.has(entity, NetId)) return void 0;
+  return world.entityTable(entity).column(NetId, "id")[world.entityRow(entity)];
+}
+function makeKnown(netId, entity, count) {
+  return {
+    netId,
+    entity,
+    present: new Uint8Array(count),
+    sent: new Uint32Array(count),
+    acked: new Uint32Array(count),
+    sentAt: new Float64Array(count),
+    lastSent: 0
+  };
+}
+function section(out, kind, count, body) {
+  out.u8(kind);
+  out.varuint(count);
+  out.bytes(body.finish());
+}
+function isRecipient(to, peer) {
+  if (to === "all") return true;
+  if (typeof to === "number") return to === peer;
+  return to(peer);
+}
+export {
+  NetServer,
+  ServerCommand
+};