@spooky-sync/core 0.0.1-canary.26 → 0.0.1-canary.261

package/src/client/bucket-handle.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it, vi } from 'vitest';
+import { BucketHandle, bucketContentToBlob } from './bucket-handle';
+
+vi.mock('../utils/blurhash', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../utils/blurhash')>();
+  return { ...actual, encodeImageToBlurhash: vi.fn(async () => 'LEHV6nWB2yk8pyo0adR*.7kCMdnj') };
+});
+
+function fakeRemote(answers: Record<string, unknown> = {}) {
+  const calls: Array<[string, unknown]> = [];
+  const remote = {
+    query: async (sql: string, vars?: unknown) => {
+      calls.push([sql, vars]);
+      for (const [needle, answer] of Object.entries(answers)) if (sql.includes(needle)) return [answer];
+      return [undefined];
+    },
+  } as any;
+  return { remote, calls };
+}
+
+function fakeBlobs() {
+  const log: string[] = [];
+  return {
+    log,
+    blobs: {
+      invalidate: async (k: { path: string }) => void log.push(`invalidate:${k.path}`),
+      read: async (k: { path: string }) => (k.path.endsWith('.bh') ? new Blob(['LEHV6nWB2yk8pyo0adR*.7kCMdnj']) : new Blob(['x'])),
+      acquireUrl: async (k: { path: string }) => ({ url: `blob:${k.path}`, release: () => undefined }),
+      setPinned: (k: { path: string }, pinned: boolean) => void log.push(`pin:${k.path}:${pinned}`),
+      prefetch: async (keys: Array<{ path: string }>) => void log.push(`prefetch:${keys.map((k) => k.path).join('+')}`),
+    } as any,
+  };
+}
+
+describe('bucketContentToBlob', () => {
+  it('coerces strings, buffers and views; passes blobs through; rejects the rest', async () => {
+    expect(bucketContentToBlob(null)).toBeNull();
+    expect(bucketContentToBlob(42)).toBeNull();
+    const b = new Blob(['a']);
+    expect(bucketContentToBlob(b)).toBe(b);
+    expect(await bucketContentToBlob('hi')!.text()).toBe('hi');
+    expect((await bucketContentToBlob(new ArrayBuffer(3))!.arrayBuffer()).byteLength).toBe(3);
+    expect((await bucketContentToBlob(new Uint8Array([1, 2]))!.arrayBuffer()).byteLength).toBe(2);
+  });
+});
+
+describe('BucketHandle', () => {
+  it('put: uploads, invalidates, writes the blurhash sidecar for images (best-effort), honours the setting', async () => {
+    const { remote, calls } = fakeRemote();
+    const { blobs, log } = fakeBlobs();
+    const warn = vi.fn();
+    const h = new BucketHandle('files', remote, blobs, { logger: { warn } });
+    const res = await h.put('a/pic.png', new Uint8Array([1]));
+    expect(res.blurhash).toBe('LEHV6nWB2yk8pyo0adR*.7kCMdnj');
+    expect(calls.map(([s]) => s)).toEqual(['RETURN f"files:/a/pic.png".put($content);', 'RETURN f"files:/a/pic.png.bh".put($content);']);
+    expect(log).toEqual(['invalidate:a/pic.png', 'invalidate:a/pic.png.bh']);
+    const off = new BucketHandle('files', remote, blobs, { blurhash: false });
+    expect((await off.put('b.png', 'x')).blurhash).toBeNull();
+    const perCall = new BucketHandle('files', remote, blobs, { blurhash: { componentX: 2 } });
+    expect((await perCall.put('c.txt', 'x', { blurhash: true })).blurhash).toBeNull();
+    expect((await perCall.put('c.png', 'x', { blurhash: { componentY: 3 } })).blurhash).toBeTruthy();
+    const failing = { query: async (sql: string) => { if (sql.includes('.bh')) throw new Error('sidecar'); return [undefined]; } } as any;
+    const sidecarFail = new BucketHandle('files', failing, blobs, { logger: { warn } });
+    expect((await sidecarFail.put('d.png', 'x')).blurhash).toBeNull();
+    expect(warn).toHaveBeenCalled();
+    const noBlobs = new BucketHandle('files', remote, null);
+    expect((await noBlobs.put('e.png', 'x')).blurhash).toBeTruthy();
+  });
+
+  it('blurhash: reads the sidecar through the cache, negative-caches misses, warns on invalid or failing reads', async () => {
+    const { remote } = fakeRemote();
+    const warn = vi.fn();
+    const { blobs } = fakeBlobs();
+    const h = new BucketHandle('bucketA', remote, blobs, { logger: { warn } });
+    expect(await h.blurhash('img.png')).toBe('LEHV6nWB2yk8pyo0adR*.7kCMdnj');
+    const missing = new BucketHandle('bucketB', remote, { ...blobs, read: async () => null } as any, { logger: { warn } });
+    expect(await missing.blurhash('none.png')).toBeNull();
+    expect(await missing.blurhash('none.png')).toBeNull();
+    const invalid = new BucketHandle('bucketC', remote, { ...blobs, read: async () => new Blob(['not-a-hash']) } as any, { logger: { warn } });
+    expect(await invalid.blurhash('bad.png')).toBeNull();
+    const throwing = new BucketHandle('bucketD', remote, { ...blobs, read: async () => { throw new Error('io'); } } as any, { logger: { warn } });
+    expect(await throwing.blurhash('err.png')).toBeNull();
+    expect(warn).toHaveBeenCalledTimes(2);
+    await new BucketHandle('bucketB', remote, blobs).put('none.png', 'x');
+    expect(await new BucketHandle('bucketB', remote, blobs).blurhash('none.png')).toBeTruthy();
+  });
+
+  it('get / read / url / pin / evict / prefetch / delete / exists / head / copy / rename / list', async () => {
+    const { remote, calls } = fakeRemote({ '.get()': 'content', '.exists()': true, '.head()': { size: 1 }, '.list()': ['a'] });
+    const { blobs, log } = fakeBlobs();
+    const h = new BucketHandle('files', remote, blobs);
+    expect(await h.get('p')).toBe('content');
+    expect(await (await h.read('p'))!.text()).toBe('x');
+    expect(await new BucketHandle('files', remote, null).read('p')).toBeInstanceOf(Blob);
+    expect(await h.url('p')).toEqual({ url: 'blob:p', release: expect.any(Function) });
+    expect(await new BucketHandle('files', remote, null).url('p')).toBeNull();
+    h.pin('p');
+    h.unpin('p');
+    await h.evict('p');
+    await h.prefetch(['a', 'b']);
+    await h.delete('doc.txt');
+    await h.delete('img.png');
+    const flaky = { query: async (sql: string) => { if (sql.includes('.bh".delete')) throw new Error('nope'); return [undefined]; } } as any;
+    await new BucketHandle('files', flaky, blobs).delete('img2.png');
+    expect(await h.exists('p')).toBe(true);
+    expect(await h.head('p')).toEqual({ size: 1 });
+    await h.copy('a', 'b');
+    await h.rename('a', 'b');
+    expect(await h.list()).toEqual(['a']);
+    expect(await h.list('pre/')).toEqual(['a']);
+    expect(log).toContain('pin:p:true');
+    expect(log).toContain('pin:p:false');
+    expect(log).toContain('prefetch:a+b');
+    expect(calls.some(([s]) => s === 'RETURN f"files:/img.png.bh".delete();')).toBe(true);
+    expect(calls.some(([s]) => s === 'RETURN f"files:/pre/".list();')).toBe(true);
+  });
+});

