cursedbelt 2.7.0 → 3.0.0

package/src/server/storage/chunked.integration.spec.ts

@@ -1,185 +0,0 @@
-import { Database } from 'bun:sqlite';
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { subtle } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { pickFreePort, startTestServer, type TestServer } from 'cwip/testing';
-import { runMigrations } from '../migration/runner';
-import { createBinaryServerStore } from './binaryServerStore';
-import {
-  type ChunkedUploadService,
-  createChunkedUploadService,
-  createSqliteFileCatalogue,
-  createStorageOpsLedger,
-  FILE_CATALOGUE_MIGRATIONS,
-} from './files';
-import type { MediaCtx } from './types';
-
-// End-to-end PROOF of the large-file (chunked) upload against a REAL binary-server: spawn bs with
-// a boot-registered app (our RS256 public key), then run the exact client flow — init → PUT each
-// chunk DIRECT to bs → bs assembles on the last chunk → complete registers the catalogue row over
-// the assembled bytes — and read the bytes back through the store. Skips cleanly when the local
-// binary-server checkout isn't present (CI / other machines).
-const BS_DIR = process.env.BINARY_SERVER_DIR ?? '';
-const BS_PRESENT = BS_DIR !== '' && existsSync(path.join(BS_DIR, 'src', 'index.ts'));
-const ISSUER = 'https://demo.local';
-const APP_ID = 'demo';
-const CTX: MediaCtx = { userId: 'user-stub', tenantId: 'user-stub' };
-
-const b64url = (b: ArrayBuffer | Uint8Array) =>
-  Buffer.from(b instanceof Uint8Array ? b : new Uint8Array(b)).toString('base64url');
-const jsonSeg = (o: unknown) => b64url(new TextEncoder().encode(JSON.stringify(o)));
-const pem = (der: ArrayBuffer, label: string) =>
-  `-----BEGIN ${label}-----\n${(
-    Buffer.from(der)
-      .toString('base64')
-      .match(/.{1,64}/g) ?? []
-  ).join('\n')}\n-----END ${label}-----\n`;
-
-// SKIPPED until a real binary-server checkout is present: point BINARY_SERVER_DIR at one.
-// There is deliberately no default — a published package must not go looking in one machine's
-// directory layout — and `binary-server` has not been re-homed here, so this skips on every host today.
-describe.skipIf(!BS_PRESENT)('chunked upload → real binary-server (integration)', () => {
-  let server: TestServer | null = null;
-  let tmp = '';
-  let base = '';
-  let svc: ChunkedUploadService;
-  let store: ReturnType<typeof createBinaryServerStore>;
-  let signJwt: (claims: Record<string, unknown>) => Promise<string>;
-
-  beforeAll(async () => {
-    // RS256 keypair — bs verifies our tokens with the exported public key; we sign with the private.
-    const kp = await subtle.generateKey(
-      {
-        name: 'RSASSA-PKCS1-v1_5',
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: 'SHA-256',
-      },
-      true,
-      ['sign', 'verify'],
-    );
-    const spki = pem(await subtle.exportKey('spki', kp.publicKey), 'PUBLIC KEY');
-    signJwt = async (claims) => {
-      const now = Math.floor(Date.now() / 1000);
-      const input = `${jsonSeg({ alg: 'RS256', typ: 'JWT' })}.${jsonSeg({ iss: ISSUER, iat: now, exp: now + 3600, ...claims })}`;
-      const sig = await subtle.sign(
-        'RSASSA-PKCS1-v1_5',
-        kp.privateKey,
-        new TextEncoder().encode(input),
-      );
-      return `${input}.${b64url(new Uint8Array(sig))}`;
-    };
-
-    tmp = await mkdtemp(path.join(tmpdir(), 'bs-int-'));
-    const port = await pickFreePort();
-    server = await startTestServer({
-      cwd: BS_DIR,
-      cmd: ['bun', path.join(BS_DIR, 'src', 'index.ts')],
-      port,
-      env: {
-        PORT: String(port),
-        HOST: '127.0.0.1',
-        STORAGE_ROOT: path.join(tmp, 'binaries'),
-        DB_PATH: path.join(tmp, 'bs.sqlite'),
-        FILE_TOKEN_PUBLIC_KEY: spki,
-        FILE_TOKEN_ISSUER: ISSUER,
-        CA_APP_ID: APP_ID,
-        INTERNAL_SECRET: 'demo-internal',
-      },
-      healthPath: '/healthz',
-      timeoutMs: 90_000,
-    });
-    base = server.baseUrl;
-
-    const signFileToken = (c: {
-      k?: string;
-      p?: string;
-      fn?: string;
-      dl?: 'inline' | 'attachment';
-    }) => signJwt(c);
-    store = createBinaryServerStore({
-      baseUrl: base,
-      appId: APP_ID,
-      signFileToken,
-      internalSecret: 'demo-internal',
-    });
-    const db = new Database(':memory:');
-    runMigrations(db, FILE_CATALOGUE_MIGRATIONS);
-    const catalogue = createSqliteFileCatalogue({
-      db,
-      store,
-      workDir: path.join(tmp, 'work'),
-      owner: (c) => c.userId,
-    });
-    const ledger = createStorageOpsLedger(db);
-    svc = createChunkedUploadService({
-      catalogue,
-      ledger,
-      backend: 'binary',
-      chunkSize: 64 * 1024, // small so a modest test file splits into several chunks
-      owner: (c) => c.userId,
-      mintChunkUpload: async ({ key, sid, ci, tc, owner }) => {
-        const token = await signJwt({
-          k: `${APP_ID}/${key}`,
-          uid: owner,
-          sid,
-          ci,
-          tc,
-        });
-        return `${base}/upload-chunk/${APP_ID}/${key}?token=${encodeURIComponent(token)}`;
-      },
-    });
-  }, 90_000);
-
-  afterAll(async () => {
-    await server?.stop();
-    if (tmp) await rm(tmp, { recursive: true, force: true });
-  });
-
-  test('uploads a multi-chunk file direct to bs, registers it, and reads the bytes back intact', async () => {
-    // A ~200 KiB payload → 4 chunks at 64 KiB. Deterministic bytes so we can verify integrity.
-    const size = 200 * 1024;
-    const payload = new Uint8Array(size);
-    for (let i = 0; i < size; i++) payload[i] = (i * 31 + 7) & 0xff;
-
-    const init = await svc.init(CTX, {
-      name: 'big.bin',
-      mime: 'application/octet-stream',
-      size,
-      tags: ['large'],
-    });
-    expect(init.chunkCount).toBe(Math.ceil(size / (64 * 1024)));
-    expect(init.chunkUploadUrls).toHaveLength(init.chunkCount);
-
-    // PUT each chunk DIRECT to bs (as the browser would). The last returns 201 assembled.
-    let assembled = false;
-    for (let ci = 0; ci < init.chunkCount; ci++) {
-      const start = ci * init.chunkSize;
-      const slice = payload.slice(start, Math.min(start + init.chunkSize, size));
-      const res = await fetch(init.chunkUploadUrls[ci], {
-        method: 'PUT',
-        headers: { 'content-type': 'application/octet-stream' },
-        body: slice,
-      });
-      expect(res.ok).toBe(true);
-      if (res.status === 201)
-        assembled = ((await res.json()) as { assembled?: boolean }).assembled === true;
-    }
-    expect(assembled).toBe(true); // bs assembled on the final chunk
-
-    // Complete → the catalogue row exists over the already-assembled bytes (no re-upload).
-    const rec = await svc.complete(init.sid, { size });
-    expect(rec?.id).toBe(init.fileId);
-    expect(rec?.name).toBe('big.bin');
-    expect(rec?.tags).toEqual(['large']);
-
-    // Read the assembled bytes back THROUGH the store (bs Range GET) — byte-for-byte intact.
-    const back = await store.get(`fs/${CTX.userId}/${init.fileId}`);
-    expect(back).not.toBeNull();
-    expect(back?.length).toBe(size);
-    expect(Buffer.from(back as Uint8Array).equals(Buffer.from(payload))).toBe(true);
-  }, 30_000);
-});

