Fix the OPFS output lifecycle (locked stream on close)

StreamTarget closes the underlying writer when the output is finalized —
that is also what commits an OPFS file — so closing it ourselves threw
"Can not close locked stream". finalize() now simply reads the committed
file back, and every failure path (invalid attempt, encode error,
validation failure) aborts the write and deletes the temporary entry.

frontend/src/features/optimize/stream.ts

@@ -1,6 +1,11 @@
 import { StreamTarget, type StreamTargetChunk } from "mediabunny";
 
-import { createStoredFile, opfsSupported, purgeStaleStoredFiles } from "./opfs";
+import {
+  createStoredFile,
+  deleteStoredFile,
+  opfsSupported,
+  purgeStaleStoredFiles,
+} from "./opfs";
 
 interface CollectedChunk {
   blob: Blob;
@@ -11,6 +16,7 @@ interface CollectedChunk {
 export interface StreamOutput {
   target: StreamTarget;
   finalize(type: string): Promise<{ blob: Blob; storageKey?: string }>;
+  abort(): Promise<void>;
 }
 
 /**
@@ -19,8 +25,9 @@ export interface StreamOutput {
  *
  * Preferred: a real Origin Private File System file with random access, which
  * is what the muxer expects (it rewrites earlier byte ranges for headers).
- * Fallback: collect chunks and assemble them, with the newest write winning
+ * StreamTarget closes the underlying writer when the output is finalized,
- * per byte range.
+ * which also commits the OPFS file. Fallback: collect chunks and assemble
+ * them, with the newest write winning per byte range.
  */
 export async function createStreamOutput(
   extension: string,
@@ -30,16 +37,28 @@ export async function createStreamOutput(
     if (stored) {
       void purgeStaleStoredFiles();
       const writable = await stored.handle.createWritable();
+      let finalized = false;
       return {
         target: new StreamTarget(writable),
         finalize: async (type: string) => {
-          await writable.close();
+          finalized = true;
+          // The writer is already closed and the file committed; just read it.
           const file = await stored.handle.getFile();
           return {
             blob: new File([file], stored.name, { type }),
             storageKey: stored.name,
           };
         },
+        abort: async () => {
+          if (!finalized) {
+            try {
+              await writable.abort();
+            } catch {
+              // Locked or already closed — the entry removal still applies.
+            }
+          }
+          await deleteStoredFile(stored.name);
+        },
       };
     }
   }
@@ -66,6 +85,9 @@ function createBufferOutput(): StreamOutput {
     finalize: async (type: string) => ({
       blob: assembleBlob(chunks, type),
     }),
+    abort: async () => {
+      chunks.length = 0;
+    },
   };
 }
 

frontend/src/features/optimize/video.ts

@@ -115,6 +115,7 @@ export async function optimizeVideo(
         break;
       }
       input.dispose?.();
+      await stream.abort();
     }
     if (winner) break;
   }
@@ -132,6 +133,7 @@ export async function optimizeVideo(
   try {
     await winner.conversion.execute();
   } catch (error) {
+    await winner.stream.abort();
     throw new Error(
       `Video encoding failed: ${
         error instanceof Error ? error.message : "unknown error"
@@ -142,6 +144,7 @@ export async function optimizeVideo(
   }
 
   report(0.97, "Checking the result…");
+  try {
     const { blob, storageKey } = await winner.stream.finalize(
       container === "webm" ? "video/webm" : "video/mp4",
     );
@@ -153,6 +156,10 @@ export async function optimizeVideo(
       note: `${winner.codec} · ${container}`,
       storageKey,
     };
+  } catch (error) {
+    await winner.stream.abort();
+    throw error;
+  }
 }
 
 /** Reject a truncated or structurally broken muxer output up front. */