@ai-matrx/meet 0.9.0 → 0.10.0

package/dist/index.cjs

@@ -534,7 +534,17 @@ var MEET_ROUTES = {
    */
   collab: "/api/v1/meet/collab",
   /** Meet wave 5: translate finished caption lines into this viewer's language. */
-  captionsTranslate: "/api/v1/meet/captions/translate"
+  captionsTranslate: "/api/v1/meet/captions/translate",
+  /**
+   * S4 — THE STATE READ (CORE-DESIGN §2.6): `GET ?meeting_id=` with `x-meet-pass`. This
+   * person's admission (lazy expiry applied), whether anyone who can admit is here, the run's
+   * phase. Read every `waiting_poll_seconds` while waiting and on every `mx.state.changed`.
+   */
+  state: "/api/v1/meet/state",
+  /** S4: `withdraw` (stop waiting) or `leave` (close this tab); the pass may ride in the body. */
+  leave: "/api/v1/meet/leave",
+  /** S4: a pass holder (guests included) saw the recording notice, for this run. */
+  consent: "/api/v1/meet/consent"
 };
 function meetingPath(template, meetingId) {
   return template.replace("{meeting_id}", encodeURIComponent(meetingId));
@@ -608,6 +618,8 @@ function parseRoomToken(body, roomName) {
     meetingPassExpiresAt: readString(payload, "meeting_pass_expires_at"),
     sessionId: readString(payload, "session_id"),
     lobby: readBoolean(payload, "lobby", false),
+    admissionState: readString(payload, "admission_state") ?? void 0,
+    pollSeconds: typeof payload["poll_seconds"] === "number" ? payload["poll_seconds"] : void 0,
     breakoutRoomId: readString(payload, "breakout_room_id") ?? null
   };
 }
@@ -1220,14 +1232,15 @@ var MEET_EVENTS = {
   cancel: "mx.call.cancel",
   /** You answered (or declined) on another device. Stop ringing here. */
   settled: "mx.call.settled",
-  /** Someone is in the lobby. Hosts render the knock. */
-  knock: "mx.lobby.knock",
-  /** A host decided. The knocker learns it here — they have no DB read. */
-  admission: "mx.lobby.admission",
-  /** The room was locked or unlocked. */
-  lock: "mx.room.lock",
-  /** Recording started or stopped. EVERY participant renders the indicator. */
-  recording: "mx.room.recording"
+  /**
+   * 🚨 S4 (CORE-DESIGN §2.6): the ONE room-channel event — payload-free "something changed,
+   * read again". Nothing a person must see rides it: a waiting person learns admitted /
+   * denied / expired / ended by READING their row (`GET /v1/meet/state`) on a timer and on
+   * every hint. The four payload broadcasts (`mx.lobby.knock`, `mx.lobby.admission`,
+   * `mx.room.lock`, `mx.room.recording`) are gone with their senders and receivers. The
+   * server publishes the same event on the same topic (aidream `admission.room_topic`).
+   */
+  stateChanged: "mx.state.changed"
 };
 
 // src/core/types.ts
