@q9labsai/chalk-client 5.3.0 → 5.3.1

package/dist/{chunk-XSB2GDRW.js → chunk-FD7ZSDTM.js}

@@ -1,3 +1,7 @@
+import {
+  sessionBaggage
+} from "./chunk-N4IPKRS6.js";
+
 // src/sync/canonical.ts
 var encoder = new TextEncoder();
 function canonicalJson(value) {
@@ -405,11 +409,20 @@ var SyncProtocolMetadata = {
         pattern: "^[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256}(,[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256})*$"
       }
     },
+    helloOnlyFields: {
+      baggage: {
+        kind: "string",
+        minBytes: 47,
+        maxBytes: 47,
+        format: "w3c-baggage-session-id",
+        pattern: "^session\\.id=[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
+      }
+    },
     acceptedOn: {
       hello: "client-to-server",
       serverFrames: "server-to-client"
     },
-    upgradeHeaders: ["x-chalk-journey-id", "traceparent", "tracestate"],
+    upgradeHeaders: ["x-chalk-journey-id", "traceparent", "tracestate", "baggage"],
     rule: "propagate_from_first_observed_layer_to_every_downstream_frame"
   },
   externalIntents: [
@@ -712,7 +725,9 @@ function strictCommand(value) {
 function strictCollaborationsHelloExtension(value) {
   return exactObject(value, ["name", "chat_cursor"]) && ["collaboration_v1", "collaboration_v2"].includes(String(value.name)) && exactObject(value.chat_cursor, ["after_sequence", "retained_floor_sequence"]);
 }
-function strictHello(value) {
+function strictHello(hello) {
+  const { baggage, ...value } = hello;
+  if (baggage !== void 0 && !(typeof baggage === "string" && boundedCorrelationString(baggage, 47, 47) && /^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}$/u.test(baggage))) return false;
   const base = exactObjectWithCorrelation(value, ["type", "protocol", "token", "streams"]);
   const extended = exactObjectWithCorrelation(value, ["type", "protocol", "token", "streams", "extensions"]) && Array.isArray(value.extensions) && value.extensions.length === 1 && strictCollaborationsHelloExtension(value.extensions[0]);
   if (!base && !extended || !exactObject(value.streams, ["control", "media", "presence", "requests"])) return false;
@@ -957,9 +972,10 @@ var TraceparentSchema = boundedUtf8String(55, 55).check(
 var TracestateSchema = boundedUtf8String(512, 1).check(
   Schema.makeFilter((value) => new RegExp("^[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256}(,[a-z][a-z0-9_*\\-/]{0,255}=[\\x21-\\x2b\\x2d-\\x3c\\x3e-\\x7e]{1,256})*$", "u").test(value) ? void 0 : { path: [], issue: "must be a valid bounded W3C tracestate" })
 );
+var BaggageSchema = boundedUtf8String(47, 47).check(Schema.makeFilter((value) => /^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}$/u.test(value) ? void 0 : { path: [], issue: "must be the single W3C baggage member session.id=<lowercase UUID>" }));
 var SyncCorrelationFieldsSchema = Schema.Struct({ journey_id: Schema.optional(JourneyIdSchema), traceparent: Schema.optional(TraceparentSchema), tracestate: Schema.optional(TracestateSchema) });
-var HelloCorrelationFields = { journey_id: Schema.optional(JourneyIdSchema), traceparent: Schema.optional(TraceparentSchema), tracestate: Schema.optional(TracestateSchema) };
-var ServerCorrelationFields = { ...HelloCorrelationFields };
+var ServerCorrelationFields = { journey_id: Schema.optional(JourneyIdSchema), traceparent: Schema.optional(TraceparentSchema), tracestate: Schema.optional(TracestateSchema) };
+var HelloCorrelationFields = { ...ServerCorrelationFields, baggage: Schema.optional(BaggageSchema) };
 var StateDigestSchema = Schema.String.check(Schema.makeFilter((value) => /^[0-9a-f]{64}$/u.test(value) ? void 0 : { path: [], issue: "must be a lowercase hexadecimal SHA-256 digest" }));
 var UnsignedDecimalSchema = Schema.String.check(Schema.makeFilter((value) => /^(?:0|[1-9][0-9]*)$/u.test(value) ? void 0 : { path: [], issue: "must be an unsigned decimal integer" }));
 var CommandIdSchema = boundedUtf8String(64).check(Schema.makeFilter((value) => textEncoder.encode(value).byteLength >= 16 ? void 0 : { path: [], issue: "must meet the command ID minimum byte length" }));
@@ -2528,6 +2544,11 @@ var V1CommandScheduler = class {
   async acknowledge(frame) {
     const deferred = this.#commands.get(frame.command_id);
     if (!deferred) return;
+    if (isSatisfiedByInactiveParticipant(frame, deferred.frame)) {
+      const head = this.#options.controlHead();
+      await this.#finishCommand(frame.command_id, { type: "ack", command_id: frame.command_id, delivery: "duplicate", outcome: "satisfied", revision: head.revision, state_digest: head.state_digest });
+      return;
+    }
     if (frame.outcome === "rejected" || frame.outcome === "command_id_conflict") {
       await this.#finishCommand(frame.command_id, frame);
       return;
@@ -2566,15 +2587,12 @@ var V1CommandScheduler = class {
     }
   }
   async settleTerminalRecovery(frame) {
-    const satisfiedOperations = /* @__PURE__ */ new Set();
-    if (frame.reason === "episode_ended") {
-      satisfiedOperations.add("end_episode");
-      satisfiedOperations.add("participant_leave");
-    } else if (frame.reason === "participant_inactive") {
-      satisfiedOperations.add("participant_leave");
-    }
+    const satisfies = (operation) => {
+      if (frame.reason === "episode_ended") return operation === "end_episode" || operation === "participant_leave";
+      return frame.reason === "participant_inactive" && inactiveParticipantSatisfies(operation);
+    };
     for (const [commandId, deferred] of this.#commands) {
-      if (deferred.frame.type !== "operation" || !satisfiedOperations.has(deferred.frame.name)) continue;
+      if (deferred.frame.type !== "operation" || !satisfies(deferred.frame.name)) continue;
       await this.#finishCommand(commandId, {
         type: "ack",
         command_id: commandId,
@@ -2744,6 +2762,12 @@ function targetFrame(commandId, command) {
       return { type: "command", command_id: commandId, name: command.name, payload: command.payload };
   }
 }
+function inactiveParticipantSatisfies(operation) {
+  return operation === "participant_leave";
+}
+function isSatisfiedByInactiveParticipant(result, command) {
+  return result.outcome === "rejected" && result.reason === "participant_inactive" && command.type === "operation" && inactiveParticipantSatisfies(command.name);
+}
 function isTerminalLifecycleOperation(frame) {
   return frame.type === "operation" && (frame.name === "participant_leave" || frame.name === "end_episode");
 }
@@ -3002,6 +3026,7 @@ var MAX_REPLAY_EVENTS = SyncProtocolLimits.completeReplayMaxEvents;
 var MAX_REPLAY_BYTES = SyncProtocolLimits.completeReplayEncodedBytes;
 var MAX_PROJECTION_EVENT_EVIDENCE = 256;
 var CLIENT_RESTART_CLOSE_CODE = 4e3;
+var legacyHelloServers = /* @__PURE__ */ new Set();
 var DEFAULT_RECONNECT_DELAY_MS = 250;
 var MAX_RECONNECT_DELAY_MS = 5e3;
 var FAST_RECONNECT_ATTEMPTS = 8;
@@ -3052,6 +3077,8 @@ var V1SyncClient = class {
     return { stage: this.#opened ? "hello" : "upgrade", opened: this.#opened, closeCode: null, closeReason: null, durationMs: Math.max(0, this.#clock().now() - (this.#connectStartedAt ?? this.#clock().now())), attempt: this.#connectAttemptCount };
   }
   #reconnectAttempt = 0;
+  /** The socket whose hello carried baggage and has not been answered by a welcome yet. */
+  #baggageHelloSocket = null;
   #episodeEndTimer;
   #heartbeatTimer;
   #missedHeartbeats = 0;
@@ -3082,7 +3109,11 @@ var V1SyncClient = class {
       isStarted: () => this.#started,
       sendIfLive: (frame) => this.#sendIfLive(frame),
       stateChanged: () => this.#emit(),
-      ackHeadIsProven: (ack) => this.#ackHeadIsProven(ack)
+      ackHeadIsProven: (ack) => this.#ackHeadIsProven(ack),
+      controlHead: () => {
+        const control = this.#requireControl();
+        return { revision: control.revision, state_digest: control.stateDigest };
+      }
     });
     this.#liveTargets = new V1LiveTargetCoordinator({
       mediaPlane: options.mediaPlane,
@@ -3373,11 +3404,12 @@ var V1SyncClient = class {
       this.#clock().setTimeout(() => {
         if (connectionGeneration !== this.#connectionGeneration) return;
         this.#inbound = this.#inbound.then(() => {
+          const legacyHello = event.code === 1009 && this.#legacyHelloRejected(socket);
           if (socket === this.#socket && event.code === 1008 && (event.reason === "" || event.reason === "invalid token" || event.reason === "policy violation" || event.reason === "entry timeout")) {
             this.#phase = { phase: "terminal", terminalReason: event.reason === "entry timeout" ? "entry_timeout" : "access_rejected" };
             this.#emit();
           }
-          this.#disconnected(socket);
+          this.#disconnected(socket, legacyHello);
         });
       }, 0);
     };
@@ -3394,10 +3426,12 @@ var V1SyncClient = class {
       const token = await this.#options.token();
       if (socket !== this.#socket) return;
       this.#phase = { phase: "recovering" };
+      const baggage = legacyHelloServers.has(this.#options.url) ? void 0 : sessionBaggage();
       const hello = {
         type: "hello",
         protocol: 1,
         ...this.#options.traceparent ? { traceparent: this.#options.traceparent } : {},
+        ...baggage ? { baggage } : {},
         token,
         streams: {
           control: { cursor: this.#control && { revision: this.#control.revision, state_schema_version: this.#control.stateSchemaVersion, state_digest: this.#control.stateDigest } },
@@ -3407,6 +3441,7 @@ var V1SyncClient = class {
         }
       };
       const collaborationExtension = this.#collaborationState.helloExtension;
+      this.#baggageHelloSocket = baggage ? socket : null;
       if (!collaborationExtension) {
         this.#send(hello);
       } else {
@@ -3426,7 +3461,7 @@ var V1SyncClient = class {
     } catch (error) {
       if (this.#snapshotRecoveryRequested) this.#failDigestRecovery();
       else if (error instanceof V1StateDigestMismatchError) this.#recoverDigestMismatch();
-      else this.#recover("invalid_frame");
+      else this.#recover("invalid_frame", error instanceof V1ReplicaError && error.message === "invalid_frame" && this.#legacyHelloRejected(socket));
     }
   }
   async #handleFrame(frame) {
@@ -3548,6 +3583,7 @@ var V1SyncClient = class {
   }
   async #welcome(frame) {
     if (this.#phase.phase !== "recovering" || this.#recovery) throw new V1ReplicaError("unexpected welcome");
+    this.#baggageHelloSocket = null;
     this.#collaborationState.acceptWelcome(frame);
     this.#entryNegotiated = frame.entry_confirmation === true;
     this.#entryGeneration = frame.entry_generation ?? this.#entryGeneration;
@@ -3704,7 +3740,7 @@ var V1SyncClient = class {
     if (evidence.get(frame.sequence) !== frameSignature(frame)) throw new V1ReplicaError("conflicting or unprovable duplicate projection event");
     return true;
   }
-  #disconnected(socket) {
+  #disconnected(socket, retryNow = false) {
     if (socket !== this.#socket) return;
     this.#socket = null;
     this.#clearDial();
@@ -3723,6 +3759,13 @@ var V1SyncClient = class {
     this.#emit();
     if (!this.#transportAvailable) return;
     this.#clearReconnect();
+    if (retryNow) {
+      this.#reconnectTimer = this.#clock().setTimeout(() => {
+        this.#reconnectTimer = void 0;
+        this.#connect();
+      }, 0);
+      return;
+    }
     const configuredDelay = this.#options.reconnectDelayMs;
     const exponentialAttempt = configuredDelay === void 0 ? Math.max(0, this.#reconnectAttempt - FAST_RECONNECT_ATTEMPTS + 1) : this.#reconnectAttempt;
     const baseDelay = configuredDelay === 0 ? 0 : Math.min(MAX_RECONNECT_DELAY_MS, (configuredDelay ?? DEFAULT_RECONNECT_DELAY_MS) * 2 ** Math.min(exponentialAttempt, 5));
@@ -3733,11 +3776,21 @@ var V1SyncClient = class {
       this.#connect();
     }, delay);
   }
-  #recover(reason) {
+  #recover(reason, retryNow = false) {
     const socket = this.#socket;
     if (!socket) return;
     socket.close(CLIENT_RESTART_CLOSE_CODE, reason);
-    this.#disconnected(socket);
+    this.#disconnected(socket, retryNow);
+  }
+  /**
+   * A Sync that predates the session ID rejects any hello with an unknown `baggage` field before welcome. The first
+   * rejection marks that server as legacy, so the retry and every later reconnect send the hello without it.
+   */
+  #legacyHelloRejected(socket) {
+    if (this.#baggageHelloSocket !== socket) return false;
+    this.#baggageHelloSocket = null;
+    legacyHelloServers.add(this.#options.url);
+    return true;
   }
   #recoverDigestMismatch() {
     const now = this.#clock().now();

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
+};