trellis 3.1.35 → 3.2.2

package/dist/realtime.bundle.js

@@ -0,0 +1,1100 @@
+// src/client/reactive.ts
+var Signal = class {
+  _value;
+  _subs = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this._value = initial;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    if (Object.is(this._value, v)) return;
+    this._value = v;
+    for (const fn of this._subs) {
+      try {
+        fn(v);
+      } catch {
+      }
+    }
+  }
+  /** Subscribe to changes. Immediately called with current value. */
+  subscribe(fn) {
+    this._subs.add(fn);
+    try {
+      fn(this._value);
+    } catch {
+    }
+    return () => {
+      this._subs.delete(fn);
+    };
+  }
+  /** Read without tracking. */
+  peek() {
+    return this._value;
+  }
+  /** Whether any subscriber is registered. */
+  hasSubscribers() {
+    return this._subs.size > 0;
+  }
+};
+
+// src/realtime/room.ts
+var RealtimeRoom = class _RealtimeRoom {
+  id;
+  transport;
+  myState;
+  peers = /* @__PURE__ */ new Map();
+  /** Sender timestamps from presence messages (not local lastSeen). */
+  presenceTsByPeer = /* @__PURE__ */ new Map();
+  channelHandlers = /* @__PURE__ */ new Map();
+  _presence = new Signal([]);
+  now;
+  heartbeatMs;
+  timeoutMs;
+  heartbeatTimer;
+  unsubscribe;
+  closed = false;
+  pendingReplay = null;
+  /** Ids of broadcasts already delivered — keeps replay idempotent (G-Set). */
+  seenMsgIds = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.transport = opts.transport;
+    this.id = opts.transport.id;
+    this.myState = opts.initialPresence ?? {};
+    this.now = opts.now ?? (() => Date.now());
+    this.heartbeatMs = opts.heartbeatMs ?? 2e3;
+    this.timeoutMs = opts.timeoutMs ?? 6e3;
+    this.unsubscribe = this.transport.onMessage((m) => this.handle(m));
+    this.recomputePresence();
+  }
+  /** Join a room and announce presence. */
+  static join(opts) {
+    const room = new _RealtimeRoom(opts);
+    room.announceHello();
+    room.announcePresence();
+    room.startHeartbeat();
+    return room;
+  }
+  // -------------------------------------------------------------------------
+  // Presence
+  // -------------------------------------------------------------------------
+  /** The local peer id. */
+  get selfId() {
+    return this.id;
+  }
+  /** Current local presence state. */
+  getSelfState() {
+    return this.myState;
+  }
+  /** Merge a partial update into local presence and broadcast it. */
+  setPresence(partial) {
+    this.myState = { ...this.myState, ...partial };
+    this.recomputePresence();
+    this.announcePresence();
+  }
+  /** Replace local presence wholesale and broadcast it. */
+  replacePresence(state) {
+    this.myState = state;
+    this.recomputePresence();
+    this.announcePresence();
+  }
+  /** All peers including self (self first). */
+  getPresence() {
+    return this._presence.value;
+  }
+  /** Peers excluding self. */
+  getOthers() {
+    return this._presence.value.filter((p) => !p.self);
+  }
+  /** Subscribe to presence changes. Called immediately with current peers. */
+  onPresence(cb) {
+    const unsub = this._presence.subscribe(cb);
+    this.flushPendingReplay();
+    return unsub;
+  }
+  /** Reactive presence signal (for framework adapters). */
+  get presenceSignal() {
+    return this._presence;
+  }
+  // -------------------------------------------------------------------------
+  // Broadcast pub/sub
+  // -------------------------------------------------------------------------
+  /**
+   * Fire-and-forget broadcast to all other peers on a channel. Returns the
+   * stable message id assigned to this broadcast — persist it alongside an
+   * optimistic local render so an echoed copy (relay replay, reconnect) is
+   * deduplicated by id rather than re-rendered.
+   */
+  broadcast(channel, event, payload) {
+    const id = this.newMsgId();
+    if (this.closed) return id;
+    this.seenMsgIds.add(id);
+    this.transport.send({
+      v: 1,
+      t: "msg",
+      from: this.id,
+      channel,
+      event,
+      payload,
+      ts: this.now(),
+      id
+    });
+    return id;
+  }
+  newMsgId() {
+    const rand = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : Math.random().toString(36).slice(2);
+    return `${this.id}:${rand}`;
+  }
+  /** Subscribe to broadcasts on a channel. Returns an unsubscribe fn. */
+  on(channel, handler) {
+    let set = this.channelHandlers.get(channel);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.channelHandlers.set(channel, set);
+    }
+    set.add(handler);
+    this.flushPendingReplay();
+    return () => {
+      set.delete(handler);
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  /**
+   * Apply a relay replay batch (chat history, text snapshot, presence).
+   * Used when reconnecting to a hub with {@link RelayPersistence}.
+   */
+  replay(messages) {
+    for (const message of messages) {
+      this.integrateRemote(message);
+    }
+  }
+  /** Announce departure and tear down. */
+  leave() {
+    if (this.closed) return;
+    this.closed = true;
+    try {
+      this.transport.send({ v: 1, t: "bye", from: this.id, ts: this.now() });
+    } catch {
+    }
+    if (this.heartbeatTimer !== void 0) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+    this.unsubscribe();
+    this.transport.close();
+  }
+  // -------------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------------
+  handle(message) {
+    if (this.closed) return;
+    if (message.t === "replay") {
+      this.pendingReplay = message.messages;
+      this.flushPendingReplay();
+      return;
+    }
+    if (message.from === this.id) return;
+    this.integrateRemote(message);
+  }
+  flushPendingReplay() {
+    if (!this.pendingReplay || this.pendingReplay.length === 0) return;
+    if (!this.hasActiveSubscribers()) return;
+    const batch = this.pendingReplay;
+    this.pendingReplay = null;
+    this.replay(batch);
+  }
+  hasActiveSubscribers() {
+    if (this._presence.hasSubscribers()) return true;
+    for (const handlers of this.channelHandlers.values()) {
+      if (handlers.size > 0) return true;
+    }
+    return false;
+  }
+  integrateRemote(message) {
+    switch (message.t) {
+      case "hello":
+        this.announcePresence();
+        break;
+      case "presence":
+        this.upsertPeer(message.from, message.state, message.ts);
+        break;
+      case "bye":
+        if (this.peers.delete(message.from)) {
+          this.presenceTsByPeer.delete(message.from);
+          this.recomputePresence();
+        }
+        break;
+      case "msg": {
+        if (message.id !== void 0 && this.seenMsgIds.has(message.id)) return;
+        const handlers = this.channelHandlers.get(message.channel);
+        if (!handlers || handlers.size === 0) return;
+        if (message.id !== void 0) this.seenMsgIds.add(message.id);
+        const event = {
+          from: message.from,
+          channel: message.channel,
+          event: message.event,
+          payload: message.payload,
+          ts: message.ts,
+          id: message.id
+        };
+        for (const handler of handlers) {
+          try {
+            handler(event);
+          } catch {
+          }
+        }
+        break;
+      }
+      case "replay":
+        break;
+    }
+  }
+  upsertPeer(id, state, ts) {
+    const prevTs = this.presenceTsByPeer.get(id) ?? 0;
+    if (ts < prevTs) {
+      const existing = this.peers.get(id);
+      if (existing) existing.lastSeen = this.now();
+      return;
+    }
+    this.presenceTsByPeer.set(id, ts);
+    this.peers.set(id, { id, state, lastSeen: this.now(), self: false });
+    this.recomputePresence();
+  }
+  announceHello() {
+    this.transport.send({ v: 1, t: "hello", from: this.id });
+  }
+  announcePresence() {
+    this.transport.send({
+      v: 1,
+      t: "presence",
+      from: this.id,
+      state: this.myState,
+      ts: this.now()
+    });
+  }
+  startHeartbeat() {
+    if (this.heartbeatMs <= 0 || typeof setInterval !== "function") {
+      return;
+    }
+    this.heartbeatTimer = setInterval(() => {
+      this.announcePresence();
+      this.pruneExpired();
+    }, this.heartbeatMs);
+  }
+  pruneExpired() {
+    const cutoff = this.now() - this.timeoutMs;
+    let changed = false;
+    for (const [id, peer] of this.peers) {
+      if (peer.lastSeen < cutoff) {
+        this.peers.delete(id);
+        this.presenceTsByPeer.delete(id);
+        changed = true;
+      }
+    }
+    if (changed) this.recomputePresence();
+  }
+  recomputePresence() {
+    const self = {
+      id: this.id,
+      state: this.myState,
+      lastSeen: this.now(),
+      self: true
+    };
+    const others = [...this.peers.values()].sort(
+      (a, b) => a.id.localeCompare(b.id)
+    );
+    this._presence.value = [self, ...others];
+  }
+};
+
+// src/realtime/memory-hub.ts
+var MemoryHub = class {
+  transports = /* @__PURE__ */ new Set();
+  /** Create a transport bound to this hub for the given peer id. */
+  connect(id) {
+    const transport = new MemoryRealtimeTransport(this, id);
+    this.transports.add(transport);
+    return transport;
+  }
+  /** Number of currently connected transports. */
+  size() {
+    return this.transports.size;
+  }
+  /** @internal */
+  _broadcast(from, message) {
+    for (const transport of this.transports) {
+      if (transport === from) continue;
+      transport._deliver(message);
+    }
+  }
+  /** @internal */
+  _remove(transport) {
+    this.transports.delete(transport);
+  }
+};
+var MemoryRealtimeTransport = class {
+  id;
+  hub;
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  constructor(hub, id) {
+    this.hub = hub;
+    this.id = id;
+  }
+  send(message) {
+    if (this.closed) return;
+    this.hub._broadcast(this, message);
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.hub._remove(this);
+    this.handlers.clear();
+  }
+  /** @internal */
+  _deliver(message) {
+    if (this.closed) return;
+    for (const handler of this.handlers) {
+      try {
+        handler(message);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/realtime/broadcast-channel-transport.ts
+var BroadcastChannelTransport = class {
+  id;
+  bc;
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  constructor(opts) {
+    this.id = opts.id;
+    const Impl = opts.BroadcastChannelImpl ?? globalThis.BroadcastChannel;
+    if (!Impl) {
+      throw new Error(
+        "BroadcastChannelTransport requires BroadcastChannel or opts.BroadcastChannelImpl."
+      );
+    }
+    this.bc = new Impl(opts.channel);
+    const onIncoming = (event) => {
+      const message = event.data;
+      if (!message || typeof message !== "object" || message.v !== 1) return;
+      for (const handler of this.handlers) {
+        try {
+          handler(message);
+        } catch {
+        }
+      }
+    };
+    if (this.bc.addEventListener) {
+      this.bc.addEventListener("message", onIncoming);
+    } else {
+      this.bc.onmessage = onIncoming;
+    }
+  }
+  send(message) {
+    if (this.closed) return;
+    this.bc.postMessage(message);
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.handlers.clear();
+    try {
+      this.bc.close();
+    } catch {
+    }
+  }
+};
+
+// src/realtime/websocket-relay-transport.ts
+var WebSocketRelayTransport = class {
+  id;
+  ws;
+  handlers = /* @__PURE__ */ new Set();
+  closed = false;
+  pending = [];
+  constructor(opts) {
+    this.id = opts.id;
+    const WS = opts.WebSocketImpl ?? globalThis.WebSocket;
+    if (!WS) {
+      throw new Error(
+        "WebSocketRelayTransport requires WebSocket or opts.WebSocketImpl."
+      );
+    }
+    this.ws = new WS(opts.url);
+    this.ws.addEventListener("open", () => this.flushPending());
+    this.ws.addEventListener("message", (event) => {
+      let message;
+      try {
+        message = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      if (!message || typeof message !== "object" || message.v !== 1) return;
+      for (const handler of this.handlers) {
+        try {
+          handler(message);
+        } catch {
+        }
+      }
+    });
+    this.ws.addEventListener("close", () => {
+      if (!this.closed) this.pending = [];
+    });
+  }
+  send(message) {
+    if (this.closed) return;
+    if (this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(message));
+      return;
+    }
+    this.pending.push(message);
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.pending = [];
+    this.handlers.clear();
+    try {
+      this.ws.close();
+    } catch {
+    }
+  }
+  flushPending() {
+    if (this.ws.readyState !== 1) return;
+    const batch = this.pending.splice(0);
+    for (const message of batch) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+};
+
+// src/realtime/durable-object-relay-transport.ts
+var DEFAULT_RECONNECT = {
+  maxAttempts: 0,
+  baseDelayMs: 500,
+  maxDelayMs: 1e4
+};
+function defaultBuildUrl(opts) {
+  let url = opts.url;
+  if (opts.room) {
+    url = `${url.replace(/\/$/, "")}/${encodeURIComponent(opts.room)}`;
+  }
+  if (opts.auth) {
+    url += `${url.includes("?") ? "&" : "?"}token=${encodeURIComponent(opts.auth)}`;
+  }
+  return url;
+}
+var DurableObjectRelayTransport = class {
+  id;
+  url;
+  WS;
+  reconnect;
+  maxPending;
+  ws = null;
+  handlers = /* @__PURE__ */ new Set();
+  pending = [];
+  closed = false;
+  attempts = 0;
+  reconnectTimer = null;
+  constructor(opts) {
+    this.id = opts.id;
+    const WS = opts.WebSocketImpl ?? globalThis.WebSocket;
+    if (!WS) {
+      throw new Error(
+        "DurableObjectRelayTransport requires WebSocket or opts.WebSocketImpl."
+      );
+    }
+    this.WS = WS;
+    this.url = (opts.buildUrl ?? defaultBuildUrl)({
+      url: opts.url,
+      room: opts.room,
+      auth: opts.auth
+    });
+    this.reconnect = opts.reconnect === false ? null : { ...DEFAULT_RECONNECT, ...opts.reconnect ?? {} };
+    this.maxPending = opts.maxPending ?? 128;
+    this.open();
+  }
+  send(message) {
+    if (this.closed) return;
+    if (this.ws && this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(message));
+      return;
+    }
+    this.pending.push(message);
+    if (this.pending.length > this.maxPending) {
+      this.pending.splice(0, this.pending.length - this.maxPending);
+    }
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+    this.pending = [];
+    this.handlers.clear();
+    try {
+      this.ws?.close();
+    } catch {
+    }
+    this.ws = null;
+  }
+  open() {
+    if (this.closed) return;
+    const ws = new this.WS(this.url);
+    this.ws = ws;
+    ws.addEventListener("open", () => {
+      if (this.closed) return;
+      this.attempts = 0;
+      try {
+        ws.send(JSON.stringify({ v: 1, t: "hello", from: this.id }));
+      } catch {
+      }
+      this.flushPending();
+    });
+    ws.addEventListener("message", (event) => {
+      const data = event.data;
+      let message;
+      try {
+        message = JSON.parse(String(data));
+      } catch {
+        return;
+      }
+      if (!message || typeof message !== "object" || message.v !== 1) return;
+      for (const handler of this.handlers) {
+        try {
+          handler(message);
+        } catch {
+        }
+      }
+    });
+    ws.addEventListener("close", () => {
+      if (this.ws === ws) this.ws = null;
+      this.scheduleReconnect();
+    });
+    ws.addEventListener("error", () => {
+    });
+  }
+  scheduleReconnect() {
+    if (this.closed || !this.reconnect || this.reconnectTimer) return;
+    if (this.reconnect.maxAttempts > 0 && this.attempts >= this.reconnect.maxAttempts) {
+      return;
+    }
+    const delay = Math.min(
+      this.reconnect.baseDelayMs * 2 ** this.attempts,
+      this.reconnect.maxDelayMs
+    );
+    this.attempts += 1;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.open();
+    }, delay);
+    this.reconnectTimer?.unref?.();
+  }
+  flushPending() {
+    if (!this.ws || this.ws.readyState !== 1) return;
+    const batch = this.pending.splice(0);
+    for (const message of batch) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+};
+
+// src/realtime/presence.ts
+function createPresenceTransport(opts) {
+  if (opts.transport) return opts.transport;
+  if (opts.relayUrl) {
+    return new DurableObjectRelayTransport({
+      id: opts.peerId,
+      url: opts.relayUrl,
+      room: opts.room,
+      auth: opts.auth,
+      WebSocketImpl: opts.WebSocketImpl
+    });
+  }
+  return new BroadcastChannelTransport({
+    id: opts.peerId,
+    channel: `presence:${opts.room}`,
+    BroadcastChannelImpl: opts.BroadcastChannelImpl
+  });
+}
+function joinPresence(opts) {
+  return RealtimeRoom.join({
+    transport: createPresenceTransport(opts),
+    initialPresence: opts.initialPresence,
+    heartbeatMs: opts.heartbeatMs,
+    timeoutMs: opts.timeoutMs,
+    now: opts.now
+  });
+}
+
+// src/realtime/relay-persistence.ts
+var DEFAULT_MAX_CHAT = 200;
+var DEFAULT_MAX_TEXT_OPS = 2e3;
+function chatKey(msg) {
+  return msg.id ?? `${msg.from}:${msg.ts}`;
+}
+function tieKey(msg) {
+  if (msg.t === "msg") return chatKey(msg);
+  if (msg.t === "presence" || msg.t === "bye") return msg.from;
+  return "";
+}
+function messageTs(msg) {
+  if (msg.t === "presence" || msg.t === "bye" || msg.t === "msg") {
+    return msg.ts;
+  }
+  return 0;
+}
+var RelayPersistence = class {
+  maxChat;
+  maxTextOps;
+  presence = /* @__PURE__ */ new Map();
+  /** Chat is a grow-only set keyed by {@link chatKey} — dedup on record. */
+  chatLog = [];
+  chatKeys = /* @__PURE__ */ new Set();
+  textSnapshot = null;
+  textOps = [];
+  constructor(opts = {}) {
+    this.maxChat = opts.maxChat ?? DEFAULT_MAX_CHAT;
+    this.maxTextOps = opts.maxTextOps ?? DEFAULT_MAX_TEXT_OPS;
+  }
+  /** Record an inbound client message (skip `hello` / `replay`). */
+  record(message) {
+    if (message.v !== 1) return;
+    switch (message.t) {
+      case "hello":
+        return;
+      case "replay":
+        return;
+      case "presence":
+        this.presence.set(message.from, message);
+        return;
+      case "bye":
+        this.presence.delete(message.from);
+        return;
+      case "msg":
+        this.recordBroadcast(message);
+        return;
+    }
+  }
+  /** Ordered messages to replay to a peer that just connected. */
+  buildReplay() {
+    const out = [
+      ...this.presence.values(),
+      ...this.chatLog
+    ];
+    if (this.textSnapshot) {
+      out.push(this.textSnapshot);
+    } else {
+      out.push(...this.textOps);
+    }
+    out.sort((a, b) => {
+      const dt = messageTs(a) - messageTs(b);
+      if (dt !== 0) return dt;
+      return tieKey(a).localeCompare(tieKey(b));
+    });
+    return out;
+  }
+  getPresenceCount() {
+    return this.presence.size;
+  }
+  getChatCount() {
+    return this.chatLog.length;
+  }
+  hasTextSnapshot() {
+    return this.textSnapshot !== null;
+  }
+  recordBroadcast(message) {
+    if (message.channel === "chat" && message.event === "message") {
+      const key = chatKey(message);
+      if (this.chatKeys.has(key)) return;
+      this.chatKeys.add(key);
+      this.chatLog.push(message);
+      if (this.chatLog.length > this.maxChat) {
+        const evicted = this.chatLog.splice(0, this.chatLog.length - this.maxChat);
+        for (const m of evicted) this.chatKeys.delete(chatKey(m));
+      }
+      return;
+    }
+    if (message.channel === "text" && message.event === "state") {
+      this.textSnapshot = message;
+      this.textOps = [];
+      return;
+    }
+    if (message.channel === "text" && message.event === "op") {
+      if (this.textSnapshot) return;
+      this.textOps.push(message);
+      if (this.textOps.length > this.maxTextOps) {
+        this.textOps.splice(0, this.textOps.length - this.maxTextOps);
+      }
+    }
+  }
+};
+
+// src/realtime/persistent-channel.ts
+var DEFAULT_MAX_RECORDS = 200;
+var PersistentChannel = class _PersistentChannel {
+  /** Reactive, deduped, `(ts, id)`-sorted message list. */
+  messages = new Signal([]);
+  room;
+  channel;
+  event;
+  store;
+  max;
+  resolveMeta;
+  now;
+  records = [];
+  byId = /* @__PURE__ */ new Map();
+  unsubscribe;
+  disposed = false;
+  constructor(room, channel, opts) {
+    this.room = room;
+    this.channel = channel;
+    this.event = opts.event ?? "message";
+    this.store = opts.store;
+    this.max = opts.max ?? DEFAULT_MAX_RECORDS;
+    this.resolveMeta = opts.resolveMeta;
+    this.now = opts.now ?? (() => Date.now());
+    this.unsubscribe = this.room.on(this.channel, this.handleEvent);
+    void this.hydrate();
+  }
+  /** Create a persistent view over `room`'s `channel`. */
+  static create(room, channel, opts = {}) {
+    return new _PersistentChannel(room, channel, opts);
+  }
+  /**
+   * Optimistically record locally, broadcast to peers, and persist. Returns the
+   * stable message id. The room dedups its own id, so the broadcast never
+   * echoes back into this channel.
+   */
+  send(payload, meta) {
+    const id = this.room.broadcast(this.channel, this.event, payload);
+    this.commitOne({ id, from: this.room.selfId, ts: this.now(), payload, meta });
+    return id;
+  }
+  /** Current records (deduped + sorted). Read without subscribing. */
+  snapshot() {
+    return this.messages.peek();
+  }
+  /** Stop listening. Does not clear the durable store. */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.unsubscribe();
+  }
+  // --- internal --------------------------------------------------------------
+  handleEvent = (event) => {
+    if (event.event !== this.event) return;
+    this.commitOne({
+      id: event.id ?? `${event.from}:${event.ts}`,
+      from: event.from,
+      ts: event.ts,
+      payload: event.payload,
+      meta: this.resolveMeta?.(event)
+    });
+  };
+  async hydrate() {
+    if (!this.store) return;
+    let loaded;
+    try {
+      loaded = await this.store.load();
+    } catch {
+      return;
+    }
+    if (this.disposed) return;
+    let changed = false;
+    for (const rec of loaded) {
+      if (this.add(rec)) changed = true;
+    }
+    if (changed) this.commit();
+  }
+  /** Insert one record and publish if it was new. */
+  commitOne(rec) {
+    if (this.add(rec)) this.commit();
+  }
+  /** Pure insert with dedup + cap. Returns true when a new record was added. */
+  add(rec) {
+    if (!rec || !rec.id || this.byId.has(rec.id)) return false;
+    this.byId.set(rec.id, rec);
+    this.records.push(rec);
+    this.records.sort((a, b) => a.ts - b.ts || a.id.localeCompare(b.id));
+    if (this.records.length > this.max) {
+      const evicted = this.records.splice(0, this.records.length - this.max);
+      for (const m of evicted) this.byId.delete(m.id);
+    }
+    return true;
+  }
+  commit() {
+    this.messages.value = [...this.records];
+    void this.store?.save(this.records);
+  }
+};
+function localStorageChannelStore(key, storage = globalThis.localStorage) {
+  return {
+    load() {
+      try {
+        const raw = storage?.getItem(key);
+        const parsed = raw ? JSON.parse(raw) : [];
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    },
+    save(records) {
+      try {
+        storage?.setItem(key, JSON.stringify(records));
+      } catch {
+      }
+    }
+  };
+}
+
+// src/realtime/text.ts
+function parseId(id) {
+  const at = id.indexOf("@");
+  return {
+    counter: Number(id.slice(0, at)),
+    peer: id.slice(at + 1)
+  };
+}
+function compareSiblings(a, b) {
+  const pa = parseId(a);
+  const pb = parseId(b);
+  if (pa.counter !== pb.counter) return pb.counter - pa.counter;
+  return pb.peer.localeCompare(pa.peer);
+}
+var RealtimeText = class {
+  nodes = /* @__PURE__ */ new Map();
+  counter = 0;
+  peerId;
+  listeners = /* @__PURE__ */ new Set();
+  room;
+  channel;
+  unsubscribe;
+  constructor(opts) {
+    this.peerId = opts.peerId;
+    this.room = opts.room;
+    this.channel = opts.channel ?? "text";
+    if (this.room) {
+      this.unsubscribe = this.room.on(this.channel, (e) => {
+        if (e.from === this.peerId) return;
+        this.onRemote(e.event, e.payload);
+      });
+      this.room.broadcast(this.channel, "state-req", {});
+    }
+  }
+  /** Materialized visible text. */
+  toString() {
+    return this.visibleNodes().map((n) => n.ch).join("");
+  }
+  /** Current length of visible text. */
+  get length() {
+    return this.visibleNodes().length;
+  }
+  /** Insert a string at a visible index. Broadcasts ops when room-bound. */
+  insert(index, str) {
+    if (str.length === 0) return [];
+    const visible = this.visibleNodes();
+    let after = index <= 0 ? null : visible[index - 1]?.id ?? null;
+    const ops = [];
+    for (const ch of str) {
+      const id = this.nextId();
+      const node = { id, ch, after, deleted: false };
+      this.nodes.set(id, node);
+      ops.push({ op: "ins", id, ch, after });
+      after = id;
+    }
+    this.emit();
+    this.publish(ops);
+    return ops;
+  }
+  /** Delete `count` visible characters starting at `index`. */
+  delete(index, count = 1) {
+    if (count <= 0) return [];
+    const visible = this.visibleNodes();
+    const ops = [];
+    for (let k = 0; k < count; k++) {
+      const target = visible[index + k];
+      if (!target) break;
+      const node = this.nodes.get(target.id);
+      if (node && !node.deleted) {
+        node.deleted = true;
+        ops.push({ op: "del", id: node.id });
+      }
+    }
+    if (ops.length > 0) {
+      this.emit();
+      this.publish(ops);
+    }
+    return ops;
+  }
+  /** Apply a single remote op. Returns true if the document changed. */
+  applyOp(op) {
+    if (op.op === "ins") {
+      if (this.nodes.has(op.id)) return false;
+      this.bumpCounter(op.id);
+      this.nodes.set(op.id, {
+        id: op.id,
+        ch: op.ch,
+        after: op.after,
+        deleted: false
+      });
+      return true;
+    }
+    const node = this.nodes.get(op.id);
+    if (!node || node.deleted) return false;
+    node.deleted = true;
+    return true;
+  }
+  /** Apply a batch of remote ops, emitting once. */
+  applyOps(ops) {
+    let changed = false;
+    for (const op of ops) {
+      if (this.applyOp(op)) changed = true;
+    }
+    if (changed) this.emit();
+  }
+  /** Snapshot of all nodes (including tombstones) for state sync. */
+  getNodes() {
+    return [...this.nodes.values()];
+  }
+  /** Merge a remote snapshot of nodes. */
+  mergeNodes(nodes) {
+    let changed = false;
+    for (const incoming of nodes) {
+      this.bumpCounter(incoming.id);
+      const existing = this.nodes.get(incoming.id);
+      if (!existing) {
+        this.nodes.set(incoming.id, { ...incoming });
+        changed = true;
+      } else if (incoming.deleted && !existing.deleted) {
+        existing.deleted = true;
+        changed = true;
+      }
+    }
+    if (changed) this.emit();
+  }
+  /** Subscribe to text changes. Returns an unsubscribe fn. */
+  onChange(cb) {
+    this.listeners.add(cb);
+    return () => {
+      this.listeners.delete(cb);
+    };
+  }
+  /** Detach room bindings. */
+  dispose() {
+    this.unsubscribe?.();
+    this.listeners.clear();
+  }
+  // -------------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------------
+  onRemote(event, payload) {
+    switch (event) {
+      case "op":
+        this.applyOps(payload);
+        break;
+      case "state-req":
+        this.room?.broadcast(this.channel, "state", this.getNodes());
+        break;
+      case "state":
+        this.mergeNodes(payload);
+        break;
+    }
+  }
+  publish(ops) {
+    this.room?.broadcast(this.channel, "op", ops);
+  }
+  visibleNodes() {
+    const children = /* @__PURE__ */ new Map();
+    for (const node of this.nodes.values()) {
+      const list = children.get(node.after);
+      if (list) list.push(node);
+      else children.set(node.after, [node]);
+    }
+    for (const list of children.values()) {
+      list.sort((a, b) => compareSiblings(a.id, b.id));
+    }
+    const result = [];
+    const stack = [...children.get(null) ?? []].reverse();
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (!node.deleted) result.push(node);
+      const kids = children.get(node.id);
+      if (kids) {
+        for (let i = kids.length - 1; i >= 0; i--) stack.push(kids[i]);
+      }
+    }
+    return result;
+  }
+  nextId() {
+    this.counter += 1;
+    return `${this.counter}@${this.peerId}`;
+  }
+  bumpCounter(id) {
+    const { counter } = parseId(id);
+    if (Number.isFinite(counter) && counter > this.counter) {
+      this.counter = counter;
+    }
+  }
+  emit() {
+    const text = this.toString();
+    for (const cb of this.listeners) {
+      try {
+        cb(text);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/realtime/types.ts
+var REALTIME_PROTOCOL = 1;
+export {
+  BroadcastChannelTransport,
+  DEFAULT_MAX_CHAT,
+  DEFAULT_MAX_RECORDS,
+  DEFAULT_MAX_TEXT_OPS,
+  DurableObjectRelayTransport,
+  MemoryHub,
+  MemoryRealtimeTransport,
+  PersistentChannel,
+  REALTIME_PROTOCOL,
+  RealtimeRoom,
+  RealtimeText,
+  RelayPersistence,
+  WebSocketRelayTransport,
+  createPresenceTransport,
+  joinPresence,
+  localStorageChannelStore
+};