@q9labsai/chalk-client 5.3.0 → 5.3.1

package/dist/generated/schemas.d.ts

@@ -99,6 +99,29 @@ export declare const AdmitEpisodeParticipantRequestSchema: Schema.Struct<{
 export type AdmitEpisodeParticipantRequest = typeof AdmitEpisodeParticipantRequestSchema.Type;
 export declare const AuditLogIdSchema: Schema.brand<Schema.String, "AuditLogId">;
 export type AuditLogId = typeof AuditLogIdSchema.Type;
+export declare const CallStatsRequestSchema: Schema.Struct<{
+    readonly samples: Schema.$Array<Schema.Struct<{
+        readonly connection_type: Schema.Literals<readonly ["udp", "tcp", "turn", "unknown"]>;
+        readonly elapsed_ms: Schema.Number;
+        readonly freeze_count: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly freeze_ms: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly local_candidate_type: Schema.optional<Schema.Literals<readonly ["host", "srflx", "prflx", "relay"]>>;
+        readonly recv_bitrate_kbps: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly recv_height: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly recv_jitter_ms: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly recv_loss_pct: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly relay_protocol: Schema.optional<Schema.Literals<readonly ["udp", "tcp", "tls"]>>;
+        readonly remote_candidate_type: Schema.optional<Schema.Literals<readonly ["host", "srflx", "prflx", "relay"]>>;
+        readonly rtt_ms: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly send_bitrate_kbps: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly send_jitter_ms: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly send_layer: Schema.optional<Schema.Literals<readonly ["h", "m", "l"]>>;
+        readonly send_loss_pct: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly window_ms: Schema.Number;
+    }>>;
+    readonly version: Schema.Literal<1>;
+}>;
+export type CallStatsRequest = typeof CallStatsRequestSchema.Type;
 export declare const CancelRecordingPreparationRequestSchema: Schema.Struct<{
     readonly expected_revision: Schema.Number;
 }>;
@@ -140,6 +163,7 @@ export type CloudflareSFUCloseTracksAPIResponse = typeof CloudflareSFUCloseTrack
 export declare const CloudflareSFUCloseTracksRequestSchema: Schema.Struct<{
     readonly connection_id: Schema.String;
     readonly force: Schema.Boolean;
+    readonly receive_only: Schema.optional<Schema.Boolean>;
     readonly session_description: Schema.optional<Schema.NullOr<Schema.Struct<{
         readonly sdp: Schema.String;
         readonly type: Schema.String;
@@ -173,6 +197,32 @@ export declare const CloudflareSFURenegotiateResponseSchema: Schema.Struct<{
     readonly accepted: Schema.Boolean;
 }>;
 export type CloudflareSFURenegotiateResponse = typeof CloudflareSFURenegotiateResponseSchema.Type;
+export declare const CloudflareSFUUpdateTracksAPIResponseSchema: Schema.Struct<{
+    readonly requiresImmediateRenegotiation: Schema.optional<Schema.Boolean>;
+    readonly sessionDescription: Schema.optional<Schema.NullOr<Schema.Struct<{
+        readonly sdp: Schema.String;
+        readonly type: Schema.String;
+    }>>>;
+    readonly trackErrors: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly code: Schema.String;
+        readonly connectionId: Schema.String;
+        readonly trackName: Schema.String;
+    }>>>;
+    readonly tracks: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly location: Schema.String;
+        readonly mid: Schema.optional<Schema.String>;
+        readonly publication_id: Schema.optional<Schema.String>;
+        readonly sessionId: Schema.optional<Schema.String>;
+        readonly simulcast: Schema.optional<Schema.NullOr<Schema.Struct<{
+            readonly preferredRid: Schema.String;
+            readonly priorityOrdering: Schema.String;
+            readonly ridNotAvailable: Schema.String;
+        }>>>;
+        readonly source: Schema.optional<Schema.String>;
+        readonly trackName: Schema.String;
+    }>>>;
+}>;
+export type CloudflareSFUUpdateTracksAPIResponse = typeof CloudflareSFUUpdateTracksAPIResponseSchema.Type;
 export declare const CloudflareSFUTracksAPIResponseSchema: Schema.Struct<{
     readonly requiresImmediateRenegotiation: Schema.optional<Schema.Boolean>;
     readonly sessionDescription: Schema.optional<Schema.NullOr<Schema.Struct<{
@@ -220,6 +270,23 @@ export declare const CloudflareSFUTracksRequestSchema: Schema.Struct<{
     }>>;
 }>;
 export type CloudflareSFUTracksRequest = typeof CloudflareSFUTracksRequestSchema.Type;
+export declare const CloudflareSFUUpdateTracksRequestSchema: Schema.Struct<{
+    readonly connection_id: Schema.String;
+    readonly tracks: Schema.$Array<Schema.Struct<{
+        readonly location: Schema.String;
+        readonly mid: Schema.optional<Schema.String>;
+        readonly publication_id: Schema.optional<Schema.String>;
+        readonly sessionId: Schema.optional<Schema.String>;
+        readonly simulcast: Schema.optional<Schema.NullOr<Schema.Struct<{
+            readonly preferredRid: Schema.String;
+            readonly priorityOrdering: Schema.String;
+            readonly ridNotAvailable: Schema.String;
+        }>>>;
+        readonly source: Schema.optional<Schema.String>;
+        readonly trackName: Schema.String;
+    }>>;
+}>;
+export type CloudflareSFUUpdateTracksRequest = typeof CloudflareSFUUpdateTracksRequestSchema.Type;
 export declare const ConnectionReportRequestSchema: Schema.Struct<{
     readonly events: Schema.$Array<Schema.Struct<{
         readonly attempt: Schema.optional<Schema.NullOr<Schema.Number>>;
@@ -1662,6 +1729,7 @@ export type CloseCloudflareSFUTracksPathParams = typeof CloseCloudflareSFUTracks
 export declare const CloseCloudflareSFUTracksRequestBodySchema: Schema.Struct<{
     readonly connection_id: Schema.String;
     readonly force: Schema.Boolean;
+    readonly receive_only: Schema.optional<Schema.Boolean>;
     readonly session_description: Schema.optional<Schema.NullOr<Schema.Struct<{
         readonly sdp: Schema.String;
         readonly type: Schema.String;
@@ -3686,6 +3754,62 @@ export declare const TestWebhookEndpoint429ResponseHeadersSchema: Schema.Struct<
     readonly "X-RateLimit-Remaining": Schema.NumberFromString;
 }>;
 export type TestWebhookEndpoint429ResponseHeaders = typeof TestWebhookEndpoint429ResponseHeadersSchema.Type;
+export declare const UpdateCloudflareSFUTracksPathParamsSchema: Schema.Struct<{
+    readonly episode_id: Schema.brand<Schema.String, "EpisodeId">;
+    readonly participant_id: Schema.brand<Schema.String, "ParticipantId">;
+    readonly space_id: Schema.brand<Schema.String, "SpaceId">;
+    readonly tenant_id: Schema.brand<Schema.String, "TenantId">;
+}>;
+export type UpdateCloudflareSFUTracksPathParams = typeof UpdateCloudflareSFUTracksPathParamsSchema.Type;
+export declare const UpdateCloudflareSFUTracksRequestBodySchema: Schema.Struct<{
+    readonly connection_id: Schema.String;
+    readonly tracks: Schema.$Array<Schema.Struct<{
+        readonly location: Schema.String;
+        readonly mid: Schema.optional<Schema.String>;
+        readonly publication_id: Schema.optional<Schema.String>;
+        readonly sessionId: Schema.optional<Schema.String>;
+        readonly simulcast: Schema.optional<Schema.NullOr<Schema.Struct<{
+            readonly preferredRid: Schema.String;
+            readonly priorityOrdering: Schema.String;
+            readonly ridNotAvailable: Schema.String;
+        }>>>;
+        readonly source: Schema.optional<Schema.String>;
+        readonly trackName: Schema.String;
+    }>>;
+}>;
+export type UpdateCloudflareSFUTracksRequestBody = typeof UpdateCloudflareSFUTracksRequestBodySchema.Type;
+export declare const UpdateCloudflareSFUTracksResponseSchema: Schema.Struct<{
+    readonly requiresImmediateRenegotiation: Schema.optional<Schema.Boolean>;
+    readonly sessionDescription: Schema.optional<Schema.NullOr<Schema.Struct<{
+        readonly sdp: Schema.String;
+        readonly type: Schema.String;
+    }>>>;
+    readonly trackErrors: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly code: Schema.String;
+        readonly connectionId: Schema.String;
+        readonly trackName: Schema.String;
+    }>>>;
+    readonly tracks: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly location: Schema.String;
+        readonly mid: Schema.optional<Schema.String>;
+        readonly publication_id: Schema.optional<Schema.String>;
+        readonly sessionId: Schema.optional<Schema.String>;
+        readonly simulcast: Schema.optional<Schema.NullOr<Schema.Struct<{
+            readonly preferredRid: Schema.String;
+            readonly priorityOrdering: Schema.String;
+            readonly ridNotAvailable: Schema.String;
+        }>>>;
+        readonly source: Schema.optional<Schema.String>;
+        readonly trackName: Schema.String;
+    }>>>;
+}>;
+export type UpdateCloudflareSFUTracksResponse = typeof UpdateCloudflareSFUTracksResponseSchema.Type;
+export declare const UpdateCloudflareSFUTracks429ResponseHeadersSchema: Schema.Struct<{
+    readonly "Retry-After": Schema.NumberFromString;
+    readonly "X-RateLimit-Limit": Schema.NumberFromString;
+    readonly "X-RateLimit-Remaining": Schema.NumberFromString;
+}>;
+export type UpdateCloudflareSFUTracks429ResponseHeaders = typeof UpdateCloudflareSFUTracks429ResponseHeadersSchema.Type;
 export declare const UpdateMembershipPathParamsSchema: Schema.Struct<{
     readonly membership_id: Schema.brand<Schema.String, "MembershipId">;
     readonly tenant_id: Schema.brand<Schema.String, "TenantId">;
@@ -3902,6 +4026,39 @@ export declare const UpdateWebhookEndpoint429ResponseHeadersSchema: Schema.Struc
     readonly "X-RateLimit-Remaining": Schema.NumberFromString;
 }>;
 export type UpdateWebhookEndpoint429ResponseHeaders = typeof UpdateWebhookEndpoint429ResponseHeadersSchema.Type;
+export declare const UploadCallStatsPathParamsSchema: Schema.Struct<{
+    readonly tenant_id: Schema.brand<Schema.String, "TenantId">;
+}>;
+export type UploadCallStatsPathParams = typeof UploadCallStatsPathParamsSchema.Type;
+export declare const UploadCallStatsRequestBodySchema: Schema.Struct<{
+    readonly samples: Schema.$Array<Schema.Struct<{
+        readonly connection_type: Schema.Literals<readonly ["udp", "tcp", "turn", "unknown"]>;
+        readonly elapsed_ms: Schema.Number;
+        readonly freeze_count: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly freeze_ms: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly local_candidate_type: Schema.optional<Schema.Literals<readonly ["host", "srflx", "prflx", "relay"]>>;
+        readonly recv_bitrate_kbps: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly recv_height: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly recv_jitter_ms: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly recv_loss_pct: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly relay_protocol: Schema.optional<Schema.Literals<readonly ["udp", "tcp", "tls"]>>;
+        readonly remote_candidate_type: Schema.optional<Schema.Literals<readonly ["host", "srflx", "prflx", "relay"]>>;
+        readonly rtt_ms: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly send_bitrate_kbps: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly send_jitter_ms: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly send_layer: Schema.optional<Schema.Literals<readonly ["h", "m", "l"]>>;
+        readonly send_loss_pct: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly window_ms: Schema.Number;
+    }>>;
+    readonly version: Schema.Literal<1>;
+}>;
+export type UploadCallStatsRequestBody = typeof UploadCallStatsRequestBodySchema.Type;
+export declare const UploadCallStats429ResponseHeadersSchema: Schema.Struct<{
+    readonly "Retry-After": Schema.NumberFromString;
+    readonly "X-RateLimit-Limit": Schema.NumberFromString;
+    readonly "X-RateLimit-Remaining": Schema.NumberFromString;
+}>;
+export type UploadCallStats429ResponseHeaders = typeof UploadCallStats429ResponseHeadersSchema.Type;
 declare const AccessForbiddenError_base: Schema.Class<AccessForbiddenError, Schema.TaggedStruct<"AccessForbiddenError", {
     readonly error: Schema.Struct<{
         readonly code: Schema.Literal<"access.forbidden">;
@@ -10795,6 +10952,78 @@ export declare const TestWebhookEndpointErrorSchema: Schema.Union<readonly [Sche
     }>;
 }>, never, never>]>;
 export type TestWebhookEndpointError = typeof TestWebhookEndpointErrorSchema.Type;
+export declare const UpdateCloudflareSFUTracksErrorSchema: Schema.Union<readonly [Schema.decodeTo<typeof AccessForbiddenError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"access.forbidden">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof AccessUnauthenticatedError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"access.unauthenticated">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof EpisodeInvalidIdError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"episode.invalid_id">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof EpisodeNotFoundError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"episode.not_found">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof MediaConnectionNotFoundError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"media.connection_not_found">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof MediaUnavailableError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"media.unavailable">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof ParticipantInvalidIdError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"participant.invalid_id">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof RequestInvalidError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"request.invalid">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof RequestPayloadTooLargeError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"request.payload_too_large">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof RequestRateLimitedError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"request.rate_limited">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof ServiceInternalError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"service.internal_error">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof ServiceUnavailableError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"service.unavailable">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof SpaceInvalidIdError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"space.invalid_id">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof TenantInvalidIdError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"tenant.invalid_id">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>]>;
+export type UpdateCloudflareSFUTracksError = typeof UpdateCloudflareSFUTracksErrorSchema.Type;
 export declare const UpdateMembershipErrorSchema: Schema.Union<readonly [Schema.decodeTo<typeof AccessForbiddenError, Schema.Struct<{
     readonly error: Schema.Struct<{
         readonly code: Schema.Literal<"access.forbidden">;
@@ -11195,6 +11424,48 @@ export declare const UpdateWebhookEndpointErrorSchema: Schema.Union<readonly [Sc
     }>;
 }>, never, never>]>;
 export type UpdateWebhookEndpointError = typeof UpdateWebhookEndpointErrorSchema.Type;
+export declare const UploadCallStatsErrorSchema: Schema.Union<readonly [Schema.decodeTo<typeof AccessForbiddenError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"access.forbidden">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof AccessUnauthenticatedError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"access.unauthenticated">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof RequestInvalidError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"request.invalid">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof RequestPayloadTooLargeError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"request.payload_too_large">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof RequestRateLimitedError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"request.rate_limited">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof ServiceInternalError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"service.internal_error">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof ServiceUnavailableError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"service.unavailable">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>, Schema.decodeTo<typeof TenantInvalidIdError, Schema.Struct<{
+    readonly error: Schema.Struct<{
+        readonly code: Schema.Literal<"tenant.invalid_id">;
+        readonly message: Schema.String;
+    }>;
+}>, never, never>]>;
+export type UploadCallStatsError = typeof UploadCallStatsErrorSchema.Type;
 export declare const ChalkOperationPolicies: {
     readonly addCloudflareSFUTracks: {
         readonly maxBodyBytes: 1048576;
@@ -11644,6 +11915,14 @@ export declare const ChalkOperationPolicies: {
             readonly windowSeconds: 60;
         };
     };
+    readonly updateCloudflareSFUTracks: {
+        readonly maxBodyBytes: 1048576;
+        readonly rateLimit: {
+            readonly limit: 60;
+            readonly policy: "v1.authenticated.write";
+            readonly windowSeconds: 60;
+        };
+    };
     readonly updateMembership: {
         readonly maxBodyBytes: 1048576;
         readonly rateLimit: {
@@ -11684,6 +11963,14 @@ export declare const ChalkOperationPolicies: {
             readonly windowSeconds: 60;
         };
     };
+    readonly uploadCallStats: {
+        readonly maxBodyBytes: 32768;
+        readonly rateLimit: {
+            readonly limit: 30;
+            readonly policy: "call_stats.participant";
+            readonly windowSeconds: 600;
+        };
+    };
 };
 export type ChalkOperationPolicy = (typeof ChalkOperationPolicies)[keyof typeof ChalkOperationPolicies];
 export {};

package/dist/generated/sync.d.ts

@@ -100,11 +100,20 @@ export declare const SyncProtocolMetadata: {
                 readonly pattern: "^[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256}(,[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256})*$";
             };
         };
+        readonly helloOnlyFields: {
+            readonly baggage: {
+                readonly kind: "string";
+                readonly minBytes: 47;
+                readonly maxBytes: 47;
+                readonly format: "w3c-baggage-session-id";
+                readonly pattern: "^session\\.id=[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$";
+            };
+        };
         readonly acceptedOn: {
             readonly hello: "client-to-server";
             readonly serverFrames: "server-to-client";
         };
-        readonly upgradeHeaders: readonly ["x-chalk-journey-id", "traceparent", "tracestate"];
+        readonly upgradeHeaders: readonly ["x-chalk-journey-id", "traceparent", "tracestate", "baggage"];
         readonly rule: "propagate_from_first_observed_layer_to_every_downstream_frame";
     };
     readonly externalIntents: readonly ["admit_participant", "deny_admission", "admission_request_expired", "mute_participant", "stop_participant_camera", "stop_participant_screen_share", "remove_participant", "start_recording", "stop_recording", "participant_leave", "start_episode", "extend_episode", "end_episode", "tenant_set_deadline", "tenant_end_episode", "maximum_duration_expired"];
@@ -353,6 +362,7 @@ export declare const UuidSchema: Schema.String;
 export declare const JourneyIdSchema: Schema.String;
 export declare const TraceparentSchema: Schema.String;
 export declare const TracestateSchema: Schema.String;
+export declare const BaggageSchema: Schema.String;
 export declare const SyncCorrelationFieldsSchema: Schema.Struct<{
     readonly journey_id: Schema.optional<Schema.String>;
     readonly traceparent: Schema.optional<Schema.String>;
@@ -424,6 +434,7 @@ export declare const HelloFrameSchema: Schema.Struct<{
     readonly journey_id: Schema.optional<Schema.String>;
     readonly traceparent: Schema.optional<Schema.String>;
     readonly tracestate: Schema.optional<Schema.String>;
+    readonly baggage: Schema.optional<Schema.String>;
     readonly type: Schema.Literal<"hello">;
     readonly protocol: Schema.Literal<1>;
     readonly token: Schema.String;
@@ -461,6 +472,7 @@ export declare const ExtendedHelloFrameSchema: Schema.Struct<{
     readonly journey_id: Schema.optional<Schema.String>;
     readonly traceparent: Schema.optional<Schema.String>;
     readonly tracestate: Schema.optional<Schema.String>;
+    readonly baggage: Schema.optional<Schema.String>;
     readonly type: Schema.Literal<"hello">;
     readonly protocol: Schema.Literal<1>;
     readonly token: Schema.String;
@@ -2793,6 +2805,7 @@ export declare const SyncV1ClientFrameSchema: Schema.decodeTo<Schema.Union<reado
     readonly journey_id: Schema.optional<Schema.String>;
     readonly traceparent: Schema.optional<Schema.String>;
     readonly tracestate: Schema.optional<Schema.String>;
+    readonly baggage: Schema.optional<Schema.String>;
     readonly type: Schema.Literal<"hello">;
     readonly protocol: Schema.Literal<1>;
     readonly token: Schema.String;
@@ -2825,6 +2838,7 @@ export declare const SyncV1ClientFrameSchema: Schema.decodeTo<Schema.Union<reado
     readonly journey_id: Schema.optional<Schema.String>;
     readonly traceparent: Schema.optional<Schema.String>;
     readonly tracestate: Schema.optional<Schema.String>;
+    readonly baggage: Schema.optional<Schema.String>;
     readonly type: Schema.Literal<"hello">;
     readonly protocol: Schema.Literal<1>;
     readonly token: Schema.String;

package/dist/index.d.ts

@@ -5,5 +5,6 @@ export * from "./space-client";
 export * from "./sync";
 export * from "./whiteboard";
 export * from "./public-invites";
+export { currentSessionId, newSessionId, requestContextHeaders, SESSION_ID_KEY, sessionBaggage, setSessionSource, withRequestContext, type SessionSource } from "./session";
 export { formatSyncConnectDiagnostic } from "./sync/connect-diagnostics";
 export { getConnectionFailureDetail } from "./space-client/failure-detail";

package/dist/index.js

@@ -15,7 +15,19 @@ import {
   createSpaceClient,
   decodeWhiteboardV1ServerFrame,
   encodeWhiteboardV1ClientFrame
-} from "./chunk-DHUHTIU7.js";
+} from "./chunk-2CEMOTZF.js";
+import {
+  createChalkPublicClient,
+  createChalkPublicInviteClient,
+  parseInviteCode
+} from "./chunk-VAJ6XNAA.js";
+import {
+  ArrivalInvalidHandleError,
+  ArrivalUnavailableError,
+  SpacePublicInviteUnavailableError,
+  parseParsedAccessGrant,
+  requireAccessGrant
+} from "./chunk-MHJ4UPM3.js";
 import {
   CloudflareSFUClient,
   CloudflareSFUError,
@@ -26,21 +38,10 @@ import {
   publicationKey,
   requireDescription,
   requireSFUDescription,
+  setVideoRenderSize,
   validatePublicationSnapshot,
   waitFor
-} from "./chunk-3TGVTP6Z.js";
-import {
-  createChalkPublicClient,
-  createChalkPublicInviteClient,
-  parseInviteCode
-} from "./chunk-O26BHHMI.js";
-import {
-  ArrivalInvalidHandleError,
-  ArrivalUnavailableError,
-  SpacePublicInviteUnavailableError,
-  parseParsedAccessGrant,
-  requireAccessGrant
-} from "./chunk-GOSWSXTH.js";
+} from "./chunk-O5JB5XVX.js";
 import {
   AsyncStorageV1PendingTargetStore,
   InMemoryV1PendingTargetStore,
@@ -69,7 +70,16 @@ import {
   optimisticV1Control,
   reactionFromFrame,
   restoreV1Snapshot
-} from "./chunk-XSB2GDRW.js";
+} from "./chunk-FD7ZSDTM.js";
+import {
+  SESSION_ID_KEY,
+  currentSessionId,
+  newSessionId,
+  requestContextHeaders,
+  sessionBaggage,
+  setSessionSource,
+  withRequestContext
+} from "./chunk-N4IPKRS6.js";
 
 // src/space-client/reload-rejoin.ts
 import { Schema } from "effect";
@@ -149,6 +159,7 @@ export {
   InMemoryChalkWhiteboardV1PendingOperationStore,
   InMemoryV1PendingTargetStore,
   IndexedDbV1PendingTargetStore,
+  SESSION_ID_KEY,
   SpaceClientError,
   SpacePublicInviteUnavailableError,
   SyncBrowserCapabilityError,
@@ -176,6 +187,7 @@ export {
   createReactNativeWebSocketFactory,
   createSpaceClient,
   createV1SyncClient,
+  currentSessionId,
   decodeV1ClientFrame,
   decodeV1ServerFrame,
   decodeWhiteboardV1ServerFrame,
@@ -184,6 +196,7 @@ export {
   encodeWhiteboardV1ClientFrame,
   formatSyncConnectDiagnostic,
   getConnectionFailureDetail,
+  newSessionId,
   optimisticV1Control,
   parseCloudflareSFUPublicationID,
   parseInviteCode,
@@ -192,11 +205,16 @@ export {
   readReloadRejoin,
   reloadRejoinAccess,
   reloadRejoinStorageKey,
+  requestContextHeaders,
   requireDescription,
   requireSFUDescription,
   restoreV1Snapshot,
   resumeReloadRejoin,
+  sessionBaggage,
+  setSessionSource,
+  setVideoRenderSize,
   validatePublicationSnapshot,
   waitFor,
+  withRequestContext,
   writeReloadRejoin
 };

package/dist/media/call-stats.d.ts

@@ -0,0 +1,27 @@
+import type { components } from "../generated/openapi-types";
+export type CallStatsRequest = components["schemas"]["CallStatsRequest"];
+export type CallStatsSample = CallStatsRequest["samples"][number];
+/** One summary covers this long, so a call makes about six per minute. */
+export declare const CALL_STATS_WINDOW_MS = 10000;
+/** A batch uploads once it holds this many samples (about a minute of call). */
+export declare const CALL_STATS_UPLOAD_SAMPLES = 6;
+/** The API rejects larger batches. */
+export declare const CALL_STATS_MAX_BATCH = 30;
+/** The API rejects a window longer than this and drops the whole batch, so a longer gap (a stalled tab, a sleeping device) is skipped. */
+export declare const CALL_STATS_MAX_WINDOW_MS = 60000;
+/** Per-call cap: about an hour of samples. Later windows are dropped. */
+export declare const CALL_STATS_CALL_CAP = 360;
+export type CallStatsCollector = {
+    /** Feed one `getStats()` report. Cheap; summarises once a window has elapsed. */
+    readonly observe: (report: RTCStatsReport) => void;
+    /** Close the open window (if long enough) and upload what is buffered with `upload`, once any upload in flight ends. */
+    readonly flush: (upload: Upload) => Promise<void>;
+    /** A new peer connection starts new counters: drop the open window and its baseline, keep what is already buffered. */
+    readonly reset: () => void;
+};
+type Upload = (request: CallStatsRequest) => Promise<void>;
+export declare function createCallStatsCollector(options: {
+    readonly upload: Upload;
+    readonly now?: () => number;
+}): CallStatsCollector;
+export {};

package/dist/media/ice-servers.d.ts

@@ -0,0 +1,3 @@
+import type { CloudflareSFUBootstrap } from "./types";
+/** The server sends TURN with its STUN entry; an older server sends only `stunServer`. */
+export declare function iceServersFor(bootstrap: CloudflareSFUBootstrap): RTCIceServer[];

package/dist/media/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./cloudflare-sfu";
 export type { ClientMediaPlane, ConnectionMediaLocalTrack, ConnectionMediaPhase, ConnectionMediaRemoteTrack, ConnectionMediaSnapshot, MediaPlaneOutcome, MediaPlaneResult, MediaPlaneTarget, MediaPublication, MediaPublicationSource, MediaSource } from "./plane";
 export { describeMediaCaptureError } from "./capture-error";
+export { setVideoRenderSize } from "./video-render-size";
+export type { VideoRenderSize } from "./video-render-size";

package/dist/media/index.js

@@ -8,9 +8,11 @@ import {
   publicationKey,
   requireDescription,
   requireSFUDescription,
+  setVideoRenderSize,
   validatePublicationSnapshot,
   waitFor
-} from "../chunk-3TGVTP6Z.js";
+} from "../chunk-O5JB5XVX.js";
+import "../chunk-N4IPKRS6.js";
 export {
   CloudflareSFUClient,
   CloudflareSFUError,
@@ -21,6 +23,7 @@ export {
   publicationKey,
   requireDescription,
   requireSFUDescription,
+  setVideoRenderSize,
   validatePublicationSnapshot,
   waitFor
 };

package/dist/media/receive-stall.d.ts

@@ -25,15 +25,24 @@ export type ReceiveStallObservation = {
     readonly expectedTracks: number;
     readonly stalledTracks: number;
 };
-/** Owns eligibility, pending stalls and the budget across replacement peers. */
+/**
+ * Owns eligibility, pending stalls and the budget across replacement peers.
+ * Rebuild budgets belong to a remote participant's source, not to one publication id:
+ * a rebuild republishes every local track, and the peers' replacement publications must not renew them.
+ */
 export declare class ReceiveStallRecovery {
     #private;
     get observations(): readonly ReceiveStallObservation[];
     expect(publications: readonly MediaPublication[], participantId: string): void;
     suspend(): void;
     isStalled(publicationId: string): boolean;
-    canRebuild(): boolean;
+    canRepull(id: string): boolean;
+    reserveRepull(id: string): boolean;
+    restarted(id: string): void;
+    canRebuild(id?: string): boolean;
     reserveRebuild(): boolean;
+    /** The media connection was replaced: its receivers are gone, so nothing is awaiting a restore. */
+    replaced(): void;
     clear(): void;
     sample(now: number, connection: RTCPeerConnection, report: RTCStatsReport, tracks: Iterable<CloudflareSFURemoteTrack>): {
         readonly stalled: readonly string[];

package/dist/media/types.d.ts

@@ -1,8 +1,15 @@
 import type { ConnectionReportTransportEvent } from "../transport-diagnostics";
 import type { MediaConnectionReplacementCause, MediaPublication, MediaPublicationSource } from "./plane";
+export type CloudflareSFUIceServer = {
+    readonly urls: readonly string[];
+    readonly username?: string;
+    readonly credential?: string;
+};
 export type CloudflareSFUBootstrap = {
     readonly connectionId: string;
     readonly stunServer: string;
+    /** STUN and TURN servers from the API. Absent on older servers, which means STUN only. */
+    readonly iceServers?: readonly CloudflareSFUIceServer[];
 };
 export type CloudflareSFUSessionDescription = {
     readonly type: "offer" | "answer";
@@ -59,12 +66,24 @@ export type CloudflareSFUSignalingTransport = {
         readonly sessionDescription?: CloudflareSFUSessionDescription;
         readonly tracks: readonly CloudflareSFUCloseTrackRequest[];
         readonly force: boolean;
+        readonly receiveOnly?: boolean;
+    }) => Promise<CloudflareSFUTracksResponse>;
+    /** Changes the simulcast layer of tracks already pulled, without renegotiating. Transports without it keep the layer chosen at pull time. */
+    readonly updateTracks?: (input: {
+        readonly connectionId: string;
+        readonly tracks: readonly CloudflareSFUTrackRequest[];
     }) => Promise<CloudflareSFUTracksResponse>;
     readonly renegotiate: (input: {
         readonly connectionId: string;
         readonly sessionDescription: CloudflareSFUSessionDescription;
     }) => Promise<void>;
     readonly listPublications: () => Promise<CloudflareSFUPublicationSnapshot>;
+    /**
+     * Best-effort per-call stats upload; transports without it simply report nothing. The `closing`
+     * batch reuses the last token and never asks the credential provider, which could refresh access
+     * for a participant who just left or was evicted.
+     */
+    readonly uploadCallStats?: (stats: import("./call-stats").CallStatsRequest, closing: boolean) => Promise<void>;
 };
 export type CloudflareSFURemoteTrack = CloudflareSFUPublication & {
     readonly track: MediaStreamTrack;