@genex-ai/multiplayer 0.2.2 → 0.4.0

package/README.md

@@ -57,6 +57,42 @@ room.shared.get('round');   // 3
 room.shared.keys();         // ['round', ...]
 ```
 
+## `objects` — shared objects nobody owns until claimed
+
+For a **ball, a puck, an NPC** — a moving thing that isn't any one player. Exactly one client
+**owns** an object at a time (the server enforces it); the owner simulates it and `set`s it, and
+everyone else reads it **auto-smoothed**, on the same interpolation as remote players. Ownership
+survives the owner leaving — the object is reassigned to the room host.
+
+```ts
+if (iKicked) room.objects.claim('ball');           // take ownership (last claim wins)
+
+if (room.objects.get('ball')?.isMine) {
+  room.objects.set('ball', simulateBall());        // only the owner's writes land
+}
+const ball = room.objects.get('ball');             // { owner, isMine, state, stateRaw }
+drawBall(ball.state);                              // smoothed for everyone (live for the owner)
+
+room.objects.release('ball');                      // give it up (stays until reclaimed)
+room.objects.remove('bullet');                     // destroy transient objects when done
+```
+
+Keep object state **flat** (top-level numbers + a 4-number quaternion) so it smooths, same as a
+player. `state` is smoothed; `stateRaw` is the raw latest (hit-tests). `objects.ids()` lists them.
+
+## `isHost` / `host` — the elected room authority
+
+One client is the **host** (the first joiner still present, re-elected automatically when they
+leave). Use it to pick a single writer for scores/rounds or a single simulator for NPCs.
+
+```ts
+if (room.isHost) room.shared.set('round', nextRound);   // only the host advances the round
+room.on('host', (id) => {});                             // host changed (migration)
+```
+
+`isHost`/`host` settle within the first patch after `connect()` — read them in your loop (or react
+to `on('host')`), not once at startup.
+
 ## `on` — events
 
 ```ts
@@ -64,6 +100,8 @@ room.on('join',   (id, state) => {});  // a player appeared (also fires for YOU
 room.on('change', (id, state) => {});  // a player updated their me-state
 room.on('leave',  (id)        => {});  // a player left
 room.on('shared', (key, value) => {}); // a shared key changed
