@q9labsai/chalk-client 5.0.0 → 5.1.0

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+## 5.1.0
+
+- Add shared board views: `ChalkWhiteboardView`, `ChalkWhiteboardViewBounds`, and the whiteboard client's `supportsViews` and `sendView()`, so participants can follow a person's board view or bring everyone to theirs. The board stream also carries a `view` event.
+- Export `isChalkAccessGrantError` and the `ChalkAccessGrantErrorCode` type from the server entry point. `ChalkAPIError.code` now includes the known media-token codes, such as `media_token.expired`.
+- Admission responses add `decision_state` and an optional `decision_action`, so dashboard hosts see public invite knocks and a call that ends shows without a reload. Hosts can admit simultaneous knocks without reconnecting.
+- Public invite reads (`getSpacePublicInvite`, `getSpacePublicInviteArrival`, `listSpacePublicAdmissionRequests`) move from `v1.authenticated.write` (60 per minute) to `v1.authenticated.read` (300 per minute) in the exported `ChalkOperationPolicies`.
+- Calling `leave()` no longer closes media the server already ended.
+- Recover a call when Sync rejects a state update, such as on a state digest mismatch. The client requests one fresh snapshot, validates it before replacing local state, and resumes; commands sent before or during recovery complete once. If that snapshot is rejected too, it stops reconnecting and fails with the new non-recoverable public code `connection.state_digest_recovery_failed`. Handle it like other terminal connection failures and offer a rejoin.
+- Bound each Sync and whiteboard WebSocket opening attempt to 10 seconds by default. The whiteboard, and Sync once the call is live, retry a timed-out attempt through the existing reconnect backoff. During first join the Sync deadline ends with the default 10-second startup wait, so it does not retry a Sync socket that never opens: the join fails when the deadline expires. Late opens from expired attempts are ignored, and a redacted dial-timeout diagnostic is kept after recovery. The transports' existing options allow a longer deadline.
+- Capture a fresh microphone when it is turned on after its previous track ended, instead of reusing the ended track.
+- Report a chat send that Sync refuses for sending too fast as recoverable `command.rate_limited`, and one it refuses while overloaded as recoverable `collaboration.unavailable`, instead of non-recoverable `chat.payload_invalid`.
+- Accept a server-selected media replacement during access refresh, including when the client clock still considers its prior credential valid, so rejoining with an expired media token works. The full participant subject check still runs before the client switches connections.
+- Add optional Sync health to connection snapshots without changing the public status union. Brief pong loss degrades without blocking; sustained silence triggers recovery and stable pongs clear it. Reaction acknowledgements time out after five seconds and are not replayed.
+- Guard media enabling at the controller boundary for every caller. Off intents are retained until Sync confirms them after reconnect, and media publication runs through revisioned workers so a late capture cannot enable a device after Off.
+- Add `media.captureCameraPreview()` to capture an unpublished camera track with the selected device and refresh the inventory after permission is granted. It shares live or pending camera capture; callers release a preview handle.
+- Exhausted media confirmations now return recoverable `media.timeout`; unrelated command retries are not classified as media failures.
+- Reaction acknowledgement timeouts return recoverable `collaboration.unavailable` without claiming whether the reaction arrived.
+
+- Preserve access, Sync, SFU, and recovery failure codes and recoverability in join rejections, snapshots, and error events.
+- Add `connection.sync_hello_timeout` for the Sync startup handshake deadline. Handle it alongside `connection.sync_start_failed` and retain a fallback for future codes.
+- Media changes while Sync is not live now return recoverable `connection.invalid_state` with plain connection guidance instead of an internal target error.
+
+## 5.0.0
+
+- BREAKING: remove Episode diagnostics, client telemetry, feedback submission, RealtimeKit, public status, Tenant invitations, audit-log and Users API operations, and the regions catalog.
+- BREAKING: replace `createChalkWhiteboardV1FileHttpTransport` with the download-only `createChalkWhiteboardV1FileDownloadTransport`. Remove the retired local file-upload API.
+- Recover stalled whiteboard connections with a heartbeat watchdog. Use monotonic ages even when an injected wall clock moves backward. Persisted operation timestamps still use wall time.
+- BREAKING: custom whiteboard `clock` objects must provide `monotonicNow()` on the same timeline as their `setTimeout` scheduler. A three-method clock now throws at construction. For real-time timers, add `monotonicNow: () => performance.now()`; for a virtual scheduler, return its elapsed time independently of wall-clock corrections.
+- Publish and play shared tab audio separately from microphones, with share-audio state and coupled screen-share lifecycle.
+
+- Add optional screen-capture surface/audio hints and actual selected surface/label metadata.
+- Add explicit per-message reactions, versioned live/history state, offline queue support, and the shared 24-emoji set.

