@q9labsai/chalk-client 5.2.4 → 5.2.5

package/dist/{chunk-SYUGRHZ5.js → chunk-LKNT6XFD.js}

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

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

@@ -295,17 +295,25 @@ var ConnectionReportRequestSchema = Schema.Struct({
         "sync_socket_close",
         "sync_heartbeat_gap",
         "media_state",
-        "media_http_error"
+        "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"]),
+  trigger: Schema.Literals(["join_failed", "connection_lost", "recovery_exhausted", "media_projection_mismatch"]),
   version: Schema.Literal(1)
 });
 var CreateAPIKeyRequestSchema = Schema.Struct({
@@ -475,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
 });
@@ -493,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
 });
@@ -1383,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
 });
@@ -2889,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"),
@@ -4490,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]);
@@ -4621,6 +4676,7 @@ var IssueAccessGrantErrorSchema = Schema.Union([
   ParticipantConnectionSupersededErrorSchema,
   ParticipantGenerationMismatchErrorSchema,
   ParticipantInvalidIdErrorSchema,
+  ParticipantMediaReplacementPendingErrorSchema,
   ParticipantNotFoundErrorSchema,
   RequestInvalidErrorSchema,
   RequestPayloadTooLargeErrorSchema,
@@ -5148,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 } },
@@ -5475,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)),
@@ -5911,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,
@@ -6797,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";
@@ -6810,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);
@@ -6852,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) {
@@ -6864,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) {
@@ -7007,6 +7093,7 @@ export {
   MembershipIdSchema,
   MembershipSchema,
   MembershipListSchema,
+  ParticipantEpisodeStatusSchema,
   ParticipantJoinCancellationSchema,
   ParticipantLifecycleSchema,
   ParticipantRemovalSchema,
@@ -7163,6 +7250,9 @@ export {
   GetEpisodeAttendancePathParamsSchema,
   GetEpisodeAttendanceResponseSchema,
   GetEpisodeAttendance429ResponseHeadersSchema,
+  GetParticipantEpisodeStatusPathParamsSchema,
+  GetParticipantEpisodeStatusResponseSchema,
+  GetParticipantEpisodeStatus429ResponseHeadersSchema,
   GetProblemReportAvailabilityPathParamsSchema,
   GetProblemReportAvailabilityResponseSchema,
   GetRecordingPathParamsSchema,
@@ -7490,6 +7580,9 @@ export {
   ParticipantInvalidIdError,
   ParticipantInvalidIdErrorWireSchema,
   ParticipantInvalidIdErrorSchema,
+  ParticipantMediaReplacementPendingError,
+  ParticipantMediaReplacementPendingErrorWireSchema,
+  ParticipantMediaReplacementPendingErrorSchema,
   ParticipantNotActiveError,
   ParticipantNotActiveErrorWireSchema,
   ParticipantNotActiveErrorSchema,
@@ -7711,6 +7804,7 @@ export {
   GetChatAttachmentDownloadErrorSchema,
   GetEpisodeAttendanceErrorSchema,
   GetEpisodeErrorSchema,
+  GetParticipantEpisodeStatusErrorSchema,
   GetProblemReportAvailabilityErrorSchema,
   GetRecordingErrorSchema,
   GetSpaceErrorSchema,

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">;
@@ -1770,15 +1776,22 @@ export declare const createChalkEffectClient: (options: ChalkEffectClientOptions
                 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"]>;
+                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"]>;
+            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<{
@@ -2980,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,4 @@
+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";
@@ -13,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 = {
@@ -82,7 +84,7 @@ export type ConnectionMediaFactoryInput = {
     readonly replaceMediaConnection?: () => Promise<ParticipantMediaAccess>;
     readonly traceparent?: string;
     readonly onTransportDiagnostic?: (event: ConnectionReportTransportEvent) => void;
-    readonly onFailure: (error: unknown) => void;
+    readonly onFailure: (error: unknown, mediaConnectionId?: string) => void;
     readonly onScreenEnded: () => void;
 };
 export type ConnectionSyncFactoryInput = {
@@ -103,6 +105,7 @@ 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[];
     };

package/dist/connection/lifecycle.d.ts

@@ -39,6 +39,7 @@ export type ConnectionLifecycleCapability = {
     }>) => Effect.Effect<void, ConnectionLifecycleFailure>;
     readonly getSyncToken: () => Effect.Effect<string, ConnectionLifecycleFailure>;
     readonly confirmEpisodeEnded: Effect.Effect<void>;
+    readonly runEpisodeEnd: <A, E>(operation: Effect.Effect<A, E>) => Effect.Effect<A, E>;
     readonly join: () => Effect.Effect<void, ConnectionLifecycleFailure>;
     readonly leave: () => Effect.Effect<void, ConnectionLifecycleFailure>;
     readonly runCommand: <A, E>(operation: (ports: ConnectionPorts) => Effect.Effect<A, E>) => Effect.Effect<A, ConnectionLifecycleFailure | E>;
@@ -47,6 +48,7 @@ export type ConnectionLifecycleCapability = {
     readonly scheduleUnsafe: (callback: () => void, milliseconds: number) => unknown;
     readonly cancelScheduleUnsafe: (handle: unknown) => void;
     readonly createId: () => string;
+    readonly recordTransportDiagnostic: (event: import("./report").ConnectionReportTransportEvent) => void;
 };
 declare const ConnectionLifecycleService_base: Context.ServiceClass<ConnectionLifecycleService, "@chalk/client/ConnectionLifecycle", ConnectionLifecycleCapability>;
 export declare class ConnectionLifecycleService extends ConnectionLifecycleService_base {

package/dist/effect.js

@@ -17,8 +17,8 @@ import {
   makeSpaceClientCoreLayer,
   makeSpaceClientCoreLayerFromServices,
   makeSpaceStoreLayer
-} from "./chunk-LDPC2JZB.js";
-import "./chunk-3ASKGMD3.js";
+} from "./chunk-BUNSEDXL.js";
+import "./chunk-FD25AMLG.js";
 import {
   APIKeyListSchema,
   APIKeyWithSecretSchema,
@@ -261,6 +261,10 @@ import {
   GetEpisodeErrorSchema,
   GetEpisodePathParamsSchema,
   GetEpisodeResponseSchema,
+  GetParticipantEpisodeStatus429ResponseHeadersSchema,
+  GetParticipantEpisodeStatusErrorSchema,
+  GetParticipantEpisodeStatusPathParamsSchema,
+  GetParticipantEpisodeStatusResponseSchema,
   GetProblemReportAvailabilityErrorSchema,
   GetProblemReportAvailabilityPathParamsSchema,
   GetProblemReportAvailabilityResponseSchema,
@@ -451,6 +455,7 @@ import {
   ParticipantConnectionSupersededError,
   ParticipantConnectionSupersededErrorSchema,
   ParticipantConnectionSupersededErrorWireSchema,
+  ParticipantEpisodeStatusSchema,
   ParticipantGenerationMismatchError,
   ParticipantGenerationMismatchErrorSchema,
   ParticipantGenerationMismatchErrorWireSchema,
@@ -460,6 +465,9 @@ import {
   ParticipantInvalidIdErrorWireSchema,
   ParticipantJoinCancellationSchema,
   ParticipantLifecycleSchema,
+  ParticipantMediaReplacementPendingError,
+  ParticipantMediaReplacementPendingErrorSchema,
+  ParticipantMediaReplacementPendingErrorWireSchema,
   ParticipantNotActiveError,
   ParticipantNotActiveErrorSchema,
   ParticipantNotActiveErrorWireSchema,
@@ -833,7 +841,7 @@ import {
   WhiteboardStorageUnavailableErrorSchema,
   WhiteboardStorageUnavailableErrorWireSchema,
   createChalkEffectClient
-} from "./chunk-AZONR3Q3.js";
+} from "./chunk-UMAE5GCV.js";
 import "./chunk-5YPQNMJE.js";
 
 // src/space-client/effect.ts
@@ -1117,6 +1125,10 @@ export {
   GetEpisodeErrorSchema,
   GetEpisodePathParamsSchema,
   GetEpisodeResponseSchema,
+  GetParticipantEpisodeStatus429ResponseHeadersSchema,
+  GetParticipantEpisodeStatusErrorSchema,
+  GetParticipantEpisodeStatusPathParamsSchema,
+  GetParticipantEpisodeStatusResponseSchema,
   GetProblemReportAvailabilityErrorSchema,
   GetProblemReportAvailabilityPathParamsSchema,
   GetProblemReportAvailabilityResponseSchema,
@@ -1307,6 +1319,7 @@ export {
   ParticipantConnectionSupersededError,
   ParticipantConnectionSupersededErrorSchema,
   ParticipantConnectionSupersededErrorWireSchema,
+  ParticipantEpisodeStatusSchema,
   ParticipantGenerationMismatchError,
   ParticipantGenerationMismatchErrorSchema,
   ParticipantGenerationMismatchErrorWireSchema,
@@ -1316,6 +1329,9 @@ export {
   ParticipantInvalidIdErrorWireSchema,
   ParticipantJoinCancellationSchema,
   ParticipantLifecycleSchema,
+  ParticipantMediaReplacementPendingError,
+  ParticipantMediaReplacementPendingErrorSchema,
+  ParticipantMediaReplacementPendingErrorWireSchema,
   ParticipantNotActiveError,
   ParticipantNotActiveErrorSchema,
   ParticipantNotActiveErrorWireSchema,