@q9labsai/chalk-client 5.2.3 → 5.2.5

package/dist/{chunk-6LNRDKJF.js → chunk-LKNT6XFD.js}

@@ -1,7 +1,7 @@
 import {
   createChalkEffectClient,
   parseAccessGrant
-} from "./chunk-GA3JDPFI.js";
+} from "./chunk-UMAE5GCV.js";
 
 // src/public-invites/client.ts
 import { Effect } from "effect";

package/dist/{chunk-GA3JDPFI.js → chunk-UMAE5GCV.js}

@@ -243,6 +243,79 @@ var CloudflareSFUTracksRequestSchema = Schema.Struct({
     })
   )
 });
+var ConnectionReportRequestSchema = Schema.Struct({
+  events: Schema.Array(
+    Schema.Struct({
+      attempt: Schema.optional(Schema.NullOr(Schema.Number)),
+      close_code: Schema.optional(Schema.NullOr(Schema.Number)),
+      code: Schema.optional(
+        Schema.Literals([
+          "invalid_state",
+          "invalid_access",
+          "access_unavailable",
+          "permission_denied",
+          "device_not_found",
+          "device_busy",
+          "device_constraint_invalid",
+          "media_capture_failed",
+          "sync_start_failed",
+          "state_digest_recovery_failed",
+          "sync_hello_timeout",
+          "media_start_failed",
+          "join_cleanup_unconfirmed",
+          "sync_recovery_exhausted",
+          "media_recovery_exhausted",
+          "command_rejected",
+          "leave_unconfirmed",
+          "episode_ended",
+          "unsupported_environment",
+          "internal_error",
+          "collaboration_unavailable",
+          "chat_cursor_reset_required",
+          "rate_limited",
+          "invalid_payload"
+        ])
+      ),
+      duration_ms: Schema.optional(Schema.NullOr(Schema.Number)),
+      elapsed_ms: Schema.Number,
+      event: Schema.Literals([
+        "space_join_span",
+        "state_changed",
+        "connection_failed",
+        "sync_connect_failed",
+        "sync_dial_timeout",
+        "access_refreshed",
+        "access_refresh_failed",
+        "recovery_attempt",
+        "recovery_succeeded",
+        "recovery_exhausted",
+        "cleanup_completed",
+        "cleanup_unconfirmed",
+        "sync_socket_open",
+        "sync_socket_close",
+        "sync_heartbeat_gap",
+        "media_state",
+        "media_http_error",
+        "media_projection_mismatch"
+      ]),
+      granted_audio: Schema.optional(Schema.Literals(["granted", "not_granted", "unknown"])),
+      granted_video: Schema.optional(Schema.Literals(["granted", "not_granted", "unknown"])),
+      heartbeat_gap_ms: Schema.optional(Schema.NullOr(Schema.Number)),
+      http_status: Schema.optional(Schema.NullOr(Schema.Number)),
+      media_error_kind: Schema.optional(Schema.Literals(["NotAllowedError", "NotReadableError", "NotFoundError", "OverconstrainedError", "AbortError", "SecurityError", "InvalidStateError", "OperationError", "NotSupportedError", "CloudflareSFUError", "network", "timeout", "unknown"])),
+      media_error_step: Schema.optional(Schema.Literals(["local_capture", "peer_connection", "access_refresh", "sfu_tracks", "sfu_close_tracks", "sfu_renegotiate", "sfu_publications"])),
+      outcome: Schema.optional(Schema.Literals(["started", "succeeded", "failed", "cancelled"])),
+      phase: Schema.optional(Schema.Literals(["idle", "connecting", "live", "recovering", "failed", "stopped", "new", "connected", "disconnected", "closed"])),
+      projection_state: Schema.optional(Schema.Literals(["on", "off"])),
+      publication_state: Schema.optional(Schema.Literals(["on", "off"])),
+      source: Schema.optional(Schema.Literals(["microphone", "camera"])),
+      state: Schema.optional(Schema.Literals(["idle", "joining", "live", "reconnecting", "leaving", "left", "failed"])),
+      step: Schema.optional(Schema.Literals(["join", "acquire_initial_media", "access_initialize", "create_media_client", "create_sync_client", "start_media", "start_sync", "wait_for_sync_live", "confirm_entered"]))
+    })
+  ).check(Schema.isMinLength(1), Schema.isMaxLength(64)),
+  trigger: Schema.Literals(["join_failed", "connection_lost", "recovery_exhausted", "media_projection_mismatch"]),
+  version: Schema.Literal(1)
+});
 var CreateAPIKeyRequestSchema = Schema.Struct({
   expires_at: DateTimeStringSchema,
   name: Schema.String.check(Schema.isMinLength(1)),
@@ -410,6 +483,7 @@ var IntegrationActionIdSchema = Schema.String.check(Schema.isMinLength(1)).pipe(
 var IntegrationServiceIdSchema = Schema.String.check(Schema.isMinLength(1)).pipe(Schema.brand("IntegrationServiceId"));
 var IssueAccessGrantRequestSchema = Schema.Struct({
   current_media_token: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
+  expected_media_connection_id: Schema.optional(Schema.NullOr(Schema.String.check(Schema.isMinLength(1)))),
   participant_generation: Schema.Number,
   replace_media_connection: Schema.Boolean
 });
@@ -428,6 +502,9 @@ var MembershipListSchema = Schema.Struct({
   memberships: Schema.Array(MembershipSchema),
   pagination: PaginationSchema
 });
+var ParticipantEpisodeStatusSchema = Schema.Struct({
+  status: Schema.Literals(["active", "ending", "ended"])
+});
 var ParticipantJoinCancellationSchema = Schema.Struct({
   cancelled: Schema.Boolean
 });
@@ -1318,6 +1395,18 @@ var GetEpisodeAttendance429ResponseHeadersSchema = Schema.Struct({
   "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
   "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
 });
+var GetParticipantEpisodeStatusPathParamsSchema = Schema.Struct({
+  episode_id: EpisodeIdSchema,
+  participant_id: ParticipantIdSchema,
+  space_id: SpaceIdSchema,
+  tenant_id: TenantIdSchema
+});
+var GetParticipantEpisodeStatusResponseSchema = ParticipantEpisodeStatusSchema;
+var GetParticipantEpisodeStatus429ResponseHeadersSchema = Schema.Struct({
+  "Retry-After": RetryAfterHeaderSchema,
+  "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
+  "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
+});
 var GetProblemReportAvailabilityPathParamsSchema = Schema.Struct({
   tenant_id: TenantIdSchema
 });
@@ -1687,6 +1776,15 @@ var RenegotiateCloudflareSFU429ResponseHeadersSchema = Schema.Struct({
   "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
   "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
 });
+var ReportConnectionFailurePathParamsSchema = Schema.Struct({
+  tenant_id: TenantIdSchema
+});
+var ReportConnectionFailureRequestBodySchema = ConnectionReportRequestSchema;
+var ReportConnectionFailure429ResponseHeadersSchema = Schema.Struct({
+  "Retry-After": RetryAfterHeaderSchema,
+  "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
+  "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
+});
 var RequestRecordingExportPathParamsSchema = Schema.Struct({
   recording_id: RecordingIdSchema,
   tenant_id: TenantIdSchema
@@ -2815,6 +2913,25 @@ var ParticipantInvalidIdErrorSchema = ParticipantInvalidIdErrorWireSchema.pipe(
     encode: SchemaGetter.transform((error) => ({ error: error.error }))
   })
 );
+var ParticipantMediaReplacementPendingError = class extends Schema.TaggedErrorClass()("ParticipantMediaReplacementPendingError", {
+  error: Schema.Struct({
+    code: Schema.Literal("participant.media_replacement_pending"),
+    message: Schema.String
+  })
+}) {
+};
+var ParticipantMediaReplacementPendingErrorWireSchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.Literal("participant.media_replacement_pending"),
+    message: Schema.String
+  })
+});
+var ParticipantMediaReplacementPendingErrorSchema = ParticipantMediaReplacementPendingErrorWireSchema.pipe(
+  Schema.decodeTo(ParticipantMediaReplacementPendingError, {
+    decode: SchemaGetter.transform((wire) => ({ _tag: "ParticipantMediaReplacementPendingError", ...wire })),
+    encode: SchemaGetter.transform((error) => ({ error: error.error }))
+  })
+);
 var ParticipantNotActiveError = class extends Schema.TaggedErrorClass()("ParticipantNotActiveError", {
   error: Schema.Struct({
     code: Schema.Literal("participant.not_active"),
@@ -4416,6 +4533,18 @@ var GetEpisodeErrorSchema = Schema.Union([
   SpaceNotFoundErrorSchema,
   TenantInvalidIdErrorSchema
 ]);
+var GetParticipantEpisodeStatusErrorSchema = Schema.Union([
+  AccessForbiddenErrorSchema,
+  AccessUnauthenticatedErrorSchema,
+  EpisodeInvalidIdErrorSchema,
+  EpisodeNotFoundErrorSchema,
+  ParticipantInvalidIdErrorSchema,
+  RequestRateLimitedErrorSchema,
+  ServiceInternalErrorSchema,
+  ServiceUnavailableErrorSchema,
+  SpaceInvalidIdErrorSchema,
+  TenantInvalidIdErrorSchema
+]);
 var GetProblemReportAvailabilityErrorSchema = TenantInvalidIdErrorSchema;
 var GetRecordingErrorSchema = Schema.Union([AccessForbiddenErrorSchema, AccessUnauthenticatedErrorSchema, RecordingInvalidIdErrorSchema, RecordingNotFoundErrorSchema, ServiceInternalErrorSchema, ServiceUnavailableErrorSchema, TenantInvalidIdErrorSchema]);
 var GetSpaceErrorSchema = Schema.Union([AccessForbiddenErrorSchema, AccessUnauthenticatedErrorSchema, ServiceInternalErrorSchema, ServiceUnavailableErrorSchema, SpaceInvalidIdErrorSchema, SpaceNotFoundErrorSchema, TenantInvalidIdErrorSchema]);
@@ -4547,6 +4676,7 @@ var IssueAccessGrantErrorSchema = Schema.Union([
   ParticipantConnectionSupersededErrorSchema,
   ParticipantGenerationMismatchErrorSchema,
   ParticipantInvalidIdErrorSchema,
+  ParticipantMediaReplacementPendingErrorSchema,
   ParticipantNotFoundErrorSchema,
   RequestInvalidErrorSchema,
   RequestPayloadTooLargeErrorSchema,
@@ -4794,6 +4924,16 @@ var RenegotiateCloudflareSFUErrorSchema = Schema.Union([
   SpaceInvalidIdErrorSchema,
   TenantInvalidIdErrorSchema
 ]);
+var ReportConnectionFailureErrorSchema = Schema.Union([
+  AccessForbiddenErrorSchema,
+  AccessUnauthenticatedErrorSchema,
+  RequestInvalidErrorSchema,
+  RequestPayloadTooLargeErrorSchema,
+  RequestRateLimitedErrorSchema,
+  ServiceInternalErrorSchema,
+  ServiceUnavailableErrorSchema,
+  TenantInvalidIdErrorSchema
+]);
 var RequestRecordingExportErrorSchema = Schema.Union([
   AccessForbiddenErrorSchema,
   AccessUnauthenticatedErrorSchema,
@@ -5064,6 +5204,7 @@ 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 } },
+  getParticipantEpisodeStatus: { rateLimit: { limit: 300, policy: "v1.authenticated.read", 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 } },
@@ -5087,6 +5228,7 @@ var ChalkOperationPolicies = {
   refreshSpacePublicInviteAccess: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   removeEpisodeParticipant: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   renegotiateCloudflareSFU: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
+  reportConnectionFailure: { maxBodyBytes: 32768, rateLimit: { limit: 6, policy: "connection_reports.participant", windowSeconds: 600 } },
   requestRecordingExport: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   requestTranscript: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   restoreSpace: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
@@ -5390,6 +5532,7 @@ var defaultGroup = HttpApiGroup.make("default").add(
       ParticipantNotFoundErrorSchema.pipe(HttpApiSchema.status(404)),
       ParticipantConnectionSupersededErrorSchema.pipe(HttpApiSchema.status(409)),
       ParticipantGenerationMismatchErrorSchema.pipe(HttpApiSchema.status(409)),
+      ParticipantMediaReplacementPendingErrorSchema.pipe(HttpApiSchema.status(409)),
       RequestPayloadTooLargeErrorSchema.pipe(HttpApiSchema.status(413)),
       RequestRateLimitedErrorSchema.pipe(HttpApiSchema.status(429)),
       ServiceInternalErrorSchema.pipe(HttpApiSchema.status(500)),
@@ -5528,6 +5671,22 @@ var defaultGroup = HttpApiGroup.make("default").add(
       ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
     ]
   })
+).add(
+  HttpApiEndpoint.post("reportConnectionFailure", "/v1/tenants/:tenant_id/connection-reports", {
+    params: ReportConnectionFailurePathParamsSchema,
+    payload: ReportConnectionFailureRequestBodySchema,
+    success: HttpApiSchema.Empty(204).pipe(HttpApiSchema.status(204)),
+    error: [
+      RequestInvalidErrorSchema.pipe(HttpApiSchema.status(400)),
+      TenantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      AccessUnauthenticatedErrorSchema.pipe(HttpApiSchema.status(401)),
+      AccessForbiddenErrorSchema.pipe(HttpApiSchema.status(403)),
+      RequestPayloadTooLargeErrorSchema.pipe(HttpApiSchema.status(413)),
+      RequestRateLimitedErrorSchema.pipe(HttpApiSchema.status(429)),
+      ServiceInternalErrorSchema.pipe(HttpApiSchema.status(500)),
+      ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
+    ]
+  })
 ).add(
   HttpApiEndpoint.delete("revokeAPIKey", "/v1/tenants/:tenant_id/api-keys/:api_key_id", {
     params: RevokeAPIKeyPathParamsSchema,
@@ -5810,6 +5969,23 @@ var episodesGroup = HttpApiGroup.make("episodes").add(
       ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
     ]
   })
+).add(
+  HttpApiEndpoint.get("getParticipantEpisodeStatus", "/v1/tenants/:tenant_id/spaces/:space_id/episodes/:episode_id/participants/:participant_id/episode-status", {
+    params: GetParticipantEpisodeStatusPathParamsSchema,
+    success: GetParticipantEpisodeStatusResponseSchema.pipe(HttpApiSchema.status(200)),
+    error: [
+      EpisodeInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      ParticipantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      SpaceInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      TenantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      AccessUnauthenticatedErrorSchema.pipe(HttpApiSchema.status(401)),
+      AccessForbiddenErrorSchema.pipe(HttpApiSchema.status(403)),
+      EpisodeNotFoundErrorSchema.pipe(HttpApiSchema.status(404)),
+      RequestRateLimitedErrorSchema.pipe(HttpApiSchema.status(429)),
+      ServiceInternalErrorSchema.pipe(HttpApiSchema.status(500)),
+      ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
+    ]
+  })
 ).add(
   HttpApiEndpoint.post("issueEpisodeParticipantSyncToken", "/v1/tenants/:tenant_id/spaces/:space_id/episodes/:episode_id/participants/:participant_id/sync-token", {
     params: IssueEpisodeParticipantSyncTokenPathParamsSchema,
@@ -6696,11 +6872,13 @@ function decodeBase64Url(value) {
 // src/access/grant.ts
 var accessGrantBrand = /* @__PURE__ */ Symbol("AccessGrant");
 var AccessGrantError = class extends TypeError {
-  code = "access.invalid";
-  constructor(message = "Access grant is invalid") {
+  constructor(message = "Access grant is invalid", reason) {
     super(message);
+    this.reason = reason;
     this.name = "AccessGrantError";
   }
+  reason;
+  code = "access.invalid";
 };
 var AccessUnavailableError = class extends Error {
   code = "access.unavailable";
@@ -6709,12 +6887,21 @@ var AccessUnavailableError = class extends Error {
     this.name = "AccessUnavailableError";
   }
 };
-function requireSuccessfulResponse(response) {
+async function requireSuccessfulResponse(response) {
   if (response.ok) return;
   const status = response.status;
   if (status === 408 || status === 425 || status === 429 || status >= 500) throw new AccessUnavailableError(status);
+  if (status === 409) {
+    const body = await response.json().catch(() => null);
+    const code = conflictResponseCode(body);
+    if (code === "participant.media_replacement_pending") throw new AccessUnavailableError(status);
+    if (code === "participant.connection_superseded") throw new AccessGrantError(void 0, "connection_superseded");
+  }
   throw new AccessGrantError(`Access grant request failed with HTTP ${status}`);
 }
+function conflictResponseCode(body) {
+  return typeof body === "object" && body !== null && "error" in body && typeof body.error === "object" && body.error !== null && "code" in body.error ? body.error.code : void 0;
+}
 function parseParsedAccessGrant(value) {
   if (!isRecord(value)) throw new AccessGrantError();
   const subject = parseSubject(value.subject);
@@ -6751,7 +6938,7 @@ function accessGrantFromParsed(value) {
 }
 async function requireParsedAccessGrant(value) {
   if (typeof Response !== "undefined" && value instanceof Response) {
-    requireSuccessfulResponse(value);
+    await requireSuccessfulResponse(value);
     try {
       return parseParsedAccessGrant(await value.json());
     } catch (error) {
@@ -6763,7 +6950,7 @@ async function requireParsedAccessGrant(value) {
 }
 async function requireAccessGrant(value) {
   if (typeof Response !== "undefined" && value instanceof Response) {
-    requireSuccessfulResponse(value);
+    await requireSuccessfulResponse(value);
     try {
       return parseAccessGrant(await value.json());
     } catch (error) {
@@ -6877,6 +7064,7 @@ export {
   CloudflareSFURenegotiateResponseSchema,
   CloudflareSFUTracksAPIResponseSchema,
   CloudflareSFUTracksRequestSchema,
+  ConnectionReportRequestSchema,
   CreateAPIKeyRequestSchema,
   CreateEpisodeRequestSchema,
   CreateMembershipRequestSchema,
@@ -6905,6 +7093,7 @@ export {
   MembershipIdSchema,
   MembershipSchema,
   MembershipListSchema,
+  ParticipantEpisodeStatusSchema,
   ParticipantJoinCancellationSchema,
   ParticipantLifecycleSchema,
   ParticipantRemovalSchema,
@@ -7061,6 +7250,9 @@ export {
   GetEpisodeAttendancePathParamsSchema,
   GetEpisodeAttendanceResponseSchema,
   GetEpisodeAttendance429ResponseHeadersSchema,
+  GetParticipantEpisodeStatusPathParamsSchema,
+  GetParticipantEpisodeStatusResponseSchema,
+  GetParticipantEpisodeStatus429ResponseHeadersSchema,
   GetProblemReportAvailabilityPathParamsSchema,
   GetProblemReportAvailabilityResponseSchema,
   GetRecordingPathParamsSchema,
@@ -7174,6 +7366,9 @@ export {
   RenegotiateCloudflareSFURequestBodySchema,
   RenegotiateCloudflareSFUResponseSchema,
   RenegotiateCloudflareSFU429ResponseHeadersSchema,
+  ReportConnectionFailurePathParamsSchema,
+  ReportConnectionFailureRequestBodySchema,
+  ReportConnectionFailure429ResponseHeadersSchema,
   RequestRecordingExportPathParamsSchema,
   RequestRecordingExportRequestBodySchema,
   RequestRecordingExportResponseSchema,
@@ -7385,6 +7580,9 @@ export {
   ParticipantInvalidIdError,
   ParticipantInvalidIdErrorWireSchema,
   ParticipantInvalidIdErrorSchema,
+  ParticipantMediaReplacementPendingError,
+  ParticipantMediaReplacementPendingErrorWireSchema,
+  ParticipantMediaReplacementPendingErrorSchema,
   ParticipantNotActiveError,
   ParticipantNotActiveErrorWireSchema,
   ParticipantNotActiveErrorSchema,
@@ -7606,6 +7804,7 @@ export {
   GetChatAttachmentDownloadErrorSchema,
   GetEpisodeAttendanceErrorSchema,
   GetEpisodeErrorSchema,
+  GetParticipantEpisodeStatusErrorSchema,
   GetProblemReportAvailabilityErrorSchema,
   GetRecordingErrorSchema,
   GetSpaceErrorSchema,
@@ -7642,6 +7841,7 @@ export {
   RefreshSpacePublicInviteAccessErrorSchema,
   RemoveEpisodeParticipantErrorSchema,
   RenegotiateCloudflareSFUErrorSchema,
+  ReportConnectionFailureErrorSchema,
   RequestRecordingExportErrorSchema,
   RequestTranscriptErrorSchema,
   RestoreSpaceErrorSchema,

package/dist/client.d.ts

@@ -1065,6 +1065,7 @@ export declare const createChalkEffectClient: (options: ChalkEffectClientOptions
             readonly tenant_id: import("effect/Schema").brand<import("effect/Schema").String, "TenantId">;
         }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
             readonly current_media_token: import("effect/Schema").optional<import("effect/Schema").String>;
+            readonly expected_media_connection_id: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").String>>;
             readonly participant_generation: import("effect/Schema").Number;
             readonly replace_media_connection: import("effect/Schema").Boolean;
         }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
@@ -1186,6 +1187,11 @@ export declare const createChalkEffectClient: (options: ChalkEffectClientOptions
                 readonly code: import("effect/Schema").Literal<"participant.invalid_id">;
                 readonly message: import("effect/Schema").String;
             }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").ParticipantMediaReplacementPendingError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"participant.media_replacement_pending">;
+                readonly message: import("effect/Schema").String;
+            }>;
         }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").ParticipantNotFoundError, import("effect/Schema").Struct<{
             readonly error: import("effect/Schema").Struct<{
                 readonly code: import("effect/Schema").Literal<"participant.not_found">;
@@ -1761,6 +1767,73 @@ export declare const createChalkEffectClient: (options: ChalkEffectClientOptions
                 readonly message: import("effect/Schema").String;
             }>;
         }>, never, never>>, never, never>, never, never>;
+        readonly reportConnectionFailure: HttpApiClient.Client.Method<import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"reportConnectionFailure", "POST", "/v1/tenants/:tenant_id/connection-reports", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
+            readonly tenant_id: import("effect/Schema").brand<import("effect/Schema").String, "TenantId">;
+        }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+            readonly events: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly attempt: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").Number>>;
+                readonly close_code: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").Number>>;
+                readonly code: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["invalid_state", "invalid_access", "access_unavailable", "permission_denied", "device_not_found", "device_busy", "device_constraint_invalid", "media_capture_failed", "sync_start_failed", "state_digest_recovery_failed", "sync_hello_timeout", "media_start_failed", "join_cleanup_unconfirmed", "sync_recovery_exhausted", "media_recovery_exhausted", "command_rejected", "leave_unconfirmed", "episode_ended", "unsupported_environment", "internal_error", "collaboration_unavailable", "chat_cursor_reset_required", "rate_limited", "invalid_payload"]>>;
+                readonly duration_ms: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").Number>>;
+                readonly elapsed_ms: import("effect/Schema").Number;
+                readonly event: import("effect/Schema").Literals<readonly ["space_join_span", "state_changed", "connection_failed", "sync_connect_failed", "sync_dial_timeout", "access_refreshed", "access_refresh_failed", "recovery_attempt", "recovery_succeeded", "recovery_exhausted", "cleanup_completed", "cleanup_unconfirmed", "sync_socket_open", "sync_socket_close", "sync_heartbeat_gap", "media_state", "media_http_error", "media_projection_mismatch"]>;
+                readonly granted_audio: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["granted", "not_granted", "unknown"]>>;
+                readonly granted_video: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["granted", "not_granted", "unknown"]>>;
+                readonly heartbeat_gap_ms: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").Number>>;
+                readonly http_status: import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").Number>>;
+                readonly media_error_kind: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["NotAllowedError", "NotReadableError", "NotFoundError", "OverconstrainedError", "AbortError", "SecurityError", "InvalidStateError", "OperationError", "NotSupportedError", "CloudflareSFUError", "network", "timeout", "unknown"]>>;
+                readonly media_error_step: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["local_capture", "peer_connection", "access_refresh", "sfu_tracks", "sfu_close_tracks", "sfu_renegotiate", "sfu_publications"]>>;
+                readonly outcome: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["started", "succeeded", "failed", "cancelled"]>>;
+                readonly phase: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["idle", "connecting", "live", "recovering", "failed", "stopped", "new", "connected", "disconnected", "closed"]>>;
+                readonly projection_state: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["on", "off"]>>;
+                readonly publication_state: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["on", "off"]>>;
+                readonly source: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["microphone", "camera"]>>;
+                readonly state: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["idle", "joining", "live", "reconnecting", "leaving", "left", "failed"]>>;
+                readonly step: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["join", "acquire_initial_media", "access_initialize", "create_media_client", "create_sync_client", "start_media", "start_sync", "wait_for_sync_live", "confirm_entered"]>>;
+            }>>;
+            readonly trigger: import("effect/Schema").Literals<readonly ["join_failed", "connection_lost", "recovery_exhausted", "media_projection_mismatch"]>;
+            readonly version: import("effect/Schema").Literal<1>;
+        }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Void>, import("effect/Schema").toCodecJson<import("effect/Schema").decodeTo<typeof import("./effect").AccessForbiddenError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"access.forbidden">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").AccessUnauthenticatedError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"access.unauthenticated">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").RequestInvalidError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"request.invalid">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").RequestPayloadTooLargeError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"request.payload_too_large">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").RequestRateLimitedError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"request.rate_limited">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").ServiceInternalError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"service.internal_error">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").ServiceUnavailableError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"service.unavailable">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").TenantInvalidIdError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"tenant.invalid_id">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never>>, never, never>, never, never>;
         readonly revokeAPIKey: HttpApiClient.Client.Method<import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"revokeAPIKey", "DELETE", "/v1/tenants/:tenant_id/api-keys/:api_key_id", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
             readonly api_key_id: import("effect/Schema").brand<import("effect/Schema").String, "UUID">;
             readonly tenant_id: import("effect/Schema").brand<import("effect/Schema").String, "TenantId">;
@@ -2920,6 +2993,64 @@ export declare const createChalkEffectClient: (options: ChalkEffectClientOptions
                 readonly message: import("effect/Schema").String;
             }>;
         }>, never, never>>, never, never>, never, never>;
+        readonly getParticipantEpisodeStatus: HttpApiClient.Client.Method<import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"getParticipantEpisodeStatus", "GET", "/v1/tenants/:tenant_id/spaces/:space_id/episodes/:episode_id/participants/:participant_id/episode-status", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
+            readonly episode_id: import("effect/Schema").brand<import("effect/Schema").String, "EpisodeId">;
+            readonly participant_id: import("effect/Schema").brand<import("effect/Schema").String, "ParticipantId">;
+            readonly space_id: import("effect/Schema").brand<import("effect/Schema").String, "SpaceId">;
+            readonly tenant_id: import("effect/Schema").brand<import("effect/Schema").String, "TenantId">;
+        }>>, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+            readonly status: import("effect/Schema").Literals<readonly ["active", "ending", "ended"]>;
+        }>>, import("effect/Schema").toCodecJson<import("effect/Schema").decodeTo<typeof import("./effect").AccessForbiddenError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"access.forbidden">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").AccessUnauthenticatedError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"access.unauthenticated">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").EpisodeInvalidIdError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"episode.invalid_id">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").EpisodeNotFoundError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"episode.not_found">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").ParticipantInvalidIdError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"participant.invalid_id">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").RequestRateLimitedError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"request.rate_limited">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").ServiceInternalError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"service.internal_error">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").ServiceUnavailableError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"service.unavailable">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").SpaceInvalidIdError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"space.invalid_id">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never> | import("effect/Schema").decodeTo<typeof import("./effect").TenantInvalidIdError, import("effect/Schema").Struct<{
+            readonly error: import("effect/Schema").Struct<{
+                readonly code: import("effect/Schema").Literal<"tenant.invalid_id">;
+                readonly message: import("effect/Schema").String;
+            }>;
+        }>, never, never>>, never, never>, never, never>;
         readonly issueEpisodeParticipantSyncToken: HttpApiClient.Client.Method<import("effect/unstable/httpapi/HttpApiEndpoint").HttpApiEndpoint<"issueEpisodeParticipantSyncToken", "POST", "/v1/tenants/:tenant_id/spaces/:space_id/episodes/:episode_id/participants/:participant_id/sync-token", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
             readonly episode_id: import("effect/Schema").brand<import("effect/Schema").String, "EpisodeId">;
             readonly participant_id: import("effect/Schema").brand<import("effect/Schema").String, "ParticipantId">;

package/dist/connection/dependencies.d.ts

@@ -1,3 +1,5 @@
+import type { ParticipantEpisodeStatus } from "../generated/schemas";
+import type { ConnectionReporter, ConnectionReportTransportEvent } from "./report";
 import type { ClientMediaPlane, CloudflareSFUBootstrap, ConnectionMediaSnapshot } from "../media";
 import type { ChalkChatFileTransport } from "../chat-files";
 import type { V1AdmissionTarget, V1AssignableRole, V1CommandResult, V1EpisodeSnapshot, V1SelfMediaTargetResult } from "../sync";
@@ -12,6 +14,7 @@ export type ConnectionAccessRequest = {
     readonly signal?: AbortSignal;
     readonly currentMediaToken?: ParticipantMediaCredential;
     readonly expectedParticipantGeneration?: number;
+    readonly expectedMediaConnectionId?: string;
 };
 export type ConnectionAccessProvider = (request?: ConnectionAccessRequest) => ParsedAccessGrant | Promise<ParsedAccessGrant>;
 export type ConnectionClock = {
@@ -79,13 +82,17 @@ export type ConnectionMediaFactoryInput = {
     readonly access: ParsedAccessGrant;
     readonly credential: () => Promise<string>;
     readonly replaceMediaConnection?: () => Promise<ParticipantMediaAccess>;
-    readonly onFailure: (error: unknown) => void;
+    readonly traceparent?: string;
+    readonly onTransportDiagnostic?: (event: ConnectionReportTransportEvent) => void;
+    readonly onFailure: (error: unknown, mediaConnectionId?: string) => void;
     readonly onScreenEnded: () => void;
 };
 export type ConnectionSyncFactoryInput = {
     readonly access: ParsedAccessGrant;
     readonly token: () => Promise<string>;
     readonly media: ConnectionMediaClient;
+    readonly traceparent?: string;
+    readonly onTransportDiagnostic?: (event: ConnectionReportTransportEvent) => void;
 };
 export type ConnectionWhiteboardFactoryInput = {
     readonly onWatchdogReplacement?: ChalkWhiteboardV1ClientOptions["onWatchdogReplacement"];
@@ -97,6 +104,8 @@ export type ConnectionChatFileFactoryInput = {
 };
 export type ConnectionDependencies = {
     readonly clock: ConnectionClock;
+    readonly createConnectionReporter?: (access: () => ParsedAccessGrant | null) => ConnectionReporter | undefined;
+    readonly getEpisodeStatus?: (access: ParsedAccessGrant, signal: AbortSignal) => Promise<ParticipantEpisodeStatus["status"]>;
     readonly cancelPendingAdmission?: (access: ParsedAccessGrant, signal: AbortSignal) => Promise<boolean>;
     readonly mediaDevices: ConnectionMediaDevices;
     readonly createMediaClient: (input: ConnectionMediaFactoryInput) => ConnectionMediaClient;

package/dist/connection/diagnostics.d.ts

@@ -18,8 +18,10 @@ export type ConnectionJoinTraceEnd = {
     readonly epoch: number;
     readonly outcome: Exclude<ConnectionJoinTraceOutcome, "started">;
     readonly code?: ConnectionErrorCode;
+    readonly media?: import("../media/failure-diagnostics").MediaFailureDiagnostic & import("../media/failure-diagnostics").GrantedMedia;
 };
 export type ConnectionDiagnostic = {
+    readonly media?: import("../media/failure-diagnostics").MediaFailureDiagnostic & import("../media/failure-diagnostics").GrantedMedia;
     readonly timestamp: number;
     readonly event: ConnectionDiagnosticEventName;
     readonly state: ConnectionState;
@@ -54,6 +56,8 @@ export declare class ConnectionDiagnostics {
         readonly code: "sync_recovery_exhausted" | "media_recovery_exhausted";
         readonly attempts: number;
         readonly transport: import("../sync/connect-diagnostics").SyncRecoveryDiagnostic | null;
+        readonly media?: ConnectionDiagnostic["media"];
+        readonly grantedMedia: import("../media/failure-diagnostics").GrantedMedia;
     }): void;
     snapshot(): readonly ConnectionDiagnostic[];
     startSpan(input: {

package/dist/connection/episode-status.d.ts

@@ -0,0 +1,7 @@
+export declare class EpisodeStatusError extends Error {
+    readonly status: number;
+    readonly retryAfterMs: number;
+    constructor(status: number, retryAfterMs?: number);
+}
+export declare function episodeStatusRetryDelay(attempt: number, error: unknown): number;
+export declare function retryAfterMilliseconds(value: string | null, now: number): number;

package/dist/connection/index.d.ts

@@ -34,7 +34,9 @@ export type ConnectionOptions = {
     readonly initialCameraEnabled?: boolean;
     readonly accessRefreshWindowMs?: number;
     readonly recovery?: {
+        /** Sync attempt cap. Recoverable media failures retry until budgetMs expires. */
         readonly maxAttempts?: number;
+        /** Foreground recovery budget for either transport; defaults to 60 seconds. */
         readonly budgetMs?: number;
         readonly backoffMs?: readonly number[];
     };