@ai-matrx/meet 0.7.77 → 0.7.79

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog — `@ai-matrx/meet`
 
+## 0.7.79
+
+**A meeting's record is read once per tab, and kept live.** `useMeetingRecord` held the bundle
+in its own state and read all four parts (`meet_participants`, `meet_notes`,
+`meet_transcript_segments`, `meet_recordings`) on every mount — so a board tile that slept
+and woke (React `<Activity>` re-runs every effect), a Remove + Undo, and every second view of
+the same meeting read the whole record again. The record now lives in one per-tab cache
+(`core/record-cache.ts`, keyed by reader + meeting): the first view reads, later views and
+remounts render the kept record and read nothing; a read in flight is joined; Retry and a
+reconnect read again, and an older answer never paints over a newer one. A member's record is
+kept current by ONE change-feed channel per meeting (notes, transcript, attendance,
+recordings — applied row by row, no re-read), held while any view is mounted and 60 s after;
+past that the record is marked stale and the next view reads it once. A meeting rename
+re-assembles the kept record instead of re-reading it. New exports: `loadMeetingRecordParts`,
+`assembleMeetingRecord`, `createMeetingRecordCache`, `MEETING_RECORD_GRACE_MS`, and
+`meetingRecordCache()` from `/react`. Guard: `react/meeting-record-reads-once.test.tsx`
+(4/4 red on 0.7.78).
+
+Consumer action: none. A host test that renders the record for the same meeting twice and
+expects two reads resets the cache between cases (`meetingRecordCache().reset()`).
+
+## 0.7.78
+
+**A meeting can run inside a box.** `.mx-meet` was `height: 100dvh`, so a stage mounted in a
+board tile or a pane was as tall as the window and its control bar fell below the box. The
+height now reads `var(--mx-meet-height, 100dvh)`: unchanged by default; a host sets
+`--mx-meet-height: 100%` on an ancestor with a definite height to contain every screen.
+Guard: `styles.test.ts` "the stage's height".
+
+Consumer action: none (opt-in).
+
 ## 0.7.77
 
 The pre-join background choice spans its column (`SegmentedControl fullWidth`) instead of

package/README.md