package/src/client/bucket-handle.ts

@@ -0,0 +1,227 @@
+import type { RemoteDatabaseService } from '../services/database/remote';
+import type { BlobCache, BlobReadOptions, BlobUrlLease } from '../services/blobs/index';
+import {
+  blurhashSidecarPath,
+  encodeImageToBlurhash,
+  isImagePath,
+  isBlurhashValid,
+  type BlurhashSetting,
+  type BlurhashEncodeOptions,
+} from '../utils/blurhash';
+
+/** Coerce whatever the `.get()` RPC hands back into a Blob. */
+export function bucketContentToBlob(content: unknown): Blob | null {
+  if (content == null) return null;
+  if (content instanceof Blob) return content;
+  if (typeof content === 'string') return new Blob([content]);
+  if (content instanceof ArrayBuffer) return new Blob([content]);
+  // Uint8Array and friends. The cast sidesteps `ArrayBufferLike` vs
+  // `ArrayBuffer` (SharedArrayBuffer) in lib.dom's BlobPart.
+  if (ArrayBuffer.isView(content)) return new Blob([content as unknown as BlobPart]);
+  return null;
+}
+
+export interface BucketPutOptions {
+  /** Override the client-level {@link Sp00kyConfig.blurhash} setting for this put. */
+  blurhash?: BlurhashSetting;
+}
+
+export interface BucketPutResult {
+  /** The computed blurhash when the content was a hashable image; else null. */
+  blurhash: string | null;
+}
+
+interface BucketHandleSettings {
+  blurhash?: BlurhashSetting;
+  logger?: { warn: (obj: unknown, msg?: string) => void };
+}
+
+/**
+ * Paths known to have no blurhash sidecar, per tab. The blob cache has no
+ * negative caching, so without this every mount of a hashless image would pay
+ * one serialized remote read. Cleared when a put writes a sidecar or a delete
+ * removes the image. Keyed `${bucket}:${path}` (the image path, not the sidecar).
+ */
+const missingBlurhash = new Set<string>();
+
+export class BucketHandle {
+  constructor(
+    private bucketName: string,
+    private remote: RemoteDatabaseService,
+    /** Absent on the raw handle the cache itself reads through. */
+    private blobs?: BlobCache | null,
+    private settings?: BucketHandleSettings
+  ) {}
+
+  /** Effective blurhash setting: per-call option > client config > default ON. */
+  private resolveBlurhash(option?: BlurhashSetting): BlurhashEncodeOptions | null {
+    const setting = option ?? this.settings?.blurhash ?? true;
+    if (setting === false) return null;
+    return setting === true ? {} : setting;
+  }
+
+  async put(
+    path: string,
+    content: string | Uint8Array | Blob,
+    options?: BucketPutOptions
+  ): Promise<BucketPutResult> {
+    // Start hashing while the upload is in flight; both browser-side costs
+    // overlap and the sidecar put only queues once the main put resolved.
+    const encodeOptions = this.resolveBlurhash(options?.blurhash);
+    const hashPromise =
+      encodeOptions && isImagePath(path)
+        ? encodeImageToBlurhash(content, encodeOptions)
+        : Promise.resolve(null);
+
+    await this.remote.query(`RETURN f"${this.bucketName}:/${path}".put($content);`, { content });
+    // A path can be overwritten, so anything cached under it is now wrong.
+    await this.blobs?.invalidate({ bucket: this.bucketName, path });
+
+    // The sidecar is best-effort: a hash or sidecar failure must never fail
+    // the image put that triggered it.
+    let hash: string | null = null;
+    try {
+      hash = await hashPromise;
+      if (hash) {
+        const sidecar = blurhashSidecarPath(path);
+        await this.remote.query(`RETURN f"${this.bucketName}:/${sidecar}".put($content);`, {
+          content: hash,
+        });
+        await this.blobs?.invalidate({ bucket: this.bucketName, path: sidecar });
+        missingBlurhash.delete(`${this.bucketName}:${path}`);
+      }
+    } catch (error) {
+      hash = null;
+      this.settings?.logger?.warn({ error, path }, 'blurhash sidecar put failed');
+    }
+    return { blurhash: hash };
+  }
+
+  /**
+   * The blurhash stored alongside an uploaded image (see
+   * {@link blurhashSidecarPath}), or null when there is none. Reads through the
+   * blob cache, so a warm client answers from OPFS without a network hop, and
+   * misses are remembered per tab so a hashless image costs at most one
+   * serialized remote read per session.
+   */
+  async blurhash(path: string): Promise<string | null> {
+    const cacheKey = `${this.bucketName}:${path}`;
+    if (missingBlurhash.has(cacheKey)) return null;
+    try {
+      const blob = await this.read(blurhashSidecarPath(path), { persist: true });
+      if (!blob) {
+        missingBlurhash.add(cacheKey);
+        return null;
+      }
+      const hash = (await blob.text()).trim();
+      if (!isBlurhashValid(hash).result) {
+        this.settings?.logger?.warn({ path }, 'blurhash sidecar holds an invalid hash');
+        missingBlurhash.add(cacheKey);
+        return null;
+      }
+      return hash;
+    } catch (error) {
+      // Transient failure: do NOT negative-cache, the next mount may succeed.
+      this.settings?.logger?.warn({ error, path }, 'blurhash sidecar read failed');
+      return null;
+    }
+  }
+
+  async get(path: string): Promise<unknown> {
+    const [result] = await this.remote.query<[unknown]>(
+      `RETURN f"${this.bucketName}:/${path}".get();`
+    );
+    return result;
+  }
+
+  /**
+   * Read through the local blob cache: OPFS first, the bucket second. Unlike
+   * {@link get} this survives a reload and works offline. Returns null when the
+   * file exists in neither place.
+   */
+  async read(path: string, options?: BlobReadOptions): Promise<Blob | null> {
+    if (!this.blobs) return bucketContentToBlob(await this.get(path));
+    return this.blobs.read({ bucket: this.bucketName, path }, options);
+  }
+
+  /**
+   * A refcounted object URL for `path`, suitable for `<img src>`. The caller
+   * MUST call `release()` when the URL goes off screen. Returns null when the
+   * file does not exist, or when object URLs are unavailable (non-browser).
+   */
+  async url(path: string, options?: BlobReadOptions): Promise<BlobUrlLease | null> {
+    if (!this.blobs) return null;
+    return this.blobs.acquireUrl({ bucket: this.bucketName, path }, options);
+  }
+
+  /** Exempt `path` from pressure eviction. Pinned bytes never expire. */
+  pin(path: string): void {
+    this.blobs?.setPinned({ bucket: this.bucketName, path }, true);
+  }
+
+  unpin(path: string): void {
+    this.blobs?.setPinned({ bucket: this.bucketName, path }, false);
+  }
+
+  /** Drop `path` from the local cache without touching the remote file. */
+  async evict(path: string): Promise<void> {
+    await this.blobs?.invalidate({ bucket: this.bucketName, path });
+  }
+
+  /** Warm the cache for offline use. Already-cached paths are skipped. */
+  async prefetch(paths: string[]): Promise<void> {
+    await this.blobs?.prefetch(paths.map((path) => ({ bucket: this.bucketName, path })));
+  }
+
+  async delete(path: string): Promise<void> {
+    await this.remote.query(`RETURN f"${this.bucketName}:/${path}".delete();`);
+    await this.blobs?.invalidate({ bucket: this.bucketName, path });
+    // Symmetry with put: an image's blurhash sidecar dies with it. Best-effort,
+    // the sidecar may simply not exist.
+    if (isImagePath(path)) {
+      const sidecar = blurhashSidecarPath(path);
+      try {
+        await this.remote.query(`RETURN f"${this.bucketName}:/${sidecar}".delete();`);
+        await this.blobs?.invalidate({ bucket: this.bucketName, path: sidecar });
+      } catch {
+        // Nothing to clean up.
+      }
+      missingBlurhash.delete(`${this.bucketName}:${path}`);
+    }
+  }
+
+  async exists(path: string): Promise<boolean> {
+    const [result] = await this.remote.query<[boolean]>(
+      `RETURN f"${this.bucketName}:/${path}".exists();`
+    );
+    return result;
+  }
+
+  async head(path: string): Promise<Record<string, unknown>> {
+    const [result] = await this.remote.query<[Record<string, unknown>]>(
+      `RETURN f"${this.bucketName}:/${path}".head();`
+    );
+    return result;
+  }
+
+  async copy(sourcePath: string, targetPath: string): Promise<void> {
+    await this.remote.query(`RETURN f"${this.bucketName}:/${sourcePath}".copy($target);`, {
+      target: targetPath,
+    });
+  }
+
+  async rename(sourcePath: string, targetPath: string): Promise<void> {
+    await this.remote.query(`RETURN f"${this.bucketName}:/${sourcePath}".rename($target);`, {
+      target: targetPath,
+    });
+  }
+
+  async list(prefix?: string): Promise<string[]> {
+    const p = prefix ?? '';
+    const [result] = await this.remote.query<[string[]]>(
+      `RETURN f"${this.bucketName}:/${p}".list();`
+    );
+    return result;
+  }
+}
+

