feat(review): High quality playback switch and per-version ProRes download
Deploy / deploy (push) Successful in 3m23s

Worker 1.7.0 (preview.highQuality, default on) now, after the AE render:
- encodes a High quality MP4 from the delivery MOV (full-res H.264 High,
  CRF 14 capped at 100 Mbps) -> Version.hqFileUrl
- uploads the MOV itself -> Version.highResKey/Filename/Size
Both best-effort (the preview never fails over them), with a lease
keep-alive during the long encode/uploads; the export timeline records
what was attached.

Player: HQ switch when a High quality source exists; keeps frame, play
state, speed and zoom, remembered per browser, falls back to Standard if
the file won't load. ProRes itself stays download-only (browser support).

Downloads: the client portal's High Res button serves the version's
ProRes (client-code filename), falling back to the shot's manual file;
staff get a ProRes button on the review page.

Housekeeping (lib/render-pipeline/high-res.ts): HQ MP4 + ProRes are kept
while a version is latest, client-shared, approved or younger than
preview.highResRetentionDays (14); otherwise deleted from storage. Runs
per task after finalize and hourly from the reaper; deleting a version or
a reslate removes its files. The Standard MP4 is never touched.

Also: ProRes/Handles top-bar buttons go icon-only below lg so they don't
overlap the version selector.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
twotalesanimation
2026-09-22 16:32:18 +02:00
parent bae46c2968
commit 9660cdc21c
27 changed files with 793 additions and 18 deletions
@@ -0,0 +1,57 @@
import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db";
import { validateReviewToken } from "@/lib/review-auth";
import { generateHetznerDownloadUrl } from "@/lib/storage";
import { clientHighResFilename } from "@/lib/shot-code";
/**
* GET /api/client/[token]/versions/[versionId]/highres/download
* The version's ProRes, for a client reviewer: same visibility rule as the
* version itself (GET ../route.ts), and named with the client's shot code.
*/
export async function GET(
req: NextRequest,
{ params }: { params: Promise<{ token: string; versionId: string }> }
) {
const { token, versionId } = await params;
const result = await validateReviewToken(token, req);
if (result.type !== "ok") {
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}
const version = await db.version.findUnique({
where: { id: versionId },
select: {
highResKey: true,
highResFilename: true,
isClientVisible: true,
shot: { select: { projectId: true, shotCode: true, clientCode: true } },
task: {
select: {
projectId: true,
shot: { select: { shotCode: true, clientCode: true } },
},
},
},
});
const projectId = version?.shot?.projectId ?? version?.task?.projectId;
if (!version || projectId !== result.session.projectId) {
return NextResponse.json({ error: "Not found" }, { status: 404 });
}
// Task-only versions need explicit sharing, as in the version route
if (!version.shot && !version.isClientVisible) {
return NextResponse.json({ error: "Not found" }, { status: 404 });
}
if (!version.highResKey) {
return NextResponse.json({ error: "No high-res file available" }, { status: 404 });
}
const shot = version.shot ?? version.task?.shot ?? null;
const url = await generateHetznerDownloadUrl(
version.highResKey,
clientHighResFilename(version.highResFilename ?? "high-res.mov", shot)
);
return NextResponse.json({ url });
}
@@ -1,7 +1,7 @@
import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db";
import { validateReviewToken, findReviewUser, ownsComment } from "@/lib/review-auth";
import { clientShotCode, clientTaskTitle } from "@/lib/shot-code";
import { clientHighResFilename, clientShotCode, clientTaskTitle } from "@/lib/shot-code";
/** GET /api/client/[token]/versions/[versionId] — returns version + comments for client portal */
export async function GET(
@@ -95,13 +95,21 @@ export async function GET(
// The shot the title and breadcrumb are drawn from — either relation.
const namingShot = version.shot ?? ((version.task as any)?.shot ?? null);
// High Res: this version's own ProRes (uploaded by the render worker) wins;
// the shot's manually uploaded file is the fallback for older versions.
const versionHighRes = !!version.highResKey;
const serializedVersion = {
...version,
fileSize: version.fileSize?.toString() ?? null,
highResKey: undefined, // never expose a storage key
highResSize: version.highResSize?.toString() ?? null,
// Top-level high-res fields so the client works for both shot and task versions
hasHighRes: !!(highResShot?.highResKey),
highResShotId: highResShot?.highResKey ? (highResShot.id ?? null) : null,
highResFilename: highResShot?.highResFilename ?? null,
hasHighRes: versionHighRes || !!(highResShot?.highResKey),
highResSource: versionHighRes ? "version" : highResShot?.highResKey ? "shot" : null,
highResShotId: !versionHighRes && highResShot?.highResKey ? (highResShot.id ?? null) : null,
highResFilename: versionHighRes
? clientHighResFilename(version.highResFilename ?? "high-res.mov", namingShot)
: highResShot?.highResFilename ?? null,
// Expose only whether a high-res file exists on the shot relation, never the storage key
shot: version.shot
? {
@@ -9,13 +9,15 @@ import { generateHetznerPresignedUploadUrl, sanitizeFileName } from "@/lib/stora
//
// Presigned upload URL for worker artifacts. Kinds map to the existing object
// storage folder layout: preview → videos/, thumbnail → image/,
// metadata/log → renders/.
// metadata/log → renders/, highres (the delivery MOV) → highres/ beside the
// manually uploaded High Res files.
const KIND_FOLDERS: Record<string, string> = {
preview: "videos",
thumbnail: "image",
metadata: "renders",
log: "renders",
highres: "highres",
};
export async function POST(
+2
View File
@@ -51,6 +51,7 @@ export async function GET(req: NextRequest) {
posterUrl: true,
fps: true,
frameCount: true,
hqFileUrl: true,
handleHead: true,
handleTail: true,
pictureStartFrame: true,
@@ -90,6 +91,7 @@ export async function GET(req: NextRequest) {
posterUrl: latest.posterUrl,
fps: latest.fps,
frameCount: latest.frameCount,
hqFileUrl: latest.hqFileUrl,
handleHead: latest.handleHead,
handleTail: latest.handleTail,
pictureStartFrame: latest.pictureStartFrame,
@@ -0,0 +1,34 @@
import { NextRequest, NextResponse } from "next/server";
import { auth } from "@/auth";
import { db } from "@/lib/db";
import { generateHetznerDownloadUrl } from "@/lib/storage";
/**
* GET /api/versions/[versionId]/highres/download — short-lived presigned URL
* for this version's ProRes (the delivery MOV the render worker uploaded).
*/
export async function GET(
req: NextRequest,
{ params }: { params: Promise<{ versionId: string }> }
) {
const session = await auth();
if (!session?.user) {
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}
const { versionId } = await params;
const version = await db.version.findUnique({
where: { id: versionId },
select: { highResKey: true, highResFilename: true },
});
if (!version?.highResKey) {
return NextResponse.json({ error: "No high-res file available" }, { status: 404 });
}
const url = await generateHetznerDownloadUrl(
version.highResKey,
version.highResFilename ?? "high-res.mov"
);
return NextResponse.json({ url });
}