realtime-avatar 0.27.2 → 0.27.3

package/README.md

@@ -86,8 +86,12 @@ if (recording.status === "ready") {
 
 Omitted or `"off"` disables recording. `"audio"` records published user and avatar audio;
 `"video"` records published video without audio; `"audio_video"` keeps both on one media timeline.
+`"participants"` keeps each participant's voice and camera in its own continuous file.
+`"tracks"` saves separate published audio/video tracks and replacement-camera segments;
+use `listRecordings({ sessionId: call.sessionId })` because its initial grant omits recording
+metadata so older installed clients remain compatible.
 Recording does not enable the microphone, camera, or screen sharing. Only tracks that participants
-authorize and publish can be recorded. Camera controls remain a future SDK feature.
+authorize and publish can be recorded.
 
 Recordings may finish processing after a call ends. Use `listRecordings({ sessionId })` to find
 them, or refresh `getRecording(recordingId)` while processing. These methods and
@@ -98,6 +102,15 @@ default); each URL expires at `expiresAt` (up to one hour, capped by retention).
 access before replaying or seeking after expiry. An expired URL does not delete the file.
 Treat the URL as private: anyone who has it can play that file until it expires.
 
+For participant replay, pass every ready `{ recording, url }` asset to `RecordingPlayer`
+from `realtime-avatar/react`. It accepts combined participant MP4s and separate audio/video
+segments, including camera republication. Follow `nextCursor` when listing a session's recordings.
+The optional `mediaStartOffsetMs` preserves a file's first native media timestamp; it delays
+that track's visibility without shifting its playback clock. The player preserves native
+timestamps across gaps and uses the artifact's duration instead of an initially truncated
+WebM container duration. `mediaMutedIntervalsMs` hides a muted camera while keeping media
+clocks and audio running, including audio carried by a legacy combined file.
+
 ## Optional connection history
 
 Set `connectionHistory: true` in the server's `startCall` policy when the caller needs a

package/dist/{chunk-SP5SYYSS.js → chunk-QBOIOZ3O.js}

@@ -1,4 +1,4 @@
-import { sessionModeSchema, liveKitSessionReleaseReasonSchema, RealtimeAvatar, ROUTE_TIMEOUT_MS, isQueued, RealtimeAvatarHttpError, RealtimeAvatarError } from './chunk-YR5NJTEO.js';
+import { sessionModeSchema, liveKitSessionReleaseReasonSchema, RealtimeAvatar, ROUTE_TIMEOUT_MS, isQueued, RealtimeAvatarHttpError, RealtimeAvatarError } from './chunk-W4DGBG4Z.js';
 import { z } from 'zod';
 
 // ../http-client/src/generated/error-semantics.ts

package/dist/{chunk-YR5NJTEO.js → chunk-W4DGBG4Z.js}

