cursedbelt 2.8.0 → 3.0.0

package/src/server/storage/files/adapter.photo.spec.ts

@@ -1,128 +0,0 @@
-import { Database } from 'bun:sqlite';
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { runMigrations } from '../../migration/runner';
-import { createDiskStore } from '../diskStore';
-import type { MediaUrls } from '../sources';
-import type { MediaCtx } from '../types';
-import { createCataloguePhotoSource } from './adapter';
-import { createSqliteFileCatalogue } from './catalogue';
-import type { FileUrls } from './fileRoutes';
-import { FILE_CATALOGUE_MIGRATIONS } from './migrations';
-import type { FileCatalogue, PrivateFileCatalogue } from './types';
-
-// The photo source is an image-filtered VIEW over the catalogue: primary bytes via the file
-// route URL, grid thumb via the type-agnostic poster URL (only when the thumbnailer produced one).
-
-const CTX: MediaCtx = { userId: 'u1', tenantId: 't1' };
-const stream = (s: string) =>
-  new Response(new TextEncoder().encode(s)).body as ReadableStream<Uint8Array>;
-
-const fakeFileUrls: FileUrls = {
-  async build(_ctx, fileId, mime) {
-    return { url: `/_files/s/tok/${fileId}?ct=${encodeURIComponent(mime)}` };
-  },
-};
-const fakeMediaUrls: MediaUrls = {
-  async build(_ctx, sourceId, videoId) {
-    const p = `/_media/s/tok/${sourceId}/${videoId}`;
-    return {
-      streamUrl: `${p}/media`,
-      hlsUrl: `${p}/hls`,
-      posterUrl: `${p}/poster`,
-      displayUrl: `${p}/display`,
-      vttUrl: `${p}/vtt`,
-      spriteUrl: `${p}/sprite`,
-    };
-  },
-};
-
-describe('createCataloguePhotoSource', () => {
-  let db: Database;
-  let root: string;
-  let cat: FileCatalogue & PrivateFileCatalogue;
-  let photoId: string;
-  let videoId: string;
-
-  beforeAll(async () => {
-    db = new Database(':memory:');
-    runMigrations(db, FILE_CATALOGUE_MIGRATIONS);
-    root = await mkdtemp(path.join(tmpdir(), 'fc-photo-'));
-    let clock = 1;
-    cat = createSqliteFileCatalogue({
-      db,
-      store: createDiskStore(root),
-      workDir: path.join(root, 'w'),
-      owner: (c) => c.userId,
-      now: () => ++clock,
-    });
-  });
-  afterAll(async () => {
-    // The fake video's fire-and-forget transcode fails asynchronously — let it settle before
-    // closing the db, or its progress write hits a finalized statement between test files.
-    for (let i = 0; i < 40; i++) {
-      const status = (await cat.get(CTX, videoId))?.processingStatus;
-      if (status && status !== 'processing' && status !== 'pending') break;
-      await new Promise((r) => setTimeout(r, 50));
-    }
-    db.close();
-    await rm(root, { recursive: true, force: true });
-  });
-
-  const source = () =>
-    createCataloguePhotoSource({
-      id: 'photos',
-      title: 'Photos',
-      catalogue: cat,
-      fileUrls: fakeFileUrls,
-      mediaUrls: fakeMediaUrls,
-    });
-
-  test('lists ONLY images — video/doc rows are invisible to the photo view', async () => {
-    const img = await cat.ingest(CTX, {
-      name: 'a.jpg',
-      // a fake-jpeg text body: fine — the thumbnailer fails quietly and has_thumbnail stays 0
-      mime: 'image/jpeg',
-      body: stream('img-bytes'),
-      tags: ['trip'],
-    });
-    photoId = img.id;
-    videoId = (await cat.ingest(CTX, { name: 'b.mp4', mime: 'video/mp4', body: stream('vid') })).id;
-    await cat.ingest(CTX, { name: 'c.txt', mime: 'text/plain', body: stream('txt') });
-
-    const page = await source().list(CTX, {});
-    expect(page.items.map((p) => p.name)).toEqual(['a.jpg']);
-    const photo = page.items[0];
-    expect(photo.type).toBe('image');
-    expect(photo.url).toBe(`/_files/s/tok/${photoId}?ct=image%2Fjpeg`);
-    expect(photo.thumbnailUrl).toBeUndefined(); // no thumbnail produced for fake bytes
-    expect(photo.tags).toEqual(['trip']);
-  });
-
-  test('resolve: image → GalleryPhoto; non-image id → null', async () => {
-    expect((await source().resolve(CTX, photoId))?.name).toBe('a.jpg');
-    const all = await cat.list(CTX, {});
-    const video = all.items.find((f) => f.fileType === 'video');
-    expect(await source().resolve(CTX, video?.id ?? '')).toBeNull();
-  });
-
-  test('ingest rejects non-image uploads', async () => {
-    expect(
-      source().ingest?.(CTX, { name: 'x.mp4', mime: 'video/mp4', body: stream('v') }),
-    ).rejects.toThrow(/image/);
-  });
-
-  test('remove trashes (soft-deletes) through to the catalogue, not a hard delete', async () => {
-    const rec = await cat.ingest(CTX, {
-      name: 'gone.png',
-      mime: 'image/png',
-      body: stream('bye'),
-    });
-    await source().remove?.(CTX, rec.id);
-    // Trashed, not gone — the row + bytes survive until an explicit hard-delete (catalogue.remove).
-    expect((await cat.get(CTX, rec.id))?.trashedAt).toBeDefined();
-    expect((await source().list(CTX, {})).items.some((p) => p.id === rec.id)).toBe(false);
-  });
-});

