@ai-matrx/meet 0.10.7 → 0.11.1

package/dist/core.js

@@ -1014,6 +1014,166 @@ var MEET_EVENTS = {
   stateChanged: "mx.state.changed"
 };
 
+// src/core/reasons.ts
+var JOIN_REFUSAL_REASONS = [
+  "not_found",
+  "cancelled",
+  "ended",
+  "expired",
+  "too_early",
+  "sign_in_required",
+  "wrong_account",
+  "not_invited",
+  "locked",
+  "removed",
+  "lobby_rejects",
+  "meeting_full",
+  "platform_capacity",
+  "verification_required",
+  "registration_required"
+];
+function isJoinRefusalReason(value) {
+  return typeof value === "string" && JOIN_REFUSAL_REASONS.includes(value);
+}
+
+// src/core/phase.ts
+var LIVE_PHASES = /* @__PURE__ */ new Set(["joining", "in_call"]);
+var WAITING_PHASES = /* @__PURE__ */ new Set([
+  "waiting:host_not_started",
+  "waiting:knocking",
+  "denied",
+  "knock_expired"
+]);
+var JOINABLE_FROM = /* @__PURE__ */ new Set([
+  "prejoin",
+  "left",
+  "disconnected",
+  "superseded",
+  "inactive",
+  "denied",
+  "knock_expired"
+]);
+var NOT_ENDABLE = /* @__PURE__ */ new Set([
+  "ended",
+  "record",
+  "unsupported",
+  "ringing_out",
+  "ringing_in",
+  "call_declined",
+  "call_missed",
+  "call_busy",
+  "answered_elsewhere"
+]);
+var RINGING = /* @__PURE__ */ new Set(["ringing_out", "ringing_in"]);
+var IDLE_PHASES = /* @__PURE__ */ new Set([
+  "resolving",
+  "left",
+  "call_declined",
+  "call_missed",
+  "call_busy",
+  "answered_elsewhere"
+]);
+function isLivePhase(phase) {
+  return LIVE_PHASES.has(phase);
+}
+function isWaitingPhase(phase) {
+  return WAITING_PHASES.has(phase);
+}
+function isRefusedPhase(phase) {
+  return phase.startsWith("refused:");
+}
+function reasonOf(phase) {
+  return isRefusedPhase(phase) ? phase.slice("refused:".length) : null;
+}
+function refusalPhase(reason) {
+  if (reason === null || !isJoinRefusalReason(reason)) return "disconnected";
+  return reason === "ended" ? "ended" : `refused:${reason}`;
+}
+function admissionPhase(admission) {
+  switch (admission) {
+    case "waiting_host":
+      return "waiting:host_not_started";
+    case "knocking":
+      return "waiting:knocking";
+    case "denied":
+      return "denied";
+    case "expired":
+      return "knock_expired";
+    case "withdrawn":
+      return "left";
+    case "ended":
+      return "ended";
+    case "removed":
+      return "refused:removed";
+    default:
+      return null;
+  }
+}
+function nextPhase(from, event) {
+  switch (event.type) {
+    case "resolved":
+      return from === "resolving" ? "prejoin" : null;
+    case "unsupported":
+      return from === "resolving" ? "unsupported" : null;
+    case "join":
+      return JOINABLE_FROM.has(from) ? "joining" : null;
+    case "back_to_prejoin":
+      return from === "left" || from === "disconnected" ? "prejoin" : null;
+    case "retry":
+      return isRefusedPhase(from) || from === "unsupported" ? "resolving" : null;
+    case "admission": {
+      if (from !== "joining" && !WAITING_PHASES.has(from)) return null;
+      return admissionPhase(event.admission);
+    }
+    case "admitted":
+      return WAITING_PHASES.has(from) ? "joining" : null;
+    case "connected":
+      return from === "joining" ? "in_call" : null;
+    case "join_failed":
+      return from === "joining" ? refusalPhase(event.reason) : null;
+    case "exit":
+      return from === "in_call" || from === "joining" ? event.to : null;
+    case "leave":
+      return from === "in_call" || from === "joining" || WAITING_PHASES.has(from) ? "left" : null;
+    case "ended":
+      return NOT_ENDABLE.has(from) ? null : "ended";
+    case "ring_out":
+      return IDLE_PHASES.has(from) || from === "prejoin" ? "ringing_out" : null;
+    case "ring_in":
+      return IDLE_PHASES.has(from) ? "ringing_in" : null;
+    case "call_answered":
+      return RINGING.has(from) ? "joining" : null;
+    case "call_outcome":
+      return RINGING.has(from) ? event.outcome : null;
+    case "reset":
+      return LIVE_PHASES.has(from) ? null : "resolving";
+  }
+}
+function resolveExit(input) {
+  const { server, hint } = input;
+  if (server === null) {
+    return { to: "disconnected", reason: null, connection: "server_unreachable", notice: null };
+  }
+  const word = server?.exitReason ?? null;
+  if (server !== void 0 && (server.sessionPhase === "ended" || server.meetingPhase === "ended" || word === "ended" || word === "time_limit")) {
+    return { to: "ended", reason: word === "time_limit" ? "time_limit" : "ended", connection: "stable", notice: null };
+  }
+  if (word === "removed") return { to: "removed", reason: "removed", connection: "stable", notice: null };
+  if (word === "displaced") return { to: "superseded", reason: "displaced", connection: "stable", notice: null };
+  if (word === "sent_to_waiting") {
+    return { to: "waiting:knocking", reason: "sent_to_waiting", connection: "stable", notice: "sent-to-waiting" };
+  }
+  if (hint === "DUPLICATE_IDENTITY") return { to: "superseded", reason: "displaced", connection: "stable", notice: null };
+  if (hint === "PARTICIPANT_REMOVED" && word === null && server === void 0) {
+    return { to: "removed", reason: "removed", connection: "stable", notice: null };
+  }
+  if (hint === "ROOM_DELETED" && server === void 0) {
+    return { to: "ended", reason: "ended", connection: "stable", notice: null };
+  }
+  if (input.frozen === true) return { to: "inactive", reason: "inactive", connection: "stable", notice: null };
+  return { to: "disconnected", reason: null, connection: "stable", notice: null };
+}
+
 // src/core/types.ts
 var asMeetingId = (value) => value;
 var asCallId = (value) => value;
