realtime-avatar 0.27.1 → 0.27.3

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(),
@@ -2333,6 +2339,8 @@ var transcriptionOptionsSchema = z.object({
   languageCodes: transcriptionWireSchema.shape.language_codes,
   customVocabulary: transcriptionWireSchema.shape.custom_vocabulary
 }).strict();
+var schema02 = z.enum(["minor-sexual-content-v1"]);
+var contentPolicySchema = schema02;
 
 // ../client/src/wire.ts
 var DEFAULT_AVATAR_ID = "maria";
@@ -2499,7 +2507,8 @@ z.object({
   support_edits: sessionSupportEditsSchema.optional(),
   transcript_webhook: transcriptWebhookSchema.optional(),
   client_metadata: clientMetadataSchema.optional(),
-  connection_history: z.boolean().optional()
+  connection_history: z.boolean().optional(),
+  content_policy: contentPolicySchema.optional()
 }).strict().superRefine((value, ctx) => {
   if (value.support_edits && value.render_backend === "generative") {
     ctx.addIssue({
@@ -2567,7 +2576,8 @@ z.object({
   supportEdits: sessionSupportEditsSchema.optional(),
   transcriptWebhook: transcriptWebhookSchema.optional(),
   clientMetadata: clientMetadataSchema.optional(),
-  connectionHistory: z.boolean().optional()
+  connectionHistory: z.boolean().optional(),
+  contentPolicy: contentPolicySchema.optional()
 }).strict();
 z.object({
   recording: recordingArtifactSchema.optional(),
@@ -4588,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);
@@ -4632,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;
@@ -4648,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();
     };
@@ -4664,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();
@@ -4712,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();
     }
   };
@@ -4733,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();
@@ -4748,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);
@@ -4758,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-6MUqx800.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-4IEGR75H.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-JtCwa0Ip.js';
-import './types-6MUqx800.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-DOHZ365B.js';
-import './chunk-4IEGR75H.js';
+import { createProxyHandler } from './chunk-QBOIOZ3O.js';
+import './chunk-W4DGBG4Z.js';
 import './chunk-MCIXU6XP.js';
 
 // src/tanstack-start.ts