+room.on('object', (id)        => {});  // an object's owner changed (handoff)
+room.on('host',   (id)        => {});  // the room host changed
 room.on('hit',    (payload)   => {});  // a custom event someone sent (see `send`)
 ```
 
@@ -87,11 +125,13 @@ room.leave();
 
 ## Smoothing remote players
 
-Remote players are **smoothed automatically** — nothing to configure. `room.players` gives each remote player's `state` rendered slightly in the past and lerped between snapshots, so motion glides instead of teleporting between network updates (you send ~10–20Hz but render at 60). The delay **self-tunes to the live snapshot rate** (held ~2 snapshots back, the way Valve Source / Unity do it), so it works whether you send at 5Hz or 30Hz.
+Remote players are **smoothed automatically** — nothing to configure. `room.players` gives each remote player's `state` rendered slightly in the past and interpolated between snapshots, so motion glides between network updates (you send ~10–20Hz but render at 60). Interpolation runs on the **sender's clock** (each update is timestamped and mapped to your local clock), the way Valve/Unity/Mirror do it — so jitter doesn't distort the motion. The delay **self-tunes to the live snapshot rate**, so it works whether you send at 5Hz or 30Hz.
 
 - `player.state` is the **smoothed** value (what you draw); `player.stateRaw` is the **latest raw** snapshot — use it for hit-tests / discrete logic.
 - **Your own player is never delayed** — you always render yourself live.
-- Only **numeric** top-level fields are lerped; everything else snaps.
+- **Numbers** are interpolated; a 4-element `[x, y, z, w]` **quaternion** is **slerped** (shortest-arc); anything else snaps.
+- **Send rotation as a quaternion:** `state.q = mesh.quaternion.toArray()`, then on the remote `mesh.quaternion.fromArray(p.state.q)`. The package slerps it and **output-smooths** it so it glides through turns.
+- **Late/dropped packets keep moving:** **position** dead-reckons forward from its last velocity (capped ~0.25s, Source-style) until fresh snapshots arrive; **rotation** holds its last orientation rather than extrapolating (extrapolating a turn overshoots and snaps — Mirror/Unity interpolate rotation only). Both are output-smoothed, so the catch-up glides. This is what holds up on high-latency links.
 
 > No client-side prediction/reconciliation: in this relay you're authoritative over **yourself** (you render instantly, the server never corrects you), so there's nothing to predict — smoothing *remote* players is the piece that matters.
 
@@ -114,7 +154,7 @@ setInterval(() => room.me.set(me), 66);
 function frame() {
   for (const [id, p] of room.players) {
     const cube = cubeFor(id);                 // create-or-reuse a mesh per id
-    cube.position.set(p.state.x ?? 0, 0, p.state.z ?? 0);   // smoothed if interpolation:true, else snaps
+    cube.position.set(p.state.x ?? 0, 0, p.state.z ?? 0);   // auto-smoothed
   }
   requestAnimationFrame(frame);
 }
@@ -134,7 +174,7 @@ onKey('right', () => { me.x += 1; });
 - **`me` / `shared` are synced; everything else is local.** Movement input → mutate a local object → `me.set` it on the tick.
 - **Tick `me.set` at ~10–20Hz**, render at your own framerate. One `me.set` = one network message.
 - **`room` (game id) must be stable per game** — use the project slug. Same id = same room; different id = isolated.
-- **Smooth remote players** with `interpolation` (or read `stateRaw` and smooth yourself). No server-side prediction — you render yourself live.
+- **Remote players are smoothed automatically** — read `stateRaw` when you need the raw latest (hit-tests). No server-side prediction — you render yourself live.
 - `me.set` replaces your whole state object — send the full object each time, not a partial.
 
 ---

package/dist/index.d.ts

@@ -7,8 +7,20 @@ type ConnectOptions = {
     /** Game id — everyone who passes the same id shares a room; different ids are
      * fully isolated. Use your project slug (or any stable per-game string). */
     room: string;
-    /** Display name for this player (anonymous is fine). */
+    /** Display name for this player. The server prefers the verified identity's
+     * name (from `auth`) when present; this is the display fallback. */
     name?: string;
+    /**
+     * Verified-identity credential — REQUIRED to actually join: the relay
+     * rejects tokenless joins (there is no anonymous play). Pass
+     * `genexEmbed.getColyseusAuth()` AFTER `await genexEmbed.waitForAuth()`
+     * (from `@genex-ai/embed-sdk`), and read it fresh at every connect() call —
+     * never cache the object across reconnects (tokens rotate every ~10 min).
+     * NEVER log this value.
+     */
+    auth?: {
+        embedToken: string;
+    };
     /** Extra join options passed to the room. */
     options?: Record<string, unknown>;
 };
@@ -21,6 +33,19 @@ type PlayerView<TState> = {
     /** The latest raw snapshot (never smoothed/delayed) — use for hit-tests / logic. */
     stateRaw: TState;
 };
+/** A shared object (a ball, a puck, an NPC) owned by exactly one client at a time. */
+type ObjectView<TState> = {
+    id: string;
+    /** Session id of the current owner, or `undefined` if unowned. */
+    owner: string | undefined;
+    /** True if you own it (so you should simulate + `objects.set` it). */
+    isMine: boolean;
+    /** State to render — **auto-smoothed** like a remote player when someone else owns it;
+     * live (your last `set`) when it's yours. */
+    state: TState;
+    /** The latest raw snapshot (never smoothed/delayed) — for hit-tests / logic. */
+    stateRaw: TState;
+};
 type Session<TState extends Record<string, unknown>> = {
     /** Your own session id. */
     readonly id: string;
@@ -45,12 +70,41 @@ type Session<TState extends Record<string, unknown>> = {
         /** All shared keys currently set. */
         keys(): string[];
     };
+    /**
+     * Shared objects nobody owns until claimed — a ball, a puck, an NPC. Exactly one client
+     * owns an object at a time (server-enforced); the owner simulates it and `set`s it, and
+     * everyone else reads it **auto-smoothed**, on the same interpolation as remote players.
+     * Ownership survives an owner leaving: the object is reassigned to the room host.
+     */
+    readonly objects: {
+        /** Take ownership (last claim wins — call it when you kick/touch the object). */
+        claim(id: string): void;
+        /** Give up ownership (leaves the object unowned until someone claims it). */
+        release(id: string): void;
+        /** Destroy the object everywhere (owner-only) — use for transient objects (bullets, pickups). */
+        remove(id: string): void;
+        /** Publish the object's state — only takes effect while you own it. Full object each call. */
+        set(id: string, state: Record<string, unknown>): void;
+        /** Read an object, or `undefined` if it doesn't exist yet. */
+        get<T extends Record<string, unknown> = Record<string, unknown>>(id: string): ObjectView<T> | undefined;
+        /** Ids of every object seen so far. */
+        ids(): string[];
+    };
+    /** True if you are the elected room host (first joiner still present). Settles within the
+     * first state patch after connect — read it in your loop or react to `on('host')`, not once. */
+    readonly isHost: boolean;
+    /** Session id of the current room host, or `undefined` until the first host patch lands. */
+    readonly host: string | undefined;
     /** A player appeared/updated. **Also fires for you** on connect — filter `id === room.id`. */
     on(event: 'join' | 'change', cb: (id: string, state: TState) => void): () => void;
     /** A player left. */
     on(event: 'leave', cb: (id: string) => void): () => void;
-    /** A shared key changed (fires on first set; for live values just read `shared.get`). */
+    /** A shared key changed (reserved `__*` keys are hidden). For live values just read `shared.get`. */
     on(event: 'shared', cb: (key: string, value: unknown) => void): () => void;
+    /** An object's owner or state changed (fires with its id). */
+    on(event: 'object', cb: (id: string) => void): () => void;
+    /** The room host changed (fires with the new host's id, or `undefined`). */
+    on(event: 'host', cb: (host: string | undefined) => void): () => void;
     /** A custom event another client sent via `send(type, ...)`. */
     on(event: string & {}, cb: (payload: unknown) => void): () => void;
     /** Fire-and-forget event to all OTHER clients (not stored in state). */
@@ -75,4 +129,4 @@ type Session<TState extends Record<string, unknown>> = {
  */
 declare function connect<TState extends Record<string, unknown> = never>(opts: ConnectOptions): Promise<Session<TState>>;
 
-export { type ConnectOptions, type PlayerView, type Session, connect };
+export { type ConnectOptions, type ObjectView, type PlayerView, type Session, connect };

package/dist/index.js

@@ -1,17 +1,34 @@
 // src/index.ts
 import { Client, getStateCallbacks } from "colyseus.js";
 var RELAY_ROOM_TYPE = "play";
-var INTERP_RATIO = 2;
-var INTERP_MIN_MS = 60;
-var INTERP_MAX_MS = 400;
+var INTERP_RATIO = 1.5;
+var INTERP_MIN_MS = 50;
+var INTERP_MAX_MS = 300;
 var INTERP_EASE = 0.1;
-function parseObject(s) {
-  if (!s) return {};
+var MAX_EXTRAP_MS = 250;
+var CLOCK_WIN = 80;
+var SMOOTH_TAU_POS = 30;
+var SMOOTH_TAU_ROT = 70;
+var SEND_TIME_KEY = "__t";
+var RESERVED_PREFIX = "__";
+var OBJ_PREFIX = "__obj:";
+var HOST_KEY = "__host";
+var MP_PROTOCOL = 1;
+function parseData(s) {
+  if (!s) return { state: {} };
   try {
     const v = JSON.parse(s);
-    return v && typeof v === "object" ? v : {};
+    if (!v || typeof v !== "object") return { state: {} };
+    const o = v;
+    const t = o[SEND_TIME_KEY];
+    if (typeof t === "number" && Number.isFinite(t)) {
+      const state = { ...o };
+      delete state[SEND_TIME_KEY];
+      return { state, sendTime: t };
+    }
+    return { state: o };
   } catch {
-    return {};
+    return { state: {} };
   }
 }
 function parseValue(s) {
@@ -23,26 +40,82 @@ function parseValue(s) {
   }
 }
 var nowMs = () => typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
-function lerpState(a, b, alpha) {
+function slerp(a, b, t) {
+  let [bx, by, bz, bw] = b;
+  const [ax, ay, az, aw] = a;
+  let dot = ax * bx + ay * by + az * bz + aw * bw;
+  if (dot < 0) {
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+    dot = -dot;
+  }
+  if (dot > 0.9995) {
+    const x = ax + (bx - ax) * t, y = ay + (by - ay) * t, z = az + (bz - az) * t, w = aw + (bw - aw) * t;
+    const l = Math.hypot(x, y, z, w) || 1;
+    return [x / l, y / l, z / l, w / l];
+  }
+  const theta0 = Math.acos(dot);
+  const sin0 = Math.sin(theta0);
+  const s0 = Math.sin(theta0 - theta0 * t) / sin0;
+  const s1 = Math.sin(theta0 * t) / sin0;
+  return [ax * s0 + bx * s1, ay * s0 + by * s1, az * s0 + bz * s1, aw * s0 + bw * s1];
+}
+function isQuat(v) {
+  return Array.isArray(v) && v.length === 4 && v.every((n) => typeof n === "number" && Number.isFinite(n));
+}
+function blend(a, b, tNum, tQuat) {
   const out = {};
   for (const k in b) {
     const av = a[k];
     const bv = b[k];
-    out[k] = typeof av === "number" && typeof bv === "number" && Number.isFinite(av) && Number.isFinite(bv) ? av + (bv - av) * alpha : bv;
+    if (typeof av === "number" && typeof bv === "number" && Number.isFinite(av) && Number.isFinite(bv)) {
+      out[k] = av + (bv - av) * tNum;
+    } else if (isQuat(av) && isQuat(bv)) {
+      out[k] = slerp(av, bv, tQuat);
+    } else {
+      out[k] = bv;
+    }
+  }
+  return out;
+}
+function easeState(prev, target, aNum, aQuat) {
+  const out = {};
+  for (const k in target) {
+    const tv = target[k];
+    const pv = prev[k];
+    if (typeof pv === "number" && typeof tv === "number" && Number.isFinite(pv) && Number.isFinite(tv)) {
+      out[k] = pv + (tv - pv) * aNum;
+    } else if (isQuat(pv) && isQuat(tv)) {
+      out[k] = slerp(pv, tv, aQuat);
+    } else {
+      out[k] = tv;
+    }
   }
   return out;
 }
 function sampleBuffer(buf, renderTime) {
   const n = buf.length;
   if (n === 0) return void 0;
+  if (n === 1) return buf[0].state;
   let j = 0;
   while (j < n && buf[j].t <= renderTime) j++;
   if (j === 0) return buf[0].state;
-  if (j >= n) return buf[n - 1].state;
+  if (j >= n) {
+    const a2 = buf[n - 2];
+    const b2 = buf[n - 1];
+    const span2 = b2.t - a2.t;
+    if (span2 <= 0) return b2.state;
+    const capped = Math.min(renderTime, b2.t + MAX_EXTRAP_MS);
+    const t2 = (capped - a2.t) / span2;
+    return blend(a2.state, b2.state, t2, 1);
+  }
   const a = buf[j - 1];
   const b = buf[j];
   const span = b.t - a.t;
-  return lerpState(a.state, b.state, span > 0 ? (renderTime - a.t) / span : 1);
+  const t = span > 0 ? (renderTime - a.t) / span : 1;
+  return blend(a.state, b.state, t, t);
 }
 function median(xs) {
   if (xs.length === 0) return 66;
@@ -54,23 +127,46 @@ async function connect(opts) {
   const room = await client.joinOrCreate(RELAY_ROOM_TYPE, {
     gameId: opts.room,
     name: opts.name,
-    ...opts.options
+    embedToken: opts.auth?.embedToken,
+    ...opts.options,
+    __v: MP_PROTOCOL
+    // tells the relay this client hides reserved `__` keys (see MP_PROTOCOL)
   });
   const buffers = /* @__PURE__ */ new Map();
-  const lastArrival = /* @__PURE__ */ new Map();
-  const intervals = [];
-  let autoDelay = 100;
-  const pushSnap = (id, state) => {
-    const t = nowMs();
-    const prev = lastArrival.get(id);
-    lastArrival.set(id, t);
+  const lastStamp = /* @__PURE__ */ new Map();
+  const clockOffsets = /* @__PURE__ */ new Map();
+  const offsetWin = /* @__PURE__ */ new Map();
+  const smoothed = /* @__PURE__ */ new Map();
+  const smoothedAt = /* @__PURE__ */ new Map();
+  const intervalsById = /* @__PURE__ */ new Map();
+  const autoDelayById = /* @__PURE__ */ new Map();
+  let localState;
+  const objOwners = /* @__PURE__ */ new Map();
+  const objRaw = /* @__PURE__ */ new Map();
+  const localObjState = /* @__PURE__ */ new Map();
+  let hostId;
+  const pushSnap = (id, state, sendTime) => {
+    const arrival = nowMs();
+    const t = sendTime ?? arrival;
+    if (sendTime != null) {
+      let win = offsetWin.get(id);
+      if (!win) offsetWin.set(id, win = []);
+      win.push(arrival - sendTime);
+      if (win.length > CLOCK_WIN) win.shift();
+      clockOffsets.set(id, Math.min(...win));
+    }
+    const prev = lastStamp.get(id);
+    lastStamp.set(id, t);
     if (prev != null) {
       const gap = t - prev;
       if (gap > 5 && gap < 1e3) {
-        intervals.push(gap);
-        if (intervals.length > 30) intervals.shift();
-        const target = Math.min(INTERP_MAX_MS, Math.max(INTERP_MIN_MS, INTERP_RATIO * median(intervals)));
-        autoDelay += (target - autoDelay) * INTERP_EASE;
+        let iv = intervalsById.get(id);
+        if (!iv) intervalsById.set(id, iv = []);
+        iv.push(gap);
+        if (iv.length > 30) iv.shift();
+        const target = Math.min(INTERP_MAX_MS, Math.max(INTERP_MIN_MS, INTERP_RATIO * median(iv)));
+        const cur = autoDelayById.get(id) ?? 100;
+        autoDelayById.set(id, cur + (target - cur) * INTERP_EASE);
       }
     }
     let buf = buffers.get(id);
@@ -79,27 +175,105 @@ async function connect(opts) {
     const cutoff = t - 1500;
     while (buf.length > 2 && buf[0].t < cutoff) buf.shift();
   };
+  const sampleSmoothed = (streamKey, localNow) => {
+    const buf = buffers.get(streamKey);
+    const autoDelay = autoDelayById.get(streamKey) ?? 100;
+    const renderTime = localNow - (clockOffsets.get(streamKey) ?? 0) - autoDelay;
+    const sampled = buf && sampleBuffer(buf, renderTime);
+    if (!sampled) return void 0;
+    const prev = smoothed.get(streamKey);
+    let out;
+    if (prev) {
+      const dt = Math.min(250, Math.max(0, localNow - (smoothedAt.get(streamKey) ?? localNow)));
+      out = easeState(prev, sampled, 1 - Math.exp(-dt / SMOOTH_TAU_POS), 1 - Math.exp(-dt / SMOOTH_TAU_ROT));
+    } else {
+      out = sampled;
+    }
+    smoothed.set(streamKey, out);
+    smoothedAt.set(streamKey, localNow);
+    return out;
+  };
+  const clearStream = (streamKey) => {
+    buffers.delete(streamKey);
+    lastStamp.delete(streamKey);
+    clockOffsets.delete(streamKey);
+    offsetWin.delete(streamKey);
+    smoothed.delete(streamKey);
+    smoothedAt.delete(streamKey);
+    intervalsById.delete(streamKey);
+    autoDelayById.delete(streamKey);
+  };
   const emitters = /* @__PURE__ */ new Map();
   const bridged = /* @__PURE__ */ new Set();
-  const reserved = /* @__PURE__ */ new Set(["join", "leave", "change", "shared"]);
+  const reserved = /* @__PURE__ */ new Set(["join", "leave", "change", "shared", "object", "host"]);
   const emit = (event, ...args) => emitters.get(event)?.forEach((cb) => cb(...args));
   const $ = getStateCallbacks(room);
   $(room.state).players.onAdd((player, id) => {
-    const initial = parseObject(player.data);
-    emit("join", id, initial);
-    if (id !== room.sessionId) pushSnap(id, initial);
+    const { state, sendTime } = parseData(player.data);
+    emit("join", id, state);
+    if (id !== room.sessionId) pushSnap(id, state, sendTime);
     $(player).onChange(() => {
-      const st = parseObject(player.data);
+      const { state: st, sendTime: ts } = parseData(player.data);
       emit("change", id, st);
-      if (id !== room.sessionId) pushSnap(id, st);
+      if (id !== room.sessionId) pushSnap(id, st, ts);
     });
   });
   $(room.state).players.onRemove((_player, id) => {
     emit("leave", id);
-    buffers.delete(id);
-    lastArrival.delete(id);
+    clearStream(id);
+  });
+  const lastShared = /* @__PURE__ */ new Map();
+  const handleShared = (value, key) => {
+    if (lastShared.get(key) === value) return;
+    lastShared.set(key, value);
+    if (key === HOST_KEY) {
+      const next = parseValue(value) || void 0;
+      if (next !== hostId) {
+        hostId = next;
+        emit("host", hostId);
+      }
+      return;
+    }
+    if (key.startsWith(OBJ_PREFIX)) {
+      const id = key.slice(OBJ_PREFIX.length);
+      const blob = parseValue(value);
+      if (!blob || typeof blob !== "object") return;
+      const owner = typeof blob.o === "string" && blob.o ? blob.o : void 0;
+      const ownerChanged = owner !== objOwners.get(id);
+      if (ownerChanged) {
+        if (owner) objOwners.set(id, owner);
+        else objOwners.delete(id);
+        if (owner !== room.sessionId) localObjState.delete(id);
+      }
+      if (blob.d && typeof blob.d === "object" && Object.keys(blob.d).length > 0) {
+        objRaw.set(id, blob.d);
+        if (owner !== room.sessionId) pushSnap(key, blob.d, blob.t);
+      }
+      if (ownerChanged) emit("object", id);
+      return;
+    }
+    emit("shared", key, parseValue(value));
+  };
+  $(room.state).shared.onAdd(handleShared);
+  $(room.state).shared.onChange(handleShared);
+  $(room.state).shared.onRemove((_value, key) => {
+    lastShared.delete(key);
+    if (key === HOST_KEY) {
+      if (hostId !== void 0) {
+        hostId = void 0;
+        emit("host", void 0);
+      }
+      return;
+    }
+    if (key.startsWith(OBJ_PREFIX)) {
+      const id = key.slice(OBJ_PREFIX.length);
+      clearStream(key);
+      objRaw.delete(id);
+      objOwners.delete(id);
+      localObjState.delete(id);
+      emit("object", id);
+    }
   });
-  $(room.state).shared.onAdd((value, key) => emit("shared", key, parseValue(value)));
   const on = ((event, cb) => {
     let set = emitters.get(event);
     if (!set) emitters.set(event, set = /* @__PURE__ */ new Set());
@@ -116,35 +290,96 @@ async function connect(opts) {
     id: room.sessionId,
     get players() {
       const out = /* @__PURE__ */ new Map();
-      const renderTime = nowMs() - autoDelay;
+      const localNow = nowMs();
       room.state?.players?.forEach((p, id) => {
-        const latest = parseObject(p.data);
+        const { state: latest } = parseData(p.data);
         let state = latest;
-        if (id !== room.sessionId) {
-          const buf = buffers.get(id);
-          const sampled = buf && sampleBuffer(buf, renderTime);
-          if (sampled) state = sampled;
+        let raw = latest;
+        if (id === room.sessionId) {
+          if (localState) {
+            state = localState;
+            raw = localState;
+          }
+        } else {
+          state = sampleSmoothed(id, localNow) ?? latest;
         }
-        out.set(id, { id, name: p.name, state, stateRaw: latest });
+        out.set(id, { id, name: p.name, state, stateRaw: raw });
       });
       return out;
     },
     me: {
       set(state) {
-        room.send("state", JSON.stringify(state));
+        localState = { ...state };
+        room.send("state", JSON.stringify({ ...state, [SEND_TIME_KEY]: nowMs() }));
       }
     },
     shared: {
       get(key) {
+        if (key.startsWith(RESERVED_PREFIX)) return void 0;
         return parseValue(room.state?.shared?.get(key));
       },
       set(key, value) {
+        if (key.startsWith(RESERVED_PREFIX)) return;
         room.send("shared", { key, value: JSON.stringify(value) });
       },
       keys() {
-        return room.state?.shared ? Array.from(room.state.shared.keys()) : [];
+        return room.state?.shared ? Array.from(room.state.shared.keys()).filter((k) => !k.startsWith(RESERVED_PREFIX)) : [];
+      }
+    },
+    objects: {
+      claim(id) {
+        const key = String(id);
+        objOwners.set(key, room.sessionId);
+        room.send("claim", { id: key });
+      },
+      release(id) {
+        const key = String(id);
+        localObjState.delete(key);
+        if (objOwners.get(key) === room.sessionId) objOwners.delete(key);
+        room.send("release", { id: key });
+      },
+      remove(id) {
+        const key = String(id);
+        if (objOwners.get(key) === room.sessionId) {
+          localObjState.delete(key);
+          objRaw.delete(key);
+          objOwners.delete(key);
+          clearStream(OBJ_PREFIX + key);
+        }
+        room.send("destroy", { id: key });
+      },
+      set(id, state) {
+        const key = String(id);
+        if (objOwners.get(key) === room.sessionId) localObjState.set(key, { ...state });
+        room.send("obj", { id: key, d: { ...state } });
+      },
+      get(id) {
+        const key = String(id);
+        const owner = objOwners.get(key);
+        const mine = localObjState.get(key);
+        if (owner === void 0 && !objRaw.has(key) && !mine) return void 0;
+        const isMine = owner !== void 0 && owner === room.sessionId;
+        let state;
+        let raw;
+        if (isMine && mine) {
+          state = mine;
+          raw = mine;
+        } else {
+          raw = objRaw.get(key) ?? {};
+          state = sampleSmoothed(OBJ_PREFIX + key, nowMs()) ?? raw;
+        }
+        return { id: key, owner, isMine, state, stateRaw: raw };
+      },
+      ids() {
+        return [.../* @__PURE__ */ new Set([...objOwners.keys(), ...objRaw.keys(), ...localObjState.keys()])];
       }
     },
+    get isHost() {
+      return hostId !== void 0 && hostId === room.sessionId;
+    },
+    get host() {
+      return hostId;
+    },
     on,
     send(type, payload) {
       room.send(type, payload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/multiplayer",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "The multiplayer client wrapper + shared room schema for genex.",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,12 +20,6 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "check": "pnpm build && publint && attw --pack . --profile esm-only",
-    "prepack": "pnpm build && publint"
-  },
   "publishConfig": {
     "access": "public"
   },
@@ -51,5 +45,10 @@
     "url": "git+https://github.com/me-ai-org/genex-demo.git",
     "directory": "packages/multiplayer"
   },
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "check": "pnpm build && publint && attw --pack . --profile esm-only"
+  }
+}