@relu-interactives/spatial-ecs 0.5.3 → 0.9.0

package/dist/network/index.d.cts

@@ -0,0 +1,98 @@
+import { y as NetworkTransport, z as NetEntityView, A as NetPose, B as EcsSystem, F as NetworkService, W as World, G as EntityId, H as NetworkHandle } from '../System-8D-XBDKZ.cjs';
+export { J as NetSpawnOptions } from '../System-8D-XBDKZ.cjs';
+import 'three';
+import '@dimforge/rapier3d-compat';
+import '../animation/index.cjs';
+import 'three/webgpu';
+
+/** A shared world in a Colyseus room running `ReluRoom`. */
+declare class ColyseusTransport implements NetworkTransport {
+    private readonly room;
+    private constructor();
+    static connect(options: {
+        endpoint: string;
+        room: string;
+        join?: Record<string, unknown>;
+    }): Promise<ColyseusTransport>;
+    get sessionId(): string;
+    get host(): string;
+    get players(): string[];
+    private get $();
+    onEntityAdd(cb: (entity: NetEntityView) => void): void;
+    onEntityChange(cb: (entity: NetEntityView) => void): void;
+    onEntityRemove(cb: (id: string) => void): void;
+    onPlayerJoin(cb: (id: string) => void): void;
+    onPlayerLeave(cb: (id: string) => void): void;
+    onMessage(cb: (name: string, payload: unknown, from: string) => void): void;
+    onCorrect(cb: (id: string, pose: NetPose) => void): void;
+    onClose(cb: () => void): void;
+    registerScene(entities: Parameters<NetworkTransport["registerScene"]>[0]): void;
+    spawn(request: Parameters<NetworkTransport["spawn"]>[0]): void;
+    despawn(id: string): void;
+    sendPose(id: string, pose: NetPose): void;
+    setProp(id: string, key: string, json: string): void;
+    send(name: string, payload: unknown): void;
+    leave(): void;
+}
+
+/**
+ * A transport with a bad connection: everything takes `ms` longer round trip.
+ * For testing a game at a real player's latency on a local server.
+ */
+declare function withLatency(transport: NetworkTransport, ms: number): NetworkTransport;
+
+/**
+ * Keeps a world in step with a shared room: spawns what others spawned, sends
+ * what this client owns, and plays back what it doesn't. Add it to
+ * `world.setup({ systems })` after the script systems, then call `connect`
+ * once the scene is hydrated.
+ *
+ * @category Systems
+ */
+declare class NetworkSystem implements EcsSystem, NetworkService {
+    private readonly now;
+    private world;
+    private transport;
+    private readonly tracked;
+    private readonly byEntity;
+    private readonly listeners;
+    private readonly handles;
+    private spawnedAvatar;
+    constructor(now?: () => number);
+    /** Join the shared world. Call after hydrating, so scene objects exist. */
+    connect(world: World, transport: NetworkTransport): void;
+    /** Scene objects: every client hydrates the same scene, so their ids already match. */
+    private registerScene;
+    private spawnAvatar;
+    private track;
+    /** The buffer needs the entity's own teleport setting, known once the entity exists. */
+    private bindEntity;
+    private entityAdded;
+    private entityChanged;
+    private entityRemoved;
+    private applyProps;
+    private corrected;
+    private disconnected;
+    /** Call a Behaviour hook: on one entity's scripts, or every script. */
+    private dispatch;
+    update(world: World): void;
+    dispose(): void;
+    private spawn;
+    handleFor(entityId: EntityId): NetworkHandle;
+}
+
+/**
+ * Plays a remote entity back slightly in the past, between the two updates
+ * around that moment. Packets arrive unevenly; a small delay turns that into
+ * smooth motion.
+ */
+declare class SnapshotBuffer {
+    private readonly teleportDistance;
+    private snapshots;
+    constructor(teleportDistance?: number);
+    push(at: number, pose: NetPose): void;
+    /** The pose at time `at`: holds the first and last, and never extrapolates. */
+    sample(at: number): NetPose | null;
+}
+
+export { ColyseusTransport, NetEntityView, NetPose, NetworkHandle, NetworkService, NetworkSystem, NetworkTransport, SnapshotBuffer, withLatency };