package/src/client/router.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+import type { RuntimeEvent } from '../kernel/events';
+import { defaultEnv } from '../query/env';
+import { route } from './router';
+
+const env = defaultEnv({ tables: [] } as any);
+
+describe('route', () => {
+  it('maps every event to a saga and the documented lane', () => {
+    const cases: Array<[RuntimeEvent, string | undefined]> = [
+      [{ type: 'EnsureRegistered' }, 'serial:ensure'],
+      [{ type: 'RegisterRemote', hash: 'h' }, 'dedupe:register:h'],
+      [{ type: 'ReadDirtyMembership' }, 'serial:membership'],
+      [{ type: 'ReadMembership', hashes: ['h'] }, 'serial:membership'],
+      [{ type: 'FetchRows' }, 'serial:fetch'],
+      [{ type: 'Materialize', hash: 'h' }, 'serial:mat:h'],
+      [{ type: 'MaterializeDirty' }, undefined],
+      [{ type: 'StreamUpdate', update: { queryHash: 'h', localArray: [] } }, 'serial:stream:h'],
+      [{ type: 'LifecycleTick' }, 'dedupe:lifecycle'],
+      [{ type: 'HeartbeatNow' }, 'dedupe:lifecycle'],
+      [{ type: 'AckPrune' }, 'dedupe:ack-prune'],
+      [{ type: 'GcTick' }, 'dedupe:gc'],
+      [{ type: 'Drain' }, 'serial:outbox'],
+      [{ type: 'FlushWrite', key: 'k' }, 'serial:outbox-write'],
+      [{ type: 'PollTick' }, 'dedupe:poll'],
+      [{ type: 'SelfHealTick' }, 'dedupe:heal'],
+      [{ type: 'SyncOutcome', ok: true }, 'serial:health'],
+      [{ type: 'ConnectionChanged', state: 'connected' }, 'serial:connection'],
+      [{ type: 'LiveStart' }, 'serial:live'],
+      [{ type: 'LiveChange', hashes: [] }, 'serial:live-change'],
+      [{ type: 'TabRole', role: 'leader' }, 'serial:tabs'],
+      [{ type: 'TabMessage', message: {} }, 'serial:tabs'],
+      [{ type: 'StartRemote' }, 'dedupe:start-remote'],
+      [{ type: 'PrimeCircuit' }, 'dedupe:prime'],
+      [{ type: 'VersionsPrimed', entries: [] }, undefined],
+      [{ type: 'WarmBlobs' }, 'dedupe:blobs'],
+      [{ type: 'AuthFlip', userId: null }, 'serial:bucket'],
+      [{ type: 'BucketSwitch', target: 'x' }, 'serial:bucket'],
+      [{ type: 'PageHide' }, undefined],
+    ];
+    for (const [event, lane] of cases) {
+      const target = route(env, event);
+      expect(typeof target.saga.next).toBe('function');
+      expect(target.lane ? `${target.lane.kind}:${target.lane.key}` : undefined).toBe(lane);
+      target.saga.return(undefined);
+    }
+  });
+  it('MaterializeDirty fans out one Materialize per dirty hash', async () => {
+    const { runPure } = await import('../testing/run-pure');
+    const { buildEntry, buildState } = await import('../testing/build');
+    const R = await import('../state/reducers');
+    const s = R.markDirty(['a', 'b'])(buildState([buildEntry({ def: { hash: 'a' } }), buildEntry({ def: { hash: 'b' } })]));
+    const out = await runPure(route(env, { type: 'MaterializeDirty' }).saga, { state: s });
+    expect(out.dispatched).toEqual([{ type: 'Materialize', hash: 'a' }, { type: 'Materialize', hash: 'b' }]);
+  });
+});

