@q9labsai/chalk-client 5.2.4 → 5.2.6

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 5.2.6
+
+- Reuse microphone and camera senders after short browser capture interruptions, keeping capture disabled until a fresh user enable. Republish after long interruptions before trusting an expired provider track, and detach again if capture is interrupted during reattachment. Report interrupted owned capture as unavailable to other participants through the existing Sync pause command. Include a bounded replacement cause on the first SFU track request after a media connection is replaced.
+
 ## 5.2.0
 
 ### board-draw-policy

package/dist/access/grant.d.ts

@@ -39,8 +39,9 @@ export type AccessGrant = {
 };
 export type AccessGrantProvider = () => ParsedAccessGrant | Promise<ParsedAccessGrant>;
 export declare class AccessGrantError extends TypeError {
+    readonly reason?: "connection_superseded" | undefined;
     readonly code: "access.invalid";
-    constructor(message?: string);
+    constructor(message?: string, reason?: "connection_superseded" | undefined);
 }
 export declare function parseParsedAccessGrant(value: unknown): ParsedAccessGrant;
 export declare function parseAccessGrant(value: unknown): AccessGrant;

package/dist/access/manager.d.ts

@@ -23,6 +23,7 @@ export type ConnectionAccessEffectService = {
     readonly subscribeAutomaticMediaReplacement: (listener: AutomaticMediaReplacementListener) => Effect.Effect<() => void>;
     readonly requiresRefresh: Effect.Effect<boolean>;
     readonly millisecondsUntilRefresh: Effect.Effect<number | null>;
+    readonly holdMediaBinding: (binding: string) => Effect.Effect<Effect.Effect<void>>;
     readonly clear: Effect.Effect<void>;
 };
 declare const ConnectionAccessService_base: Context.ServiceClass<ConnectionAccessService, "@chalk/client/ConnectionAccess", ConnectionAccessEffectService>;

package/dist/{chunk-AZONR3Q3.js → chunk-CJVLTSIO.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
 });
@@ -1097,7 +1109,25 @@ var AddCloudflareSFUTracksPathParamsSchema = Schema.Struct({
   tenant_id: TenantIdSchema
 });
 var AddCloudflareSFUTracksQueryParamsSchema = Schema.Struct({
-  allow_partial_remote_tracks: Schema.optional(Schema.Boolean)
+  allow_partial_remote_tracks: Schema.optional(Schema.Boolean),
+  replacement_cause: Schema.optional(
+    Schema.Literals([
+      "user_pause",
+      "moderation_pause",
+      "sync_recovery_loss",
+      "discovery_absent",
+      "capture_cleanup",
+      "consent_revoked",
+      "publish_failure",
+      "enable_failure",
+      "projection_mismatch",
+      "forced_pause",
+      "local_signaling_failure",
+      "remote_signaling_failure",
+      "dormant_connection",
+      "access_refresh"
+    ])
+  )
 });
 var AddCloudflareSFUTracksRequestBodySchema = CloudflareSFUTracksRequestSchema;
 var AddCloudflareSFUTracksResponseSchema = CloudflareSFUTracksAPIResponseSchema;
@@ -1383,6 +1413,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 +2931,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 +4551,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 +4694,7 @@ var IssueAccessGrantErrorSchema = Schema.Union([
   ParticipantConnectionSupersededErrorSchema,
   ParticipantGenerationMismatchErrorSchema,
   ParticipantInvalidIdErrorSchema,
+  ParticipantMediaReplacementPendingErrorSchema,
   ParticipantNotFoundErrorSchema,
   RequestInvalidErrorSchema,
   RequestPayloadTooLargeErrorSchema,
@@ -5148,6 +5222,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 +5550,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 +5987,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 +6890,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 +6905,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 +6956,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 +6968,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 +7111,7 @@ export {
   MembershipIdSchema,
   MembershipSchema,
   MembershipListSchema,
+  ParticipantEpisodeStatusSchema,
   ParticipantJoinCancellationSchema,
   ParticipantLifecycleSchema,
   ParticipantRemovalSchema,
@@ -7163,6 +7268,9 @@ export {
   GetEpisodeAttendancePathParamsSchema,
   GetEpisodeAttendanceResponseSchema,
   GetEpisodeAttendance429ResponseHeadersSchema,
+  GetParticipantEpisodeStatusPathParamsSchema,
+  GetParticipantEpisodeStatusResponseSchema,
+  GetParticipantEpisodeStatus429ResponseHeadersSchema,
   GetProblemReportAvailabilityPathParamsSchema,
   GetProblemReportAvailabilityResponseSchema,
   GetRecordingPathParamsSchema,
@@ -7490,6 +7598,9 @@ export {
   ParticipantInvalidIdError,
   ParticipantInvalidIdErrorWireSchema,
   ParticipantInvalidIdErrorSchema,
+  ParticipantMediaReplacementPendingError,
+  ParticipantMediaReplacementPendingErrorWireSchema,
+  ParticipantMediaReplacementPendingErrorSchema,
   ParticipantNotActiveError,
   ParticipantNotActiveErrorWireSchema,
   ParticipantNotActiveErrorSchema,
@@ -7711,6 +7822,7 @@ export {
   GetChatAttachmentDownloadErrorSchema,
   GetEpisodeAttendanceErrorSchema,
   GetEpisodeErrorSchema,
+  GetParticipantEpisodeStatusErrorSchema,
   GetProblemReportAvailabilityErrorSchema,
   GetRecordingErrorSchema,
   GetSpaceErrorSchema,