M15.2: web app depth (WEB-1): browser storage, Web Audio, worker renders, WebGPU viewer, PWA

- Persistence: settings, shortcuts, recent projects, imported media, saved projects and
  auto-saves live in OPFS (IndexedDB fallback) through an in-memory mirror flushed in the
  background (apps/effectcraft-web/src/store.rs, persist.rs); ConfigStore gains FileOps so
  auto-save / recovery work in the browser store; the session snapshot restores the last
  project + editor state on reload; File > Open Recent works from storage.
- Audio: Web Audio output (AudioWorklet, ScriptProcessor fallback) fed by AudioPlayback::pump
  on wasm32; A/V sync from AudioContext.currentTime; meters; unlock on first gesture.
- Background jobs: engine::offload (WorkerRequest/WorkerReply protocol, Offload trait,
  run_request); Render Queue, tracker, mask tracker, Warp Stabilizer and Roto Freeze run in Web
  Workers (a second engine instance on the shared compiled module), progress streamed back;
  cancel terminates the worker.
- GPU: WebGPU viewer frames drawn straight from the compositor's texture (gpu_display on
  wasm32 when the viewer draws plainly); async readback (Gpu::read_display_async) for pixels.
- PWA: manifest, service worker precaching the build (xtask fills list/version), icons copied
  from assets/app-icon; COOP/COEP kept from cached responses; offline reload works.
- window.effectcraft: saveToBrowser, listStored, removeStored, flush; info() reports storage,
  audio, gpu, workers.
- Tests: native store + protocol + offload (render, track, cancel) tests; smoke.mjs extended
  (GPU path, worker render responsiveness, audio gesture + playback, reload persistence,
  Open Recent, offline reload).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/gpu/src/context.rs

@@ -484,6 +484,41 @@ impl<'g> Enc<'g> {
         Some(out)
     }
 
+    /// [`Enc::read_texture`] without waiting for the GPU (the browser's main thread can't): `done`
+    /// gets the bytes once the copy is mapped (from the browser's event loop on the web; from
+    /// a later device poll natively).
+    pub fn read_texture_async(&mut self, texture: &wgpu::Texture, w: u32, h: u32, bpp: u32, done: impl FnOnce(Option<Vec<u8>>) + wgpu::WasmNotSend + 'static) {
+        let row = w * bpp;
+        let padded = row.div_ceil(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT) * wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
+        let buf = self.g.device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("readback-async"),
+            size: padded as u64 * h as u64,
+            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        self.encoder().copy_texture_to_buffer(
+            wgpu::TexelCopyTextureInfo { texture, mip_level: 0, origin: wgpu::Origin3d::ZERO, aspect: wgpu::TextureAspect::All },
+            wgpu::TexelCopyBufferInfo { buffer: &buf, layout: wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(padded), rows_per_image: Some(h) } },
+            wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
+        );
+        self.submit();
+        let b = buf.clone();
+        buf.map_async(wgpu::MapMode::Read, .., move |r| {
+            let out = r.ok().and_then(|_| {
+                let view = b.get_mapped_range(..).ok()?;
+                let mut out = Vec::with_capacity((row * h) as usize);
+                for y in 0..h as usize {
+                    out.extend_from_slice(&view[y * padded as usize..y * padded as usize + row as usize]);
+                }
+                Some(out)
+            });
+            b.unmap();
+            done(out);
+        });
+        #[cfg(not(target_arch = "wasm32"))]
+        let _ = self.g.device.poll(wgpu::PollType::Poll);
+    }
+
     /// A data buffer for kernels that read tables (curves).
     pub fn data(&self, v: &[f32]) -> wgpu::Buffer {
         let mut bytes = Vec::with_capacity(v.len().max(4) * 4);

crates/gpu/src/lib.rs

@@ -93,6 +93,12 @@ impl Gpu {
         Enc::new(&self.ctx).read_texture(&f.texture, f.width, f.height, 4)
     }
 
+    /// [`Gpu::read_display`] without blocking (the browser's main thread): `done` gets the bytes
+    /// once the GPU has them.
+    pub fn read_display_async(&self, f: &DisplayFrame, done: impl FnOnce(Option<Vec<u8>>) + wgpu::WasmNotSend + 'static) {
+        Enc::new(&self.ctx).read_texture_async(&f.texture, f.width, f.height, 4, done);
+    }
+
     /// Render a frame on the GPU and read it back (`None` = not handled).
     pub fn render(&self, r: &Renderer, comp: ItemId, t: Tick) -> Option<Image> {
         if !self.ctx.can_readback() {