package/README.md

@@ -175,6 +175,38 @@ Events are `participantJoined`, `participantLeft`, `episodeEnded`,
 stable codes such as `access.invalid`, `episode.ended`, and
 `chat.payload_invalid`.
 
+### Connection failures
+
+`join()` rejections, `connection.lastError`, and `client.on("error")` use the
+same public codes and preserve `recoverable`. Recoverable does not mean joined:
+a failed startup needs another `join()`, while interrupted live connections keep
+recovering in the background. Device warnings below do not fail entry.
+
+| Stage                                                                        | Public error code                     |
+| ---------------------------------------------------------------------------- | ------------------------------------- |
+| Rejected or invalid access grant                                             | `access.invalid`                      |
+| Access provider unavailable                                                  | `access.unavailable`                  |
+| Sync could not start                                                         | `connection.sync_start_failed`        |
+| Sync did not finish its hello/recovery handshake before the startup deadline | `connection.sync_hello_timeout`       |
+| SFU/ICE media startup                                                        | `connection.media_start_failed`       |
+| Sync recovery budget exhausted                                               | `connection.sync_recovery_exhausted`  |
+| Media recovery budget exhausted                                              | `connection.media_recovery_exhausted` |
+| Unsupported capture environment                                              | `environment.unsupported`             |
+| Unexpected, unclassified exception                                           | `client.internal_error`               |
+
+`connection.sync_hello_timeout` is an additive public code. Integrations that
+show guidance for `connection.sync_start_failed` should use the same fallback
+for this new timeout code. Keep a default branch for future codes. No existing
+code is renamed or removed; snapshots and error events now retain the
+stage instead of incorrectly reporting `client.internal_error`. Rejected access
+and unsupported-environment rejections also retain their nonrecoverable flag.
+The React failed screen shows safe stage guidance and a public code reference;
+it does not display provider responses or tokens.
+
+Media changes that race Sync joining or reconnecting reject with the existing
+`connection.invalid_state` code, `recoverable: true`, and plain connection
+guidance. Wait for the call to connect before retrying the media change.
+
 ### Join capture errors
 
 `join()` requests the microphone and camera by default. If both work, capture