package/src/server/storage/diskStore.ts

@@ -1,83 +0,0 @@
-import { mkdir, rm, unlink } from 'node:fs/promises';
-import path from 'node:path';
-import type { MediaStore } from './types';
-
-// Local-disk MediaStore (the dev default). Bun-native: Bun.file/Bun.write handle web streams
-// and byte-range slices directly, so there is no node:stream on the hot path. Keys are
-// generated server-side (owner/id…) but we still guard against path traversal so a stored key
-// can never escape the media root.
-export function createDiskStore(root: string): MediaStore {
-  const resolveKey = (key: string): string => {
-    const full = path.join(root, key);
-    const rel = path.relative(root, full);
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
-      throw new Error(`Invalid media key: ${key}`);
-    }
-    return full;
-  };
-
-  return {
-    async put(key, bytes) {
-      // Bun.write creates intermediate directories automatically.
-      await Bun.write(resolveKey(key), bytes);
-    },
-    async putStream(key, body) {
-      const full = resolveKey(key);
-      // Grab the reader BEFORE any real await: in Bun 1.3.x a request-body stream's
-      // internals detach across an I/O tick, after which releaseLock() (and the
-      // async iterator) throw "undefined is not a function" — 500ing every upload.
-      const reader = body.getReader();
-      await mkdir(path.dirname(full), { recursive: true });
-      // Stream through a Bun FileSink — peak memory is one chunk. (NB: `Bun.write(full,
-      // new Response(body))` HANGS on a web ReadableStream in Bun 1.3.x, so we pump manually.)
-      const writer = Bun.file(full).writer();
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          writer.write(value);
-        }
-        await writer.end();
-      } finally {
-        try {
-          reader.releaseLock();
-        } catch {
-          // Same Bun 1.3.x detach bug via a caller-side await (e.g. an async auth
-          // guard): reads still complete, only this cleanup call explodes — and by
-          // here the stream is fully consumed, so there is nothing left to release.
-        }
-      }
-    },
-    async get(key) {
-      const file = Bun.file(resolveKey(key));
-      if (!(await file.exists())) return null;
-      return new Uint8Array(await file.arrayBuffer());
-    },
-    async remove(key) {
-      try {
-        await unlink(resolveKey(key));
-      } catch (err) {
-        if ((err as NodeJS.ErrnoException)?.code !== 'ENOENT') throw err;
-      }
-    },
-    async removePrefix(prefix) {
-      await rm(resolveKey(prefix), { recursive: true, force: true });
-    },
-    async stat(key) {
-      const file = Bun.file(resolveKey(key));
-      if (!(await file.exists())) return null;
-      return { size: file.size };
-    },
-    async getRange(key, range) {
-      const file = Bun.file(resolveKey(key));
-      if (!(await file.exists())) return null;
-      // Bun.file.slice(start, end) is exclusive-end; our ranges are inclusive.
-      const blob = range ? file.slice(range.start, range.end + 1) : file;
-      return { stream: blob.stream() };
-    },
-    async localPath(key) {
-      const full = resolveKey(key);
-      return (await Bun.file(full).exists()) ? full : null;
-    },
-  };
-}

