@q9labsai/chalk-client 5.3.0 → 5.4.0

package/dist/access/grant.d.ts

@@ -1,3 +1,4 @@
+import type { CloudflareSFUIceServer } from "../media/types";
 declare const syncCredentialBrand: unique symbol;
 declare const mediaCredentialBrand: unique symbol;
 declare const accessGrantBrand: unique symbol;
@@ -25,6 +26,7 @@ export type ParticipantMediaAccess = {
     readonly clientPayload: {
         readonly connectionId: string;
         readonly stunServer: string;
+        readonly iceServers?: readonly CloudflareSFUIceServer[];
     };
 };
 export type ParsedAccessGrant = {

package/dist/{chunk-GOSWSXTH.js → chunk-MHJ4UPM3.js}

@@ -1,3 +1,7 @@
+import {
+  withRequestContext
+} from "./chunk-N4IPKRS6.js";
+
 // src/generated/schemas.ts
 import { Schema, SchemaGetter } from "effect";
 var ChalkCodePointLimits = {
@@ -92,6 +96,30 @@ var AdmitEpisodeParticipantRequestSchema = Schema.Struct({
   role: Schema.String.check(Schema.isMinLength(1))
 });
 var AuditLogIdSchema = Schema.String.check(Schema.isMinLength(36), Schema.isMaxLength(36), Schema.isPattern(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)).pipe(Schema.brand("AuditLogId"));
+var CallStatsRequestSchema = Schema.Struct({
+  samples: Schema.Array(
+    Schema.Struct({
+      connection_type: Schema.Literals(["udp", "tcp", "turn", "unknown"]),
+      elapsed_ms: Schema.Number,
+      freeze_count: Schema.optional(Schema.NullOr(Schema.Number)),
+      freeze_ms: Schema.optional(Schema.NullOr(Schema.Number)),
+      local_candidate_type: Schema.optional(Schema.Literals(["host", "srflx", "prflx", "relay"])),
+      recv_bitrate_kbps: Schema.optional(Schema.NullOr(Schema.Number)),
+      recv_height: Schema.optional(Schema.NullOr(Schema.Number)),
+      recv_jitter_ms: Schema.optional(Schema.NullOr(Schema.Number)),
+      recv_loss_pct: Schema.optional(Schema.NullOr(Schema.Number)),
+      relay_protocol: Schema.optional(Schema.Literals(["udp", "tcp", "tls"])),
+      remote_candidate_type: Schema.optional(Schema.Literals(["host", "srflx", "prflx", "relay"])),
+      rtt_ms: Schema.optional(Schema.NullOr(Schema.Number)),
+      send_bitrate_kbps: Schema.optional(Schema.NullOr(Schema.Number)),
+      send_jitter_ms: Schema.optional(Schema.NullOr(Schema.Number)),
+      send_layer: Schema.optional(Schema.Literals(["h", "m", "l"])),
+      send_loss_pct: Schema.optional(Schema.NullOr(Schema.Number)),
+      window_ms: Schema.Number
+    })
+  ).check(Schema.isMinLength(1), Schema.isMaxLength(30)),
+  version: Schema.Literal(1)
+});
 var CancelRecordingPreparationRequestSchema = Schema.Struct({
   expected_revision: Schema.Number
 });
@@ -136,6 +164,7 @@ var CloudflareSFUCloseTracksAPIResponseSchema = Schema.Struct({
 var CloudflareSFUCloseTracksRequestSchema = Schema.Struct({
   connection_id: Schema.String.check(Schema.isMinLength(1)),
   force: Schema.Boolean,
+  receive_only: Schema.optional(Schema.Boolean),
   session_description: Schema.optional(
     Schema.NullOr(
       Schema.Struct({
@@ -173,7 +202,7 @@ var CloudflareSFURenegotiateRequestSchema = Schema.Struct({
 var CloudflareSFURenegotiateResponseSchema = Schema.Struct({
   accepted: Schema.Boolean
 });
-var CloudflareSFUTracksAPIResponseSchema = Schema.Struct({
+var CloudflareSFUUpdateTracksAPIResponseSchema = Schema.Struct({
   requiresImmediateRenegotiation: Schema.optional(Schema.Boolean),
   sessionDescription: Schema.optional(
     Schema.NullOr(
@@ -214,6 +243,7 @@ var CloudflareSFUTracksAPIResponseSchema = Schema.Struct({
     )
   )
 });
+var CloudflareSFUTracksAPIResponseSchema = CloudflareSFUUpdateTracksAPIResponseSchema;
 var CloudflareSFUTracksRequestSchema = Schema.Struct({
   connection_id: Schema.String.check(Schema.isMinLength(1)),
   session_description: Schema.optional(
@@ -244,6 +274,28 @@ var CloudflareSFUTracksRequestSchema = Schema.Struct({
     })
   )
 });
+var CloudflareSFUUpdateTracksRequestSchema = Schema.Struct({
+  connection_id: Schema.String.check(Schema.isMinLength(1)),
+  tracks: Schema.Array(
+    Schema.Struct({
+      location: Schema.String.check(Schema.isMinLength(1)),
+      mid: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
+      publication_id: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
+      sessionId: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
+      simulcast: Schema.optional(
+        Schema.NullOr(
+          Schema.Struct({
+            preferredRid: Schema.String.check(Schema.isMinLength(1)),
+            priorityOrdering: Schema.String.check(Schema.isMinLength(1)),
+            ridNotAvailable: Schema.String.check(Schema.isMinLength(1))
+          })
+        )
+      ),
+      source: Schema.optional(Schema.String.check(Schema.isMinLength(1))),
+      trackName: Schema.String.check(Schema.isMinLength(1))
+    })
+  )
+});
 var ConnectionReportRequestSchema = Schema.Struct({
   events: Schema.Array(
     Schema.Struct({
@@ -1925,6 +1977,19 @@ var TestWebhookEndpoint429ResponseHeadersSchema = Schema.Struct({
   "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
   "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
 });
+var UpdateCloudflareSFUTracksPathParamsSchema = Schema.Struct({
+  episode_id: EpisodeIdSchema,
+  participant_id: ParticipantIdSchema,
+  space_id: SpaceIdSchema,
+  tenant_id: TenantIdSchema
+});
+var UpdateCloudflareSFUTracksRequestBodySchema = CloudflareSFUUpdateTracksRequestSchema;
+var UpdateCloudflareSFUTracksResponseSchema = CloudflareSFUUpdateTracksAPIResponseSchema;
+var UpdateCloudflareSFUTracks429ResponseHeadersSchema = Schema.Struct({
+  "Retry-After": RetryAfterHeaderSchema,
+  "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
+  "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
+});
 var UpdateMembershipPathParamsSchema = Schema.Struct({
   membership_id: MembershipIdSchema,
   tenant_id: TenantIdSchema
@@ -1983,6 +2048,15 @@ var UpdateWebhookEndpoint429ResponseHeadersSchema = Schema.Struct({
   "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
   "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
 });
+var UploadCallStatsPathParamsSchema = Schema.Struct({
+  tenant_id: TenantIdSchema
+});
+var UploadCallStatsRequestBodySchema = CallStatsRequestSchema;
+var UploadCallStats429ResponseHeadersSchema = Schema.Struct({
+  "Retry-After": RetryAfterHeaderSchema,
+  "X-RateLimit-Limit": RateLimitLimitHeaderSchema,
+  "X-RateLimit-Remaining": RateLimitRemainingHeaderSchema
+});
 var AccessForbiddenError = class extends Schema.TaggedErrorClass()("AccessForbiddenError", {
   error: Schema.Struct({
     code: Schema.Literal("access.forbidden"),
@@ -5110,6 +5184,22 @@ var TestWebhookEndpointErrorSchema = Schema.Union([
   WebhookInvalidUrlErrorSchema,
   WebhookUnsafeUrlErrorSchema
 ]);
+var UpdateCloudflareSFUTracksErrorSchema = Schema.Union([
+  AccessForbiddenErrorSchema,
+  AccessUnauthenticatedErrorSchema,
+  EpisodeInvalidIdErrorSchema,
+  EpisodeNotFoundErrorSchema,
+  MediaConnectionNotFoundErrorSchema,
+  MediaUnavailableErrorSchema,
+  ParticipantInvalidIdErrorSchema,
+  RequestInvalidErrorSchema,
+  RequestPayloadTooLargeErrorSchema,
+  RequestRateLimitedErrorSchema,
+  ServiceInternalErrorSchema,
+  ServiceUnavailableErrorSchema,
+  SpaceInvalidIdErrorSchema,
+  TenantInvalidIdErrorSchema
+]);
 var UpdateMembershipErrorSchema = Schema.Union([
   AccessForbiddenErrorSchema,
   AccessUnauthenticatedErrorSchema,
@@ -5198,6 +5288,7 @@ var UpdateWebhookEndpointErrorSchema = Schema.Union([
   WebhookInvalidUrlErrorSchema,
   WebhookUnsafeUrlErrorSchema
 ]);
+var UploadCallStatsErrorSchema = Schema.Union([AccessForbiddenErrorSchema, AccessUnauthenticatedErrorSchema, RequestInvalidErrorSchema, RequestPayloadTooLargeErrorSchema, RequestRateLimitedErrorSchema, ServiceInternalErrorSchema, ServiceUnavailableErrorSchema, TenantInvalidIdErrorSchema]);
 var ChalkOperationPolicies = {
   addCloudflareSFUTracks: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   admitEpisodeParticipant: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
@@ -5259,11 +5350,13 @@ var ChalkOperationPolicies = {
   sendProblemReport: { maxBodyBytes: 37024, rateLimit: { limit: 3, policy: "problem_reports.participant", windowSeconds: 3600 } },
   setEpisodeDeadline: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   testWebhookEndpoint: { rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
+  updateCloudflareSFUTracks: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   updateMembership: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   updateSpace: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   updateSpacePublicInvite: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
   updateTenant: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
-  updateWebhookEndpoint: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } }
+  updateWebhookEndpoint: { maxBodyBytes: 1048576, rateLimit: { limit: 60, policy: "v1.authenticated.write", windowSeconds: 60 } },
+  uploadCallStats: { maxBodyBytes: 32768, rateLimit: { limit: 30, policy: "call_stats.participant", windowSeconds: 600 } }
 };
 
 // src/generated/http-api.ts
@@ -5832,6 +5925,28 @@ var defaultGroup = HttpApiGroup.make("default").add(
       ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
     ]
   })
+).add(
+  HttpApiEndpoint.put("updateCloudflareSFUTracks", "/v1/tenants/:tenant_id/spaces/:space_id/episodes/:episode_id/participants/:participant_id/media/sfu/tracks/update", {
+    params: UpdateCloudflareSFUTracksPathParamsSchema,
+    payload: UpdateCloudflareSFUTracksRequestBodySchema,
+    success: UpdateCloudflareSFUTracksResponseSchema.pipe(HttpApiSchema.status(200)),
+    error: [
+      EpisodeInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      ParticipantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      RequestInvalidErrorSchema.pipe(HttpApiSchema.status(400)),
+      SpaceInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      TenantInvalidIdErrorSchema.pipe(HttpApiSchema.status(400)),
+      AccessUnauthenticatedErrorSchema.pipe(HttpApiSchema.status(401)),
+      AccessForbiddenErrorSchema.pipe(HttpApiSchema.status(403)),
+      EpisodeNotFoundErrorSchema.pipe(HttpApiSchema.status(404)),
+      MediaConnectionNotFoundErrorSchema.pipe(HttpApiSchema.status(404)),
+      RequestPayloadTooLargeErrorSchema.pipe(HttpApiSchema.status(413)),
+      RequestRateLimitedErrorSchema.pipe(HttpApiSchema.status(429)),
+      ServiceInternalErrorSchema.pipe(HttpApiSchema.status(500)),
+      MediaUnavailableErrorSchema.pipe(HttpApiSchema.status(503)),
+      ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
+    ]
+  })
 ).add(
   HttpApiEndpoint.patch("updateWebhookEndpoint", "/v1/tenants/:tenant_id/webhook-endpoints/:endpoint_id", {
     params: UpdateWebhookEndpointPathParamsSchema,
@@ -5867,6 +5982,22 @@ var defaultGroup = HttpApiGroup.make("default").add(
       ServiceUnavailableErrorSchema.pipe(HttpApiSchema.status(503))
     ]
   })
+).add(
+  HttpApiEndpoint.post("uploadCallStats", "/v1/tenants/:tenant_id/call-stats", {
+    params: UploadCallStatsPathParamsSchema,
+    payload: UploadCallStatsRequestBodySchema,
+    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))
+    ]
+  })
 );
 var episodesGroup = HttpApiGroup.make("episodes").add(
   HttpApiEndpoint.post("admitEpisodeParticipant", "/v1/tenants/:tenant_id/spaces/:space_id/episodes/:episode_id/participants", {
@@ -6864,7 +6995,7 @@ var createChalkEffectClient = (options) => {
     })
   }).pipe(Effect.provide(FetchHttpClient.layer));
   const configuredClient = options.credentials === void 0 ? client : client.pipe(Effect.provideService(FetchHttpClient.RequestInit, { credentials: options.credentials }));
-  return options.fetch ? configuredClient.pipe(Effect.provideService(FetchHttpClient.Fetch, options.fetch)) : configuredClient;
+  return configuredClient.pipe(Effect.provideService(FetchHttpClient.Fetch, withRequestContext(options.fetch)));
 };
 function requestHeaders(options) {
   return {
@@ -7015,17 +7146,31 @@ function parseMediaAccess(value) {
         provider: value.provider,
         clientPayload: {
           connectionId: requireNonEmptyString(payload.connectionId),
-          stunServer: requireNonEmptyString(payload.stunServer)
+          stunServer: requireNonEmptyString(payload.stunServer),
+          ...payload.iceServers === void 0 || payload.iceServers === null ? {} : { iceServers: parseIceServers(payload.iceServers) }
         }
       };
     default:
       throw new AccessGrantError();
   }
 }
+function parseIceServers(value) {
+  if (!Array.isArray(value)) throw new AccessGrantError();
+  return value.map((entry) => {
+    if (!isRecord(entry) || !Array.isArray(entry.urls) || entry.urls.length === 0) throw new AccessGrantError();
+    const urls = entry.urls.map(requireNonEmptyString);
+    if (entry.username === void 0 && entry.credential === void 0) return { urls };
+    return { urls, username: requireNonEmptyString(entry.username), credential: requireNonEmptyString(entry.credential) };
+  });
+}
 function mediaClientPayload(value) {
   switch (value.provider) {
     case "cloudflare_sfu":
-      return { connectionId: value.clientPayload.connectionId, stunServer: value.clientPayload.stunServer };
+      return {
+        connectionId: value.clientPayload.connectionId,
+        stunServer: value.clientPayload.stunServer,
+        ...value.clientPayload.iceServers ? { iceServers: value.clientPayload.iceServers } : {}
+      };
   }
 }
 function requireCredential(value, audience) {
@@ -7073,6 +7218,7 @@ export {
   AccessGrantSchema,
   AdmitEpisodeParticipantRequestSchema,
   AuditLogIdSchema,
+  CallStatsRequestSchema,
   CancelRecordingPreparationRequestSchema,
   ChatAttachmentSchema,
   ChatAttachmentDownloadSchema,
@@ -7082,8 +7228,10 @@ export {
   CloudflareSFUPublicationsResponseSchema,
   CloudflareSFURenegotiateRequestSchema,
   CloudflareSFURenegotiateResponseSchema,
+  CloudflareSFUUpdateTracksAPIResponseSchema,
   CloudflareSFUTracksAPIResponseSchema,
   CloudflareSFUTracksRequestSchema,
+  CloudflareSFUUpdateTracksRequestSchema,
   ConnectionReportRequestSchema,
   CreateAPIKeyRequestSchema,
   CreateEpisodeRequestSchema,
@@ -7429,6 +7577,10 @@ export {
   TestWebhookEndpointRequestHeadersSchema,
   TestWebhookEndpointResponseSchema,
   TestWebhookEndpoint429ResponseHeadersSchema,
+  UpdateCloudflareSFUTracksPathParamsSchema,
+  UpdateCloudflareSFUTracksRequestBodySchema,
+  UpdateCloudflareSFUTracksResponseSchema,
+  UpdateCloudflareSFUTracks429ResponseHeadersSchema,
   UpdateMembershipPathParamsSchema,
   UpdateMembershipRequestBodySchema,
   UpdateMembershipResponseSchema,
@@ -7450,6 +7602,9 @@ export {
   UpdateWebhookEndpointRequestBodySchema,
   UpdateWebhookEndpointResponseSchema,
   UpdateWebhookEndpoint429ResponseHeadersSchema,
+  UploadCallStatsPathParamsSchema,
+  UploadCallStatsRequestBodySchema,
+  UploadCallStats429ResponseHeadersSchema,
   AccessForbiddenError,
   AccessForbiddenErrorWireSchema,
   AccessForbiddenErrorSchema,
@@ -7872,11 +8027,13 @@ export {
   SendProblemReportErrorSchema,
   SetEpisodeDeadlineErrorSchema,
   TestWebhookEndpointErrorSchema,
+  UpdateCloudflareSFUTracksErrorSchema,
   UpdateMembershipErrorSchema,
   UpdateSpaceErrorSchema,
   UpdateSpacePublicInviteErrorSchema,
   UpdateTenantErrorSchema,
   UpdateWebhookEndpointErrorSchema,
+  UploadCallStatsErrorSchema,
   ChalkOperationPolicies,
   ChalkApi,
   createChalkEffectClient,

package/dist/chunk-N4IPKRS6.js

@@ -0,0 +1,76 @@
+// src/session/index.ts
+var SESSION_ID_KEY = "session.id";
+var STORAGE_KEY = "chalk.session.id";
+var TAB_KEY = "chalk.session.tab";
+var TAB_NAME_PREFIX = "chalk.tab:";
+var 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}$/;
+var source = browserSession;
+var browserId;
+function setSessionSource(next) {
+  source = next;
+}
+function currentSessionId() {
+  return source();
+}
+function newSessionId() {
+  const random = globalThis.crypto;
+  if (typeof random?.randomUUID === "function") return random.randomUUID();
+  return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (digit) => (Number(digit) ^ random.getRandomValues(new Uint8Array(1))[0] & 15 >> Number(digit) / 4).toString(16));
+}
+function browserSession() {
+  if (browserId) return browserId;
+  if (typeof globalThis.document === "undefined") return void 0;
+  const tab = tabToken();
+  browserId = newSessionId();
+  try {
+    const storage = globalThis.sessionStorage;
+    browserId = storedSession(storage, tab) ?? browserId;
+    storage.setItem(STORAGE_KEY, browserId);
+    if (tab !== void 0) storage.setItem(TAB_KEY, tab);
+  } catch {
+  }
+  return browserId;
+}
+function storedSession(storage, tab) {
+  const stored = storage.getItem(STORAGE_KEY) ?? void 0;
+  if (!stored || !SESSION_ID.test(stored)) return void 0;
+  return tab === void 0 || storage.getItem(TAB_KEY) === tab ? stored : void 0;
+}
+function tabToken() {
+  const win = globalThis.window;
+  if (!win) return void 0;
+  if (win.name.startsWith(TAB_NAME_PREFIX)) return win.name;
+  if (win.name !== "") return void 0;
+  win.name = `${TAB_NAME_PREFIX}${newSessionId()}`;
+  return win.name;
+}
+function sessionBaggage() {
+  const sessionId = currentSessionId();
+  return sessionId ? `${SESSION_ID_KEY}=${sessionId}` : void 0;
+}
+function requestContextHeaders() {
+  const baggage = sessionBaggage();
+  if (!baggage) return {};
+  const trace = newSessionId().replaceAll("-", "");
+  return { baggage, traceparent: `00-${trace}-${trace.slice(16)}-01` };
+}
+function withRequestContext(fetchImplementation) {
+  return (input, init) => {
+    const send = fetchImplementation ?? globalThis.fetch;
+    const context = requestContextHeaders();
+    if (Object.keys(context).length === 0) return send(input, init);
+    const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+    for (const [name, value] of Object.entries(context)) if (!headers.has(name)) headers.set(name, value);
+    return send(input, { ...init, headers });
+  };
+}
+
+export {
+  SESSION_ID_KEY,
+  setSessionSource,
+  currentSessionId,
+  newSessionId,
+  sessionBaggage,
+  requestContextHeaders,
+  withRequestContext
+};