package/src/server/storage/files/adapter.spec.ts

@@ -1,121 +0,0 @@
-import { Database } from 'bun:sqlite';
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { runMigrations } from '../../migration/runner';
-import { createDiskStore } from '../diskStore';
-import type { MediaUrls } from '../sources';
-import type { MediaCtx } from '../types';
-import { createCatalogueVideoSource, createFileToPlayable } from './adapter';
-import { createSqliteFileCatalogue } from './catalogue';
-import { FILE_CATALOGUE_MIGRATIONS } from './migrations';
-import type { FileCatalogue, FileRecord } from './types';
-
-const CTX: MediaCtx = { userId: 'u1', tenantId: 't1' };
-const stream = (s: string) =>
-  new Response(new TextEncoder().encode(s)).body as ReadableStream<Uint8Array>;
-
-// A fake URL builder — the real one signs a token; here we just echo the ids so the adapter's
-// URL wiring is testable without a signing service.
-const fakeUrls: MediaUrls = {
-  async build(_ctx, sourceId, videoId) {
-    const p = `/_media/s/tok/${sourceId}/${videoId}`;
-    return {
-      streamUrl: `${p}/media`,
-      hlsUrl: `${p}/hls`,
-      posterUrl: `${p}/poster`,
-      displayUrl: `${p}/display`,
-      vttUrl: `${p}/vtt`,
-      spriteUrl: `${p}/sprite`,
-    };
-  },
-};
-
-const videoRecord = (over: Partial<FileRecord> = {}): FileRecord => ({
-  id: 'v1',
-  name: 'clip.mp4',
-  mime: 'video/mp4',
-  size: 10,
-  fileType: 'video',
-  tags: ['fun'],
-  isPrivate: false,
-  favorite: false,
-  collectionIds: [],
-  hasThumbnail: true,
-  hasHls: true,
-  hasSprites: false,
-  durationSeconds: 12,
-  processingStatus: 'ready',
-  processingProgress: 100,
-  createdAt: 1,
-  updatedAt: 1,
-  ...over,
-});
-
-describe('createFileToPlayable', () => {
-  const toPlayable = createFileToPlayable(fakeUrls, 'files');
-
-  test('maps a ready video, gating optional URLs on capability flags', async () => {
-    const p = await toPlayable(CTX, videoRecord());
-    expect(p).not.toBeNull();
-    expect(p?.streamUrl).toBe('/_media/s/tok/files/v1/media');
-    expect(p?.hlsUrl).toBe('/_media/s/tok/files/v1/hls'); // hasHls
-    expect(p?.posterUrl).toBe('/_media/s/tok/files/v1/poster'); // hasThumbnail
-    expect(p?.vttUrl).toBeUndefined(); // hasSprites false
-    expect(p?.spriteUrl).toBeUndefined();
-    expect(p?.tags).toEqual(['fun']);
-    expect(p?.processingStatus).toBe('ready');
-  });
-
-  test('returns null for a non-video file', async () => {
-    expect(await toPlayable(CTX, videoRecord({ fileType: 'image', mime: 'image/png' }))).toBeNull();
-  });
-});
-
-describe('createCatalogueVideoSource (gallery = view over catalogue)', () => {
-  let db: Database;
-  let root: string;
-  let cat: FileCatalogue;
-
-  beforeAll(async () => {
-    db = new Database(':memory:');
-    runMigrations(db, FILE_CATALOGUE_MIGRATIONS);
-    root = await mkdtemp(path.join(tmpdir(), 'fc-adapter-'));
-    let clock = 1;
-    cat = createSqliteFileCatalogue({
-      db,
-      store: createDiskStore(root),
-      workDir: path.join(root, 'w'),
-      now: () => ++clock,
-    });
-    // Mix media types; only videos should surface through the gallery source.
-    await cat.ingest(CTX, { name: 'a.png', mime: 'image/png', body: stream('a'), tags: ['pic'] });
-    await cat.ingest(CTX, { name: 'doc.pdf', mime: 'application/pdf', body: stream('d') });
-  });
-  afterAll(async () => {
-    db.close();
-    await rm(root, { recursive: true, force: true });
-  });
-
-  test('lists only videos (none here) — images/docs are filtered out', async () => {
-    const src = createCatalogueVideoSource({
-      id: 'files',
-      title: 'Files',
-      catalogue: cat,
-      urls: fakeUrls,
-    });
-    const page = await src.list(CTX, {});
-    expect(page.items).toEqual([]); // catalogue has an image + a doc, zero videos
-  });
-
-  test('tags() reflects the catalogue facets', async () => {
-    const src = createCatalogueVideoSource({
-      id: 'files',
-      title: 'Files',
-      catalogue: cat,
-      urls: fakeUrls,
-    });
-    expect(await src.tags?.(CTX)).toContain('pic');
-  });
-});