@@ -1253,6 +1266,7 @@ function isLinkFollower(standing) {
 function isHostRole(role) {
   return role === "host" || role === "cohost";
 }
+var WAITING_ADMISSION_STATES = ["waiting_host", "knocking"];
 
 // src/core/calls.ts
 var TRANSITIONS = {
@@ -1865,7 +1879,14 @@ var RPCS = {
   getOrCreateMeeting: "meet_get_or_create_meeting",
   /** Resolve a durable public link, before/during/after its scheduled time. */
   meetingBySlug: "meet_meeting_by_slug",
-  admit: "meet_admit_participant",
+  /*
+   * ── S4 ADMISSION (CORE-DESIGN §2.4). Each returns the decided row; the caller then
+   * sends the payload-free `mx.state.changed` hint. Authorized by `who_may_admit`.
+   */
+  admit: "meet_admit",
+  deny: "meet_deny",
+  undeny: "meet_undeny",
+  admitAll: "meet_admit_all",
   setLock: "meet_set_lock",
   recordConsent: "meet_record_consent",
   /*
@@ -1908,13 +1929,13 @@ var RPCS = {
   /** Titles, agendas, current notes and final transcript lines; snippets mark hits with ⟦ ⟧. */
   search: "meet_search"
 };
-var VOID_RPCS = [RPCS.admit, RPCS.recordConsent];
+var VOID_RPCS = [RPCS.recordConsent];
 var MEETING_COLUMNS = "id,organization_id,room_name,slug,title,kind,host_user_id,scheduled_for,scheduled_duration_minutes,started_at,ended_at,locked,lobby_enabled,recording_policy,ai_enabled,metadata,time_zone,agenda,recurrence_rule,join_before_host,cancelled_at,cancellation_reason,deleted_at,calendar_sequence,version";
 var INVITEE_COLUMNS = "id,meeting_id,invitee_user_id,email,display_name,role,rsvp_state,responded_at,rsvp_note,last_sent_sequence,last_sent_at";
 var RECORDING_COLUMNS = "id,meeting_id,state,started_at,ended_at,started_by,file_id,failure_reason";
 var SEGMENT_COLUMNS = "id,meeting_id,identity,speaker,text,started_at,is_final,metadata";
 var NOTE_COLUMNS = "id,meeting_id,text,kind,assignee_user_id,created_at,metadata";
-var ATTENDEE_COLUMNS = "id,meeting_id,identity,participant_user_id,display_name,avatar_url,role,admission_state,is_agent,joined_at,left_at,sessions:metadata->sessions";
+var ATTENDEE_COLUMNS = "id,meeting_id,identity,participant_user_id,display_name,avatar_url,role,admission_state,knocked_at,knock_expires_at,is_agent,joined_at,left_at,sessions:metadata->sessions";
 function projectStays(value) {
   if (!Array.isArray(value)) return [];
   const stays = [];
@@ -2281,7 +2302,16 @@ function createMeetRepository(options) {
     const role = text(row, "role");
     const admission = text(row, "admission_state");
     const known = ["host", "cohost", "presenter", "participant", "viewer"];
-    const states = ["knocking", "admitted", "denied", "removed"];
+    const states = [
+      "waiting_host",
+      "knocking",
+      "admitted",
+      "denied",
+      "expired",
+      "withdrawn",
+      "removed",
+      "ended"
+    ];
     const userId = text(row, "participant_user_id");
     const identity = requireText(row, "identity", operation);
     return {
@@ -2295,6 +2325,8 @@ function createMeetRepository(options) {
       userId: userId === null ? null : asUserId(userId),
       role: known.includes(role) ? role : "participant",
       admissionState: states.includes(admission) ? admission : "admitted",
+      knockedAt: text(row, "knocked_at"),
+      knockExpiresAt: text(row, "knock_expires_at"),
       isAgent: bool(row, "is_agent", false),
       joinedAt: text(row, "joined_at"),
       leftAt: text(row, "left_at"),
@@ -2573,16 +2605,26 @@ function createMeetRepository(options) {
         hasMore: rows.length > limit
       };
     },
-    async admit({ meetingId, identity, admitted, byUserId }) {
-      await guardVoid(
-        "meet.admit",
-        () => db.rpc(RPCS.admit, {
+    async decideAdmission({ meetingId, identity, decision, byUserId }) {
+      const fn = decision === "admit" ? RPCS.admit : decision === "deny" ? RPCS.deny : RPCS.undeny;
+      const row = await guard(
+        `meet.${decision}`,
+        () => db.rpc(fn, {
           p_meeting_id: meetingId,
           p_identity: identity,
-          p_admitted: admitted,
           p_by_user_id: byUserId
         })
       );
+      return projectAttendee(row);
+    },
+    async admitAll(meetingId, byUserId) {
+      const response = await db.rpc(RPCS.admitAll, {
+        p_meeting_id: meetingId,
+        p_by_user_id: byUserId
+      });
+      if (response.error !== null) throw normalizeMeetError(response.error, "meet.admitAll");
+      const rows = Array.isArray(response.data) ? response.data : [];
+      return rows.map(projectAttendee);
     },
     async setLock(meetingId, locked, byUserId) {
       const row = await guard(
@@ -2930,6 +2972,7 @@ var NO_GRANTS = {
 };
 var EMPTY = {
   phase: "idle",
+  waiting: null,
   meeting: null,
   localIdentity: null,
   grants: NO_GRANTS,
@@ -4207,19 +4250,25 @@ function roleOf(participants, identity) {
   return participants.find((p) => p.identity === identity)?.role ?? "participant";
 }
 var END_MEETING_NOT_SERVED = "Ending a meeting is not available on this server yet";
-function lobbyEntryFrom(attendee) {
-  if (attendee.admissionState !== "knocking") return null;
+function lobbyEntryFrom(attendee, now = Date.now()) {
+  if (!WAITING_ADMISSION_STATES.includes(attendee.admissionState)) return null;
+  const expires = attendee.knockExpiresAt ? Date.parse(attendee.knockExpiresAt) : Number.NaN;
+  if (!Number.isNaN(expires) && expires <= now) return null;
   return {
     identity: attendee.identity,
     displayName: attendee.displayName,
     avatarUrl: attendee.avatarUrl,
     userId: attendee.userId,
     state: "knocking",
-    knockedAt: attendee.joinedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    knockedAt: attendee.knockedAt ?? attendee.joinedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    knockExpiresAt: attendee.knockExpiresAt ?? null,
     decidedAt: null,
     decidedBy: null
   };
 }
+function decidedState(state) {
+  return WAITING_ADMISSION_STATES.includes(state) ? "expired" : state;
+}
 function createMeetingSession(options) {
   const { manager, repository, store, identity } = options;
   let channel = null;
@@ -4243,11 +4292,6 @@ function createMeetingSession(options) {
     }
     return identity.userId;
   }
-  function knockIdentity() {
-    return asParticipantIdentity(
-      identity.userId !== null ? `user:${identity.userId}` : `guest:${identity.deviceId}`
-    );
-  }
   function requireMeeting(operation) {
     const meeting = store.snapshot().meeting;
     if (meeting === null) {
@@ -4259,6 +4303,191 @@ function createMeetingSession(options) {
     }
     return meeting;
   }
+  let polling = false;
+  let pollTimer = null;
+  let reading = null;
+  let admittedOnce = false;
+  let unlisten = null;
+  function report(level, message, remedy) {
+    options.onDiagnostic?.(remedy === void 0 ? { level, message } : { level, message, remedy });
+  }
+  function pollMs() {
+    const seconds = store.snapshot().waiting?.pollSeconds ?? 3;
+    return Math.max(1, Math.min(60, seconds)) * 1e3;
+  }
+  function schedule(ms2) {
+    if (pollTimer !== null) clearTimeout(pollTimer);
+    if (!polling) return;
+    pollTimer = setTimeout(() => {
+      pollTimer = null;
+      void readState2().finally(() => schedule(pollMs()));
+    }, ms2);
+  }
+  function listen() {
+    if (unlisten !== null || typeof window === "undefined") return;
+    const nudge = () => {
+      if (typeof document !== "undefined" && document.visibilityState === "hidden") return;
+      void readState2();
+    };
+    const goodbye = () => {
+      const meeting = store.snapshot().meeting;
+      const pass = options.resolvePass?.() ?? null;
+      const waiting = store.snapshot().waiting;
+      if (meeting === null || pass === null || waiting === null) return;
+      if (!WAITING_ADMISSION_STATES.includes(waiting.admission)) return;
+      try {
+        navigator.sendBeacon?.(
+          options.api.url(MEET_ROUTES.leave),
+          new Blob([JSON.stringify({ meeting_id: meeting.id, intent: "withdraw", meeting_pass: pass })], {
+            type: "application/json"
+          })
+        );
+      } catch {
+      }
+    };
+    window.addEventListener("online", nudge);
+    window.addEventListener("pagehide", goodbye);
+    document.addEventListener("visibilitychange", nudge);
+    unlisten = () => {
+      window.removeEventListener("online", nudge);
+      window.removeEventListener("pagehide", goodbye);
+      document.removeEventListener("visibilitychange", nudge);
+    };
+  }
+  function stopWaiting() {
+    polling = false;
+    if (pollTimer !== null) clearTimeout(pollTimer);
+    pollTimer = null;
+    unlisten?.();
+    unlisten = null;
+  }
+  function patchWaiting(next) {
+    const current = store.snapshot().waiting;
+    const base = current ?? {
+      admission: "knocking",
+      admittersPresent: null,
+      reknockAllowed: true,
+      knockExpiresAt: null,
+      pollSeconds: 3,
+      liveVersion: 0
+    };
+    store.patch({ waiting: { ...base, ...next } });
+  }
+  function apply(read) {
+    const snapshot = store.snapshot();
+    if (snapshot.phase !== "lobby") return;
+    const admission = read.admission_state ?? null;
+    const ended = admission === "ended" || read.session_phase === "ended" || read.meeting_phase === "ended";
+    if (admission === "admitted" && !ended) {
+      if (admittedOnce) return;
+      admittedOnce = true;
+      stopWaiting();
+      options.onAdmitted?.();
+      return;
+    }
+    if (ended) {
+      stopWaiting();
+      patchWaiting({ admission: "ended" });
+      const meeting = snapshot.meeting;
+      if (read.meeting_phase === "ended" && meeting !== null && meeting.endedAt === null) {
+        store.patch({ meeting: { ...meeting, endedAt: (/* @__PURE__ */ new Date()).toISOString() } });
+      }
+      return;
+    }
+    if (admission === null) return;
+    patchWaiting({
+      admission,
+      admittersPresent: read.admitters_present ?? null,
+      reknockAllowed: read.reknock_allowed ?? true,
+      knockExpiresAt: read.knock_expires_at ?? null,
+      pollSeconds: read.poll_seconds ?? snapshot.waiting?.pollSeconds ?? 3,
+      liveVersion: read.live_version ?? 0
+    });
+    if (admission === "denied" || admission === "expired" || admission === "withdrawn" || admission === "removed") {
+      stopWaiting();
+    }
+  }
+  async function readState2() {
+    if (reading !== null) return reading;
+    const meeting = store.snapshot().meeting;
+    const pass = options.resolvePass?.() ?? null;
+    if (meeting === null || pass === null) return;
+    reading = (async () => {
+      try {
+        const response = await options.api.request({
+          path: `${MEET_ROUTES.state}?meeting_id=${encodeURIComponent(meeting.id)}`,
+          method: "GET",
+          requireAuth: false,
+          operation: "meet.state",
+          headers: { [MEETING_PASS_HEADER]: pass }
+        });
+        if (!response.ok) {
+          let body = null;
+          try {
+            body = await response.json();
+          } catch {
+            body = null;
+          }
+          const refusal2 = readServerRefusal(body);
+          report(
+            "warn",
+            refusal2?.reason ?? `meet.state: the server answered ${response.status}`,
+            refusal2?.remedy ?? "The waiting room keeps asking; nothing on this screen changes until the server answers."
+          );
+          return;
+        }
+        apply(await response.json());
+      } catch (error) {
+        report("info", `meet.state: ${String(error)}`, "Waiting continues; the state is read again shortly.");
+      } finally {
+        reading = null;
+      }
+    })();
+    return reading;
+  }
+  async function postLeave(intent) {
+    const meeting = requireMeeting(`meet.${intent}`);
+    const pass = options.resolvePass?.() ?? null;
+    const response = await options.api.request({
+      path: MEET_ROUTES.leave,
+      method: "POST",
+      requireAuth: false,
+      operation: `meet.${intent}`,
+      body: { meeting_id: meeting.id, intent },
+      ...pass !== null ? { headers: { [MEETING_PASS_HEADER]: pass } } : {}
+    });
+    if (!response.ok) {
+      let body = null;
+      try {
+        body = await response.json();
+      } catch {
+        body = null;
+      }
+      const refusal2 = readServerRefusal(body);
+      throw new MeetError(
+        "transport",
+        refusal2?.reason ?? `meet.${intent}: the server answered ${response.status}`,
+        refusal2?.remedy ?? "You are still in the waiting room. Try again."
+      );
+    }
+  }
+  function hint() {
+    channel?.send(MEET_EVENTS.stateChanged, { v: null });
+  }
+  async function refreshQueue() {
+    const meeting = store.snapshot().meeting;
+    if (meeting === null || isGuest(identity) || !isHostRole(effectiveRole(store.snapshot()))) return;
+    try {
+      const attendees = await repository.attendees(meeting.id);
+      store.learn(attendees);
+      for (const attendee of attendees) {
+        const entry = lobbyEntryFrom(attendee);
+        if (entry !== null) store.upsertLobby(entry);
+        else store.setAdmission(attendee.identity, decidedState(attendee.admissionState), null);
+      }
+    } catch {
+    }
+  }
   return {
     watch(roomName) {
       channel?.close();
@@ -4266,58 +4495,22 @@ function createMeetingSession(options) {
         topic: roomTopic(roomName),
         broadcast: [
           {
-            event: MEET_EVENTS.knock,
-            onMessage: (message) => {
-              store.upsertLobby(message.data);
-            }
-          },
-          {
-            event: MEET_EVENTS.admission,
-            onMessage: (message) => {
-              const verdict = message.data;
-              const decided = asParticipantIdentity(verdict.identity);
-              store.setAdmission(
-                decided,
-                verdict.admitted ? "admitted" : "denied",
-                verdict.by === null ? null : verdict.by
-              );
-              if (decided === knockIdentity()) {
-                if (verdict.admitted) options.onAdmitted?.();
-                else options.onDenied?.();
-              }
-            }
-          },
-          {
-            event: MEET_EVENTS.lock,
-            onMessage: (message) => {
-              const { locked } = message.data;
-              const meeting = store.snapshot().meeting;
-              store.patch({
-                locked,
-                ...meeting !== null ? { meeting: { ...meeting, locked } } : {}
-              });
-            }
-          },
-          {
-            event: MEET_EVENTS.recording,
-            onMessage: (message) => {
-              const payload = message.data;
-              store.setRecording(
-                payload.state,
-                payload.by === null ? null : payload.by,
-                "room"
-              );
+            // 🚨 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();
+              void refreshQueue();
             }
           }
         ],
-        // THE BACKFILL DOOR. A host whose socket blipped must not miss a knock:
-        // re-reading the meeting restores lock/recording truth, and knockers
-        // re-announce on their own timer.
+        // THE BACKFILL DOOR. A socket blip must not lose a decision: re-read the meeting
+        // row, and a waiting tab re-reads its own state.
         onBackfill: async () => {
           const meeting = store.snapshot().meeting;
           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();
         }
       });
     },
@@ -4378,7 +4571,7 @@ function createMeetingSession(options) {
                 store.upsertLobby(entry);
                 return;
               }
-              store.setAdmission(attendee.identity, attendee.admissionState, null);
+              store.setAdmission(attendee.identity, decidedState(attendee.admissionState), null);
             }
           },
           {
@@ -4430,62 +4623,75 @@ function createMeetingSession(options) {
             if (entry !== null) {
               store.upsertLobby(entry);
             } else {
-              store.setAdmission(attendee.identity, attendee.admissionState, null);
+              store.setAdmission(attendee.identity, decidedState(attendee.admissionState), null);
             }
           }
         }
       });
       meetingChannel.requestBackfill("manual");
     },
-    knock(roomName) {
-      const handle = channel ?? manager.open({ topic: roomTopic(roomName) });
-      channel = handle;
-      const entry = {
-        identity: knockIdentity(),
-        displayName: identity.displayName,
-        avatarUrl: identity.avatarUrl,
-        userId: identity.userId,
-        state: "knocking",
-        knockedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        decidedAt: null,
-        decidedBy: null
-      };
-      store.upsertLobby(entry);
-      handle.send(MEET_EVENTS.knock, entry);
-    },
     async admit(entry, admitted) {
       const by = requireHostUser("meet.admit");
       const meeting = requireMeeting("meet.admit");
-      await repository.admit({
+      const row = await repository.decideAdmission({
         meetingId: meeting.id,
         identity: entry.identity,
-        admitted,
+        decision: admitted ? "admit" : "deny",
         byUserId: by
       });
       store.upsertLobby({
         ...entry,
-        state: admitted ? "admitted" : "denied",
+        state: decidedState(row.admissionState),
         decidedAt: (/* @__PURE__ */ new Date()).toISOString(),
         decidedBy: by
       });
-      channel?.send(MEET_EVENTS.admission, {
+      hint();
+    },
+    async undeny(entry) {
+      const by = requireHostUser("meet.undeny");
+      const meeting = requireMeeting("meet.undeny");
+      const row = await repository.decideAdmission({
+        meetingId: meeting.id,
         identity: entry.identity,
-        admitted,
-        by
+        decision: "undeny",
+        byUserId: by
       });
+      store.upsertLobby({ ...entry, state: decidedState(row.admissionState), decidedAt: (/* @__PURE__ */ new Date()).toISOString(), decidedBy: by });
+      hint();
     },
     async admitAll() {
-      const knocking = store.snapshot().lobby.filter((entry) => entry.state === "knocking");
-      for (const entry of knocking) {
-        await this.admit(entry, true);
+      const by = requireHostUser("meet.admitAll");
+      const meeting = requireMeeting("meet.admitAll");
+      const rows = await repository.admitAll(meeting.id, by);
+      for (const row of rows) {
+        store.setAdmission(row.identity, row.admissionState, by);
       }
+      hint();
+    },
+    startWaiting() {
+      if (polling) return;
+      polling = true;
+      admittedOnce = false;
+      listen();
+      schedule(0);
+    },
+    stopWaiting,
+    readState: readState2,
+    async withdraw() {
+      stopWaiting();
+      await postLeave("withdraw");
+      patchWaiting({ admission: "withdrawn" });
+      hint();
+    },
+    async askAgain() {
+      await options.rejoin?.();
     },
     async setLock(locked) {
       const by = requireHostUser("meet.setLock");
       const meeting = requireMeeting("meet.setLock");
       const updated = await repository.setLock(meeting.id, locked, by);
       store.patch({ meeting: updated, locked: updated.locked });
-      channel?.send(MEET_EVENTS.lock, { locked: updated.locked });
+      hint();
       return updated;
     },
     /**
@@ -4543,6 +4749,7 @@ function createMeetingSession(options) {
       return { endedAt, served: true };
     },
     dispose() {
+      stopWaiting();
       channel?.close();
       channel = null;
       meetingChannel?.close();
@@ -5403,7 +5610,7 @@ function createRoomEngine(options) {
     }
   };
   async function connect(request) {
-    store.patch({ phase: "requesting-token", failure: null });
+    store.patch({ phase: "requesting-token", failure: null, waiting: null });
     const token = await tokens.get({
       roomName: request.roomName,
       identity,
@@ -5423,11 +5630,21 @@ function createRoomEngine(options) {
         canSubscribe: token.canSubscribe
       }
     });
-    if (token.lobby) {
-      store.patch({ phase: "lobby" });
+    if (token.lobby || !token.canSubscribe) {
+      store.patch({
+        phase: "lobby",
+        waiting: {
+          admission: token.admissionState !== void 0 && token.admissionState !== "admitted" ? token.admissionState : "knocking",
+          admittersPresent: null,
+          reknockAllowed: true,
+          knockExpiresAt: null,
+          pollSeconds: token.pollSeconds ?? 3,
+          liveVersion: 0
+        }
+      });
       return;
     }
-    store.patch({ phase: "connecting" });
+    store.patch({ phase: "connecting", waiting: null });
     const created = await options.driverFactory(handlers);
     if (disposed) {
       await created.disconnect();
@@ -6686,7 +6903,7 @@ function observedPhase(input) {
     case "left":
       return "prejoin";
     case "lobby":
-      return "waiting:knocking";
+      return waitingPhase(snapshot);
     case "requesting-token":
     case "connecting":
       return "joining";
@@ -6695,6 +6912,24 @@ function observedPhase(input) {
       return "in_call";
   }
 }
+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";
+  }
+}
 var ADMITTER_ROLES = /* @__PURE__ */ new Set(["host", "cohost"]);
 function observe(input) {
   const { snapshot } = input;
@@ -6709,7 +6944,7 @@ function observe(input) {
     reason: phase.startsWith("refused:") ? phase.slice("refused:".length) : null,
     role,
     connection: snapshot?.phase === "reconnecting" ? "reconnecting" : "stable",
-    hostPresent: inCall && snapshot !== null ? snapshot.participants.some((p) => ADMITTER_ROLES.has(p.role)) : null,
+    hostPresent: inCall && snapshot !== null ? snapshot.participants.some((p) => ADMITTER_ROLES.has(p.role)) : snapshot?.phase === "lobby" ? 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,