package/src/server/storage/fileUploadClient-chunked.integration.spec.ts

@@ -1,177 +0,0 @@
-import { Database } from 'bun:sqlite';
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { subtle } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { pickFreePort, startTestServer, type TestServer } from 'cwip/testing';
-import { Hono } from 'hono';
-import { createFileUploadClient } from '../../react/media/fileUploadClient';
-import { runMigrations } from '../migration/runner';
-import { createBinaryServerStore } from './binaryServerStore';
-import {
-  createChunkedUploadService,
-  createSqliteFileCatalogue,
-  createStorageOpsLedger,
-  FILE_CATALOGUE_MIGRATIONS,
-} from './files';
-import { mountFileRoutes } from './files/fileRoutes';
-import { createStreamTokenService } from './streamToken';
-import type { MediaCtx } from './types';
-
-// genapp-100: the missing half of the chunked-upload proof. `chunked.integration.spec.ts`
-// drives the SERVICE against a real binary-server; THIS spec drives the BROWSER CLIENT
-// (`fileUploadClient.uploadAuto`) through the real `mountFileRoutes` edge — the exact wire a
-// generated app uses in production — and pins the load-bearing property: the app origin sees
-// ONLY the small init/complete JSON calls, while every chunk PUTs DIRECT to binary-server.
-// Skips cleanly when the local binary-server checkout isn't present (CI / other machines).
-const BS_DIR = process.env.BINARY_SERVER_DIR ?? '';
-const BS_PRESENT = BS_DIR !== '' && existsSync(path.join(BS_DIR, 'src', 'index.ts'));
-const ISSUER = 'https://demo.local';
-const APP_ID = 'demo';
-const CTX: MediaCtx = { userId: 'user-stub', tenantId: 'user-stub' };
-
-const b64url = (b: ArrayBuffer | Uint8Array) =>
-  Buffer.from(b instanceof Uint8Array ? b : new Uint8Array(b)).toString('base64url');
-const jsonSeg = (o: unknown) => b64url(new TextEncoder().encode(JSON.stringify(o)));
-const pem = (der: ArrayBuffer, label: string) =>
-  `-----BEGIN ${label}-----\n${(
-    Buffer.from(der)
-      .toString('base64')
-      .match(/.{1,64}/g) ?? []
-  ).join('\n')}\n-----END ${label}-----\n`;
-
-// SKIPPED until a real binary-server checkout is present: point BINARY_SERVER_DIR at one.
-// There is deliberately no default — a published package must not go looking in one machine's
-// directory layout — and `binary-server` has not been re-homed here, so this skips on every host today.
-describe.skipIf(!BS_PRESENT)('fileUploadClient chunked path → real binary-server (integration)', () => {
-  let server: TestServer | null = null;
-  let tmp = '';
-  let store: ReturnType<typeof createBinaryServerStore>;
-  const app = new Hono();
-  /** Every request the APP ORIGIN handled: [method+path, request body bytes]. */
-  const originRequests: Array<{ path: string; bodyBytes: number }> = [];
-  /** How many chunk PUTs bypassed the origin and hit binary-server directly. */
-  let directChunkPuts = 0;
-
-  beforeAll(async () => {
-    const kp = await subtle.generateKey(
-      {
-        name: 'RSASSA-PKCS1-v1_5',
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: 'SHA-256',
-      },
-      true,
-      ['sign', 'verify'],
-    );
-    const spki = pem(await subtle.exportKey('spki', kp.publicKey), 'PUBLIC KEY');
-    const signJwt = async (claims: Record<string, unknown>) => {
-      const now = Math.floor(Date.now() / 1000);
-      const input = `${jsonSeg({ alg: 'RS256', typ: 'JWT' })}.${jsonSeg({ iss: ISSUER, iat: now, exp: now + 3600, ...claims })}`;
-      const sig = await subtle.sign('RSASSA-PKCS1-v1_5', kp.privateKey, new TextEncoder().encode(input));
-      return `${input}.${b64url(new Uint8Array(sig))}`;
-    };
-
-    tmp = await mkdtemp(path.join(tmpdir(), 'bs-client-int-'));
-    const port = await pickFreePort();
-    server = await startTestServer({
-      cwd: BS_DIR,
-      cmd: ['bun', path.join(BS_DIR, 'src', 'index.ts')],
-      port,
-      env: {
-        PORT: String(port),
-        HOST: '127.0.0.1',
-        STORAGE_ROOT: path.join(tmp, 'binaries'),
-        DB_PATH: path.join(tmp, 'bs.sqlite'),
-        FILE_TOKEN_PUBLIC_KEY: spki,
-        FILE_TOKEN_ISSUER: ISSUER,
-        CA_APP_ID: APP_ID,
-        INTERNAL_SECRET: 'demo-internal',
-      },
-      healthPath: '/healthz',
-      timeoutMs: 90_000,
-    });
-    const base = server.baseUrl;
-
-    store = createBinaryServerStore({
-      baseUrl: base,
-      appId: APP_ID,
-      signFileToken: (c) => signJwt(c),
-      internalSecret: 'demo-internal',
-    });
-    const db = new Database(':memory:');
-    runMigrations(db, FILE_CATALOGUE_MIGRATIONS);
-    const catalogue = createSqliteFileCatalogue({
-      db,
-      store,
-      workDir: path.join(tmp, 'work'),
-      owner: (c) => c.userId,
-    });
-    const svc = createChunkedUploadService({
-      catalogue,
-      ledger: createStorageOpsLedger(db),
-      backend: 'binary',
-      chunkSize: 64 * 1024,
-      owner: (c) => c.userId,
-      mintChunkUpload: async ({ key, sid, ci, tc, owner }) => {
-        const token = await signJwt({ k: `${APP_ID}/${key}`, uid: owner, sid, ci, tc });
-        return `${base}/upload-chunk/${APP_ID}/${key}?token=${encodeURIComponent(token)}`;
-      },
-    });
-    mountFileRoutes(app, {
-      store,
-      token: createStreamTokenService({ secret: 's' }),
-      catalogue,
-      authorizeUpload: () => CTX,
-      chunked: svc,
-    });
-  }, 90_000);
-
-  afterAll(async () => {
-    await server?.stop();
-    await rm(tmp, { recursive: true, force: true });
-  });
-
-  test('uploadAuto splits a large file into direct-to-bs chunk PUTs; the origin sees only init/complete', async () => {
-    // The client's fetch seam is where prod's routing lives: same-origin paths go
-    // to the app, absolute (minted) URLs go straight out to binary-server.
-    const client = createFileUploadClient({
-      authHeaders: () => ({ Authorization: 'Bearer test' }),
-      chunkThreshold: 128 * 1024,
-      fetchImpl: (async (input: RequestInfo | URL, init?: RequestInit) => {
-        const url = String(input);
-        if (url.startsWith('http')) {
-          directChunkPuts++;
-          return fetch(input as string, init);
-        }
-        const bodyBytes =
-          init?.body instanceof Blob ? init.body.size : typeof init?.body === 'string' ? init.body.length : 0;
-        originRequests.push({ path: url, bodyBytes });
-        return app.request(url, init);
-      }) as typeof fetch,
-    });
-
-    // ~1 MiB of deterministic bytes → 16 × 64 KiB chunks, well over the 128 KiB threshold.
-    const bytes = new Uint8Array(1024 * 1024).map((_, i) => (i * 31 + 7) % 256);
-    const file = new File([bytes], 'big-clip.bin', { type: 'application/octet-stream' });
-
-    const result = await client.uploadAuto(file, { tags: ['chunked-proof'] });
-    expect(result.ok).toBe(true);
-    const fileId = result.ok ? (result.file?.id ?? '') : '';
-    expect(fileId.length).toBeGreaterThan(0);
-
-    // Every chunk bypassed the origin…
-    expect(directChunkPuts).toBe(16);
-    // …and the origin handled ONLY small JSON control calls (init + complete):
-    expect(originRequests.map((r) => r.path)).toEqual(['/_files/upload-init', '/_files/upload-complete']);
-    for (const r of originRequests) expect(r.bodyBytes).toBeLessThan(2_048);
-
-    // The assembled object on binary-server is byte-identical to the source (bs Range GET).
-    const back = await store.get(`fs/${CTX.userId}/${fileId}`);
-    expect(back).not.toBeNull();
-    expect(back?.length).toBe(bytes.byteLength);
-    expect(Buffer.from(back as Uint8Array).equals(Buffer.from(bytes))).toBe(true);
-  });
-});

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

