feat: dynamic timeouts — scale with image size, respect PROCESSING_TIMEOUT_S

Create timeout.ts utility for dynamic timeout computation.
Replace hardcoded timeouts across the stack:
- tool-factory worker: 30s → dynamic based on megapixels
- Python bridge default: 300s → 600s (or env override)
- background-removal: fixed → dynamic based on image size
- OCR: fixed 600s → dynamic based on image size
- seam-carving: 120s → dynamic based on image size
- ExifTool: 30s → 60s
- HEIC converter: 30s → 120s
- SQLite busy_timeout: 5s → 10s

apps/api/src/db/index.ts

@@ -13,7 +13,7 @@ const sqlite: DatabaseType = new Database(env.DB_PATH);
 // Critical SQLite pragmas for reliability.
 // busy_timeout must be set first so journal_mode = WAL can retry
 // if another connection holds the lock (e.g. parallel test files).
-sqlite.pragma("busy_timeout = 5000");
+sqlite.pragma("busy_timeout = 10000");
 sqlite.pragma("journal_mode = WAL");
 sqlite.pragma("synchronous = NORMAL");
 sqlite.pragma("foreign_keys = ON");

apps/api/src/lib/exiftool.ts

@@ -51,7 +51,7 @@ export async function inspectMetadata(buffer: Buffer, filename: string): Promise
   try {
     await writeFile(tempPath, buffer);
     const { stdout } = await execFileAsync(bin, ["-json", "-G", "-struct", "-n", tempPath], {
-      timeout: 30_000,
+      timeout: 60_000,
       maxBuffer: 10 * 1024 * 1024,
     });
 
@@ -126,7 +126,7 @@ export async function writeMetadata(
   try {
     await writeFile(tempPath, buffer);
     await execFileAsync(bin, ["-overwrite_original", ...tags, tempPath], {
-      timeout: 30_000,
+      timeout: 60_000,
       maxBuffer: 10 * 1024 * 1024,
     });
     return await readFile(tempPath);

apps/api/src/lib/heic-converter.ts

@@ -45,7 +45,7 @@ export async function decodeHeic(buffer: Buffer): Promise<Buffer> {
 
   try {
     await writeFile(inputPath, buffer);
-    await execFileAsync(cmd, [inputPath, outputPath], { timeout: 30_000 });
+    await execFileAsync(cmd, [inputPath, outputPath], { timeout: 120_000 });
 
     // Single-image HEIF: exact filename. Multi-image: -1 suffix on first image.
     try {
@@ -94,7 +94,7 @@ export async function encodeHeic(buffer: Buffer, quality = 80): Promise<Buffer>
   try {
     await writeFile(inputPath, buffer);
     await execFileAsync("heif-enc", ["-q", String(quality), "-o", outputPath, inputPath], {
-      timeout: 30_000,
+      timeout: 120_000,
     });
     return await readFile(outputPath);
   } finally {

apps/api/src/lib/timeout.ts

@@ -0,0 +1,26 @@
+import { env } from "../config.js";
+
+type ToolCategory = "sharp" | "ai_cpu" | "ai_gpu" | "external" | "python";
+
+const TIMEOUT_RATES: Record<ToolCategory, number> = {
+  sharp: 2,
+  ai_cpu: 30,
+  ai_gpu: 5,
+  external: 10,
+  python: 15,
+};
+
+export function computeTimeout(megapixels: number, category: ToolCategory, fileCount = 1): number {
+  if (env.PROCESSING_TIMEOUT_S > 0) {
+    return env.PROCESSING_TIMEOUT_S * 1000;
+  }
+  const perFile = Math.max(60_000, megapixels * TIMEOUT_RATES[category] * 1000);
+  return perFile * fileCount;
+}
+
+export function computeExternalToolTimeout(megapixels: number): number {
+  if (env.PROCESSING_TIMEOUT_S > 0) {
+    return env.PROCESSING_TIMEOUT_S * 1000;
+  }
+  return Math.max(60_000, megapixels * TIMEOUT_RATES.external * 1000);
+}

apps/api/src/routes/tool-factory.ts

@@ -15,6 +15,7 @@ import { sanitizeFilename } from "../lib/filename.js";
 import { decodeHeic } from "../lib/heic-converter.js";
 import type { WorkerInput, WorkerOutput } from "../lib/image-worker.js";
 import { sanitizeSvg } from "../lib/svg-sanitize.js";
+import { computeTimeout } from "../lib/timeout.js";
 import { getWorkerPool } from "../lib/worker-pool.js";
 import { createWorkspace } from "../lib/workspace.js";
 
@@ -227,8 +228,11 @@ export function createToolRoute<T>(app: FastifyInstance, config: ToolRouteConfig
               filename,
               inputFormat: validation.format,
             };
+            const meta = await sharp(fileBuffer).metadata();
+            const megapixels = ((meta.width ?? 0) * (meta.height ?? 0)) / 1_000_000;
+            const timeoutMs = computeTimeout(megapixels, "sharp");
             const workerResult: WorkerOutput = await pool.run(workerInput, {
-              signal: AbortSignal.timeout(30_000),
+              signal: AbortSignal.timeout(timeoutMs),
             });
             result = {
               buffer: Buffer.from(workerResult.buffer),