@@ -282,3 +314,10 @@ SpaceClient negotiates `collaboration_v2` for the 24-emoji set and per-message r
 The sharer keeps local playback (`suppressLocalAudioPlayback: false`). Display audio disables echo cancellation, noise suppression and automatic gain control to preserve music; microphone capture and its processing are unchanged. System audio is excluded to avoid sending the call back to itself. Headphones avoid acoustic doubling through the microphone; local playback cannot be preserved while guaranteeing that loudspeakers never leak into it. Chrome documents [local playback control](https://developer.chrome.com/blog/screen-sharing-improvements-in-chrome-109) and [system-audio feedback](https://developer.chrome.com/docs/web-platform/screen-sharing-controls). [Meet documents the same “Also share tab audio” picker control](https://support.google.com/meet/answer/9308856?hl=en). No public X documentation establishing its echo default was found.
 
 Shared tab audio is excluded from recordings until the recording format supports it. React Native display capture behavior is unchanged.
+
+Media-command confirmation deadlines and exhausted retries use existing
+`media.timeout` with `recoverable: true`. This classification applies only to
+media commands, not other operations with exhausted retries. Reaction
+acknowledgement deadlines use existing `collaboration.unavailable`, recoverable,
+with “Couldn’t confirm your reaction. Try again.” A missing acknowledgement does
+not establish whether anyone received the reaction.

package/dist/access/base64-url.d.ts

@@ -1,2 +1 @@
 export declare function decodeBase64Url(value: string): string;
-//# sourceMappingURL=base64-url.d.ts.map

package/dist/access/grant.d.ts

@@ -49,4 +49,3 @@ export declare function requireParsedAccessGrant(value: unknown): Promise<Parsed
 export declare function requireAccessGrant(value: unknown): Promise<AccessGrant>;
 export declare function isParsedAccessGrant(value: unknown): value is ParsedAccessGrant;
 export {};
-//# sourceMappingURL=grant.d.ts.map

package/dist/access/manager.d.ts

@@ -35,4 +35,3 @@ export declare class ConnectionAccessService extends ConnectionAccessService_bas
 export declare const makeConnectionAccessLayer: (provider: ConnectionAccessEffectProvider, refreshWindowMs?: number) => Layer.Layer<ConnectionAccessService, never, never>;
 export declare const makeFakeConnectionAccessLayer: (provider: ConnectionAccessEffectProvider, refreshWindowMs?: number) => Layer.Layer<ConnectionAccessService, never, never>;
 export {};
-//# sourceMappingURL=manager.d.ts.map

package/dist/chat-files/http-transport.d.ts

@@ -5,4 +5,3 @@ export type ChalkChatFileHttpTransportOptions = {
     readonly fetch?: typeof globalThis.fetch;
 };
 export declare function createChalkChatFileHttpTransport(options: ChalkChatFileHttpTransportOptions): ChalkChatFileTransport;
-//# sourceMappingURL=http-transport.d.ts.map

package/dist/chat-files/index.d.ts

@@ -1,3 +1,2 @@
 export { createChalkChatFileHttpTransport, type ChalkChatFileHttpTransportOptions } from "./http-transport";
 export { ChalkChatFileError, type ChalkChatFileErrorCode, type ChalkChatFileFailure, type ChalkChatFileOperation, type ChalkChatFileTransport } from "./types";
-//# sourceMappingURL=index.d.ts.map

package/dist/chat-files/types.d.ts

@@ -34,4 +34,3 @@ export type ChalkChatFileTransport = {
         readonly expiresAt: string;
     }>;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/{chunk-2HJIJVE2.js → chunk-3ZN7IXOZ.js}

@@ -490,6 +490,8 @@ var PrepareRecordingRequestSchema = Schema.Struct({
   starts_at: DateTimeStringSchema
 });
 var PublicAdmissionRequestSchema = Schema.Struct({
+  decision_action: Schema.optional(Schema.String),
+  decision_state: Schema.String,
   display_name: Schema.String,
   expires_at: DateTimeStringSchema,
   request_handle: Schema.String,
@@ -2277,6 +2279,253 @@ var MediaConnectionNotFoundErrorSchema = MediaConnectionNotFoundErrorWireSchema.
     encode: SchemaGetter.transform((error) => ({ error: error.error }))
   })
 );