@@ -1105,6 +1265,39 @@ function createCallCenter(options) {
     clearRing(invite.id);
     incoming.delete(invite.id);
     if (outgoing !== null && outgoing.id === invite.id) outgoing = invite;
+    const held = options.store.snapshot().call;
+    if (held !== null && held.invite.id === invite.id && held.direction === "incoming") {
+      const outcome = invite.state === "connecting" || invite.state === "active" ? "answered_elsewhere" : invite.state === "declined" ? "reset" : "call_missed";
+      const moved = outcome === "reset" ? options.store.dispatch({ type: "reset" }) : options.store.dispatch({ type: "call_outcome", outcome });
+      if (moved) options.store.patch({ call: outcome === "reset" ? null : { ...held, invite } });
+    }
+    options.onSettled?.(invite);
+  }
+  function settleOutgoing(invite) {
+    if (outgoing === null || outgoing.id !== invite.id) return;
+    clearRing(invite.id);
+    outgoing = invite;
+    const store = options.store;
+    const held = store.snapshot().call;
+    if (held !== null && held.invite.id === invite.id) store.patch({ call: { ...held, invite } });
+    switch (invite.state) {
+      case "connecting":
+      case "active":
+        if (store.dispatch({ type: "call_answered" })) options.onAnswered?.(invite);
+        break;
+      case "declined":
+        store.dispatch({ type: "call_outcome", outcome: "call_declined" });
+        break;
+      case "busy":
+        store.dispatch({ type: "call_outcome", outcome: "call_busy" });
+        break;
+      case "missed":
+      case "failed":
+        store.dispatch({ type: "call_outcome", outcome: "call_missed" });
+        break;
+      default:
+        break;
+    }
     options.onSettled?.(invite);
   }
   function ingest(invite) {
@@ -1113,7 +1306,7 @@ function createCallCenter(options) {
     if (identity.userId === null) return;
     if (invite.callerUserId === identity.userId) return;
     const phase = options.store.snapshot().phase;
-    if (phase === "connected" || phase === "connecting" || phase === "reconnecting") {
+    if (isLivePhase(phase) || phase === "ringing_out") {
       void repository.settleCallInvite(invite.id, "busy", null).then((settled) => {
         to(settled.callerUserId).send(MEET_EVENTS.settled, settled);
       }).catch((error) => {
@@ -1126,6 +1319,9 @@ function createCallCenter(options) {
       return;
     }
     incoming.set(invite.id, { ...invite, state: "ringing" });
+    if (options.store.snapshot().call === null && options.store.dispatch({ type: "ring_in" })) {
+      options.store.patch({ call: { invite: { ...invite, state: "ringing" }, direction: "incoming" } });
+    }
     options.onIncoming?.(invite);
     timeouts.set(
       invite.id,
@@ -1163,6 +1359,7 @@ function createCallCenter(options) {
               const invite = message.data;
               const held = incoming.get(invite.id);
               if (held !== void 0) settleLocal(invite);
+              else if (outgoing?.id === invite.id) settleOutgoing(invite);
             }
           }
         ],
@@ -1229,6 +1426,9 @@ function createCallCenter(options) {
         expiresAt: new Date(timers.now() + ringTimeoutMs).toISOString()
       });
       outgoing = invite;
+      if (options.store.dispatch({ type: "ring_out" })) {
+        options.store.patch({ call: { invite, direction: "outgoing" } });
+      }
       for (const callee of people) {
         to(callee).send(MEET_EVENTS.ring, invite);
       }
@@ -1237,8 +1437,7 @@ function createCallCenter(options) {
         timers.setTimeout(() => {
           if (outgoing?.id !== invite.id) return;
           void repository.settleCallInvite(invite.id, "missed", null).then((settled) => {
-            outgoing = settled;
-            options.onSettled?.(settled);
+            settleOutgoing(settled);
           }).catch(() => void 0);
         }, ringTimeoutMs)
       );
@@ -1253,7 +1452,9 @@ function createCallCenter(options) {
           "A late accept must not resurrect a settled call. Close the ringing UI; the caller has already moved on."
         );
       }
+      if (options.store.snapshot().phase === "ringing_in") options.store.dispatch({ type: "call_answered" });
       const settled = await repository.settleCallInvite(id, "connecting", null);
+      options.store.patch({ call: { invite: settled, direction: "incoming" } });
       settleLocal(settled);
       channel?.send(MEET_EVENTS.settled, settled);
       to(settled.callerUserId).send(MEET_EVENTS.settled, { ...settled, mode });
@@ -1261,6 +1462,9 @@ function createCallCenter(options) {
     },
     async decline(id, message) {
       const settled = await repository.settleCallInvite(id, "declined", message ?? null);
+      if (options.store.snapshot().call?.invite.id === id && options.store.dispatch({ type: "reset" })) {
+        options.store.patch({ call: null });
+      }
       settleLocal(settled);
       channel?.send(MEET_EVENTS.settled, settled);
       to(settled.callerUserId).send(MEET_EVENTS.settled, settled);
@@ -1270,6 +1474,9 @@ function createCallCenter(options) {
       const settled = await repository.settleCallInvite(id, "cancelled", null);
       clearRing(id);
       if (outgoing?.id === id) outgoing = settled;
+      if (options.store.snapshot().call?.invite.id === id && options.store.dispatch({ type: "reset" })) {
+        options.store.patch({ call: null });
+      }
       for (const callee of settled.calleeUserIds) {
         to(callee).send(MEET_EVENTS.cancel, settled);
       }
@@ -1301,7 +1508,9 @@ var TABLES = {
   /** Wave 1 (0.8): who a meeting was sent to, and what they answered. */
   invitees: "meet_invitees",
   /** Wave 1 (0.8): one occurrence of a series cancelled or moved. */
-  occurrenceOverrides: "meet_occurrence_overrides"
+  occurrenceOverrides: "meet_occurrence_overrides",
+  /** S5: one row per RUN of a meeting; carries that run's note-taker state. */
+  sessions: "meet_sessions"
 };
 var RPCS = {
   /** Atomic: create the invite row and stamp its expiry in one statement. */
@@ -1777,6 +1986,18 @@ function createMeetRepository(options) {
       );
     }
   }
+  async function withRunNoteTaker(meeting) {
+    const response = await db.from(TABLES.sessions).select("note_taker,started_at").eq("meeting_id", meeting.id).order("started_at", { ascending: false }).limit(1);
+    const run = response.error === null ? (response.data ?? [])[0] : void 0;
+    const noteTaker = run?.["note_taker"];
+    if (typeof noteTaker !== "object" || noteTaker === null || Array.isArray(noteTaker)) {
+      return meeting;
+    }
+    return {
+      ...meeting,
+      metadata: { ...meeting.metadata ?? {}, note_taker: noteTaker }
+    };
+  }
   return {
     schema: MEET_SCHEMA,
     tables: TABLES,
@@ -2015,13 +2236,13 @@ function createMeetRepository(options) {
         "meet.meetingBySlug",
         () => db.rpc(RPCS.meetingBySlug, { p_slug: slug })
       );
-      return projectMeeting(row);
+      return withRunNoteTaker(projectMeeting(row));
     },
     async meeting(id) {
       const response = await db.from(TABLES.meetings).select(MEETING_COLUMNS).eq("id", id).single();
       if (response.error !== null) throw normalizeMeetError(response.error, "meet.meeting");
       if (response.data === null) throw invalidResponse("meet.meeting", "no such meeting");
-      return projectMeeting(response.data);
+      return withRunNoteTaker(projectMeeting(response.data));
     },
     async listMeetings({ organizationId = null, limit = 25, before = null }) {
       let query = db.from(TABLES.meetings).select(MEETING_COLUMNS);
@@ -2782,8 +3003,15 @@ var NO_GRANTS = {
   canPublish: false,
   canSubscribe: false
 };
+var NO_SHARE = { state: "none", reason: null, remedy: null, at: 0 };
 var EMPTY = {
-  phase: "idle",
+  phase: "resolving",
+  reason: null,
+  phaseNotice: null,
+  roomName: null,
+  connection: "stable",
+  share: NO_SHARE,
+  call: null,
   waiting: null,
   meeting: null,
   localIdentity: null,
@@ -2847,8 +3075,20 @@ function createMeetStore(initial = {}) {
       return () => listeners.delete(listener);
     },
     patch(next) {
+      if ("phase" in next || "reason" in next || "phaseNotice" in next) {
+        throw new TypeError("meet store: the phase moves only through store.dispatch(event)");
+      }
       commit({ ...state, ...next });
     },
+    dispatch(event, detail) {
+      const to = nextPhase(state.phase, event);
+      if (to === null) return false;
+      const reason = detail?.reason !== void 0 ? detail.reason : reasonOf(to);
+      const phaseNotice = detail?.notice ?? null;
+      if (to === state.phase && reason === state.reason && phaseNotice === state.phaseNotice) return true;
+      commit({ ...state, phase: to, reason, phaseNotice });
+      return true;
+    },
     setParticipants(participants) {
       const names = learnNames(state.names, participants);
       const hands = new Map(state.participants.map((p) => [p.identity, p.handRaised]));
@@ -3842,7 +4082,8 @@ function createLiveKitDriver(handlers, options = {}) {
     }).on(RoomEvent.Disconnected, (reason) => {
       audioContainer?.remove();
       audioContainer = null;
-      handlers.disconnected(reason === void 0 ? null : String(reason));
+      const named = reason === void 0 ? null : module?.DisconnectReason?.[reason] ?? String(reason);
+      handlers.disconnected(named);
     });
     try {
       created.registerTextStreamHandler(TRANSCRIPTION_TOPIC, (reader, participantInfo) => {
@@ -4190,7 +4431,7 @@ function createMeetingSession(options) {
   }
   function apply(read) {
     const snapshot = store.snapshot();
-    if (snapshot.phase !== "lobby") return;
+    if (!isWaitingPhase(snapshot.phase)) return;
     const admission = read.admission_state ?? null;
     const ended = admission === "ended" || read.session_phase === "ended" || read.meeting_phase === "ended";
     if (admission === "admitted" && !ended) {
@@ -4207,6 +4448,7 @@ function createMeetingSession(options) {
       if (read.meeting_phase === "ended" && meeting !== null && meeting.endedAt === null) {
         store.patch({ meeting: { ...meeting, endedAt: (/* @__PURE__ */ new Date()).toISOString() } });
       }
+      store.dispatch({ type: "admission", admission: "ended" }, { reason: "ended" });
       return;
     }
     if (admission === null) return;
@@ -4218,6 +4460,7 @@ function createMeetingSession(options) {
       pollSeconds: read.poll_seconds ?? snapshot.waiting?.pollSeconds ?? 3,
       liveVersion: read.live_version ?? 0
     });
+    store.dispatch({ type: "admission", admission });
     if (admission === "denied" || admission === "expired" || admission === "withdrawn" || admission === "removed") {
       stopWaiting();
     }
@@ -4313,7 +4556,7 @@ function createMeetingSession(options) {
             // 🚨 PAYLOAD-FREE. Every receiver reads again; a spoofed hint only causes a read.
             event: MEET_EVENTS.stateChanged,
             onMessage: () => {
-              if (store.snapshot().phase === "lobby") void readState2();
+              if (isWaitingPhase(store.snapshot().phase)) void readState2();
               void refreshQueue();
             }
           }
@@ -4325,7 +4568,7 @@ function createMeetingSession(options) {
           if (meeting === null) return;
           const fresh = isGuest(identity) ? await repository.meetingBySlug(meeting.slug) : await readMeeting(meeting.id);
           store.patch({ meeting: fresh, locked: fresh.locked });
-          if (store.snapshot().phase === "lobby") void readState2();
+          if (isWaitingPhase(store.snapshot().phase)) void readState2();
         }
       });
     },
@@ -4492,10 +4735,34 @@ function createMeetingSession(options) {
     },
     stopWaiting,
     readState: readState2,
+    async readExit(connection) {
+      const meeting = store.snapshot().meeting;
+      const pass = options.resolvePass?.() ?? null;
+      if (meeting === null || pass === null) return void 0;
+      try {
+        const response = await options.api.request({
+          path: `${MEET_ROUTES.state}?meeting_id=${encodeURIComponent(meeting.id)}&connection=${encodeURIComponent(connection)}`,
+          method: "GET",
+          requireAuth: false,
+          operation: "meet.state(exit)",
+          headers: { [MEETING_PASS_HEADER]: pass }
+        });
+        if (!response.ok) return null;
+        const read = await response.json();
+        return {
+          exitReason: read.exit_reason ?? null,
+          sessionPhase: read.session_phase ?? null,
+          meetingPhase: read.meeting_phase ?? null
+        };
+      } catch {
+        return null;
+      }
+    },
     async withdraw() {
       stopWaiting();
       await postLeave("withdraw");
       patchWaiting({ admission: "withdrawn" });
+      store.dispatch({ type: "admission", admission: "withdrawn" });
       hint();
     },
     async askAgain() {
@@ -5119,6 +5386,9 @@ async function pushMeetingToGoogleCalendar(api, meetingId, target) {
 }
 
 // src/core/room.ts
+function SCREEN_SHARE_BLOCKED_REMEDY_FOR(remedy) {
+  return /administrator|policy/i.test(remedy) ? remedy : SCREEN_SHARE_BLOCKED_REMEDY;
+}
 var PARTICIPANT_ROLE_ATTRIBUTE = "matrx.participant.role";
 var PARTICIPANT_CAN_RECORD_ATTRIBUTE = "matrx.participant.can_record";
 var PARTICIPANT_STANDING_ATTRIBUTE = "matrx.participant.standing";
@@ -5186,7 +5456,7 @@ function createRoomEngine(options) {
   let disposed = false;
   let moving = false;
   const confirmingEnds = /* @__PURE__ */ new WeakSet();
-  async function leaveRoom() {
+  async function dropRoom() {
     const target = driver;
     driver = null;
     if (current !== null) {
@@ -5195,9 +5465,14 @@ function createRoomEngine(options) {
     }
     store.setLocalTrack("microphone", IDLE_TRACK);
     store.setLocalTrack("camera", IDLE_TRACK);
-    store.patch({ phase: "left" });
+    store.patch({ share: NO_SHARE, connection: "stable" });
     await target?.disconnect();
   }
+  async function leaveRoom() {
+    store.dispatch({ type: "leave" });
+    await dropRoom();
+    options.onLeft?.(null);
+  }
   async function confirmMeetingEnd() {
     const meeting = store.snapshot().meeting;
     const target = driver;
@@ -5219,7 +5494,9 @@ function createRoomEngine(options) {
       const latest = store.snapshot().meeting;
       if (latest === null) return;
       store.patch({ meeting: { ...latest, endedAt: verified.endedAt } });
-      await leaveRoom();
+      store.dispatch({ type: "ended" }, { reason: "ended" });
+      await dropRoom();
+      options.onLeft?.("ended");
     } catch (error) {
       report("error", `Meet could not confirm or finish meeting teardown: ${String(error)}`, "Check the meeting link again; if media remains active, close this meeting tab.");
     } finally {
@@ -5231,12 +5508,12 @@ function createRoomEngine(options) {
     options.onDiagnostic?.(remedy === void 0 ? { level, message } : { level, message, remedy });
   }
   let ambiguousShareDenials = 0;
-  function fail(error, operation) {
+  function failJoin(error, operation) {
     const normalized = normalizeMeetError(error, operation);
     store.patch({
-      phase: "failed",
       failure: { message: normalized.message, remedy: normalized.remedy, reason: normalized.reason }
     });
+    store.dispatch({ type: "join_failed", reason: normalized.reason ?? null });
     report(
       normalized.code === "session-unavailable" ? "warn" : "error",
       normalized.message,
@@ -5244,6 +5521,14 @@ function createRoomEngine(options) {
     );
     return normalized;
   }
+  async function lostRoom(error, operation) {
+    const normalized = normalizeMeetError(error, operation);
+    store.patch({ failure: { message: normalized.message, remedy: normalized.remedy, reason: normalized.reason } });
+    await dropRoom();
+    store.dispatch({ type: "exit", to: "disconnected" });
+    report("error", normalized.message, normalized.remedy);
+    return normalized;
+  }
   const handlers = {
     participants(list) {
       const joinedAt = new Date(now()).toISOString();
@@ -5286,9 +5571,12 @@ function createRoomEngine(options) {
       store.setQuality(asParticipantIdentity(who), value);
     },
     connectionState(state) {
-      if (state === "connected") store.patch({ phase: "connected", failure: null });
-      else if (state === "reconnecting") store.patch({ phase: "reconnecting" });
-      else if (state === "connecting") store.patch({ phase: "connecting" });
+      if (state === "connected") {
+        if (store.snapshot().connection !== "stable") store.patch({ connection: "stable" });
+        store.dispatch({ type: "connected" });
+      } else if (state === "reconnecting") {
+        store.patch({ connection: "reconnecting" });
+      }
     },
     transcription(event) {
       const snapshot = store.snapshot();
@@ -5415,17 +5703,48 @@ function createRoomEngine(options) {
       }
     },
     disconnected(reason) {
-      if (moving) return;
-      if (current !== null) {
-        tokens.invalidate(current.roomName);
-        current = null;
-      }
-      store.patch({ phase: "left" });
-      options.onLeft?.(reason);
+      if (moving || driver === null) return;
+      void resolveExitAndApply(reason);
     }
   };
+  async function resolveExitAndApply(hint) {
+    const connection = current?.identity ?? store.snapshot().localIdentity ?? null;
+    await dropRoom();
+    let server;
+    if (options.readExit === void 0 || connection === null || store.snapshot().meeting === null) {
+      server = void 0;
+    } else {
+      try {
+        server = await options.readExit(connection);
+      } catch {
+        server = null;
+      }
+    }
+    if (disposed) return;
+    const resolved = resolveExit({ server, hint, frozen: options.wasFrozen?.() ?? false });
+    store.patch({ connection: resolved.connection });
+    if (resolved.to === "waiting:knocking") {
+      store.patch({
+        waiting: {
+          admission: "knocking",
+          admittersPresent: null,
+          reknockAllowed: true,
+          knockExpiresAt: null,
+          pollSeconds: store.snapshot().waiting?.pollSeconds ?? 3,
+          liveVersion: 0
+        }
+      });
+    }
+    store.dispatch({ type: "exit", to: resolved.to }, { reason: resolved.reason, notice: resolved.notice });
+    report(
+      resolved.to === "disconnected" ? "warn" : "info",
+      `meet: the room connection ended (${hint ?? "no LiveKit reason"}) \u2192 ${resolved.to}`,
+      resolved.to === "disconnected" ? "Press Rejoin; the meeting is still going." : "The screen says what happened."
+    );
+    options.onLeft?.(hint);
+  }
   async function connect(request) {
-    store.patch({ phase: "requesting-token", failure: null, waiting: null });
+    store.patch({ failure: null, waiting: null, roomName: request.roomName, share: NO_SHARE, connection: "stable" });
     const token = await tokens.get({
       roomName: request.roomName,
       identity,
@@ -5448,10 +5767,10 @@ function createRoomEngine(options) {
       }
     });
     if (token.lobby || !token.canSubscribe) {
+      const admission = token.admissionState !== void 0 && token.admissionState !== "admitted" ? token.admissionState : "knocking";
       store.patch({
-        phase: "lobby",
         waiting: {
-          admission: token.admissionState !== void 0 && token.admissionState !== "admitted" ? token.admissionState : "knocking",
+          admission,
           admittersPresent: null,
           reknockAllowed: true,
           knockExpiresAt: null,
@@ -5459,9 +5778,10 @@ function createRoomEngine(options) {
           liveVersion: 0
         }
       });
+      store.dispatch({ type: "admission", admission });
       return;
     }
-    store.patch({ phase: "connecting", waiting: null });
+    store.patch({ waiting: null });
     const created = await options.driverFactory(handlers);
     if (disposed) {
       await created.disconnect();
@@ -5469,7 +5789,8 @@ function createRoomEngine(options) {
     }
     driver = created;
     await created.connect(token.serverUrl, token.token);
-    store.patch({ phase: "connected", failure: null });
+    store.patch({ failure: null, connection: "stable" });
+    store.dispatch({ type: "connected" });
     store.setLocalTrack("microphone", IDLE_TRACK);
     store.setLocalTrack("camera", IDLE_TRACK);
     const effects = options.effectsStorage?.load() ?? store.snapshot().effects;
@@ -5540,9 +5861,17 @@ function createRoomEngine(options) {
   return {
     join(request) {
       if (joining !== null) return joining;
+      if (store.snapshot().phase !== "joining" && !store.dispatch({ type: "join", click: true })) {
+        report(
+          "warn",
+          `meet.join: cannot join from "${store.snapshot().phase}"`,
+          "Join is offered from the pre-join, left, disconnected and replaced screens only."
+        );
+        return Promise.resolve();
+      }
       lastRequest = request;
       joining = connect(request).catch((error) => {
-        throw fail(error, "meet.join");
+        throw failJoin(error, "meet.join");
       }).finally(() => {
         joining = null;
       });
@@ -5559,10 +5888,16 @@ function createRoomEngine(options) {
         return;
       }
       if (joining !== null) return joining;
+      const phase = store.snapshot().phase;
+      const moved = phase === "joining" || store.dispatch({ type: "join", click: true }) || store.dispatch({ type: "admitted" });
+      if (!moved) {
+        report("warn", `meet.rejoin: cannot rejoin from "${phase}"`, "Rejoin is offered after leaving, a lost connection, or admission.");
+        return;
+      }
       tokens.invalidate(request.roomName);
       current = null;
       joining = connect(request).catch((error) => {
-        throw fail(error, "meet.rejoin");
+        throw failJoin(error, "meet.rejoin");
       }).finally(() => {
         joining = null;
       });
@@ -5607,11 +5942,11 @@ function createRoomEngine(options) {
           joining = connect(lastRequest).finally(() => {
             joining = null;
           });
-          await joining.catch((again) => {
-            throw fail(again, "meet.moveToBreakout");
+          await joining.catch(async (again) => {
+            throw await lostRoom(again, "meet.moveToBreakout");
           });
         } else {
-          throw fail(error, "meet.moveToBreakout");
+          throw await lostRoom(error, "meet.moveToBreakout");
         }
         throw normalized;
       } finally {
@@ -5619,6 +5954,9 @@ function createRoomEngine(options) {
       }
     },
     leave: leaveRoom,
+    backToPrejoin() {
+      store.dispatch({ type: "back_to_prejoin", click: true });
+    },
     // Turning a device on mid-meeting is the SAME operation as turning it on
     // during the join, so it runs the same function. A failure here used to
     // stamp the room `failed` — a busy microphone would blank a live meeting.
@@ -5632,21 +5970,41 @@ function createRoomEngine(options) {
     },
     async setScreenShareEnabled(enabled) {
       if (driver === null) return;
+      if (enabled && driver.supportsScreenShare?.() === false) {
+        store.patch({ share: { state: "refused", reason: "unsupported", remedy: null, at: now() } });
+        report("warn", "meet: this browser cannot share a screen", "Share from a desktop browser (Chrome, Edge, Firefox or Safari).");
+        return;
+      }
+      if (enabled) store.patch({ share: { state: "picking", reason: null, remedy: null, at: now() } });
       try {
         await driver.setScreenShareEnabled(enabled);
         ambiguousShareDenials = 0;
+        store.patch({ share: { state: enabled ? "presenting" : "none", reason: null, remedy: null, at: now() } });
       } catch (error) {
         const kind = classifyScreenShareError(error);
         if (kind === "ambiguous") {
           ambiguousShareDenials += 1;
-          if (ambiguousShareDenials < 2) return;
+          if (ambiguousShareDenials < 2) {
+            store.patch({ share: NO_SHARE });
+            return;
+          }
         }
+        ambiguousShareDenials = 0;
         const normalized = normalizeScreenShareError(error, "meet.setScreenShareEnabled");
         report("warn", normalized.message, normalized.remedy);
-        const text3 = kind === "other" ? `Screen sharing is not available. ${normalized.remedy}` : `Screen sharing did not start. ${SCREEN_SHARE_BLOCKED_REMEDY}`;
-        store.patch({ actionNotice: { text: text3, failed: true, at: now() } });
+        store.patch({
+          share: {
+            state: "refused",
+            reason: kind === "other" ? "failed" : "blocked",
+            remedy: kind === "other" ? normalized.remedy : SCREEN_SHARE_BLOCKED_REMEDY_FOR(normalized.remedy),
+            at: now()
+          }
+        });
       }
     },
+    dismissShareNotice() {
+      if (store.snapshot().share.state === "refused") store.patch({ share: NO_SHARE });
+    },
     async raiseHand(raised) {
       const local = store.snapshot().localIdentity;
       if (local !== null) store.setHand(local, raised);
@@ -6613,28 +6971,6 @@ function createMeetingRecordCache(options = {}) {
   };
 }
 
-// src/core/reasons.ts
-var JOIN_REFUSAL_REASONS = [
-  "not_found",
-  "cancelled",
-  "ended",
-  "expired",
-  "too_early",
-  "sign_in_required",
-  "wrong_account",
-  "not_invited",
-  "locked",
-  "removed",
-  "lobby_rejects",
-  "meeting_full",
-  "platform_capacity",
-  "verification_required",
-  "registration_required"
-];
-function isJoinRefusalReason(value) {
-  return typeof value === "string" && JOIN_REFUSAL_REASONS.includes(value);
-}
-
 // src/core/reactions.ts
 var MEET_REACTIONS = ["\u{1F496}", "\u{1F44D}", "\u{1F389}", "\u{1F44F}", "\u{1F602}", "\u{1F62E}", "\u{1F622}", "\u{1F914}", "\u{1F44E}"];
 
@@ -6733,43 +7069,12 @@ function endedRecord(snapshot, given) {
 function observedPhase(input) {
   const { snapshot } = input;
   if (snapshot === null) return "resolving";
-  const raw = snapshot.phase;
-  const live = raw === "connected" || raw === "reconnecting";
-  if (endedRecord(snapshot, input.meeting ?? null) && !live) return "ended";
-  const reason = raw === "failed" ? snapshot.failure?.reason ?? null : null;
-  if (reason !== null) return reason === "ended" ? "ended" : `refused:${reason}`;
-  switch (raw) {
-    case "idle":
-    case "failed":
-    case "left":
-      return "prejoin";
-    case "lobby":
-      return waitingPhase(snapshot);
-    case "requesting-token":
-    case "connecting":
-      return "joining";
-    case "connected":
-    case "reconnecting":
-      return "in_call";
-  }
+  const phase = snapshot.phase;
+  if (endedRecord(snapshot, input.meeting ?? null) && !isLivePhase(phase) && !isCallPhase(phase)) return "ended";
+  return phase;
 }
-function waitingPhase(snapshot) {
-  switch (snapshot.waiting?.admission) {
-    case "waiting_host":
-      return "waiting:host_not_started";
-    case "denied":
-      return "denied";
-    case "expired":
-      return "knock_expired";
-    case "withdrawn":
-      return "left";
-    case "ended":
-      return "ended";
-    case "removed":
-      return "refused:removed";
-    default:
-      return "waiting:knocking";
-  }
+function isCallPhase(phase) {
+  return phase.startsWith("ringing_") || phase.startsWith("call_") || phase === "answered_elsewhere";
 }
 var ADMITTER_ROLES = /* @__PURE__ */ new Set(["host", "cohost"]);
 function observe(input) {
@@ -6782,10 +7087,10 @@ function observe(input) {
   const deviceInPlay = phase === "joining" || inCall;
   return {
     phase,
-    reason: phase.startsWith("refused:") ? phase.slice("refused:".length) : null,
+    reason: phase === "ended" ? snapshot?.reason ?? null : snapshot?.reason ?? reasonOf(phase),
     role,
-    connection: snapshot?.phase === "reconnecting" ? "reconnecting" : "stable",
-    hostPresent: inCall && snapshot !== null ? snapshot.participants.some((p) => ADMITTER_ROLES.has(p.role)) : snapshot?.phase === "lobby" ? snapshot.waiting?.admittersPresent ?? null : null,
+    connection: snapshot?.connection ?? "stable",
+    hostPresent: inCall && snapshot !== null ? snapshot.participants.some((p) => ADMITTER_ROLES.has(p.role)) : snapshot !== null && isWaitingPhase(snapshot.phase) ? snapshot.waiting?.admittersPresent ?? null : null,
     lobbyCount: canAdmit && snapshot !== null ? snapshot.lobby.filter((entry) => entry.state === "knocking").length : 0,
     recording: snapshot?.recording === "recording" || snapshot?.recording === "stopping",
     audioBlocked: null,
@@ -6877,9 +7182,11 @@ export {
   GUEST_RECORD_ACCESS_METADATA_KEY,
   GUEST_RECORD_NOT_SHARED,
   IDLE_MEDIA,
+  IDLE_PHASES,
   IDLE_TRACK,
   JOIN_REFUSAL_REASONS,
   LISTEN_ONLY_NOTICE,
+  LIVE_PHASES,
   MEETING_INVITE_KIND,
   MEETING_INVITE_VERSION,
   MEETING_PASS_HEADER,
@@ -6895,6 +7202,7 @@ export {
   NOTE_TAKER_IDENTITY_PREFIX,
   NOTE_TAKER_METADATA_KEY,
   NO_GRANTS,
+  NO_SHARE,
   ORGANIZATION_HEADER,
   PARTICIPANT_CAN_RECORD_ATTRIBUTE,
   PARTICIPANT_ROLE_ATTRIBUTE,
@@ -6908,9 +7216,11 @@ export {
   TABLES,
   TRANSCRIPTION_ATTRIBUTES,
   TRANSCRIPTION_TOPIC,
+  WAITING_PHASES,
   absenceSentence,
   activeWrapUpSummary,
   activityAttention,
+  admissionPhase,
   announceMeeting,
   appPanelOf,
   applyCollabPacket,
@@ -6980,10 +7290,13 @@ export {
   isJoinRefusalReason,
   isLinkFollower,
   isListenOnly,
+  isLivePhase,
   isNoteTaker,
   isObserverRole,
   isRealName,
+  isRefusedPhase,
   isRoomEventTopic,
+  isWaitingPhase,
   learnName,
   learnNames,
   listenOnlyNotice,
@@ -7007,6 +7320,7 @@ export {
   mergeRecord,
   microphoneNoticeCode,
   moveToRoom,
+  nextPhase,
   nextTranslationBatch,
   normalizeDeviceError,
   normalizeMeetError,
@@ -7039,10 +7353,13 @@ export {
   pushMeetingToGoogleCalendar,
   readServerRefusal,
   readableTranscript,
+  reasonOf,
   recordingLabel,
   recordingNotice,
   recordingOffsetMs,
+  refusalPhase,
   rememberedMeetingPass,
+  resolveExit,
   roleOf,
   roomTopic,
   rootAttributes,