package/dist/network/index.d.ts

@@ -0,0 +1,98 @@
+import { G as NetworkTransport, H as NetEntityView, J as NetPose, K as EcsSystem, L as NetworkService, W as World, M as EntityId, O as NetworkHandle } from '../System-DPMAW30g.js';
+export { Q as NetSpawnOptions } from '../System-DPMAW30g.js';
+import 'three';
+import '@dimforge/rapier3d-compat';
+import '../animation/index.js';
+import 'three/webgpu';
+
+/** A shared world in a Colyseus room running `ReluRoom`. */
+declare class ColyseusTransport implements NetworkTransport {
+    private readonly room;
+    private constructor();
+    static connect(options: {
+        endpoint: string;
+        room: string;
+        join?: Record<string, unknown>;
+    }): Promise<ColyseusTransport>;
+    get sessionId(): string;
+    get host(): string;
+    get players(): string[];
+    private get $();
+    onEntityAdd(cb: (entity: NetEntityView) => void): void;
+    onEntityChange(cb: (entity: NetEntityView) => void): void;
+    onEntityRemove(cb: (id: string) => void): void;
+    onPlayerJoin(cb: (id: string) => void): void;
+    onPlayerLeave(cb: (id: string) => void): void;
+    onMessage(cb: (name: string, payload: unknown, from: string) => void): void;
+    onCorrect(cb: (id: string, pose: NetPose) => void): void;
+    onClose(cb: () => void): void;
+    registerScene(entities: Parameters<NetworkTransport["registerScene"]>[0]): void;
+    spawn(request: Parameters<NetworkTransport["spawn"]>[0]): void;
+    despawn(id: string): void;
+    sendPose(id: string, pose: NetPose): void;
+    setProp(id: string, key: string, json: string): void;
+    send(name: string, payload: unknown): void;
+    leave(): void;
+}
+
+/**
+ * A transport with a bad connection: everything takes `ms` longer round trip.
+ * For testing a game at a real player's latency on a local server.
+ */
+declare function withLatency(transport: NetworkTransport, ms: number): NetworkTransport;
+
+/**
+ * Keeps a world in step with a shared room: spawns what others spawned, sends
+ * what this client owns, and plays back what it doesn't. Add it to
+ * `world.setup({ systems })` after the script systems, then call `connect`
+ * once the scene is hydrated.
+ *
+ * @category Systems
+ */
+declare class NetworkSystem implements EcsSystem, NetworkService {
+    private readonly now;
+    private world;
+    private transport;
+    private readonly tracked;
+    private readonly byEntity;
+    private readonly listeners;
+    private readonly handles;
+    private spawnedAvatar;
+    constructor(now?: () => number);
+    /** Join the shared world. Call after hydrating, so scene objects exist. */
+    connect(world: World, transport: NetworkTransport): void;
+    /** Scene objects: every client hydrates the same scene, so their ids already match. */
+    private registerScene;
+    private spawnAvatar;
+    private track;
+    /** The buffer needs the entity's own teleport setting, known once the entity exists. */
+    private bindEntity;
+    private entityAdded;
+    private entityChanged;
+    private entityRemoved;
+    private applyProps;
+    private corrected;
+    private disconnected;
+    /** Call a Behaviour hook: on one entity's scripts, or every script. */
+    private dispatch;
+    update(world: World): void;
+    dispose(): void;
+    private spawn;
+    handleFor(entityId: EntityId): NetworkHandle;
+}
+
+/**
+ * Plays a remote entity back slightly in the past, between the two updates
+ * around that moment. Packets arrive unevenly; a small delay turns that into
+ * smooth motion.
+ */
+declare class SnapshotBuffer {
+    private readonly teleportDistance;
+    private snapshots;
+    constructor(teleportDistance?: number);
+    push(at: number, pose: NetPose): void;
+    /** The pose at time `at`: holds the first and last, and never extrapolates. */
+    sample(at: number): NetPose | null;
+}
+
+export { ColyseusTransport, NetEntityView, NetPose, NetworkHandle, NetworkService, NetworkSystem, NetworkTransport, SnapshotBuffer, withLatency };

