fix(display): close the video writer when the audio writer's close throws

recordScreenAndAudioToFiles closed its two writers in sequence:

    audioWritten = await audioOut.close();
    await videoOut.close();

M4aFileWriter finalizes by appending the moov box, ending the stream, then
reopening the finished file to patch mdat's length field. Any of those can fail
on a full disk or a reaped temp directory, long after every frame is already
safely on disk. When one does, the video writer's close is skipped.

The cost is a leaked file descriptor. Without close() the write stream is never
ended, and Node does not release descriptors on garbage collection, so it lives
until the process exits. The error the stream is holding also goes unread, since
AnnexBFileWriter only surfaces that from write() or close().

The video file itself is intact. Node's write queue drains on its own once
chunks are handed to write(), the recording loop awaits every write, and Annex-B
is an elementary stream with no index or footer to finalize, so a file ending
after the last frame is valid and playable. Verified by writing 15 MB and never
calling close(): every byte was on disk.

Closing the video writer from a finally makes it independent of the audio
writer's failure. The audio error still propagates when the video close
succeeds. If both throw the video error supersedes, which is standard finally
behaviour and an acceptable edge for a path that has already failed.

Covered by a unit test that stubs the audio writer's close to throw and asserts
the video writer was still closed. Reverting to sequential closes fails it with
0 closes instead of 1.

Author: harsha509

src/services/ios/display/recording/av-capture.ts

@@ -196,8 +196,16 @@ export async function recordScreenAndAudioToFiles(
       log.debug(`Failed to stop cleanly: ${error instanceof Error ? error.message : String(error)}`);
     });
     await audioCapture.stop().catch((): void => undefined);
-    audioWritten = await audioOut.close();
-    await videoOut.close();
+    // The video writer closes even when the audio writer throws. M4aFileWriter
+    // finalizes by reopening the finished file to patch mdat's length, so it can
+    // fail on a full disk long after every frame is safely on disk. Sequencing
+    // the two closes would leak the video file descriptor for the life of the
+    // process, and the error its stream is holding would never be read.
+    try {
+      audioWritten = await audioOut.close();
+    } finally {
+      await videoOut.close();
+    }
   }
 
   const audioDurationMs = aacEldDurationMs(audioWritten.sampleCount);

test/unit/display/recording/av-capture.spec.ts

@@ -2,10 +2,15 @@ import assert from 'node:assert/strict';
 import {mkdtemp, rm} from 'node:fs/promises';
 import {tmpdir} from 'node:os';
 import {join} from 'node:path';
-import {after, before, describe, it} from 'node:test';
+import {type TestContext, after, before, describe, it} from 'node:test';
 
 import type {DisplayService, MediaStreamAnswer} from '../../../../src/services/ios/display/index.js';
 import {recordScreenAndAudioToFiles} from '../../../../src/services/ios/display/recording/av-capture.js';
+import {mockImport} from '../../../helpers/mock-module.js';
+
+const AV_CAPTURE_MODULE = '../../../../src/services/ios/display/recording/av-capture.js';
+const M4A_WRITER_MODULE = '../../../../src/services/ios/display/audio/m4a-writer.js';
+const SCREEN_CAPTURE_MODULE = '../../../../src/services/ios/display/video/screen-stream-capture.js';
 
 /** A stub service that negotiates without a device and counts teardowns. */
 function makeStubService(): {service: DisplayService; stopCalls: () => number} {
@@ -60,4 +65,58 @@ describe('recordScreenAndAudioToFiles', function () {
 
     assert.strictEqual(stopCalls(), 2, 'both captures must be stopped before the error propagates');
   });
+
+  it('closes the video writer even when closing the audio writer throws', async function (t: TestContext) {
+    // M4aFileWriter finalizes by reopening the finished file to patch mdat's
+    // length, so it can fail on a full disk after every frame is already on
+    // disk. Sequencing the closes would skip the video one, leaking its file
+    // descriptor and leaving the error its stream holds unread.
+    let videoCloseCalls = 0;
+    const closeFailure = new Error('failed to patch the mdat header');
+
+    class StubM4aFileWriter {
+      static async create(): Promise<StubM4aFileWriter> {
+        return new StubM4aFileWriter();
+      }
+      async write(): Promise<void> {
+        return undefined;
+      }
+      async close(): Promise<never> {
+        throw closeFailure;
+      }
+    }
+
+    class StubAnnexBFileWriter {
+      constructor(path: string) {
+        void path;
+      }
+      async write(): Promise<void> {
+        return undefined;
+      }
+      async close(): Promise<void> {
+        videoCloseCalls += 1;
+      }
+    }
+
+    const {recordScreenAndAudioToFiles: record} = await mockImport<{
+      recordScreenAndAudioToFiles: typeof recordScreenAndAudioToFiles;
+    }>(t, AV_CAPTURE_MODULE, import.meta.url, {
+      [M4A_WRITER_MODULE]: {M4aFileWriter: StubM4aFileWriter},
+      // Merged over the real exports, so ScreenStreamCapture stays intact.
+      [SCREEN_CAPTURE_MODULE]: {AnnexBFileWriter: StubAnnexBFileWriter},
+    });
+
+    const {service} = makeStubService();
+    await assert.rejects(
+      () =>
+        record(service, {
+          videoPath: join(directory, 'screen-close.h265'),
+          audioPath: join(directory, 'audio-close.m4a'),
+          durationMs: 50,
+        }),
+      /failed to patch the mdat header/,
+    );
+
+    assert.strictEqual(videoCloseCalls, 1, 'the video writer must be closed even though the audio close threw');
+  });
 });