@irtio/client 0.1.0

package/dist/index.js

@@ -0,0 +1,1364 @@
+// src/endpoint.ts
+var DEFAULT_REGION = "eu";
+var DEV_PORT = 7070;
+function currentLocation() {
+  const loc = globalThis.location;
+  if (!loc || typeof loc.hostname !== "string" || typeof loc.href !== "string") return void 0;
+  return loc;
+}
+function isLocalHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+function envUrl() {
+  const g = globalThis;
+  const fromWindow = g.IRT_URL;
+  if (typeof fromWindow === "string" && fromWindow !== "") return fromWindow;
+  const fromEnv = g.process?.env?.IRT_URL;
+  if (typeof fromEnv === "string" && fromEnv !== "") return fromEnv;
+  return void 0;
+}
+function resolveUrl(explicit) {
+  if (explicit !== void 0 && explicit !== "") return explicit;
+  const fromEnv = envUrl();
+  if (fromEnv !== void 0) return fromEnv;
+  const loc = currentLocation();
+  if (!loc || isLocalHostname(loc.hostname)) return `ws://localhost:${DEV_PORT}`;
+  return `wss://${DEFAULT_REGION}.irt.io`;
+}
+function isLocalUrl(url) {
+  try {
+    return isLocalHostname(new URL(url).hostname);
+  } catch {
+    return false;
+  }
+}
+function roomIdFrom(roomOrLink) {
+  const raw = roomOrLink.trim();
+  if (raw === "") return "";
+  if (!raw.includes("://") && !raw.includes("?") && !raw.includes("/")) return raw;
+  try {
+    const url = new URL(raw);
+    return url.searchParams.get("room") ?? "";
+  } catch {
+    return raw;
+  }
+}
+function roomIdFromLocation() {
+  const loc = currentLocation();
+  if (!loc) return "";
+  try {
+    return new URL(loc.href).searchParams.get("room") ?? "";
+  } catch {
+    return "";
+  }
+}
+function publishRoomToLocation(roomId) {
+  const loc = currentLocation();
+  const history = globalThis.history;
+  if (!loc) return void 0;
+  let href;
+  try {
+    const url = new URL(loc.href);
+    url.searchParams.set("room", roomId);
+    href = url.href;
+  } catch {
+    return void 0;
+  }
+  if (href !== loc.href && typeof history?.replaceState === "function") {
+    try {
+      history.replaceState(null, "", href);
+    } catch {
+    }
+  }
+  return href;
+}
+function linkForUrl(wsUrl, roomId) {
+  try {
+    const url = new URL(wsUrl);
+    url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+    url.pathname = "/";
+    url.search = "";
+    if (roomId !== "") url.searchParams.set("room", roomId);
+    return url.href;
+  } catch {
+    return roomId === "" ? wsUrl : `${wsUrl}?room=${roomId}`;
+  }
+}
+
+// src/session.ts
+import {
+  FrameType,
+  PROTOCOL_VERSION,
+  RELAY_HASH8,
+  decodeCall,
+  decodeErrorPayload,
+  decodeFrame,
+  decodeMsg,
+  decodePong,
+  decodeReply,
+  decodeWelcome,
+  encodeCall,
+  encodeFrame,
+  encodeHello,
+  encodeMsg,
+  encodePing,
+  encodeReply,
+  errorByCode,
+  formatError,
+  readCorrectClientTick,
+  relaySchema,
+  rpcTable,
+  withBuiltins
+} from "@irtio/protocol";
+import {
+  ByteReader,
+  decodeDelta,
+  decodeDeltaFrom,
+  decodeFields,
+  encodeFields
+} from "@irtio/schema";
+
+// src/contract.ts
+var E_CONNECT_FAILED = "E_CONNECT_FAILED";
+
+// src/scheduler.ts
+function rafPair() {
+  const g = globalThis;
+  if (typeof g.requestAnimationFrame !== "function") return void 0;
+  const request = g.requestAnimationFrame.bind(globalThis);
+  const cancel = (g.cancelAnimationFrame ?? (() => {
+  })).bind(globalThis);
+  return { request, cancel };
+}
+function defaultScheduler() {
+  const raf = rafPair();
+  const base = {
+    now: () => Date.now(),
+    setTimeout(fn, ms) {
+      const handle = setTimeout(fn, ms);
+      handle.unref?.();
+      return () => clearTimeout(handle);
+    }
+  };
+  if (!raf) return base;
+  return {
+    ...base,
+    frame(fn) {
+      const handle = raf.request(() => fn());
+      return () => raf.cancel(handle);
+    }
+  };
+}
+
+// src/state.ts
+import {
+  applyDelta,
+  collectionDirty,
+  createDirtySet,
+  createFieldMask,
+  createState,
+  decodeSnapshot,
+  encodeDelta,
+  frozenProxy,
+  isDirtyEmpty,
+  track
+} from "@irtio/schema";
+var RESIM_DEPTH = 20;
+function entityOf(state, name) {
+  return state[name];
+}
+function subtractMask(dst, src) {
+  for (const idx of src.fields) {
+    const srcNested = src.nested.get(idx);
+    const dstNested = dst.nested.get(idx);
+    if (srcNested && dstNested) {
+      subtractMask(dstNested, srcNested);
+      if (dstNested.fields.size === 0) {
+        dst.fields.delete(idx);
+        dst.nested.delete(idx);
+      }
+      continue;
+    }
+    dst.fields.delete(idx);
+    dst.nested.delete(idx);
+  }
+}
+var ClientCollectionImpl = class {
+  constructor(store, desc) {
+    this.store = store;
+    this.desc = desc;
+  }
+  store;
+  desc;
+  get plain() {
+    return entityOf(this.store.plain, this.desc.name);
+  }
+  get(id) {
+    return this.store.instance(this.desc, id);
+  }
+  has(id) {
+    return this.plain.has(id);
+  }
+  ownerOf(id) {
+    return this.plain.ownerOf(id);
+  }
+  get size() {
+    return this.plain.size;
+  }
+  ids() {
+    return this.plain.ids();
+  }
+  *[Symbol.iterator]() {
+    for (const id of [...this.plain.ids()]) {
+      yield [id, this.store.instance(this.desc, id)];
+    }
+  }
+};
+function withIndexSugar(collection) {
+  return new Proxy(collection, {
+    get(target, prop, receiver) {
+      if (typeof prop !== "string" || prop in target) return Reflect.get(target, prop, receiver);
+      return target.get(prop);
+    },
+    has(target, prop) {
+      if (typeof prop !== "string" || prop in target) return Reflect.has(target, prop);
+      return target.has(prop);
+    }
+  });
+}
+var ClientStore = class {
+  constructor(ext, meOf) {
+    this.ext = ext;
+    this.meOf = meOf;
+    for (const c of ext.collections) this.descs.set(c.name, c);
+    this.plain = createState(ext);
+    this.tracked = track(ext, this.plain);
+    this.view = this.buildView();
+  }
+  ext;
+  meOf;
+  plain;
+  tracked;
+  descs = /* @__PURE__ */ new Map();
+  frozen = /* @__PURE__ */ new WeakMap();
+  /** The object handed out as `room.state`; identity survives a resync. */
+  view;
+  /** Flushed-but-unjudged writes, oldest first, at most `RESIM_DEPTH` entries (D19). */
+  pendingWrites = [];
+  /** The newest write tick evicted from `pendingWrites` — corrections older than it must snap. */
+  evictedThroughTick = 0;
+  // -- snapshot / resync -----------------------------------------------------
+  loadSnapshot(bytes) {
+    this.plain = decodeSnapshot(this.ext, bytes).state;
+    this.tracked = track(this.ext, this.plain);
+    this.pendingWrites.length = 0;
+    this.evictedThroughTick = 0;
+  }
+  /**
+   * Captures the field values of every pending owned write, keyed by collection then id then
+   * field name — call this **before** `loadSnapshot` on a resync, or the edit is gone once the
+   * old `plain` it lives in is replaced. Paired with `applyPendingWrites`.
+   */
+  capturePendingWrites() {
+    const out = /* @__PURE__ */ new Map();
+    const me = this.meOf();
+    if (me === "") return out;
+    for (const [name, cd] of this.tracked.dirty) {
+      const desc = this.desc(name);
+      if (!desc || desc.kind !== "entity" || desc.serverOwned) continue;
+      const coll = entityOf(this.plain, name);
+      for (const [id, rd] of cd.updated) {
+        if (rd.mask.fields.size === 0 || !coll.has(id) || coll.ownerOf(id) !== me) continue;
+        const value = coll.get(id);
+        const patch = {};
+        for (const idx of rd.mask.fields) {
+          const fname = desc.fields[idx]?.name;
+          if (fname !== void 0) patch[fname] = value[fname];
+        }
+        let byId = out.get(name);
+        if (!byId) {
+          byId = /* @__PURE__ */ new Map();
+          out.set(name, byId);
+        }
+        byId.set(id, patch);
+      }
+    }
+    return out;
+  }
+  /**
+   * Writes a `capturePendingWrites` snapshot into the freshly loaded `plain` (still the raw
+   * decoded values — no validation, they were already validated at the time of the original
+   * local write) and marks every owned field dirty so the next flush resends the real edit, not
+   * whatever the resync snapshot happened to carry for that field.
+   */
+  applyPendingWrites(pending) {
+    const me = this.meOf();
+    if (me === "" || pending.size === 0) return;
+    for (const [name, byId] of pending) {
+      const coll = entityOf(this.plain, name);
+      for (const [id, patch] of byId) {
+        if (!coll.has(id) || coll.ownerOf(id) !== me) continue;
+        const rec = coll.get(id);
+        for (const [field, value] of Object.entries(patch)) {
+          rec[field] = Array.isArray(value) ? [...value] : value;
+        }
+      }
+    }
+    this.remarkOwned();
+  }
+  buildView() {
+    const view = {};
+    for (const c of this.ext.collections) {
+      if (c.kind === "entity") {
+        const facade = withIndexSugar(new ClientCollectionImpl(this, c));
+        Object.defineProperty(view, c.name, { get: () => facade, enumerable: true });
+      } else {
+        Object.defineProperty(view, c.name, {
+          get: () => this.freeze(this.plain[c.name], this.singletonHint(c)),
+          enumerable: true
+        });
+      }
+    }
+    return view;
+  }
+  // -- instances ------------------------------------------------------------
+  /** The writable tracked proxy when this client owns `id`, otherwise a frozen one. */
+  instance(desc, id) {
+    const coll = entityOf(this.plain, desc.name);
+    const value = coll.get(id);
+    if (value === void 0) return void 0;
+    if (!desc.serverOwned && coll.ownerOf(id) === this.meOf()) {
+      const trackedColl = this.tracked.state[desc.name];
+      return trackedColl ? trackedColl.get(id) : value;
+    }
+    return this.freeze(value, this.entityHint(desc, id, coll.ownerOf(id)));
+  }
+  freeze(value, hint) {
+    const cached = this.frozen.get(value);
+    if (cached !== void 0) return cached;
+    const proxy = frozenProxy(value, hint);
+    this.frozen.set(value, proxy);
+    return proxy;
+  }
+  entityHint(desc, id, owner) {
+    if (desc.serverOwned) {
+      return `${desc.name} is server-owned; change it with an RPC (room.call.\u2026)`;
+    }
+    const me = this.meOf();
+    if (owner === void 0 || owner === "") {
+      return `${desc.name}[${id}] is owned by the server; await room.requestOwnership(${JSON.stringify(desc.name)}, ${JSON.stringify(id)}) first`;
+    }
+    return `${desc.name}[${id}] is owned by ${owner}, not by you (${me}); await room.requestOwnership(${JSON.stringify(desc.name)}, ${JSON.stringify(id)}) first`;
+  }
+  singletonHint(desc) {
+    return `${desc.name} is a singleton and never client-owned; change it with an RPC (room.call.\u2026)`;
+  }
+  // -- inbound frames -------------------------------------------------------
+  /**
+   * Applies a server `DELTA`. Update ops for instances this client owns are dropped field-wise
+   * (server wins only through `CORRECT`); adds, removes and owner changes always apply.
+   */
+  applyServerDelta(delta) {
+    applyDelta(this.ext, this.plain, this.withoutOwnedUpdates(delta));
+    this.replayOverAddEchoes(delta);
+  }
+  /**
+   * The flushed-write half of the §7.2 in-flight own-write fix: an `add` op for an instance this
+   * client owns replaces the whole record, so any write already *flushed* (dirty set consumed —
+   * `preserveLocalWrites` cannot see it) but not yet judged would be reverted by the echo.
+   * Re-apply the retained pending writes in flush order; the server's eventual `CORRECT` (if the
+   * write is clamped) still wins through the snap+replay path.
+   */
+  replayOverAddEchoes(delta) {
+    const me = this.meOf();
+    if (me === "" || this.pendingWrites.length === 0) return;
+    for (const dc of delta.collections) {
+      const desc = this.desc(dc.name);
+      if (!desc || desc.kind !== "entity" || desc.serverOwned) continue;
+      for (const op of dc.ops) {
+        if (op.op !== "add" || op.owner !== me) continue;
+        for (const pw of this.pendingWrites) this.replayWrite(pw, dc.name, op.id);
+      }
+    }
+  }
+  withoutOwnedUpdates(delta) {
+    const me = this.meOf();
+    let changed = false;
+    const collections = [];
+    for (const dc of delta.collections) {
+      const desc = this.desc(dc.name);
+      if (!desc || desc.kind !== "entity" || desc.serverOwned) {
+        collections.push(dc);
+        continue;
+      }
+      const coll = entityOf(this.plain, dc.name);
+      const ops = [];
+      for (const op of dc.ops) {
+        if (op.op === "add") {
+          const rewritten = this.preserveLocalWrites(desc, coll, op, me);
+          if (rewritten !== op) changed = true;
+          ops.push(rewritten);
+          continue;
+        }
+        if (op.op !== "update") {
+          ops.push(op);
+          continue;
+        }
+        const owner = op.owner ?? coll.ownerOf(op.id);
+        if (owner !== me) {
+          ops.push(op);
+          continue;
+        }
+        changed = true;
+        if (op.owner !== void 0) {
+          ops.push({
+            op: "update",
+            id: op.id,
+            owner: op.owner,
+            mask: createFieldMask(),
+            patch: {}
+          });
+        }
+      }
+      collections.push({ name: dc.name, ops });
+    }
+    return changed ? { tick: delta.tick, hash8: delta.hash8, collections } : delta;
+  }
+  /**
+   * An `add` for an instance this client will own, with its unflushed local field values folded
+   * back in. Returns `op` unchanged when there is nothing to preserve.
+   */
+  preserveLocalWrites(desc, coll, op, me) {
+    if (me === "" || op.owner !== me) return op;
+    const pending = this.tracked.dirty.get(desc.name)?.updated.get(op.id);
+    if (!pending || pending.mask.fields.size === 0) return op;
+    const local = coll.get(op.id);
+    if (!local) return op;
+    const value = { ...op.value };
+    for (const idx of pending.mask.fields) {
+      const field = desc.fields[idx]?.name;
+      if (field !== void 0) value[field] = local[field];
+    }
+    return { op: "add", id: op.id, owner: op.owner, value };
+  }
+  /**
+   * Applies a `CORRECT`: snap the named fields to the server's values, then re-apply every local
+   * write newer than the judged `clientTick` in order (D19 snap + replay) — flushed writes from
+   * the retained buffer first, the still-unflushed in-window edit last (it is the newest, and its
+   * dirty mark survives so the next flush re-sends the *local* value, not the server's).
+   *
+   * Without a `clientTick` (a pre-week-8 server) — or when the correction outran the
+   * `RESIM_DEPTH` window (`snapped`) — the pre-D19 semantics apply: the correction wins in full
+   * and the local dirty marks it supersedes are cleared.
+   */
+  applyCorrection(delta, clientTick) {
+    if (clientTick !== void 0) {
+      while (this.pendingWrites.length > 0 && this.pendingWrites[0].tick <= clientTick) {
+        this.pendingWrites.shift();
+      }
+    }
+    const snapped = clientTick !== void 0 && clientTick < this.evictedThroughTick;
+    const replay = clientTick !== void 0 && !snapped;
+    const me = this.meOf();
+    const out = [];
+    const targets = [];
+    const unflushed = { tick: Number.MAX_SAFE_INTEGER, writes: /* @__PURE__ */ new Map() };
+    for (const dc of delta.collections) {
+      const desc = this.desc(dc.name);
+      if (!desc) continue;
+      for (const op of dc.ops) {
+        if (op.op !== "update") continue;
+        const pending = this.tracked.dirty.get(dc.name)?.updated.get(op.id);
+        if (pending) {
+          if (replay) {
+            const coll = entityOf(this.plain, dc.name);
+            const value = coll.get(op.id);
+            if (value && coll.ownerOf(op.id) === me && pending.mask.fields.size > 0) {
+              const patch = {};
+              for (const idx of pending.mask.fields) {
+                const fname = desc.fields[idx]?.name;
+                if (fname !== void 0) patch[fname] = value[fname];
+              }
+              let byId = unflushed.writes.get(dc.name);
+              if (!byId) {
+                byId = /* @__PURE__ */ new Map();
+                unflushed.writes.set(dc.name, byId);
+              }
+              byId.set(op.id, patch);
+            }
+          } else {
+            subtractMask(pending.mask, op.mask);
+          }
+        }
+        targets.push({ collection: dc.name, id: op.id });
+        out.push({
+          collection: dc.name,
+          id: op.id,
+          fields: [...op.mask.fields].map((i) => desc.fields[i]?.name).filter((n) => n !== void 0),
+          patch: op.patch,
+          tick: delta.tick,
+          ...clientTick !== void 0 ? { clientTick } : {},
+          replayed: 0,
+          snapped
+        });
+      }
+    }
+    applyDelta(this.ext, this.plain, delta);
+    let replayed = 0;
+    if (replay) {
+      for (const pw of [...this.pendingWrites, unflushed]) {
+        let applied = false;
+        for (const t of targets) {
+          if (this.replayWrite(pw, t.collection, t.id)) applied = true;
+        }
+        if (applied) replayed++;
+      }
+    }
+    return replayed === 0 ? out : out.map((op) => ({ ...op, replayed }));
+  }
+  desc(name) {
+    return this.descs.get(name);
+  }
+  // -- outbound writes ------------------------------------------------------
+  /** Cheap check for the flush loop: has anything been written locally since the last flush? */
+  get hasLocalWrites() {
+    return !isDirtyEmpty(this.tracked.dirty);
+  }
+  /**
+   * The `WRITE` payload for everything dirty, or `undefined` when nothing qualifies. Consumes the
+   * dirty set either way (a write to an instance that has since been removed or handed away is
+   * dropped, not retried forever).
+   */
+  takeWrite(tick) {
+    const dirty = this.tracked.flush();
+    const owned = this.ownedDirty(dirty);
+    if (owned.size === 0) return void 0;
+    this.retainPendingWrite(tick, owned);
+    return encodeDelta(this.ext, this.plain, owned, { tick });
+  }
+  /**
+   * Captures the field values a flushed `WRITE` carried, keyed by its write tick, so a later
+   * `CORRECT` can re-apply exactly the writes the server had not judged yet (D19 snap + replay).
+   * Bounded to `RESIM_DEPTH` entries; eviction is remembered so an outrun correction snaps.
+   */
+  retainPendingWrite(tick, owned) {
+    const writes = /* @__PURE__ */ new Map();
+    for (const [name, cd] of owned) {
+      const desc = this.desc(name);
+      if (!desc) continue;
+      const coll = entityOf(this.plain, name);
+      for (const [id, rd] of cd.updated) {
+        const value = coll.get(id);
+        if (!value) continue;
+        const patch = {};
+        for (const idx of rd.mask.fields) {
+          const fname = desc.fields[idx]?.name;
+          if (fname === void 0) continue;
+          const v = value[fname];
+          patch[fname] = Array.isArray(v) ? [...v] : typeof v === "object" && v !== null ? { ...v } : v;
+        }
+        let byId = writes.get(name);
+        if (!byId) {
+          byId = /* @__PURE__ */ new Map();
+          writes.set(name, byId);
+        }
+        byId.set(id, patch);
+      }
+    }
+    if (writes.size === 0) return;
+    this.pendingWrites.push({ tick, writes });
+    while (this.pendingWrites.length > RESIM_DEPTH) {
+      const evicted = this.pendingWrites.shift();
+      if (evicted && evicted.tick > this.evictedThroughTick) this.evictedThroughTick = evicted.tick;
+    }
+  }
+  /** Re-applies one retained write's fields for `collection[id]` onto the plain state. */
+  replayWrite(pw, collection, id) {
+    const patch = pw.writes.get(collection)?.get(id);
+    if (!patch) return false;
+    const me = this.meOf();
+    const coll = entityOf(this.plain, collection);
+    if (!coll.has(id) || coll.ownerOf(id) !== me) return false;
+    const rec = coll.get(id);
+    for (const [field, value] of Object.entries(patch)) {
+      rec[field] = Array.isArray(value) ? [...value] : typeof value === "object" && value !== null ? { ...value } : value;
+    }
+    return true;
+  }
+  /**
+   * Re-marks every field of every instance this client owns, so a resync `WELCOME` (wake or
+   * worker restart) does not silently drop writes that were in flight.
+   */
+  remarkOwned() {
+    const me = this.meOf();
+    if (me === "") return;
+    for (const c of this.ext.collections) {
+      if (c.kind !== "entity" || c.serverOwned) continue;
+      const coll = entityOf(this.plain, c.name);
+      for (const id of [...coll.ids()]) {
+        if (coll.ownerOf(id) !== me) continue;
+        const rec = collectionDirty(this.tracked.dirty, c.name).updated;
+        const mask = createFieldMask();
+        for (const f of c.fields) mask.fields.add(f.index);
+        rec.set(id, { mask, owner: false });
+      }
+    }
+  }
+  /** Only update ops, only instances that still exist and are still mine, never the owner bit. */
+  ownedDirty(dirty) {
+    const me = this.meOf();
+    const out = createDirtySet();
+    if (me === "") return out;
+    for (const [name, cd] of dirty) {
+      const desc = this.desc(name);
+      if (!desc || desc.kind !== "entity" || desc.serverOwned) continue;
+      const coll = entityOf(this.plain, name);
+      for (const [id, rd] of cd.updated) {
+        if (rd.mask.fields.size === 0) continue;
+        if (!coll.has(id) || coll.ownerOf(id) !== me) continue;
+        collectionDirty(out, name).updated.set(id, { mask: rd.mask, owner: false });
+      }
+    }
+    for (const [name, cd] of [...out]) {
+      if (cd.updated.size === 0) out.delete(name);
+    }
+    return out;
+  }
+};
+
+// src/transport.ts
+function globalWebSocket() {
+  const ctor = globalThis.WebSocket;
+  if (!ctor) {
+    throw new Error(
+      "irtio: no global WebSocket. Node 22+ or a browser is required; pass `transport` to use another one."
+    );
+  }
+  return ctor;
+}
+async function toBytes(data) {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    const view = data;
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+  }
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  throw new Error(`irtio: unexpected websocket payload of type ${typeof data}`);
+}
+var WebSocketTransportSocket = class {
+  onopen = null;
+  onmessage = null;
+  onclose = null;
+  onerror = null;
+  ws;
+  constructor(url) {
+    this.ws = new (globalWebSocket())(url);
+    this.ws.binaryType = "arraybuffer";
+    this.ws.addEventListener("open", () => this.onopen?.());
+    this.ws.addEventListener("message", (event) => {
+      void toBytes(event.data).then(
+        (bytes) => this.onmessage?.(bytes),
+        (err) => this.onerror?.(err)
+      );
+    });
+    this.ws.addEventListener(
+      "close",
+      (event) => this.onclose?.({
+        ...event?.code !== void 0 ? { code: event.code } : {},
+        ...event?.reason !== void 0 ? { reason: event.reason } : {}
+      })
+    );
+    this.ws.addEventListener("error", (event) => this.onerror?.(event));
+  }
+  send(bytes) {
+    this.ws.send(bytes);
+  }
+  close() {
+    try {
+      this.ws.close();
+    } catch {
+    }
+  }
+};
+var webSocketTransport = {
+  connect(url) {
+    return new WebSocketTransportSocket(url);
+  }
+};
+
+// src/session.ts
+var DEFAULT_WRITE_INTERVAL_MS = 50;
+var PING_INTERVAL_MS = 1e4;
+var CALL_TIMEOUT_MS = 1e4;
+var BACKOFF_START_MS = 250;
+var BACKOFF_MAX_MS = 5e3;
+function isThenable(v) {
+  return typeof v === "object" && v !== null && typeof v.then === "function";
+}
+function nameOfCode(code) {
+  try {
+    return errorByCode(code).name;
+  } catch {
+    return "E_INTERNAL";
+  }
+}
+var Session = class {
+  constructor(options) {
+    this.options = options;
+    this.ext = options.schema ? withBuiltins(options.schema) : relaySchema;
+    this.rpcSchema = options.schema ?? relaySchema;
+    this.transport = options.transport ?? webSocketTransport;
+    this.scheduler = options.scheduler ?? defaultScheduler();
+    this.writeIntervalMs = options.writeIntervalMs ?? DEFAULT_WRITE_INTERVAL_MS;
+    this.impls = new Map(Object.entries(options.rpc ?? {}));
+    this.roomId = options.roomId;
+    this.role = options.role ?? "";
+    this.store = new ClientStore(this.ext, () => this.me);
+  }
+  options;
+  ext;
+  store;
+  /** The schema the `CALL`/`REPLY` rpc id space indexes into. */
+  rpcSchema;
+  transport;
+  scheduler;
+  writeIntervalMs;
+  impls;
+  me = "";
+  role = "";
+  roomId;
+  tick = 0;
+  /**
+   * The client-local write counter (D19): +1 per flushed `WRITE`, stamped in its delta header.
+   * Monotonic for the life of the session, across reconnects — the server's `lastClientTick`
+   * for this client survives the grace window too.
+   */
+  writeTick = 0;
+  /** The room's tick interval from `WELCOME`, or 0 when unknown (relay / pre-week-8 server). */
+  tickIntervalMs = 0;
+  rtt = 0;
+  status = "connecting";
+  socket;
+  resumeToken;
+  joined = false;
+  left = false;
+  attempt = 0;
+  reqId = 0;
+  pending = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  messageListeners = /* @__PURE__ */ new Set();
+  cancelFlush;
+  cancelPing;
+  cancelRetry;
+  linkOverride;
+  settleJoin;
+  failJoin;
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  /** Connects and resolves on the first `WELCOME`; a fatal `ERROR` before it rejects. */
+  start() {
+    return new Promise((resolve, reject) => {
+      this.settleJoin = resolve;
+      this.failJoin = reject;
+      this.options.onStatus?.("connecting");
+      this.emit("status", "connecting");
+      this.connect();
+    });
+  }
+  connect() {
+    if (this.left) return;
+    let socket;
+    try {
+      socket = this.transport.connect(this.options.url);
+    } catch (err) {
+      this.transportFailed(err);
+      return;
+    }
+    this.socket = socket;
+    socket.onopen = () => {
+      if (this.socket === socket) this.sendHello();
+    };
+    socket.onmessage = (bytes) => {
+      if (this.socket === socket) this.onFrame(bytes);
+    };
+    socket.onclose = (info) => {
+      if (this.socket === socket) this.onSocketClosed(info);
+    };
+    socket.onerror = (err) => {
+      if (this.socket === socket && !this.joined) this.transportFailed(err);
+    };
+  }
+  transportFailed(err) {
+    const message = err instanceof Error ? err.message : `websocket error (${String(err)})`;
+    if (!this.joined) {
+      this.emit("error", { code: E_CONNECT_FAILED, message, fatal: true });
+      this.fatal(
+        new Error(
+          `${E_CONNECT_FAILED}: cannot reach ${this.options.url}: ${message} (the room was never joined)`
+        )
+      );
+      return;
+    }
+    this.emit("error", { code: "E_INTERNAL", message, fatal: false });
+  }
+  sendHello() {
+    const hash8 = this.options.schema ? this.options.schema.hash8 : RELAY_HASH8;
+    const hello = encodeHello({
+      protocolVersion: PROTOCOL_VERSION,
+      credential: { kind: "key", key: this.options.key },
+      roomId: this.roomId,
+      schemaHash8: hash8,
+      ...this.resumeToken !== void 0 ? { resumeToken: this.resumeToken } : {},
+      ...this.options.role !== void 0 ? { role: this.options.role } : {},
+      ...this.options.name !== void 0 ? { name: this.options.name } : {}
+    });
+    this.send(FrameType.HELLO, hello);
+  }
+  /** Leaves for good: no reconnect, pending calls reject, the socket closes. */
+  leave() {
+    if (this.left) return;
+    this.left = true;
+    this.stopTimers();
+    this.rejectPending(new Error("irtio: left the room"));
+    this.setStatus("closed");
+    if (this.socket && this.joined) this.send(FrameType.LEAVE, new Uint8Array(0));
+    this.socket?.close();
+    this.socket = void 0;
+  }
+  fatal(error) {
+    this.left = true;
+    this.stopTimers();
+    this.rejectPending(error);
+    this.setStatus("closed");
+    this.socket?.close();
+    this.socket = void 0;
+    const fail = this.failJoin;
+    this.settleJoin = void 0;
+    this.failJoin = void 0;
+    fail?.(error);
+  }
+  onSocketClosed(info) {
+    this.socket = void 0;
+    this.stopTimers();
+    if (!this.joined) {
+      const detail = info?.code !== void 0 ? ` (code ${info.code}${info.reason ? `: ${info.reason}` : ""})` : "";
+      this.fatal(
+        new Error(
+          `${E_CONNECT_FAILED}: ${this.options.url} closed the connection before the room was joined${detail}`
+        )
+      );
+      return;
+    }
+    this.rejectPending(new Error("irtio: connection lost before the reply arrived"));
+    if (this.left) return;
+    this.setStatus("reconnecting");
+    const delay = Math.min(BACKOFF_START_MS * 2 ** this.attempt, BACKOFF_MAX_MS);
+    this.attempt++;
+    this.cancelRetry = this.scheduler.setTimeout(() => {
+      this.cancelRetry = void 0;
+      this.connect();
+    }, delay);
+  }
+  stopTimers() {
+    this.cancelFlush?.();
+    this.cancelFlush = void 0;
+    this.cancelPing?.();
+    this.cancelPing = void 0;
+    this.cancelRetry?.();
+    this.cancelRetry = void 0;
+  }
+  // -------------------------------------------------------------------------
+  // Frames
+  // -------------------------------------------------------------------------
+  send(type, payload) {
+    const frame = encodeFrame(type, payload);
+    this.options.onFrame?.("out", type, frame);
+    this.socket?.send(frame);
+  }
+  onFrame(bytes) {
+    let type;
+    let payload;
+    try {
+      const frame = decodeFrame(bytes);
+      type = frame.type;
+      payload = frame.payload;
+    } catch (err) {
+      this.localError(err);
+      return;
+    }
+    this.options.onFrame?.("in", type, bytes);
+    try {
+      switch (type) {
+        case FrameType.WELCOME:
+          this.onWelcome(payload);
+          return;
+        case FrameType.DELTA:
+          this.onDelta(payload);
+          return;
+        case FrameType.CORRECT:
+          this.onCorrect(payload);
+          return;
+        case FrameType.ERROR:
+          this.onError(payload);
+          return;
+        case FrameType.PONG:
+          this.onPong(payload);
+          return;
+        case FrameType.CALL:
+          this.onCall(payload);
+          return;
+        case FrameType.REPLY:
+          this.onReply(payload);
+          return;
+        default:
+          if (type === FrameType.MSG) this.onMsg(payload);
+          return;
+      }
+    } catch (err) {
+      this.localError(err);
+    }
+  }
+  /** A frame we could not decode or apply. Reported, never fatal: the stream may recover. */
+  localError(err) {
+    this.emit("error", {
+      code: "E_INTERNAL",
+      message: err instanceof Error ? err.message : String(err),
+      fatal: false
+    });
+  }
+  onWelcome(payload) {
+    const welcome = decodeWelcome(payload);
+    const pending = this.store.capturePendingWrites();
+    this.me = welcome.clientId;
+    this.role = welcome.role;
+    this.tick = welcome.tick;
+    this.resumeToken = welcome.resumeToken;
+    this.tickIntervalMs = welcome.tickIntervalMs;
+    if (welcome.roomId !== "") this.roomId = welcome.roomId;
+    this.store.loadSnapshot(welcome.snapshot);
+    this.store.applyPendingWrites(pending);
+    this.attempt = 0;
+    if (this.options.publishLocation) {
+      this.linkOverride = publishRoomToLocation(this.roomId);
+    }
+    this.joined = true;
+    this.setStatus("connected");
+    this.startTimers();
+    const settle = this.settleJoin;
+    this.settleJoin = void 0;
+    this.failJoin = void 0;
+    settle?.(this);
+  }
+  onDelta(payload) {
+    const delta = decodeDelta(this.ext, payload);
+    this.tick = delta.tick;
+    this.store.applyServerDelta(delta);
+  }
+  onCorrect(payload) {
+    const r = new ByteReader(payload);
+    const delta = decodeDeltaFrom(this.ext, r);
+    const clientTick = readCorrectClientTick(r);
+    this.tick = delta.tick;
+    for (const op of this.store.applyCorrection(delta, clientTick)) {
+      this.emit("correct", op);
+    }
+  }
+  onError(payload) {
+    const e = decodeErrorPayload(payload);
+    const code = nameOfCode(e.code);
+    if (code === "E_STARTING") {
+      this.emit("error", { code, message: e.message, fatal: false });
+      this.setStatus("starting");
+      return;
+    }
+    if (code === "E_RESUME_EXPIRED" && this.resumeToken !== void 0) {
+      this.resumeToken = void 0;
+      this.emit("error", { code, message: e.message, fatal: false });
+      return;
+    }
+    this.emit("error", { code, message: e.message, fatal: e.fatal });
+    if (e.fatal) this.fatal(new Error(`${code}: ${e.message}`));
+  }
+  onPong(payload) {
+    const pong = decodePong(payload);
+    this.rtt = Math.max(1, (this.scheduler.now() >>> 0) - pong.t >>> 0);
+    if (pong.serverTick > this.tick) this.tick = pong.serverTick;
+  }
+  onMsg(payload) {
+    const msg = decodeMsg(payload);
+    const from = msg.target.kind === "client" ? msg.target.clientId : "server";
+    const bytes = msg.payload.slice();
+    for (const cb of [...this.messageListeners]) cb(from, bytes);
+  }
+  // -------------------------------------------------------------------------
+  // Timers
+  // -------------------------------------------------------------------------
+  startTimers() {
+    if (!this.cancelFlush) this.armFlush();
+    if (!this.cancelPing) this.armPing();
+  }
+  /**
+   * The write batcher: one window per animation frame in a browser, or per `writeIntervalMs`
+   * everywhere else, with `writeIntervalMs` as the hard cap in both. Every owned field written
+   * inside a window leaves as a single `WRITE`.
+   */
+  armFlush() {
+    let capCancel;
+    let frameCancel;
+    const fire = () => {
+      capCancel?.();
+      frameCancel?.();
+      capCancel = void 0;
+      frameCancel = void 0;
+      this.cancelFlush = void 0;
+      if (this.left) return;
+      this.flush();
+      this.armFlush();
+    };
+    capCancel = this.scheduler.setTimeout(fire, this.writeIntervalMs);
+    if (this.scheduler.frame) frameCancel = this.scheduler.frame(fire);
+    this.cancelFlush = () => {
+      capCancel?.();
+      frameCancel?.();
+    };
+  }
+  armPing() {
+    this.cancelPing = this.scheduler.setTimeout(() => {
+      this.cancelPing = void 0;
+      if (this.left || !this.socket) return;
+      this.send(FrameType.PING, encodePing({ t: this.scheduler.now() >>> 0 }));
+      this.armPing();
+    }, PING_INTERVAL_MS);
+  }
+  /** Sends every pending owned write now. */
+  flush() {
+    if (!this.socket || !this.joined) return;
+    if (!this.store.hasLocalWrites) return;
+    const payload = this.store.takeWrite(this.writeTick + 1);
+    if (payload) {
+      this.writeTick++;
+      this.send(FrameType.WRITE, payload);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // RPCs
+  // -------------------------------------------------------------------------
+  descOf(name) {
+    const desc = rpcTable(this.rpcSchema).find((r) => r.name === name);
+    if (!desc) throw new Error(`irtio: unknown rpc ${JSON.stringify(name)}`);
+    return desc;
+  }
+  call(name, params = {}) {
+    let desc;
+    let encoded;
+    try {
+      desc = this.descOf(name);
+      encoded = encodeFields(desc.params, params);
+    } catch (err) {
+      return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+    }
+    if (!this.socket || this.left) {
+      return Promise.reject(new Error(`irtio: ${name} failed \u2014 not connected`));
+    }
+    const reqId = ++this.reqId;
+    return new Promise((resolve, reject) => {
+      const cancelTimeout = this.scheduler.setTimeout(() => {
+        if (this.pending.delete(reqId)) {
+          reject(new Error(formatError("E_RPC_TIMEOUT", { name })));
+        }
+      }, CALL_TIMEOUT_MS);
+      this.pending.set(reqId, {
+        name,
+        returns: desc.returns,
+        resolve,
+        reject,
+        cancelTimeout
+      });
+      this.send(FrameType.CALL, encodeCall({ reqId, rpcId: desc.index, params: encoded }));
+    });
+  }
+  async requestOwnership(entity, id) {
+    const result = await this.call("requestOwnership", { entity, id });
+    return result?.granted === true;
+  }
+  onReply(payload) {
+    const reply = decodeReply(payload);
+    const p = this.pending.get(reply.reqId);
+    if (!p) return;
+    this.pending.delete(reply.reqId);
+    p.cancelTimeout();
+    if (!reply.ok) {
+      p.reject(new Error(reply.error));
+      return;
+    }
+    if (!p.returns) {
+      p.resolve(void 0);
+      return;
+    }
+    try {
+      p.resolve(decodeFields(p.returns, reply.result));
+    } catch (err) {
+      p.reject(new Error(`${p.name}: bad reply payload: ${String(err)}`));
+    }
+  }
+  onCall(payload) {
+    const call = decodeCall(payload);
+    const desc = rpcTable(this.rpcSchema).find((r) => r.index === call.rpcId);
+    if (!desc) {
+      this.replyError(call.reqId, formatError("E_RPC_UNKNOWN", { name: String(call.rpcId) }));
+      return;
+    }
+    let params;
+    try {
+      params = decodeFields(desc.params, call.params);
+    } catch (err) {
+      this.replyError(
+        call.reqId,
+        formatError("E_RPC_BAD_PARAMS", { name: desc.name, reason: String(err) })
+      );
+      return;
+    }
+    const impl = this.impls.get(desc.name);
+    if (!impl) {
+      this.replyError(
+        call.reqId,
+        formatError("E_RPC_REJECTED", {
+          name: desc.name,
+          reason: "no client implementation \u2014 pass it in joinRoom({ rpc })"
+        })
+      );
+      return;
+    }
+    let result;
+    try {
+      result = impl(params);
+    } catch (err) {
+      this.replyError(call.reqId, err instanceof Error ? err.message : String(err));
+      return;
+    }
+    if (isThenable(result)) {
+      Promise.resolve(result).then(
+        (v) => this.replyOk(desc, call.reqId, v),
+        (err) => this.replyError(call.reqId, err instanceof Error ? err.message : String(err))
+      );
+      return;
+    }
+    this.replyOk(desc, call.reqId, result);
+  }
+  replyOk(desc, reqId, result) {
+    let bytes;
+    try {
+      bytes = desc.returns ? encodeFields(desc.returns, result ?? {}) : new Uint8Array(0);
+    } catch (err) {
+      this.replyError(reqId, err instanceof Error ? err.message : String(err));
+      return;
+    }
+    this.send(FrameType.REPLY, encodeReply({ reqId, ok: true, result: bytes }));
+  }
+  replyError(reqId, error) {
+    this.send(FrameType.REPLY, encodeReply({ reqId, ok: false, error }));
+  }
+  rejectPending(error) {
+    for (const [reqId, p] of [...this.pending]) {
+      this.pending.delete(reqId);
+      p.cancelTimeout();
+      p.reject(error);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Messages, presence, events
+  // -------------------------------------------------------------------------
+  message(target, bytes) {
+    const wire = target === "all" ? { kind: "all" } : typeof target === "string" ? { kind: "client", clientId: target } : { kind: "role", role: target.role };
+    this.send(FrameType.MSG, encodeMsg({ target: wire, payload: bytes }));
+  }
+  onMessage(cb) {
+    this.messageListeners.add(cb);
+    return () => {
+      this.messageListeners.delete(cb);
+    };
+  }
+  get clients() {
+    const coll = this.store.plain.clients;
+    if (!coll) return [];
+    const out = [];
+    for (const [, value] of coll) out.push(value);
+    return out;
+  }
+  get link() {
+    return this.linkOverride ?? linkForUrl(this.options.url, this.roomId);
+  }
+  on(event, cb) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(cb);
+    return () => {
+      set?.delete(cb);
+    };
+  }
+  emit(event, value) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const cb of [...set]) cb(value);
+  }
+  setStatus(status) {
+    if (this.status === status) return;
+    this.status = status;
+    this.options.onStatus?.(status);
+    this.emit("status", status);
+  }
+};
+function resolveKey(explicit, schema, url) {
+  if (explicit !== void 0 && explicit !== "") return explicit;
+  if (schema?.project !== void 0 && schema.project !== "") return schema.project;
+  if (isLocalUrl(url)) return "dev";
+  throw new Error(
+    "irtio: this schema has no project id. Run `npx irtio init` (it writes irtio.json and puts the project id in irtio/schema.ts), or pass `key` to joinRoom."
+  );
+}
+
+// src/index.ts
+function callProxy(session) {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, prop) {
+      if (typeof prop !== "string") return void 0;
+      let fn = cache.get(prop);
+      if (!fn) {
+        fn = prop === "requestOwnership" ? (entity, id) => session.requestOwnership(entity, id) : (params) => session.call(prop, params ?? {});
+        cache.set(prop, fn);
+      }
+      return fn;
+    }
+  });
+}
+async function joinRoom(schema, options = {}) {
+  const url = resolveUrl(options.url);
+  const key = resolveKey(options.key, schema, url);
+  const explicitRoom = options.room !== void 0;
+  const fromLocation = !explicitRoom && currentLocation() !== void 0;
+  const roomId = explicitRoom ? roomIdFrom(options.room ?? "") : fromLocation ? roomIdFromLocation() : "";
+  const session = new Session({
+    schema,
+    url,
+    key,
+    roomId,
+    publishLocation: fromLocation,
+    role: options.role,
+    name: options.name,
+    rpc: options.rpc,
+    writeIntervalMs: options.writeIntervalMs,
+    transport: options.transport,
+    scheduler: options.scheduler,
+    onFrame: options.onFrame,
+    onStatus: options.onStatus
+  });
+  await session.start();
+  return makeRoom(session);
+}
+function makeRoom(session) {
+  const call = callProxy(session);
+  const room = {
+    get me() {
+      return session.me;
+    },
+    get id() {
+      return session.roomId;
+    },
+    get link() {
+      return session.link;
+    },
+    get tick() {
+      return session.tick;
+    },
+    get status() {
+      return session.status;
+    },
+    get rtt() {
+      return session.rtt;
+    },
+    get state() {
+      return session.store.view;
+    },
+    get clients() {
+      return session.clients;
+    },
+    call,
+    requestOwnership: (entity, id) => session.requestOwnership(entity, id),
+    message: (target, bytes) => session.message(target, bytes),
+    onMessage: (cb) => session.onMessage(cb),
+    on: (event, cb) => session.on(event, cb),
+    flush: () => session.flush(),
+    leave: () => session.leave()
+  };
+  return room;
+}
+async function joinRelay(options = {}) {
+  const url = resolveUrl(options.url);
+  const explicitRoom = options.room !== void 0;
+  const fromLocation = !explicitRoom && currentLocation() !== void 0;
+  const roomId = explicitRoom ? roomIdFrom(options.room ?? "") : fromLocation ? roomIdFromLocation() : "";
+  const session = new Session({
+    schema: void 0,
+    url,
+    key: options.key ?? resolveKey(void 0, void 0, url),
+    roomId,
+    publishLocation: fromLocation,
+    role: options.role,
+    name: options.name,
+    transport: options.transport,
+    scheduler: options.scheduler,
+    onFrame: options.onFrame,
+    onStatus: options.onStatus
+  });
+  await session.start();
+  return {
+    get me() {
+      return session.me;
+    },
+    get id() {
+      return session.roomId;
+    },
+    get link() {
+      return session.link;
+    },
+    get status() {
+      return session.status;
+    },
+    get rtt() {
+      return session.rtt;
+    },
+    get clients() {
+      return session.clients;
+    },
+    message: (target, bytes) => session.message(target, bytes),
+    onMessage: (cb) => session.onMessage(cb),
+    on: (event, cb) => session.on(event, cb),
+    leave: () => session.leave()
+  };
+}
+export {
+  CALL_TIMEOUT_MS,
+  ClientStore,
+  DEFAULT_REGION,
+  DEFAULT_WRITE_INTERVAL_MS,
+  DEV_PORT,
+  E_CONNECT_FAILED,
+  PING_INTERVAL_MS,
+  RESIM_DEPTH,
+  Session,
+  defaultScheduler,
+  joinRelay,
+  joinRoom,
+  linkForUrl,
+  resolveUrl,
+  roomIdFrom,
+  webSocketTransport
+};