test(raw): pin the drop-and-instantly-re-add case, and fix two comment drifts

Review found the drop-cancellation implementation correct but the test
surface incomplete: no test exercised re-adding a frame in the same turn it
was dropped, which is the only way to observe `forget`'s identity check and
`dropRawConversions`'s eager `forget` actually doing their jobs -- the
existing "forgets a frame dropped before it started" test awaits the
rejection first, giving the ordinary catch -> forget path time to clean up
before the re-add ever runs.

Adds one test that drops and re-adds with no await between, confirmed by
mutation to fail both ways: deleting `dropRawConversions`'s `forget` call
lets the re-added promise inherit the dropped entry's AbortError, and
reverting `forget`'s identity check lets the dropped entry's late,
post-rejection forget delete the re-added entry's cache slot, surfacing as a
third conversion of bytes already held.

Also corrects two doc comments that had drifted from the code they describe:
`tiffFor`'s claim that a converter skipping `onStart` leaves frames
droppable "for their whole life" (false since the `started || done`
widening -- droppable only until they finish), and `dropRawConversions`'s
docstring naming the test fixture `countingIo` where it should state the
underlying contract instead.

Refs #248

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: adulbrich

src/lib/raw-preview.test.ts

@@ -233,6 +233,43 @@ describe("shared RAW conversion", () => {
     expect(source.converted).toHaveLength(1);
   });
 
+  it("does not let a frame dropped and instantly re-added inherit the dropped entry's rejection or lose its own cache slot", async () => {
+    const io = deferredIo();
+    const path = "/in/capt01.CR2";
+
+    const dropped = rawToTiff(path, io);
+    // Two turns so `tiffFor` has run and the abort listener is attached
+    // before the drop, exactly as in the "forgets a frame dropped before it
+    // started" case above.
+    await Promise.resolve();
+    await Promise.resolve();
+    dropRawConversions([path]);
+    // No await between the drop and the re-add: that gap is what the earlier
+    // "forgets a frame dropped..." test could not exercise, because it
+    // awaited `dropped`'s rejection first, giving `rawToTiff`'s own
+    // `catch -> forget` time to clear the entry before the re-add ever ran.
+    const again = rawToTiff(path, io);
+    await expect(dropped).rejects.toThrow(ABORT_MESSAGE);
+
+    await Promise.resolve();
+    await Promise.resolve();
+    io.start(path);
+    io.finish(path);
+    await expect(again).resolves.toHaveLength(1024);
+    expect(io.converted).toHaveLength(2);
+
+    // The replacement entry `again` created must still be the live cache
+    // entry for this key. Deliberately not awaited: if it were lost -- the
+    // dropped entry's late `forget` deleting it regardless of identity --
+    // this call starts a third, real conversion that nothing here ever
+    // finishes, and awaiting it would hang for 5 s instead of failing
+    // cleanly on `io.converted`'s length.
+    rawToTiff(path, io);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(io.converted).toHaveLength(2);
+  });
+
   it("does not count a conversion that finished after its entry was gone", async () => {
     const io = deferredIo();
 

src/lib/raw-preview.ts

@@ -100,7 +100,9 @@ export interface RawSourceIo {
    * `options.onStart` is the converter's half of that bargain: it says the
    * frame can no longer be skipped, which is the only way this module can
    * tell a queued frame from one already converting. A converter that never
-   * calls it leaves its frames droppable for their whole life.
+   * calls it leaves its frames droppable until they finish -- see
+   * `dropRawConversions`, which keeps a settled entry by its `done` flag
+   * regardless of `started`.
    */
   tiffFor?: (
     path: string,
@@ -276,10 +278,11 @@ async function convert(
  * because forgetting it would make a re-added set a cache miss and convert
  * the same bytes a second time. A finished frame is kept too -- it costs
  * nothing the LRU budget does not already govern, and it makes re-adding the
- * same file instant. `flags.done` is what recognizes it: a converter that
- * resolves without ever calling `onStart` -- `countingIo` in the tests --
- * would otherwise leave `flags.started` false on a completed entry,
- * indistinguishable from one still queued.
+ * same file instant. `flags.done` is what recognizes it: a converter is free
+ * to resolve without ever calling `onStart` -- #243's OPFS path will do
+ * exactly that when it answers from a cached TIFF instead of converting --
+ * and such a converter would otherwise leave `flags.started` false on a
+ * completed entry, indistinguishable from one still queued.
  *
  * Paths that were never converted, including every non-RAW one, match no key
  * and cost a scan.