@@ -1,169 +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 { isFfmpegAvailable } from '../../media-bun';
-import { runMigrations } from '../../migration/runner';
-import { createDiskStore } from '../diskStore';
-import type { MediaUrls } from '../sources';
-import { fsDisplayKey, 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';
-import { bytesStream } from '../../../testing/bytes';
-
-// End-to-end: an HEIC photo must gain a browser-safe full-size display derivative + advertise it as
-// displayUrl; a normal JPEG must NOT (its raw url is already renderable).
-
-const haveFfmpeg = await isFfmpegAvailable();
-const CTX: MediaCtx = { userId: 'u1', tenantId: 't1' };
-
-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`,
-    };
-  },
-};
-
-/** A real HEVC-in-HEIF still, the format sharp can't decode but ffmpeg can. */
-async function heicBytes(): Promise<Uint8Array | null> {
-  const dir = await mkdtemp(path.join(tmpdir(), 'fc-heic-src-'));
-  const dest = path.join(dir, 'src.heic');
-  const proc = Bun.spawn(
-    [
-      'ffmpeg',
-      '-hide_banner',
-      '-y',
-      '-f',
-      'lavfi',
-      '-i',
-      'testsrc=duration=1:size=800x600:rate=1',
-      '-frames:v',
-      '1',
-      '-c:v',
-      'libx265',
-      '-tag:v',
-      'hvc1',
-      '-f',
-      'hevc',
-      dest,
-    ],
-    { stdout: 'ignore', stderr: 'ignore' },
-  );
-  await proc.exited;
-  if (proc.exitCode !== 0) {
-    await rm(dir, { recursive: true, force: true });
-    return null; // libx265 not built in — caller skips
-  }
-  const bytes = new Uint8Array(await Bun.file(dest).arrayBuffer());
-  await rm(dir, { recursive: true, force: true });
-  return bytes;
-}
-
-// SKIPPED on a host without ffmpeg/ffprobe — it synthesizes and decodes real media. Runs by default wherever ffmpeg is installed.
-describe.skipIf(!haveFfmpeg)('photo display derivative (HEIC)', () => {
-  let db: Database;
-  let root: string;
-  let cat: FileCatalogue & PrivateFileCatalogue;
-
-  beforeAll(async () => {
-    db = new Database(':memory:');
-    runMigrations(db, FILE_CATALOGUE_MIGRATIONS);
-    root = await mkdtemp(path.join(tmpdir(), 'fc-photo-display-'));
-    cat = createSqliteFileCatalogue({
-      db,
-      store: createDiskStore(root),
-      workDir: path.join(root, 'w'),
-      owner: (c) => c.userId,
-    });
-  });
-  afterAll(async () => {
-    db.close();
-    await rm(root, { recursive: true, force: true });
-  });
-
-  const source = () =>
-    createCataloguePhotoSource({
-      id: 'photos',
-      title: 'Photos',
-      catalogue: cat,
-      fileUrls: fakeFileUrls,
-      mediaUrls: fakeMediaUrls,
-    });
-
-  const settle = async (id: string) => {
-    for (let i = 0; i < 60; i++) {
-      if ((await cat.get(CTX, id))?.hasThumbnail) break;
-      await new Promise((r) => setTimeout(r, 50));
-    }
-  };
-
-  test('HEIC → display derivative stored + displayUrl advertised', async () => {
-    const bytes = await heicBytes();
-    if (!bytes) return; // no libx265 in this ffmpeg
-    const rec = await cat.ingest(CTX, {
-      name: 'photo.heic',
-      mime: 'image/heic',
-      body: bytesStream(bytes),
-    });
-    await settle(rec.id);
-
-    const store = createDiskStore(root);
-    expect(await store.stat(fsDisplayKey(CTX.userId, rec.id))).not.toBeNull();
-
-    const photo = await source().resolve(CTX, rec.id);
-    expect(photo?.thumbnailUrl).toBeDefined();
-    expect(photo?.displayUrl).toBe(`/_media/s/tok/photos/${rec.id}/display`);
-  });
-
-  test('JPEG → no display derivative, no displayUrl (raw is renderable)', async () => {
-    // A real JPEG sharp can resize.
-    const dir = await mkdtemp(path.join(tmpdir(), 'fc-jpg-'));
-    const jpgPath = path.join(dir, 'x.jpg');
-    const proc = Bun.spawn(
-      [
-        'ffmpeg',
-        '-hide_banner',
-        '-y',
-        '-f',
-        'lavfi',
-        '-i',
-        'testsrc=size=320x240:rate=1',
-        '-frames:v',
-        '1',
-        jpgPath,
-      ],
-      { stdout: 'ignore', stderr: 'ignore' },
-    );
-    await proc.exited;
-    const bytes = new Uint8Array(await Bun.file(jpgPath).arrayBuffer());
-    await rm(dir, { recursive: true, force: true });
-
-    const rec = await cat.ingest(CTX, {
-      name: 'photo.jpg',
-      mime: 'image/jpeg',
-      body: new Response(bytes).body as ReadableStream<Uint8Array>,
-    });
-    await settle(rec.id);
-
-    const store = createDiskStore(root);
-    expect(await store.stat(fsDisplayKey(CTX.userId, rec.id))).toBeNull();
-    const photo = await source().resolve(CTX, rec.id);
-    expect(photo?.displayUrl).toBeUndefined();
-  });
-});