package/dist/network/index.js

@@ -0,0 +1,493 @@
+import { spawnPrefab, despawnPrefab, Behaviour, reportBehaviourHookError } from '../chunk-WWP46AEF.js';
+import '../chunk-JEPUCLZX.js';
+import { NetworkIdentityComponent, TransformComponent, NetworkedPropsComponent, NetworkSpawnerComponent, NetworkTransformComponent, ScriptComponent } from '../chunk-JNYPJB55.js';
+import '../chunk-CKTHDXPS.js';
+import '../chunk-GSWC6LLD.js';
+import { __name } from '../chunk-XE4OXN2W.js';
+import { Client, Callbacks } from '@colyseus/sdk';
+import * as THREE from 'three';
+
+var view = /* @__PURE__ */ __name((e) => ({
+  id: e.id,
+  owner: e.owner,
+  prefab: e.prefab,
+  x: e.x,
+  y: e.y,
+  z: e.z,
+  qx: e.qx,
+  qy: e.qy,
+  qz: e.qz,
+  qw: e.qw,
+  props: Object.fromEntries(e.props.entries())
+}), "view");
+var _ColyseusTransport = class _ColyseusTransport {
+  constructor(room) {
+    this.room = room;
+  }
+  static async connect(options) {
+    const client = new Client(options.endpoint);
+    const room = await client.joinOrCreate(options.room, options.join ?? {});
+    return new _ColyseusTransport(room);
+  }
+  get sessionId() {
+    return this.room.sessionId;
+  }
+  get host() {
+    return this.room.state.host;
+  }
+  get players() {
+    return [...this.room.state.players.keys()];
+  }
+  get $() {
+    return Callbacks.get(this.room);
+  }
+  onEntityAdd(cb) {
+    this.$.onAdd("entities", (entity) => cb(view(entity)));
+  }
+  onEntityChange(cb) {
+    const $ = this.$;
+    $.onAdd("entities", (entity) => {
+      $.onChange(entity, () => cb(view(entity)));
+      $.onChange(entity, "props", () => cb(view(entity)));
+    });
+  }
+  onEntityRemove(cb) {
+    this.$.onRemove("entities", (_entity, id) => cb(id));
+  }
+  onPlayerJoin(cb) {
+    this.$.onAdd("players", (_player, id) => cb(id));
+  }
+  onPlayerLeave(cb) {
+    this.$.onRemove("players", (_player, id) => cb(id));
+  }
+  onMessage(cb) {
+    this.room.onMessage(
+      "m",
+      (m) => cb(m.name, m.payload, m.from)
+    );
+  }
+  onCorrect(cb) {
+    this.room.onMessage("correct", (m) => cb(m.id, m));
+  }
+  onClose(cb) {
+    this.room.onLeave(() => cb());
+  }
+  registerScene(entities) {
+    this.room.send("scene", entities);
+  }
+  spawn(request) {
+    this.room.send("spawn", request);
+  }
+  despawn(id) {
+    this.room.send("despawn", { id });
+  }
+  sendPose(id, pose) {
+    this.room.send("pose", { id, ...pose });
+  }
+  setProp(id, key, json) {
+    this.room.send("prop", { id, key, json });
+  }
+  send(name, payload) {
+    this.room.send("m", { name, payload });
+  }
+  leave() {
+    void this.room.leave();
+  }
+};
+__name(_ColyseusTransport, "ColyseusTransport");
+var ColyseusTransport = _ColyseusTransport;
+
+// core/network/latency.ts
+function withLatency(transport, ms) {
+  if (ms <= 0) return transport;
+  const oneWay = ms / 2;
+  return new Proxy(transport, {
+    get(target, key) {
+      const value = Reflect.get(target, key);
+      if (typeof value !== "function") return value;
+      const name = String(key);
+      const fn = value;
+      if (name === "leave") return fn.bind(target);
+      if (name.startsWith("on")) {
+        return (cb) => fn.call(target, (...args) => {
+          setTimeout(() => cb(...args), oneWay);
+        });
+      }
+      return (...args) => {
+        setTimeout(() => fn.apply(target, args), oneWay);
+      };
+    }
+  });
+}
+__name(withLatency, "withLatency");
+
+// core/network/snapshotBuffer.ts
+var MAX_SNAPSHOTS = 32;
+function lerpPose(a, b, t) {
+  const dot = a.qx * b.qx + a.qy * b.qy + a.qz * b.qz + a.qw * b.qw;
+  const s = dot < 0 ? -1 : 1;
+  const qx = a.qx + (s * b.qx - a.qx) * t;
+  const qy = a.qy + (s * b.qy - a.qy) * t;
+  const qz = a.qz + (s * b.qz - a.qz) * t;
+  const qw = a.qw + (s * b.qw - a.qw) * t;
+  const len = Math.hypot(qx, qy, qz, qw) || 1;
+  return {
+    x: a.x + (b.x - a.x) * t,
+    y: a.y + (b.y - a.y) * t,
+    z: a.z + (b.z - a.z) * t,
+    qx: qx / len,
+    qy: qy / len,
+    qz: qz / len,
+    qw: qw / len
+  };
+}
+__name(lerpPose, "lerpPose");
+var _SnapshotBuffer = class _SnapshotBuffer {
+  constructor(teleportDistance = Number.POSITIVE_INFINITY) {
+    this.teleportDistance = teleportDistance;
+    this.snapshots = [];
+  }
+  push(at, pose) {
+    this.snapshots.push({ at, pose });
+    if (this.snapshots.length > MAX_SNAPSHOTS) this.snapshots.shift();
+  }
+  /** The pose at time `at`: holds the first and last, and never extrapolates. */
+  sample(at) {
+    const list = this.snapshots;
+    if (list.length === 0) return null;
+    if (at <= list[0].at) return list[0].pose;
+    for (let i = list.length - 1; i > 0; i--) {
+      const a = list[i - 1];
+      const b = list[i];
+      if (at < a.at) continue;
+      if (i > 1) this.snapshots = list.slice(i - 1);
+      if (at >= b.at) return b.pose;
+      const jump = Math.hypot(b.pose.x - a.pose.x, b.pose.y - a.pose.y, b.pose.z - a.pose.z);
+      if (jump > this.teleportDistance) return b.pose;
+      return lerpPose(a.pose, b.pose, (at - a.at) / (b.at - a.at));
+    }
+    return list[list.length - 1].pose;
+  }
+};
+__name(_SnapshotBuffer, "SnapshotBuffer");
+var SnapshotBuffer = _SnapshotBuffer;
+
+// core/network/NetworkSystem.ts
+var POSITION_EPSILON = 1e-3;
+var ROTATION_EPSILON = 5e-4;
+var euler = new THREE.Euler();
+var quat = new THREE.Quaternion();
+function poseOf(transform) {
+  const { position: p, rotation: r } = transform;
+  quat.setFromEuler(euler.set(r.x, r.y, r.z));
+  return { x: p.x, y: p.y, z: p.z, qx: quat.x, qy: quat.y, qz: quat.z, qw: quat.w };
+}
+__name(poseOf, "poseOf");
+function applyPose(transform, pose, rotation) {
+  transform.position.x = pose.x;
+  transform.position.y = pose.y;
+  transform.position.z = pose.z;
+  if (!rotation) return;
+  euler.setFromQuaternion(quat.set(pose.qx, pose.qy, pose.qz, pose.qw));
+  transform.rotation.x = euler.x;
+  transform.rotation.y = euler.y;
+  transform.rotation.z = euler.z;
+}
+__name(applyPose, "applyPose");
+var moved = /* @__PURE__ */ __name((a, b) => Math.abs(a.x - b.x) > POSITION_EPSILON || Math.abs(a.y - b.y) > POSITION_EPSILON || Math.abs(a.z - b.z) > POSITION_EPSILON || Math.abs(a.qx - b.qx) > ROTATION_EPSILON || Math.abs(a.qy - b.qy) > ROTATION_EPSILON || Math.abs(a.qz - b.qz) > ROTATION_EPSILON || Math.abs(a.qw - b.qw) > ROTATION_EPSILON, "moved");
+function encodeProps(props) {
+  return Object.fromEntries(
+    Object.entries(props ?? {}).map(([k, v]) => [k, JSON.stringify(v)])
+  );
+}
+__name(encodeProps, "encodeProps");
+var _NetworkSystem = class _NetworkSystem {
+  constructor(now = () => performance.now()) {
+    this.now = now;
+    this.world = null;
+    this.transport = null;
+    this.tracked = /* @__PURE__ */ new Map();
+    this.byEntity = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.handles = /* @__PURE__ */ new Map();
+    this.spawnedAvatar = false;
+  }
+  /** Join the shared world. Call after hydrating, so scene objects exist. */
+  connect(world, transport) {
+    this.world = world;
+    this.transport = transport;
+    world.setNetwork(this);
+    transport.onEntityAdd((e) => this.entityAdded(e));
+    transport.onEntityChange((e) => this.entityChanged(e));
+    transport.onEntityRemove((id) => this.entityRemoved(id));
+    transport.onPlayerJoin((id) => this.dispatch("onPlayerJoin", id));
+    transport.onPlayerLeave((id) => this.dispatch("onPlayerLeave", id));
+    transport.onMessage((name, payload, from) => {
+      for (const fn of this.listeners.get(name) ?? []) fn(payload, from);
+    });
+    transport.onCorrect((id, pose) => this.corrected(id, pose));
+    transport.onClose(() => this.disconnected());
+    this.registerScene();
+    this.spawnAvatar();
+  }
+  /** Scene objects: every client hydrates the same scene, so their ids already match. */
+  registerScene() {
+    const world = this.world;
+    const transport = this.transport;
+    if (!world || !transport) return;
+    const entities = [];
+    for (const entityId of world.query(NetworkIdentityComponent)) {
+      const identity = world.getComponent(entityId, NetworkIdentityComponent);
+      if (!identity || identity.networkId) continue;
+      identity.networkId = `scene-${entityId}`;
+      const transform = world.getComponent(entityId, TransformComponent);
+      const props = world.getComponent(entityId, NetworkedPropsComponent);
+      const tracked = this.track(identity.networkId, entityId, "", null);
+      tracked.props = encodeProps(props?.values);
+      entities.push({
+        id: identity.networkId,
+        props: tracked.props,
+        ...transform ? poseOf(transform) : { x: 0, y: 0, z: 0, qx: 0, qy: 0, qz: 0, qw: 1 }
+      });
+    }
+    if (entities.length) transport.registerScene(entities);
+  }
+  spawnAvatar() {
+    const world = this.world;
+    if (!world || this.spawnedAvatar) return;
+    const [entityId] = world.query(NetworkSpawnerComponent);
+    if (entityId === void 0) return;
+    const spawner = world.getComponent(entityId, NetworkSpawnerComponent);
+    if (!spawner?.playerPrefab) return;
+    this.spawnedAvatar = true;
+    const at = world.getComponent(entityId, TransformComponent)?.position;
+    const angle = Math.random() * Math.PI * 2;
+    this.spawn(spawner.playerPrefab, {
+      position: {
+        x: (at?.x ?? 0) + Math.cos(angle) * spawner.spawnRadius,
+        y: at?.y ?? 0,
+        z: (at?.z ?? 0) + Math.sin(angle) * spawner.spawnRadius
+      }
+    });
+  }
+  track(id, entityId, owner, view2) {
+    const entry = {
+      id,
+      entityId,
+      owner,
+      buffer: new SnapshotBuffer(),
+      sentAt: 0,
+      sent: null,
+      props: {}
+    };
+    if (view2) entry.buffer.push(this.now(), view2);
+    this.tracked.set(id, entry);
+    if (entityId !== null) this.byEntity.set(entityId, entry);
+    return entry;
+  }
+  /** The buffer needs the entity's own teleport setting, known once the entity exists. */
+  bindEntity(entry, entityId) {
+    const world = this.world;
+    if (!world) return;
+    entry.entityId = entityId;
+    this.byEntity.set(entityId, entry);
+    let identity = world.getComponent(entityId, NetworkIdentityComponent);
+    if (!identity) {
+      identity = new NetworkIdentityComponent();
+      world.addComponent(entityId, identity);
+    }
+    identity.networkId = entry.id;
+    identity.owner = entry.owner;
+    const settings = world.getComponent(entityId, NetworkTransformComponent);
+    entry.buffer = new SnapshotBuffer(settings?.teleportDistance);
+  }
+  entityAdded(view2) {
+    const existing = this.tracked.get(view2.id);
+    if (existing) {
+      this.entityChanged(view2);
+      return;
+    }
+    const entry = this.track(view2.id, null, view2.owner, view2);
+    if (!view2.prefab || !this.world) return;
+    euler.setFromQuaternion(quat.set(view2.qx, view2.qy, view2.qz, view2.qw));
+    void spawnPrefab(this.world, view2.prefab, {
+      position: { x: view2.x, y: view2.y, z: view2.z },
+      rotation: { x: euler.x, y: euler.y, z: euler.z }
+    }).then((entityId) => {
+      if (this.tracked.get(view2.id) !== entry) {
+        if (this.world) despawnPrefab(this.world, entityId);
+        return;
+      }
+      this.bindEntity(entry, entityId);
+      entry.buffer.push(this.now(), view2);
+      this.applyProps(entry, view2.props);
+    });
+  }
+  entityChanged(view2) {
+    const entry = this.tracked.get(view2.id);
+    if (!entry) return;
+    entry.owner = view2.owner;
+    if (entry.entityId !== null && this.world) {
+      const identity = this.world.getComponent(entry.entityId, NetworkIdentityComponent);
+      if (identity) identity.owner = view2.owner;
+    }
+    if (view2.owner !== this.transport?.sessionId) entry.buffer.push(this.now(), view2);
+    this.applyProps(entry, view2.props);
+  }
+  entityRemoved(id) {
+    const entry = this.tracked.get(id);
+    if (!entry) return;
+    this.tracked.delete(id);
+    if (entry.entityId === null) return;
+    this.byEntity.delete(entry.entityId);
+    if (this.world) despawnPrefab(this.world, entry.entityId);
+  }
+  applyProps(entry, props) {
+    if (entry.entityId === null || !this.world) return;
+    for (const [key, json] of Object.entries(props)) {
+      if (entry.props[key] === json) continue;
+      entry.props[key] = json;
+      const value = JSON.parse(json);
+      let component = this.world.getComponent(entry.entityId, NetworkedPropsComponent);
+      if (!component) {
+        component = new NetworkedPropsComponent();
+        this.world.addComponent(entry.entityId, component);
+      }
+      component.values[key] = value;
+      this.dispatch("onNetworkProp", key, value, entry.entityId);
+    }
+  }
+  corrected(id, pose) {
+    const entry = this.tracked.get(id);
+    if (entry?.entityId == null || !this.world) return;
+    const transform = this.world.getComponent(entry.entityId, TransformComponent);
+    if (transform) applyPose(transform, pose, true);
+    entry.sent = pose;
+  }
+  disconnected() {
+    this.transport = null;
+    this.world?.setNetwork(null);
+  }
+  dispatch(hook, a, b, on) {
+    const world = this.world;
+    if (!world) return;
+    const ids = on !== void 0 ? [on] : world.query(ScriptComponent);
+    for (const entityId of ids) {
+      const instances = world.getComponent(entityId, ScriptComponent)?.scriptInstances;
+      for (const instance of instances?.values() ?? []) {
+        if (!(instance instanceof Behaviour)) continue;
+        try {
+          instance[hook]?.(a, b);
+        } catch (error) {
+          reportBehaviourHookError(world, entityId, instance, hook, error);
+        }
+      }
+    }
+  }
+  update(world) {
+    const transport = this.transport;
+    if (!transport) return;
+    const now = this.now();
+    for (const entry of this.tracked.values()) {
+      if (entry.entityId === null) continue;
+      const settings = world.getComponent(entry.entityId, NetworkTransformComponent);
+      if (!settings?.enabled) continue;
+      const transform = world.getComponent(entry.entityId, TransformComponent);
+      if (!transform) continue;
+      if (entry.owner === transport.sessionId) {
+        if (now - entry.sentAt < 1e3 / settings.sendRate) continue;
+        const pose = poseOf(transform);
+        if (entry.sent && !moved(entry.sent, pose)) continue;
+        entry.sentAt = now;
+        entry.sent = pose;
+        transport.sendPose(entry.id, pose);
+      } else {
+        const pose = entry.buffer.sample(now - settings.interpolationMs);
+        if (pose) applyPose(transform, pose, settings.syncRotation);
+      }
+    }
+  }
+  dispose() {
+    this.transport?.leave();
+    this.transport = null;
+    this.world?.setNetwork(null);
+    this.tracked.clear();
+    this.byEntity.clear();
+    this.handles.clear();
+    this.listeners.clear();
+  }
+  spawn(prefab, options = {}) {
+    const p = options.position;
+    const r = options.rotation;
+    quat.setFromEuler(euler.set(r?.x ?? 0, r?.y ?? 0, r?.z ?? 0));
+    this.transport?.spawn({
+      prefab: typeof prefab === "string" ? prefab : prefab.path,
+      props: encodeProps(options.props),
+      x: p?.x ?? 0,
+      y: p?.y ?? 0,
+      z: p?.z ?? 0,
+      qx: quat.x,
+      qy: quat.y,
+      qz: quat.z,
+      qw: quat.w
+    });
+  }
+  handleFor(entityId) {
+    const known = this.handles.get(entityId);
+    if (known) return known;
+    const self = this;
+    const entry = /* @__PURE__ */ __name(() => self.byEntity.get(entityId), "entry");
+    const handle = {
+      get connected() {
+        return self.transport !== null;
+      },
+      get sessionId() {
+        return self.transport?.sessionId ?? "";
+      },
+      get isHost() {
+        const t = self.transport;
+        return Boolean(t) && t?.host === t?.sessionId;
+      },
+      get isOwner() {
+        return entry()?.owner === self.transport?.sessionId;
+      },
+      get players() {
+        return self.transport?.players ?? [];
+      },
+      send: /* @__PURE__ */ __name((name, payload) => self.transport?.send(name, payload ?? null), "send"),
+      onMessage: /* @__PURE__ */ __name((name, fn) => {
+        const set = self.listeners.get(name) ?? /* @__PURE__ */ new Set();
+        self.listeners.set(name, set);
+        set.add(fn);
+        return () => set.delete(fn);
+      }, "onMessage"),
+      spawn: /* @__PURE__ */ __name((prefab, options) => self.spawn(prefab, options), "spawn"),
+      despawn: /* @__PURE__ */ __name((id = entityId) => {
+        const target = self.byEntity.get(id);
+        if (target) self.transport?.despawn(target.id);
+      }, "despawn"),
+      setProp: /* @__PURE__ */ __name((key, value) => {
+        const target = entry();
+        if (!target || target.entityId === null || !self.world) return;
+        const json = JSON.stringify(value);
+        target.props[key] = json;
+        let component = self.world.getComponent(target.entityId, NetworkedPropsComponent);
+        if (!component) {
+          component = new NetworkedPropsComponent();
+          self.world.addComponent(target.entityId, component);
+        }
+        component.values[key] = value;
+        self.transport?.setProp(target.id, key, json);
+      }, "setProp"),
+      getProp: /* @__PURE__ */ __name((key) => self.world?.getComponent(entityId, NetworkedPropsComponent)?.values[key], "getProp")
+    };
+    this.handles.set(entityId, handle);
+    return handle;
+  }
+};
+__name(_NetworkSystem, "NetworkSystem");
+var NetworkSystem = _NetworkSystem;
+
+export { ColyseusTransport, NetworkSystem, SnapshotBuffer, withLatency };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map