package/src/client/router.ts

@@ -0,0 +1,96 @@
+import type { RuntimeEvent } from '../kernel/events';
+import type { Lane, Saga } from '../kernel/saga';
+import type { SagaEnv } from '../query/env';
+import { ensureRegistered, registerRemote } from '../query/register.saga';
+import { readDirtyMembership, readMembership, recoverLostView } from '../query/membership.saga';
+import { fetchRows } from '../query/fetch.saga';
+import { materialize, streamUpdate } from '../query/materialize.saga';
+import { ackPrune, gcTick, lifecycleTick } from '../query/lifecycle.saga';
+import { drain } from '../mutation/push.saga';
+import { flushWrite } from '../mutation/write.saga';
+import { pollTick } from '../sync/poll.saga';
+import { liveChange, liveStart } from '../sync/live.saga';
+import { connectionChanged, selfHealTick, syncOutcome } from '../sync/connection.saga';
+import { setRole, tabMessage } from '../sync/tabs.saga';
+import { pageHide, primeCircuit, startRemote, versionsPrimed, warmBlobs } from '../boot/boot.saga';
+import { authFlip } from '../boot/auth-flip.saga';
+import { bucketSwitch } from '../boot/bucket-switch.saga';
+import { fx } from '../kernel/effects';
+
+export interface RouteTarget {
+  saga: Saga<unknown>;
+  lane?: Lane;
+}
+
+const serial = (key: string): Lane => ({ kind: 'serial', key });
+const dedupe = (key: string): Lane => ({ kind: 'dedupe', key });
+
+function* materializeDirty(): Saga<void> {
+  const dirty = (yield fx.state.read((s) => [...s.dirty])) as string[];
+  for (const hash of dirty) yield fx.dispatch({ type: 'Materialize', hash });
+}
+
+/** One table: which saga handles an event, and on which lane. */
+export function route(env: SagaEnv, event: RuntimeEvent): RouteTarget {
+  switch (event.type) {
+    case 'EnsureRegistered':
+      return { saga: ensureRegistered(env, { requireAuth: event.requireAuth, attempt: event.attempt }), lane: serial('ensure') };
+    case 'RegisterRemote':
+      return { saga: registerRemote(env, event.hash, event.retry), lane: dedupe(`register:${event.hash}`) };
+    case 'RecoverLostView':
+      return { saga: recoverLostView(event.hash), lane: dedupe(`view-lost:${event.hash}`) };
+    case 'ReadDirtyMembership':
+      return { saga: readDirtyMembership(env), lane: serial('membership') };
+    case 'ReadMembership':
+      return { saga: readMembership(env, event.hashes, { force: true }), lane: serial('membership') };
+    case 'FetchRows':
+      return { saga: fetchRows(env), lane: serial('fetch') };
+    case 'Materialize':
+      return { saga: materialize(event.hash), lane: serial(`mat:${event.hash}`) };
+    case 'MaterializeDirty':
+      return { saga: materializeDirty() };
+    case 'StreamUpdate':
+      return { saga: streamUpdate(event.update), lane: serial(`stream:${event.update.queryHash}`) };
+    case 'LifecycleTick':
+    case 'HeartbeatNow':
+      return { saga: lifecycleTick(env), lane: dedupe('lifecycle') };
+    case 'AckPrune':
+      return { saga: ackPrune(), lane: dedupe('ack-prune') };
+    case 'GcTick':
+      return { saga: gcTick(), lane: dedupe('gc') };
+    case 'Drain':
+      return { saga: drain(env), lane: serial('outbox') };
+    case 'FlushWrite':
+      return { saga: flushWrite(env, event.key), lane: serial('outbox-write') };
+    case 'PollTick':
+      return { saga: pollTick(env), lane: dedupe('poll') };
+    case 'SelfHealTick':
+      return { saga: selfHealTick(env), lane: dedupe('heal') };
+    case 'SyncOutcome':
+      return { saga: syncOutcome(env, event.ok, event.error), lane: serial('health') };
+    case 'ConnectionChanged':
+      return { saga: connectionChanged(env, event.state), lane: serial('connection') };
+    case 'LiveStart':
+      return { saga: liveStart(env), lane: serial('live') };
+    case 'LiveChange':
+      return { saga: liveChange(env, event.hashes, event.rows), lane: serial('live-change') };
+    case 'TabRole':
+      return { saga: setRole(env, event.role), lane: serial('tabs') };
+    case 'TabMessage':
+      return { saga: tabMessage(env, event.message), lane: serial('tabs') };
+    case 'StartRemote':
+      return { saga: startRemote(), lane: dedupe('start-remote') };
+    case 'PrimeCircuit':
+      return { saga: primeCircuit(), lane: dedupe('prime') };
+    case 'VersionsPrimed':
+      return { saga: versionsPrimed(event.entries) };
+    case 'WarmBlobs':
+      return { saga: warmBlobs(), lane: dedupe('blobs') };
+    case 'AuthFlip':
+      return { saga: authFlip(env, event.userId), lane: serial('bucket') };
+    case 'BucketSwitch':
+      return { saga: bucketSwitch(env, event.target), lane: serial('bucket') };
+    case 'PageHide':
+      return { saga: pageHide() };
+  }
+}