@@ -192,6 +192,10 @@ export function App({ children }) {
 <MeetingRoom roomName={roomName} meetingId={meetingId} />
 ```
 
+The stage fills the viewport (`100dvh`). To run a meeting inside a box — a board tile, a split
+pane — give an ancestor a definite height and set `--mx-meet-height: 100%` on it; every screen
+(pre-join, lobby, room, record) then fills that box.
+
 🚨 **You do not tell Meet who the user is, and there is no prop for it.** The acting user is read
 from `client`'s own session — the same client that mints the JWT on every request — so the id in a
 `p_user_id` argument and the id in the token cannot disagree. Through 0.5.x this WAS a prop, every

package/dist/index.cjs

@@ -50,6 +50,7 @@ __export(src_exports, {
   LISTEN_ONLY_NOTICE: () => LISTEN_ONLY_NOTICE,
   MEETING_INVITE_KIND: () => MEETING_INVITE_KIND,
   MEETING_INVITE_VERSION: () => MEETING_INVITE_VERSION,
+  MEETING_RECORD_GRACE_MS: () => MEETING_RECORD_GRACE_MS,
   MEET_ANSWER_CONTEXT_EVENT: () => MEET_ANSWER_CONTEXT_EVENT,
   MEET_ANSWER_EVENTS: () => MEET_ANSWER_EVENTS,
   MEET_EVENTS: () => MEET_EVENTS,
@@ -84,6 +85,7 @@ __export(src_exports, {
   asParticipantIdentity: () => asParticipantIdentity,
   asRoomName: () => asRoomName,
   asUserId: () => asUserId,
+  assembleMeetingRecord: () => assembleMeetingRecord,
   assignedRoom: () => assignedRoom,
   attendanceCsv: () => attendanceCsv,
   attendanceReport: () => attendanceReport,
@@ -113,6 +115,7 @@ __export(src_exports, {
   createMeetRepository: () => createMeetRepository,
   createMeetStore: () => createMeetStore,
   createMeetingInviteHandler: () => createMeetingInviteHandler,
+  createMeetingRecordCache: () => createMeetingRecordCache,
   createMeetingSession: () => createMeetingSession,
   createMemoryDeviceStorage: () => createMemoryDeviceStorage,
   createRecordingController: () => createRecordingController,
@@ -147,6 +150,7 @@ __export(src_exports, {
   loadMeetingActivities: () => loadMeetingActivities,
   loadMeetingChat: () => loadMeetingChat,
   loadMeetingRecord: () => loadMeetingRecord,
+  loadMeetingRecordParts: () => loadMeetingRecordParts,
   mapConnectionState: () => mapConnectionState,
   mapQuality: () => mapQuality,
   meetingInviteAction: () => meetingInviteAction,
@@ -1033,13 +1037,13 @@ function mergeCaption(list, caption) {
   return list.map((entry, position) => position === index ? caption : entry);
 }
 function mergeRecord(list, record) {
-  const byId = list.findIndex((entry) => entry.source === "record" && entry.id === record.id);
-  if (byId !== -1) {
-    const existing = list[byId];
+  const byId2 = list.findIndex((entry) => entry.source === "record" && entry.id === record.id);
+  if (byId2 !== -1) {
+    const existing = list[byId2];
     if (existing !== void 0 && existing.text === record.text && existing.final === record.final) {
       return list;
     }
-    return list.map((entry, position) => position === byId ? record : entry);
+    return list.map((entry, position) => position === byId2 ? record : entry);
   }
   const captionIndex = list.findIndex((entry) => supersedes(record, entry));
   if (captionIndex === -1) return [...list, record];
@@ -5869,6 +5873,9 @@ function restrictionFor(part, error) {
   };
 }
 async function loadMeetingRecord(repository, meetingId, meeting, reader = { userId: null }) {
+  return assembleMeetingRecord(meeting, await loadMeetingRecordParts(repository, meetingId, reader));
+}
+async function loadMeetingRecordParts(repository, meetingId, reader = { userId: null }) {
   const restrictions = [];
   async function attempt(part, run, empty) {
     if (reader.userId === null) {
@@ -5896,6 +5903,10 @@ async function loadMeetingRecord(repository, meetingId, meeting, reader = { user
       []
     )
   ]);
+  return { attendees, notes, transcript, recordings, restrictions };
+}
+function assembleMeetingRecord(meeting, parts) {
+  const { attendees, notes, transcript, recordings, restrictions } = parts;
   return {
     meeting,
     attendees,
@@ -6240,4 +6251,208 @@ async function setGuestRecordAccess(args) {
   };
 }
 var GUEST_RECORD_NOT_SHARED = NOT_SHARED;
+
+// src/core/record-cache.ts
+var MEETING_RECORD_GRACE_MS = 6e4;
+var INITIAL = { loading: true, record: null, failure: null };
+function upsert2(rows, row, removedId, order) {
+  const id = row?.id ?? removedId;
+  if (id === void 0) return rows;
+  const rest = rows.filter((existing) => existing.id !== id);
+  return row === null ? rest : [...rest, row].sort(order);
+}
+var byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+var ascending = (a, b) => a === b ? 0 : a === null ? 1 : b === null ? -1 : a < b ? -1 : 1;
+function createMeetingRecordCache(options = {}) {
+  const graceMs = options.graceMs ?? MEETING_RECORD_GRACE_MS;
+  const entries = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+  const entryOf = (key) => {
+    let entry = entries.get(key);
+    if (!entry) {
+      entry = {
+        state: INITIAL,
+        meeting: null,
+        parts: null,
+        fresh: false,
+        seq: 0,
+        inflight: null,
+        holders: 0,
+        close: null,
+        owner: null,
+        grace: null
+      };
+      entries.set(key, entry);
+    }
+    return entry;
+  };
+  const assemble = (entry) => {
+    if (entry.meeting === null || entry.parts === null) return;
+    entry.state = { loading: false, failure: null, record: assembleMeetingRecord(entry.meeting, entry.parts) };
+    notify();
+  };
+  return {
+    state: (key) => key === null ? INITIAL : entries.get(key)?.state ?? INITIAL,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    ensure(key, read, { force = false } = {}) {
+      const entry = entryOf(key);
+      if (!force) {
+        if (entry.inflight !== null) return entry.inflight;
+        if (entry.fresh) return Promise.resolve();
+      }
+      const seq = ++entry.seq;
+      if (entry.state.failure !== null) {
+        entry.state = { ...entry.state, loading: true, failure: null };
+        notify();
+      }
+      const request = read().then(
+        (answer) => {
+          if (seq !== entry.seq) return;
+          entry.fresh = true;
+          if (answer.kind === "parts") {
+            entry.meeting = answer.meeting;
+            entry.parts = answer.parts;
+            assemble(entry);
+          } else {
+            entry.meeting = answer.bundle.meeting;
+            entry.parts = null;
+            entry.state = { loading: false, failure: null, record: answer.bundle };
+            notify();
+          }
+        },
+        (thrown) => {
+          if (seq !== entry.seq) return;
+          entry.fresh = false;
+          entry.state = {
+            loading: false,
+            record: entry.state.record,
+            failure: {
+              message: thrown?.message ?? String(thrown),
+              remedy: thrown?.remedy ?? "The meeting record could not be read. Reload the page; nothing was changed."
+            }
+          };
+          notify();
+        }
+      );
+      const tracked = request.finally(() => {
+        if (entry.inflight === tracked) entry.inflight = null;
+      });
+      entry.inflight = tracked;
+      return tracked;
+    },
+    setMeeting(key, meeting) {
+      const entry = entries.get(key);
+      if (!entry || entry.meeting === meeting) return;
+      if (entry.parts !== null) {
+        entry.meeting = meeting;
+        assemble(entry);
+      } else if (entry.state.record !== null) {
+        entry.meeting = meeting;
+        entry.state = { ...entry.state, record: { ...entry.state.record, meeting } };
+        notify();
+      }
+    },
+    apply(key, change) {
+      const entry = entries.get(key);
+      const parts = entry?.parts;
+      if (!entry || !parts) return;
+      const refused = parts.restrictions.some((r) => r.part === change.part);
+      if (refused) return;
+      switch (change.part) {
+        case "transcript":
+          entry.parts = {
+            ...parts,
+            transcript: upsert2(
+              parts.transcript,
+              change.row,
+              change.removedId,
+              (a, b) => ascending(a.startedAt, b.startedAt) || byId(a, b)
+            )
+          };
+          break;
+        case "notes":
+          entry.parts = {
+            ...parts,
+            notes: upsert2(
+              parts.notes,
+              change.row,
+              change.removedId,
+              (a, b) => ascending(a.createdAt, b.createdAt) || byId(a, b)
+            )
+          };
+          break;
+        case "attendance":
+          entry.parts = {
+            ...parts,
+            attendees: upsert2(
+              parts.attendees,
+              change.row,
+              change.removedId,
+              (a, b) => ascending(a.joinedAt, b.joinedAt) || byId(a, b)
+            )
+          };
+          break;
+        case "recording":
+          entry.parts = {
+            ...parts,
+            // Newest first, as the read orders them.
+            recordings: upsert2(
+              parts.recordings,
+              change.row,
+              change.removedId,
+              (a, b) => ascending(b.startedAt, a.startedAt) || byId(a, b)
+            )
+          };
+          break;
+      }
+      assemble(entry);
+    },
+    hold(key, open, owner = null) {
+      const entry = entryOf(key);
+      if (entry.grace !== null) {
+        clearTimeout(entry.grace);
+        entry.grace = null;
+      }
+      if (entry.close !== null && entry.owner !== owner) {
+        entry.close();
+        entry.close = null;
+      }
+      if (entry.close === null) {
+        entry.close = open();
+        entry.owner = owner;
+      }
+      entry.holders += 1;
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        entry.holders -= 1;
+        if (entry.holders > 0) return;
+        entry.grace = setTimeout(() => {
+          entry.grace = null;
+          if (entry.holders > 0) return;
+          entry.close?.();
+          entry.close = null;
+          entry.fresh = false;
+        }, graceMs);
+      };
+    },
+    reset() {
+      for (const entry of entries.values()) {
+        if (entry.grace !== null) clearTimeout(entry.grace);
+        entry.close?.();
+      }
+      entries.clear();
+      notify();
+    }
+  };
+}
 //# sourceMappingURL=index.cjs.map