package/src/server/storage/files/adapter.ts

@@ -1,255 +0,0 @@
-import type { GalleryMedia, GalleryPhoto } from '../../../core/media';
-import { isBrowserRenderableImage } from '../imageThumbnail';
-import type { MediaUrls } from '../sources';
-import type { MediaCtx, MediaGallerySource, MediaSource, PhotoSource } from '../types';
-import type { FileUrls } from './fileRoutes';
-import type { FileCatalogue, FileRecord, FileToPlayable } from './types';
-
-/** Build the image→GalleryPhoto mapper shared by the photo source and the mixed media source.
- * The primary image is served by the file byte route (fileUrls); the grid thumbnail + HEIC
- * display derivative by the type-agnostic poster route (mediaUrls) when ingest produced one. */
-function createFileToPhoto(cfg: {
-  id: string;
-  fileUrls: FileUrls;
-  mediaUrls: MediaUrls;
-}): (ctx: MediaCtx, file: FileRecord) => Promise<GalleryPhoto | null> {
-  return async (ctx, file) => {
-    if (file.fileType !== 'image') return null;
-    const { url } = await cfg.fileUrls.build(ctx, file.id, file.mime);
-    const media = file.hasThumbnail ? await cfg.mediaUrls.build(ctx, cfg.id, file.id) : null;
-    const thumbnailUrl = media?.posterUrl;
-    const displayUrl = media && !isBrowserRenderableImage(file.mime) ? media.displayUrl : undefined;
-    return {
-      id: file.id,
-      type: 'image',
-      url,
-      thumbnailUrl,
-      displayUrl,
-      name: file.name,
-      sizeBytes: file.size,
-      mimeType: file.mime,
-      tags: file.tags,
-      createdAt: file.createdAt,
-      favorite: file.favorite,
-    };
-  };
-}
-
-// ── FileCatalogue → media seam ────────────────────────────────────────────────────
-// The catalogue is the ONE source of truth for a user's binaries. The video gallery is not a
-// separate store — it is a video-filtered VIEW over the catalogue. These two adapters are the
-// seam: `createFileToPlayable` turns a video FileRecord into the player's PlayableVideo (URLs
-// baked server-side via the shared token/serve infra), and `createCatalogueVideoSource` exposes
-// the catalogue as a `MediaSource` so the existing `mountMediaRoutes` + gallery serve it
-// unchanged. Because the serve routes address bytes by (owner, videoId) through the shared
-// keyspace, a catalogue video is served by the same routes regardless of `sourceId`.
-
-/** Resolve a video FileRecord to a PlayableVideo with tokenised URLs. Non-video ⇒ null. */
-export function createFileToPlayable(urls: MediaUrls, sourceId: string): FileToPlayable {
-  return async (ctx, file) => {
-    if (file.fileType !== 'video') return null;
-    const u = await urls.build(ctx, sourceId, file.id);
-    return {
-      id: file.id,
-      name: file.name,
-      streamUrl: u.streamUrl,
-      hlsUrl: file.hasHls ? u.hlsUrl : undefined,
-      posterUrl: file.hasThumbnail ? u.posterUrl : undefined,
-      vttUrl: file.hasSprites ? u.vttUrl : undefined,
-      spriteUrl: file.hasSprites ? u.spriteUrl : undefined,
-      durationSeconds: file.durationSeconds,
-      tags: file.tags,
-      processingStatus: file.processingStatus,
-      processingProgress: file.processingProgress,
-    };
-  };
-}
-
-/** Expose a FileCatalogue as a video-only `MediaSource` — the gallery is a view, not a store. */
-export function createCatalogueVideoSource(cfg: {
-  id: string;
-  title: string;
-  catalogue: FileCatalogue;
-  urls: MediaUrls;
-}): MediaSource {
-  const toPlayable = createFileToPlayable(cfg.urls, cfg.id);
-  return {
-    id: cfg.id,
-    title: cfg.title,
-
-    async list(ctx, opts) {
-      const page = await cfg.catalogue.list(ctx, {
-        type: 'video',
-        tag: opts.tag,
-        query: opts.query,
-        cursor: opts.cursor,
-        limit: opts.limit,
-        sort: opts.sort,
-      });
-      const items = await Promise.all(page.items.map((f) => toPlayable(ctx, f)));
-      return { items: items.filter((v) => v !== null), nextCursor: page.nextCursor };
-    },
-
-    async resolve(ctx, videoId) {
-      const file = await cfg.catalogue.get(ctx, videoId);
-      return file ? toPlayable(ctx, file) : null;
-    },
-
-    async tags(ctx) {
-      return (await cfg.catalogue.tagFacets(ctx)).map((f) => f.tag);
-    },
-
-    async ingest(ctx, upload) {
-      const file = await cfg.catalogue.ingest(ctx, upload);
-      const playable = await toPlayable(ctx, file);
-      if (!playable) throw new Error('gallery ingest expects a video file');
-      return playable;
-    },
-
-    async remove(ctx, videoId) {
-      await cfg.catalogue.trash(ctx, videoId);
-    },
-
-    async recordView(ctx, videoId) {
-      await cfg.catalogue.recordView(ctx, videoId);
-    },
-  };
-}
-
-// ── Photo view ────────────────────────────────────────────────────────────────────
-// The photo gallery is the image-filtered sibling of the video view: same catalogue, same
-// token/serve infra. The primary image is served by the file byte route (fileUrls) and the grid
-// thumbnail by the type-agnostic poster route (mediaUrls) when the ingest thumbnailer produced
-// one — so a PhotoSource needs BOTH URL builders.
-
-/** Expose a FileCatalogue as an image-only `PhotoSource` — a view, not a store. */
-export function createCataloguePhotoSource(cfg: {
-  id: string;
-  title: string;
-  catalogue: FileCatalogue;
-  fileUrls: FileUrls;
-  mediaUrls: MediaUrls;
-}): PhotoSource {
-  const toPhoto = createFileToPhoto(cfg);
-
-  return {
-    id: cfg.id,
-    title: cfg.title,
-
-    async list(ctx, opts) {
-      const page = await cfg.catalogue.list(ctx, {
-        type: 'image',
-        tag: opts.tag,
-        query: opts.query,
-        cursor: opts.cursor,
-        limit: opts.limit,
-        sort: opts.sort,
-      });
-      const items = await Promise.all(page.items.map((f) => toPhoto(ctx, f)));
-      return { items: items.filter((p) => p !== null), nextCursor: page.nextCursor };
-    },
-
-    async resolve(ctx, photoId) {
-      const file = await cfg.catalogue.get(ctx, photoId);
-      return file ? toPhoto(ctx, file) : null;
-    },
-
-    async tags(ctx) {
-      return (await cfg.catalogue.tagFacets(ctx)).map((f) => f.tag);
-    },
-
-    async ingest(ctx, upload) {
-      if (!upload.mime.startsWith('image/')) {
-        throw new Error('photo ingest expects an image file');
-      }
-      const file = await cfg.catalogue.ingest(ctx, upload);
-      const photo = await toPhoto(ctx, file);
-      if (!photo) throw new Error('photo ingest expects an image file');
-      return photo;
-    },
-
-    async remove(ctx, photoId) {
-      await cfg.catalogue.trash(ctx, photoId);
-    },
-
-    async recordView(ctx, photoId) {
-      await cfg.catalogue.recordView(ctx, photoId);
-    },
-  };
-}
-
-// ── Mixed media view ───────────────────────────────────────────────────────────────
-// A combined gallery lists BOTH photos and videos from the one catalogue. This adapter
-// reuses the same two mappers (`createFileToPlayable`, `createFileToPhoto`) so a mixed
-// item renders identically to its single-type sibling — it just tags each with
-// `mediaKind` for the UI to pick a tile/stage. It needs BOTH URL builders (video streams
-// + image bytes/poster). A `kind` filter maps to the catalogue's `type`; `all` lists
-// untyped and keeps only image|video (dropping docs/audio the mixed gallery can't show).
-
-/** Expose a FileCatalogue as a `MediaGallerySource` — photos + videos in one feed.
- * Videos are tokenised under `videoSourceId` (must match the registered video source so
- * `mountMediaRoutes` serves their streams); photo posters/thumbnails under this source's `id`. */
-export function createCatalogueMediaSource(cfg: {
-  id: string;
-  title: string;
-  catalogue: FileCatalogue;
-  urls: MediaUrls;
-  fileUrls: FileUrls;
-  /** SourceId the video stream tokens are minted under. Default `id`. */
-  videoSourceId?: string;
-}): MediaGallerySource {
-  const toPlayable = createFileToPlayable(cfg.urls, cfg.videoSourceId ?? cfg.id);
-  const toPhoto = createFileToPhoto({ id: cfg.id, fileUrls: cfg.fileUrls, mediaUrls: cfg.urls });
-
-  const toMedia = async (ctx: MediaCtx, file: FileRecord): Promise<GalleryMedia | null> => {
-    if (file.fileType === 'video') {
-      const v = await toPlayable(ctx, file);
-      return v ? { ...v, mediaKind: 'video' } : null;
-    }
-    if (file.fileType === 'image') {
-      const p = await toPhoto(ctx, file);
-      return p ? { ...p, mediaKind: 'photo' } : null;
-    }
-    return null;
-  };
-
-  return {
-    id: cfg.id,
-    title: cfg.title,
-
-    async list(ctx, opts) {
-      // `all` ⇒ no catalogue type filter, then drop non-image/video below.
-      const type = opts.kind === 'image' ? 'image' : opts.kind === 'video' ? 'video' : undefined;
-      const page = await cfg.catalogue.list(ctx, {
-        type,
-        tag: opts.tag,
-        query: opts.query,
-        cursor: opts.cursor,
-        limit: opts.limit,
-        sort: opts.sort,
-      });
-      const items = await Promise.all(page.items.map((f) => toMedia(ctx, f)));
-      return {
-        items: items.filter((m): m is GalleryMedia => m !== null),
-        nextCursor: page.nextCursor,
-      };
-    },
-
-    async resolve(ctx, itemId) {
-      const file = await cfg.catalogue.get(ctx, itemId);
-      return file ? toMedia(ctx, file) : null;
-    },
-
-    async tags(ctx) {
-      return (await cfg.catalogue.tagFacets(ctx)).map((f) => f.tag);
-    },
-
-    async remove(ctx, itemId) {
-      await cfg.catalogue.trash(ctx, itemId);
-    },
-
-    async recordView(ctx, itemId) {
-      await cfg.catalogue.recordView(ctx, itemId);
-    },
-  };
-}

