@ai-matrx/meet 0.7.84 → 0.8.0

package/dist/collab-Bss-_Jfp.d.cts

@@ -0,0 +1,805 @@
+/**
+ * THE MEET DOMAIN MODEL.
+ *
+ * D3: an audio call, a video call, and a meeting are ONE thing — a room. An
+ * audio call is a room with video off; a meeting is a room plus scheduling,
+ * lobby and host metadata. That ruling is expressed here as ONE `MeetRoom`
+ * identity carried by both `/calls` and `/meetings`, not as three parallel
+ * hierarchies that drift.
+ *
+ * Identity-bearing values are BRANDED (C22). A `MeetingId` and a `RoomName` are
+ * both strings and are NOT interchangeable — passing the meeting's row id where
+ * LiveKit wants the room name produces a room nobody else joins, which looks
+ * exactly like "the other person's camera is broken".
+ */
+declare const brand: unique symbol;
+type Brand<T, B extends string> = T & {
+    readonly [brand]: B;
+};
+type MeetingId = Brand<string, "MeetingId">;
+type CallId = Brand<string, "CallId">;
+/** The LiveKit room name. THE MEDIA ROOM KEY — durable for a meeting link. */
+type RoomName = Brand<string, "RoomName">;
+type UserId = Brand<string, "UserId">;
+type OrganizationId = Brand<string, "OrganizationId">;
+/** LiveKit participant identity. `user:<uuid>` or `guest:<opaque>`. */
+type ParticipantIdentity = Brand<string, "ParticipantIdentity">;
+declare const asMeetingId: (value: string) => MeetingId;
+declare const asCallId: (value: string) => CallId;
+declare const asRoomName: (value: string) => RoomName;
+declare const asUserId: (value: string) => UserId;
+declare const asOrganizationId: (value: string) => OrganizationId;
+declare const asParticipantIdentity: (value: string) => ParticipantIdentity;
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+/** Audio-only or with video. A call escalates; it never becomes a new call. */
+type CallMode = "audio" | "video";
+/**
+ * WHO IS IN THE ROOM, as far as authorization is concerned.
+ *
+ * A guest has no `userId` — by construction, not by convention. Everything that
+ * requires authentication (host powers, recording, starting a call) takes a
+ * `userId` and therefore cannot compile against a guest identity (D6).
+ */
+interface MeetIdentity {
+    readonly userId: UserId | null;
+    readonly organizationId: OrganizationId;
+    readonly displayName: string;
+    readonly avatarUrl: string | null;
+    /** Stable per-device value so a reconnect keeps ONE LiveKit identity. */
+    readonly deviceId: string;
+}
+declare function isGuest(identity: MeetIdentity): boolean;
+/**
+ * WHO SOMEBODY IS IN A ROOM — the SERVER's word, never this client's (MRI-A11).
+ *
+ * `host` is `meet_meetings.host_user_id` or a real `iam` grant on the meeting;
+ * `participant` is an authenticated member of the meeting's organization;
+ * `guest` is a link-follower with no session. Organization membership is
+ * TENANCY and never permission, which is why "member of the org" lands on
+ * `participant` and not on `host`.
+ *
+ * `cohost` has no server-side minter yet and is kept because the rank ladder
+ * below is the thing that stops a co-host from removing the host; the moment a
+ * co-host grant exists it slots in without a second vocabulary.
+ */
+type ParticipantRole = "host" | "cohost" | "participant" | "guest";
+/** Rank, so "can this actor do that to that participant" is one comparison. */
+declare const ROLE_RANK: Readonly<Record<ParticipantRole, number>>;
+/**
+ * 🚨 THE ONE PREDICATE FOR "DOES THIS PERSON HOLD HOST POWERS".
+ *
+ * Every host control in this package answers this question and no other. It is
+ * a pure function of a SERVER-minted role, so there is no path by which a
+ * client's own state can grant it anything.
+ */
+declare function isHostRole(role: ParticipantRole): boolean;
+/**
+ * THE LOBBY LADDER (D6). A guest link-follower starts `knocking`; the host
+ * admits or denies. An authenticated member of the meeting's org is `admitted`
+ * on arrival unless the meeting is locked.
+ */
+type AdmissionState = "knocking" | "admitted" | "denied" | "removed";
+interface LobbyEntry {
+    readonly identity: ParticipantIdentity;
+    readonly displayName: string;
+    readonly avatarUrl: string | null;
+    readonly userId: UserId | null;
+    readonly state: AdmissionState;
+    readonly knockedAt: string;
+    readonly decidedAt: string | null;
+    readonly decidedBy: UserId | null;
+}
+type ConnectionQuality = "excellent" | "good" | "poor" | "lost" | "unknown";
+/** One person in the room, as the UI needs them. Media state is a FACT here. */
+interface MeetParticipant {
+    readonly identity: ParticipantIdentity;
+    readonly userId: UserId | null;
+    readonly displayName: string;
+    readonly avatarUrl: string | null;
+    readonly role: ParticipantRole;
+    /**
+     * Whether the SERVER granted this participant the power to start a recording
+     * (MRI-A11). It is not `role === "host"`: a meeting whose recording policy is
+     * `always-on` is the server's to start and a host may not touch it, and a
+     * `disabled` policy grants it to nobody. The client renders this; it never
+     * recomputes the policy.
+     */
+    readonly canRecord: boolean;
+    readonly isLocal: boolean;
+    readonly isAgent: boolean;
+    readonly micEnabled: boolean;
+    readonly cameraEnabled: boolean;
+    readonly screenSharing: boolean;
+    readonly speaking: boolean;
+    readonly handRaised: boolean;
+    /**
+     * When the hand went up (epoch ms), or null. The HAND QUEUE is ordered by it —
+     * first raised, first called on (Meet wave 2). Optional so a roster built by a
+     * host before 0.8 still type-checks.
+     */
+    readonly handRaisedAt?: number | null | undefined;
+    readonly quality: ConnectionQuality;
+    readonly joinedAt: string;
+    /**
+     * LiveKit participant attributes, verbatim. The note-taker announces itself
+     * here (`matrx.agent.consent_notice`), which is how a consent notice can be
+     * rendered for a participant whose token metadata this client cannot read.
+     */
+    readonly attributes: Readonly<Record<string, string>>;
+}
+type RoomPhase = "idle" | "requesting-token" | "lobby" | "connecting" | "connected" | "reconnecting" | "left" | "failed";
+type MeetingKind = "instant" | "scheduled" | "recurring";
+interface MeetingRecord {
+    readonly id: MeetingId;
+    readonly organizationId: OrganizationId;
+    /** Durable: the same room name before, during, and after (R3). */
+    readonly roomName: RoomName;
+    /** The public slug in a meeting link. Durable for recurring meetings. */
+    readonly slug: string;
+    readonly title: string;
+    readonly kind: MeetingKind;
+    readonly hostUserId: UserId;
+    readonly scheduledFor: string | null;
+    readonly scheduledDurationMinutes: number | null;
+    readonly startedAt: string | null;
+    readonly endedAt: string | null;
+    readonly locked: boolean;
+    readonly lobbyEnabled: boolean;
+    readonly recordingPolicy: RecordingPolicy;
+    readonly aiEnabled: boolean;
+    readonly metadata: JsonObject;
+    /** IANA zone the meeting's wall-clock time is authored in (`America/Los_Angeles`). */
+    readonly timeZone?: string;
+    /** Description / agenda text. */
+    readonly agenda?: string | null;
+    /** RFC 5545 RRULE subset — one row and one durable link per series. */
+    readonly recurrenceRule?: string | null;
+    /** Signed-in members and invitees may enter before a host arrives. */
+    readonly joinBeforeHost?: boolean;
+    /** Cancel is a STATE: the link still resolves and says so; nobody can join. */
+    readonly cancelledAt?: string | null;
+    readonly cancellationReason?: string | null;
+    /** Archived (soft deleted). Restorable by the host or a co-host. */
+    readonly deletedAt?: string | null;
+    /** iCalendar SEQUENCE — bumped by the database on every reschedule and on cancel. */
+    readonly calendarSequence?: number;
+    /** Row version, for the compare-and-swap in `updateMeeting`. */
+    readonly version?: number;
+}
+/** An invitee's answer. `needs_action` = not answered yet (iCalendar NEEDS-ACTION). */
+type RsvpState = "needs_action" | "accepted" | "declined" | "tentative";
+/** The answers a person can give. */
+type RsvpAnswer = Exclude<RsvpState, "needs_action">;
+/** A co-host holds host moderation through a real `iam` admin grant on the meeting. */
+type InviteeRole = "invitee" | "cohost";
+/** One person a meeting was sent to (`communication.meet_invitees`). */
+interface MeetingInvitee {
+    readonly id: string;
+    readonly meetingId: MeetingId;
+    /** Set when the person has an account — they skip the waiting room and answer in-app. */
+    readonly userId: UserId | null;
+    readonly email: string | null;
+    readonly displayName: string | null;
+    readonly role: InviteeRole;
+    readonly rsvpState: RsvpState;
+    readonly respondedAt: string | null;
+    readonly rsvpNote: string | null;
+    /** The calendar_sequence of the last invitation they were sent; null = never told. */
+    readonly lastSentSequence: number | null;
+    readonly lastSentAt: string | null;
+}
+/** Who to invite: an account (`userId`) or an address (`email`), or both. */
+interface InviteeInput {
+    readonly userId?: UserId | undefined;
+    readonly email?: string | undefined;
+    readonly displayName?: string | undefined;
+    /** Omit to keep an existing invitee's role; `cohost` needs the host or a co-host. */
+    readonly role?: InviteeRole | undefined;
+}
+/** Where one occurrence of a meeting stands. */
+type OccurrenceState = "scheduled" | "moved" | "cancelled";
+/** One occurrence — for a one-off meeting, the meeting itself. */
+interface MeetingOccurrence {
+    readonly meetingId: MeetingId;
+    /** The start the rule generates (iCalendar RECURRENCE-ID). The key for exceptions. */
+    readonly originalStart: string;
+    /** When it actually happens (differs from `originalStart` only when `moved`). */
+    readonly occurrenceStart: string;
+    readonly durationMinutes: number | null;
+    readonly state: OccurrenceState;
+    readonly sequence: number;
+}
+/** One row of the Upcoming list — an occurrence plus what the list shows about its meeting. */
+interface UpcomingOccurrence extends MeetingOccurrence {
+    readonly organizationId: OrganizationId;
+    readonly title: string;
+    readonly slug: string;
+    readonly kind: MeetingKind;
+    readonly hostUserId: UserId;
+    readonly timeZone: string;
+    readonly meetingCancelled: boolean;
+    /** The signed-in reader's own answer, when they are an invitee. */
+    readonly myRsvp: RsvpState | null;
+    /** `host`, `cohost` or `invitee` — null when the reader simply can see it (org member). */
+    readonly myRole: "host" | InviteeRole | null;
+}
+/** An exception row (`communication.meet_occurrence_overrides`). */
+interface OccurrenceOverride {
+    readonly id: string;
+    readonly meetingId: MeetingId;
+    readonly originalStart: string;
+    readonly state: "cancelled" | "moved";
+    readonly newStart: string | null;
+    readonly newDurationMinutes: number | null;
+    readonly reason: string | null;
+    readonly calendarSequence: number;
+    /** Set when the exception was withdrawn (`restore`) and the occurrence is back on schedule. */
+    readonly deletedAt: string | null;
+}
+/** Settings a meeting carries; unset ones come from the person's / organization's knobs. */
+interface MeetingSettings {
+    readonly lobbyEnabled?: boolean | undefined;
+    readonly recordingPolicy?: RecordingPolicy | undefined;
+    readonly aiEnabled?: boolean | undefined;
+    readonly joinBeforeHost?: boolean | undefined;
+}
+/** A partial edit. `null` clears a clearable field (agenda, recurrence rule, time). */
+interface MeetingChanges extends MeetingSettings {
+    readonly title?: string | undefined;
+    readonly agenda?: string | null | undefined;
+    readonly timeZone?: string | undefined;
+    readonly scheduledFor?: string | null | undefined;
+    readonly scheduledDurationMinutes?: number | null | undefined;
+    readonly recurrenceRule?: string | null | undefined;
+    /**
+     * When the SERIES moves (start, rule or zone), carry its per-date changes
+     * (cancelled or moved occurrences) to the new schedule instead of archiving
+     * them — Google Calendar's and Outlook's "keep changes to individual events".
+     * Absent or false archives them (restorable). Ask the person; never decide.
+     */
+    readonly keepExceptions?: boolean | undefined;
+}
+/** What the emailed RSVP link shows and answers (no account needed). */
+type RsvpInvitation = {
+    readonly ok: true;
+    readonly meeting: {
+        readonly title: string;
+        readonly slug: string;
+        readonly scheduledFor: string | null;
+        readonly durationMinutes: number | null;
+        readonly timeZone: string;
+        readonly agenda: string | null;
+        readonly recurrenceRule: string | null;
+        readonly cancelledAt: string | null;
+        readonly cancellationReason: string | null;
+        readonly endedAt: string | null;
+    };
+    readonly invitee: {
+        readonly displayName: string | null;
+        readonly email: string | null;
+        readonly rsvpState: RsvpState;
+        readonly respondedAt: string | null;
+    };
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/** Org-configurable, never hardcoded taste (Law 6 / "opinions become knobs"). */
+type RecordingPolicy = "disabled" | "host-controlled" | "always-on";
+type RecordingState = "idle" | "starting" | "recording" | "stopping" | "processing" | "available"
+/** Bytes were purged under retention; notes and transcript remain durable. */
+ | "expired" | "failed";
+/**
+ * WHICH transport last said what the recording is doing (MRI-A16).
+ *
+ * `local` — this browser's own optimistic `starting`/`stopping`, which is all
+ * the indicator ever had through 0.4.7, and the reason it never went solid.
+ * `room` — a `matrx.meet.recording` packet, the ONLY feed a guest has.
+ * `record` — the durable `meet_recordings` row. It outranks both (D16).
+ */
+type RecordingSource = "local" | "room" | "record";
+/** The server's durable retention receipt; never inferred from a browser clock. */
+interface RecordingRetention {
+    readonly operationId: string;
+    readonly policyId: string;
+    readonly policyUpdatedAt: string;
+    readonly phase: "warning" | "expired";
+    readonly dueAt: string;
+    readonly expiredAt: string | null;
+}
+interface RecordingRecord {
+    readonly id: string;
+    readonly meetingId: MeetingId;
+    readonly state: RecordingState;
+    readonly startedAt: string | null;
+    readonly endedAt: string | null;
+    readonly startedBy: UserId | null;
+    /** The PLATFORM file id. Never a provider URL (R3). */
+    readonly fileId: string | null;
+    readonly failureReason: string | null;
+    /** Present when central retention warned or purged this recording. */
+    readonly retention: RecordingRetention | null;
+}
+/**
+ * WHERE A TRANSCRIPT LINE CAME FROM — and therefore how much it is worth.
+ *
+ * D16: `lk.transcription` is published by a room participant and its
+ * `sender_identity` is client-supplied and unvalidated by LiveKit, so a caption
+ * is a HINT — good enough to read live, never good enough to reason from. A
+ * `record` line is a durable `meet_transcript_segments` row written server-side
+ * by the note-taker: that is the transcript. A record always beats a caption;
+ * a caption never overwrites a record.
+ */
+type TranscriptSource = "caption" | "record";
+interface TranscriptSegment {
+    readonly id: string;
+    readonly meetingId: MeetingId;
+    readonly identity: ParticipantIdentity;
+    readonly speaker: string;
+    readonly text: string;
+    readonly startedAt: string;
+    /** Interim text is replaced in place by its final; it is never appended. */
+    readonly final: boolean;
+    readonly source: TranscriptSource;
+    /**
+     * The `lk.segment_id` this line was captioned under, when known. A durable
+     * row carries it too (the worker writes it into the row's metadata), which is
+     * what lets a record REPLACE the caption it supersedes rather than doubling it.
+     */
+    readonly captionId: string | null;
+}
+/**
+ * SOMEBODY WHO WAS IN THE MEETING — the durable `meet_participants` row, which
+ * outlives the LiveKit room (MRI-D2). `MeetParticipant` above is a live tile;
+ * THIS is the attendance record a person reads a week later.
+ */
+interface MeetingAttendee {
+    readonly id: string;
+    readonly meetingId: MeetingId;
+    readonly identity: ParticipantIdentity;
+    readonly displayName: string;
+    readonly avatarUrl: string | null;
+    readonly userId: UserId | null;
+    readonly role: ParticipantRole;
+    readonly admissionState: AdmissionState;
+    readonly isAgent: boolean;
+    /** FIRST arrival in the room — a rejoin never moves it. */
+    readonly joinedAt: string | null;
+    /** Null while in the room, else the last time they left. */
+    readonly leftAt: string | null;
+    /**
+     * Every stay in the room, oldest first (`metadata.sessions`, written by the
+     * server's one attendance rule). Empty for a row recorded before stays were
+     * kept; the report then falls back to `joinedAt`–`leftAt`.
+     */
+    readonly sessions?: readonly AttendanceStay[] | undefined;
+}
+/** One stay in the room: arrived, and left (null = still there or never recorded). */
+interface AttendanceStay {
+    readonly joinedAt: string;
+    readonly leftAt: string | null;
+}
+type MeetingNoteKind = "note" | "decision" | "action-item";
+/**
+ * ONE ROW OF WHAT THE MEETING DECIDED. `meet_notes.kind` is a live CHECK
+ * constraint of exactly three values (D5) — there is no `summary` kind and no
+ * `transcript` kind — so the wrap-up summary is a `note` carrying
+ * `metadata.role = "summary"`, and a live-window note carries `metadata.window`.
+ * Both are projected here so the UI never re-reads raw metadata.
+ */
+interface MeetingNote {
+    readonly id: string;
+    readonly meetingId: MeetingId;
+    readonly text: string;
+    readonly createdAt: string;
+    readonly kind: MeetingNoteKind;
+    /** Set ONLY when the assignee resolved to a real user (D18). */
+    readonly assigneeUserId: UserId | null;
+    /** Who the item is for, as a person reads it. A guest keeps their name here. */
+    readonly assigneeDisplayName: string | null;
+    /** `"summary"` for the wrap-up; `null` for everything else. */
+    readonly role: "summary" | null;
+    /** The live-notes window index this came out of, when it came from one. */
+    readonly window: number | null;
+    /**
+     * 🚨 THE WRAP-UP IS THE AUTHORITATIVE POST-MEETING SET (D20).
+     *
+     * A live-notes window and the wrap-up both write decisions and action items,
+     * and on production 2026-09-09 meeting `9cb-39f8-782` carried the SAME
+     * decision twice — once from the note-taker at 04:43:57 and once from the
+     * wrap-up at 04:47:15 — and the record view listed both. A reader cannot tell
+     * a repeated decision from two decisions.
+     *
+     * So when the wrap-up lands, the server MARKS the window-written decisions
+     * and action items it supersedes (`metadata.superseded_by` = the wrap-up's
+     * run id) and never deletes them: the row is still the timeline of what was
+     * known at 04:43. This field carries that marker, and the record view and the
+     * assistant panel render only the rows where it is `null`.
+     */
+    readonly supersededBy: string | null;
+    /**
+     * WHICH TRANSPORT DELIVERED THIS COPY (MRI-A12). The same durable row reaches
+     * a signed-in member twice — once as a `meet_notes` row over Postgres Changes
+     * (`"record"`) and once as a `matrx.meet.note` packet on the media plane
+     * (`"room"`), which is the ONLY copy a session-less guest can receive, because
+     * `anon` holds no grant on the table (MRI-A10).
+     *
+     * They carry the same id and the same words, so the store renders one note.
+     * Where they could ever disagree, `"record"` wins and `"room"` never overwrites
+     * it — the database is the record and the packet is the courtesy copy. That is
+     * the same precedence captions and segments already follow (D16).
+     */
+    readonly source: "record" | "room";
+}
+/**
+ * THE WRAP-UP, ANNOUNCED (MRI-A12). The summary, decisions and action items
+ * arrive as ordinary notes; this says the pass that wrote them FINISHED, which
+ * is the difference between "no summary yet" and "no summary is coming".
+ *
+ * 🚨 It reaches a screen only while the room still exists. `POST /v1/meet/end`
+ * deletes the LiveKit room and the wrap-up runs afterwards, so on the ordinary
+ * ending path nobody is in the room to be told — the post-meeting record view is
+ * where the summary is read. A surface must therefore treat `null` as "not
+ * announced", never as "not written".
+ */
+interface WrapUpAnnouncement {
+    readonly meetingId: MeetingId;
+    /** The `meet_notes` ids the pass wrote, in the order it wrote them. */
+    readonly noteIds: readonly string[];
+    /** How many durable transcript segments it summarized. */
+    readonly segmentCount: number;
+    readonly at: string;
+}
+/**
+ * THE NOTE-TAKER'S STATE, as the meeting row records it
+ * (`meet_meetings.metadata.note_taker.state`, MRI-A2). Five values and no
+ * spinner: a surface renders the state it is in, or the server's refusal.
+ *
+ * - `absent` — nobody summoned it. The control offers to.
+ * - `joining` — dispatched; it has not entered the room yet.
+ * - `transcribing` — the server recorded active transcription and the exact
+ *   deterministic actor is present in the room.
+ * - `handoff_pending` — a row that said transcribing no longer has that exact
+ *   actor in the room. The next state and any missed audio are not inferred.
+ * - `ended` — the recorded note-taker stopped. The cause is not inferred.
+ */
+type NoteTakerState = "absent" | "joining" | "transcribing" | "handoff_pending" | "ended";
+/** The lifecycle of a 1:1 or ad-hoc group call (R2). */
+type CallState = "idle" | "dialing" | "ringing" | "connecting" | "active" | "declined" | "missed" | "busy" | "cancelled" | "ended" | "failed";
+interface CallInvite {
+    readonly id: CallId;
+    readonly organizationId: OrganizationId;
+    readonly roomName: RoomName;
+    readonly mode: CallMode;
+    readonly callerUserId: UserId;
+    readonly callerName: string;
+    readonly callerAvatarUrl: string | null;
+    readonly calleeUserIds: readonly UserId[];
+    /** The durable conversation the invite was delivered into, if any. */
+    readonly conversationId: string | null;
+    readonly createdAt: string;
+    readonly expiresAt: string;
+    readonly state: CallState;
+    readonly declineMessage: string | null;
+}
+/** A person the UI can call. Deliberately minimal: hosts already have this. */
+interface CallablePerson {
+    readonly userId: UserId;
+    readonly displayName: string;
+    readonly avatarUrl: string | null;
+}
+type StageLayout = "grid" | "speaker" | "sidebar";
+
+/**
+ * THE ONE WAY THIS PACKAGE TALKS TO AIDREAM (MRI-A16).
+ *
+ * 🚨 **Every request to the aidream server carries `x-organization-id`, and the
+ * only way to guarantee "every" is for there to be ONE place that builds the
+ * request.** aidream's org-admission middleware refuses an authenticated
+ * request that does not name the organization it is acting in — 400
+ * `organization_required`, before the router is ever reached.
+ *
+ * 0.1.3 learned that lesson and put the header on the three meet callers by
+ * hand. That fixed the instances and left the CLASS wide open, and on
+ * 2026-09-09 the class collected its next victim: `<RecordingPlayer>` fetched
+ * `GET /files/{id}/download?inline=1` through a bare `fetch` with only a bearer
+ * token, so a perfectly landed 1.38 MB recording could not be played by the
+ * host who made it (MRI-C8; the identical URL returned `200 video/mp4` the
+ * moment the header was added by hand). A fourth caller was written months
+ * after the lesson and never heard it, because a lesson written into three call
+ * sites is not a lesson, it is three copies of a workaround.
+ *
+ * So: this module owns the base URL, the organization header and the bearer
+ * token, and `api.test.ts` holds a guard that FAILS THE BUILD if any other file
+ * in the package calls `fetch(` against a base URL or points an element `src=`
+ * at one. A new caller cannot be written without the header any more.
+ *
+ * 🚨 **HOW A `<video>` GETS ITS BYTES, given that signed URLs are eradicated.**
+ * A browser media element cannot attach a header, so a bare
+ * `src="https://server…/files/{id}/download"` carries no session and no
+ * organization and is refused — which is precisely what MRI-C8 saw. The
+ * platform's answer is NOT a signed URL (`aidream/api/routers/files` mints
+ * none, by law) but the FILE-SESSION COOKIE: `POST /files/session` mints an
+ * HttpOnly `SameSite=None` cookie that the auth middleware accepts on exactly
+ * the GET byte-serving routes (`COOKIE_AUTH_PATH_RE` in
+ * `matrx_connect/middleware/session_cookie.py`), and a cookie rides a media
+ * request that a header cannot. Every private `<img>`/`<video>` in the platform
+ * already renders this way.
+ *
+ * So `fileMedia` mints the cookie and hands back a STREAMING url — which is
+ * what lets a person scrub a two-hour recording instead of waiting for a
+ * gigabyte to arrive. When the mint is refused (no session, an older server,
+ * a browser blocking third-party cookies) it falls back to reading the bytes
+ * with the organization header into a `blob:` url — and it SAYS it did, with
+ * the reason, because a silent fallback that downloads a gigabyte is exactly
+ * the kind of automatic intervention that must announce itself.
+ */
+
+/**
+ * How the host tells us who is asking. Returns null before sign-in resolves,
+ * and for a guest, who has no session at all and is still a first-class joiner.
+ *
+ * It lives HERE rather than in `tokens.ts` (where it was born) because this is
+ * now the one module that turns a session into a request.
+ */
+type AccessTokenSource = () => Promise<string | null>;
+/** The header aidream's org-admission middleware demands. One definition. */
+declare const ORGANIZATION_HEADER = "x-organization-id";
+interface MeetApiOptions {
+    /** aidream's origin. Never a LiveKit or provider URL. */
+    baseUrl: string;
+    /** Named on EVERY request; the server refuses one that omits it. */
+    organizationId: OrganizationId;
+    accessToken: AccessTokenSource;
+    fetchImpl?: typeof fetch | undefined;
+}
+interface MeetApiRequest {
+    /** An absolute path on the aidream origin, e.g. `/api/v1/meet/token`. */
+    path: string;
+    method?: "GET" | "POST" | undefined;
+    /** JSON body. Serialized here so no caller can forget the content type. */
+    body?: Record<string, unknown> | undefined;
+    /**
+     * `true` — refuse before the wire when there is no session, with the given
+     * operation named. `false` — send whatever session exists, or none (a guest
+     * minting a room token is a real, authorized case).
+     */
+    requireAuth?: boolean | undefined;
+    /** Names the caller in every error this raises. */
+    operation: string;
+    /** Extra headers. May not override the organization header. */
+    headers?: Record<string, string> | undefined;
+    /**
+     * `"include"` for the ONE request that mints the file-session cookie — a
+     * `Set-Cookie` on a cross-origin response is dropped without it.
+     */
+    credentials?: RequestCredentials | undefined;
+    /** Cancels the request. The Q&A stream is abortable by the person asking. */
+    signal?: AbortSignal | undefined;
+}
+interface MeetApi {
+    readonly baseUrl: string;
+    readonly organizationId: OrganizationId;
+    /** The URL a request to `path` would go to. For diagnostics, never for fetching. */
+    url(path: string): string;
+    /** One request, with the organization header and the session already on it. */
+    request(input: MeetApiRequest): Promise<Response>;
+    /**
+     * Read an authenticated file into a `blob:` URL an element can load. The
+     * caller MUST `URL.revokeObjectURL` it — a leaked one pins the whole file in
+     * memory for the life of the tab.
+     */
+    fetchObjectUrl(input: MeetApiRequest): Promise<string>;
+    /**
+     * A url a `<video>`/`<img>` can load for a platform file. Streams when the
+     * file-session cookie can be minted; otherwise reads the bytes with the
+     * organization header and says why it had to.
+     */
+    fileMedia(fileId: string, operation: string): Promise<MeetFileMedia>;
+    /** Re-mint the file-session cookie. Returns whether it now exists. */
+    refreshFileSession(): Promise<boolean>;
+}
+/** Where a media element's bytes are coming from, and whether that is plan A. */
+interface MeetFileMedia {
+    readonly url: string;
+    /** `stream` seeks and starts instantly; `bytes` is a fully downloaded blob. */
+    readonly kind: "stream" | "bytes";
+    /**
+     * Set only for `bytes`, and never null-and-hoping: the sentence a surface
+     * shows to explain why it had to download the whole file first.
+     */
+    readonly fallbackReason: string | null;
+}
+/** `POST /files/session` — mints the `mx_files_session` cookie (files law). */
+declare const FILE_SESSION_PATH = "/files/session";
+declare function createMeetApi(options: MeetApiOptions): MeetApi;
+/** `GET /files/{id}/download?inline=1` — the platform files route (R3). */
+declare function fileDownloadPath(fileId: string): string;
+
+/**
+ * MEETING ROOM ITEMS — polls, Q&A, the shared whiteboard and breakout rooms (Meet wave 5).
+ *
+ * The server decides every one of them (`aidream/services/meet/collab.py`,
+ * `breakouts.py`): who may create, launch, vote, ask, answer, draw, erase, open rooms or
+ * move people — and what each viewer SEES (a draft poll is the host's alone; counts
+ * reach everyone only once shared; anonymous votes and questions carry no identity;
+ * a dismissed question stays with the hosts). This file only holds what the server
+ * said and folds the room's `matrx.meet.collab` packets into it.
+ *
+ * Two reads, one truth: `GET /v1/meet/collab` once per join (a late joiner sees every
+ * poll, question, stroke and the open breakout plan), then packets. Every item is keyed
+ * by its row id, so the same item arriving twice is one item.
+ */
+
+interface MeetPollOption {
+    readonly id: string;
+    readonly text: string;
+    /** Present when this viewer may see counts (a host, or results shared). */
+    readonly votes?: number | undefined;
+    /** Who picked it — hosts only, never for an anonymous poll. */
+    readonly voters?: readonly string[] | undefined;
+}
+type MeetPollState = "draft" | "live" | "closed";
+interface MeetPoll {
+    readonly id: string;
+    readonly question: string;
+    readonly options: readonly MeetPollOption[];
+    readonly multiple: boolean;
+    readonly anonymous: boolean;
+    readonly state: MeetPollState;
+    readonly resultsShared: boolean;
+    readonly voterCount: number | null;
+    /** This viewer's own answer — kept locally, since a room packet cannot know it. */
+    readonly myVote: readonly string[];
+    readonly createdByName: string;
+    readonly createdAt: string | null;
+}
+type MeetQuestionState = "open" | "answered" | "dismissed";
+interface MeetQuestion {
+    readonly id: string;
+    readonly text: string;
+    readonly askerName: string;
+    readonly anonymous: boolean;
+    readonly state: MeetQuestionState;
+    readonly answer: string | null;
+    readonly answeredByName: string | null;
+    readonly upvotes: number;
+    readonly upvotedByMe: boolean;
+    readonly mine: boolean;
+    readonly createdAt: string | null;
+}
+interface MeetStroke {
+    readonly id: string;
+    /** Points in the board's own 0..1 space. */
+    readonly points: readonly (readonly [number, number])[];
+    readonly color: string;
+    readonly width: number;
+    readonly tool: "pen" | "highlighter";
+    readonly by: string;
+    readonly byName: string;
+    /** True while this browser's stroke has not come back from the server. */
+    readonly pending?: boolean | undefined;
+}
+interface MeetBreakoutRoom {
+    readonly id: string;
+    readonly name: string;
+    readonly identities: readonly string[];
+}
+interface MeetBreakoutBroadcast {
+    readonly text: string;
+    readonly by: string;
+    readonly at: string;
+}
+interface MeetBreakoutPlan {
+    readonly id: string;
+    readonly state: "open" | "closed";
+    readonly rooms: readonly MeetBreakoutRoom[];
+    readonly allowChoose: boolean;
+    readonly minutes: number;
+    readonly openedAt: string | null;
+    readonly endsAt: string | null;
+    readonly closedAt: string | null;
+    readonly broadcasts: readonly MeetBreakoutBroadcast[];
+}
+/** The org's knobs for this meeting — which controls EXIST (absent, never dead). */
+interface MeetCollabSettings {
+    readonly pollsEnabled: boolean;
+    readonly pollMaxOptions: number;
+    readonly qaEnabled: boolean;
+    readonly qaAnonymousAllowed: boolean;
+    readonly whiteboardEnabled: boolean;
+    readonly breakoutsEnabled: boolean;
+    readonly breakoutMaxRooms: number;
+    readonly breakoutDefaultMinutes: number;
+    readonly captionTranslationEnabled: boolean;
+    /** Empty = the viewer's own language. */
+    readonly captionTranslationLanguage: string;
+}
+type CollabPanel = "polls" | "qa" | "whiteboard" | "breakouts";
+interface CollabSnapshot {
+    readonly loaded: boolean;
+    /** Why the state could not be read, in words — or null. */
+    readonly error: string | null;
+    readonly settings: MeetCollabSettings | null;
+    readonly polls: readonly MeetPoll[];
+    readonly questions: readonly MeetQuestion[];
+    readonly strokes: readonly MeetStroke[];
+    readonly breakout: MeetBreakoutPlan | null;
+    /** The newest message a host sent to every breakout room, for the banner. */
+    readonly broadcast: MeetBreakoutBroadcast | null;
+    /** A host moved THIS person (or everyone came back): where to go. `undefined` = nothing asked. */
+    readonly moveRequest: {
+        readonly roomId: string | null;
+        readonly at: number;
+    } | null;
+    /** Something asked a panel to open (a poll launched, a question arrived for a host). */
+    readonly panelRequest: {
+        readonly panel: CollabPanel;
+        readonly at: number;
+    } | null;
+    /** Caption translations for THIS viewer: line id → text, for `captionLanguage`. */
+    readonly captionLanguage: string | null;
+    readonly captionTranslations: Readonly<Record<string, string>>;
+    readonly captionTranslationError: string | null;
+}
+declare const EMPTY_COLLAB: CollabSnapshot;
+type Row = Record<string, unknown>;
+/** The server's `GET /collab` body → a loaded snapshot (keeps this viewer's caption state). */
+declare function collabFromState(body: Row, previous: CollabSnapshot): CollabSnapshot;
+/**
+ * Fold one server item into the snapshot. `fromRoom` = it came on the room broadcast,
+ * which cannot know THIS viewer's vote, upvote or authorship — those are kept from what
+ * the viewer's own reads and answers already said.
+ */
+declare function withItem(collab: CollabSnapshot, row: Row, fromRoom?: boolean): CollabSnapshot;
+interface CollabPacketContext {
+    readonly localIdentity: ParticipantIdentity | null;
+    /** Hosts and co-hosts receive a second, fuller packet; they ignore the room copy. */
+    readonly isHost: boolean;
+    readonly now: number;
+}
+/**
+ * One `matrx.meet.collab` packet → the next snapshot, or `null` when it must be dropped
+ * (with the reason in `dropped`). Pure; the room-event dispatcher patches the store.
+ */
+declare function applyCollabPacket(collab: CollabSnapshot, payload: Row, context: CollabPacketContext): {
+    next: CollabSnapshot | null;
+    dropped?: string;
+};
+/** The breakout room a person is assigned to, or null. */
+declare function assignedRoom(plan: MeetBreakoutPlan | null, identity: string | null): MeetBreakoutRoom | null;
+/**
+ * Split people into `rooms` rooms, round-robin in the order given — Zoom's "assign
+ * automatically". Hosts are left out (they visit); pass them in `exclude`.
+ */
+declare function autoAssign(identities: readonly string[], rooms: number, exclude?: readonly string[]): string[][];
+/** Milliseconds until the plan's timer ends, or null when it has none. */
+declare function breakoutRemainingMs(plan: MeetBreakoutPlan | null, now: number): number | null;
+/** The language translated captions start in: the knob, else the viewer's own. */
+declare function defaultCaptionLanguage(settings: MeetCollabSettings | null, viewerLanguage: string | null | undefined): string;
+/** Languages offered in the captions menu (tags the translator understands). */
+declare const CAPTION_LANGUAGES: readonly {
+    readonly tag: string;
+    readonly name: string;
+}[];
+interface MeetingActivities {
+    /** Polls (with results), questions, whiteboard strokes — or null when refused. */
+    readonly collab: CollabSnapshot | null;
+    readonly refusal: {
+        readonly message: string;
+        readonly remedy: string;
+    } | null;
+}
+/**
+ * THE MEETING'S POLLS, Q&A AND WHITEBOARD, AFTER IT (Meet wave 5) — for the record page.
+ * The same `GET /v1/meet/collab` the room reads on join; a refusal is returned as data,
+ * so the record still renders everything else.
+ */
+declare function loadMeetingActivities(api: MeetApi, meetingId: string, roomToken?: string | null): Promise<MeetingActivities>;
+
+export { type NoteTakerState as $, type AccessTokenSource as A, type MeetPollState as B, type CollabPanel as C, type MeetQuestion as D, EMPTY_COLLAB as E, FILE_SESSION_PATH as F, type MeetQuestionState as G, type MeetStroke as H, type InviteeInput as I, type JsonObject as J, type MeetingActivities as K, type LobbyEntry as L, type MeetingRecord as M, type MeetingAttendee as N, type OrganizationId as O, type ParticipantIdentity as P, type MeetingChanges as Q, type RoomName as R, type StageLayout as S, type TranscriptSource as T, type UserId as U, type MeetingInvitee as V, type WrapUpAnnouncement as W, type MeetingKind as X, type MeetingNoteKind as Y, type MeetingOccurrence as Z, type MeetingSettings as _, type MeetParticipant as a, ORGANIZATION_HEADER as a0, type OccurrenceOverride as a1, type OccurrenceState as a2, ROLE_RANK as a3, type RecordingPolicy as a4, type RecordingRecord as a5, type RecordingState as a6, type RoomPhase as a7, type RsvpAnswer as a8, type RsvpInvitation as a9, type RsvpState as aa, type TranscriptSegment as ab, type UpcomingOccurrence as ac, applyCollabPacket as ad, asCallId as ae, asMeetingId as af, asOrganizationId as ag, asParticipantIdentity as ah, asRoomName as ai, asUserId as aj, assignedRoom as ak, autoAssign as al, breakoutRemainingMs as am, collabFromState as an, createMeetApi as ao, defaultCaptionLanguage as ap, fileDownloadPath as aq, isGuest as ar, isHostRole as as, loadMeetingActivities as at, withItem as au, type RecordingSource as av, type MeetApi as b, type MeetIdentity as c, type CallInvite as d, type ParticipantRole as e, type CallMode as f, type MeetingNote as g, type MeetingId as h, type CollabSnapshot as i, type AdmissionState as j, CAPTION_LANGUAGES as k, type CallId as l, type CallState as m, type CallablePerson as n, type ConnectionQuality as o, type InviteeRole as p, type JsonValue as q, type MeetApiOptions as r, type MeetApiRequest as s, type MeetBreakoutBroadcast as t, type MeetBreakoutPlan as u, type MeetBreakoutRoom as v, type MeetCollabSettings as w, type MeetFileMedia as x, type MeetPoll as y, type MeetPollOption as z };