Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
fix(sdk-recorder): cancel capture startup when destroyed
Akshar Patel2ae8d7ebdaf5
diff --git a/packages/sdk-recorder/__tests__/startup-cancellation.test.ts b/packages/sdk-recorder/__tests__/startup-cancellation.test.tsnew file mode 100644index 000000000..b773acb05--- /dev/null+++ b/packages/sdk-recorder/__tests__/startup-cancellation.test.ts@@ -0,0 +1,295 @@+import { afterEach, beforeEach, expect, mock, test } from "bun:test";+import { CapRecorder } from "../src/index";++class Track {+ readyState = "live";+ onended: (() => void) | null = null;++ constructor(readonly kind: "video" | "audio") {}++ stop() {+ this.readyState = "ended";+ }+}++class Stream {+ constructor(private readonly tracks: Track[]) {}++ getTracks() {+ return this.tracks;+ }++ getVideoTracks() {+ return this.tracks.filter((track) => track.kind === "video");+ }++ getAudioTracks() {+ return this.tracks.filter((track) => track.kind === "audio");+ }+}++class Encoder {+ static starts = 0;+ state = "inactive";++ static isTypeSupported() {+ return true;+ }++ start() {+ Encoder.starts++;+ this.state = "recording";+ }++ stop() {+ this.state = "inactive";+ }+}++function deferred<T>() {+ let resolve!: (value: T) => void;+ let reject!: (error: Error) => void;+ const promise = new Promise<T>((res, rej) => {+ resolve = res;+ reject = rej;+ });+ return { promise, resolve, reject };+}++const descriptors = [+ "navigator",+ "MediaStream",+ "MediaRecorder",+ "AudioContext",+].map(+ (name) => [name, Object.getOwnPropertyDescriptor(globalThis, name)] as const,+);++function setGlobal(name: string, value: unknown) {+ Object.defineProperty(globalThis, name, { configurable: true, value });+}++beforeEach(() => {+ Encoder.starts = 0;+ setGlobal("MediaStream", Stream);+ setGlobal("MediaRecorder", Encoder);+});++afterEach(() => {+ for (const [name, descriptor] of descriptors) {+ if (descriptor) Object.defineProperty(globalThis, name, descriptor);+ else Reflect.deleteProperty(globalThis, name);+ }+});++test("destroy cancels pending camera startup without requesting the microphone", async () => {+ const permission = deferred<Stream>();+ const camera = new Track("video");+ const microphone = new Track("audio");+ const getUserMedia = mock((constraints: MediaStreamConstraints) =>+ constraints.video+ ? permission.promise+ : Promise.resolve(new Stream([microphone])),+ );+ setGlobal("navigator", { mediaDevices: { getUserMedia } });+ const recorder = new CapRecorder({ publicKey: "fixture", mode: "camera" });++ try {+ const starting = recorder.start();+ expect(recorder.phase).toBe("requesting-permission");+ recorder.destroy();+ permission.resolve(new Stream([camera]));+ await starting;++ expect(recorder.phase).toBe("idle");+ expect(camera.readyState).toBe("ended");+ expect(getUserMedia).toHaveBeenCalledTimes(1);+ expect(Encoder.starts).toBe(0);+ } finally {+ recorder.destroy();+ }+});++test("destroy releases the screen while microphone permission is pending", async () => {+ const permission = deferred<Stream>();+ const screen = new Track("video");+ const microphone = new Track("audio");+ const getUserMedia = mock(() => permission.promise);+ setGlobal("navigator", {+ mediaDevices: {+ getDisplayMedia: async () => new Stream([screen]),+ getUserMedia,+ },+ });+ const recorder = new CapRecorder({+ publicKey: "fixture",+ camera: { enabled: false },+ });++ try {+ const starting = recorder.start();+ await new Promise<void>((resolve) => setImmediate(resolve));+ expect(getUserMedia).toHaveBeenCalledTimes(1);+ recorder.destroy();+ const screenAfterDestroy = screen.readyState;+ permission.resolve(new Stream([microphone]));+ await starting;++ expect(screenAfterDestroy).toBe("ended");+ expect(microphone.readyState).toBe("ended");+ expect(recorder.phase).toBe("idle");+ expect(Encoder.starts).toBe(0);+ } finally {+ recorder.destroy();+ }+});++test("destroy releases streams returned before start resumes", async () => {+ const permission = deferred<Stream>();+ const camera = new Track("video");+ setGlobal("navigator", {+ mediaDevices: { getUserMedia: () => permission.promise },+ });+ const recorder = new CapRecorder({+ publicKey: "fixture",+ mode: "camera",+ microphone: { enabled: false },+ });++ try {+ const starting = recorder.start();+ permission.resolve(new Stream([camera]));+ queueMicrotask(() => recorder.destroy());+ await starting;++ expect(recorder.phase).toBe("idle");+ expect(camera.readyState).toBe("ended");+ expect(Encoder.starts).toBe(0);+ } finally {+ recorder.destroy();+ }+});++test.each(["grant", "deny"] as const)(+ "a late screen permission %s cannot change a replacement recording",+ async (outcome) => {+ const permission = deferred<Stream>();+ const oldScreen = new Track("video");+ const newScreen = new Track("video");+ const getDisplayMedia = mock()+ .mockImplementationOnce(() => permission.promise)+ .mockImplementationOnce(async () => new Stream([newScreen]));+ setGlobal("navigator", { mediaDevices: { getDisplayMedia } });+ const recorder = new CapRecorder({+ publicKey: "fixture",+ camera: { enabled: false },+ microphone: { enabled: false },+ });+ const errors = mock(() => {});+ recorder.on("error", errors);++ try {+ const starting = recorder.start().catch((error: unknown) => error);+ recorder.destroy();+ await recorder.start();+ if (outcome === "grant") permission.resolve(new Stream([oldScreen]));+ else permission.reject(new Error("Permission denied"));+ expect(await starting).toBeUndefined();++ expect(recorder.phase).toBe("recording");+ expect(newScreen.readyState).toBe("live");+ if (outcome === "grant") expect(oldScreen.readyState).toBe("ended");+ expect(errors).not.toHaveBeenCalled();+ expect(Encoder.starts).toBe(1);+ } finally {+ recorder.destroy();+ }+ },+);++test.each(["resolve", "reject"] as const)(+ "destroy cancels audio startup when resume later %ss",+ async (outcome) => {+ const startup = deferred<void>();+ const screen = new Track("video");+ const system = new Track("audio");+ const microphone = new Track("audio");+ const mixed = new Track("audio");+ const close = mock(async () => {});+ const resume = mock(() => startup.promise);+ setGlobal("navigator", {+ mediaDevices: {+ getDisplayMedia: async () => new Stream([screen, system]),+ getUserMedia: async () => new Stream([microphone]),+ },+ });+ setGlobal(+ "AudioContext",+ class {+ close = close;+ resume = resume;+ createMediaStreamDestination() {+ return { stream: new Stream([mixed]) };+ }+ createGain() {+ return { gain: { value: 1 }, connect() {} };+ }+ createMediaStreamSource() {+ return { connect() {} };+ }+ },+ );+ const recorder = new CapRecorder({+ publicKey: "fixture",+ camera: { enabled: false },+ systemAudio: true,+ });++ try {+ const starting = recorder.start().catch((error: unknown) => error);+ await new Promise<void>((resolve) => setImmediate(resolve));+ expect(resume).toHaveBeenCalledTimes(1);+ recorder.destroy();+ for (const track of [screen, system, microphone, mixed]) {+ expect(track.readyState).toBe("ended");+ }+ if (outcome === "resolve") startup.resolve();+ else startup.reject(new Error("Audio context closed"));+ expect(await starting).toBeUndefined();+ expect(recorder.phase).toBe("idle");+ expect(close).toHaveBeenCalledTimes(1);+ expect(Encoder.starts).toBe(0);+ } finally {+ recorder.destroy();+ }+ },+);++test("an error handler can destroy and start a replacement recording", async () => {+ const camera = new Track("video");+ const getDisplayMedia = mock()+ .mockRejectedValueOnce(new Error("Permission failed"))+ .mockResolvedValueOnce(new Stream([camera]));+ setGlobal("navigator", { mediaDevices: { getDisplayMedia } });+ const recorder = new CapRecorder({+ publicKey: "fixture",+ camera: { enabled: false },+ microphone: { enabled: false },+ });+ let replacement: Promise<void> | undefined;+ recorder.on("error", () => {+ recorder.destroy();+ replacement = recorder.start();+ });++ try {+ await expect(recorder.start()).rejects.toThrow("Permission failed");+ await replacement;++ expect(recorder.phase).toBe("recording");+ expect(camera.readyState).toBe("live");+ expect(Encoder.starts).toBe(1);+ } finally {+ recorder.destroy();+ }+});diff --git a/packages/sdk-recorder/src/core/stream-manager.ts b/packages/sdk-recorder/src/core/stream-manager.tsindex f93156d09..1f6c99d25 100644--- a/packages/sdk-recorder/src/core/stream-manager.ts+++ b/packages/sdk-recorder/src/core/stream-manager.ts@@ -16,6 +16,7 @@ export interface ManagedStreams {export async function acquireStreams(config: StreamConfig,+ signal: AbortSignal,): Promise<ManagedStreams> {const result: ManagedStreams = {display: null,@@ -23,50 +24,65 @@ export async function acquireStreams(microphone: null,};- if (config.mode !== "camera") {- const displayMediaOptions: DisplayMediaStreamOptions = {- video: true,- audio: config.systemAudio ?? false,- };+ signal.throwIfAborted();+ const onAbort = () => releaseStreams(result);+ signal.addEventListener("abort", onAbort, { once: true });- if (config.mode === "window") {- (displayMediaOptions as Record<string, unknown>).preferCurrentTab = false;- }+ try {+ if (config.mode !== "camera") {+ const displayMediaOptions: DisplayMediaStreamOptions = {+ video: true,+ audio: config.systemAudio ?? false,+ };++ if (config.mode === "window") {+ (displayMediaOptions as Record<string, unknown>).preferCurrentTab =+ false;+ }- result.display =- await navigator.mediaDevices.getDisplayMedia(displayMediaOptions);- }+ result.display =+ await navigator.mediaDevices.getDisplayMedia(displayMediaOptions);+ signal.throwIfAborted();+ }- if (config.camera?.enabled !== false) {- const constraints: MediaStreamConstraints = {- video: config.camera?.deviceId- ? { deviceId: { exact: config.camera.deviceId } }- : true,- audio: false,- };- try {- result.camera = await navigator.mediaDevices.getUserMedia(constraints);- } catch {- result.camera = null;+ if (config.camera?.enabled !== false) {+ const constraints: MediaStreamConstraints = {+ video: config.camera?.deviceId+ ? { deviceId: { exact: config.camera.deviceId } }+ : true,+ audio: false,+ };+ try {+ result.camera = await navigator.mediaDevices.getUserMedia(constraints);+ } catch {+ result.camera = null;+ }+ signal.throwIfAborted();}- }- if (config.microphone?.enabled !== false) {- const constraints: MediaStreamConstraints = {- video: false,- audio: config.microphone?.deviceId- ? { deviceId: { exact: config.microphone.deviceId } }- : true,- };- try {- result.microphone =- await navigator.mediaDevices.getUserMedia(constraints);- } catch {- result.microphone = null;+ if (config.microphone?.enabled !== false) {+ const constraints: MediaStreamConstraints = {+ video: false,+ audio: config.microphone?.deviceId+ ? { deviceId: { exact: config.microphone.deviceId } }+ : true,+ };+ try {+ result.microphone =+ await navigator.mediaDevices.getUserMedia(constraints);+ } catch {+ result.microphone = null;+ }+ signal.throwIfAborted();}- }- return result;+ return result;+ } catch (error) {+ releaseStreams(result);+ throw error;+ } finally {+ signal.removeEventListener("abort", onAbort);+ }}export function releaseStreams(streams: ManagedStreams) {diff --git a/packages/sdk-recorder/src/index.ts b/packages/sdk-recorder/src/index.tsindex 2da81477c..51c58072d 100644--- a/packages/sdk-recorder/src/index.ts+++ b/packages/sdk-recorder/src/index.ts@@ -36,6 +36,7 @@ export class CapRecorder {private _durationMs = 0;private recorder: MediaRecorder | null = null;private streams: ManagedStreams | null = null;+ private startup: AbortController | null = null;private chunks: Blob[] = [];private durationInterval: ReturnType<typeof setInterval> | null = null;private accumulatedMs = 0;@@ -114,18 +115,29 @@ export class CapRecorder {throw new Error(`Cannot start from phase "${this._phase}"`);}const maxDurationMs = options?.maxDurationMs ?? this.maxDurationMs;+ const startup = new AbortController();+ this.startup = startup;try {this.setPhase("requesting-permission");- this.streams = await acquireStreams({- mode: this.options.mode,- camera: this.options.camera,- microphone: this.options.microphone,- systemAudio: this.options.systemAudio,- });+ const streams = await acquireStreams(+ {+ mode: this.options.mode,+ camera: this.options.camera,+ microphone: this.options.microphone,+ systemAudio: this.options.systemAudio,+ },+ startup.signal,+ );+ if (startup.signal.aborted) {+ releaseStreams(streams);+ return;+ }+ this.streams = streams;- const composite = await buildCompositeStream(this.streams);+ const composite = await buildCompositeStream(streams);+ if (startup.signal.aborted) return;if (composite.getTracks().length === 0) {throw new Error("No media tracks available");}@@ -161,11 +173,12 @@ export class CapRecorder {}, maxDurationMs);this.setPhase("recording");} catch (error) {+ if (startup.signal.aborted) return;+ this.cleanup();this.setPhase("error");this.emit("error", {error: error instanceof Error ? error : new Error(String(error)),});- this.cleanup();throw error;}}@@ -275,6 +288,8 @@ export class CapRecorder {}private cleanup() {+ this.startup?.abort();+ this.startup = null;this.stopDurationTimer();if (this.maxDurationTimeout) {clearTimeout(this.maxDurationTimeout);