package/src/server/storage/files/catalogue.media-host.spec.ts

@@ -1,184 +0,0 @@
-import { Database } from 'bun:sqlite';
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { runMigrations } from '../../migration/runner';
-import {
-  cryptBlobStream,
-  derivePasswordSetKey,
-  generateUserSalt,
-  openMeta,
-  unwrapContentKey,
-} from '../../private-media/crypto';
-import { createDiskStore } from '../diskStore';
-import { fsPosterKey, type MediaCtx, type MediaStore, privateSourceKey } from '../types';
-import { createSqliteFileCatalogue, fileBinaryKey } from './catalogue';
-import { FILE_CATALOGUE_MIGRATIONS } from './migrations';
-import type { FileCatalogue, PrivateFileCatalogue } from './types';
-import { bytesStream } from '../../../testing/bytes';
-
-// New media-host capabilities: private NON-video blobs (photos), in-place byte replacement
-// (the editor's "overwrite original"), and ingest-time image thumbnails.
-
-const CTX: MediaCtx = { userId: 'u1', tenantId: 't1' };
-const OWNER = CTX.userId;
-const stream = bytesStream;
-const drain = async (s: ReadableStream<Uint8Array>): Promise<Uint8Array> =>
-  new Uint8Array(await new Response(s).arrayBuffer());
-
-let db: Database;
-let root: string;
-let store: MediaStore;
-let cat: FileCatalogue & PrivateFileCatalogue;
-
-beforeAll(async () => {
-  db = new Database(':memory:');
-  runMigrations(db, FILE_CATALOGUE_MIGRATIONS);
-  root = await mkdtemp(path.join(tmpdir(), 'fc-host-'));
-  store = createDiskStore(root);
-  let clock = 1;
-  cat = createSqliteFileCatalogue({
-    db,
-    store,
-    workDir: path.join(root, 'w'),
-    owner: (c) => c.userId,
-    now: () => ++clock,
-  });
-});
-afterAll(async () => {
-  db.close();
-  await rm(root, { recursive: true, force: true });
-});
-
-describe('private blob ingest (non-video)', () => {
-  const salt = generateUserSalt();
-  const setKey = derivePasswordSetKey('photo-pass', salt);
-  const plaintext = new TextEncoder().encode('these are secret photo bytes — not for the feed');
-  let id: string;
-
-  test('ingests an image as a ready, encrypted blob (no ffmpeg involved)', async () => {
-    const item = await cat.ingestPrivate(
-      CTX,
-      { name: 'secret.jpg', mime: 'image/jpeg', body: stream(plaintext), tags: ['hidden'] },
-      { setKey, keyMode: 'deniable' },
-    );
-    id = item.id;
-    expect(item.processingStatus).toBe('ready');
-    expect(item.size).toBe(plaintext.byteLength);
-    expect(item.hasHls).toBe(false);
-  });
-
-  test('stored bytes are ciphertext; the wrapped content key decrypts them', async () => {
-    const stored = await store.get(privateSourceKey(OWNER, id));
-    expect(stored).not.toBeNull();
-    expect(stored?.byteLength).toBe(plaintext.byteLength); // CTR is length-preserving
-    expect(Buffer.from(stored as Uint8Array).equals(Buffer.from(plaintext))).toBe(false);
-
-    const item = await cat.asPrivateIndex().get(OWNER, id);
-    const content = unwrapContentKey(setKey, item?.wrappedContentKey ?? '');
-    expect(content).not.toBeNull();
-    const decrypted = await drain(
-      cryptBlobStream(content as NonNullable<typeof content>, stream(stored as Uint8Array)),
-    );
-    expect(Buffer.from(decrypted).equals(Buffer.from(plaintext))).toBe(true);
-  });
-
-  test('the sealed descriptor reveals name/mime/tags to its set key only', async () => {
-    const item = await cat.asPrivateIndex().get(OWNER, id);
-    const meta = openMeta<{ name: string; mime: string; tags: string[] }>(
-      setKey,
-      item?.sealedMeta ?? '',
-    );
-    expect(meta).toEqual({ name: 'secret.jpg', mime: 'image/jpeg', tags: ['hidden'] });
-    expect(openMeta(derivePasswordSetKey('wrong', salt), item?.sealedMeta ?? '')).toBeNull();
-  });
-
-  test('index.remove wipes the ciphertext blob too', async () => {
-    await cat.asPrivateIndex().remove(OWNER, id);
-    expect(await store.get(privateSourceKey(OWNER, id))).toBeNull();
-  });
-});
-
-describe('replaceContent — overwrite bytes, keep identity', () => {
-  let id: string;
-  let collectionId: string;
-
-  test('setup: ingest a tagged, collected, favorited doc', async () => {
-    const rec = await cat.ingest(CTX, {
-      name: 'notes.txt',
-      mime: 'text/plain',
-      body: stream('v1 bytes'),
-      tags: ['keep-me'],
-    });
-    id = rec.id;
-    const coll = await cat.createCollection(CTX, { name: 'Stuff' });
-    collectionId = coll.id;
-    await cat.addToCollection(CTX, collectionId, [id]);
-    await cat.setFavorite(CTX, id, true);
-  });
-
-  test('replaces bytes + re-derives mime/size/type while identity survives', async () => {
-    const updated = await cat.replaceContent(CTX, id, {
-      mime: 'application/pdf',
-      body: stream('v2 much longer replacement bytes'),
-      name: 'notes.pdf',
-    });
-    expect(updated?.id).toBe(id);
-    expect(updated?.name).toBe('notes.pdf');
-    expect(updated?.mime).toBe('application/pdf');
-    expect(updated?.fileType).toBe('doc');
-    expect(updated?.size).toBe('v2 much longer replacement bytes'.length);
-    expect(updated?.tags).toEqual(['keep-me']);
-    expect(updated?.favorite).toBe(true);
-    expect(updated?.collectionIds).toContain(collectionId);
-
-    const bytes = await store.get(fileBinaryKey(OWNER, id));
-    expect(new TextDecoder().decode(bytes as Uint8Array)).toBe('v2 much longer replacement bytes');
-  });
-
-  test('unknown id → null; private rows refuse replacement', async () => {
-    expect(await cat.replaceContent(CTX, 'nope', { mime: 'text/plain', body: stream('x') })).toBe(
-      null,
-    );
-    const salt = generateUserSalt();
-    const priv = await cat.ingestPrivate(
-      CTX,
-      { name: 'p.jpg', mime: 'image/jpeg', body: stream('p') },
-      { setKey: derivePasswordSetKey('pw', salt), keyMode: 'deniable' },
-    );
-    expect(
-      cat.replaceContent(CTX, priv.id, { mime: 'image/jpeg', body: stream('q') }),
-    ).rejects.toThrow(/private/);
-  });
-});
-
-describe('image ingest thumbnails (sharp)', () => {
-  test('an ingested image grows a poster-key thumbnail + has_thumbnail flips', async () => {
-    // A real encoded image, generated by the same optional peer the thumbnailer uses.
-    const sharp = (await import('sharp')).default;
-    const png = await sharp({
-      create: { width: 64, height: 48, channels: 3, background: { r: 200, g: 40, b: 40 } },
-    })
-      .png()
-      .toBuffer();
-
-    const rec = await cat.ingest(CTX, {
-      name: 'photo.png',
-      mime: 'image/png',
-      body: stream(new Uint8Array(png)),
-    });
-    expect(rec.processingStatus).toBe('ready'); // images are ready immediately; thumb is async
-
-    // The thumbnailer is fire-and-forget — poll briefly.
-    let thumbed = false;
-    for (let i = 0; i < 40 && !thumbed; i++) {
-      await new Promise((r) => setTimeout(r, 50));
-      thumbed = (await cat.get(CTX, rec.id))?.hasThumbnail ?? false;
-    }
-    expect(thumbed).toBe(true);
-    const poster = await store.get(fsPosterKey(OWNER, rec.id));
-    expect(poster).not.toBeNull();
-    expect((poster as Uint8Array).byteLength).toBeGreaterThan(0);
-  });
-});