ooxml-core 0.14.0 → 0.15.0

package/dist/teams/index.cjs

@@ -0,0 +1,2207 @@
+'use strict';
+
+var Y = require('yjs');
+var awarenessProtocol = require('y-protocols/awareness');
+var decoding = require('lib0/decoding');
+var encoding = require('lib0/encoding');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Y__namespace = /*#__PURE__*/_interopNamespace(Y);
+var awarenessProtocol__namespace = /*#__PURE__*/_interopNamespace(awarenessProtocol);
+var decoding__namespace = /*#__PURE__*/_interopNamespace(decoding);
+var encoding__namespace = /*#__PURE__*/_interopNamespace(encoding);
+
+// src/collab/emitter.ts
+var Emitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) this.listeners.set(event, set = /* @__PURE__ */ new Set());
+    set.add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, payload) {
+    for (const listener of [...this.listeners.get(event) ?? []]) {
+      try {
+        listener(payload);
+      } catch (error) {
+        queueMicrotask(() => {
+          throw error;
+        });
+      }
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/teams/peer.ts
+function createPeer(selfId, peerId, factory, createStream, config, tracks, callbacks) {
+  const pc = factory(config);
+  const polite = selfId < peerId;
+  let makingOffer = false;
+  let ignoreOffer = false;
+  let closed = false;
+  const fail = (error) => {
+    if (!closed) callbacks.onError(error instanceof Error ? error : new Error(String(error)));
+  };
+  const audio = pc.addTransceiver("audio", { direction: "sendrecv" });
+  const video = pc.addTransceiver("video", { direction: "sendrecv" });
+  if (tracks.audio) void audio.sender.replaceTrack(tracks.audio).catch(fail);
+  if (tracks.video) void video.sender.replaceTrack(tracks.video).catch(fail);
+  let remote = null;
+  pc.ontrack = ({ track, streams }) => {
+    const stream = streams[0] ?? remote ?? createStream();
+    if (!streams[0] && !stream.getTracks().includes(track)) stream.addTrack(track);
+    if (stream !== remote) {
+      remote = stream;
+      callbacks.onStream(stream);
+    }
+  };
+  pc.onicecandidate = ({ candidate }) => {
+    if (candidate) callbacks.sendCandidate(candidate);
+  };
+  pc.onconnectionstatechange = () => {
+    callbacks.onConnection(pc.connectionState);
+    if (pc.connectionState === "failed") pc.restartIce?.();
+  };
+  pc.onnegotiationneeded = () => {
+    void (async () => {
+      try {
+        makingOffer = true;
+        await pc.setLocalDescription();
+        const d = pc.localDescription;
+        if (d && (d.type === "offer" || d.type === "answer") && d.sdp)
+          callbacks.sendDescription({ type: d.type, sdp: d.sdp });
+      } catch (error) {
+        fail(error);
+      } finally {
+        makingOffer = false;
+      }
+    })();
+  };
+  return {
+    async setTracks(next) {
+      if ("audio" in next) await audio.sender.replaceTrack(next.audio ?? null);
+      if ("video" in next) await video.sender.replaceTrack(next.video ?? null);
+    },
+    async receiveDescription(description) {
+      try {
+        const collision = description.type === "offer" && (makingOffer || pc.signalingState !== "stable");
+        ignoreOffer = !polite && collision;
+        if (ignoreOffer) return;
+        await pc.setRemoteDescription(description);
+        if (description.type === "offer") {
+          await pc.setLocalDescription();
+          const d = pc.localDescription;
+          if (d?.sdp && (d.type === "answer" || d.type === "offer"))
+            callbacks.sendDescription({ type: d.type, sdp: d.sdp });
+        }
+      } catch (error) {
+        fail(error);
+      }
+    },
+    async receiveCandidate(candidate) {
+      try {
+        await pc.addIceCandidate(candidate);
+      } catch (error) {
+        if (!ignoreOffer) fail(error);
+      }
+    },
+    close() {
+      closed = true;
+      pc.onnegotiationneeded = pc.onicecandidate = pc.ontrack = pc.onconnectionstatechange = null;
+      pc.close();
+    }
+  };
+}
+
+// src/teams/call.ts
+var EMPTY = { audio: false, video: false, screen: false, hand: false };
+var asConnection = (s) => s === "connected" || s === "connecting" || s === "disconnected" || s === "failed" || s === "closed" ? s : "new";
+function defaults() {
+  const g = globalThis;
+  const PC = g.RTCPeerConnection;
+  const MS = g.MediaStream;
+  const nav = g.navigator;
+  return {
+    pc: (config) => {
+      if (!PC) throw new Error("RTCPeerConnection is not available in this environment");
+      return new PC(config);
+    },
+    stream: () => {
+      if (!MS) throw new Error("MediaStream is not available in this environment");
+      return new MS();
+    },
+    ...nav?.mediaDevices ? { media: nav.mediaDevices } : {}
+  };
+}
+function createCallSession(options) {
+  const env = defaults();
+  const makePc = options.createPeerConnection ?? env.pc;
+  const makeStream = options.createStream ?? env.stream;
+  const media = options.mediaDevices ?? env.media;
+  const maxParticipants = options.maxParticipants ?? 12;
+  const events = new Emitter();
+  const self = options.user;
+  const remotes = /* @__PURE__ */ new Map();
+  const local = {
+    audio: null,
+    camera: null,
+    screen: null
+  };
+  let state = { ...EMPTY };
+  let status = "idle";
+  let selfStream = null;
+  const setStatus = (next) => {
+    status = next;
+    events.emit("status", next);
+  };
+  const videoTrack = () => local.screen ?? local.camera;
+  const rebuildSelfStream = () => {
+    const tracks = [local.audio, videoTrack()].filter((t) => t !== null);
+    if (tracks.length === 0) return void (selfStream = null);
+    const stream = makeStream();
+    for (const t of tracks) stream.addTrack(t);
+    selfStream = stream;
+  };
+  const list = () => [
+    {
+      id: self.id,
+      name: self.name,
+      self: true,
+      state,
+      connection: "connected",
+      stream: selfStream
+    },
+    ...[...remotes].map(([id, r]) => ({
+      id,
+      name: r.name,
+      self: false,
+      state: r.state,
+      connection: r.connection,
+      stream: r.stream
+    }))
+  ];
+  const publish = () => events.emit("participants", list());
+  const send = (signal) => options.signaling.send(signal);
+  const announceState = () => send({ type: "state", from: self.id, state });
+  const fail = (error) => events.emit("error", error instanceof Error ? error : new Error(String(error)));
+  const ensurePeer = (id, name, remoteState) => {
+    const existing = remotes.get(id);
+    if (existing) {
+      existing.name = name;
+      existing.state = remoteState;
+      return existing;
+    }
+    if (remotes.size + 1 >= maxParticipants) {
+      fail(new Error(`Call is full (${maxParticipants} participants)`));
+      return null;
+    }
+    const config = {
+      iceServers: options.iceServers ?? [],
+      ...options.iceTransportPolicy ? { iceTransportPolicy: options.iceTransportPolicy } : {}
+    };
+    const remote = {
+      name,
+      state: remoteState,
+      connection: "new",
+      stream: null,
+      peer: createPeer(
+        self.id,
+        id,
+        makePc,
+        makeStream,
+        config,
+        { audio: local.audio, video: videoTrack() },
+        {
+          sendDescription: (description) => send({ type: "description", from: self.id, to: id, description }),
+          sendCandidate: (candidate) => send({ type: "candidate", from: self.id, to: id, candidate }),
+          onStream: (stream) => {
+            remote.stream = stream;
+            publish();
+          },
+          onConnection: (s) => {
+            remote.connection = asConnection(s);
+            publish();
+          },
+          onError: fail
+        }
+      )
+    };
+    remotes.set(id, remote);
+    return remote;
+  };
+  const drop = (id) => {
+    const r = remotes.get(id);
+    if (!r) return;
+    r.peer.close();
+    remotes.delete(id);
+    publish();
+  };
+  const hello = (to, reply = false) => send({
+    type: "hello",
+    from: self.id,
+    name: self.name,
+    state,
+    ...to ? { to } : {},
+    ...reply ? { reply } : {}
+  });
+  const onSignal = (signal) => {
+    if (signal.from === self.id) return;
+    switch (signal.type) {
+      case "hello":
+        if (signal.to && signal.to !== self.id) return;
+        if (ensurePeer(signal.from, signal.name, signal.state) && !signal.reply)
+          hello(signal.from, true);
+        publish();
+        return;
+      case "bye":
+        return drop(signal.from);
+      case "state": {
+        const r = remotes.get(signal.from);
+        if (r) r.state = signal.state;
+        return publish();
+      }
+      case "description":
+        if (signal.to === self.id)
+          void remotes.get(signal.from)?.peer.receiveDescription(signal.description);
+        return;
+      case "candidate":
+        if (signal.to === self.id)
+          void remotes.get(signal.from)?.peer.receiveCandidate(signal.candidate);
+        return;
+    }
+  };
+  const setVideoEverywhere = async () => {
+    const track = videoTrack();
+    await Promise.all([...remotes.values()].map((r) => r.peer.setTracks({ video: track })));
+    rebuildSelfStream();
+    publish();
+  };
+  const watchEnd = (track, onEnd) => {
+    track.onended = onEnd;
+  };
+  return {
+    roomId: options.roomId,
+    get status() {
+      return status;
+    },
+    participants: list,
+    on: (event, listener) => events.on(event, listener),
+    async join(want = {}) {
+      if (status === "joining" || status === "connected") return;
+      setStatus("joining");
+      const audio = want.audio ?? true;
+      const video = want.video ?? true;
+      if (media && (audio || video)) {
+        let stream = null;
+        for (const c of [
+          { audio, video },
+          { audio, video: false },
+          { audio: false, video }
+        ]) {
+          if (!c.audio && !c.video) continue;
+          try {
+            stream = await media.getUserMedia(c);
+            break;
+          } catch (error) {
+            if (c.audio && c.video) fail(error);
+          }
+        }
+        for (const t of stream?.getTracks() ?? []) {
+          if (t.kind === "audio") local.audio = t;
+          else if (t.kind === "video") local.camera = t;
+        }
+      }
+      state = { ...EMPTY, audio: Boolean(local.audio), video: Boolean(local.camera) };
+      rebuildSelfStream();
+      options.signaling.connect({
+        open: () => {
+          hello();
+          setStatus("connected");
+          publish();
+        },
+        close: () => {
+        },
+        message: onSignal,
+        error: fail
+      });
+      publish();
+    },
+    leave() {
+      if (status === "left" || status === "idle") return;
+      send({ type: "bye", from: self.id });
+      for (const id of [...remotes.keys()]) drop(id);
+      for (const t of [local.audio, local.camera, local.screen]) t?.stop();
+      local.audio = local.camera = local.screen = null;
+      selfStream = null;
+      options.signaling.disconnect();
+      setStatus("left");
+      publish();
+    },
+    toggleMic() {
+      if (!local.audio) return;
+      local.audio.enabled = !local.audio.enabled;
+      state = { ...state, audio: local.audio.enabled };
+      announceState();
+      publish();
+    },
+    async toggleCamera() {
+      if (local.camera) {
+        local.camera.stop();
+        local.camera = null;
+      } else if (media) {
+        try {
+          const s = await media.getUserMedia({ video: true });
+          local.camera = s.getTracks().find((t) => t.kind === "video") ?? null;
+        } catch (error) {
+          return fail(error);
+        }
+      }
+      state = { ...state, video: Boolean(local.camera) };
+      await setVideoEverywhere();
+      announceState();
+    },
+    async startScreenShare() {
+      if (local.screen || !media?.getDisplayMedia) return;
+      try {
+        const s = await media.getDisplayMedia({ video: true });
+        const track = s.getTracks().find((t) => t.kind === "video") ?? null;
+        if (!track) return;
+        local.screen = track;
+        watchEnd(track, () => void this.stopScreenShare());
+      } catch (error) {
+        return fail(error);
+      }
+      state = { ...state, screen: true };
+      await setVideoEverywhere();
+      announceState();
+    },
+    async stopScreenShare() {
+      if (!local.screen) return;
+      local.screen.stop();
+      local.screen = null;
+      state = { ...state, screen: false };
+      await setVideoEverywhere();
+      announceState();
+    },
+    toggleHand() {
+      state = { ...state, hand: !state.hand };
+      announceState();
+      publish();
+    }
+  };
+}
+
+// src/collab/validation.ts
+var DEFAULT_COLOR = "#4c8bf5";
+var ROOM_ID_REGEX = /^[a-zA-Z0-9_-]{1,128}$/u;
+var HEX_COLOR_REGEX = /^#[0-9a-fA-F]{6}$/u;
+function isValidRoomId(roomId) {
+  return typeof roomId === "string" && ROOM_ID_REGEX.test(roomId);
+}
+function validateRoomId(roomId) {
+  if (!isValidRoomId(roomId)) {
+    throw new Error(
+      `Invalid collaboration room ID: "${String(roomId)}". Must be 1-128 alphanumeric characters, hyphens, or underscores.`
+    );
+  }
+  return roomId;
+}
+function isValidId(value, max = 160) {
+  return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+function stripHtmlTags(text) {
+  let result = "";
+  let insideTag = false;
+  for (const char of text) {
+    if (char === "<") insideTag = true;
+    else if (char === ">") insideTag = false;
+    else if (!insideTag) result += char;
+  }
+  return result;
+}
+function sanitizeUserName(name, fallback = "Anonymous") {
+  if (typeof name !== "string") return fallback;
+  const trimmed = stripHtmlTags(name).trim().slice(0, 64);
+  return trimmed || fallback;
+}
+function sanitizeColor(color, fallback = DEFAULT_COLOR) {
+  return typeof color === "string" && HEX_COLOR_REGEX.test(color) ? color : fallback;
+}
+function sanitizeAvatarUrl(url) {
+  if (typeof url !== "string") return void 0;
+  try {
+    const { protocol } = new URL(url);
+    if (protocol === "https:" || protocol === "http:" || protocol === "data:") return url;
+  } catch {
+  }
+  return void 0;
+}
+var LOOPBACK_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+function isMixedContentBlocked(serverUrl, pageProtocol = globalThis.location?.protocol) {
+  if (pageProtocol !== "https:") return false;
+  let parsed;
+  try {
+    parsed = new URL(serverUrl);
+  } catch {
+    return false;
+  }
+  return parsed.protocol === "ws:" && !LOOPBACK_HOSTS.includes(parsed.hostname);
+}
+
+// src/collab/identity.ts
+var COLLABORATION_ROLES = [
+  "owner",
+  "collaborator",
+  "viewer"
+];
+function sanitizeRole(value) {
+  return COLLABORATION_ROLES.includes(value) ? value : void 0;
+}
+function canWrite(role) {
+  return role !== "viewer";
+}
+var CURSOR_PALETTE = [
+  "#ef4444",
+  "#f97316",
+  "#eab308",
+  "#22c55e",
+  "#06b6d4",
+  "#3b82f6",
+  "#8b5cf6",
+  "#ec4899"
+];
+function assignUserColor(seed, palette = CURSOR_PALETTE) {
+  if (palette.length === 0) return DEFAULT_COLOR;
+  let hash = 0;
+  const text = String(seed);
+  for (let i = 0; i < text.length; i++) hash = hash * 31 + text.charCodeAt(i) | 0;
+  return palette[Math.abs(hash) % palette.length] ?? DEFAULT_COLOR;
+}
+function createClientId() {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.randomUUID) return cryptoApi.randomUUID();
+  return `c${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+}
+function clientKey(clientId) {
+  if (!isValidId(clientId)) throw new Error("Invalid collaboration client ID");
+  return Array.from(clientId, (character) => character.codePointAt(0).toString(16)).join("_");
+}
+function createIdGenerator(clientId, prefix = "cid") {
+  const key = clientKey(clientId);
+  let counter = 0;
+  return (kind) => {
+    const safeKind = kind.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 24) || "item";
+    return `${prefix}-${safeKind}-${key}-${++counter}`;
+  };
+}
+
+// src/teams/model.ts
+var MAX_MESSAGE_CHARS = 2e4;
+var MAX_CHANNEL_NAME_CHARS = 80;
+var MAX_ATTACHMENTS = 20;
+var MAX_EMOJI_CHARS = 16;
+var OFFICE_EXTENSIONS = {
+  docx: "docx",
+  docm: "docx",
+  dotx: "docx",
+  xlsx: "xlsx",
+  xlsm: "xlsx",
+  xltx: "xlsx",
+  pptx: "pptx",
+  pptm: "pptx",
+  potx: "pptx",
+  ppsx: "pptx",
+  vsdx: "vsdx",
+  vsdm: "vsdx",
+  vssx: "vsdx",
+  vstx: "vsdx"
+};
+function detectOfficeKind(name, mime) {
+  const ext = name.split(".").pop()?.toLowerCase() ?? "";
+  const byExt = OFFICE_EXTENSIONS[ext];
+  if (byExt) return byExt;
+  const m = mime?.toLowerCase() ?? "";
+  if (m.includes("wordprocessingml")) return "docx";
+  if (m.includes("spreadsheetml")) return "xlsx";
+  if (m.includes("presentationml")) return "pptx";
+  if (m.includes("visio")) return "vsdx";
+  return "other";
+}
+function sanitizeMessageText(text) {
+  if (typeof text !== "string") return "";
+  const cleaned = stripHtmlTags(text).replace(
+    /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu,
+    ""
+  );
+  return cleaned.trim().slice(0, MAX_MESSAGE_CHARS);
+}
+function sanitizeChannelName(name) {
+  if (typeof name !== "string") return "";
+  return stripHtmlTags(name).replace(/\s+/gu, " ").trim().slice(0, MAX_CHANNEL_NAME_CHARS);
+}
+function sanitizeEmoji(emoji) {
+  if (typeof emoji !== "string") return "";
+  const cleaned = emoji.trim();
+  if (!cleaned || [...cleaned].length > MAX_EMOJI_CHARS || /[\s<>&"'|]/u.test(cleaned)) return "";
+  return cleaned;
+}
+function sanitizeAttachment(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const name = sanitizeChannelName(r.name);
+  if (!name) return null;
+  const mime = typeof r.mime === "string" && r.mime.length <= 120 ? r.mime : void 0;
+  const out = { name, kind: detectOfficeKind(name, mime) };
+  if (typeof r.size === "number" && Number.isFinite(r.size) && r.size >= 0) out.size = r.size;
+  if (mime) out.mime = mime;
+  if (typeof r.url === "string" && /^(https?:\/\/|\/(?!\/))/iu.test(r.url) && r.url.length <= 2048)
+    out.url = r.url;
+  return out;
+}
+function sanitizeAttachments(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw.slice(0, MAX_ATTACHMENTS)) {
+    const a = sanitizeAttachment(item);
+    if (a) out.push(a);
+  }
+  return out;
+}
+
+// src/teams/chat.ts
+var CHANNELS = "teams:channels";
+var REACTIONS = "teams:reactions";
+var messagesMap = (channelId) => `teams:messages:${channelId}`;
+var SEP = "|";
+var isChannelId = (id) => isValidId(id, 64) && /^[\w-]+$/u.test(id);
+function readChannel(id, raw) {
+  if (!(raw instanceof Y__namespace.Map)) return null;
+  const name = sanitizeChannelName(raw.get("name"));
+  if (!name || !isChannelId(id)) return null;
+  return {
+    id,
+    name,
+    topic: sanitizeChannelName(raw.get("topic")),
+    kind: raw.get("kind") === "direct" ? "direct" : "channel",
+    createdAt: Number(raw.get("createdAt")) || 0,
+    createdBy: String(raw.get("createdBy") ?? "").slice(0, 160),
+    archived: raw.get("archived") === true
+  };
+}
+function readMessage(channelId, id, raw, reactions) {
+  if (!(raw instanceof Y__namespace.Map) || !isValidId(id)) return null;
+  const authorId = raw.get("authorId");
+  if (!isValidId(authorId)) return null;
+  const deleted = raw.get("deleted") === true;
+  const replyTo = raw.get("replyTo");
+  const editedAt = Number(raw.get("editedAt"));
+  const message = {
+    id,
+    channelId,
+    authorId,
+    authorName: sanitizeChannelName(raw.get("authorName")) || "Unknown",
+    text: deleted ? "" : sanitizeMessageText(raw.get("text")),
+    ts: Number(raw.get("ts")) || 0,
+    deleted,
+    attachments: deleted ? [] : sanitizeAttachments(raw.get("attachments")),
+    reactions
+  };
+  if (isValidId(replyTo)) message.replyTo = replyTo;
+  if (editedAt > 0) message.editedAt = editedAt;
+  return message;
+}
+var slug = (name) => name.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-|-$/gu, "") || "channel";
+function createChatStore(doc, user) {
+  const nextId = createIdGenerator(String(doc.clientID), "m");
+  const channelMap = doc.getMap(CHANNELS);
+  const reactionMap = doc.getMap(REACTIONS);
+  const channelMessages = (channelId) => doc.getMap(messagesMap(channelId));
+  const listeners = /* @__PURE__ */ new Set();
+  let scheduled = false;
+  const onUpdate = () => {
+    if (scheduled) return;
+    scheduled = true;
+    queueMicrotask(() => {
+      scheduled = false;
+      for (const l of [...listeners]) l();
+    });
+  };
+  doc.on("update", onUpdate);
+  const reactionsFor = (messageId) => {
+    const out = {};
+    const prefix = messageId + SEP;
+    reactionMap.forEach((on, key) => {
+      if (!on || !key.startsWith(prefix)) return;
+      const [, emoji, userId] = key.split(SEP);
+      if (!emoji || !userId || !sanitizeEmoji(emoji)) return;
+      (out[emoji] ??= []).push(userId);
+    });
+    return out;
+  };
+  return {
+    channels() {
+      const out = [];
+      channelMap.forEach((raw, id) => {
+        const c = readChannel(id, raw);
+        if (c) out.push(c);
+      });
+      return out.sort((a, b) => a.createdAt - b.createdAt || a.name.localeCompare(b.name));
+    },
+    createChannel({ name, topic = "", kind = "channel", id }) {
+      const clean = sanitizeChannelName(name);
+      if (!clean) return null;
+      const channelId = id && isChannelId(id) ? id : `${slug(clean)}-${nextId("c").slice(-6)}`;
+      if (channelMap.has(channelId)) return readChannel(channelId, channelMap.get(channelId));
+      doc.transact(() => {
+        const m = new Y__namespace.Map();
+        m.set("name", clean);
+        m.set("topic", sanitizeChannelName(topic));
+        m.set("kind", kind);
+        m.set("createdAt", Date.now());
+        m.set("createdBy", user.id);
+        m.set("archived", false);
+        channelMap.set(channelId, m);
+      });
+      return readChannel(channelId, channelMap.get(channelId));
+    },
+    archiveChannel(channelId, archived = true) {
+      channelMap.get(channelId)?.set("archived", archived);
+    },
+    messages(channelId) {
+      if (!isChannelId(channelId)) return [];
+      const out = [];
+      channelMessages(channelId).forEach((raw, id) => {
+        const m = readMessage(channelId, id, raw, reactionsFor(id));
+        if (m) out.push(m);
+      });
+      return out.sort((a, b) => a.ts - b.ts || a.id.localeCompare(b.id));
+    },
+    post(channelId, { text, replyTo, attachments }) {
+      if (!isChannelId(channelId) || !channelMap.has(channelId)) return null;
+      const clean = sanitizeMessageText(text);
+      const files = sanitizeAttachments(attachments);
+      if (!clean && files.length === 0) return null;
+      const id = nextId("m");
+      doc.transact(() => {
+        const m = new Y__namespace.Map();
+        m.set("authorId", user.id);
+        m.set("authorName", user.name);
+        m.set("text", clean);
+        m.set("ts", Date.now());
+        m.set("deleted", false);
+        if (replyTo && isValidId(replyTo)) m.set("replyTo", replyTo);
+        if (files.length) m.set("attachments", files);
+        channelMessages(channelId).set(id, m);
+      });
+      return readMessage(channelId, id, channelMessages(channelId).get(id), {});
+    },
+    edit(channelId, messageId, text) {
+      if (!isChannelId(channelId)) return false;
+      const m = channelMessages(channelId).get(messageId);
+      const clean = sanitizeMessageText(text);
+      if (!m || m.get("authorId") !== user.id || m.get("deleted") === true || !clean) return false;
+      doc.transact(() => {
+        m.set("text", clean);
+        m.set("editedAt", Date.now());
+      });
+      return true;
+    },
+    remove(channelId, messageId) {
+      if (!isChannelId(channelId)) return false;
+      const m = channelMessages(channelId).get(messageId);
+      if (!m || m.get("authorId") !== user.id) return false;
+      m.set("deleted", true);
+      return true;
+    },
+    react(messageId, emoji) {
+      const e = sanitizeEmoji(emoji);
+      if (e && isValidId(messageId)) reactionMap.set([messageId, e, user.id].join(SEP), true);
+    },
+    unreact(messageId, emoji) {
+      const e = sanitizeEmoji(emoji);
+      if (e) reactionMap.delete([messageId, e, user.id].join(SEP));
+    },
+    observe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    destroy() {
+      doc.off("update", onUpdate);
+      listeners.clear();
+    }
+  };
+}
+
+// src/teams/server-config.ts
+var DEFAULT_ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
+var WS_URL = /^wss?:\/\/[^\s/?#]+(?::\d+)?(?:\/[^\s?#]*)?$/iu;
+var ICE_URL = /^(stuns?|turns?):[^\s]+$/iu;
+function wsUrl(value, field, issues) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string" || !WS_URL.test(value.trim())) {
+    issues.push(`${field} must be a ws:// or wss:// URL without query or fragment`);
+    return void 0;
+  }
+  return value.trim().replace(/\/+$/u, "");
+}
+function iceServer(raw, index, issues) {
+  if (!raw || typeof raw !== "object") {
+    issues.push(`iceServers[${index}] must be an object`);
+    return null;
+  }
+  const r = raw;
+  const urls = (Array.isArray(r.urls) ? r.urls : [r.urls]).filter(
+    (u) => typeof u === "string" && ICE_URL.test(u.trim())
+  );
+  if (urls.length === 0) {
+    issues.push(`iceServers[${index}].urls needs a stun: or turn: URL`);
+    return null;
+  }
+  const turn = urls.some((u) => /^turns?:/iu.test(u));
+  if (turn && (typeof r.username !== "string" || typeof r.credential !== "string")) {
+    issues.push(`iceServers[${index}] is a TURN server and needs username and credential`);
+    return null;
+  }
+  return {
+    urls: urls.length === 1 ? urls[0] : urls,
+    ...typeof r.username === "string" ? { username: r.username } : {},
+    ...typeof r.credential === "string" ? { credential: r.credential } : {}
+  };
+}
+function parseServerConfig(input) {
+  const issues = [];
+  const raw = input && typeof input === "object" ? input : {};
+  const syncUrl = wsUrl(raw.syncUrl, "syncUrl", issues);
+  const signalingUrl = wsUrl(raw.signalingUrl, "signalingUrl", issues);
+  const iceRaw = Array.isArray(raw.iceServers) ? raw.iceServers : void 0;
+  const ice = iceRaw ? iceRaw.map((s, i) => iceServer(s, i, issues)).filter((s) => s !== null) : [];
+  const mode = raw.mode === "server" && (syncUrl || signalingUrl) ? "server" : "local";
+  if (raw.mode === "server" && mode === "local")
+    issues.push('mode "server" needs a syncUrl or a signalingUrl; falling back to local');
+  const config = {
+    mode,
+    iceServers: iceRaw ? ice : [...DEFAULT_ICE_SERVERS]
+  };
+  if (syncUrl) config.syncUrl = syncUrl;
+  if (signalingUrl) config.signalingUrl = signalingUrl;
+  if (raw.iceTransportPolicy === "relay" || raw.iceTransportPolicy === "all")
+    config.iceTransportPolicy = raw.iceTransportPolicy;
+  if (typeof raw.token === "string" && raw.token.length > 0 && raw.token.length <= 4096)
+    config.token = raw.token;
+  if (config.iceTransportPolicy === "relay" && !ice.some((s) => [s.urls].flat().some((u) => /^turns?:/iu.test(u))))
+    issues.push('iceTransportPolicy "relay" needs a TURN server, otherwise no call can connect');
+  return { config, issues };
+}
+function endpointUrl(base, roomId, token) {
+  const url = `${base.replace(/\/+$/u, "")}/${encodeURIComponent(roomId)}`;
+  return token ? `${url}?token=${encodeURIComponent(token)}` : url;
+}
+function localServerConfig() {
+  return { mode: "local", iceServers: [...DEFAULT_ICE_SERVERS] };
+}
+
+// src/teams/signaling.ts
+var MAX_SDP_CHARS = 2e5;
+var MAX_SIGNAL_CHARS = 262144;
+var bool = (v) => v === true;
+var parseState = (raw) => {
+  const r = raw && typeof raw === "object" ? raw : {};
+  return { audio: bool(r.audio), video: bool(r.video), screen: bool(r.screen), hand: bool(r.hand) };
+};
+function parseSignal(input) {
+  let raw = input;
+  if (typeof input === "string") {
+    if (input.length > MAX_SIGNAL_CHARS) return null;
+    try {
+      raw = JSON.parse(input);
+    } catch {
+      return null;
+    }
+  }
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (!isValidId(r.from, 128)) return null;
+  const from = r.from;
+  const to = isValidId(r.to, 128) ? r.to : void 0;
+  switch (r.type) {
+    case "hello": {
+      const name = typeof r.name === "string" ? r.name.slice(0, 80) : "";
+      if (!name) return null;
+      const out = { type: "hello", from, name, state: parseState(r.state) };
+      if (to) out.to = to;
+      if (r.reply === true) out.reply = true;
+      return out;
+    }
+    case "bye":
+      return { type: "bye", from };
+    case "state":
+      return { type: "state", from, state: parseState(r.state) };
+    case "description": {
+      const d = r.description;
+      if (!to || !d || d.type !== "offer" && d.type !== "answer") return null;
+      if (typeof d.sdp !== "string" || d.sdp.length > MAX_SDP_CHARS) return null;
+      return { type: "description", from, to, description: { type: d.type, sdp: d.sdp } };
+    }
+    case "candidate": {
+      const c = r.candidate;
+      if (!to || !c || typeof c.candidate !== "string" || c.candidate.length > 2048) return null;
+      const candidate = { candidate: c.candidate };
+      if (typeof c.sdpMid === "string" || c.sdpMid === null) candidate.sdpMid = c.sdpMid;
+      if (typeof c.sdpMLineIndex === "number" || c.sdpMLineIndex === null)
+        candidate.sdpMLineIndex = c.sdpMLineIndex;
+      if (typeof c.usernameFragment === "string") candidate.usernameFragment = c.usernameFragment;
+      return { type: "candidate", from, to, candidate };
+    }
+    default:
+      return null;
+  }
+}
+function createMemorySignalingHub() {
+  const rooms = /* @__PURE__ */ new Map();
+  return {
+    createChannel(roomId) {
+      let mine = null;
+      const room = () => {
+        let set = rooms.get(roomId);
+        if (!set) rooms.set(roomId, set = /* @__PURE__ */ new Set());
+        return set;
+      };
+      return {
+        connect(handlers) {
+          mine = handlers;
+          room().add(handlers);
+          queueMicrotask(() => handlers.open());
+        },
+        send(signal) {
+          const wire = parseSignal(JSON.stringify(signal));
+          if (!wire) return;
+          for (const other of room()) if (other !== mine) queueMicrotask(() => other.message(wire));
+        },
+        disconnect() {
+          if (mine) room().delete(mine);
+          mine = null;
+        }
+      };
+    }
+  };
+}
+function createBroadcastSignaling(options) {
+  let channel = null;
+  return {
+    connect(handlers) {
+      const Impl = options.BroadcastChannel ?? globalThis.BroadcastChannel;
+      if (!Impl) return handlers.error(new Error("BroadcastChannel is not available"));
+      channel = new Impl(`${options.prefix ?? "teams-signal"}:${options.roomId}`);
+      channel.onmessage = (event) => {
+        const signal = parseSignal(event.data);
+        if (signal) handlers.message(signal);
+      };
+      handlers.open();
+    },
+    send(signal) {
+      channel?.postMessage(JSON.stringify(signal));
+    },
+    disconnect() {
+      channel?.close();
+      channel = null;
+    }
+  };
+}
+function createWebSocketSignaling(options) {
+  const { baseDelayMs = 250, maxDelayMs = 1e4 } = options;
+  let socket = null;
+  let timer = null;
+  let failures = 0;
+  let stopped = true;
+  let active = null;
+  const open = () => {
+    if (stopped || !active) return;
+    const handlers = active;
+    const Impl = options.WebSocket ?? globalThis.WebSocket;
+    if (!Impl) return handlers.error(new Error("No WebSocket implementation available"));
+    const ws = new Impl(options.url);
+    socket = ws;
+    ws.onopen = () => {
+      failures = 0;
+      handlers.open();
+    };
+    ws.onmessage = (event) => {
+      const signal = parseSignal(event.data);
+      if (signal) handlers.message(signal);
+    };
+    ws.onerror = () => handlers.error(new Error("Signaling socket error"));
+    ws.onclose = (event) => {
+      socket = null;
+      handlers.close(event.reason);
+      if (stopped) return;
+      timer = setTimeout(open, Math.min(maxDelayMs, baseDelayMs * 2 ** failures++));
+    };
+  };
+  return {
+    connect(handlers) {
+      active = handlers;
+      stopped = false;
+      open();
+    },
+    send(signal) {
+      if (socket && socket.readyState === 1) socket.send(JSON.stringify(signal));
+    },
+    disconnect() {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+      socket?.close();
+      socket = null;
+    }
+  };
+}
+var MAX_UPDATE_BYTES = 32 * 1024 * 1024;
+function validateUpdate(update, maxBytes = MAX_UPDATE_BYTES) {
+  if (!(update instanceof Uint8Array)) return { ok: false, reason: "update must be a Uint8Array" };
+  if (update.byteLength === 0) return { ok: false, reason: "update is empty" };
+  if (update.byteLength > maxBytes)
+    return { ok: false, reason: `update exceeds the ${maxBytes} byte limit` };
+  try {
+    Y__namespace.decodeUpdate(update);
+    return { ok: true };
+  } catch (cause) {
+    return {
+      ok: false,
+      reason: `malformed update: ${cause instanceof Error ? cause.message : String(cause)}`
+    };
+  }
+}
+function applyUpdateSafe(doc, update, origin, options = {}) {
+  const checked = options.validate === false ? update instanceof Uint8Array && update.byteLength <= (options.maxBytes ?? MAX_UPDATE_BYTES) ? { ok: true } : { ok: false, reason: "invalid or oversized update" } : validateUpdate(update, options.maxBytes);
+  if (!checked.ok) return checked;
+  try {
+    Y__namespace.applyUpdate(doc, update, origin);
+    return { ok: true };
+  } catch (cause) {
+    return {
+      ok: false,
+      reason: `could not apply update: ${cause instanceof Error ? cause.message : String(cause)}`
+    };
+  }
+}
+var CHUNK = 32768;
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK)
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  return btoa(binary);
+}
+function fromBase64(text) {
+  try {
+    const binary = atob(text);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return bytes;
+  } catch {
+    return null;
+  }
+}
+
+// src/teams/view.ts
+var callRoomId = (workspaceId, channelId) => `call-${workspaceId}-${channelId}`.slice(0, 128);
+var asAvailability = (v) => v === "busy" || v === "away" ? v : "available";
+function channelViews(input) {
+  const { channels, messagesOf, selfId, lastRead, peers, workspaceId, selectedId, inCallRoom } = input;
+  return channels.filter((c) => !c.archived).map((c) => {
+    const read = lastRead[c.id] ?? 0;
+    const unread = c.id === selectedId ? 0 : messagesOf(c.id).filter((m) => !m.deleted && m.authorId !== selfId && m.ts > read).length;
+    const room = callRoomId(workspaceId, c.id);
+    return {
+      id: c.id,
+      name: c.name,
+      topic: c.topic,
+      kind: c.kind,
+      unread,
+      live: inCallRoom === room || peers.some((p) => p.callRoom === room)
+    };
+  });
+}
+function peopleViews(self, peers) {
+  return [
+    { ...self, self: true },
+    ...peers.map((p) => ({
+      id: `peer-${p.clientId}`,
+      name: p.userName,
+      color: p.userColor,
+      self: false,
+      availability: asAvailability(p.availability),
+      inCall: Boolean(p.callRoom)
+    }))
+  ];
+}
+var typingNames = (peers, channelId) => peers.filter((p) => p.typingIn === channelId).map((p) => p.userName);
+function filesOf(messages) {
+  const out = [];
+  for (const m of messages) {
+    if (m.deleted) continue;
+    for (const a of m.attachments)
+      out.push({
+        name: a.name,
+        kind: a.kind,
+        ...a.size !== void 0 ? { size: a.size } : {},
+        ...a.url ? { url: a.url } : {},
+        author: m.authorName,
+        ts: m.ts,
+        messageId: m.id
+      });
+  }
+  return out.sort((a, b) => b.ts - a.ts);
+}
+function allFilesOf(channels, messagesOf) {
+  return channels.filter((c) => !c.archived).flatMap(
+    (c) => filesOf(messagesOf(c.id)).map((f) => ({ ...f, channelId: c.id, channelName: c.name }))
+  ).sort((a, b) => b.ts - a.ts);
+}
+function searchMessages(channels, messagesOf, query, limit = 50) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [];
+  const hits = [];
+  for (const c of channels) {
+    if (c.archived) continue;
+    for (const m of messagesOf(c.id))
+      if (!m.deleted && (m.text.toLowerCase().includes(q) || m.authorName.toLowerCase().includes(q)))
+        hits.push({ channelId: c.id, channelName: c.name, message: m });
+  }
+  return hits.sort((a, b) => b.message.ts - a.message.ts).slice(0, limit);
+}
+
+// src/collab/broadcast-transport.ts
+var isBytes = (value) => ArrayBuffer.isView(value) && Object.prototype.toString.call(value) === "[object Uint8Array]";
+var isEnvelope = (value) => {
+  const envelope = value;
+  return !!envelope && typeof envelope.from === "string" && (envelope.kind === "hello" || envelope.kind === "data" && isBytes(envelope.data));
+};
+function createBroadcastTransport(options) {
+  const roomId = validateRoomId(options.roomId);
+  const Channel = options.BroadcastChannel ?? globalThis.BroadcastChannel;
+  const self = Math.random().toString(36).slice(2) + Date.now().toString(36);
+  let channel = null;
+  let handlers = null;
+  const close = () => {
+    if (!channel) return;
+    channel.onmessage = null;
+    channel.close();
+    channel = null;
+  };
+  return {
+    connect(next) {
+      close();
+      handlers = next;
+      if (!Channel) {
+        next.error(new Error("BroadcastChannel is not available in this environment."));
+        next.close("unavailable");
+        return;
+      }
+      const open = new Channel(`${options.prefix ?? "ooxml-collab:"}${roomId}`);
+      channel = open;
+      open.onmessage = ({ data }) => {
+        if (channel !== open || !isEnvelope(data) || data.from === self) return;
+        if (data.kind === "hello") handlers?.peer?.();
+        else handlers?.message(new Uint8Array(data.data));
+      };
+      next.open();
+      open.postMessage({ kind: "hello", from: self });
+    },
+    send(data) {
+      try {
+        channel?.postMessage({ kind: "data", from: self, data });
+      } catch (cause) {
+        handlers?.error(cause instanceof Error ? cause : new Error(String(cause)));
+      }
+    },
+    disconnect() {
+      const was = handlers;
+      const open = channel !== null;
+      close();
+      handlers = null;
+      if (open) was?.close("disconnected");
+    }
+  };
+}
+
+// src/collab/presence.ts
+var PRESENCE_FIELD = "presence";
+var STALE_PRESENCE_MS = 3e4;
+var PRESENCE_HEARTBEAT_MS = 1e4;
+var BROADCAST_THROTTLE_MS = 50;
+function sanitizeIdentity(raw) {
+  return {
+    userName: sanitizeUserName(raw.userName),
+    userColor: sanitizeColor(raw.userColor, DEFAULT_COLOR),
+    userAvatar: sanitizeAvatarUrl(raw.userAvatar),
+    role: sanitizeRole(raw.role)
+  };
+}
+function isPresenceFresh(lastUpdated, now = Date.now(), staleMs = STALE_PRESENCE_MS) {
+  const updatedAt = new Date(lastUpdated).getTime();
+  return !Number.isNaN(updatedAt) && now - updatedAt <= staleMs;
+}
+function derivePresence(states, localClientId, sanitizePayload, options = {}) {
+  const { now = Date.now(), staleMs = STALE_PRESENCE_MS } = options;
+  const users = [];
+  for (const [clientId, state] of states) {
+    if (clientId === localClientId) continue;
+    const raw = state?.[PRESENCE_FIELD];
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const record = raw;
+    const payload = sanitizePayload(record);
+    if (!payload) continue;
+    const lastUpdated = typeof record.lastUpdated === "string" ? record.lastUpdated : "";
+    if (!isPresenceFresh(lastUpdated, now, staleMs)) continue;
+    users.push({ ...sanitizeIdentity(record), clientId, lastUpdated, ...payload });
+  }
+  return users;
+}
+
+// src/collab/awareness.ts
+function createPresencePublisher(awareness, identity, initial, options = {}) {
+  const throttleMs = options.throttleMs ?? BROADCAST_THROTTLE_MS;
+  const clock = options.now ?? Date.now;
+  const local = { ...initial };
+  let lastBroadcast = 0;
+  let pending = null;
+  const publish = () => {
+    lastBroadcast = clock();
+    awareness.setLocalStateField(PRESENCE_FIELD, {
+      ...identity,
+      ...local,
+      lastUpdated: new Date(clock()).toISOString()
+    });
+  };
+  const cancel = () => {
+    if (pending !== null) clearTimeout(pending);
+    pending = null;
+  };
+  const update = (patch) => {
+    const keys = Object.keys(patch);
+    if (!keys.some((key) => patch[key] !== local[key])) return;
+    Object.assign(local, patch);
+    const elapsed = clock() - lastBroadcast;
+    if (elapsed >= throttleMs) {
+      cancel();
+      publish();
+    } else if (pending === null) {
+      pending = setTimeout(() => {
+        pending = null;
+        publish();
+      }, throttleMs - elapsed);
+    }
+  };
+  publish();
+  lastBroadcast = 0;
+  return {
+    update,
+    flush: () => {
+      cancel();
+      publish();
+    },
+    dispose: cancel
+  };
+}
+function removeAwarenessStatesLocally(awareness, clients) {
+  const states = awareness?.states;
+  if (!awareness || !states) return [];
+  const removed = clients.filter((clientId) => states.delete(clientId));
+  if (removed.length > 0) {
+    const change = { added: [], updated: [], removed };
+    awareness.emit?.("change", [change, "peer-departed"]);
+    awareness.emit?.("update", [change, "peer-departed"]);
+  }
+  return removed;
+}
+
+// src/collab/lifecycle.ts
+var COLLAB_LEAVE_MESSAGE = "ooxml-core:collab-leave";
+var DEPARTURE_CHANNEL = "ooxml-core:collab-departures";
+function isLeaveMessage(data, expected) {
+  if (typeof data === "string") return data === expected;
+  return typeof data === "object" && data !== null && data.type === expected;
+}
+function registerTeardown(options) {
+  const target = options.target ?? globalThis.window;
+  if (!target) return () => {
+  };
+  const { leave, rejoin } = options;
+  const leaveMessage = options.leaveMessage ?? COLLAB_LEAVE_MESSAGE;
+  let left = false;
+  const doLeave = () => {
+    if (left) return;
+    left = true;
+    leave();
+  };
+  const onPageHide = (event) => {
+    if (event.persisted === true && !rejoin) return;
+    doLeave();
+  };
+  const onBeforeUnload = () => {
+    const allowed = typeof options.leaveOnBeforeUnload === "function" ? options.leaveOnBeforeUnload() : options.leaveOnBeforeUnload !== false;
+    if (allowed) doLeave();
+  };
+  const onPageShow = (event) => {
+    if (event.persisted !== true || !left || !rejoin) return;
+    left = false;
+    rejoin();
+  };
+  const onMessage = (event) => {
+    if (isLeaveMessage(event.data, leaveMessage)) doLeave();
+  };
+  const listeners = {
+    pagehide: onPageHide,
+    beforeunload: onBeforeUnload,
+    pageshow: onPageShow,
+    message: onMessage
+  };
+  for (const [type, listener] of Object.entries(listeners)) target.addEventListener(type, listener);
+  return () => {
+    for (const [type, listener] of Object.entries(listeners))
+      target.removeEventListener(type, listener);
+  };
+}
+function defaultFactory(name) {
+  const scope = globalThis;
+  return scope.BroadcastChannel ? new scope.BroadcastChannel(name) : null;
+}
+function createDepartureChannel(roomId, awareness, factory, channelName = DEPARTURE_CHANNEL) {
+  const channel = defaultFactory(channelName);
+  if (!channel) return { announce: () => {
+  }, dispose: () => {
+  } };
+  const selfId = awareness.clientID;
+  channel.onmessage = (event) => {
+    const data = event.data;
+    if (typeof data !== "object" || data === null) return;
+    const notice = data;
+    if (notice.channel !== channelName || notice.roomId !== roomId) return;
+    if (typeof notice.clientId !== "number" || notice.clientId === selfId) return;
+    removeAwarenessStatesLocally(awareness, [notice.clientId]);
+  };
+  let closed = false;
+  return {
+    announce: () => {
+      if (closed || typeof selfId !== "number") return;
+      channel.postMessage({ channel: channelName, roomId, clientId: selfId });
+    },
+    dispose: () => {
+      if (closed) return;
+      closed = true;
+      channel.onmessage = null;
+      channel.close();
+    }
+  };
+}
+
+// src/collab/policy.ts
+var INITIAL_SYNC_GRACE_MS = 3e3;
+function createSyncGate(onOpen, graceMs = INITIAL_SYNC_GRACE_MS) {
+  let opened = false;
+  let timer = null;
+  const clear = () => {
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+  };
+  const open = () => {
+    clear();
+    if (opened) return;
+    opened = true;
+    onOpen();
+  };
+  return {
+    isOpen: () => opened,
+    arm: () => {
+      clear();
+      if (!opened) timer = setTimeout(open, graceMs);
+    },
+    open,
+    reset: () => {
+      clear();
+      opened = false;
+    }
+  };
+}
+
+// src/collab/provider.ts
+var CONNECTION_TIMEOUT_MS = 3e4;
+
+// src/collab/session.ts
+function createCollabSession(options) {
+  const roomId = validateRoomId(options.roomId);
+  const ownsDoc = !options.doc;
+  const doc = options.doc ?? new Y__namespace.Doc();
+  const awareness = new awarenessProtocol.Awareness(doc);
+  const events = new Emitter();
+  const role = options.user.role;
+  const identity = {
+    userName: sanitizeUserName(options.user.name),
+    userColor: sanitizeColor(options.user.color, assignUserColor(doc.clientID)),
+    userAvatar: options.user.avatar,
+    role
+  };
+  const sanitizePayload = options.sanitizePayload ?? (() => ({}));
+  const publisher = createPresencePublisher(
+    awareness,
+    identity,
+    options.initialPresence ?? {}
+  );
+  let destroyed = false;
+  let timeout = null;
+  const gate = createSyncGate(() => {
+    if (destroyed) return;
+    options.onReady?.({ synced: provider.synced });
+    events.emit("ready", void 0);
+  }, options.syncGraceMs ?? INITIAL_SYNC_GRACE_MS);
+  const peers = () => derivePresence(awareness.getStates(), doc.clientID, sanitizePayload);
+  const emitPeers = () => events.emit("peers", peers());
+  awareness.on("change", emitPeers);
+  const provider = options.provider({ doc, awareness, roomId });
+  const clearTimeoutTimer = () => {
+    if (timeout !== null) clearTimeout(timeout);
+    timeout = null;
+  };
+  provider.on("status", (status) => {
+    clearTimeoutTimer();
+    events.emit("status", status);
+    if (status === "connecting")
+      timeout = setTimeout(() => {
+        events.emit("error", new Error("Collaboration connection timed out"));
+        events.emit("status", "error");
+      }, options.connectionTimeoutMs ?? CONNECTION_TIMEOUT_MS);
+    if (status === "connected") gate.arm();
+  });
+  provider.on("synced", (synced) => {
+    events.emit("synced", synced);
+    if (synced) gate.open();
+  });
+  provider.on("error", (error) => events.emit("error", error));
+  const heartbeatMs = options.heartbeatMs ?? PRESENCE_HEARTBEAT_MS;
+  const heartbeat = heartbeatMs > 0 ? setInterval(() => {
+    publisher.flush();
+    emitPeers();
+  }, heartbeatMs) : null;
+  heartbeat?.unref?.();
+  const departure = createDepartureChannel(roomId, awareness);
+  const leave = () => {
+    departure.announce();
+    publisher.dispose();
+    awareness.setLocalState(null);
+    provider.disconnect();
+  };
+  const unregisterTeardown = options.teardown ? registerTeardown({
+    leave,
+    rejoin: () => {
+      publisher.flush();
+      provider.connect();
+    },
+    ...typeof options.teardown === "object" ? options.teardown : {}
+  }) : () => {
+  };
+  const session = {
+    roomId,
+    doc,
+    awareness,
+    clientId: doc.clientID,
+    role,
+    identity,
+    gate,
+    provider,
+    get status() {
+      return provider.status;
+    },
+    get synced() {
+      return provider.synced;
+    },
+    canWrite: () => !destroyed && gate.isOpen() && canWrite(role),
+    peers,
+    updatePresence: (patch) => publisher.update(patch),
+    on: (event, listener) => events.on(event, listener),
+    connect: () => {
+      if (!destroyed) provider.connect();
+    },
+    disconnect: () => {
+      clearTimeoutTimer();
+      gate.reset();
+      provider.disconnect();
+    },
+    destroy: () => {
+      if (destroyed) return;
+      departure.announce();
+      unregisterTeardown();
+      clearTimeoutTimer();
+      if (heartbeat !== null) clearInterval(heartbeat);
+      publisher.dispose();
+      gate.reset();
+      awareness.setLocalState(null);
+      provider.destroy();
+      departure.dispose();
+      awareness.off("change", emitPeers);
+      awareness.destroy();
+      destroyed = true;
+      events.clear();
+      if (ownsDoc) doc.destroy();
+    }
+  };
+  if (options.autoConnect !== false) provider.connect();
+  return session;
+}
+var MESSAGE_SYNC = 0;
+var MESSAGE_AWARENESS = 1;
+var MESSAGE_QUERY_AWARENESS = 3;
+var SYNC_STEP1 = 0;
+var SYNC_STEP2 = 1;
+var SYNC_UPDATE = 2;
+function transportProvider(options) {
+  return (context) => createTransportProvider(context, options);
+}
+function createTransportProvider({ doc, awareness }, { transport, maxMessageBytes = MAX_UPDATE_BYTES }) {
+  const events = new Emitter();
+  let status = "disconnected";
+  let synced = false;
+  let open = false;
+  let destroyed = false;
+  const origin = {};
+  const setStatus = (next) => {
+    if (status === next) return;
+    status = next;
+    events.emit("status", next);
+  };
+  const setSynced = (next) => {
+    if (synced === next) return;
+    synced = next;
+    events.emit("synced", next);
+  };
+  const fail = (reason) => events.emit("error", new Error(reason));
+  const send = (encoder) => {
+    if (open) transport.send(encoding__namespace.toUint8Array(encoder));
+  };
+  const sendStep1 = () => {
+    const encoder = encoding__namespace.createEncoder();
+    encoding__namespace.writeVarUint(encoder, MESSAGE_SYNC);
+    encoding__namespace.writeVarUint(encoder, SYNC_STEP1);
+    encoding__namespace.writeVarUint8Array(encoder, Y__namespace.encodeStateVector(doc));
+    send(encoder);
+  };
+  const sendAwareness = (clients) => {
+    if (clients.length === 0) return;
+    const encoder = encoding__namespace.createEncoder();
+    encoding__namespace.writeVarUint(encoder, MESSAGE_AWARENESS);
+    encoding__namespace.writeVarUint8Array(
+      encoder,
+      awarenessProtocol__namespace.encodeAwarenessUpdate(awareness, clients)
+    );
+    send(encoder);
+  };
+  const handshake = () => {
+    sendStep1();
+    const local = awareness.getLocalState();
+    if (local !== null) awareness.setLocalState(local);
+  };
+  const onDocUpdate = (update, updateOrigin) => {
+    if (updateOrigin === origin || !open) return;
+    const encoder = encoding__namespace.createEncoder();
+    encoding__namespace.writeVarUint(encoder, MESSAGE_SYNC);
+    encoding__namespace.writeVarUint(encoder, SYNC_UPDATE);
+    encoding__namespace.writeVarUint8Array(encoder, update);
+    send(encoder);
+  };
+  const onAwarenessUpdate = (change, updateOrigin) => {
+    if (updateOrigin === origin) return;
+    sendAwareness([...change.added, ...change.updated, ...change.removed]);
+  };
+  const readSync = (decoder) => {
+    const kind = decoding__namespace.readVarUint(decoder);
+    const payload = decoding__namespace.readVarUint8Array(decoder);
+    if (kind === SYNC_STEP1) {
+      const encoder = encoding__namespace.createEncoder();
+      encoding__namespace.writeVarUint(encoder, MESSAGE_SYNC);
+      encoding__namespace.writeVarUint(encoder, SYNC_STEP2);
+      let diff;
+      try {
+        diff = Y__namespace.encodeStateAsUpdate(doc, payload);
+      } catch {
+        return fail("malformed state vector");
+      }
+      encoding__namespace.writeVarUint8Array(encoder, diff);
+      return send(encoder);
+    }
+    if (kind !== SYNC_STEP2 && kind !== SYNC_UPDATE) return fail(`unknown sync message ${kind}`);
+    const result = applyUpdateSafe(doc, payload, origin, { maxBytes: maxMessageBytes });
+    if (!result.ok) return fail(result.reason);
+    if (kind === SYNC_STEP2) setSynced(true);
+  };
+  const onMessage = (data) => {
+    if (destroyed) return;
+    if (!(data instanceof Uint8Array) || data.byteLength === 0 || data.byteLength > maxMessageBytes)
+      return fail("message is empty, not binary, or too large");
+    try {
+      const decoder = decoding__namespace.createDecoder(data);
+      const type = decoding__namespace.readVarUint(decoder);
+      if (type === MESSAGE_SYNC) readSync(decoder);
+      else if (type === MESSAGE_AWARENESS)
+        awarenessProtocol__namespace.applyAwarenessUpdate(
+          awareness,
+          decoding__namespace.readVarUint8Array(decoder),
+          origin
+        );
+      else if (type === MESSAGE_QUERY_AWARENESS) sendAwareness([...awareness.getStates().keys()]);
+    } catch (cause) {
+      fail(`malformed message: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+  };
+  const dropRemotePeers = () => {
+    const remote = [...awareness.getStates().keys()].filter((id) => id !== doc.clientID);
+    if (remote.length > 0) awarenessProtocol__namespace.removeAwarenessStates(awareness, remote, origin);
+  };
+  const connect = () => {
+    if (destroyed) return;
+    setStatus("connecting");
+    transport.connect({
+      open: () => {
+        if (destroyed) return;
+        open = true;
+        setStatus("connected");
+        handshake();
+      },
+      close: () => {
+        open = false;
+        setSynced(false);
+        dropRemotePeers();
+        if (!destroyed) setStatus("disconnected");
+      },
+      message: onMessage,
+      error: (error) => {
+        events.emit("error", error);
+        if (!open) setStatus("error");
+      },
+      peer: () => {
+        if (open && !destroyed) handshake();
+      }
+    });
+  };
+  doc.on("update", onDocUpdate);
+  awareness.on("update", onAwarenessUpdate);
+  return {
+    get status() {
+      return status;
+    },
+    get synced() {
+      return synced;
+    },
+    connect,
+    disconnect: () => {
+      if (destroyed) return;
+      const local = awareness.getLocalState();
+      if (open && local !== null) awareness.setLocalState(null);
+      transport.disconnect();
+      open = false;
+      if (local !== null) awareness.setLocalState(local);
+      setSynced(false);
+      dropRemotePeers();
+      setStatus("disconnected");
+    },
+    destroy: () => {
+      if (destroyed) return;
+      if (open) awareness.setLocalState(null);
+      destroyed = true;
+      open = false;
+      doc.off("update", onDocUpdate);
+      awareness.off("update", onAwarenessUpdate);
+      transport.disconnect();
+      events.clear();
+    },
+    on: (event, listener) => events.on(event, listener)
+  };
+}
+
+// src/collab/websocket-transport.ts
+var OPEN = 1;
+function createWebSocketTransport(options) {
+  const { baseDelayMs = 250, maxDelayMs = 1e4, maxRetries = Infinity } = options;
+  let socket = null;
+  let handlers = null;
+  let timer = null;
+  let failures = 0;
+  let stopped = true;
+  const open = () => {
+    if (stopped || !handlers) return;
+    const active = handlers;
+    const Impl = options.WebSocket ?? globalThis.WebSocket;
+    if (!Impl) return active.error(new Error("No WebSocket implementation available"));
+    if (isMixedContentBlocked(options.url, options.pageProtocol)) {
+      stopped = true;
+      return active.error(new Error("Insecure ws:// connection blocked from an https page"));
+    }
+    const ws = new Impl(options.url);
+    socket = ws;
+    ws.binaryType = "arraybuffer";
+    ws.onopen = () => {
+      failures = 0;
+      active.open();
+    };
+    ws.onmessage = (event) => {
+      const data = event.data;
+      if (data instanceof ArrayBuffer) active.message(new Uint8Array(data));
+      else if (data instanceof Uint8Array) active.message(data);
+      else active.error(new Error("Received a non-binary WebSocket message"));
+    };
+    ws.onerror = () => active.error(new Error("WebSocket error"));
+    ws.onclose = (event) => {
+      if (socket !== ws) return;
+      socket = null;
+      active.close(event.reason);
+      if (stopped) return;
+      if (++failures > maxRetries) {
+        stopped = true;
+        return active.error(new Error("WebSocket reconnect attempts exhausted"));
+      }
+      timer = setTimeout(open, Math.min(maxDelayMs, baseDelayMs * 2 ** (failures - 1)));
+    };
+  };
+  return {
+    connect(next) {
+      handlers = next;
+      stopped = false;
+      failures = 0;
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+      if (socket) socket.close();
+      open();
+    },
+    send(data) {
+      if (socket && socket.readyState === OPEN) socket.send(data);
+    },
+    disconnect() {
+      stopped = true;
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+      const ws = socket;
+      socket = null;
+      if (ws) {
+        ws.onclose = null;
+        ws.close();
+        handlers?.close("disconnected");
+      }
+    }
+  };
+}
+
+// src/teams/workspace.ts
+var AVAILABILITY = ["available", "busy", "away"];
+var safeId = (v) => typeof v === "string" && /^[\w-]{1,64}$/u.test(v) ? v : void 0;
+function sanitizePresence(raw) {
+  const out = {};
+  const channelId = safeId(raw.channelId);
+  const typingIn = safeId(raw.typingIn);
+  const callRoom = typeof raw.callRoom === "string" && /^[\w-]{1,200}$/u.test(raw.callRoom) ? raw.callRoom : void 0;
+  if (channelId) out.channelId = channelId;
+  if (typingIn) out.typingIn = typingIn;
+  if (callRoom) out.callRoom = callRoom;
+  out.availability = AVAILABILITY.includes(raw.availability) ? raw.availability : "available";
+  return out;
+}
+function createTeamsWorkspace(options) {
+  const config = options.config ?? localServerConfig();
+  const user = { id: options.user.id ?? createClientId(), name: options.user.name };
+  const wsCtor = options.WebSocket;
+  const bcCtor = options.BroadcastChannel;
+  const syncTransport = (roomId) => config.mode === "server" && config.syncUrl ? createWebSocketTransport({
+    url: endpointUrl(config.syncUrl, roomId, config.token),
+    ...wsCtor ? { WebSocket: wsCtor } : {}
+  }) : createBroadcastTransport({ roomId, ...bcCtor ? { BroadcastChannel: bcCtor } : {} });
+  const signaling = (roomId) => config.mode === "server" && config.signalingUrl ? createWebSocketSignaling({
+    url: endpointUrl(config.signalingUrl, roomId, config.token),
+    ...wsCtor ? { WebSocket: wsCtor } : {}
+  }) : createBroadcastSignaling({ roomId, ...bcCtor ? { BroadcastChannel: bcCtor } : {} });
+  let chat;
+  const session = createCollabSession({
+    roomId: options.workspaceId,
+    ...options.doc ? { doc: options.doc } : {},
+    provider: transportProvider({ transport: syncTransport(options.workspaceId) }),
+    user: { name: user.name, ...options.user.color ? { color: options.user.color } : {} },
+    initialPresence: { availability: "available" },
+    sanitizePayload: sanitizePresence,
+    teardown: true,
+    // Any writer may seed the default channel; the fixed id makes concurrent seeds converge.
+    onReady: () => {
+      if (chat.channels().length === 0)
+        chat.createChannel({ id: "general", name: "General", topic: "Company-wide announcements" });
+    }
+  });
+  chat = createChatStore(session.doc, user);
+  const calls = /* @__PURE__ */ new Map();
+  return {
+    user,
+    session,
+    chat,
+    config,
+    call(channelId) {
+      const existing = calls.get(channelId);
+      if (existing && existing.status !== "left") return existing;
+      const roomId = `call-${options.workspaceId}-${channelId}`.slice(0, 128);
+      const call = createCallSession({
+        roomId,
+        user,
+        signaling: signaling(roomId),
+        iceServers: config.iceServers,
+        ...config.iceTransportPolicy ? { iceTransportPolicy: config.iceTransportPolicy } : {},
+        ...options.mediaDevices ? { mediaDevices: options.mediaDevices } : {},
+        ...options.createPeerConnection ? { createPeerConnection: options.createPeerConnection } : {},
+        ...options.createStream ? { createStream: options.createStream } : {}
+      });
+      call.on("status", (s) => {
+        if (s === "connected") session.updatePresence({ callRoom: roomId });
+        if (s === "left") session.updatePresence({ callRoom: "" });
+      });
+      calls.set(channelId, call);
+      return call;
+    },
+    setActiveChannel: (channelId) => session.updatePresence({ channelId: channelId ?? "" }),
+    setTyping: (channelId) => session.updatePresence({ typingIn: channelId ?? "" }),
+    setAvailability: (availability) => session.updatePresence({ availability }),
+    destroy() {
+      for (const c of calls.values()) c.leave();
+      chat.destroy();
+      session.destroy();
+    }
+  };
+}
+
+// src/teams/store.ts
+var STORAGE_DOC = "teams:doc:";
+var STORAGE_READ = "teams:read:";
+var MAX_SNAPSHOT_CHARS = 3e6;
+var TYPING_MS = 4e3;
+function restoreDoc(storage, id) {
+  const doc = new Y__namespace.Doc();
+  try {
+    const bytes = fromBase64(storage?.getItem(STORAGE_DOC + id) ?? "");
+    if (bytes) Y__namespace.applyUpdate(doc, bytes);
+  } catch {
+  }
+  return doc;
+}
+function createTeamsClient(options) {
+  const { storage, workspaceId } = options;
+  const doc = restoreDoc(storage, workspaceId);
+  const ws = createTeamsWorkspace({ ...options, doc });
+  const notices = new Emitter();
+  const notice = (text) => notices.emit("notice", text);
+  const listeners = /* @__PURE__ */ new Set();
+  let lastRead = {};
+  try {
+    lastRead = JSON.parse(storage?.getItem(STORAGE_READ + workspaceId) ?? "{}");
+  } catch {
+    lastRead = {};
+  }
+  let selected = "";
+  let query = "";
+  let replyId = "";
+  let editId = "";
+  let availability = "available";
+  let typingTimer;
+  let saveTimer;
+  let destroyed = false;
+  let call = null;
+  const media = () => options.mediaDevices ?? globalThis.navigator?.mediaDevices;
+  const messagesOf = (id) => ws.chat.messages(id);
+  const peers = () => ws.session.peers();
+  const visibleChannels = () => ws.chat.channels().filter((c) => !c.archived);
+  const compute = () => {
+    const channels = visibleChannels();
+    if (!channels.some((c) => c.id === selected)) {
+      selected = channels[0]?.id ?? "";
+      if (selected) ws.setActiveChannel(selected);
+    }
+    if (selected) lastRead[selected] = Date.now();
+    const p = peers();
+    const messages = selected ? messagesOf(selected) : [];
+    const channel = channels.find((c) => c.id === selected) ?? null;
+    const session = call?.session ?? null;
+    const participants = session?.participants() ?? [];
+    const channelName = channels.find((c) => c.id === call?.channelId)?.name ?? "";
+    return {
+      status: ws.session.status,
+      mode: ws.config.mode,
+      user: ws.user,
+      availability,
+      channels: channelViews({
+        channels,
+        messagesOf,
+        selfId: ws.user.id,
+        lastRead,
+        peers: p,
+        workspaceId,
+        selectedId: selected,
+        ...call?.session && call.phase === "connected" ? { inCallRoom: callRoomId(workspaceId, call.channelId) } : {}
+      }),
+      selectedChannelId: selected,
+      channel,
+      messages,
+      files: filesOf(messages),
+      allFiles: allFilesOf(channels, messagesOf),
+      people: peopleViews(
+        {
+          id: ws.user.id,
+          name: ws.user.name,
+          color: ws.session.identity.userColor,
+          availability,
+          inCall: call?.phase === "connected"
+        },
+        p
+      ),
+      typing: selected ? typingNames(p, selected) : [],
+      replyingTo: messages.find((m) => m.id === replyId) ?? null,
+      editing: messages.find((m) => m.id === editId) ?? null,
+      searchQuery: query,
+      searchResults: searchMessages(channels, messagesOf, query),
+      call: call ? {
+        channelId: call.channelId,
+        channelName,
+        phase: call.phase,
+        prejoin: call.prejoin,
+        preview: call.preview,
+        participants,
+        self: participants.find((x) => x.self),
+        startedAt: call.startedAt
+      } : null
+    };
+  };
+  let state = compute();
+  let queued = false;
+  const refresh = () => {
+    if (queued || destroyed) return;
+    queued = true;
+    queueMicrotask(() => {
+      queued = false;
+      if (destroyed) return;
+      state = compute();
+      for (const l of [...listeners]) l();
+    });
+  };
+  const scheduleSave = () => {
+    if (!storage) return;
+    clearTimeout(saveTimer);
+    saveTimer = setTimeout(() => {
+      try {
+        const text = toBase64(Y__namespace.encodeStateAsUpdate(doc));
+        if (text.length <= MAX_SNAPSHOT_CHARS) storage.setItem(STORAGE_DOC + workspaceId, text);
+        storage.setItem(STORAGE_READ + workspaceId, JSON.stringify(lastRead));
+      } catch {
+      }
+    }, 800);
+  };
+  doc.on("update", scheduleSave);
+  const unsubs = [
+    ws.chat.observe(refresh),
+    ws.session.on("peers", refresh),
+    ws.session.on("status", refresh),
+    ws.session.on("error", (e) => notice(e.message))
+  ];
+  const stopPreview = () => {
+    for (const t of call?.preview?.getTracks() ?? []) t.stop();
+    if (call) call.preview = null;
+  };
+  const startPreview = async () => {
+    if (!call || call.phase !== "prejoin" || call.preview || !call.prejoin.video) return;
+    try {
+      const stream = await media()?.getUserMedia({ video: true });
+      if (!stream) return;
+      if (call?.phase === "prejoin" && call.prejoin.video) call.preview = stream;
+      else for (const t of stream.getTracks()) t.stop();
+    } catch (error) {
+      notice(error instanceof Error ? error.message : "Camera unavailable");
+      if (call) call.prejoin = { ...call.prejoin, video: false };
+    }
+  };
+  const server = () => {
+    const { config } = ws;
+    if (config.mode !== "server" || !config.syncUrl) return null;
+    const u = new URL(config.syncUrl);
+    u.protocol = u.protocol === "wss:" ? "https:" : "http:";
+    return { base: u.origin, token: config.token };
+  };
+  const upload = async (file) => {
+    const attachment = {
+      name: file.name,
+      kind: "other",
+      size: file.size,
+      ...file.type ? { mime: file.type } : {}
+    };
+    try {
+      if (options.uploadFile) {
+        attachment.url = (await options.uploadFile(file, { workspaceId })).url;
+        return attachment;
+      }
+      const target = server();
+      if (!target) {
+        notice("No file server configured: sharing the name only");
+        return attachment;
+      }
+      const doFetch = options.fetch ?? globalThis.fetch;
+      const res = await doFetch(
+        `${target.base}/files/${workspaceId}/${encodeURIComponent(file.name)}`,
+        {
+          method: "POST",
+          body: file,
+          ...target.token ? { headers: { Authorization: `Bearer ${target.token}` } } : {}
+        }
+      );
+      if (!res.ok) throw new Error(`Upload failed (${res.status})`);
+      attachment.url = `${target.base}${(await res.json()).url}`;
+    } catch (error) {
+      notice(error instanceof Error ? error.message : "Upload failed");
+    }
+    return attachment;
+  };
+  const act = (fn) => (...args) => {
+    fn(...args);
+    refresh();
+  };
+  const find = (id) => messagesOf(selected).find((m) => m.id === id);
+  const leave = () => {
+    const active = call;
+    if (!active) return;
+    stopPreview();
+    active.session?.leave();
+    for (const f of active.off) f();
+    call = null;
+  };
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    on: (event, listener) => notices.on(event, listener),
+    workspace: ws,
+    select: act((id) => {
+      if (id === selected) return;
+      selected = id;
+      replyId = editId = "";
+      ws.setActiveChannel(id);
+      scheduleSave();
+    }),
+    createChannel: act((name, topic = "") => {
+      const channel = ws.chat.createChannel({ name, topic });
+      if (channel) {
+        selected = channel.id;
+        ws.setActiveChannel(channel.id);
+      }
+    }),
+    async send({ text, files = [] }) {
+      if (!selected) return;
+      clearTimeout(typingTimer);
+      ws.setTyping(void 0);
+      if (editId) {
+        if (!ws.chat.edit(selected, editId, text)) notice("Only your own messages can be edited");
+        editId = "";
+        return refresh();
+      }
+      const attachments = [];
+      for (const file of files) attachments.push(await upload(file));
+      ws.chat.post(selected, { text, ...replyId ? { replyTo: replyId } : {}, attachments });
+      replyId = "";
+      refresh();
+    },
+    startReply: act((id) => {
+      if (find(id)) [replyId, editId] = [id, ""];
+    }),
+    startEdit: act((id) => {
+      const m = find(id);
+      if (m && m.authorId === ws.user.id) [editId, replyId] = [id, ""];
+    }),
+    cancelCompose: act(() => {
+      replyId = editId = "";
+    }),
+    deleteMessage: act((id) => void ws.chat.remove(selected, id)),
+    toggleReaction: act((id, emoji) => {
+      const mine = find(id)?.reactions[emoji]?.includes(ws.user.id);
+      if (mine) ws.chat.unreact(id, emoji);
+      else ws.chat.react(id, emoji);
+    }),
+    notifyTyping() {
+      if (!selected) return;
+      ws.setTyping(selected);
+      clearTimeout(typingTimer);
+      typingTimer = setTimeout(() => ws.setTyping(void 0), TYPING_MS);
+    },
+    setAvailability: act((value) => {
+      availability = value;
+      ws.setAvailability(value);
+    }),
+    search: act((q) => {
+      query = q;
+    }),
+    async fileUrl(attachment) {
+      const target = server();
+      const raw = attachment.url;
+      if (!raw || !target?.token) return raw;
+      let url;
+      try {
+        url = new URL(raw);
+      } catch {
+        return raw;
+      }
+      if (url.origin !== target.base || url.username || url.password) return raw;
+      if (!url.pathname.startsWith("/files/")) return raw;
+      try {
+        const doFetch = options.fetch ?? globalThis.fetch;
+        const res = await doFetch(
+          `${target.base}/files/link${url.pathname.slice("/files".length)}`,
+          {
+            method: "POST",
+            headers: { Authorization: `Bearer ${target.token}` }
+          }
+        );
+        if (!res.ok) throw new Error(`Link failed (${res.status})`);
+        const { url: signed } = await res.json();
+        return `${target.base}${signed}`;
+      } catch (error) {
+        notice(error instanceof Error ? error.message : "Could not open the file");
+        return void 0;
+      }
+    },
+    async openCall(channelId = selected) {
+      if (!channelId) return;
+      if (call?.channelId === channelId) return;
+      leave();
+      if (channelId !== selected) {
+        selected = channelId;
+        ws.setActiveChannel(channelId);
+      }
+      call = {
+        channelId,
+        phase: "prejoin",
+        prejoin: { audio: true, video: true },
+        preview: null,
+        session: null,
+        startedAt: null,
+        off: []
+      };
+      refresh();
+      await startPreview();
+      refresh();
+    },
+    async setPrejoin(next) {
+      if (!call || call.phase !== "prejoin") return;
+      call.prejoin = { ...call.prejoin, ...next };
+      if (next.video === false) stopPreview();
+      refresh();
+      await startPreview();
+      refresh();
+    },
+    async joinCall() {
+      const active = call;
+      if (!active || active.phase !== "prejoin") return;
+      stopPreview();
+      active.phase = "joining";
+      const session = ws.call(active.channelId);
+      active.session = session;
+      active.off.push(
+        session.on("participants", refresh),
+        session.on("error", (e) => notice(e.message)),
+        session.on("status", (s) => {
+          if (s === "connected") {
+            active.phase = "connected";
+            active.startedAt ??= Date.now();
+          }
+          if (s === "left" && call === active) {
+            for (const f of active.off) f();
+            call = null;
+          }
+          refresh();
+        })
+      );
+      refresh();
+      await session.join(active.prejoin);
+      refresh();
+    },
+    leaveCall: act(leave),
+    toggleMic: act(() => call?.session?.toggleMic()),
+    async toggleCamera() {
+      await call?.session?.toggleCamera();
+      refresh();
+    },
+    async toggleScreenShare() {
+      const s = call?.session;
+      if (!s) return;
+      const sharing = s.participants().find((p) => p.self)?.state.screen;
+      await (sharing ? s.stopScreenShare() : s.startScreenShare());
+      refresh();
+    },
+    toggleHand: act(() => call?.session?.toggleHand()),
+    destroy() {
+      destroyed = true;
+      clearTimeout(typingTimer);
+      clearTimeout(saveTimer);
+      try {
+        storage?.setItem(STORAGE_READ + workspaceId, JSON.stringify(lastRead));
+      } catch {
+      }
+      leave();
+      for (const u of unsubs) u();
+      doc.off("update", scheduleSave);
+      listeners.clear();
+      ws.destroy();
+    }
+  };
+}
+
+exports.DEFAULT_ICE_SERVERS = DEFAULT_ICE_SERVERS;
+exports.MAX_ATTACHMENTS = MAX_ATTACHMENTS;
+exports.MAX_CHANNEL_NAME_CHARS = MAX_CHANNEL_NAME_CHARS;
+exports.MAX_MESSAGE_CHARS = MAX_MESSAGE_CHARS;
+exports.MAX_SDP_CHARS = MAX_SDP_CHARS;
+exports.MAX_SIGNAL_CHARS = MAX_SIGNAL_CHARS;
+exports.allFilesOf = allFilesOf;
+exports.callRoomId = callRoomId;
+exports.channelViews = channelViews;
+exports.createBroadcastSignaling = createBroadcastSignaling;
+exports.createCallSession = createCallSession;
+exports.createChatStore = createChatStore;
+exports.createMemorySignalingHub = createMemorySignalingHub;
+exports.createPeer = createPeer;
+exports.createTeamsClient = createTeamsClient;
+exports.createTeamsWorkspace = createTeamsWorkspace;
+exports.createWebSocketSignaling = createWebSocketSignaling;
+exports.detectOfficeKind = detectOfficeKind;
+exports.endpointUrl = endpointUrl;
+exports.filesOf = filesOf;
+exports.localServerConfig = localServerConfig;
+exports.parseServerConfig = parseServerConfig;
+exports.parseSignal = parseSignal;
+exports.peopleViews = peopleViews;
+exports.sanitizeAttachment = sanitizeAttachment;
+exports.sanitizeAttachments = sanitizeAttachments;
+exports.sanitizeChannelName = sanitizeChannelName;
+exports.sanitizeEmoji = sanitizeEmoji;
+exports.sanitizeMessageText = sanitizeMessageText;
+exports.searchMessages = searchMessages;
+exports.typingNames = typingNames;