@strevokit/meeting-sdk 0.6.0 → 0.8.0

package/CHANGELOG.md

@@ -6,6 +6,34 @@ All notable changes to `@strevokit/meeting-sdk` are documented here. The format
 
 ## [Unreleased]
 
+## [0.8.0]
+
+Bundles `@strevokit/signaling-protocol` 1.6.0.
+
+### Changed
+
+- A live camera or microphone whose capture ends may continue on another device of that kind. The kind stays on, and
+  the change is not announced as stopped or started. When no other device of that kind can be opened, the kind turns
+  off and is announced as before.
+
+## [0.7.0]
+
+Bundles `@strevokit/signaling-protocol` 1.6.0.
+
+### Added
+
+- Connection state `reconnecting` for automatic meeting-service recovery after an unexpected drop while joined.
+- Optional `getJoinToken` and `reconnectWindowMs` on `MeetingEngineOptions` so hosts can mint a fresh join token
+  during recovery (default recovery window 120 seconds).
+- Media-path recovery while the room connection stays up: restart after a sustained interruption, and one bounded
+  link recreate after a failure within the recovery window.
+
+### Documentation
+
+- Backend API guide covering `POST /v1/meetings`, `POST /v1/meetings/{public_id}/participants`,
+  `POST /v1/meetings/{public_id}/join-token`, and related embed-origin / get / end routes, with an Express-style
+  integration example.
+
 ## [0.6.0]
 
 Bundles `@strevokit/signaling-protocol` 1.6.0.

package/README.md

@@ -22,23 +22,52 @@ The package is ESM-only and runs in browsers. Use it through a bundler (Vite, we
 
 ## Quick start
 
-### 1. Mint a join token on your backend
+### 1. Prepare the meeting on your backend
 
-Join tokens are short-lived and single-use. Your backend mints one per participant with its Strevokit API credential.
-**Never** send the API credential to the browser.
+Your backend talks to the Strevokit HTTP API with its API credential, then returns only a short-lived join token to the
+browser. **Never** send the API credential to the browser. Full request and response shapes:
+[Backend API](./docs/backend-api.md).
 
 ```ts
-// Server side (for example, a route in your backend).
-const response = await fetch(`https://api.example.com/v1/meetings/${meetingPublicId}/join-token`, {
+// Server side. Headers on every call:
+//   Authorization: Bearer ${process.env.STREVOKIT_API_CREDENTIAL}
+//   Content-Type: application/json
+const api = "https://api.example.com"; // your Strevokit API base URL
+const headers = {
+  Authorization: `Bearer ${process.env.STREVOKIT_API_CREDENTIAL}`,
+  "Content-Type": "application/json",
+};
+
+// Once per environment: allow-list the origin that hosts your page.
+await fetch(`${api}/v1/embed-origins`, {
   method: "POST",
-  headers: {
-    Authorization: `Bearer ${process.env.STREVOKIT_API_CREDENTIAL}`,
-    "Content-Type": "application/json",
-  },
-  body: JSON.stringify({ participant_public_id: participantPublicId }),
+  headers,
+  body: JSON.stringify({ origin: "https://app.example.com" }),
 });
-const { data } = await response.json(); // { token, expires_at, expires_in }
-// Return data.token to the signed-in user's browser.
+
+// Create the meeting, then authorize each person who may join.
+const { data: meeting } = await fetch(`${api}/v1/meetings`, {
+  method: "POST",
+  headers,
+  body: JSON.stringify({ type: "one_to_one", max_participants: 2 }),
+}).then((r) => r.json());
+
+const { data: participant } = await fetch(`${api}/v1/meetings/${meeting.public_id}/participants`, {
+  method: "POST",
+  headers,
+  body: JSON.stringify({
+    external_user_id: "user_42",
+    display_name: "Alex",
+    role: "host",
+  }),
+}).then((r) => r.json());
+
+// When the signed-in user opens the meeting page, mint a join token and return only data.token.
+const { data } = await fetch(`${api}/v1/meetings/${meeting.public_id}/join-token`, {
+  method: "POST",
+  headers,
+  body: JSON.stringify({ participant_public_id: participant.public_id }),
+}).then((r) => r.json()); // { token, expires_at, expires_in }
 ```
 
 ### 2. Join from the browser
@@ -104,7 +133,8 @@ await engine.leave(); // releases camera, microphone, and screen; then `closed`
 An engine joins once. To join again, mint a new token and create a new engine. Call `engine.dispose()` when your
 component unmounts; it releases everything immediately and emits nothing.
 
-More examples: [plain HTML](./docs/examples/vanilla.html) and [React](./docs/examples/react.tsx).
+More examples: [plain HTML](./docs/examples/vanilla.html), [React](./docs/examples/react.tsx), and
+[backend integration](./docs/examples/backend-integration.md).
 
 ## Browser support
 
@@ -132,6 +162,8 @@ values generically. See the [changelog](./CHANGELOG.md).
 
 ## Documentation
 
+- [Backend API](./docs/backend-api.md): create meeting, authorize participants, mint join tokens, and related routes
+  (`POST` / `GET` / `DELETE` with request and response shapes).
 - [API reference](./docs/api-reference.md): every export, method, event, error code, and close reason.
 - [Examples](./docs/examples/).
 

package/dist/index.d.ts

@@ -1,8 +1,15 @@
 /** Why the engine closed. */
 export declare type CloseReason = "left" | "meeting_ended" | "session_replaced" | "connection_lost" | "join_failed" | "error";
 
-/** Engine lifecycle state. `closed` is terminal: create a new engine to join again. */
-export declare type ConnectionState = "idle" | "connecting" | "joining" | "joined" | "leaving" | "closed";
+/**
+ * Engine lifecycle state. `closed` is terminal: create a new engine to join again.
+ *
+ * After a recoverable meeting-service interruption while `joined`, the engine moves to `reconnecting`
+ * and attempts automatic recovery. Success returns to `joined` (same self identity; `joined` is not
+ * re-emitted). Exhaustion or hard failure moves to `closed` with `connection_lost`. Deliberate leave,
+ * meeting ended, and session replaced cancel recovery and close accordingly.
+ */
+export declare type ConnectionState = "idle" | "connecting" | "joining" | "joined" | "reconnecting" | "leaving" | "closed";
 
 /**
  * Creates a meeting engine for one participant. Pass the join token your backend issued and the realtime
@@ -104,6 +111,17 @@ export declare interface MeetingEngineOptions {
     joinTimeoutMs?: number;
     /** Optional diagnostics sink. The SDK never passes the join token or raw exception text to it. */
     logger?: MeetingLogger;
+    /**
+     * Optional. Called when a new meeting-service connection needs a join token and the in-memory token
+     * cannot be used. Must resolve to a server-issued join token for the same participant. Reject to fail
+     * recovery. The returned token is kept in memory only and never logged.
+     */
+    getJoinToken?: () => Promise<string>;
+    /**
+     * Optional. Continuous unsuccessful recovery budget in milliseconds. Default 120000.
+     * Values outside 1000–600000 are clamped to that range.
+     */
+    reconnectWindowMs?: number;
 }
 
 /**