@@ -239,13 +239,17 @@ var schema26 = z.strictObject({
 var clipLibraryResponseSchema = schema24;
 var clipLibraryUpdateSchema = schema26;
 var RECORDED_MEDIA_MODES = ["audio", "video", "audio_video"];
-var recordingModeSchema = z.enum(["off", ...RECORDED_MEDIA_MODES, "participants"]).describe("Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices.");
+var recordingModeSchema = z.enum(["off", ...RECORDED_MEDIA_MODES, "participants", "tracks"]).describe("Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices. tracks saves each published participant audio/video track separately; list recordings by session after capture.");
 var RECORDING_STATUSES = ["pending", "recording", "processing", "ready", "failed", "expired"];
 z.enum(RECORDING_STATUSES);
 var recordingParticipantSchema = z.object({
   participantIdentity: z.string().min(1).max(160),
   role: z.enum(["user", "avatar"])
 }).strict();
+var recordingMutedIntervalSchema = z.object({
+  startMs: z.number().int().min(0),
+  endMs: z.number().int().positive()
+}).strict().refine((interval) => interval.endMs > interval.startMs, "Muted interval must end after it starts");
 var recordingMetadataSchema = z.object({
   sessionId: z.string().min(1),
   recordingId: z.string().min(1),
@@ -254,13 +258,15 @@ var recordingMetadataSchema = z.object({
   retainedUntil: z.string().datetime({ offset: true }),
   participant: recordingParticipantSchema.optional(),
   mediaStartedAt: z.string().datetime({ offset: true }).optional(),
-  mediaEndedAt: z.string().datetime({ offset: true }).optional()
+  mediaEndedAt: z.string().datetime({ offset: true }).optional(),
+  mediaStartOffsetMs: z.number().int().min(0).optional().describe("First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero."),
+  mediaMutedIntervalsMs: z.array(recordingMutedIntervalSchema).optional().describe("Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals.")
 });
 var recordingArtifactSchema = z.discriminatedUnion("status", [
   recordingMetadataSchema.extend({ status: z.enum(["pending", "recording", "processing", "expired"]) }).strict(),
   recordingMetadataSchema.extend({
     status: z.literal("ready"),
-    mediaType: z.enum(["audio/mp4", "video/mp4"]),
+    mediaType: z.enum(["audio/mp4", "video/mp4", "audio/ogg", "video/webm"]),
     sizeBytes: z.number().int().positive(),
     durationMs: z.number().int().nonnegative().nullable()
   }).strict(),
@@ -669,7 +675,7 @@ var liveKitSessionReleaseReasonSchema = z.enum([
 
 // ../http-client/src/client.ts
 var DEFAULT_BASE_URL = "https://realtimeavatar.ai/api/v1";
-var SDK_VERSION = "0.27.2";
+var SDK_VERSION = "0.27.3";
 var RealtimeAvatar = class {
   #apiKey;
   #baseUrl;

package/dist/express.d.ts

@@ -1,5 +1,5 @@
-import { P as ProxyConfig } from './types-BH9O5leB.js';
-import './types-D_s7ff7w.js';
+import { P as ProxyConfig } from './types-lgS4Z9rd.js';
+import './types-kgmS7ECd.js';
 import 'zod';
 
 type Expressish = {

package/dist/express.js

@@ -1,5 +1,5 @@
-import { createProxyHandler } from './chunk-SP5SYYSS.js';
-import './chunk-YR5NJTEO.js';
+import { createProxyHandler } from './chunk-QBOIOZ3O.js';
+import './chunk-W4DGBG4Z.js';
 import './chunk-MCIXU6XP.js';
 
 // ../proxy/src/express.ts

package/dist/hono.d.ts

@@ -1,5 +1,5 @@
-import { P as ProxyConfig } from './types-BH9O5leB.js';
-import './types-D_s7ff7w.js';
+import { P as ProxyConfig } from './types-lgS4Z9rd.js';
+import './types-kgmS7ECd.js';
 import 'zod';
 
 /**

package/dist/hono.js

@@ -1,5 +1,5 @@
-import { createProxyHandler } from './chunk-SP5SYYSS.js';
-import './chunk-YR5NJTEO.js';
+import { createProxyHandler } from './chunk-QBOIOZ3O.js';
+import './chunk-W4DGBG4Z.js';
 import './chunk-MCIXU6XP.js';
 
 // ../proxy/src/hono.ts

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as CallPolicy, C as CallMode, S as StartCallResult, E as EndCallOptions, A as Avatar, b as AvatarUpdate, c as AvatarSourceSwap, d as ClipLibraryDeclaration, e as ClipLibraryUpdate, L as LoopRedirect, f as ClipLibrary, g as AssetKind, h as Asset, i as ListSessionsOptions, U as UsageSessionPage, j as UsageSession, k as ListRecordingsQuery, l as ListRecordingsResponse, R as RecordingArtifact, m as RecordingAccessResponse, n as CreditBalance, T as TranscriptPayload } from './types-D_s7ff7w.js';
-export { o as AvatarClip, p as CallConnection, q as CallQueued, r as ClipDeclaration, s as ClipLibraryPlan, t as ClipSource, u as ContextMessage, v as EndCallReason, w as ExternalLlm, x as RecordingArtifactStatus, y as RecordingMode, V as VideoPolicy, z as isQueued, B as listRecordingsResponseSchema, D as recordingAccessResponseSchema, F as recordingArtifactSchema, G as recordingModeSchema } from './types-D_s7ff7w.js';
+import { a as CallPolicy, C as CallMode, S as StartCallResult, E as EndCallOptions, A as Avatar, b as AvatarUpdate, c as AvatarSourceSwap, d as ClipLibraryDeclaration, e as ClipLibraryUpdate, L as LoopRedirect, f as ClipLibrary, g as AssetKind, h as Asset, i as ListSessionsOptions, U as UsageSessionPage, j as UsageSession, k as ListRecordingsQuery, l as ListRecordingsResponse, R as RecordingArtifact, m as RecordingAccessResponse, n as CreditBalance, T as TranscriptPayload } from './types-kgmS7ECd.js';
+export { o as AvatarClip, p as CallConnection, q as CallQueued, r as ClipDeclaration, s as ClipLibraryPlan, t as ClipSource, u as ContextMessage, v as EndCallReason, w as ExternalLlm, x as RecordingArtifactStatus, y as RecordingMode, V as VideoPolicy, z as isQueued, B as listRecordingsResponseSchema, D as recordingAccessResponseSchema, F as recordingArtifactSchema, G as recordingModeSchema } from './types-kgmS7ECd.js';
 import { ConnectionHistoryResponse } from './connection-history.js';
 import { z } from 'zod';
 

package/dist/index.js

@@ -1,2 +1,2 @@
-export { RealtimeAvatar, RealtimeAvatarError, RealtimeAvatarHttpError, clipLibraryDeclarationSchema, isQueued, listRecordingsResponseSchema, recordingAccessResponseSchema, recordingArtifactSchema, recordingModeSchema, verifyTranscript } from './chunk-YR5NJTEO.js';
+export { RealtimeAvatar, RealtimeAvatarError, RealtimeAvatarHttpError, clipLibraryDeclarationSchema, isQueued, listRecordingsResponseSchema, recordingAccessResponseSchema, recordingArtifactSchema, recordingModeSchema, verifyTranscript } from './chunk-W4DGBG4Z.js';
 import './chunk-MCIXU6XP.js';

package/dist/nextjs.d.ts

@@ -1,5 +1,5 @@
-import { P as ProxyConfig } from './types-BH9O5leB.js';
-import './types-D_s7ff7w.js';
+import { P as ProxyConfig } from './types-lgS4Z9rd.js';
+import './types-kgmS7ECd.js';
 import 'zod';
 
 /**

package/dist/nextjs.js

@@ -1,5 +1,5 @@
-import { createProxyHandler } from './chunk-SP5SYYSS.js';
-import './chunk-YR5NJTEO.js';
+import { createProxyHandler } from './chunk-QBOIOZ3O.js';
+import './chunk-W4DGBG4Z.js';
 import './chunk-MCIXU6XP.js';
 
 // ../proxy/src/nextjs.ts

package/dist/{proxy-client-DW_EOvmE.d.ts → proxy-client-BAY77sJZ.d.ts}

@@ -266,6 +266,11 @@ declare const liveKitSessionGrantSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodEnum<{
             pending: "pending";
             recording: "recording";
@@ -291,10 +296,17 @@ declare const liveKitSessionGrantSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodLiteral<"ready">;
         mediaType: z.ZodEnum<{
             "audio/mp4": "audio/mp4";
             "video/mp4": "video/mp4";
+            "audio/ogg": "audio/ogg";
+            "video/webm": "video/webm";
         }>;
         sizeBytes: z.ZodNumber;
         durationMs: z.ZodNullable<z.ZodNumber>;
@@ -317,6 +329,11 @@ declare const liveKitSessionGrantSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodLiteral<"failed">;
         errorCode: z.ZodEnum<{
             recording_failed: "recording_failed";
@@ -329,6 +346,7 @@ declare const liveKitSessionGrantSchema: z.ZodObject<{
         audio_video: "audio_video";
         off: "off";
         participants: "participants";
+        tracks: "tracks";
     }>>;
     recordings: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         sessionId: z.ZodString;
@@ -349,6 +367,11 @@ declare const liveKitSessionGrantSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodEnum<{
             pending: "pending";
             recording: "recording";
@@ -374,10 +397,17 @@ declare const liveKitSessionGrantSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodLiteral<"ready">;
         mediaType: z.ZodEnum<{
             "audio/mp4": "audio/mp4";
             "video/mp4": "video/mp4";
+            "audio/ogg": "audio/ogg";
+            "video/webm": "video/webm";
         }>;
         sizeBytes: z.ZodNumber;
         durationMs: z.ZodNullable<z.ZodNumber>;
@@ -400,6 +430,11 @@ declare const liveKitSessionGrantSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodLiteral<"failed">;
         errorCode: z.ZodEnum<{
             recording_failed: "recording_failed";

package/dist/react-native.d.ts

@@ -1,7 +1,7 @@
 import { LiveKitRoomProps } from '@livekit/react-native';
 export { AudioSession, VideoTrack, VideoTrackProps, registerGlobals } from '@livekit/react-native';
-import { L as LiveKitSessionGrant, A as AvatarVideoFit } from './proxy-client-DW_EOvmE.js';
-export { a as AdaptivePlayoutController, b as AdaptivePlayoutDecision, c as AdaptivePlayoutOptions, d as AdaptivePlayoutSample, e as ApproachingEndEvent, f as ApproachingEndReason, g as AvatarConnectionDetails, h as AvatarSessionClient, B as BehaviorSnapshot, C as CallTranscript, i as CallTranscriptSegment, j as CartesiaTtsModel, k as ClipResult, l as ClosingTurnResult, m as CreditsLowEvent, D as DEFAULT_APPROACHING_END_LEAD_SECONDS, n as DEFAULT_CREDITS_LOW_LEAD_SECONDS, o as DEFAULT_GOVERNOR_CONFIG, p as DEFAULT_GRACE_CEILING_SECONDS, q as DEFAULT_GRACE_WINDOW_LEAD_SECONDS, r as DEFAULT_IDLE_SECONDS, s as DEFAULT_IDLE_WARN_LEAD_SECONDS, t as DEFAULT_READY_TIMEOUT_SECONDS, u as DEFAULT_TURN_TIMEOUT_SECONDS, v as DeclaredInputSource, E as EndReason, w as EndedEvent, x as ExtendResult, F as FishTtsModel, y as FreezeReadingFn, G as Governor, z as GovernorAction, H as GovernorConfig, I as GovernorSignal, J as GovernorState, K as GraceWindowClosedEvent, M as GraceWindowOpenEvent, N as GraceWindowState, O as IdleWarningEvent, P as InboundRtpCursor, Q as InboundRtpReading, R as KnownBehaviorState, S as LLMProvider, T as LLMSelection, U as LiveKitAvatarGrantState, V as LiveKitAvatarGrantStatus, W as LiveKitCapacityState, X as LiveKitConnectionStatus, Y as LiveKitSessionRequest, Z as LiveKitSessionStartResult, _ as MAX_RECONNECT_ATTEMPTS, $ as MAX_SESSION_INSTRUCTIONS_CHARS, a0 as ProxyClientOptions, a1 as QualityCap, a2 as RECONNECT_BACKOFF_MS, a3 as RealtimeAvatarRequestOptions, a4 as RealtimeSessionApi, a5 as RealtimeSessionMedia, a6 as RealtimeSessionRoomSinks, a7 as ReconnectPolicy, a8 as ReconnectingEvent, a9 as RecoveryState, aa as RetryStep, ab as SendTurnOptions, ac as SessionBehavior, ad as SessionClip, ae as SessionClocks, af as SessionEndReason, ag as SessionLifecycleApi, ah as SessionLifecyclePhase, ai as SessionLifecyclePhaseKind, aj as SessionLifecycleRoomBridge, ak as SessionLifecycleRoomBridgeProps, al as SessionReadinessFailure, am as SurfaceLayers, an as TranscriptSender, ao as TranscriptSenderOptions, ap as TurnState, aq as TurnTimeoutEvent, ar as UseAvatarQualityGovernorInput, as as UseLiveKitAvatarGrantInput, at as UseRealtimeSessionInput, au as UseSessionLifecycleInput, av as VoiceSpec, aw as VoiceSpecInput, ax as capacityErrorFromBusy, ay as capacityStateFromGrant, az as createProxyClient, aA as isNativeLiveTrackSubscribed, aB as knownBehaviorStates, aC as mapTurnState, aD as readInboundRtp, aE as sessionBehaviorSchema, aF as sessionClipSchema, aG as splitCallTranscript, aH as useAvatarAdaptivePlayoutDelay, aI as useAvatarCamera, aJ as useAvatarPlayoutDelay, aK as useAvatarQualityGovernor, aL as useCallTranscript, aM as useLiveKitAvatarGrant, aN as useLiveTrackProducing, aO as useMicLease, aP as useRealtimeSession, aQ as useReleaseMicLeaseOnTrackEnded, aR as useSessionLifecycle } from './proxy-client-DW_EOvmE.js';
+import { L as LiveKitSessionGrant, A as AvatarVideoFit } from './proxy-client-BAY77sJZ.js';
+export { a as AdaptivePlayoutController, b as AdaptivePlayoutDecision, c as AdaptivePlayoutOptions, d as AdaptivePlayoutSample, e as ApproachingEndEvent, f as ApproachingEndReason, g as AvatarConnectionDetails, h as AvatarSessionClient, B as BehaviorSnapshot, C as CallTranscript, i as CallTranscriptSegment, j as CartesiaTtsModel, k as ClipResult, l as ClosingTurnResult, m as CreditsLowEvent, D as DEFAULT_APPROACHING_END_LEAD_SECONDS, n as DEFAULT_CREDITS_LOW_LEAD_SECONDS, o as DEFAULT_GOVERNOR_CONFIG, p as DEFAULT_GRACE_CEILING_SECONDS, q as DEFAULT_GRACE_WINDOW_LEAD_SECONDS, r as DEFAULT_IDLE_SECONDS, s as DEFAULT_IDLE_WARN_LEAD_SECONDS, t as DEFAULT_READY_TIMEOUT_SECONDS, u as DEFAULT_TURN_TIMEOUT_SECONDS, v as DeclaredInputSource, E as EndReason, w as EndedEvent, x as ExtendResult, F as FishTtsModel, y as FreezeReadingFn, G as Governor, z as GovernorAction, H as GovernorConfig, I as GovernorSignal, J as GovernorState, K as GraceWindowClosedEvent, M as GraceWindowOpenEvent, N as GraceWindowState, O as IdleWarningEvent, P as InboundRtpCursor, Q as InboundRtpReading, R as KnownBehaviorState, S as LLMProvider, T as LLMSelection, U as LiveKitAvatarGrantState, V as LiveKitAvatarGrantStatus, W as LiveKitCapacityState, X as LiveKitConnectionStatus, Y as LiveKitSessionRequest, Z as LiveKitSessionStartResult, _ as MAX_RECONNECT_ATTEMPTS, $ as MAX_SESSION_INSTRUCTIONS_CHARS, a0 as ProxyClientOptions, a1 as QualityCap, a2 as RECONNECT_BACKOFF_MS, a3 as RealtimeAvatarRequestOptions, a4 as RealtimeSessionApi, a5 as RealtimeSessionMedia, a6 as RealtimeSessionRoomSinks, a7 as ReconnectPolicy, a8 as ReconnectingEvent, a9 as RecoveryState, aa as RetryStep, ab as SendTurnOptions, ac as SessionBehavior, ad as SessionClip, ae as SessionClocks, af as SessionEndReason, ag as SessionLifecycleApi, ah as SessionLifecyclePhase, ai as SessionLifecyclePhaseKind, aj as SessionLifecycleRoomBridge, ak as SessionLifecycleRoomBridgeProps, al as SessionReadinessFailure, am as SurfaceLayers, an as TranscriptSender, ao as TranscriptSenderOptions, ap as TurnState, aq as TurnTimeoutEvent, ar as UseAvatarQualityGovernorInput, as as UseLiveKitAvatarGrantInput, at as UseRealtimeSessionInput, au as UseSessionLifecycleInput, av as VoiceSpec, aw as VoiceSpecInput, ax as capacityErrorFromBusy, ay as capacityStateFromGrant, az as createProxyClient, aA as isNativeLiveTrackSubscribed, aB as knownBehaviorStates, aC as mapTurnState, aD as readInboundRtp, aE as sessionBehaviorSchema, aF as sessionClipSchema, aG as splitCallTranscript, aH as useAvatarAdaptivePlayoutDelay, aI as useAvatarCamera, aJ as useAvatarPlayoutDelay, aK as useAvatarQualityGovernor, aL as useCallTranscript, aM as useLiveKitAvatarGrant, aN as useLiveTrackProducing, aO as useMicLease, aP as useRealtimeSession, aQ as useReleaseMicLeaseOnTrackEnded, aR as useSessionLifecycle } from './proxy-client-BAY77sJZ.js';
 import { ReactNode, ReactElement } from 'react';
 import { StyleProp, ViewStyle } from 'react-native';
 export { useChat, useConnectionState, useLocalParticipant, useRoomContext, useTrackToggle, useTranscriptions, useVoiceAssistant } from '@livekit/components-react';

package/dist/react-native.js

@@ -1630,13 +1630,17 @@ var styles = StyleSheet.create({
   }
 });
 var RECORDED_MEDIA_MODES = ["audio", "video", "audio_video"];
-var recordingModeSchema = z.enum(["off", ...RECORDED_MEDIA_MODES, "participants"]).describe("Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices.");
+var recordingModeSchema = z.enum(["off", ...RECORDED_MEDIA_MODES, "participants", "tracks"]).describe("Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices. tracks saves each published participant audio/video track separately; list recordings by session after capture.");
 var RECORDING_STATUSES = ["pending", "recording", "processing", "ready", "failed", "expired"];
 z.enum(RECORDING_STATUSES);
 var recordingParticipantSchema = z.object({
   participantIdentity: z.string().min(1).max(160),
   role: z.enum(["user", "avatar"])
 }).strict();
+var recordingMutedIntervalSchema = z.object({
+  startMs: z.number().int().min(0),
+  endMs: z.number().int().positive()
+}).strict().refine((interval) => interval.endMs > interval.startMs, "Muted interval must end after it starts");
 var recordingMetadataSchema = z.object({
   sessionId: z.string().min(1),
   recordingId: z.string().min(1),
@@ -1645,13 +1649,15 @@ var recordingMetadataSchema = z.object({
   retainedUntil: z.string().datetime({ offset: true }),
   participant: recordingParticipantSchema.optional(),
   mediaStartedAt: z.string().datetime({ offset: true }).optional(),
-  mediaEndedAt: z.string().datetime({ offset: true }).optional()
+  mediaEndedAt: z.string().datetime({ offset: true }).optional(),
+  mediaStartOffsetMs: z.number().int().min(0).optional().describe("First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero."),
+  mediaMutedIntervalsMs: z.array(recordingMutedIntervalSchema).optional().describe("Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals.")
 });
 var recordingArtifactSchema = z.discriminatedUnion("status", [
   recordingMetadataSchema.extend({ status: z.enum(["pending", "recording", "processing", "expired"]) }).strict(),
   recordingMetadataSchema.extend({
     status: z.literal("ready"),
-    mediaType: z.enum(["audio/mp4", "video/mp4"]),
+    mediaType: z.enum(["audio/mp4", "video/mp4", "audio/ogg", "video/webm"]),
     sizeBytes: z.number().int().positive(),
     durationMs: z.number().int().nonnegative().nullable()
   }).strict(),

package/dist/react.d.ts

@@ -1,9 +1,9 @@
 import { ToolRegistration, RegisteredTool } from './tools.js';
-import { ak as SessionLifecycleRoomBridgeProps, h as AvatarSessionClient, A as AvatarVideoFit, aS as CallMicrophone, aT as CallAudioPlayback, aU as CallMicrophoneProblem } from './proxy-client-DW_EOvmE.js';
-export { a as AdaptivePlayoutController, b as AdaptivePlayoutDecision, c as AdaptivePlayoutOptions, d as AdaptivePlayoutSample, e as ApproachingEndEvent, f as ApproachingEndReason, g as AvatarConnectionDetails, aV as AvatarVideoSurface, aW as AvatarVideoSurfaceProps, B as BehaviorSnapshot, C as CallTranscript, i as CallTranscriptSegment, j as CartesiaTtsModel, k as ClipResult, l as ClosingTurnResult, m as CreditsLowEvent, D as DEFAULT_APPROACHING_END_LEAD_SECONDS, n as DEFAULT_CREDITS_LOW_LEAD_SECONDS, o as DEFAULT_GOVERNOR_CONFIG, p as DEFAULT_GRACE_CEILING_SECONDS, q as DEFAULT_GRACE_WINDOW_LEAD_SECONDS, r as DEFAULT_IDLE_SECONDS, s as DEFAULT_IDLE_WARN_LEAD_SECONDS, t as DEFAULT_READY_TIMEOUT_SECONDS, u as DEFAULT_TURN_TIMEOUT_SECONDS, v as DeclaredInputSource, E as EndReason, w as EndedEvent, x as ExtendResult, F as FishTtsModel, y as FreezeReadingFn, G as Governor, z as GovernorAction, H as GovernorConfig, I as GovernorSignal, J as GovernorState, K as GraceWindowClosedEvent, M as GraceWindowOpenEvent, N as GraceWindowState, O as IdleWarningEvent, P as InboundRtpCursor, Q as InboundRtpReading, R as KnownBehaviorState, S as LLMProvider, T as LLMSelection, U as LiveKitAvatarGrantState, V as LiveKitAvatarGrantStatus, W as LiveKitCapacityState, X as LiveKitConnectionStatus, Y as LiveKitSessionRequest, Z as LiveKitSessionStartResult, aX as LivePlaybackKeeper, _ as MAX_RECONNECT_ATTEMPTS, $ as MAX_SESSION_INSTRUCTIONS_CHARS, aY as MIC_LEASE_ENDED_TIMEOUT_MS, aZ as MicLease, a_ as NETWORK_QUALITY_POLICY, a$ as NetworkQualityStatus, b0 as PlayableVideoElement, a0 as ProxyClientOptions, a1 as QualityCap, a2 as RECONNECT_BACKOFF_MS, b1 as RealtimeAvatarCapacityError, b2 as RealtimeAvatarLiveKitRoom, b3 as RealtimeAvatarLiveKitRoomProps, a3 as RealtimeAvatarRequestOptions, a4 as RealtimeSessionApi, a5 as RealtimeSessionMedia, a6 as RealtimeSessionRoomSinks, a7 as ReconnectPolicy, a8 as ReconnectingEvent, a9 as RecoveryState, aa as RetryStep, ab as SendTurnOptions, ac as SessionBehavior, ad as SessionClip, ae as SessionClocks, af as SessionEndReason, ag as SessionLifecycleApi, ah as SessionLifecyclePhase, ai as SessionLifecyclePhaseKind, aj as SessionLifecycleRoomBridge, al as SessionReadinessFailure, am as SurfaceLayers, an as TranscriptSender, ao as TranscriptSenderOptions, ap as TurnState, aq as TurnTimeoutEvent, ar as UseAvatarQualityGovernorInput, as as UseLiveKitAvatarGrantInput, at as UseRealtimeSessionInput, au as UseSessionLifecycleInput, av as VoiceSpec, aw as VoiceSpecInput, ax as capacityErrorFromBusy, ay as capacityStateFromGrant, az as createProxyClient, aB as knownBehaviorStates, aC as mapTurnState, aD as readInboundRtp, aE as sessionBehaviorSchema, aF as sessionClipSchema, b4 as shouldReplayPendingTurn, aG as splitCallTranscript, aH as useAvatarAdaptivePlayoutDelay, aI as useAvatarCamera, aJ as useAvatarPlayoutDelay, aK as useAvatarQualityGovernor, aL as useCallTranscript, aM as useLiveKitAvatarGrant, aO as useMicLease, aP as useRealtimeSession, aQ as useReleaseMicLeaseOnTrackEnded, aR as useSessionLifecycle } from './proxy-client-DW_EOvmE.js';
+import { ak as SessionLifecycleRoomBridgeProps, h as AvatarSessionClient, A as AvatarVideoFit, aS as CallMicrophone, aT as CallAudioPlayback, aU as CallMicrophoneProblem } from './proxy-client-BAY77sJZ.js';
+export { a as AdaptivePlayoutController, b as AdaptivePlayoutDecision, c as AdaptivePlayoutOptions, d as AdaptivePlayoutSample, e as ApproachingEndEvent, f as ApproachingEndReason, g as AvatarConnectionDetails, aV as AvatarVideoSurface, aW as AvatarVideoSurfaceProps, B as BehaviorSnapshot, C as CallTranscript, i as CallTranscriptSegment, j as CartesiaTtsModel, k as ClipResult, l as ClosingTurnResult, m as CreditsLowEvent, D as DEFAULT_APPROACHING_END_LEAD_SECONDS, n as DEFAULT_CREDITS_LOW_LEAD_SECONDS, o as DEFAULT_GOVERNOR_CONFIG, p as DEFAULT_GRACE_CEILING_SECONDS, q as DEFAULT_GRACE_WINDOW_LEAD_SECONDS, r as DEFAULT_IDLE_SECONDS, s as DEFAULT_IDLE_WARN_LEAD_SECONDS, t as DEFAULT_READY_TIMEOUT_SECONDS, u as DEFAULT_TURN_TIMEOUT_SECONDS, v as DeclaredInputSource, E as EndReason, w as EndedEvent, x as ExtendResult, F as FishTtsModel, y as FreezeReadingFn, G as Governor, z as GovernorAction, H as GovernorConfig, I as GovernorSignal, J as GovernorState, K as GraceWindowClosedEvent, M as GraceWindowOpenEvent, N as GraceWindowState, O as IdleWarningEvent, P as InboundRtpCursor, Q as InboundRtpReading, R as KnownBehaviorState, S as LLMProvider, T as LLMSelection, U as LiveKitAvatarGrantState, V as LiveKitAvatarGrantStatus, W as LiveKitCapacityState, X as LiveKitConnectionStatus, Y as LiveKitSessionRequest, Z as LiveKitSessionStartResult, aX as LivePlaybackKeeper, _ as MAX_RECONNECT_ATTEMPTS, $ as MAX_SESSION_INSTRUCTIONS_CHARS, aY as MIC_LEASE_ENDED_TIMEOUT_MS, aZ as MicLease, a_ as NETWORK_QUALITY_POLICY, a$ as NetworkQualityStatus, b0 as PlayableVideoElement, a0 as ProxyClientOptions, a1 as QualityCap, a2 as RECONNECT_BACKOFF_MS, b1 as RealtimeAvatarCapacityError, b2 as RealtimeAvatarLiveKitRoom, b3 as RealtimeAvatarLiveKitRoomProps, a3 as RealtimeAvatarRequestOptions, a4 as RealtimeSessionApi, a5 as RealtimeSessionMedia, a6 as RealtimeSessionRoomSinks, a7 as ReconnectPolicy, a8 as ReconnectingEvent, a9 as RecoveryState, aa as RetryStep, ab as SendTurnOptions, ac as SessionBehavior, ad as SessionClip, ae as SessionClocks, af as SessionEndReason, ag as SessionLifecycleApi, ah as SessionLifecyclePhase, ai as SessionLifecyclePhaseKind, aj as SessionLifecycleRoomBridge, al as SessionReadinessFailure, am as SurfaceLayers, an as TranscriptSender, ao as TranscriptSenderOptions, ap as TurnState, aq as TurnTimeoutEvent, ar as UseAvatarQualityGovernorInput, as as UseLiveKitAvatarGrantInput, at as UseRealtimeSessionInput, au as UseSessionLifecycleInput, av as VoiceSpec, aw as VoiceSpecInput, ax as capacityErrorFromBusy, ay as capacityStateFromGrant, az as createProxyClient, aB as knownBehaviorStates, aC as mapTurnState, aD as readInboundRtp, aE as sessionBehaviorSchema, aF as sessionClipSchema, b4 as shouldReplayPendingTurn, aG as splitCallTranscript, aH as useAvatarAdaptivePlayoutDelay, aI as useAvatarCamera, aJ as useAvatarPlayoutDelay, aK as useAvatarQualityGovernor, aL as useCallTranscript, aM as useLiveKitAvatarGrant, aO as useMicLease, aP as useRealtimeSession, aQ as useReleaseMicLeaseOnTrackEnded, aR as useSessionLifecycle } from './proxy-client-BAY77sJZ.js';
 import { CSSProperties, ReactNode } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { R as RecordingArtifact } from './recording-DjswTx5B.js';
+import { R as RecordingArtifact } from './recording-ydFVySSd.js';
 export { D as DEFAULT_AVATAR_PLAYOUT_DELAY_SECONDS } from './playout-delay-CtRZdtsj.js';
 import 'zod';
 import 'livekit-client';
@@ -201,7 +201,7 @@ type RecordingPlaybackAsset = {
     recording: RecordingArtifact;
     url: string;
 };
-/** Each participant file carries only its own voice; one clock drives both files. */
+/** Participant files and separate track segments share one clock without mixing voices. */
 declare function RecordingPlayer({ assets, className }: {
     assets: readonly RecordingPlaybackAsset[];
     className?: string;

package/dist/react.js

@@ -2249,13 +2249,17 @@ var AVATAR_VIDEO_BADGE = {
 var AVATAR_VIDEO_BADGE_DOT = { width: 6, height: 6, borderRadius: 9999, background: "#34d399" };
 var AVATAR_VIDEO_OVERLAY = { position: "absolute", inset: 0, zIndex: 40 };
 var RECORDED_MEDIA_MODES = ["audio", "video", "audio_video"];
-var recordingModeSchema = z.enum(["off", ...RECORDED_MEDIA_MODES, "participants"]).describe("Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices.");
+var recordingModeSchema = z.enum(["off", ...RECORDED_MEDIA_MODES, "participants", "tracks"]).describe("Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices. tracks saves each published participant audio/video track separately; list recordings by session after capture.");
 var RECORDING_STATUSES = ["pending", "recording", "processing", "ready", "failed", "expired"];
 z.enum(RECORDING_STATUSES);
 var recordingParticipantSchema = z.object({
   participantIdentity: z.string().min(1).max(160),
   role: z.enum(["user", "avatar"])
 }).strict();
+var recordingMutedIntervalSchema = z.object({
+  startMs: z.number().int().min(0),
+  endMs: z.number().int().positive()
+}).strict().refine((interval) => interval.endMs > interval.startMs, "Muted interval must end after it starts");
 var recordingMetadataSchema = z.object({
   sessionId: z.string().min(1),
   recordingId: z.string().min(1),
@@ -2264,13 +2268,15 @@ var recordingMetadataSchema = z.object({
   retainedUntil: z.string().datetime({ offset: true }),
   participant: recordingParticipantSchema.optional(),
   mediaStartedAt: z.string().datetime({ offset: true }).optional(),
-  mediaEndedAt: z.string().datetime({ offset: true }).optional()
+  mediaEndedAt: z.string().datetime({ offset: true }).optional(),
+  mediaStartOffsetMs: z.number().int().min(0).optional().describe("First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero."),
+  mediaMutedIntervalsMs: z.array(recordingMutedIntervalSchema).optional().describe("Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals.")
 });
 var recordingArtifactSchema = z.discriminatedUnion("status", [
   recordingMetadataSchema.extend({ status: z.enum(["pending", "recording", "processing", "expired"]) }).strict(),
   recordingMetadataSchema.extend({
     status: z.literal("ready"),
-    mediaType: z.enum(["audio/mp4", "video/mp4"]),
+    mediaType: z.enum(["audio/mp4", "video/mp4", "audio/ogg", "video/webm"]),
     sizeBytes: z.number().int().positive(),
     durationMs: z.number().int().nonnegative().nullable()
   }).strict(),
@@ -4592,43 +4598,57 @@ function recordingTimeline(recordings) {
   if (new Set(recordings.map((recording) => recording.sessionId)).size > 1) throw new Error("Recordings belong to different sessions");
   if (new Set(recordings.map((recording) => recording.recordingId)).size !== recordings.length) throw new Error("Duplicate recording assets");
   const participants = recordings.filter((recording) => recording.participant && recording.status === "ready");
-  if (new Set(participants.map((recording) => recording.participant?.role)).size !== participants.length) throw new Error("Duplicate participant recordings");
   const entries = participants.map((recording) => {
     if (recording.status !== "ready" || !recording.mediaStartedAt || !recording.mediaEndedAt || recording.durationMs === null) {
       throw new Error("Recording media timing is unavailable");
     }
     const start = Date.parse(recording.mediaStartedAt);
     const end = Math.min(Date.parse(recording.mediaEndedAt), start + recording.durationMs);
-    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) throw new Error("Recording media timing is invalid");
-    return { recording, start, end };
+    const activeStart = start + (recording.mediaStartOffsetMs ?? 0);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || !Number.isFinite(activeStart) || end <= activeStart) throw new Error("Recording media timing is invalid");
+    return { recording, start, activeStart, end };
   });
   if (!entries.length) return null;
+  const laneEnds = /* @__PURE__ */ new Map();
+  for (const { recording, activeStart, end } of [...entries].sort((a, b) => a.activeStart - b.activeStart)) {
+    const kinds = recording.mode === "audio_video" ? ["audio", "video"] : [recording.mode];
+    for (const kind of kinds) {
+      const lane = `${recording.participant?.role}:${kind}`;
+      if (activeStart < (laneEnds.get(lane) ?? -Infinity)) throw new Error(`Duplicate participant ${kind} recordings overlap`);
+      laneEnds.set(lane, end);
+    }
+  }
   const originMs = Math.min(...entries.map((entry) => entry.start));
   return {
     originMs,
     durationMs: Math.max(...entries.map((entry) => entry.end)) - originMs,
-    entries: entries.map(({ recording, start, end }) => ({ recording, startMs: start - originMs, endMs: end - originMs }))
+    entries: entries.map(({ recording, start, activeStart, end }) => ({ recording, startMs: start - originMs, activeStartMs: activeStart - originMs, endMs: end - originMs }))
   };
 }
 function recordingPositions(timeline, positionMs) {
   return timeline.entries.map((entry) => ({
     recordingId: entry.recording.recordingId,
-    active: positionMs >= entry.startMs && positionMs < entry.endMs,
+    active: positionMs >= entry.activeStartMs && positionMs < entry.endMs,
     timeSeconds: Math.max(0, Math.min(positionMs, entry.endMs) - entry.startMs) / 1e3
   }));
 }
-function exhausted(element, seconds) {
-  return Number.isFinite(element.duration) && seconds >= element.duration || element.ended && seconds >= element.currentTime;
+function recordingVideoVisible(recording, timeSeconds) {
+  const mediaMs = timeSeconds * 1e3;
+  return recording.mode !== "audio" && !(recording.mediaMutedIntervalsMs ?? []).some(
+    (interval) => mediaMs >= interval.startMs && mediaMs < interval.endMs
+  );
 }
 function RecordingPlayer({ assets, className }) {
+  const timelineKey = JSON.stringify(assets.map((asset) => asset.recording));
   const timeline = useMemo(() => {
     try {
       return recordingTimeline(assets.map((asset) => asset.recording));
     } catch {
       return null;
     }
-  }, [assets]);
+  }, [timelineKey]);
   const media = useRef(/* @__PURE__ */ new Map());
+  const seeks = useRef(/* @__PURE__ */ new Map());
   const position = useRef(0);
   const anchor = useRef(null);
   const [displayPosition, setDisplayPosition] = useState(0);
@@ -4636,6 +4656,11 @@ function RecordingPlayer({ assets, className }) {
   const [buffering, setBuffering] = useState(false);
   const [error, setError] = useState("");
   const sourceKey = assets.map((asset) => `${asset.recording.recordingId}:${asset.url}`).join("|");
+  const seekMedia = (recordingId, element, seconds) => {
+    if (element.readyState < 1 || Math.abs(element.currentTime - seconds) <= 0.02) return;
+    seeks.current.set(recordingId, { seconds, retries: 0 });
+    element.currentTime = seconds;
+  };
   useEffect(() => {
     if (!timeline) return;
     const sessionId = timeline.entries[0].recording.sessionId;
@@ -4652,6 +4677,7 @@ function RecordingPlayer({ assets, className }) {
     let last = performance.now();
     let painted = last;
     const starting = /* @__PURE__ */ new Set();
+    const active = /* @__PURE__ */ new Set();
     const stopMedia = () => {
       for (const element of media.current.values()) element.pause();
     };
@@ -4668,19 +4694,23 @@ function RecordingPlayer({ assets, className }) {
       const states = recordingPositions(timeline, proposed);
       const waiting = playing && states.some((state) => {
         const element = media.current.get(state.recordingId);
-        return state.active && (!element || !exhausted(element, state.timeSeconds) && (element.readyState < 2 || element.seeking));
+        return state.active && (!element || (!element.ended || seeks.current.has(state.recordingId)) && (element.readyState < 2 || element.seeking));
       });
       setBuffering(waiting);
       if (!waiting) position.current = proposed;
       for (const state of recordingPositions(timeline, position.current)) {
         const element = media.current.get(state.recordingId);
         if (!element) continue;
-        if (!state.active || exhausted(element, state.timeSeconds)) {
+        if (!state.active) {
           element.pause();
+          active.delete(state.recordingId);
           continue;
         }
-        if (element.readyState >= 1 && Math.abs(element.currentTime - state.timeSeconds) > 0.08) {
-          element.currentTime = state.timeSeconds;
+        if (!active.has(state.recordingId)) seekMedia(state.recordingId, element, state.timeSeconds);
+        if (element.readyState >= 1) active.add(state.recordingId);
+        if (element.ended && !seeks.current.has(state.recordingId)) {
+          element.pause();
+          continue;
         }
         if (!playing || waiting) {
           element.pause();
@@ -4716,14 +4746,14 @@ function RecordingPlayer({ assets, className }) {
       stopMedia();
     };
   }, [timeline, playing, sourceKey]);
-  const activeIds = new Set(timeline ? recordingPositions(timeline, displayPosition).filter((state) => state.active).map((state) => state.recordingId) : []);
+  const positions = new Map(timeline ? recordingPositions(timeline, displayPosition).map((state) => [state.recordingId, state]) : []);
   const seek = (value) => {
     position.current = value;
     setDisplayPosition(value);
     if (timeline) for (const state of recordingPositions(timeline, value)) {
       const element = media.current.get(state.recordingId);
       if (!element) continue;
-      if (element.readyState >= 1) element.currentTime = state.timeSeconds;
+      seekMedia(state.recordingId, element, state.timeSeconds);
       if (!state.active) element.pause();
     }
   };
@@ -4737,8 +4767,8 @@ function RecordingPlayer({ assets, className }) {
     if (position.current >= timeline.durationMs) seek(0);
     for (const state of recordingPositions(timeline, position.current)) {
       const element = media.current.get(state.recordingId);
-      if (state.active && element && !exhausted(element, state.timeSeconds)) {
-        if (element.readyState >= 1) element.currentTime = state.timeSeconds;
+      if (state.active && element) {
+        seekMedia(state.recordingId, element, state.timeSeconds);
         void element.play().catch((cause) => {
           if (cause instanceof Error && cause.name === "AbortError") return;
           for (const current of media.current.values()) current.pause();
@@ -4752,6 +4782,8 @@ function RecordingPlayer({ assets, className }) {
   return /* @__PURE__ */ jsxs("div", { className, children: [
     /* @__PURE__ */ jsx("div", { style: { display: "grid", gridTemplateColumns: "repeat(auto-fit, minmax(min(100%, 240px), 1fr))", gap: 12 }, children: assets.map(({ recording, url }) => {
       if (!recording.participant) return null;
+      const state = positions.get(recording.recordingId);
+      const visible = Boolean(state?.active && recordingVideoVisible(recording, state.timeSeconds));
       const label = recording.participant.role === "user" ? "User" : "Character";
       const ref = (element) => {
         if (element) media.current.set(recording.recordingId, element);
@@ -4762,22 +4794,36 @@ function RecordingPlayer({ assets, className }) {
         setPlaying(false);
         setError("A recording could not load. Refresh access and try again.");
       };
-      return recording.mode !== "audio" ? /* @__PURE__ */ jsxs("figure", { hidden: !activeIds.has(recording.recordingId), style: { margin: 0 }, children: [
+      const onLoadedMetadata = (event) => {
+        const state2 = timeline && recordingPositions(timeline, position.current).find((item) => item.recordingId === recording.recordingId);
+        if (state2) seekMedia(recording.recordingId, event.currentTarget, state2.timeSeconds);
+      };
+      const onSeeked = (event) => {
+        const pending = seeks.current.get(recording.recordingId);
+        if (!pending) return;
+        if (Math.abs(event.currentTarget.currentTime - pending.seconds) > 0.08 && pending.retries < 2) {
+          pending.retries++;
+          event.currentTarget.currentTime = pending.seconds;
+        } else seeks.current.delete(recording.recordingId);
+      };
+      return recording.mode !== "audio" ? /* @__PURE__ */ jsxs("figure", { hidden: !visible, style: { margin: 0 }, children: [
         /* @__PURE__ */ jsx("figcaption", { children: label }),
         /* @__PURE__ */ jsx(
           "video",
           {
             ref,
             src: url,
+            muted: recording.mode === "video",
             playsInline: true,
             preload: "auto",
             onError,
-            hidden: !activeIds.has(recording.recordingId),
+            onLoadedMetadata,
+            onSeeked,
+            hidden: !visible,
             style: { width: "100%", maxHeight: 360, objectFit: "contain" }
           }
-        ),
-        !activeIds.has(recording.recordingId) ? /* @__PURE__ */ jsx("p", { children: "No recording at this time." }) : null
-      ] }, recording.recordingId) : /* @__PURE__ */ jsx("audio", { ref, src: url, preload: "auto", onError, "aria-label": `${label} audio` }, recording.recordingId);
+        )
+      ] }, recording.recordingId) : /* @__PURE__ */ jsx("audio", { ref, src: url, preload: "auto", onError, onLoadedMetadata, onSeeked, "aria-label": `${label} audio` }, recording.recordingId);
     }) }),
     /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 12 }, children: [
       /* @__PURE__ */ jsx("button", { type: "button", onClick: toggle, disabled: !timeline, style: { minHeight: 44, minWidth: 44 }, children: playing ? "Pause" : "Play" }),

package/dist/{recording-DjswTx5B.d.ts → recording-ydFVySSd.d.ts}

@@ -6,6 +6,7 @@ declare const recordingModeSchema: z.ZodEnum<{
     audio_video: "audio_video";
     off: "off";
     participants: "participants";
+    tracks: "tracks";
 }>;
 type RecordingMode = z.infer<typeof recordingModeSchema>;
 declare const recordingArtifactStatusSchema: z.ZodEnum<{
@@ -44,6 +45,11 @@ declare const recordingArtifactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strict>>;
     mediaStartedAt: z.ZodOptional<z.ZodString>;
     mediaEndedAt: z.ZodOptional<z.ZodString>;
+    mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+    mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+    }, z.core.$strict>>>;
     status: z.ZodEnum<{
         pending: "pending";
         recording: "recording";
@@ -69,10 +75,17 @@ declare const recordingArtifactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strict>>;
     mediaStartedAt: z.ZodOptional<z.ZodString>;
     mediaEndedAt: z.ZodOptional<z.ZodString>;
+    mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+    mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+    }, z.core.$strict>>>;
     status: z.ZodLiteral<"ready">;
     mediaType: z.ZodEnum<{
         "audio/mp4": "audio/mp4";
         "video/mp4": "video/mp4";
+        "audio/ogg": "audio/ogg";
+        "video/webm": "video/webm";
     }>;
     sizeBytes: z.ZodNumber;
     durationMs: z.ZodNullable<z.ZodNumber>;
@@ -95,6 +108,11 @@ declare const recordingArtifactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strict>>;
     mediaStartedAt: z.ZodOptional<z.ZodString>;
     mediaEndedAt: z.ZodOptional<z.ZodString>;
+    mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+    mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+    }, z.core.$strict>>>;
     status: z.ZodLiteral<"failed">;
     errorCode: z.ZodEnum<{
         recording_failed: "recording_failed";
@@ -128,6 +146,11 @@ declare const listRecordingsResponseSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodEnum<{
             pending: "pending";
             recording: "recording";
@@ -153,10 +176,17 @@ declare const listRecordingsResponseSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodLiteral<"ready">;
         mediaType: z.ZodEnum<{
             "audio/mp4": "audio/mp4";
             "video/mp4": "video/mp4";
+            "audio/ogg": "audio/ogg";
+            "video/webm": "video/webm";
         }>;
         sizeBytes: z.ZodNumber;
         durationMs: z.ZodNullable<z.ZodNumber>;
@@ -179,6 +209,11 @@ declare const listRecordingsResponseSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodLiteral<"failed">;
         errorCode: z.ZodEnum<{
             recording_failed: "recording_failed";

package/dist/recording.d.ts

@@ -1,5 +1,5 @@
-import { R as RecordingArtifact } from './recording-DjswTx5B.js';
-export { L as ListRecordingsQuery, a as ListRecordingsResponse, b as RecordingAccessResponse, c as RecordingArtifactStatus, d as RecordingMode, e as RecordingParticipant, l as listRecordingsQuerySchema, f as listRecordingsResponseSchema, r as recordingAccessResponseSchema, g as recordingArtifactSchema, h as recordingArtifactStatusSchema, i as recordingModeSchema, j as recordingParticipantSchema } from './recording-DjswTx5B.js';
+import { R as RecordingArtifact } from './recording-ydFVySSd.js';
+export { L as ListRecordingsQuery, a as ListRecordingsResponse, b as RecordingAccessResponse, c as RecordingArtifactStatus, d as RecordingMode, e as RecordingParticipant, l as listRecordingsQuerySchema, f as listRecordingsResponseSchema, r as recordingAccessResponseSchema, g as recordingArtifactSchema, h as recordingArtifactStatusSchema, i as recordingModeSchema, j as recordingParticipantSchema } from './recording-ydFVySSd.js';
 import 'zod';
 
 declare function recordingTimeline(recordings: readonly RecordingArtifact[]): {
@@ -13,7 +13,7 @@ declare function recordingTimeline(recordings: readonly RecordingArtifact[]): {
             createdAt: string;
             retainedUntil: string;
             status: "ready";
-            mediaType: "audio/mp4" | "video/mp4";
+            mediaType: "audio/mp4" | "video/mp4" | "audio/ogg" | "video/webm";
             sizeBytes: number;
             durationMs: number | null;
             participant?: {
@@ -22,8 +22,14 @@ declare function recordingTimeline(recordings: readonly RecordingArtifact[]): {
             } | undefined;
             mediaStartedAt?: string | undefined;
             mediaEndedAt?: string | undefined;
+            mediaStartOffsetMs?: number | undefined;
+            mediaMutedIntervalsMs?: {
+                startMs: number;
+                endMs: number;
+            }[] | undefined;
         };
         startMs: number;
+        activeStartMs: number;
         endMs: number;
     }[];
 } | null;

package/dist/recording.js

@@ -2,13 +2,17 @@ import { z } from 'zod';
 
 // ../http-client/src/generated/recording.ts
 var RECORDED_MEDIA_MODES = ["audio", "video", "audio_video"];
-var recordingModeSchema = z.enum(["off", ...RECORDED_MEDIA_MODES, "participants"]).describe("Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices.");
+var recordingModeSchema = z.enum(["off", ...RECORDED_MEDIA_MODES, "participants", "tracks"]).describe("Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices. tracks saves each published participant audio/video track separately; list recordings by session after capture.");
 var RECORDING_STATUSES = ["pending", "recording", "processing", "ready", "failed", "expired"];
 var recordingArtifactStatusSchema = z.enum(RECORDING_STATUSES);
 var recordingParticipantSchema = z.object({
   participantIdentity: z.string().min(1).max(160),
   role: z.enum(["user", "avatar"])
 }).strict();
+var recordingMutedIntervalSchema = z.object({
+  startMs: z.number().int().min(0),
+  endMs: z.number().int().positive()
+}).strict().refine((interval) => interval.endMs > interval.startMs, "Muted interval must end after it starts");
 var recordingMetadataSchema = z.object({
   sessionId: z.string().min(1),
   recordingId: z.string().min(1),
@@ -17,13 +21,15 @@ var recordingMetadataSchema = z.object({
   retainedUntil: z.string().datetime({ offset: true }),
   participant: recordingParticipantSchema.optional(),
   mediaStartedAt: z.string().datetime({ offset: true }).optional(),
-  mediaEndedAt: z.string().datetime({ offset: true }).optional()
+  mediaEndedAt: z.string().datetime({ offset: true }).optional(),
+  mediaStartOffsetMs: z.number().int().min(0).optional().describe("First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero."),
+  mediaMutedIntervalsMs: z.array(recordingMutedIntervalSchema).optional().describe("Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals.")
 });
 var recordingArtifactSchema = z.discriminatedUnion("status", [
   recordingMetadataSchema.extend({ status: z.enum(["pending", "recording", "processing", "expired"]) }).strict(),
   recordingMetadataSchema.extend({
     status: z.literal("ready"),
-    mediaType: z.enum(["audio/mp4", "video/mp4"]),
+    mediaType: z.enum(["audio/mp4", "video/mp4", "audio/ogg", "video/webm"]),
     sizeBytes: z.number().int().positive(),
     durationMs: z.number().int().nonnegative().nullable()
   }).strict(),
@@ -52,28 +58,37 @@ function recordingTimeline(recordings) {
   if (new Set(recordings.map((recording) => recording.sessionId)).size > 1) throw new Error("Recordings belong to different sessions");
   if (new Set(recordings.map((recording) => recording.recordingId)).size !== recordings.length) throw new Error("Duplicate recording assets");
   const participants = recordings.filter((recording) => recording.participant && recording.status === "ready");
-  if (new Set(participants.map((recording) => recording.participant?.role)).size !== participants.length) throw new Error("Duplicate participant recordings");
   const entries = participants.map((recording) => {
     if (recording.status !== "ready" || !recording.mediaStartedAt || !recording.mediaEndedAt || recording.durationMs === null) {
       throw new Error("Recording media timing is unavailable");
     }
     const start = Date.parse(recording.mediaStartedAt);
     const end = Math.min(Date.parse(recording.mediaEndedAt), start + recording.durationMs);
-    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) throw new Error("Recording media timing is invalid");
-    return { recording, start, end };
+    const activeStart = start + (recording.mediaStartOffsetMs ?? 0);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || !Number.isFinite(activeStart) || end <= activeStart) throw new Error("Recording media timing is invalid");
+    return { recording, start, activeStart, end };
   });
   if (!entries.length) return null;
+  const laneEnds = /* @__PURE__ */ new Map();
+  for (const { recording, activeStart, end } of [...entries].sort((a, b) => a.activeStart - b.activeStart)) {
+    const kinds = recording.mode === "audio_video" ? ["audio", "video"] : [recording.mode];
+    for (const kind of kinds) {
+      const lane = `${recording.participant?.role}:${kind}`;
+      if (activeStart < (laneEnds.get(lane) ?? -Infinity)) throw new Error(`Duplicate participant ${kind} recordings overlap`);
+      laneEnds.set(lane, end);
+    }
+  }
   const originMs = Math.min(...entries.map((entry) => entry.start));
   return {
     originMs,
     durationMs: Math.max(...entries.map((entry) => entry.end)) - originMs,
-    entries: entries.map(({ recording, start, end }) => ({ recording, startMs: start - originMs, endMs: end - originMs }))
+    entries: entries.map(({ recording, start, activeStart, end }) => ({ recording, startMs: start - originMs, activeStartMs: activeStart - originMs, endMs: end - originMs }))
   };
 }
 function recordingPositions(timeline, positionMs) {
   return timeline.entries.map((entry) => ({
     recordingId: entry.recording.recordingId,
-    active: positionMs >= entry.startMs && positionMs < entry.endMs,
+    active: positionMs >= entry.activeStartMs && positionMs < entry.endMs,
     timeSeconds: Math.max(0, Math.min(positionMs, entry.endMs) - entry.startMs) / 1e3
   }));
 }

package/dist/server.d.ts

@@ -1,4 +1,4 @@
 export { RealtimeAvatar, RealtimeAvatarError, RealtimeAvatarHttpError, RealtimeAvatarOptions, StartCallOptions, clipLibraryDeclarationSchema, verifyTranscript } from './index.js';
-export { h as Asset, g as AssetKind, A as Avatar, o as AvatarClip, c as AvatarSourceSwap, b as AvatarUpdate, p as CallConnection, C as CallMode, a as CallPolicy, q as CallQueued, r as ClipDeclaration, f as ClipLibrary, d as ClipLibraryDeclaration, s as ClipLibraryPlan, e as ClipLibraryUpdate, t as ClipSource, u as ContextMessage, n as CreditBalance, E as EndCallOptions, v as EndCallReason, w as ExternalLlm, k as ListRecordingsQuery, l as ListRecordingsResponse, i as ListSessionsOptions, L as LoopRedirect, m as RecordingAccessResponse, R as RecordingArtifact, x as RecordingArtifactStatus, y as RecordingMode, S as StartCallResult, T as TranscriptPayload, j as UsageSession, U as UsageSessionPage, V as VideoPolicy, z as isQueued, B as listRecordingsResponseSchema, D as recordingAccessResponseSchema, F as recordingArtifactSchema, G as recordingModeSchema } from './types-D_s7ff7w.js';
+export { h as Asset, g as AssetKind, A as Avatar, o as AvatarClip, c as AvatarSourceSwap, b as AvatarUpdate, p as CallConnection, C as CallMode, a as CallPolicy, q as CallQueued, r as ClipDeclaration, f as ClipLibrary, d as ClipLibraryDeclaration, s as ClipLibraryPlan, e as ClipLibraryUpdate, t as ClipSource, u as ContextMessage, n as CreditBalance, E as EndCallOptions, v as EndCallReason, w as ExternalLlm, k as ListRecordingsQuery, l as ListRecordingsResponse, i as ListSessionsOptions, L as LoopRedirect, m as RecordingAccessResponse, R as RecordingArtifact, x as RecordingArtifactStatus, y as RecordingMode, S as StartCallResult, T as TranscriptPayload, j as UsageSession, U as UsageSessionPage, V as VideoPolicy, z as isQueued, B as listRecordingsResponseSchema, D as recordingAccessResponseSchema, F as recordingArtifactSchema, G as recordingModeSchema } from './types-kgmS7ECd.js';
 import './connection-history.js';
 import 'zod';

package/dist/server.js

@@ -1,2 +1,2 @@
-export { RealtimeAvatar, RealtimeAvatarError, RealtimeAvatarHttpError, clipLibraryDeclarationSchema, isQueued, listRecordingsResponseSchema, recordingAccessResponseSchema, recordingArtifactSchema, recordingModeSchema, verifyTranscript } from './chunk-YR5NJTEO.js';
+export { RealtimeAvatar, RealtimeAvatarError, RealtimeAvatarHttpError, clipLibraryDeclarationSchema, isQueued, listRecordingsResponseSchema, recordingAccessResponseSchema, recordingArtifactSchema, recordingModeSchema, verifyTranscript } from './chunk-W4DGBG4Z.js';
 import './chunk-MCIXU6XP.js';

package/dist/tanstack-start.d.ts

@@ -1,5 +1,5 @@
-import { P as ProxyConfig } from './types-BH9O5leB.js';
-import './types-D_s7ff7w.js';
+import { P as ProxyConfig } from './types-lgS4Z9rd.js';
+import './types-kgmS7ECd.js';
 import 'zod';
 
 /**

package/dist/tanstack-start.js

@@ -1,5 +1,5 @@
-import { createProxyHandler } from './chunk-SP5SYYSS.js';
-import './chunk-YR5NJTEO.js';
+import { createProxyHandler } from './chunk-QBOIOZ3O.js';
+import './chunk-W4DGBG4Z.js';
 import './chunk-MCIXU6XP.js';
 
 // src/tanstack-start.ts

package/dist/{types-D_s7ff7w.d.ts → types-kgmS7ECd.d.ts}

@@ -176,10 +176,10 @@ interface components {
              */
             content_policy?: "minor-sexual-content-v1";
             /**
-             * @description Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices.
+             * @description Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices. tracks saves each published participant audio/video track separately; list recordings by session after capture.
              * @enum {string}
              */
-            recording?: "off" | "audio" | "video" | "audio_video" | "participants";
+            recording?: "off" | "audio" | "video" | "audio_video" | "participants" | "tracks";
             connection_history?: boolean;
             client_metadata?: {
                 [key: string]: string;
@@ -264,6 +264,13 @@ interface components {
                 mediaStartedAt?: string;
                 /** Format: date-time */
                 mediaEndedAt?: string;
+                /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+                mediaStartOffsetMs?: number;
+                /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+                mediaMutedIntervalsMs?: {
+                    startMs: number;
+                    endMs: number;
+                }[];
                 /** @enum {string} */
                 status: "pending" | "recording" | "processing" | "expired";
             } | {
@@ -284,10 +291,17 @@ interface components {
                 mediaStartedAt?: string;
                 /** Format: date-time */
                 mediaEndedAt?: string;
+                /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+                mediaStartOffsetMs?: number;
+                /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+                mediaMutedIntervalsMs?: {
+                    startMs: number;
+                    endMs: number;
+                }[];
                 /** @constant */
                 status: "ready";
                 /** @enum {string} */
-                mediaType: "audio/mp4" | "video/mp4";
+                mediaType: "audio/mp4" | "video/mp4" | "audio/ogg" | "video/webm";
                 sizeBytes: number;
                 durationMs: number | null;
             } | {
@@ -308,16 +322,23 @@ interface components {
                 mediaStartedAt?: string;
                 /** Format: date-time */
                 mediaEndedAt?: string;
+                /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+                mediaStartOffsetMs?: number;
+                /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+                mediaMutedIntervalsMs?: {
+                    startMs: number;
+                    endMs: number;
+                }[];
                 /** @constant */
                 status: "failed";
                 /** @enum {string} */
                 errorCode: "recording_failed" | "recording_unavailable";
             };
             /**
-             * @description Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices.
+             * @description Server-owned recording policy; omitted means off. Legacy audio includes user and avatar audio. participants saves one continuous audio/video file per participant, without mixing their voices. tracks saves each published participant audio/video track separately; list recordings by session after capture.
              * @enum {string}
              */
-            readonly recording_mode?: "off" | "audio" | "video" | "audio_video" | "participants";
+            readonly recording_mode?: "off" | "audio" | "video" | "audio_video" | "participants" | "tracks";
             readonly recordings?: ({
                 sessionId: string;
                 recordingId: string;
@@ -336,6 +357,13 @@ interface components {
                 mediaStartedAt?: string;
                 /** Format: date-time */
                 mediaEndedAt?: string;
+                /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+                mediaStartOffsetMs?: number;
+                /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+                mediaMutedIntervalsMs?: {
+                    startMs: number;
+                    endMs: number;
+                }[];
                 /** @enum {string} */
                 status: "pending" | "recording" | "processing" | "expired";
             } | {
@@ -356,10 +384,17 @@ interface components {
                 mediaStartedAt?: string;
                 /** Format: date-time */
                 mediaEndedAt?: string;
+                /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+                mediaStartOffsetMs?: number;
+                /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+                mediaMutedIntervalsMs?: {
+                    startMs: number;
+                    endMs: number;
+                }[];
                 /** @constant */
                 status: "ready";
                 /** @enum {string} */
-                mediaType: "audio/mp4" | "video/mp4";
+                mediaType: "audio/mp4" | "video/mp4" | "audio/ogg" | "video/webm";
                 sizeBytes: number;
                 durationMs: number | null;
             } | {
@@ -380,6 +415,13 @@ interface components {
                 mediaStartedAt?: string;
                 /** Format: date-time */
                 mediaEndedAt?: string;
+                /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+                mediaStartOffsetMs?: number;
+                /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+                mediaMutedIntervalsMs?: {
+                    startMs: number;
+                    endMs: number;
+                }[];
                 /** @constant */
                 status: "failed";
                 /** @enum {string} */
@@ -919,6 +961,13 @@ interface components {
             mediaStartedAt?: string;
             /** Format: date-time */
             mediaEndedAt?: string;
+            /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+            mediaStartOffsetMs?: number;
+            /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+            mediaMutedIntervalsMs?: {
+                startMs: number;
+                endMs: number;
+            }[];
             /** @enum {string} */
             status: "pending" | "recording" | "processing" | "expired";
         } | {
@@ -939,10 +988,17 @@ interface components {
             mediaStartedAt?: string;
             /** Format: date-time */
             mediaEndedAt?: string;
+            /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+            mediaStartOffsetMs?: number;
+            /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+            mediaMutedIntervalsMs?: {
+                startMs: number;
+                endMs: number;
+            }[];
             /** @constant */
             status: "ready";
             /** @enum {string} */
-            mediaType: "audio/mp4" | "video/mp4";
+            mediaType: "audio/mp4" | "video/mp4" | "audio/ogg" | "video/webm";
             sizeBytes: number;
             durationMs: number | null;
         } | {
@@ -963,6 +1019,13 @@ interface components {
             mediaStartedAt?: string;
             /** Format: date-time */
             mediaEndedAt?: string;
+            /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+            mediaStartOffsetMs?: number;
+            /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+            mediaMutedIntervalsMs?: {
+                startMs: number;
+                endMs: number;
+            }[];
             /** @constant */
             status: "failed";
             /** @enum {string} */
@@ -987,6 +1050,13 @@ interface components {
                 mediaStartedAt?: string;
                 /** Format: date-time */
                 mediaEndedAt?: string;
+                /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+                mediaStartOffsetMs?: number;
+                /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+                mediaMutedIntervalsMs?: {
+                    startMs: number;
+                    endMs: number;
+                }[];
                 /** @enum {string} */
                 status: "pending" | "recording" | "processing" | "expired";
             } | {
@@ -1007,10 +1077,17 @@ interface components {
                 mediaStartedAt?: string;
                 /** Format: date-time */
                 mediaEndedAt?: string;
+                /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+                mediaStartOffsetMs?: number;
+                /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+                mediaMutedIntervalsMs?: {
+                    startMs: number;
+                    endMs: number;
+                }[];
                 /** @constant */
                 status: "ready";
                 /** @enum {string} */
-                mediaType: "audio/mp4" | "video/mp4";
+                mediaType: "audio/mp4" | "video/mp4" | "audio/ogg" | "video/webm";
                 sizeBytes: number;
                 durationMs: number | null;
             } | {
@@ -1031,6 +1108,13 @@ interface components {
                 mediaStartedAt?: string;
                 /** Format: date-time */
                 mediaEndedAt?: string;
+                /** @description First playable native media timestamp relative to mediaStartedAt. Playback retains this offset; it does not reset the file clock to zero. */
+                mediaStartOffsetMs?: number;
+                /** @description Intervals of hidden camera video relative to mediaStartedAt, using native media timestamps. Audio playback continues through these intervals. */
+                mediaMutedIntervalsMs?: {
+                    startMs: number;
+                    endMs: number;
+                }[];
                 /** @constant */
                 status: "failed";
                 /** @enum {string} */
@@ -1323,6 +1407,7 @@ declare const recordingModeSchema: z.ZodEnum<{
     video: "video";
     audio_video: "audio_video";
     participants: "participants";
+    tracks: "tracks";
 }>;
 type RecordingMode = z.infer<typeof recordingModeSchema>;
 declare const recordingArtifactStatusSchema: z.ZodEnum<{
@@ -1353,6 +1438,11 @@ declare const recordingArtifactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strict>>;
     mediaStartedAt: z.ZodOptional<z.ZodString>;
     mediaEndedAt: z.ZodOptional<z.ZodString>;
+    mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+    mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+    }, z.core.$strict>>>;
     status: z.ZodEnum<{
         pending: "pending";
         recording: "recording";
@@ -1378,10 +1468,17 @@ declare const recordingArtifactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strict>>;
     mediaStartedAt: z.ZodOptional<z.ZodString>;
     mediaEndedAt: z.ZodOptional<z.ZodString>;
+    mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+    mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+    }, z.core.$strict>>>;
     status: z.ZodLiteral<"ready">;
     mediaType: z.ZodEnum<{
         "audio/mp4": "audio/mp4";
         "video/mp4": "video/mp4";
+        "audio/ogg": "audio/ogg";
+        "video/webm": "video/webm";
     }>;
     sizeBytes: z.ZodNumber;
     durationMs: z.ZodNullable<z.ZodNumber>;
@@ -1404,6 +1501,11 @@ declare const recordingArtifactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strict>>;
     mediaStartedAt: z.ZodOptional<z.ZodString>;
     mediaEndedAt: z.ZodOptional<z.ZodString>;
+    mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+    mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+    }, z.core.$strict>>>;
     status: z.ZodLiteral<"failed">;
     errorCode: z.ZodEnum<{
         recording_failed: "recording_failed";
@@ -1437,6 +1539,11 @@ declare const listRecordingsResponseSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodEnum<{
             pending: "pending";
             recording: "recording";
@@ -1462,10 +1569,17 @@ declare const listRecordingsResponseSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodLiteral<"ready">;
         mediaType: z.ZodEnum<{
             "audio/mp4": "audio/mp4";
             "video/mp4": "video/mp4";
+            "audio/ogg": "audio/ogg";
+            "video/webm": "video/webm";
         }>;
         sizeBytes: z.ZodNumber;
         durationMs: z.ZodNullable<z.ZodNumber>;
@@ -1488,6 +1602,11 @@ declare const listRecordingsResponseSchema: z.ZodObject<{
         }, z.core.$strict>>;
         mediaStartedAt: z.ZodOptional<z.ZodString>;
         mediaEndedAt: z.ZodOptional<z.ZodString>;
+        mediaStartOffsetMs: z.ZodOptional<z.ZodNumber>;
+        mediaMutedIntervalsMs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+        }, z.core.$strict>>>;
         status: z.ZodLiteral<"failed">;
         errorCode: z.ZodEnum<{
             recording_failed: "recording_failed";

package/dist/{types-BH9O5leB.d.ts → types-lgS4Z9rd.d.ts}

@@ -1,4 +1,4 @@
-import { C as CallMode, a as CallPolicy } from './types-D_s7ff7w.js';
+import { C as CallMode, a as CallPolicy } from './types-kgmS7ECd.js';
 
 /** The three things a caller can ask the proxy to do. Gate on these, not on URLs. */
 type ProxyOperation = "connect" | "end" | "avatars" | "credits";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "realtime-avatar",
-  "version": "0.27.2",
+  "version": "0.27.3",
   "description": "Realtime Avatar SDK. `realtime-avatar` and the route adapters hold your API key and are server-only; `realtime-avatar/react`, `/browser` and `/tools` never can — importing a server entry into a browser build throws at bundle time.",
   "license": "MIT",
   "author": "The Influence Company",