+var MediaTokenExpiredError = class extends Schema.TaggedErrorClass()("MediaTokenExpiredError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.expired"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenExpiredErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.expired"),
+    message: Schema.String
+  })
+});
+var MediaTokenExpiredErrorSchema = MediaTokenExpiredErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenExpiredError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenExpiredError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidAudienceError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidAudienceError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_audience"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidAudienceErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_audience"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidAudienceErrorSchema = MediaTokenInvalidAudienceErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidAudienceError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidAudienceError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidHeaderError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidHeaderError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_header"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidHeaderErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_header"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidHeaderErrorSchema = MediaTokenInvalidHeaderErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidHeaderError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidHeaderError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidIssuerError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidIssuerError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_issuer"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidIssuerErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_issuer"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidIssuerErrorSchema = MediaTokenInvalidIssuerErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidIssuerError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidIssuerError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidSignatureError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidSignatureError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_signature"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidSignatureErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_signature"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidSignatureErrorSchema = MediaTokenInvalidSignatureErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidSignatureError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidSignatureError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidSubjectError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidSubjectError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_subject"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidSubjectErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_subject"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidSubjectErrorSchema = MediaTokenInvalidSubjectErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidSubjectError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidSubjectError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenInvalidTimeClaimsError = class extends Schema.TaggedErrorClass()("MediaTokenInvalidTimeClaimsError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_time_claims"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenInvalidTimeClaimsErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.invalid_time_claims"),
+    message: Schema.String
+  })
+});
+var MediaTokenInvalidTimeClaimsErrorSchema = MediaTokenInvalidTimeClaimsErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenInvalidTimeClaimsError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenInvalidTimeClaimsError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenLifetimeExceededError = class extends Schema.TaggedErrorClass()("MediaTokenLifetimeExceededError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.lifetime_exceeded"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenLifetimeExceededErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.lifetime_exceeded"),
+    message: Schema.String
+  })
+});
+var MediaTokenLifetimeExceededErrorSchema = MediaTokenLifetimeExceededErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenLifetimeExceededError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenLifetimeExceededError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenMalformedError = class extends Schema.TaggedErrorClass()("MediaTokenMalformedError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.malformed"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenMalformedErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.malformed"),
+    message: Schema.String
+  })
+});
+var MediaTokenMalformedErrorSchema = MediaTokenMalformedErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenMalformedError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenMalformedError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenNotYetValidError = class extends Schema.TaggedErrorClass()("MediaTokenNotYetValidError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.not_yet_valid"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenNotYetValidErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.not_yet_valid"),
+    message: Schema.String
+  })
+});
+var MediaTokenNotYetValidErrorSchema = MediaTokenNotYetValidErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenNotYetValidError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenNotYetValidError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenRequiredError = class extends Schema.TaggedErrorClass()("MediaTokenRequiredError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.required"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenRequiredErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.required"),
+    message: Schema.String
+  })
+});
+var MediaTokenRequiredErrorSchema = MediaTokenRequiredErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenRequiredError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenRequiredError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenSubjectMismatchError = class extends Schema.TaggedErrorClass()("MediaTokenSubjectMismatchError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.subject_mismatch"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenSubjectMismatchErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.subject_mismatch"),
+    message: Schema.String
+  })
+});
+var MediaTokenSubjectMismatchErrorSchema = MediaTokenSubjectMismatchErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenSubjectMismatchError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenSubjectMismatchError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
+var MediaTokenUnknownKeyError = class extends Schema.TaggedErrorClass()("MediaTokenUnknownKeyError", {
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.unknown_key"),
+    message: Schema.String
+  })
+}) {
+};
+var MediaTokenUnknownKeyErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("media_token.unknown_key"),
+    message: Schema.String
+  })
+});
+var MediaTokenUnknownKeyErrorSchema = MediaTokenUnknownKeyErrorWireSchema.pipe(
+  Schema.decodeTo(MediaTokenUnknownKeyError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "MediaTokenUnknownKeyError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
 var MediaUnavailableError = class extends Schema.TaggedErrorClass()("MediaUnavailableError", {
   error: Schema.Struct({
     code: Schema.Literal("media.unavailable"),
@@ -2410,6 +2659,25 @@ var PaginationInvalidPageSizeErrorSchema = PaginationInvalidPageSizeErrorWireSch
     encode: SchemaGetter.transform((error) => ({ error: error.error }))
   })
 );
+var ParticipantConnectionSupersededError = class extends Schema.TaggedErrorClass()("ParticipantConnectionSupersededError", {
+  error: Schema.Struct({
+    code: Schema.Literal("participant.connection_superseded"),
+    message: Schema.String
+  })
+}) {
+};
+var ParticipantConnectionSupersededErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("participant.connection_superseded"),
+    message: Schema.String
+  })
+});
+var ParticipantConnectionSupersededErrorSchema = ParticipantConnectionSupersededErrorWireSchema.pipe(
+  Schema.decodeTo(ParticipantConnectionSupersededError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "ParticipantConnectionSupersededError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
 var ParticipantGenerationMismatchError = class extends Schema.TaggedErrorClass()("ParticipantGenerationMismatchError", {
   error: Schema.Struct({
     code: Schema.Literal("participant.generation_mismatch"),
@@ -4113,7 +4381,21 @@ var IssueAccessGrantErrorSchema = Schema.Union([
   AccessForbiddenErrorSchema,
   AccessUnauthenticatedErrorSchema,
   EpisodeInvalidIdErrorSchema,
+  MediaTokenExpiredErrorSchema,
+  MediaTokenInvalidAudienceErrorSchema,
+  MediaTokenInvalidHeaderErrorSchema,
+  MediaTokenInvalidIssuerErrorSchema,
+  MediaTokenInvalidSignatureErrorSchema,
+  MediaTokenInvalidSubjectErrorSchema,
+  MediaTokenInvalidTimeClaimsErrorSchema,
+  MediaTokenLifetimeExceededErrorSchema,
+  MediaTokenMalformedErrorSchema,
+  MediaTokenNotYetValidErrorSchema,
+  MediaTokenRequiredErrorSchema,
+  MediaTokenSubjectMismatchErrorSchema,
+  MediaTokenUnknownKeyErrorSchema,
   MediaUnavailableErrorSchema,
+  ParticipantConnectionSupersededErrorSchema,
   ParticipantGenerationMismatchErrorSchema,
   ParticipantInvalidIdErrorSchema,
   ParticipantNotFoundErrorSchema,
@@ -4619,8 +4901,8 @@ var ChalkOperationPolicies = {
   findTenantByExternalID: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   getEpisode: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   getEpisodeAttendance: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
-  getSpacePublicInvite: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
-  getSpacePublicInviteArrival: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
+  getSpacePublicInvite: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
+  getSpacePublicInviteArrival: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   getTenant: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   getWebhookDelivery: { rateLimit: { limit: 300, policy: "v1.webhooks.read", windowSeconds: 60 } },
   getWebhookEndpoint: { rateLimit: { limit: 300, policy: "v1.webhooks.read", windowSeconds: 60 } },
@@ -4630,7 +4912,7 @@ var ChalkOperationPolicies = {
   leaveSpacePublicInviteArrival: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   listEpisodes: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   listSpaceLiveEpisodes: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
-  listSpacePublicAdmissionRequests: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
+  listSpacePublicAdmissionRequests: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   listTenants: { rateLimit: { limit: 300, policy: "v1.authenticated.read", windowSeconds: 60 } },
   listWebhookDeliveries: { rateLimit: { limit: 300, policy: "v1.webhooks.read", windowSeconds: 60 } },
   listWebhookEndpoints: { rateLimit: { limit: 300, policy: "v1.webhooks.read", windowSeconds: 60 } },
@@ -4915,13 +5197,27 @@ var defaultGroup = HttpApiGroup.make("default").add(
     success: IssueAccessGrantResponseSchema.pipe(HttpApiSchema.status(201)),
     error: [
       EpisodeInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenInvalidHeaderErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenInvalidSubjectErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenInvalidTimeClaimsErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenLifetimeExceededErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenMalformedErrorSchema.pipe(HttpApiSchema.status(400)),
+      MediaTokenRequiredErrorSchema.pipe(HttpApiSchema.status(400)),
       ParticipantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
       RequestInvalidErrorSchema.pipe(HttpApiSchema.status(400)),
       SpaceInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
       TenantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
       AccessUnauthenticatedErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenExpiredErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenInvalidAudienceErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenInvalidIssuerErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenInvalidSignatureErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenNotYetValidErrorSchema.pipe(HttpApiSchema.status(401)),
+      MediaTokenUnknownKeyErrorSchema.pipe(HttpApiSchema.status(401)),
       AccessForbiddenErrorSchema.pipe(HttpApiSchema.status(403)),
+      MediaTokenSubjectMismatchErrorSchema.pipe(HttpApiSchema.status(403)),
       ParticipantNotFoundErrorSchema.pipe(HttpApiSchema.status(404)),
+      ParticipantConnectionSupersededErrorSchema.pipe(HttpApiSchema.status(409)),
       ParticipantGenerationMismatchErrorSchema.pipe(HttpApiSchema.status(409)),
       RequestPayloadTooLargeErrorSchema.pipe(HttpApiSchema.status(413)),
       RequestRateLimitedErrorSchema.pipe(HttpApiSchema.status(429)),
@@ -6780,6 +7076,45 @@ export {
   MediaConnectionNotFoundError,
   MediaConnectionNotFoundErrorWireSchema,
   MediaConnectionNotFoundErrorSchema,
+  MediaTokenExpiredError,
+  MediaTokenExpiredErrorWireSchema,
+  MediaTokenExpiredErrorSchema,
+  MediaTokenInvalidAudienceError,
+  MediaTokenInvalidAudienceErrorWireSchema,
+  MediaTokenInvalidAudienceErrorSchema,
+  MediaTokenInvalidHeaderError,
+  MediaTokenInvalidHeaderErrorWireSchema,
+  MediaTokenInvalidHeaderErrorSchema,
+  MediaTokenInvalidIssuerError,
+  MediaTokenInvalidIssuerErrorWireSchema,
+  MediaTokenInvalidIssuerErrorSchema,
+  MediaTokenInvalidSignatureError,
+  MediaTokenInvalidSignatureErrorWireSchema,
+  MediaTokenInvalidSignatureErrorSchema,
+  MediaTokenInvalidSubjectError,
+  MediaTokenInvalidSubjectErrorWireSchema,
+  MediaTokenInvalidSubjectErrorSchema,
+  MediaTokenInvalidTimeClaimsError,
+  MediaTokenInvalidTimeClaimsErrorWireSchema,
+  MediaTokenInvalidTimeClaimsErrorSchema,
+  MediaTokenLifetimeExceededError,
+  MediaTokenLifetimeExceededErrorWireSchema,
+  MediaTokenLifetimeExceededErrorSchema,
+  MediaTokenMalformedError,
+  MediaTokenMalformedErrorWireSchema,
+  MediaTokenMalformedErrorSchema,
+  MediaTokenNotYetValidError,
+  MediaTokenNotYetValidErrorWireSchema,
+  MediaTokenNotYetValidErrorSchema,
+  MediaTokenRequiredError,
+  MediaTokenRequiredErrorWireSchema,
+  MediaTokenRequiredErrorSchema,
+  MediaTokenSubjectMismatchError,
+  MediaTokenSubjectMismatchErrorWireSchema,
+  MediaTokenSubjectMismatchErrorSchema,
+  MediaTokenUnknownKeyError,
+  MediaTokenUnknownKeyErrorWireSchema,
+  MediaTokenUnknownKeyErrorSchema,
   MediaUnavailableError,
   MediaUnavailableErrorWireSchema,
   MediaUnavailableErrorSchema,
@@ -6801,6 +7136,9 @@ export {
   PaginationInvalidPageSizeError,
   PaginationInvalidPageSizeErrorWireSchema,
   PaginationInvalidPageSizeErrorSchema,
+  ParticipantConnectionSupersededError,
+  ParticipantConnectionSupersededErrorWireSchema,
+  ParticipantConnectionSupersededErrorSchema,
   ParticipantGenerationMismatchError,
   ParticipantGenerationMismatchErrorWireSchema,
   ParticipantGenerationMismatchErrorSchema,

package/dist/{chunk-O2NOZKJP.js → chunk-DWKTGBHR.js}

@@ -44,7 +44,7 @@ function resolveMediaTarget(participantId, stopped, tracks, target) {
   if (target.participantId !== participantId) return { kind: "result", result: { outcome: "terminal_failure", errorCode: "invalid_participant" } };
   if (stopped) return { kind: "result", result: { outcome: "terminal_failure", errorCode: "media_stopped" } };
   const value = tracks.get(target.source);
-  if (value === void 0) return { kind: "result", result: { outcome: "terminal_failure", errorCode: "source_unavailable" } };
+  if (value === void 0) return { kind: "result", result: target.enabled ? { outcome: "terminal_failure", errorCode: "source_unavailable" } : { outcome: "satisfied", errorCode: null } };
   return { kind: "state", value };
 }
 
@@ -282,7 +282,8 @@ var CloudflareSFUClient = class {
       pendingTrackName: null,
       desiredEnabled: false,
       enabled: false,
-      endedListener: null
+      endedListener: null,
+      clearing: null
     };
     this.#reusableLocalTransceivers.delete(source);
     this.#reusableLocalPublicationIds.delete(source);
@@ -296,24 +297,35 @@ var CloudflareSFUClient = class {
     this.#publishSnapshot();
     this.#emitLocal();
   }
-  async clearPreparedLocalTrack(source) {
+  async clearPreparedLocalTrack(source, options = {}) {
     const state = this.#localTracks.get(source);
     if (!state) return;
+    if (state.clearing) return state.clearing;
+    state.clearing = this.#clearPreparedTrack(state, options.stopTrack);
+    try {
+      await state.clearing;
+    } finally {
+      state.clearing = null;
+    }
+  }
+  async #clearPreparedTrack(state, stopTrack = true) {
+    const source = state.source;
     if (source === "screen_audio") {
       try {
         await this.#retireLocalPublication(source);
       } finally {
-        this.#removeOwnedLocalTrack(state);
-        this.#localTracks.delete(source);
+        this.#removeOwnedLocalTrack(state, stopTrack);
+        if (this.#localTracks.get(source) === state) this.#localTracks.delete(source);
         this.#publishSnapshot();
         this.#emitLocal();
       }
       return;
     }
     if (state.enabled) await this.#setPreparedTrackEnabled(state, false);
+    if (this.#localTracks.get(source) !== state) return;
     if (state.transceiver) this.#reusableLocalTransceivers.set(source, state.transceiver);
     if (state.providerPublicationId) this.#reusableLocalPublicationIds.set(source, state.providerPublicationId);
-    this.#removeOwnedLocalTrack(state);
+    this.#removeOwnedLocalTrack(state, stopTrack);
     this.#localTracks.delete(source);
     this.#publishSnapshot();
     this.#emitLocal();
@@ -1171,9 +1183,9 @@ var CloudflareSFUClient = class {
       this.#reportError(error);
     }
   }
-  #removeOwnedLocalTrack(state) {
+  #removeOwnedLocalTrack(state, stopTrack = true) {
     if (state.endedListener) state.track.removeEventListener("ended", state.endedListener);
-    safeStopTrack(state.track, this.#reportError.bind(this));
+    if (stopTrack) safeStopTrack(state.track, this.#reportError.bind(this));
     state.enabled = false;
     state.desiredEnabled = false;
     state.transceiver = null;