@taskp3/react 0.1.0 → 0.1.2

package/dist/use-recorder-controller.js

@@ -1,14 +1,15 @@
 "use strict";
 /**
- * Simple screen recorder: getDisplayMedia → one MediaRecorder → chunks → blob on stop.
- * Plus pause/resume. No camera PiP or audio mixing. Finalization starts after stop,
- * but preview becomes available immediately so optimization can continue in the background.
+ * Screen recorder: capture a window-oriented display stream, mix in microphone audio
+ * when available, and finalize after stop. Preview becomes available immediately,
+ * while attach stays disabled until finalization finishes.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useRecorderController = useRecorderController;
 const react_1 = require("react");
 const finalizeRecordingInWorker_1 = require("./recorder/finalizeRecordingInWorker");
 const DEFAULT_MAX_MS = 5 * 60 * 1000;
+const DEFAULT_CAMERA_BITRATE = 500000;
 const MIME = typeof MediaRecorder !== "undefined" && MediaRecorder.isTypeSupported("video/webm;codecs=vp9")
     ? "video/webm;codecs=vp9"
     : "video/webm";
@@ -17,17 +18,201 @@ function isSupported() {
         typeof MediaRecorder !== "undefined" &&
         !!navigator.mediaDevices?.getDisplayMedia);
 }
+function buildDisplayMediaOptions() {
+    return {
+        video: true,
+        audio: true,
+        preferCurrentTab: false,
+        selfBrowserSurface: "exclude",
+        surfaceSwitching: "exclude",
+        systemAudio: "include",
+        windowAudio: "window",
+        monitorTypeSurfaces: "include",
+    };
+}
+function createMicrophoneCaptureError(message) {
+    const error = new Error(message);
+    error.name = "MicrophoneCaptureError";
+    return error;
+}
+function createCameraCaptureError(message) {
+    const error = new Error(message);
+    error.name = "CameraCaptureError";
+    return error;
+}
+function describeCameraAccessFailure(error) {
+    const errorName = error instanceof Error ? error.name : "";
+    if (errorName === "NotAllowedError" || errorName === "SecurityError") {
+        return "Camera recording is enabled, but camera access was blocked. Allow camera access in Firefox and macOS Settings, then try again.";
+    }
+    if (errorName === "NotFoundError" || errorName === "DevicesNotFoundError") {
+        return "Camera recording is enabled, but no camera device was found. Connect a camera, make sure Firefox can see it, or turn off camera recording.";
+    }
+    if (errorName === "NotReadableError" || errorName === "TrackStartError") {
+        return "Camera recording is enabled, but the camera could not be opened. Another app may already be using it.";
+    }
+    if (errorName === "OverconstrainedError") {
+        return "Camera recording is enabled, but Firefox rejected the requested camera settings. Try again or use a different camera.";
+    }
+    return "Camera recording is enabled, but camera access failed. Allow camera access or turn off camera recording.";
+}
+async function tryAcquireMicrophone(required) {
+    if (!required) {
+        return null;
+    }
+    try {
+        const microphoneStream = await navigator.mediaDevices.getUserMedia({
+            audio: {
+                echoCancellation: true,
+                noiseSuppression: true,
+                autoGainControl: true,
+            },
+            video: false,
+        });
+        const microphoneTrack = microphoneStream.getAudioTracks()[0];
+        if (!microphoneTrack || microphoneTrack.readyState !== "live") {
+            microphoneStream.getTracks().forEach((track) => track.stop());
+            throw createMicrophoneCaptureError("Microphone recording is enabled, but no working microphone input was found.");
+        }
+        return microphoneStream;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "MicrophoneCaptureError") {
+            throw error;
+        }
+        throw createMicrophoneCaptureError("Microphone recording is enabled, but microphone access failed. Allow microphone access or turn off microphone recording.");
+    }
+}
+async function tryAcquireCamera(required) {
+    if (!required) {
+        return null;
+    }
+    try {
+        const videoInputs = await navigator.mediaDevices
+            .enumerateDevices()
+            .then((devices) => devices.filter((device) => device.kind === "videoinput"))
+            .catch(() => []);
+        if (videoInputs.length === 0) {
+            throw createCameraCaptureError("Camera recording is enabled, but no camera device was found. Connect a camera, make sure Firefox can see it, or turn off camera recording.");
+        }
+        const cameraStream = await navigator.mediaDevices.getUserMedia({
+            video: true,
+            audio: false,
+        });
+        const cameraTrack = cameraStream.getVideoTracks()[0];
+        if (!cameraTrack || cameraTrack.readyState !== "live") {
+            cameraStream.getTracks().forEach((track) => track.stop());
+            throw createCameraCaptureError("Camera recording is enabled, but no working camera input was found.");
+        }
+        cameraTrack
+            .applyConstraints({
+            width: { ideal: 320 },
+            height: { ideal: 240 },
+        })
+            .catch(() => { });
+        return cameraStream;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "CameraCaptureError") {
+            throw error;
+        }
+        throw createCameraCaptureError(describeCameraAccessFailure(error));
+    }
+}
+function createVideoRecorder(stream, bitsPerSecond) {
+    const candidates = [MIME, "video/webm;codecs=vp8", "video/webm"].filter((value, index, values) => values.indexOf(value) === index);
+    for (const mimeType of candidates) {
+        if (!MediaRecorder.isTypeSupported(mimeType))
+            continue;
+        try {
+            return new MediaRecorder(stream, { mimeType, videoBitsPerSecond: bitsPerSecond });
+        }
+        catch {
+            // Try the next supported candidate.
+        }
+    }
+    return new MediaRecorder(stream, { videoBitsPerSecond: bitsPerSecond });
+}
+function createRecordingStream(displayStream, microphoneStream) {
+    const tracks = [...displayStream.getVideoTracks()];
+    const audioTracks = [
+        ...displayStream.getAudioTracks(),
+        ...(microphoneStream?.getAudioTracks() ?? []),
+    ];
+    if (audioTracks.length === 0) {
+        return {
+            stream: new MediaStream(tracks),
+            release: () => { },
+        };
+    }
+    const ctx = new AudioContext();
+    const dest = ctx.createMediaStreamDestination();
+    for (const track of audioTracks) {
+        const source = ctx.createMediaStreamSource(new MediaStream([track]));
+        source.connect(dest);
+    }
+    tracks.push(...dest.stream.getAudioTracks());
+    return {
+        stream: new MediaStream(tracks),
+        release: () => {
+            ctx.close().catch(() => { });
+        },
+    };
+}
+function toError(error, fallbackMessage) {
+    return error instanceof Error ? error : new Error(fallbackMessage);
+}
+function getFinalizationHints(displayStream, microphoneStream, cameraEnabled, pipPosition, pipShape) {
+    const videoTrack = displayStream.getVideoTracks()[0];
+    const settings = videoTrack?.getSettings();
+    return {
+        hasAudio: displayStream.getAudioTracks().length > 0
+            || (microphoneStream?.getAudioTracks().length ?? 0) > 0,
+        width: typeof settings?.width === "number" && settings.width > 0
+            ? settings.width
+            : undefined,
+        height: typeof settings?.height === "number" && settings.height > 0
+            ? settings.height
+            : undefined,
+        cameraOverlayEnabled: cameraEnabled || undefined,
+        cameraOverlayPosition: cameraEnabled ? pipPosition : undefined,
+        cameraOverlayShape: cameraEnabled ? pipShape : undefined,
+    };
+}
 function useRecorderController(options = {}) {
-    const { maxDurationMs = DEFAULT_MAX_MS, videoBitsPerSecond = 2500000 } = options;
+    const { maxDurationMs = DEFAULT_MAX_MS, videoBitsPerSecond = 2500000, cameraBitsPerSecond = DEFAULT_CAMERA_BITRATE, defaultMicrophoneEnabled = true, microphoneEnabled: controlledMicrophoneEnabled, defaultCameraEnabled = false, cameraEnabled: controlledCameraEnabled, pipPosition = "bottom-right", pipShape = "circle", } = options;
     const [state, setState] = (0, react_1.useState)("idle");
     const [duration, setDuration] = (0, react_1.useState)(0);
     const [previewUrl, setPreviewUrl] = (0, react_1.useState)(null);
     const [cameraPreviewUrl, setCameraPreviewUrl] = (0, react_1.useState)(null);
+    const [liveCameraStream, setLiveCameraStream] = (0, react_1.useState)(null);
     const [error, setError] = (0, react_1.useState)(null);
+    const [microphoneError, setMicrophoneError] = (0, react_1.useState)(null);
+    const [cameraError, setCameraError] = (0, react_1.useState)(null);
     const [isFinalizing, setIsFinalizing] = (0, react_1.useState)(false);
+    const [uncontrolledMicrophoneEnabled, setUncontrolledMicrophoneEnabled] = (0, react_1.useState)(defaultMicrophoneEnabled);
+    const [uncontrolledCameraEnabled, setUncontrolledCameraEnabled] = (0, react_1.useState)(defaultCameraEnabled);
+    const microphoneEnabled = controlledMicrophoneEnabled ?? uncontrolledMicrophoneEnabled;
+    const cameraEnabled = controlledCameraEnabled ?? uncontrolledCameraEnabled;
+    const setMicrophoneEnabled = (0, react_1.useCallback)((enabled) => {
+        if (controlledMicrophoneEnabled === undefined) {
+            setUncontrolledMicrophoneEnabled(enabled);
+        }
+    }, [controlledMicrophoneEnabled]);
+    const setCameraEnabled = (0, react_1.useCallback)((enabled) => {
+        if (controlledCameraEnabled === undefined) {
+            setUncontrolledCameraEnabled(enabled);
+        }
+    }, [controlledCameraEnabled]);
     const streamRef = (0, react_1.useRef)(null);
+    const displayStreamRef = (0, react_1.useRef)(null);
+    const microphoneStreamRef = (0, react_1.useRef)(null);
+    const cameraStreamRef = (0, react_1.useRef)(null);
+    const releaseAudioRef = (0, react_1.useRef)(null);
     const recorderRef = (0, react_1.useRef)(null);
+    const cameraRecorderRef = (0, react_1.useRef)(null);
     const chunksRef = (0, react_1.useRef)([]);
+    const cameraChunksRef = (0, react_1.useRef)([]);
     const blobRef = (0, react_1.useRef)(null);
     const blobMetadataRef = (0, react_1.useRef)(null);
     const finalizePromiseRef = (0, react_1.useRef)(null);
@@ -49,14 +234,41 @@ function useRecorderController(options = {}) {
         }
         streamRef.current?.getTracks().forEach((t) => t.stop());
         streamRef.current = null;
+        displayStreamRef.current?.getTracks().forEach((t) => t.stop());
+        displayStreamRef.current = null;
+        microphoneStreamRef.current?.getTracks().forEach((t) => t.stop());
+        microphoneStreamRef.current = null;
+        cameraStreamRef.current?.getTracks().forEach((t) => t.stop());
+        cameraStreamRef.current = null;
+        releaseAudioRef.current?.();
+        releaseAudioRef.current = null;
         recorderRef.current = null;
+        cameraRecorderRef.current = null;
+        setLiveCameraStream(null);
     }, []);
-    const buildFallbackMetadata = (0, react_1.useCallback)((blob) => ({
+    const buildFallbackMetadata = (0, react_1.useCallback)((blob, conversionReason) => ({
         durationSeconds: Math.max(1, Math.round(Math.max(elapsedMsRef.current, 1) / 1000)),
         mimeType: blob.type || "video/webm",
         fileExtension: blob.type.includes("mp4") ? "mp4" : "webm",
         conversionMode: "passthrough",
+        conversionReason,
     }), []);
+    const setPreviewBlob = (0, react_1.useCallback)((blob) => {
+        setPreviewUrl((currentUrl) => {
+            if (currentUrl) {
+                URL.revokeObjectURL(currentUrl);
+            }
+            return blob ? URL.createObjectURL(blob) : null;
+        });
+    }, []);
+    const setCameraPreviewBlob = (0, react_1.useCallback)((blob) => {
+        setCameraPreviewUrl((currentUrl) => {
+            if (currentUrl) {
+                URL.revokeObjectURL(currentUrl);
+            }
+            return blob ? URL.createObjectURL(blob) : null;
+        });
+    }, []);
     const scheduleMaxTimer = (0, react_1.useCallback)(() => {
         if (maxTimerRef.current) {
             clearTimeout(maxTimerRef.current);
@@ -70,7 +282,9 @@ function useRecorderController(options = {}) {
         cleanup();
         if (previewUrl)
             URL.revokeObjectURL(previewUrl);
-    }, [cleanup, previewUrl]);
+        if (cameraPreviewUrl)
+            URL.revokeObjectURL(cameraPreviewUrl);
+    }, [cameraPreviewUrl, cleanup, previewUrl]);
     const start = (0, react_1.useCallback)(async () => {
         if (!isSupported()) {
             setError(new Error("Screen recording is not supported"));
@@ -78,12 +292,12 @@ function useRecorderController(options = {}) {
             return;
         }
         setError(null);
+        setMicrophoneError(null);
+        setCameraError(null);
         discardingRef.current = false;
-        if (previewUrl) {
-            URL.revokeObjectURL(previewUrl);
-            setPreviewUrl(null);
-        }
-        setCameraPreviewUrl(null);
+        setPreviewBlob(null);
+        setCameraPreviewBlob(null);
+        setLiveCameraStream(null);
         blobRef.current = null;
         blobMetadataRef.current = null;
         finalizePromiseRef.current = null;
@@ -91,24 +305,45 @@ function useRecorderController(options = {}) {
         setIsFinalizing(false);
         setState("requesting");
         try {
-            const stream = await navigator.mediaDevices.getDisplayMedia({
-                video: true,
-                audio: true,
-            });
+            const displayStream = await navigator.mediaDevices.getDisplayMedia(buildDisplayMediaOptions());
+            const microphoneStream = await tryAcquireMicrophone(microphoneEnabled);
+            const cameraStream = await tryAcquireCamera(cameraEnabled);
+            const { stream, release } = createRecordingStream(displayStream, microphoneStream);
+            const finalizationHints = getFinalizationHints(displayStream, microphoneStream, cameraEnabled, pipPosition, pipShape);
+            displayStreamRef.current = displayStream;
+            microphoneStreamRef.current = microphoneStream;
+            cameraStreamRef.current = cameraStream;
+            releaseAudioRef.current = release;
             streamRef.current = stream;
-            const recorder = new MediaRecorder(stream, {
-                mimeType: MIME,
-                videoBitsPerSecond: videoBitsPerSecond ?? 2500000,
-            });
+            setLiveCameraStream(cameraStream ? new MediaStream(cameraStream.getVideoTracks()) : null);
+            const recorder = createVideoRecorder(stream, videoBitsPerSecond ?? 2500000);
+            const cameraRecorder = cameraStream && cameraStream.getVideoTracks().length > 0
+                ? createVideoRecorder(new MediaStream(cameraStream.getVideoTracks()), cameraBitsPerSecond)
+                : null;
             recorderRef.current = recorder;
+            cameraRecorderRef.current = cameraRecorder;
             chunksRef.current = [];
+            cameraChunksRef.current = [];
             recorder.ondataavailable = (e) => {
                 if (discardingRef.current)
                     return;
                 if (e.data.size > 0)
                     chunksRef.current.push(e.data);
             };
-            recorder.onstop = async () => {
+            cameraRecorder?.addEventListener("dataavailable", (e) => {
+                if (discardingRef.current)
+                    return;
+                if (e.data.size > 0)
+                    cameraChunksRef.current.push(e.data);
+            });
+            let screenStopped = false;
+            let cameraStopped = cameraRecorder == null;
+            let finalizationStarted = false;
+            const maybeFinalizeStoppedRecorders = async () => {
+                if (finalizationStarted || !screenStopped || !cameraStopped) {
+                    return;
+                }
+                finalizationStarted = true;
                 cleanup();
                 if (discardingRef.current) {
                     discardingRef.current = false;
@@ -120,14 +355,35 @@ function useRecorderController(options = {}) {
                 const chunks = chunksRef.current;
                 const type = chunks[0]?.type || MIME.split(";")[0];
                 const rawBlob = new Blob(chunks, { type });
-                const previewObjectUrl = URL.createObjectURL(rawBlob);
+                const cameraType = cameraChunksRef.current[0]?.type || cameraRecorder?.mimeType || MIME;
+                const rawCameraBlob = cameraChunksRef.current.length > 0
+                    ? new Blob(cameraChunksRef.current, { type: cameraType.split(";")[0] })
+                    : null;
+                if (cameraEnabled && !rawCameraBlob) {
+                    setError(new Error("Camera recording was enabled, but the camera overlay could not be captured."));
+                    setState("error");
+                    return;
+                }
                 blobRef.current = rawBlob;
-                blobMetadataRef.current = buildFallbackMetadata(rawBlob);
-                setPreviewUrl(previewObjectUrl);
+                blobMetadataRef.current = {
+                    ...buildFallbackMetadata(rawBlob),
+                    cameraOverlayEnabled: cameraEnabled || undefined,
+                    cameraOverlayIncluded: false,
+                    cameraOverlayPosition: cameraEnabled ? pipPosition : undefined,
+                    cameraOverlayShape: cameraEnabled ? pipShape : undefined,
+                };
+                setPreviewBlob(rawBlob);
+                setCameraPreviewBlob(rawCameraBlob);
                 setState("preview");
                 setIsFinalizing(true);
                 const runId = ++finalizationRunIdRef.current;
-                const finalizePromise = (0, finalizeRecordingInWorker_1.finalizeRecordingInWorker)(rawBlob, Math.max(elapsedMsRef.current, 1));
+                const finalizePromise = (0, finalizeRecordingInWorker_1.finalizeRecordingInWorker)(rawBlob, Math.max(elapsedMsRef.current, 1), finalizationHints, {
+                    enabled: cameraEnabled,
+                    cameraBlob: rawCameraBlob,
+                    pipScale: options.pipScale,
+                    position: pipPosition,
+                    shape: pipShape,
+                });
                 finalizePromiseRef.current = finalizePromise;
                 try {
                     const finalizedRecording = await finalizePromise;
@@ -136,12 +392,23 @@ function useRecorderController(options = {}) {
                     }
                     blobRef.current = finalizedRecording.blob;
                     blobMetadataRef.current = finalizedRecording.metadata;
+                    setPreviewBlob(finalizedRecording.blob);
+                    setCameraPreviewBlob(null);
+                    if (finalizedRecording.metadata.conversionMode !== "mp4"
+                        || finalizedRecording.metadata.mimeType !== "video/mp4") {
+                        throw new Error("Recorder finalized to a non-MP4 output");
+                    }
                 }
-                catch (err) {
+                catch (error) {
                     if (discardingRef.current || finalizationRunIdRef.current !== runId) {
                         return;
                     }
-                    setError(err instanceof Error ? err : new Error("Failed to finalize recording"));
+                    blobRef.current = null;
+                    blobMetadataRef.current = null;
+                    setPreviewBlob(null);
+                    setCameraPreviewBlob(null);
+                    setError(toError(error, "Recording processing failed. MP4 conversion is required before upload."));
+                    setState("error");
                 }
                 finally {
                     if (finalizationRunIdRef.current === runId) {
@@ -150,12 +417,27 @@ function useRecorderController(options = {}) {
                     }
                 }
             };
+            recorder.onstop = () => {
+                screenStopped = true;
+                void maybeFinalizeStoppedRecorders();
+            };
             recorder.onerror = () => {
                 setError(new Error("Recording failed"));
                 cleanup();
                 setState("error");
             };
-            stream.getVideoTracks()[0]?.addEventListener("ended", () => {
+            if (cameraRecorder) {
+                cameraRecorder.onstop = () => {
+                    cameraStopped = true;
+                    void maybeFinalizeStoppedRecorders();
+                };
+                cameraRecorder.onerror = () => {
+                    setCameraError(new Error("Camera recording failed"));
+                    cleanup();
+                    setState("error");
+                };
+            }
+            displayStream.getVideoTracks()[0]?.addEventListener("ended", () => {
                 if (recorder.state === "recording") {
                     const activeMs = Date.now() - timerStartedAtRef.current;
                     elapsedMsRef.current += activeMs;
@@ -164,6 +446,7 @@ function useRecorderController(options = {}) {
                 }
             });
             recorder.start();
+            cameraRecorder?.start();
             remainingMaxMsRef.current = maxDurationMs;
             elapsedMsRef.current = 0;
             timerStartedAtRef.current = Date.now();
@@ -177,10 +460,33 @@ function useRecorderController(options = {}) {
         }
         catch (err) {
             cleanup();
-            setError(err instanceof Error ? err : new Error("Failed to start recording"));
+            const resolvedError = err instanceof Error ? err : new Error("Failed to start recording");
+            if (resolvedError.name === "MicrophoneCaptureError") {
+                setMicrophoneError(resolvedError);
+            }
+            else if (resolvedError.name === "CameraCaptureError") {
+                setCameraError(resolvedError);
+            }
+            else {
+                setError(resolvedError);
+            }
             setState("error");
         }
-    }, [previewUrl, maxDurationMs, videoBitsPerSecond, cleanup, scheduleMaxTimer]);
+    }, [
+        cameraBitsPerSecond,
+        cameraEnabled,
+        buildFallbackMetadata,
+        cleanup,
+        maxDurationMs,
+        microphoneEnabled,
+        options.pipScale,
+        pipPosition,
+        pipShape,
+        scheduleMaxTimer,
+        setCameraPreviewBlob,
+        setPreviewBlob,
+        videoBitsPerSecond,
+    ]);
     const stop = (0, react_1.useCallback)(() => {
         if (state !== "recording" && state !== "paused")
             return;
@@ -198,17 +504,25 @@ function useRecorderController(options = {}) {
             maxTimerRef.current = null;
         }
         const rec = recorderRef.current;
+        const cameraRec = cameraRecorderRef.current;
         if (rec && (rec.state === "recording" || rec.state === "paused")) {
             rec.requestData();
             rec.stop();
         }
+        if (cameraRec && (cameraRec.state === "recording" || cameraRec.state === "paused")) {
+            cameraRec.requestData();
+            cameraRec.stop();
+        }
     }, [state]);
     const pause = (0, react_1.useCallback)(() => {
         if (state !== "recording")
             return;
         const rec = recorderRef.current;
+        const cameraRec = cameraRecorderRef.current;
         if (rec?.state === "recording")
             rec.pause();
+        if (cameraRec?.state === "recording")
+            cameraRec.pause();
         if (timerRef.current) {
             clearInterval(timerRef.current);
             timerRef.current = null;
@@ -223,8 +537,11 @@ function useRecorderController(options = {}) {
         if (state !== "paused")
             return;
         const rec = recorderRef.current;
+        const cameraRec = cameraRecorderRef.current;
         if (rec?.state === "paused")
             rec.resume();
+        if (cameraRec?.state === "paused")
+            cameraRec.resume();
         timerStartedAtRef.current = Date.now();
         timerRef.current = setInterval(() => {
             const totalMs = elapsedMsRef.current + (Date.now() - timerStartedAtRef.current);
@@ -240,16 +557,16 @@ function useRecorderController(options = {}) {
         blobMetadataRef.current = null;
         finalizePromiseRef.current = null;
         finalizationRunIdRef.current += 1;
-        if (previewUrl)
-            URL.revokeObjectURL(previewUrl);
-        setPreviewUrl(null);
-        setCameraPreviewUrl(null);
+        setPreviewBlob(null);
+        setCameraPreviewBlob(null);
+        setLiveCameraStream(null);
         setIsFinalizing(false);
         setDuration(0);
         remainingMaxMsRef.current = maxDurationMs;
         elapsedMsRef.current = 0;
         setState("idle");
         const rec = recorderRef.current;
+        const cameraRec = cameraRecorderRef.current;
         if (rec && (rec.state === "recording" || rec.state === "paused")) {
             if (timerRef.current) {
                 clearInterval(timerRef.current);
@@ -260,11 +577,14 @@ function useRecorderController(options = {}) {
                 maxTimerRef.current = null;
             }
             rec.stop();
+            if (cameraRec && (cameraRec.state === "recording" || cameraRec.state === "paused")) {
+                cameraRec.stop();
+            }
             return;
         }
         cleanup();
         discardingRef.current = false;
-    }, [cleanup, maxDurationMs, previewUrl]);
+    }, [cleanup, maxDurationMs, setCameraPreviewBlob, setPreviewBlob]);
     const restart = (0, react_1.useCallback)(async () => {
         discard();
         await start();
@@ -282,19 +602,30 @@ function useRecorderController(options = {}) {
         if (!blob) {
             return null;
         }
+        const metadata = blobMetadataRef.current;
+        if (metadata?.conversionMode !== "mp4" || metadata.mimeType !== "video/mp4") {
+            throw new Error("Recording is not finalized as MP4");
+        }
         return {
             blob,
-            metadata: blobMetadataRef.current ?? buildFallbackMetadata(blob),
+            metadata,
         };
-    }, [buildFallbackMetadata]);
+    }, []);
     return {
         state,
         duration,
         previewUrl,
         cameraPreviewUrl,
+        liveCameraStream,
         error,
+        microphoneError,
+        cameraError,
         isSupported: isSupported(),
         isFinalizing,
+        microphoneEnabled,
+        cameraEnabled,
+        setMicrophoneEnabled,
+        setCameraEnabled,
         start,
         stop,
         pause,